• Version 7.104.0
  • Published
  • 738 kB
  • 7 dependencies
  • MIT license


npm i @sentry/browser
yarn add @sentry/browser
pnpm add @sentry/browser


Official Sentry SDK for browsers



const Breadcrumbs: any;
  • Default Breadcrumbs instrumentations


    Use breadcrumbsIntegration() instead.

variable BrowserProfilingIntegration

const BrowserProfilingIntegration: IntegrationClass<any>;
  • Browser profiling integration. Stores any event that has contexts["profile"]["profile_id"] This exists because we do not want to await async profiler.stop calls as transaction.finish is called in a synchronous context. Instead, we handle sending the profile async from the promise callback and rely on being able to pull the event from the cache when we need to construct the envelope. This makes the integration less reliable as we might be dropping profiles when the cache is full.


    • @experimental


    Use browserProfilingIntegration() instead.

variable chromeStackLineParser

const chromeStackLineParser: StackLineParser;

    variable Dedupe

    const Dedupe: IntegrationClass<any>;
    • Deduplication filter.


      Use dedupeIntegration() instead.

    variable defaultIntegrations

    const defaultIntegrations: any[];
    • Deprecated

      Use getDefaultIntegrations(options) instead.

    variable defaultStackLineParsers

    const defaultStackLineParsers: StackLineParser[];

      variable defaultStackParser

      const defaultStackParser: any;

        variable geckoStackLineParser

        const geckoStackLineParser: StackLineParser;

          variable GlobalHandlers

          const GlobalHandlers: any;
          • Global handlers.


            Use globalHandlersIntegration() instead.

          variable HttpContext

          const HttpContext: IntegrationClass<any>;
          • HttpContext integration collects information about HTTP request headers.


            Use httpContextIntegration() instead.

          variable Integrations

          const Integrations: {
          GlobalHandlers: any;
          TryCatch: any;
          Breadcrumbs: any;
          LinkedErrors: any;
          HttpContext: any;
          Dedupe: any;
          FunctionToString: any;
          InboundFilters: any;
          • Deprecated

            Import the integration function directly, e.g. inboundFiltersIntegration() instead of `new Integrations.InboundFilter().

          variable LinkedErrors

          const LinkedErrors: any;
          • Aggregrate linked errors in an event.


            Use linkedErrorsIntegration() instead.

          variable opera10StackLineParser

          const opera10StackLineParser: StackLineParser;

            variable opera11StackLineParser

            const opera11StackLineParser: StackLineParser;

              variable showReportDialog

              const showReportDialog: ShowReportDialogFunction;

                variable TryCatch

                const TryCatch: any;
                • Wrap timer functions and event targets to catch errors and provide better meta data.


                  Use browserApiErrorsIntegration() instead.

                variable WINDOW

                const WINDOW: any;

                  variable winjsStackLineParser

                  const winjsStackLineParser: StackLineParser;


                    breadcrumbsIntegration: (
                    options?: Partial<BreadcrumbsOptions> | undefined
                    ) => any;

                      function browserApiErrorsIntegration

                      browserApiErrorsIntegration: (
                      options?: Partial<TryCatchOptions> | undefined
                      ) => any;

                        function browserProfilingIntegration

                        browserProfilingIntegration: () => any;

                          function captureUserFeedback

                          captureUserFeedback: (feedback: UserFeedback) => void;
                          • Captures user feedback and sends it to Sentry.

                          function createUserFeedbackEnvelope

                          createUserFeedbackEnvelope: (
                          feedback: UserFeedback,
                          }: {
                          metadata: SdkMetadata | undefined;
                          tunnel: string | undefined;
                          dsn: DsnComponents | undefined;
                          ) => EventEnvelope;
                          • Creates an envelope from a user feedback.

                          function dedupeIntegration

                          dedupeIntegration: () => any;

                            function eventFromException

                            eventFromException: (
                            stackParser: StackParser,
                            exception: unknown,
                            hint?: EventHint,
                            attachStacktrace?: boolean
                            ) => PromiseLike<Event>;
                            • Creates an Event from all inputs to captureException and non-primitive inputs to captureMessage.

                            function eventFromMessage

                            eventFromMessage: (
                            stackParser: StackParser,
                            message: ParameterizedString,
                            level?: Severity | SeverityLevel,
                            hint?: EventHint,
                            attachStacktrace?: boolean
                            ) => PromiseLike<Event>;
                            • Builds and Event from a Message

                            function exceptionFromError

                            exceptionFromError: (stackParser: StackParser, ex: Error) => Exception;
                            • This function creates an exception from a JavaScript Error

                            function forceLoad

                            forceLoad: () => void;
                            • This function is here to be API compatible with the loader.

                            function getDefaultIntegrations

                            getDefaultIntegrations: (_options: Options) => Integration[];
                            • Get the default integrations for the browser SDK.

                            function globalHandlersIntegration

                            globalHandlersIntegration: (
                            options?: Partial<GlobalHandlersIntegrations> | undefined
                            ) => any;

                              function httpContextIntegration

                              httpContextIntegration: () => any;

                                function init

                                init: (options?: BrowserOptions) => void;
                                • The Sentry Browser SDK Client.

                                  To use this SDK, call the init function as early as possible when loading the web page. To set context information or send manual events, use the provided methods.

                                  Example 1

                                  import { init } from '@sentry/browser';
                                  dsn: '__DSN__',
                                  // ...

                                  Example 2

                                  import { configureScope } from '@sentry/browser';
                                  configureScope((scope: Scope) => {
                                  scope.setExtra({ battery: 0.7 });
                                  scope.setTag({ user_mode: 'admin' });
                                  scope.setUser({ id: '4711' });

                                  Example 3

                                  import { addBreadcrumb } from '@sentry/browser';
                                  message: 'My Breadcrumb',
                                  // ...

                                  Example 4

                                  import * as Sentry from '@sentry/browser';
                                  Sentry.captureMessage('Hello, world!');
                                  Sentry.captureException(new Error('Good bye'));
                                  message: 'Manual',
                                  stacktrace: [
                                  // ...

                                  See Also

                                function linkedErrorsIntegration

                                linkedErrorsIntegration: (options?: LinkedErrorsOptions | undefined) => any;

                                  function makeBrowserOfflineTransport

                                  makeBrowserOfflineTransport: <T extends InternalBaseTransportOptions>(
                                  createTransport: (options: T) => Transport
                                  ) => (options: T & BrowserOfflineTransportOptions) => Transport;
                                  • Creates a transport that uses IndexedDb to store events when offline.

                                  function makeFetchTransport

                                  makeFetchTransport: (
                                  options: BrowserTransportOptions,
                                  nativeFetch?: FetchImpl
                                  ) => Transport;
                                  • Creates a Transport that uses the Fetch API to send events to Sentry.

                                  function makeXHRTransport

                                  makeXHRTransport: (options: BrowserTransportOptions) => Transport;
                                  • Creates a Transport that uses the XMLHttpRequest API to send events to Sentry.

                                  function onLoad

                                  onLoad: (callback: () => void) => void;
                                  • This function is here to be API compatible with the loader.

                                  function onProfilingStartRouteTransaction

                                  onProfilingStartRouteTransaction: (
                                  transaction: Transaction | undefined
                                  ) => Transaction | undefined;
                                  • Safety wrapper for startTransaction for the unlikely case that transaction starts before tracing is imported - if that happens we want to avoid throwing an error from profiling code. see https://github.com/getsentry/sentry-javascript/issues/4731.


                                    • @experimental

                                  function wrap

                                  wrap: (fn: (...args: any) => any) => any;
                                  • Wrap code within a try/catch block so the SDK is able to capture errors.

                                    Parameter fn

                                    A function to wrap.


                                    The result of wrapped function call.


                                    This function will be removed in v8. It is not part of Sentry's official API and it's easily replaceable by using a try/catch block and calling Sentry.captureException.


                                  class BrowserClient

                                  class BrowserClient extends BaseClient<BrowserClientOptions> {}
                                  • The Sentry Browser SDK Client.

                                    See Also

                                    • BrowserOptions for documentation on configuration options.

                                    • SentryClient for usage documentation.


                                  constructor(options: any);
                                  • Creates a new Browser SDK instance.

                                    Parameter options

                                    Configuration options for this SDK.

                                  method captureUserFeedback

                                  captureUserFeedback: (feedback: UserFeedback) => void;
                                  • Sends user feedback to Sentry.

                                  method eventFromException

                                  eventFromException: (exception: unknown, hint?: EventHint) => PromiseLike<Event>;

                                  method eventFromMessage

                                  eventFromMessage: (
                                  message: ParameterizedString,
                                  level?: Severity | SeverityLevel,
                                  hint?: EventHint
                                  ) => PromiseLike<Event>;


                                  interface ReportDialogOptions

                                  interface ReportDialogOptions {}
                                  • All properties the report dialog supports


                                    This type will be removed in the next major version of the Sentry SDK. showReportDialog will still be around, however the eventId option will now be required.

                                  property dsn

                                  dsn?: DsnLike;

                                    property errorFormEntry

                                    errorFormEntry?: string;

                                      property errorGeneric

                                      errorGeneric?: string;

                                        property eventId

                                        eventId?: string;

                                          property labelClose

                                          labelClose?: string;

                                            property labelComments

                                            labelComments?: string;

                                              property labelEmail

                                              labelEmail?: string;

                                                property labelName

                                                labelName?: string;

                                                  property labelSubmit

                                                  labelSubmit?: string;

                                                    property lang

                                                    lang?: string;

                                                      property subtitle

                                                      subtitle?: string;

                                                        property subtitle2

                                                        subtitle2?: string;

                                                          property successMessage

                                                          successMessage?: string;

                                                            property title

                                                            title?: string;

                                                              property user

                                                              user?: {
                                                              email?: string;
                                                              name?: string;

                                                                method onClose

                                                                onClose: (this: void) => void;
                                                                • Callback after reportDialog closed

                                                                method onLoad

                                                                onLoad: (this: void) => void;
                                                                • Callback after reportDialog showed up

                                                                index signature

                                                                [key: string]: any;

                                                                  Type Aliases

                                                                  type BrowserOptions

                                                                  type BrowserOptions = Options<BrowserTransportOptions> &
                                                                  BrowserClientReplayOptions &
                                                                  • Configuration options for the Sentry Browser SDK.

                                                                    See Also

                                                                    • @sentry/types Options for more information.

                                                                  type BrowserProfilingIntegration

                                                                  type BrowserProfilingIntegration = typeof BrowserProfilingIntegration;

                                                                    Package Files (18)

                                                                    Dependencies (7)

                                                                    Dev Dependencies (22)

                                                                    Peer Dependencies (0)

                                                                    No peer dependencies.


                                                                    To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                    You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@sentry/browser.

                                                                    • Markdown
                                                                    • HTML
                                                                      <a href="https://www.jsdocs.io/package/@sentry/browser"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>