@sentry/types

  • Version 6.5.1
  • Published
  • 292 kB
  • No dependencies
  • BSD-3-Clause license

Install

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

Overview

Types for all Sentry JavaScript SDKs

Index

Interfaces

Enums

Type Aliases

Namespaces

Interfaces

interface AggregationCounts

interface AggregationCounts {}

    property crashed

    crashed?: number;

      property errored

      errored?: number;

        property exited

        exited?: number;

          property started

          started: string;
            interface Breadcrumb {}
            • JSDoc

            category?: string;
              data?: {
              [key: string]: any;
              };
                event_id?: string;
                  level?: Severity;
                    message?: string;
                      timestamp?: number;
                        type?: string;
                          interface BreadcrumbHint {}
                          • JSDoc

                          [key: string]: any;

                            interface Client

                            interface Client<O extends Options = Options> {}
                            • User-Facing Sentry SDK Client.

                              This interface contains all methods to interface with the SDK once it has been installed. It allows to send events to Sentry, record breadcrumbs and set a context included in every event. Since the SDK mutates its environment, there will only be one instance during runtime.

                            method captureEvent

                            captureEvent: (
                            event: Event,
                            hint?: EventHint,
                            scope?: Scope
                            ) => string | undefined;
                            • Captures a manually created event and sends it to Sentry.

                              Parameter event

                              The event to send to Sentry.

                              Parameter hint

                              May contain additional information about the original exception.

                              Parameter scope

                              An optional scope containing event metadata.

                              Returns

                              The event id

                            method captureException

                            captureException: (
                            exception: any,
                            hint?: EventHint,
                            scope?: Scope
                            ) => string | undefined;
                            • Captures an exception event and sends it to Sentry.

                              Parameter exception

                              An exception-like object.

                              Parameter hint

                              May contain additional information about the original exception.

                              Parameter scope

                              An optional scope containing event metadata.

                              Returns

                              The event id

                            method captureMessage

                            captureMessage: (
                            message: string,
                            level?: Severity,
                            hint?: EventHint,
                            scope?: Scope
                            ) => string | undefined;
                            • Captures a message event and sends it to Sentry.

                              Parameter message

                              The message to send to Sentry.

                              Parameter level

                              Define the level of the message.

                              Parameter hint

                              May contain additional information about the original exception.

                              Parameter scope

                              An optional scope containing event metadata.

                              Returns

                              The event id

                            method captureSession

                            captureSession: (session: Session) => void;
                            • Captures a session

                              Parameter session

                              Session to be delivered

                            method close

                            close: (timeout?: number) => PromiseLike<boolean>;
                            • A promise that resolves when all current events have been sent. If you provide a timeout and the queue takes longer to drain the promise returns false.

                              Parameter timeout

                              Maximum time in ms the client should wait.

                            method flush

                            flush: (timeout?: number) => PromiseLike<boolean>;
                            • A promise that resolves when all current events have been sent. If you provide a timeout and the queue takes longer to drain the promise returns false.

                              Parameter timeout

                              Maximum time in ms the client should wait.

                            method getDsn

                            getDsn: () => Dsn | undefined;
                            • Returns the current Dsn.

                            method getIntegration

                            getIntegration: <T extends Integration>(
                            integration: IntegrationClass<T>
                            ) => T | null;
                            • Returns an array of installed integrations on the client.

                            method getOptions

                            getOptions: () => O;
                            • Returns the current options.

                            method setupIntegrations

                            setupIntegrations: () => void;
                            • This is an internal function to setup all integrations that should run on the client

                            interface CustomSamplingContext

                            interface CustomSamplingContext {}
                            • Context data passed by the user when starting a transaction, to be used by the tracesSampler method.

                            index signature

                            [key: string]: any;

                              interface DebugImage

                              interface DebugImage {}
                              • References to debug images.

                              property code_file

                              code_file: string;

                                property code_id

                                code_id?: string | null;

                                  property debug_file

                                  debug_file?: string | null;

                                    property debug_id

                                    debug_id: string;

                                      property type

                                      type: DebugImageType;

                                        interface DebugMeta

                                        interface DebugMeta {}
                                        • Holds meta information to customize the behavior of sentry's event processing.

                                        property images

                                        images?: Array<DebugImage>;

                                          property transactionSampling

                                          transactionSampling?: {
                                          rate?: number;
                                          method?: string;
                                          };

                                            interface Dsn

                                            interface Dsn extends DsnComponents {}
                                            • The Sentry Dsn, identifying a Sentry instance and project.

                                            method toString

                                            toString: (withPassword: boolean) => string;
                                            • Renders the string representation of this Dsn.

                                              By default, this will render the public representation without the password component. To get the deprecated private representation, set withPassword to true.

                                              Parameter withPassword

                                              When set to true, the password will be included.

                                            interface DsnComponents

                                            interface DsnComponents {}
                                            • Primitive components of a Dsn.

                                            property host

                                            host: string;
                                            • Hostname of the Sentry instance.

                                            property pass

                                            pass?: string;
                                            • Private authorization key (deprecated, optional).

                                            property path

                                            path?: string;
                                            • Sub path/

                                            property port

                                            port?: string;
                                            • Port of the Sentry instance.

                                            property projectId

                                            projectId: string;
                                            • Project ID

                                            property protocol

                                            protocol: DsnProtocol;
                                            • Protocol used to connect to Sentry.

                                            property publicKey

                                            publicKey?: string;
                                            • Public authorization key.

                                            property user

                                            user?: string;
                                            • Public authorization key (deprecated, renamed to publicKey).

                                            interface Event

                                            interface Event {}
                                            • JSDoc

                                            property breadcrumbs

                                            breadcrumbs?: Breadcrumb[];

                                              property contexts

                                              contexts?: Contexts;

                                                property debug_meta

                                                debug_meta?: DebugMeta;

                                                  property dist

                                                  dist?: string;

                                                    property environment

                                                    environment?: string;

                                                      property event_id

                                                      event_id?: string;

                                                        property exception

                                                        exception?: {
                                                        values?: Exception[];
                                                        };

                                                          property extra

                                                          extra?: Extras;

                                                            property fingerprint

                                                            fingerprint?: string[];

                                                              property level

                                                              level?: Severity;

                                                                property logger

                                                                logger?: string;

                                                                  property measurements

                                                                  measurements?: Measurements;

                                                                    property message

                                                                    message?: string;

                                                                      property modules

                                                                      modules?: {
                                                                      [key: string]: string;
                                                                      };

                                                                        property platform

                                                                        platform?: string;

                                                                          property release

                                                                          release?: string;

                                                                            property request

                                                                            request?: Request;

                                                                              property sdk

                                                                              sdk?: SdkInfo;

                                                                                property server_name

                                                                                server_name?: string;

                                                                                  property spans

                                                                                  spans?: Span[];

                                                                                    property stacktrace

                                                                                    stacktrace?: Stacktrace;

                                                                                      property start_timestamp

                                                                                      start_timestamp?: number;

                                                                                        property tags

                                                                                        tags?: {
                                                                                        [key: string]: Primitive;
                                                                                        };

                                                                                          property timestamp

                                                                                          timestamp?: number;

                                                                                            property transaction

                                                                                            transaction?: string;

                                                                                              property type

                                                                                              type?: EventType;

                                                                                                property user

                                                                                                user?: User;

                                                                                                  interface EventHint

                                                                                                  interface EventHint {}
                                                                                                  • JSDoc

                                                                                                  property captureContext

                                                                                                  captureContext?: CaptureContext;

                                                                                                    property data

                                                                                                    data?: any;

                                                                                                      property event_id

                                                                                                      event_id?: string;

                                                                                                        property originalException

                                                                                                        originalException?: Error | string | null;

                                                                                                          property syntheticException

                                                                                                          syntheticException?: Error | null;

                                                                                                            interface Exception

                                                                                                            interface Exception {}
                                                                                                            • JSDoc

                                                                                                            property mechanism

                                                                                                            mechanism?: Mechanism;

                                                                                                              property module

                                                                                                              module?: string;

                                                                                                                property stacktrace

                                                                                                                stacktrace?: Stacktrace;

                                                                                                                  property thread_id

                                                                                                                  thread_id?: number;

                                                                                                                    property type

                                                                                                                    type?: string;

                                                                                                                      property value

                                                                                                                      value?: string;

                                                                                                                        interface ExtendedError

                                                                                                                        interface ExtendedError extends Error {}
                                                                                                                        • Just an Error object with arbitrary attributes attached to it.

                                                                                                                        index signature

                                                                                                                        [key: string]: any;

                                                                                                                          interface ExtractedNodeRequestData

                                                                                                                          interface ExtractedNodeRequestData {}
                                                                                                                          • Data extracted from an incoming request to a node server

                                                                                                                          property cookies

                                                                                                                          cookies?: {
                                                                                                                          [key: string]: string;
                                                                                                                          };
                                                                                                                          • String representing the cookies sent along with the request

                                                                                                                          property data

                                                                                                                          data?: string;
                                                                                                                          • Any data sent in the request's body, as a JSON string

                                                                                                                          property headers

                                                                                                                          headers?: {
                                                                                                                          [key: string]: string;
                                                                                                                          };
                                                                                                                          • Specific headers from the request

                                                                                                                          property method

                                                                                                                          method?: string;
                                                                                                                          • The request's method

                                                                                                                          property query_string

                                                                                                                          query_string?: string;
                                                                                                                          • The request's query string, without the leading '?'

                                                                                                                          property url

                                                                                                                          url?: string;
                                                                                                                          • The request's URL, including query string

                                                                                                                          index signature

                                                                                                                          [key: string]: any;

                                                                                                                            interface Hub

                                                                                                                            interface Hub {}
                                                                                                                            • Internal class used to make sure we always have the latest internal functions working in case we have a version conflict.

                                                                                                                            method addBreadcrumb

                                                                                                                            addBreadcrumb: (breadcrumb: Breadcrumb, hint?: BreadcrumbHint) => void;
                                                                                                                            • Records a new breadcrumb which will be attached to future events.

                                                                                                                              Breadcrumbs will be added to subsequent events to provide more context on user's actions prior to an error or crash.

                                                                                                                              Parameter breadcrumb

                                                                                                                              The breadcrumb to record.

                                                                                                                              Parameter hint

                                                                                                                              May contain additional information about the original breadcrumb.

                                                                                                                            method bindClient

                                                                                                                            bindClient: (client?: Client) => void;
                                                                                                                            • This binds the given client to the current scope.

                                                                                                                              Parameter client

                                                                                                                              An SDK client (client) instance.

                                                                                                                            method captureEvent

                                                                                                                            captureEvent: (event: Event, hint?: EventHint) => string;
                                                                                                                            • Captures a manually created event and sends it to Sentry.

                                                                                                                              Parameter event

                                                                                                                              The event to send to Sentry.

                                                                                                                              Parameter hint

                                                                                                                              May contain additional information about the original exception.

                                                                                                                            method captureException

                                                                                                                            captureException: (exception: any, hint?: EventHint) => string;
                                                                                                                            • Captures an exception event and sends it to Sentry.

                                                                                                                              Parameter exception

                                                                                                                              An exception-like object.

                                                                                                                              Parameter hint

                                                                                                                              May contain additional information about the original exception.

                                                                                                                              Returns

                                                                                                                              The generated eventId.

                                                                                                                            method captureMessage

                                                                                                                            captureMessage: (message: string, level?: Severity, hint?: EventHint) => string;
                                                                                                                            • Captures a message event and sends it to Sentry.

                                                                                                                              Parameter message

                                                                                                                              The message to send to Sentry.

                                                                                                                              Parameter level

                                                                                                                              Define the level of the message.

                                                                                                                              Parameter hint

                                                                                                                              May contain additional information about the original exception.

                                                                                                                              Returns

                                                                                                                              The generated eventId.

                                                                                                                            method captureSession

                                                                                                                            captureSession: (endSession: boolean) => void;
                                                                                                                            • Sends the current session on the scope to Sentry

                                                                                                                              Parameter endSession

                                                                                                                              If set the session will be marked as exited and removed from the scope

                                                                                                                            method configureScope

                                                                                                                            configureScope: (callback: (scope: Scope) => void) => void;
                                                                                                                            • Callback to set context information onto the scope.

                                                                                                                              Parameter callback

                                                                                                                              Callback function that receives Scope.

                                                                                                                            method endSession

                                                                                                                            endSession: () => void;
                                                                                                                            • Ends the session that lives on the current scope and sends it to Sentry

                                                                                                                            method getClient

                                                                                                                            getClient: () => Client | undefined;
                                                                                                                            • Returns the client of the top stack.

                                                                                                                            method getIntegration

                                                                                                                            getIntegration: <T extends Integration>(
                                                                                                                            integration: IntegrationClass<T>
                                                                                                                            ) => T | null;
                                                                                                                            • Returns the integration if installed on the current client.

                                                                                                                            method isOlderThan

                                                                                                                            isOlderThan: (version: number) => boolean;
                                                                                                                            • Checks if this hub's version is older than the given version.

                                                                                                                              Parameter version

                                                                                                                              A version number to compare to. True if the given version is newer; otherwise false.

                                                                                                                            method lastEventId

                                                                                                                            lastEventId: () => string | undefined;
                                                                                                                            • This is the getter for lastEventId.

                                                                                                                              Returns

                                                                                                                              The last event id of a captured event.

                                                                                                                            method popScope

                                                                                                                            popScope: () => boolean;
                                                                                                                            • Removes a previously pushed scope from the stack.

                                                                                                                              This restores the state before the scope was pushed. All breadcrumbs and context information added since the last call to this.pushScope are discarded.

                                                                                                                            method pushScope

                                                                                                                            pushScope: () => Scope;
                                                                                                                            • Create a new scope to store context information.

                                                                                                                              The scope will be layered on top of the current one. It is isolated, i.e. all breadcrumbs and context information added to this scope will be removed once the scope ends. Be sure to always remove this scope with this.popScope when the operation finishes or throws.

                                                                                                                              Returns

                                                                                                                              Scope, the new cloned scope

                                                                                                                            method run

                                                                                                                            run: (callback: (hub: Hub) => void) => void;
                                                                                                                            • For the duraction of the callback, this hub will be set as the global current Hub. This function is useful if you want to run your own client and hook into an already initialized one e.g.: Reporting issues to your own sentry when running in your component while still using the users configuration.

                                                                                                                            method setContext

                                                                                                                            setContext: (name: string, context: { [key: string]: any }) => void;
                                                                                                                            • Sets context data with the given name.

                                                                                                                              Parameter name

                                                                                                                              of the context

                                                                                                                              Parameter context

                                                                                                                              Any kind of data. This data will be normalized.

                                                                                                                            method setExtra

                                                                                                                            setExtra: (key: string, extra: Extra) => void;
                                                                                                                            • Set key:value that will be sent as extra data with the event.

                                                                                                                              Parameter key

                                                                                                                              String of extra

                                                                                                                              Parameter extra

                                                                                                                              Any kind of data. This data will be normalized.

                                                                                                                            method setExtras

                                                                                                                            setExtras: (extras: Extras) => void;
                                                                                                                            • Set an object that will be merged sent as extra data with the event.

                                                                                                                              Parameter extras

                                                                                                                              Extras object to merge into current context.

                                                                                                                            method setTag

                                                                                                                            setTag: (key: string, value: Primitive) => void;
                                                                                                                            • Set key:value that will be sent as tags data with the event.

                                                                                                                              Can also be used to unset a tag, by passing undefined.

                                                                                                                              Parameter key

                                                                                                                              String key of tag

                                                                                                                              Parameter value

                                                                                                                              Value of tag

                                                                                                                            method setTags

                                                                                                                            setTags: (tags: { [key: string]: Primitive }) => void;
                                                                                                                            • Set an object that will be merged sent as tags data with the event.

                                                                                                                              Parameter tags

                                                                                                                              Tags context object to merge into current context.

                                                                                                                            method setUser

                                                                                                                            setUser: (user: User | null) => void;
                                                                                                                            • Updates user context information for future events.

                                                                                                                              Parameter user

                                                                                                                              User context object to be set in the current context. Pass null to unset the user.

                                                                                                                            method startSession

                                                                                                                            startSession: (context?: SessionContext) => Session;
                                                                                                                            • Starts a new Session, sets on the current scope and returns it.

                                                                                                                              To finish a session, it has to be passed directly to client.captureSession, which is done automatically when using hub.endSession() for the session currently stored on the scope.

                                                                                                                              When there's already an existing session on the scope, it'll be automatically ended.

                                                                                                                              Parameter context

                                                                                                                              Optional properties of the new Session.

                                                                                                                              Returns

                                                                                                                              The session which was just started

                                                                                                                            method startSpan

                                                                                                                            startSpan: (context: SpanContext) => Span;

                                                                                                                            method startTransaction

                                                                                                                            startTransaction: (
                                                                                                                            context: TransactionContext,
                                                                                                                            customSamplingContext?: CustomSamplingContext
                                                                                                                            ) => Transaction;
                                                                                                                            • Starts a new Transaction and returns it. This is the entry point to manual tracing instrumentation.

                                                                                                                              A tree structure can be built by adding child spans to the transaction, and child spans to other spans. To start a new child span within the transaction or any span, call the respective .startChild() method.

                                                                                                                              Every child span must be finished before the transaction is finished, otherwise the unfinished spans are discarded.

                                                                                                                              The transaction must be finished with a call to its .finish() method, at which point the transaction with all its finished child spans will be sent to Sentry.

                                                                                                                              Parameter context

                                                                                                                              Properties of the new Transaction.

                                                                                                                              Parameter customSamplingContext

                                                                                                                              Information given to the transaction sampling function (along with context-dependent default values). See Options.tracesSampler.

                                                                                                                              Returns

                                                                                                                              The transaction which was just started

                                                                                                                            method traceHeaders

                                                                                                                            traceHeaders: () => { [key: string]: string };
                                                                                                                            • Returns all trace headers that are currently on the top scope.

                                                                                                                            method withScope

                                                                                                                            withScope: (callback: (scope: Scope) => void) => void;
                                                                                                                            • Creates a new scope with and executes the given operation within. The scope is automatically removed once the operation finishes or throws.

                                                                                                                              This is essentially a convenience function for:

                                                                                                                              pushScope(); callback(); popScope();

                                                                                                                              Parameter callback

                                                                                                                              that will be enclosed into push/popScope.

                                                                                                                            interface Integration

                                                                                                                            interface Integration {}
                                                                                                                            • Integration interface

                                                                                                                            property name

                                                                                                                            name: string;

                                                                                                                            method setupOnce

                                                                                                                            setupOnce: (
                                                                                                                            addGlobalEventProcessor: (callback: EventProcessor) => void,
                                                                                                                            getCurrentHub: () => Hub
                                                                                                                            ) => void;
                                                                                                                            • Sets the integration up only once. This takes no options on purpose, options should be passed in the constructor

                                                                                                                            interface IntegrationClass

                                                                                                                            interface IntegrationClass<T> {}
                                                                                                                            • Integration Class Interface

                                                                                                                            property id

                                                                                                                            id: string;
                                                                                                                            • Property that holds the integration name

                                                                                                                            construct signature

                                                                                                                            new (...args: any[]): T;

                                                                                                                              interface Mechanism

                                                                                                                              interface Mechanism {}
                                                                                                                              • JSDoc

                                                                                                                              property data

                                                                                                                              data?: {
                                                                                                                              [key: string]: string | boolean;
                                                                                                                              };

                                                                                                                                property handled

                                                                                                                                handled: boolean;

                                                                                                                                  property synthetic

                                                                                                                                  synthetic?: boolean;

                                                                                                                                    property type

                                                                                                                                    type: string;

                                                                                                                                      interface Options

                                                                                                                                      interface Options {}
                                                                                                                                      • Base configuration options for every SDK.

                                                                                                                                      property attachStacktrace

                                                                                                                                      attachStacktrace?: boolean;
                                                                                                                                      • Attaches stacktraces to pure capture message / log integrations

                                                                                                                                      property autoSessionTracking

                                                                                                                                      autoSessionTracking?: boolean;
                                                                                                                                      • A flag enabling Sessions Tracking feature. By default, Sessions Tracking is enabled.

                                                                                                                                      property debug

                                                                                                                                      debug?: boolean;
                                                                                                                                      • Enable debug functionality in the SDK itself

                                                                                                                                      property defaultIntegrations

                                                                                                                                      defaultIntegrations?: false | Integration[];
                                                                                                                                      • If this is set to false, default integrations will not be added, otherwise this will internally be set to the recommended default integrations. TODO: We should consider changing this to boolean | Integration[]

                                                                                                                                      property dist

                                                                                                                                      dist?: string;
                                                                                                                                      • Sets the distribution for all events

                                                                                                                                      property dsn

                                                                                                                                      dsn?: string;
                                                                                                                                      • The Dsn used to connect to Sentry and identify the project. If omitted, the SDK will not send any data to Sentry.

                                                                                                                                      property enabled

                                                                                                                                      enabled?: boolean;
                                                                                                                                      • Specifies whether this SDK should activate and send events to Sentry. Disabling the SDK reduces all overhead from instrumentation, collecting breadcrumbs and capturing events. Defaults to true.

                                                                                                                                      property environment

                                                                                                                                      environment?: string;
                                                                                                                                      • The current environment of your application (e.g. "production").

                                                                                                                                      property ignoreErrors

                                                                                                                                      ignoreErrors?: Array<string | RegExp>;
                                                                                                                                      • A pattern for error messages which should not be sent to Sentry. By default, all errors will be sent.

                                                                                                                                      property initialScope

                                                                                                                                      initialScope?: CaptureContext;
                                                                                                                                      • Set data to the inital scope

                                                                                                                                      property integrations

                                                                                                                                      integrations?: Integration[] | ((integrations: Integration[]) => Integration[]);
                                                                                                                                      • List of integrations that should be installed after SDK was initialized. Accepts either a list of integrations or a function that receives default integrations and returns a new, updated list.

                                                                                                                                      property logLevel

                                                                                                                                      logLevel?: LogLevel;
                                                                                                                                      • Console logging verbosity for the SDK Client.

                                                                                                                                      property maxBreadcrumbs

                                                                                                                                      maxBreadcrumbs?: number;
                                                                                                                                      • The maximum number of breadcrumbs sent with events. Defaults to 100. Values over 100 will be ignored and 100 used instead.

                                                                                                                                      property maxValueLength

                                                                                                                                      maxValueLength?: number;
                                                                                                                                      • Maxium number of chars a single value can have before it will be truncated.

                                                                                                                                      property normalizeDepth

                                                                                                                                      normalizeDepth?: number;
                                                                                                                                      • Maximum number of levels that normalization algorithm will traverse in objects and arrays. Used when normalizing an event before sending, on all of the listed attributes: - breadcrumbs.data - user - contexts - extra Defaults to 3. Set to 0 to disable.

                                                                                                                                      property release

                                                                                                                                      release?: string;
                                                                                                                                      • The release identifier used when uploading respective source maps. Specify this value to allow Sentry to resolve the correct source maps when processing events.

                                                                                                                                      property sampleRate

                                                                                                                                      sampleRate?: number;
                                                                                                                                      • A global sample rate to apply to all events (0 - 1).

                                                                                                                                      property shutdownTimeout

                                                                                                                                      shutdownTimeout?: number;
                                                                                                                                      • Controls how many milliseconds to wait before shutting down. The default is SDK-specific but typically around 2 seconds. Setting this too low can cause problems for sending events from command line applications. Setting it too high can cause the application to block for users with network connectivity problems.

                                                                                                                                      property tracesSampleRate

                                                                                                                                      tracesSampleRate?: number;
                                                                                                                                      • Sample rate to determine trace sampling.

                                                                                                                                        0.0 = 0% chance of a given trace being sent (send no traces) 1.0 = 100% chance of a given trace being sent (send all traces)

                                                                                                                                        Tracing is enabled if either this or tracesSampler is defined. If both are defined, tracesSampleRate is ignored.

                                                                                                                                      property transport

                                                                                                                                      transport?: TransportClass<Transport>;
                                                                                                                                      • Transport object that should be used to send events to Sentry

                                                                                                                                      property transportOptions

                                                                                                                                      transportOptions?: TransportOptions;
                                                                                                                                      • Options for the default transport that the SDK uses.

                                                                                                                                      method beforeBreadcrumb

                                                                                                                                      beforeBreadcrumb: (
                                                                                                                                      breadcrumb: Breadcrumb,
                                                                                                                                      hint?: BreadcrumbHint
                                                                                                                                      ) => Breadcrumb | null;
                                                                                                                                      • A callback invoked when adding a breadcrumb, allowing to optionally modify it before adding it to future events.

                                                                                                                                        Note that you must return a valid breadcrumb from this callback. If you do not wish to modify the breadcrumb, simply return it at the end. Returning null will cause the breadcrumb to be dropped.

                                                                                                                                        Parameter breadcrumb

                                                                                                                                        The breadcrumb as created by the SDK.

                                                                                                                                        Returns

                                                                                                                                        The breadcrumb that will be added | null.

                                                                                                                                      method beforeSend

                                                                                                                                      beforeSend: (
                                                                                                                                      event: Event,
                                                                                                                                      hint?: EventHint
                                                                                                                                      ) => PromiseLike<Event | null> | Event | null;
                                                                                                                                      • A callback invoked during event submission, allowing to optionally modify the event before it is sent to Sentry.

                                                                                                                                        Note that you must return a valid event from this callback. If you do not wish to modify the event, simply return it at the end. Returning null will cause the event to be dropped.

                                                                                                                                        Parameter event

                                                                                                                                        The error or message event generated by the SDK.

                                                                                                                                        Parameter hint

                                                                                                                                        May contain additional information about the original exception.

                                                                                                                                        Returns

                                                                                                                                        A new event that will be sent | null.

                                                                                                                                      method tracesSampler

                                                                                                                                      tracesSampler: (samplingContext: SamplingContext) => number | boolean;
                                                                                                                                      • Function to compute tracing sample rate dynamically and filter unwanted traces.

                                                                                                                                        Tracing is enabled if either this or tracesSampleRate is defined. If both are defined, tracesSampleRate is ignored.

                                                                                                                                        Will automatically be passed a context object of default and optional custom data. See Transaction.samplingContext and Hub.startTransaction.

                                                                                                                                        Returns

                                                                                                                                        A sample rate between 0 and 1 (0 drops the trace, 1 guarantees it will be sent). Returning true is equivalent to returning 1 and returning false is equivalent to returning 0.

                                                                                                                                      interface Package

                                                                                                                                      interface Package {}
                                                                                                                                      • JSDoc

                                                                                                                                      property name

                                                                                                                                      name: string;

                                                                                                                                        property version

                                                                                                                                        version: string;

                                                                                                                                          interface Request

                                                                                                                                          interface Request {}
                                                                                                                                          • Request data included in an event as sent to Sentry

                                                                                                                                          property cookies

                                                                                                                                          cookies?: {
                                                                                                                                          [key: string]: string;
                                                                                                                                          };

                                                                                                                                            property data

                                                                                                                                            data?: any;

                                                                                                                                              property env

                                                                                                                                              env?: {
                                                                                                                                              [key: string]: string;
                                                                                                                                              };

                                                                                                                                                property headers

                                                                                                                                                headers?: {
                                                                                                                                                [key: string]: string;
                                                                                                                                                };

                                                                                                                                                  property method

                                                                                                                                                  method?: string;

                                                                                                                                                    property query_string

                                                                                                                                                    query_string?: QueryParams;

                                                                                                                                                      property url

                                                                                                                                                      url?: string;

                                                                                                                                                        interface RequestSession

                                                                                                                                                        interface RequestSession {}

                                                                                                                                                          property status

                                                                                                                                                          status?: RequestSessionStatus;

                                                                                                                                                            interface Response

                                                                                                                                                            interface Response {}
                                                                                                                                                            • JSDoc

                                                                                                                                                            property event

                                                                                                                                                            event?: Event | Session;

                                                                                                                                                              property reason

                                                                                                                                                              reason?: string;

                                                                                                                                                                property status

                                                                                                                                                                status: Status;

                                                                                                                                                                  property type

                                                                                                                                                                  type?: EventType;

                                                                                                                                                                    interface Runtime

                                                                                                                                                                    interface Runtime {}
                                                                                                                                                                    • Runtime Context.

                                                                                                                                                                    property name

                                                                                                                                                                    name?: string;

                                                                                                                                                                      property version

                                                                                                                                                                      version?: string;

                                                                                                                                                                        interface SamplingContext

                                                                                                                                                                        interface SamplingContext extends CustomSamplingContext {}
                                                                                                                                                                        • Data passed to the tracesSampler function, which forms the basis for whatever decisions it might make.

                                                                                                                                                                          Adds default data to data provided by the user. See Hub.startTransaction

                                                                                                                                                                        property location

                                                                                                                                                                        location?: WorkerLocation;
                                                                                                                                                                        • Object representing the URL of the current page or worker script. Passed by default when using the BrowserTracing integration.

                                                                                                                                                                        property parentSampled

                                                                                                                                                                        parentSampled?: boolean;
                                                                                                                                                                        • Sampling decision from the parent transaction, if any.

                                                                                                                                                                        property request

                                                                                                                                                                        request?: ExtractedNodeRequestData;
                                                                                                                                                                        • Object representing the incoming request to a node server. Passed by default when using the TracingHandler.

                                                                                                                                                                        property transactionContext

                                                                                                                                                                        transactionContext: TransactionContext;
                                                                                                                                                                        • Context data with which transaction being sampled was created

                                                                                                                                                                        interface Scope

                                                                                                                                                                        interface Scope {}
                                                                                                                                                                        • Holds additional event information. Scope.applyToEvent will be called by the client before an event will be sent.

                                                                                                                                                                        method addBreadcrumb

                                                                                                                                                                        addBreadcrumb: (breadcrumb: Breadcrumb, maxBreadcrumbs?: number) => this;
                                                                                                                                                                        • Sets the breadcrumbs in the scope

                                                                                                                                                                          Parameter breadcrumbs

                                                                                                                                                                          Breadcrumb

                                                                                                                                                                          Parameter maxBreadcrumbs

                                                                                                                                                                          number of max breadcrumbs to merged into event.

                                                                                                                                                                        method addEventProcessor

                                                                                                                                                                        addEventProcessor: (callback: EventProcessor) => this;
                                                                                                                                                                        • Add new event processor that will be called after applyToEvent.

                                                                                                                                                                        method clear

                                                                                                                                                                        clear: () => this;
                                                                                                                                                                        • Clears the current scope and resets its properties.

                                                                                                                                                                        method clearBreadcrumbs

                                                                                                                                                                        clearBreadcrumbs: () => this;
                                                                                                                                                                        • Clears all currently set Breadcrumbs.

                                                                                                                                                                        method getRequestSession

                                                                                                                                                                        getRequestSession: () => RequestSession | undefined;
                                                                                                                                                                        • Returns the RequestSession if there is one

                                                                                                                                                                        method getSession

                                                                                                                                                                        getSession: () => Session | undefined;
                                                                                                                                                                        • Returns the Session if there is one

                                                                                                                                                                        method getSpan

                                                                                                                                                                        getSpan: () => Span | undefined;
                                                                                                                                                                        • Returns the Span if there is one

                                                                                                                                                                        method getTransaction

                                                                                                                                                                        getTransaction: () => Transaction | undefined;
                                                                                                                                                                        • Returns the Transaction attached to the scope (if there is one)

                                                                                                                                                                        method getUser

                                                                                                                                                                        getUser: () => User | undefined;
                                                                                                                                                                        • Returns the User if there is one

                                                                                                                                                                        method setContext

                                                                                                                                                                        setContext: (name: string, context: Context | null) => this;
                                                                                                                                                                        • Sets context data with the given name.

                                                                                                                                                                          Parameter name

                                                                                                                                                                          of the context

                                                                                                                                                                          Parameter context

                                                                                                                                                                          an object containing context data. This data will be normalized. Pass null to unset the context.

                                                                                                                                                                        method setExtra

                                                                                                                                                                        setExtra: (key: string, extra: Extra) => this;
                                                                                                                                                                        • Set key:value that will be sent as extra data with the event.

                                                                                                                                                                          Parameter key

                                                                                                                                                                          String of extra

                                                                                                                                                                          Parameter extra

                                                                                                                                                                          Any kind of data. This data will be normalized.

                                                                                                                                                                        method setExtras

                                                                                                                                                                        setExtras: (extras: Extras) => this;
                                                                                                                                                                        • Set an object that will be merged sent as extra data with the event.

                                                                                                                                                                          Parameter extras

                                                                                                                                                                          Extras object to merge into current context.

                                                                                                                                                                        method setFingerprint

                                                                                                                                                                        setFingerprint: (fingerprint: string[]) => this;
                                                                                                                                                                        • Sets the fingerprint on the scope to send with the events.

                                                                                                                                                                          Parameter fingerprint

                                                                                                                                                                          string[] to group events in Sentry.

                                                                                                                                                                        method setLevel

                                                                                                                                                                        setLevel: (level: Severity) => this;
                                                                                                                                                                        • Sets the level on the scope for future events.

                                                                                                                                                                          Parameter level

                                                                                                                                                                          string Severity

                                                                                                                                                                        method setRequestSession

                                                                                                                                                                        setRequestSession: (requestSession?: RequestSession) => this;
                                                                                                                                                                        • Sets the RequestSession on the scope

                                                                                                                                                                        method setSession

                                                                                                                                                                        setSession: (session?: Session) => this;
                                                                                                                                                                        • Sets the Session on the scope

                                                                                                                                                                        method setSpan

                                                                                                                                                                        setSpan: (span?: Span) => this;
                                                                                                                                                                        • Sets the Span on the scope.

                                                                                                                                                                          Parameter span

                                                                                                                                                                          Span

                                                                                                                                                                        method setTag

                                                                                                                                                                        setTag: (key: string, value: Primitive) => this;
                                                                                                                                                                        • Set key:value that will be sent as tags data with the event.

                                                                                                                                                                          Can also be used to unset a tag by passing undefined.

                                                                                                                                                                          Parameter key

                                                                                                                                                                          String key of tag

                                                                                                                                                                          Parameter value

                                                                                                                                                                          Value of tag

                                                                                                                                                                        method setTags

                                                                                                                                                                        setTags: (tags: { [key: string]: Primitive }) => this;
                                                                                                                                                                        • Set an object that will be merged sent as tags data with the event.

                                                                                                                                                                          Parameter tags

                                                                                                                                                                          Tags context object to merge into current context.

                                                                                                                                                                        method setTransactionName

                                                                                                                                                                        setTransactionName: (name?: string) => this;
                                                                                                                                                                        • Sets the transaction name on the scope for future events.

                                                                                                                                                                        method setUser

                                                                                                                                                                        setUser: (user: User | null) => this;
                                                                                                                                                                        • Updates user context information for future events.

                                                                                                                                                                          Parameter user

                                                                                                                                                                          User context object to be set in the current context. Pass null to unset the user.

                                                                                                                                                                        method update

                                                                                                                                                                        update: (captureContext?: CaptureContext) => this;
                                                                                                                                                                        • Updates the scope with provided data. Can work in three variations: - plain object containing updatable attributes - Scope instance that'll extract the attributes from - callback function that'll receive the current scope as an argument and allow for modifications

                                                                                                                                                                          Parameter captureContext

                                                                                                                                                                          scope modifier to be used

                                                                                                                                                                        interface ScopeContext

                                                                                                                                                                        interface ScopeContext {}
                                                                                                                                                                        • JSDocs

                                                                                                                                                                        property contexts

                                                                                                                                                                        contexts: Contexts;

                                                                                                                                                                          property extra

                                                                                                                                                                          extra: Extras;

                                                                                                                                                                            property fingerprint

                                                                                                                                                                            fingerprint: string[];

                                                                                                                                                                              property level

                                                                                                                                                                              level: Severity;

                                                                                                                                                                                property requestSession

                                                                                                                                                                                requestSession: RequestSession;

                                                                                                                                                                                  property tags

                                                                                                                                                                                  tags: {
                                                                                                                                                                                  [key: string]: Primitive;
                                                                                                                                                                                  };

                                                                                                                                                                                    property user

                                                                                                                                                                                    user: User;

                                                                                                                                                                                      interface SdkInfo

                                                                                                                                                                                      interface SdkInfo {}

                                                                                                                                                                                        property integrations

                                                                                                                                                                                        integrations?: string[];

                                                                                                                                                                                          property name

                                                                                                                                                                                          name?: string;

                                                                                                                                                                                            property packages

                                                                                                                                                                                            packages?: Package[];

                                                                                                                                                                                              property version

                                                                                                                                                                                              version?: string;

                                                                                                                                                                                                interface SdkMetadata

                                                                                                                                                                                                interface SdkMetadata {}

                                                                                                                                                                                                  property sdk

                                                                                                                                                                                                  sdk?: SdkInfo;

                                                                                                                                                                                                    interface SentryRequest

                                                                                                                                                                                                    interface SentryRequest {}
                                                                                                                                                                                                    • A generic client request.

                                                                                                                                                                                                    property body

                                                                                                                                                                                                    body: string;

                                                                                                                                                                                                      property type

                                                                                                                                                                                                      type: SentryRequestType;

                                                                                                                                                                                                        property url

                                                                                                                                                                                                        url: string;

                                                                                                                                                                                                          interface Session

                                                                                                                                                                                                          interface Session extends SessionContext {}

                                                                                                                                                                                                          method close

                                                                                                                                                                                                          close: (status?: SessionStatus) => void;
                                                                                                                                                                                                          • JSDoc

                                                                                                                                                                                                          method toJSON

                                                                                                                                                                                                          toJSON: () => {
                                                                                                                                                                                                          init: boolean;
                                                                                                                                                                                                          sid: string;
                                                                                                                                                                                                          did?: string;
                                                                                                                                                                                                          timestamp: string;
                                                                                                                                                                                                          started: string;
                                                                                                                                                                                                          duration?: number;
                                                                                                                                                                                                          status: SessionStatus;
                                                                                                                                                                                                          errors: number;
                                                                                                                                                                                                          attrs?: {
                                                                                                                                                                                                          release?: string;
                                                                                                                                                                                                          environment?: string;
                                                                                                                                                                                                          user_agent?: string;
                                                                                                                                                                                                          ip_address?: string;
                                                                                                                                                                                                          };
                                                                                                                                                                                                          };
                                                                                                                                                                                                          • JSDoc

                                                                                                                                                                                                          method update

                                                                                                                                                                                                          update: (context?: SessionContext) => void;
                                                                                                                                                                                                          • JSDoc

                                                                                                                                                                                                          interface SessionAggregates

                                                                                                                                                                                                          interface SessionAggregates {}
                                                                                                                                                                                                          • JSDoc

                                                                                                                                                                                                          property aggregates

                                                                                                                                                                                                          aggregates: Array<AggregationCounts>;

                                                                                                                                                                                                            property attrs

                                                                                                                                                                                                            attrs?: {
                                                                                                                                                                                                            environment?: string;
                                                                                                                                                                                                            release?: string;
                                                                                                                                                                                                            };

                                                                                                                                                                                                              interface SessionContext

                                                                                                                                                                                                              interface SessionContext {}
                                                                                                                                                                                                              • Session Context

                                                                                                                                                                                                              property did

                                                                                                                                                                                                              did?: string;

                                                                                                                                                                                                                property duration

                                                                                                                                                                                                                duration?: number;

                                                                                                                                                                                                                  property environment

                                                                                                                                                                                                                  environment?: string;

                                                                                                                                                                                                                    property errors

                                                                                                                                                                                                                    errors?: number;

                                                                                                                                                                                                                      property ignoreDuration

                                                                                                                                                                                                                      ignoreDuration?: boolean;

                                                                                                                                                                                                                        property init

                                                                                                                                                                                                                        init?: boolean;

                                                                                                                                                                                                                          property ipAddress

                                                                                                                                                                                                                          ipAddress?: string;

                                                                                                                                                                                                                            property release

                                                                                                                                                                                                                            release?: string;

                                                                                                                                                                                                                              property sid

                                                                                                                                                                                                                              sid?: string;

                                                                                                                                                                                                                                property started

                                                                                                                                                                                                                                started?: number;

                                                                                                                                                                                                                                  property status

                                                                                                                                                                                                                                  status?: SessionStatus;

                                                                                                                                                                                                                                    property timestamp

                                                                                                                                                                                                                                    timestamp?: number;

                                                                                                                                                                                                                                      property user

                                                                                                                                                                                                                                      user?: User | null;

                                                                                                                                                                                                                                        property userAgent

                                                                                                                                                                                                                                        userAgent?: string;

                                                                                                                                                                                                                                          interface SessionFlusherLike

                                                                                                                                                                                                                                          interface SessionFlusherLike {}

                                                                                                                                                                                                                                            method close

                                                                                                                                                                                                                                            close: () => void;
                                                                                                                                                                                                                                            • Clears setInterval and calls flush

                                                                                                                                                                                                                                            method flush

                                                                                                                                                                                                                                            flush: () => void;
                                                                                                                                                                                                                                            • Empties Aggregate Buckets and Sends them to Transport Buffer

                                                                                                                                                                                                                                            method incrementSessionStatusCount

                                                                                                                                                                                                                                            incrementSessionStatusCount: () => void;
                                                                                                                                                                                                                                            • Increments the Session Status bucket in SessionAggregates Object corresponding to the status of the session captured

                                                                                                                                                                                                                                            method sendSessionAggregates

                                                                                                                                                                                                                                            sendSessionAggregates: (sessionAggregates: SessionAggregates) => void;
                                                                                                                                                                                                                                            • Submits the aggregates request mode sessions to Sentry

                                                                                                                                                                                                                                            interface Span

                                                                                                                                                                                                                                            interface Span extends SpanContext {}
                                                                                                                                                                                                                                            • Span holding trace_id, span_id

                                                                                                                                                                                                                                            property data

                                                                                                                                                                                                                                            data: {
                                                                                                                                                                                                                                            [key: string]: any;
                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                            property spanId

                                                                                                                                                                                                                                            spanId: string;

                                                                                                                                                                                                                                            property startTimestamp

                                                                                                                                                                                                                                            startTimestamp: number;

                                                                                                                                                                                                                                            property tags

                                                                                                                                                                                                                                            tags: {
                                                                                                                                                                                                                                            [key: string]: Primitive;
                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                            property traceId

                                                                                                                                                                                                                                            traceId: string;

                                                                                                                                                                                                                                            property transaction

                                                                                                                                                                                                                                            transaction?: Transaction;
                                                                                                                                                                                                                                            • The transaction containing this span

                                                                                                                                                                                                                                            method child

                                                                                                                                                                                                                                            child: (
                                                                                                                                                                                                                                            spanContext?: Pick<
                                                                                                                                                                                                                                            SpanContext,
                                                                                                                                                                                                                                            Exclude<
                                                                                                                                                                                                                                            keyof SpanContext,
                                                                                                                                                                                                                                            'spanId' | 'sampled' | 'traceId' | 'parentSpanId'
                                                                                                                                                                                                                                            >
                                                                                                                                                                                                                                            >
                                                                                                                                                                                                                                            ) => Span;

                                                                                                                                                                                                                                            method finish

                                                                                                                                                                                                                                            finish: (endTimestamp?: number) => void;
                                                                                                                                                                                                                                            • Sets the finish timestamp on the current span.

                                                                                                                                                                                                                                              Parameter endTimestamp

                                                                                                                                                                                                                                              Takes an endTimestamp if the end should not be the time when you call this function.

                                                                                                                                                                                                                                            method getTraceContext

                                                                                                                                                                                                                                            getTraceContext: () => {
                                                                                                                                                                                                                                            data?: { [key: string]: any };
                                                                                                                                                                                                                                            description?: string;
                                                                                                                                                                                                                                            op?: string;
                                                                                                                                                                                                                                            parent_span_id?: string;
                                                                                                                                                                                                                                            span_id: string;
                                                                                                                                                                                                                                            status?: string;
                                                                                                                                                                                                                                            tags?: { [key: string]: Primitive };
                                                                                                                                                                                                                                            trace_id: string;
                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                            • Convert the object to JSON for w. spans array info only

                                                                                                                                                                                                                                            method isSuccess

                                                                                                                                                                                                                                            isSuccess: () => boolean;
                                                                                                                                                                                                                                            • Determines whether span was successful (HTTP200)

                                                                                                                                                                                                                                            method setData

                                                                                                                                                                                                                                            setData: (key: string, value: any) => this;
                                                                                                                                                                                                                                            • Sets the data attribute on the current span

                                                                                                                                                                                                                                              Parameter key

                                                                                                                                                                                                                                              Data key

                                                                                                                                                                                                                                              Parameter value

                                                                                                                                                                                                                                              Data value

                                                                                                                                                                                                                                            method setHttpStatus

                                                                                                                                                                                                                                            setHttpStatus: (httpStatus: number) => this;
                                                                                                                                                                                                                                            • Sets the status attribute on the current span based on the http code

                                                                                                                                                                                                                                              Parameter httpStatus

                                                                                                                                                                                                                                              http code used to set the status

                                                                                                                                                                                                                                            method setStatus

                                                                                                                                                                                                                                            setStatus: (status: string) => this;
                                                                                                                                                                                                                                            • Sets the status attribute on the current span See: {@sentry/tracing SpanStatus} for possible values

                                                                                                                                                                                                                                              Parameter status

                                                                                                                                                                                                                                              http code used to set the status

                                                                                                                                                                                                                                            method setTag

                                                                                                                                                                                                                                            setTag: (key: string, value: Primitive) => this;
                                                                                                                                                                                                                                            • Sets the tag attribute on the current span.

                                                                                                                                                                                                                                              Can also be used to unset a tag, by passing undefined.

                                                                                                                                                                                                                                              Parameter key

                                                                                                                                                                                                                                              Tag key

                                                                                                                                                                                                                                              Parameter value

                                                                                                                                                                                                                                              Tag value

                                                                                                                                                                                                                                            method startChild

                                                                                                                                                                                                                                            startChild: (
                                                                                                                                                                                                                                            spanContext?: Pick<
                                                                                                                                                                                                                                            SpanContext,
                                                                                                                                                                                                                                            Exclude<
                                                                                                                                                                                                                                            keyof SpanContext,
                                                                                                                                                                                                                                            'spanId' | 'sampled' | 'traceId' | 'parentSpanId'
                                                                                                                                                                                                                                            >
                                                                                                                                                                                                                                            >
                                                                                                                                                                                                                                            ) => Span;
                                                                                                                                                                                                                                            • Creates a new Span while setting the current Span.id as parentSpanId. Also the sampled decision will be inherited.

                                                                                                                                                                                                                                            method toContext

                                                                                                                                                                                                                                            toContext: () => SpanContext;
                                                                                                                                                                                                                                            • Returns the current span properties as a SpanContext

                                                                                                                                                                                                                                            method toJSON

                                                                                                                                                                                                                                            toJSON: () => {
                                                                                                                                                                                                                                            data?: { [key: string]: any };
                                                                                                                                                                                                                                            description?: string;
                                                                                                                                                                                                                                            op?: string;
                                                                                                                                                                                                                                            parent_span_id?: string;
                                                                                                                                                                                                                                            span_id: string;
                                                                                                                                                                                                                                            start_timestamp: number;
                                                                                                                                                                                                                                            status?: string;
                                                                                                                                                                                                                                            tags?: { [key: string]: Primitive };
                                                                                                                                                                                                                                            timestamp?: number;
                                                                                                                                                                                                                                            trace_id: string;
                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                            • Convert the object to JSON

                                                                                                                                                                                                                                            method toTraceparent

                                                                                                                                                                                                                                            toTraceparent: () => string;
                                                                                                                                                                                                                                            • Return a traceparent compatible header string

                                                                                                                                                                                                                                            method updateWithContext

                                                                                                                                                                                                                                            updateWithContext: (spanContext: SpanContext) => this;
                                                                                                                                                                                                                                            • Updates the current span with a new SpanContext

                                                                                                                                                                                                                                            interface SpanContext

                                                                                                                                                                                                                                            interface SpanContext {}
                                                                                                                                                                                                                                            • Interface holding all properties that can be set on a Span on creation.

                                                                                                                                                                                                                                            property data

                                                                                                                                                                                                                                            data?: {
                                                                                                                                                                                                                                            [key: string]: any;
                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                            • Data of the Span.

                                                                                                                                                                                                                                            property description

                                                                                                                                                                                                                                            description?: string;
                                                                                                                                                                                                                                            • Description of the Span.

                                                                                                                                                                                                                                            property endTimestamp

                                                                                                                                                                                                                                            endTimestamp?: number;
                                                                                                                                                                                                                                            • Timestamp in seconds (epoch time) indicating when the span ended.

                                                                                                                                                                                                                                            property op

                                                                                                                                                                                                                                            op?: string;
                                                                                                                                                                                                                                            • Operation of the Span.

                                                                                                                                                                                                                                            property parentSpanId

                                                                                                                                                                                                                                            parentSpanId?: string;
                                                                                                                                                                                                                                            • Parent Span ID

                                                                                                                                                                                                                                            property sampled

                                                                                                                                                                                                                                            sampled?: boolean;
                                                                                                                                                                                                                                            • Was this span chosen to be sent as part of the sample?

                                                                                                                                                                                                                                            property spanId

                                                                                                                                                                                                                                            spanId?: string;
                                                                                                                                                                                                                                            • Span ID

                                                                                                                                                                                                                                            property startTimestamp

                                                                                                                                                                                                                                            startTimestamp?: number;
                                                                                                                                                                                                                                            • Timestamp in seconds (epoch time) indicating when the span started.

                                                                                                                                                                                                                                            property status

                                                                                                                                                                                                                                            status?: string;
                                                                                                                                                                                                                                            • Completion status of the Span. See: {@sentry/tracing SpanStatus} for possible values

                                                                                                                                                                                                                                            property tags

                                                                                                                                                                                                                                            tags?: {
                                                                                                                                                                                                                                            [key: string]: Primitive;
                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                            • Tags of the Span.

                                                                                                                                                                                                                                            property traceId

                                                                                                                                                                                                                                            traceId?: string;
                                                                                                                                                                                                                                            • Trace ID

                                                                                                                                                                                                                                            interface StackFrame

                                                                                                                                                                                                                                            interface StackFrame {}
                                                                                                                                                                                                                                            • JSDoc

                                                                                                                                                                                                                                            property abs_path

                                                                                                                                                                                                                                            abs_path?: string;

                                                                                                                                                                                                                                              property addr_mode

                                                                                                                                                                                                                                              addr_mode?: string;

                                                                                                                                                                                                                                                property colno

                                                                                                                                                                                                                                                colno?: number;

                                                                                                                                                                                                                                                  property context_line

                                                                                                                                                                                                                                                  context_line?: string;

                                                                                                                                                                                                                                                    property filename

                                                                                                                                                                                                                                                    filename?: string;

                                                                                                                                                                                                                                                      property function

                                                                                                                                                                                                                                                      function?: string;

                                                                                                                                                                                                                                                        property in_app

                                                                                                                                                                                                                                                        in_app?: boolean;

                                                                                                                                                                                                                                                          property instruction_addr

                                                                                                                                                                                                                                                          instruction_addr?: string;

                                                                                                                                                                                                                                                            property lineno

                                                                                                                                                                                                                                                            lineno?: number;

                                                                                                                                                                                                                                                              property module

                                                                                                                                                                                                                                                              module?: string;

                                                                                                                                                                                                                                                                property platform

                                                                                                                                                                                                                                                                platform?: string;

                                                                                                                                                                                                                                                                  property post_context

                                                                                                                                                                                                                                                                  post_context?: string[];

                                                                                                                                                                                                                                                                    property pre_context

                                                                                                                                                                                                                                                                    pre_context?: string[];

                                                                                                                                                                                                                                                                      property vars

                                                                                                                                                                                                                                                                      vars?: {
                                                                                                                                                                                                                                                                      [key: string]: any;
                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                        interface Stacktrace

                                                                                                                                                                                                                                                                        interface Stacktrace {}
                                                                                                                                                                                                                                                                        • JSDoc

                                                                                                                                                                                                                                                                        property frames

                                                                                                                                                                                                                                                                        frames?: StackFrame[];

                                                                                                                                                                                                                                                                          property frames_omitted

                                                                                                                                                                                                                                                                          frames_omitted?: [number, number];

                                                                                                                                                                                                                                                                            interface Thread

                                                                                                                                                                                                                                                                            interface Thread {}
                                                                                                                                                                                                                                                                            • JSDoc

                                                                                                                                                                                                                                                                            property crashed

                                                                                                                                                                                                                                                                            crashed?: boolean;

                                                                                                                                                                                                                                                                              property current

                                                                                                                                                                                                                                                                              current?: boolean;

                                                                                                                                                                                                                                                                                property id

                                                                                                                                                                                                                                                                                id?: number;

                                                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                                                  name?: string;

                                                                                                                                                                                                                                                                                    property stacktrace

                                                                                                                                                                                                                                                                                    stacktrace?: Stacktrace;

                                                                                                                                                                                                                                                                                      interface Transaction

                                                                                                                                                                                                                                                                                      interface Transaction extends TransactionContext, Span {}
                                                                                                                                                                                                                                                                                      • Transaction "Class", inherits Span only has setName

                                                                                                                                                                                                                                                                                      property data

                                                                                                                                                                                                                                                                                      data: {
                                                                                                                                                                                                                                                                                      [key: string]: any;
                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                      property metadata

                                                                                                                                                                                                                                                                                      metadata: TransactionMetadata;
                                                                                                                                                                                                                                                                                      • Metadata about the transaction

                                                                                                                                                                                                                                                                                      property spanId

                                                                                                                                                                                                                                                                                      spanId: string;

                                                                                                                                                                                                                                                                                      property startTimestamp

                                                                                                                                                                                                                                                                                      startTimestamp: number;

                                                                                                                                                                                                                                                                                      property tags

                                                                                                                                                                                                                                                                                      tags: {
                                                                                                                                                                                                                                                                                      [key: string]: Primitive;
                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                      property traceId

                                                                                                                                                                                                                                                                                      traceId: string;

                                                                                                                                                                                                                                                                                      method setName

                                                                                                                                                                                                                                                                                      setName: (name: string) => void;
                                                                                                                                                                                                                                                                                      • Set the name of the transaction

                                                                                                                                                                                                                                                                                      method toContext

                                                                                                                                                                                                                                                                                      toContext: () => TransactionContext;
                                                                                                                                                                                                                                                                                      • Returns the current transaction properties as a TransactionContext

                                                                                                                                                                                                                                                                                      method updateWithContext

                                                                                                                                                                                                                                                                                      updateWithContext: (transactionContext: TransactionContext) => this;
                                                                                                                                                                                                                                                                                      • Updates the current transaction with a new TransactionContext

                                                                                                                                                                                                                                                                                      interface TransactionContext

                                                                                                                                                                                                                                                                                      interface TransactionContext extends SpanContext {}
                                                                                                                                                                                                                                                                                      • Interface holding Transaction-specific properties

                                                                                                                                                                                                                                                                                      property metadata

                                                                                                                                                                                                                                                                                      metadata?: TransactionMetadata;
                                                                                                                                                                                                                                                                                      • Metadata associated with the transaction, for internal SDK use.

                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                      name: string;
                                                                                                                                                                                                                                                                                      • Human-readable identifier for the transaction

                                                                                                                                                                                                                                                                                      property parentSampled

                                                                                                                                                                                                                                                                                      parentSampled?: boolean;
                                                                                                                                                                                                                                                                                      • If this transaction has a parent, the parent's sampling decision

                                                                                                                                                                                                                                                                                      property trimEnd

                                                                                                                                                                                                                                                                                      trimEnd?: boolean;
                                                                                                                                                                                                                                                                                      • If true, sets the end timestamp of the transaction to the highest timestamp of child spans, trimming the duration of the transaction. This is useful to discard extra time in the transaction that is not accounted for in child spans, like what happens in the idle transaction Tracing integration, where we finish the transaction after a given "idle time" and we don't want this "idle time" to be part of the transaction.

                                                                                                                                                                                                                                                                                      interface TransactionMetadata

                                                                                                                                                                                                                                                                                      interface TransactionMetadata {}

                                                                                                                                                                                                                                                                                        property requestPath

                                                                                                                                                                                                                                                                                        requestPath?: string;
                                                                                                                                                                                                                                                                                        • For transactions tracing server-side request handling, the path of the request being tracked.

                                                                                                                                                                                                                                                                                        property tracestate

                                                                                                                                                                                                                                                                                        tracestate?: {
                                                                                                                                                                                                                                                                                        sentry?: string;
                                                                                                                                                                                                                                                                                        thirdparty?: string;
                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                        • The two halves (sentry and third-party) of a transaction's tracestate header, used for dynamic sampling

                                                                                                                                                                                                                                                                                        property transactionSampling

                                                                                                                                                                                                                                                                                        transactionSampling?: {
                                                                                                                                                                                                                                                                                        rate?: number;
                                                                                                                                                                                                                                                                                        method?: string;
                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                          interface Transport

                                                                                                                                                                                                                                                                                          interface Transport {}
                                                                                                                                                                                                                                                                                          • Transport used sending data to Sentry

                                                                                                                                                                                                                                                                                          method close

                                                                                                                                                                                                                                                                                          close: (timeout?: number) => PromiseLike<boolean>;
                                                                                                                                                                                                                                                                                          • Call this function to wait until all pending requests have been sent.

                                                                                                                                                                                                                                                                                            Parameter timeout

                                                                                                                                                                                                                                                                                            Number time in ms to wait until the buffer is drained.

                                                                                                                                                                                                                                                                                          method sendEvent

                                                                                                                                                                                                                                                                                          sendEvent: (event: Event) => PromiseLike<Response>;
                                                                                                                                                                                                                                                                                          • Sends the event to the Store endpoint in Sentry.

                                                                                                                                                                                                                                                                                            Parameter event

                                                                                                                                                                                                                                                                                            Event that should be sent to Sentry.

                                                                                                                                                                                                                                                                                          method sendSession

                                                                                                                                                                                                                                                                                          sendSession: (session: Session | SessionAggregates) => PromiseLike<Response>;
                                                                                                                                                                                                                                                                                          • Sends the session to the Envelope endpoint in Sentry.

                                                                                                                                                                                                                                                                                            Parameter session

                                                                                                                                                                                                                                                                                            Session that should be sent to Sentry | Session Aggregates that should be sent to Sentry.

                                                                                                                                                                                                                                                                                          interface TransportOptions

                                                                                                                                                                                                                                                                                          interface TransportOptions {}
                                                                                                                                                                                                                                                                                          • JSDoc

                                                                                                                                                                                                                                                                                          property caCerts

                                                                                                                                                                                                                                                                                          caCerts?: string;
                                                                                                                                                                                                                                                                                          • HTTPS proxy certificates path

                                                                                                                                                                                                                                                                                          property dsn

                                                                                                                                                                                                                                                                                          dsn: DsnLike;
                                                                                                                                                                                                                                                                                          • Sentry DSN

                                                                                                                                                                                                                                                                                          property fetchParameters

                                                                                                                                                                                                                                                                                          fetchParameters?: {
                                                                                                                                                                                                                                                                                          [key: string]: string;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          • Fetch API init parameters

                                                                                                                                                                                                                                                                                          property headers

                                                                                                                                                                                                                                                                                          headers?: {
                                                                                                                                                                                                                                                                                          [key: string]: string;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          • Define custom headers

                                                                                                                                                                                                                                                                                          property httpProxy

                                                                                                                                                                                                                                                                                          httpProxy?: string;
                                                                                                                                                                                                                                                                                          • Set a HTTP proxy that should be used for outbound requests.

                                                                                                                                                                                                                                                                                          property httpsProxy

                                                                                                                                                                                                                                                                                          httpsProxy?: string;
                                                                                                                                                                                                                                                                                          • Set a HTTPS proxy that should be used for outbound requests.

                                                                                                                                                                                                                                                                                          interface User

                                                                                                                                                                                                                                                                                          interface User {}
                                                                                                                                                                                                                                                                                          • JSDoc

                                                                                                                                                                                                                                                                                          property email

                                                                                                                                                                                                                                                                                          email?: string;

                                                                                                                                                                                                                                                                                            property id

                                                                                                                                                                                                                                                                                            id?: string;

                                                                                                                                                                                                                                                                                              property ip_address

                                                                                                                                                                                                                                                                                              ip_address?: string;

                                                                                                                                                                                                                                                                                                property username

                                                                                                                                                                                                                                                                                                username?: string;

                                                                                                                                                                                                                                                                                                  index signature

                                                                                                                                                                                                                                                                                                  [key: string]: any;

                                                                                                                                                                                                                                                                                                    interface WorkerLocation

                                                                                                                                                                                                                                                                                                    interface WorkerLocation {}
                                                                                                                                                                                                                                                                                                    • Location object on a service worker's self object.

                                                                                                                                                                                                                                                                                                      See https://developer.mozilla.org/en-US/docs/Web/API/WorkerLocation.

                                                                                                                                                                                                                                                                                                    property hash

                                                                                                                                                                                                                                                                                                    readonly hash: string;
                                                                                                                                                                                                                                                                                                    • The fragment identifier of the URL of the script executed in the Worker, beginning with a '#'.

                                                                                                                                                                                                                                                                                                    property host

                                                                                                                                                                                                                                                                                                    readonly host: string;
                                                                                                                                                                                                                                                                                                    • The host, that is the hostname, a ':', and the port of the URL of the script executed in the Worker.

                                                                                                                                                                                                                                                                                                    property hostname

                                                                                                                                                                                                                                                                                                    readonly hostname: string;
                                                                                                                                                                                                                                                                                                    • The domain of the URL of the script executed in the Worker.

                                                                                                                                                                                                                                                                                                    property href

                                                                                                                                                                                                                                                                                                    readonly href: string;
                                                                                                                                                                                                                                                                                                    • Stringifier that returns the whole URL of the script executed in the Worker.

                                                                                                                                                                                                                                                                                                    property origin

                                                                                                                                                                                                                                                                                                    readonly origin: string;
                                                                                                                                                                                                                                                                                                    • The canonical form of the origin of the specific location.

                                                                                                                                                                                                                                                                                                    property pathname

                                                                                                                                                                                                                                                                                                    readonly pathname: string;
                                                                                                                                                                                                                                                                                                    • The path of the URL of the script executed in the Worker, beginning with a '/'.

                                                                                                                                                                                                                                                                                                    property port

                                                                                                                                                                                                                                                                                                    readonly port: string;
                                                                                                                                                                                                                                                                                                    • The port number of the URL of the script executed in the Worker.

                                                                                                                                                                                                                                                                                                    property protocol

                                                                                                                                                                                                                                                                                                    readonly protocol: string;
                                                                                                                                                                                                                                                                                                    • The protocol scheme of the URL of the script executed in the Worker, including the final ':'.

                                                                                                                                                                                                                                                                                                    property search

                                                                                                                                                                                                                                                                                                    readonly search: string;
                                                                                                                                                                                                                                                                                                    • The parameters (query string) of the URL of the script executed in the Worker, beginning with a '?'.

                                                                                                                                                                                                                                                                                                    method toString

                                                                                                                                                                                                                                                                                                    toString: () => string;
                                                                                                                                                                                                                                                                                                    • Synonym for href attribute

                                                                                                                                                                                                                                                                                                    interface WrappedFunction

                                                                                                                                                                                                                                                                                                    interface WrappedFunction extends Function {}
                                                                                                                                                                                                                                                                                                    • JSDoc

                                                                                                                                                                                                                                                                                                    index signature

                                                                                                                                                                                                                                                                                                    [key: string]: any;

                                                                                                                                                                                                                                                                                                      Enums

                                                                                                                                                                                                                                                                                                      enum LogLevel

                                                                                                                                                                                                                                                                                                      enum LogLevel {
                                                                                                                                                                                                                                                                                                      None = 0,
                                                                                                                                                                                                                                                                                                      Error = 1,
                                                                                                                                                                                                                                                                                                      Debug = 2,
                                                                                                                                                                                                                                                                                                      Verbose = 3,
                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                      • Console logging verbosity for the SDK.

                                                                                                                                                                                                                                                                                                      member Debug

                                                                                                                                                                                                                                                                                                      Debug = 2
                                                                                                                                                                                                                                                                                                      • Information useful for debugging the SDK will be logged.

                                                                                                                                                                                                                                                                                                      member Error

                                                                                                                                                                                                                                                                                                      Error = 1
                                                                                                                                                                                                                                                                                                      • Only SDK internal errors will be logged.

                                                                                                                                                                                                                                                                                                      member None

                                                                                                                                                                                                                                                                                                      None = 0
                                                                                                                                                                                                                                                                                                      • No logs will be generated.

                                                                                                                                                                                                                                                                                                      member Verbose

                                                                                                                                                                                                                                                                                                      Verbose = 3
                                                                                                                                                                                                                                                                                                      • All SDK actions will be logged.

                                                                                                                                                                                                                                                                                                      enum RequestSessionStatus

                                                                                                                                                                                                                                                                                                      enum RequestSessionStatus {
                                                                                                                                                                                                                                                                                                      Ok = 'ok',
                                                                                                                                                                                                                                                                                                      Errored = 'errored',
                                                                                                                                                                                                                                                                                                      Crashed = 'crashed',
                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                        member Crashed

                                                                                                                                                                                                                                                                                                        Crashed = 'crashed'
                                                                                                                                                                                                                                                                                                        • JSDoc

                                                                                                                                                                                                                                                                                                        member Errored

                                                                                                                                                                                                                                                                                                        Errored = 'errored'
                                                                                                                                                                                                                                                                                                        • JSDoc

                                                                                                                                                                                                                                                                                                        member Ok

                                                                                                                                                                                                                                                                                                        Ok = 'ok'
                                                                                                                                                                                                                                                                                                        • JSDoc

                                                                                                                                                                                                                                                                                                        enum SessionStatus

                                                                                                                                                                                                                                                                                                        enum SessionStatus {
                                                                                                                                                                                                                                                                                                        Ok = 'ok',
                                                                                                                                                                                                                                                                                                        Exited = 'exited',
                                                                                                                                                                                                                                                                                                        Crashed = 'crashed',
                                                                                                                                                                                                                                                                                                        Abnormal = 'abnormal',
                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                        • Session Status

                                                                                                                                                                                                                                                                                                        member Abnormal

                                                                                                                                                                                                                                                                                                        Abnormal = 'abnormal'
                                                                                                                                                                                                                                                                                                        • JSDoc

                                                                                                                                                                                                                                                                                                        member Crashed

                                                                                                                                                                                                                                                                                                        Crashed = 'crashed'
                                                                                                                                                                                                                                                                                                        • JSDoc

                                                                                                                                                                                                                                                                                                        member Exited

                                                                                                                                                                                                                                                                                                        Exited = 'exited'
                                                                                                                                                                                                                                                                                                        • JSDoc

                                                                                                                                                                                                                                                                                                        member Ok

                                                                                                                                                                                                                                                                                                        Ok = 'ok'
                                                                                                                                                                                                                                                                                                        • JSDoc

                                                                                                                                                                                                                                                                                                        enum Severity

                                                                                                                                                                                                                                                                                                        enum Severity {
                                                                                                                                                                                                                                                                                                        Fatal = 'fatal',
                                                                                                                                                                                                                                                                                                        Error = 'error',
                                                                                                                                                                                                                                                                                                        Warning = 'warning',
                                                                                                                                                                                                                                                                                                        Log = 'log',
                                                                                                                                                                                                                                                                                                        Info = 'info',
                                                                                                                                                                                                                                                                                                        Debug = 'debug',
                                                                                                                                                                                                                                                                                                        Critical = 'critical',
                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                        • JSDoc

                                                                                                                                                                                                                                                                                                        member Critical

                                                                                                                                                                                                                                                                                                        Critical = 'critical'
                                                                                                                                                                                                                                                                                                        • JSDoc

                                                                                                                                                                                                                                                                                                        member Debug

                                                                                                                                                                                                                                                                                                        Debug = 'debug'
                                                                                                                                                                                                                                                                                                        • JSDoc

                                                                                                                                                                                                                                                                                                        member Error

                                                                                                                                                                                                                                                                                                        Error = 'error'
                                                                                                                                                                                                                                                                                                        • JSDoc

                                                                                                                                                                                                                                                                                                        member Fatal

                                                                                                                                                                                                                                                                                                        Fatal = 'fatal'
                                                                                                                                                                                                                                                                                                        • JSDoc

                                                                                                                                                                                                                                                                                                        member Info

                                                                                                                                                                                                                                                                                                        Info = 'info'
                                                                                                                                                                                                                                                                                                        • JSDoc

                                                                                                                                                                                                                                                                                                        member Log

                                                                                                                                                                                                                                                                                                        Log = 'log'
                                                                                                                                                                                                                                                                                                        • JSDoc

                                                                                                                                                                                                                                                                                                        member Warning

                                                                                                                                                                                                                                                                                                        Warning = 'warning'
                                                                                                                                                                                                                                                                                                        • JSDoc

                                                                                                                                                                                                                                                                                                        enum Status

                                                                                                                                                                                                                                                                                                        enum Status {
                                                                                                                                                                                                                                                                                                        Unknown = 'unknown',
                                                                                                                                                                                                                                                                                                        Skipped = 'skipped',
                                                                                                                                                                                                                                                                                                        Success = 'success',
                                                                                                                                                                                                                                                                                                        RateLimit = 'rate_limit',
                                                                                                                                                                                                                                                                                                        Invalid = 'invalid',
                                                                                                                                                                                                                                                                                                        Failed = 'failed',
                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                        • The status of an event.

                                                                                                                                                                                                                                                                                                        member Failed

                                                                                                                                                                                                                                                                                                        Failed = 'failed'
                                                                                                                                                                                                                                                                                                        • A server-side error ocurred during submission.

                                                                                                                                                                                                                                                                                                        member Invalid

                                                                                                                                                                                                                                                                                                        Invalid = 'invalid'
                                                                                                                                                                                                                                                                                                        • The event could not be processed.

                                                                                                                                                                                                                                                                                                        member RateLimit

                                                                                                                                                                                                                                                                                                        RateLimit = 'rate_limit'
                                                                                                                                                                                                                                                                                                        • The client is currently rate limited and will try again later.

                                                                                                                                                                                                                                                                                                        member Skipped

                                                                                                                                                                                                                                                                                                        Skipped = 'skipped'
                                                                                                                                                                                                                                                                                                        • The event was skipped due to configuration or callbacks.

                                                                                                                                                                                                                                                                                                        member Success

                                                                                                                                                                                                                                                                                                        Success = 'success'
                                                                                                                                                                                                                                                                                                        • The event was sent to Sentry successfully.

                                                                                                                                                                                                                                                                                                        member Unknown

                                                                                                                                                                                                                                                                                                        Unknown = 'unknown'
                                                                                                                                                                                                                                                                                                        • The status could not be determined.

                                                                                                                                                                                                                                                                                                        enum TransactionSamplingMethod

                                                                                                                                                                                                                                                                                                        enum TransactionSamplingMethod {
                                                                                                                                                                                                                                                                                                        Explicit = 'explicitly_set',
                                                                                                                                                                                                                                                                                                        Sampler = 'client_sampler',
                                                                                                                                                                                                                                                                                                        Rate = 'client_rate',
                                                                                                                                                                                                                                                                                                        Inheritance = 'inheritance',
                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                          member Explicit

                                                                                                                                                                                                                                                                                                          Explicit = 'explicitly_set'

                                                                                                                                                                                                                                                                                                            member Inheritance

                                                                                                                                                                                                                                                                                                            Inheritance = 'inheritance'

                                                                                                                                                                                                                                                                                                              member Rate

                                                                                                                                                                                                                                                                                                              Rate = 'client_rate'

                                                                                                                                                                                                                                                                                                                member Sampler

                                                                                                                                                                                                                                                                                                                Sampler = 'client_sampler'

                                                                                                                                                                                                                                                                                                                  Type Aliases

                                                                                                                                                                                                                                                                                                                  type CaptureContext

                                                                                                                                                                                                                                                                                                                  type CaptureContext = Scope | Partial<ScopeContext> | ((scope: Scope) => Scope);
                                                                                                                                                                                                                                                                                                                  • JSDocs

                                                                                                                                                                                                                                                                                                                  type Context

                                                                                                                                                                                                                                                                                                                  type Context = Record<string, unknown>;

                                                                                                                                                                                                                                                                                                                    type Contexts

                                                                                                                                                                                                                                                                                                                    type Contexts = Record<string, Context>;

                                                                                                                                                                                                                                                                                                                      type DebugImageType

                                                                                                                                                                                                                                                                                                                      type DebugImageType = 'wasm' | 'macho' | 'elf' | 'pe';
                                                                                                                                                                                                                                                                                                                      • Possible choices for debug images.

                                                                                                                                                                                                                                                                                                                      type DsnLike

                                                                                                                                                                                                                                                                                                                      type DsnLike = string | DsnComponents;
                                                                                                                                                                                                                                                                                                                      • Anything that can be parsed into a Dsn.

                                                                                                                                                                                                                                                                                                                      type DsnProtocol

                                                                                                                                                                                                                                                                                                                      type DsnProtocol = 'http' | 'https';
                                                                                                                                                                                                                                                                                                                      • Supported Sentry transport protocols in a Dsn.

                                                                                                                                                                                                                                                                                                                      type EventProcessor

                                                                                                                                                                                                                                                                                                                      type EventProcessor = (
                                                                                                                                                                                                                                                                                                                      event: Event,
                                                                                                                                                                                                                                                                                                                      hint?: EventHint
                                                                                                                                                                                                                                                                                                                      ) => PromiseLike<Event | null> | Event | null;
                                                                                                                                                                                                                                                                                                                      • Event processors are used to change the event before it will be send. We strongly advise to make this function sync. Returning a PromiseLike<Event | null> will work just fine, but better be sure that you know what you are doing. Event processing will be deferred until your Promise is resolved.

                                                                                                                                                                                                                                                                                                                      type Extra

                                                                                                                                                                                                                                                                                                                      type Extra = unknown;

                                                                                                                                                                                                                                                                                                                        type Extras

                                                                                                                                                                                                                                                                                                                        type Extras = Record<string, Extra>;

                                                                                                                                                                                                                                                                                                                          type Measurements

                                                                                                                                                                                                                                                                                                                          type Measurements = Record<
                                                                                                                                                                                                                                                                                                                          string,
                                                                                                                                                                                                                                                                                                                          {
                                                                                                                                                                                                                                                                                                                          value: number;
                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                            type Primitive

                                                                                                                                                                                                                                                                                                                            type Primitive = number | string | boolean | bigint | symbol | null | undefined;

                                                                                                                                                                                                                                                                                                                              type QueryParams

                                                                                                                                                                                                                                                                                                                              type QueryParams =
                                                                                                                                                                                                                                                                                                                              | string
                                                                                                                                                                                                                                                                                                                              | {
                                                                                                                                                                                                                                                                                                                              [key: string]: string;
                                                                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                                                                              | Array<[string, string]>;

                                                                                                                                                                                                                                                                                                                                type SentryRequestType

                                                                                                                                                                                                                                                                                                                                type SentryRequestType = 'event' | 'transaction' | 'session' | 'attachment';
                                                                                                                                                                                                                                                                                                                                • Possible SentryRequest types that can be used to make a distinction between Sentry features

                                                                                                                                                                                                                                                                                                                                type TraceparentData

                                                                                                                                                                                                                                                                                                                                type TraceparentData = Pick<
                                                                                                                                                                                                                                                                                                                                TransactionContext,
                                                                                                                                                                                                                                                                                                                                'traceId' | 'parentSpanId' | 'parentSampled'
                                                                                                                                                                                                                                                                                                                                >;
                                                                                                                                                                                                                                                                                                                                • Data pulled from a sentry-trace header

                                                                                                                                                                                                                                                                                                                                type TransportClass

                                                                                                                                                                                                                                                                                                                                type TransportClass<T extends Transport> = new (options: TransportOptions) => T;
                                                                                                                                                                                                                                                                                                                                • JSDoc

                                                                                                                                                                                                                                                                                                                                Namespaces

                                                                                                                                                                                                                                                                                                                                namespace Severity

                                                                                                                                                                                                                                                                                                                                namespace Severity {}

                                                                                                                                                                                                                                                                                                                                  function fromString

                                                                                                                                                                                                                                                                                                                                  fromString: (level: string) => Severity;
                                                                                                                                                                                                                                                                                                                                  • Converts a string-based level into a Severity.

                                                                                                                                                                                                                                                                                                                                    Parameter level

                                                                                                                                                                                                                                                                                                                                    string representation of Severity

                                                                                                                                                                                                                                                                                                                                    Returns

                                                                                                                                                                                                                                                                                                                                    Severity

                                                                                                                                                                                                                                                                                                                                  namespace Status

                                                                                                                                                                                                                                                                                                                                  namespace Status {}

                                                                                                                                                                                                                                                                                                                                    function fromHttpCode

                                                                                                                                                                                                                                                                                                                                    fromHttpCode: (code: number) => Status;
                                                                                                                                                                                                                                                                                                                                    • Converts a HTTP status code into a Status.

                                                                                                                                                                                                                                                                                                                                      Parameter code

                                                                                                                                                                                                                                                                                                                                      The HTTP response status code.

                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                      The send status or Status.Unknown.

                                                                                                                                                                                                                                                                                                                                    Package Files (35)

                                                                                                                                                                                                                                                                                                                                    Dependencies (0)

                                                                                                                                                                                                                                                                                                                                    No dependencies.

                                                                                                                                                                                                                                                                                                                                    Dev Dependencies (4)

                                                                                                                                                                                                                                                                                                                                    Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                    No peer dependencies.

                                                                                                                                                                                                                                                                                                                                    Badge

                                                                                                                                                                                                                                                                                                                                    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/types.

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