@sentry/types

  • Version 7.54.0
  • Published
  • 132 kB
  • No dependencies
  • MIT 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

Interfaces

interface AggregationCounts

interface AggregationCounts {}

    property crashed

    crashed?: number;

      property errored

      errored?: number;

        property exited

        exited?: number;

          property started

          started: string;

            interface AppContext

            interface AppContext extends Record<string, unknown> {}

              property app_identifier

              app_identifier?: string;

                property app_memory

                app_memory?: number;

                  property app_name

                  app_name?: string;

                    property app_start_time

                    app_start_time?: string;

                      property app_version

                      app_version?: string;

                        property build_type

                        build_type?: string;

                          interface Attachment

                          interface Attachment {}

                            property attachmentType

                            attachmentType?: string;

                              property contentType

                              contentType?: string;

                                property data

                                data: string | Uint8Array;

                                  property filename

                                  filename: string;

                                    interface BaseTransportOptions

                                    interface BaseTransportOptions extends InternalBaseTransportOptions {}

                                      property url

                                      url: string;
                                        interface Breadcrumb {}
                                        • JSDoc

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

                                                      [key: string]: any;

                                                        interface Client

                                                        interface Client<O extends ClientOptions = ClientOptions> {}
                                                        • 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 addIntegration

                                                        addIntegration: (integration: Integration) => void;
                                                        • Add an integration to the client. This can be used to e.g. lazy load integrations. In most cases, this should not be necessary, and you're better off just passing the integrations via integrations: [] at initialization time. However, if you find the need to conditionally load & add an integration, you can use addIntegration to do so.

                                                          TODO (v8): Make this a required method.

                                                        method captureCheckIn

                                                        captureCheckIn: (checkIn: CheckIn, monitorConfig?: MonitorConfig) => string;
                                                        • Create a cron monitor check in and send it to Sentry. This method is not available on all clients.

                                                          Parameter checkIn

                                                          An object that describes a check in.

                                                          Parameter upsertMonitorConfig

                                                          An optional object that describes a monitor config. Use this if you want to create a monitor automatically when sending a check in.

                                                          Returns

                                                          A string representing the id of the check in.

                                                        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 | SeverityLevel,
                                                        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>;
                                                        • Flush the event queue and set the client to enabled = false. See Client.flush.

                                                          Parameter timeout

                                                          Maximum time in ms the client should wait before shutting down. Omitting this parameter will cause the client to wait until all events are sent before disabling itself.

                                                          Returns

                                                          A promise which resolves to true if the flush completes successfully before the timeout, or false if it doesn't.

                                                        method emit

                                                        emit: {
                                                        (
                                                        hook: 'startTransaction' | 'finishTransaction',
                                                        transaction: Transaction
                                                        ): void;
                                                        (hook: 'beforeEnvelope', envelope: Envelope): void;
                                                        (
                                                        hook: 'afterSendEvent',
                                                        event: Event,
                                                        sendResponse: void | TransportMakeRequestResponse
                                                        ): void;
                                                        (
                                                        hook: 'beforeAddBreadcrumb',
                                                        breadcrumb: Breadcrumb,
                                                        hint?: BreadcrumbHint
                                                        ): void;
                                                        (hook: 'createDsc', dsc: DynamicSamplingContext): void;
                                                        };
                                                        • Fire a hook event for transaction start and finish. Expects to be given a transaction as the second argument.

                                                        • Fire a hook for when a breadcrumb is added. Expects the breadcrumb as second argument.

                                                        • Fire a hook for when a DSC (Dynamic Sampling Context) is created. Expects the DSC as second argument.

                                                        method eventFromException

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

                                                        method eventFromMessage

                                                        eventFromMessage: (
                                                        message: string,
                                                        level?: Severity | SeverityLevel,
                                                        hint?: EventHint
                                                        ) => PromiseLike<Event>;
                                                        • Creates an Event from primitive inputs to captureMessage.

                                                        method flush

                                                        flush: (timeout?: number) => PromiseLike<boolean>;
                                                        • Wait for all events to be sent or the timeout to expire, whichever comes first.

                                                          Parameter timeout

                                                          Maximum time in ms the client should wait for events to be flushed. Omitting this parameter will cause the client to wait until all events are sent before resolving the promise.

                                                          Returns

                                                          A promise that will resolve with true if all events are sent before the timeout, or false if there are still events in the queue when the timeout is reached.

                                                        method getDsn

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

                                                        method getIntegration

                                                        getIntegration: <T extends Integration>(
                                                        integration: IntegrationClass<T>
                                                        ) => T | null;
                                                        • Returns the client's instance of the given integration class, it any.

                                                        method getOptions

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

                                                        method getSdkMetadata

                                                        getSdkMetadata: () => SdkMetadata | undefined;
                                                        • TODO (v8): Make this a required method.

                                                        method getTransport

                                                        getTransport: () => Transport | undefined;
                                                        • Returns the transport that is used by the client. Please note that the transport gets lazy initialized so it will only be there once the first event has been sent.

                                                          Returns

                                                          The transport.

                                                        method on

                                                        on: {
                                                        (
                                                        hook: 'startTransaction' | 'finishTransaction',
                                                        callback: (transaction: Transaction) => void
                                                        ): void;
                                                        (hook: 'beforeEnvelope', callback: (envelope: Envelope) => void): void;
                                                        (
                                                        hook: 'afterSendEvent',
                                                        callback: (
                                                        event: Event,
                                                        sendResponse: void | TransportMakeRequestResponse
                                                        ) => void
                                                        ): void;
                                                        (
                                                        hook: 'beforeAddBreadcrumb',
                                                        callback: (breadcrumb: Breadcrumb, hint?: BreadcrumbHint) => void
                                                        ): void;
                                                        (hook: 'createDsc', callback: (dsc: DynamicSamplingContext) => void): void;
                                                        };
                                                        • Register a callback for transaction start and finish.

                                                        • Register a callback for when an event has been sent.

                                                        • Register a callback before a breadcrumb is added.

                                                        • Register a callback whena DSC (Dynamic Sampling Context) is created.

                                                        method recordDroppedEvent

                                                        recordDroppedEvent: (
                                                        reason: EventDropReason,
                                                        dataCategory: DataCategory,
                                                        event?: Event
                                                        ) => void;
                                                        • Record on the client that an event got dropped (ie, an event that will not be sent to sentry).

                                                          Parameter reason

                                                          The reason why the event got dropped.

                                                          Parameter category

                                                          The data category of the dropped event.

                                                          Parameter event

                                                          The dropped event.

                                                        method sendEvent

                                                        sendEvent: (event: Event, hint?: EventHint) => void;
                                                        • Submits the event to Sentry

                                                        method sendSession

                                                        sendSession: (session: Session | SessionAggregates) => void;
                                                        • Submits the session to Sentry

                                                        method setupIntegrations

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

                                                        interface ClientOptions

                                                        interface ClientOptions<TO extends BaseTransportOptions = BaseTransportOptions> {}

                                                          property allowUrls

                                                          allowUrls?: Array<string | RegExp>;
                                                          • A pattern for error URLs which should exclusively be sent to Sentry. This is the opposite of Options.denyUrls. By default, all errors will be sent.

                                                            Requires the use of the InboundFilters integration.

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

                                                          property beforeSend

                                                          beforeSend?: (
                                                          event: ErrorEvent,
                                                          hint: EventHint
                                                          ) => PromiseLike<Event | null> | Event | null;
                                                          • An event-processing callback for error and message events, guaranteed to be invoked after all other event processors, which allows an event to be modified or dropped.

                                                            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

                                                            Event metadata useful for processing.

                                                            Returns

                                                            A new event that will be sent | null.

                                                          property beforeSendTransaction

                                                          beforeSendTransaction?: (
                                                          event: TransactionEvent,
                                                          hint: EventHint
                                                          ) => PromiseLike<Event | null> | Event | null;
                                                          • An event-processing callback for transaction events, guaranteed to be invoked after all other event processors. This allows an event to be modified or dropped before it's sent.

                                                            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

                                                            Event metadata useful for processing.

                                                            Returns

                                                            A new event that will be sent | null.

                                                          property debug

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

                                                          property denyUrls

                                                          denyUrls?: Array<string | RegExp>;
                                                          • A pattern for error URLs which should not be sent to Sentry. To allow certain errors instead, use Options.allowUrls. By default, all errors will be sent.

                                                            Requires the use of the InboundFilters 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 send events to Sentry. Defaults to true.

                                                          property enableTracing

                                                          enableTracing?: boolean;
                                                          • If this is enabled, transactions and trace data will be generated and captured. This will set the tracesSampleRate to the recommended default of 1.0 if tracesSampleRate is undefined. Note that tracesSampleRate and tracesSampler take precedence over this option.

                                                          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 ignoreTransactions

                                                          ignoreTransactions?: Array<string | RegExp>;
                                                          • A pattern for transaction names which should not be sent to Sentry. By default, all transactions will be sent.

                                                          property initialScope

                                                          initialScope?: CaptureContext;
                                                          • Initial data to populate scope.

                                                          property instrumenter

                                                          instrumenter?: Instrumenter;
                                                          • The instrumenter to use. Defaults to sentry. When not set to sentry, auto-instrumentation inside of Sentry will be disabled, in favor of using external auto instrumentation.

                                                            NOTE: Any option except for sentry is highly experimental and subject to change!

                                                          property integrations

                                                          integrations: Integration[];
                                                          • List of integrations that should be installed after SDK was initialized.

                                                          property maxBreadcrumbs

                                                          maxBreadcrumbs?: number;
                                                          • The maximum number of breadcrumbs sent with events. Defaults to 100. Sentry has a maximum payload size of 1MB and any events exceeding that payload size will be dropped.

                                                          property maxValueLength

                                                          maxValueLength?: number;
                                                          • Maximum 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 normalizeMaxBreadth

                                                          normalizeMaxBreadth?: number;
                                                          • Maximum number of properties or elements that the normalization algorithm will output in any single array or object included in the normalized event. Used when normalizing an event before sending, on all of the listed attributes: - breadcrumbs.data - user - contexts - extra Defaults to 1000

                                                          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.0 = 0% chance of a given event being sent (send no events) 1.0 = 100% chance of a given event being sent (send all events)

                                                          property sendClientReports

                                                          sendClientReports?: boolean;
                                                          • Send SDK Client Reports. By default, Client Reports are enabled.

                                                          property sendDefaultPii

                                                          sendDefaultPii?: boolean;
                                                          • Controls if potentially sensitive data should be sent to Sentry by default. Note that this only applies to data that the SDK is sending by default but not data that was explicitly set (e.g. by calling Sentry.setUser()).

                                                            Defaults to false.

                                                            NOTE: This option currently controls only a few data points in a selected set of SDKs. The goal for this option is to eventually control all sensitive data the SDK sets by default. However, this would be a breaking change so until the next major update this option only controls data points which were added in versions above 7.9.0.

                                                          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 stackParser

                                                          stackParser: StackParser;
                                                          • A stack parser implementation By default, a stack parser is supplied for all supported platforms

                                                          property 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.

                                                          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: (transportOptions: TO) => Transport;
                                                          • A function that takes transport options and returns the Transport object which is used to send events to Sentry. The function is invoked internally when the client is initialized.

                                                          property transportOptions

                                                          transportOptions?: Partial<TO>;
                                                          • Options for the default transport that the SDK uses.

                                                          property tunnel

                                                          tunnel?: string;
                                                          • A URL to an envelope tunnel endpoint. An envelope tunnel is an HTTP endpoint that accepts Sentry envelopes for forwarding. This can be used to force data through a custom server independent of the type of data.

                                                          interface Contexts

                                                          interface Contexts extends Record<string, Context | undefined> {}

                                                            property app

                                                            app?: AppContext;

                                                              property culture

                                                              culture?: CultureContext;

                                                                property device

                                                                device?: DeviceContext;

                                                                  property os

                                                                  os?: OsContext;

                                                                    property response

                                                                    response?: ResponseContext;

                                                                      interface CultureContext

                                                                      interface CultureContext extends Record<string, unknown> {}

                                                                        property calendar

                                                                        calendar?: string;

                                                                          property display_name

                                                                          display_name?: string;

                                                                            property is_24_hour_format

                                                                            is_24_hour_format?: boolean;

                                                                              property locale

                                                                              locale?: string;

                                                                                property timezone

                                                                                timezone?: string;

                                                                                  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 DebugMeta

                                                                                    interface DebugMeta {}
                                                                                    • Holds meta information to customize the behavior of Sentry's server-side event processing.

                                                                                    property images

                                                                                    images?: Array<DebugImage>;

                                                                                      interface DeviceContext

                                                                                      interface DeviceContext extends Record<string, unknown> {}

                                                                                        property arch

                                                                                        arch?: string;

                                                                                          property battery_level

                                                                                          battery_level?: number;

                                                                                            property battery_status

                                                                                            battery_status?: string;

                                                                                              property boot_time

                                                                                              boot_time?: string;

                                                                                                property brand

                                                                                                brand?: string;

                                                                                                  property charging

                                                                                                  charging?: boolean;

                                                                                                    property cpu_description

                                                                                                    cpu_description?: string;

                                                                                                      property device_type

                                                                                                      device_type?: string;

                                                                                                        property device_unique_identifier

                                                                                                        device_unique_identifier?: string;

                                                                                                          property external_free_storage

                                                                                                          external_free_storage?: number;

                                                                                                            property external_storage_size

                                                                                                            external_storage_size?: number;

                                                                                                              property family

                                                                                                              family?: string;

                                                                                                                property free_memory

                                                                                                                free_memory?: number;

                                                                                                                  property free_storage

                                                                                                                  free_storage?: number;

                                                                                                                    property low_memory

                                                                                                                    low_memory?: boolean;

                                                                                                                      property manufacturer

                                                                                                                      manufacturer?: string;

                                                                                                                        property memory_size

                                                                                                                        memory_size?: number;

                                                                                                                          property model

                                                                                                                          model?: string;

                                                                                                                            property model_id

                                                                                                                            model_id?: string;

                                                                                                                              property name

                                                                                                                              name?: string;

                                                                                                                                property online

                                                                                                                                online?: boolean;

                                                                                                                                  property orientation

                                                                                                                                  orientation?: 'portrait' | 'landscape';

                                                                                                                                    property processor_count

                                                                                                                                    processor_count?: number;

                                                                                                                                      property processor_frequency

                                                                                                                                      processor_frequency?: number;

                                                                                                                                        property screen_density

                                                                                                                                        screen_density?: number;

                                                                                                                                          property screen_dpi

                                                                                                                                          screen_dpi?: number;

                                                                                                                                            property screen_height_pixels

                                                                                                                                            screen_height_pixels?: number;

                                                                                                                                              property screen_resolution

                                                                                                                                              screen_resolution?: string;

                                                                                                                                                property screen_width_pixels

                                                                                                                                                screen_width_pixels?: number;

                                                                                                                                                  property simulator

                                                                                                                                                  simulator?: boolean;

                                                                                                                                                    property storage_size

                                                                                                                                                    storage_size?: number;

                                                                                                                                                      property supports_accelerometer

                                                                                                                                                      supports_accelerometer?: boolean;

                                                                                                                                                        property supports_audio

                                                                                                                                                        supports_audio?: boolean;

                                                                                                                                                          property supports_gyroscope

                                                                                                                                                          supports_gyroscope?: boolean;

                                                                                                                                                            property supports_location_service

                                                                                                                                                            supports_location_service?: boolean;

                                                                                                                                                              property supports_vibration

                                                                                                                                                              supports_vibration?: boolean;

                                                                                                                                                                property usable_memory

                                                                                                                                                                usable_memory?: number;

                                                                                                                                                                  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.

                                                                                                                                                                  interface ErrorEvent

                                                                                                                                                                  interface ErrorEvent extends Event {}

                                                                                                                                                                    property type

                                                                                                                                                                    type: undefined;

                                                                                                                                                                      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 | SeverityLevel;

                                                                                                                                                                                          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 sdkProcessingMetadata

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

                                                                                                                                                                                                            property server_name

                                                                                                                                                                                                            server_name?: string;

                                                                                                                                                                                                              property spans

                                                                                                                                                                                                              spans?: Span[];

                                                                                                                                                                                                                property start_timestamp

                                                                                                                                                                                                                start_timestamp?: number;

                                                                                                                                                                                                                  property tags

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

                                                                                                                                                                                                                    property threads

                                                                                                                                                                                                                    threads?: {
                                                                                                                                                                                                                    values: Thread[];
                                                                                                                                                                                                                    };

                                                                                                                                                                                                                      property timestamp

                                                                                                                                                                                                                      timestamp?: number;

                                                                                                                                                                                                                        property transaction

                                                                                                                                                                                                                        transaction?: string;

                                                                                                                                                                                                                          property transaction_info

                                                                                                                                                                                                                          transaction_info?: {
                                                                                                                                                                                                                          source: TransactionSource;
                                                                                                                                                                                                                          };

                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                            type?: EventType;

                                                                                                                                                                                                                              property user

                                                                                                                                                                                                                              user?: User;

                                                                                                                                                                                                                                interface EventHint

                                                                                                                                                                                                                                interface EventHint {}
                                                                                                                                                                                                                                • JSDoc

                                                                                                                                                                                                                                property attachments

                                                                                                                                                                                                                                attachments?: Attachment[];

                                                                                                                                                                                                                                  property captureContext

                                                                                                                                                                                                                                  captureContext?: CaptureContext;

                                                                                                                                                                                                                                    property data

                                                                                                                                                                                                                                    data?: any;

                                                                                                                                                                                                                                      property event_id

                                                                                                                                                                                                                                      event_id?: string;

                                                                                                                                                                                                                                        property integrations

                                                                                                                                                                                                                                        integrations?: string[];

                                                                                                                                                                                                                                          property originalException

                                                                                                                                                                                                                                          originalException?: unknown;

                                                                                                                                                                                                                                            property syntheticException

                                                                                                                                                                                                                                            syntheticException?: Error | null;

                                                                                                                                                                                                                                              interface EventProcessor

                                                                                                                                                                                                                                              interface EventProcessor {}
                                                                                                                                                                                                                                              • 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.

                                                                                                                                                                                                                                              property id

                                                                                                                                                                                                                                              id?: string;

                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                (event: Event, hint: EventHint): PromiseLike<Event | null> | Event | 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?: QueryParams;
                                                                                                                                                                                                                                                                • The request's query params

                                                                                                                                                                                                                                                                property url

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

                                                                                                                                                                                                                                                                index signature

                                                                                                                                                                                                                                                                [key: string]: any;

                                                                                                                                                                                                                                                                  interface FetchBreadcrumbData

                                                                                                                                                                                                                                                                  interface FetchBreadcrumbData {}

                                                                                                                                                                                                                                                                    property method

                                                                                                                                                                                                                                                                    method: string;

                                                                                                                                                                                                                                                                      property request_body_size

                                                                                                                                                                                                                                                                      request_body_size?: number;

                                                                                                                                                                                                                                                                        property response_body_size

                                                                                                                                                                                                                                                                        response_body_size?: number;

                                                                                                                                                                                                                                                                          property status_code

                                                                                                                                                                                                                                                                          status_code?: number;

                                                                                                                                                                                                                                                                            property url

                                                                                                                                                                                                                                                                            url: string;

                                                                                                                                                                                                                                                                              interface FetchBreadcrumbHint

                                                                                                                                                                                                                                                                              interface FetchBreadcrumbHint {}

                                                                                                                                                                                                                                                                                property data

                                                                                                                                                                                                                                                                                data?: unknown;

                                                                                                                                                                                                                                                                                  property endTimestamp

                                                                                                                                                                                                                                                                                  endTimestamp: number;

                                                                                                                                                                                                                                                                                    property input

                                                                                                                                                                                                                                                                                    input: any[];

                                                                                                                                                                                                                                                                                      property response

                                                                                                                                                                                                                                                                                      response?: unknown;

                                                                                                                                                                                                                                                                                        property startTimestamp

                                                                                                                                                                                                                                                                                        startTimestamp: number;

                                                                                                                                                                                                                                                                                          interface HandlerDataFetch

                                                                                                                                                                                                                                                                                          interface HandlerDataFetch {}

                                                                                                                                                                                                                                                                                            property args

                                                                                                                                                                                                                                                                                            args: any[];

                                                                                                                                                                                                                                                                                              property endTimestamp

                                                                                                                                                                                                                                                                                              endTimestamp?: number;

                                                                                                                                                                                                                                                                                                property fetchData

                                                                                                                                                                                                                                                                                                fetchData: SentryFetchData;

                                                                                                                                                                                                                                                                                                  property response

                                                                                                                                                                                                                                                                                                  response?: unknown;

                                                                                                                                                                                                                                                                                                    property startTimestamp

                                                                                                                                                                                                                                                                                                    startTimestamp: number;

                                                                                                                                                                                                                                                                                                      interface HandlerDataXhr

                                                                                                                                                                                                                                                                                                      interface HandlerDataXhr {}

                                                                                                                                                                                                                                                                                                        property args

                                                                                                                                                                                                                                                                                                        args: [string, string];

                                                                                                                                                                                                                                                                                                          property endTimestamp

                                                                                                                                                                                                                                                                                                          endTimestamp?: number;

                                                                                                                                                                                                                                                                                                            property startTimestamp

                                                                                                                                                                                                                                                                                                            startTimestamp?: number;

                                                                                                                                                                                                                                                                                                              property xhr

                                                                                                                                                                                                                                                                                                              xhr: SentryWrappedXMLHttpRequest;

                                                                                                                                                                                                                                                                                                                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 | SeverityLevel,
                                                                                                                                                                                                                                                                                                                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 duration 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 shouldSendDefaultPii

                                                                                                                                                                                                                                                                                                                shouldSendDefaultPii: () => boolean;
                                                                                                                                                                                                                                                                                                                • Returns if default PII should be sent to Sentry and propagated in ourgoing requests when Tracing is used.

                                                                                                                                                                                                                                                                                                                method startSession

                                                                                                                                                                                                                                                                                                                startSession: (context?: Session) => 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 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 InternalBaseTransportOptions

                                                                                                                                                                                                                                                                                                                  interface InternalBaseTransportOptions {}

                                                                                                                                                                                                                                                                                                                    property bufferSize

                                                                                                                                                                                                                                                                                                                    bufferSize?: number;

                                                                                                                                                                                                                                                                                                                      property recordDroppedEvent

                                                                                                                                                                                                                                                                                                                      recordDroppedEvent: Client['recordDroppedEvent'];

                                                                                                                                                                                                                                                                                                                        property textEncoder

                                                                                                                                                                                                                                                                                                                        textEncoder?: TextEncoderInternal;

                                                                                                                                                                                                                                                                                                                          interface Mechanism

                                                                                                                                                                                                                                                                                                                          interface Mechanism {}
                                                                                                                                                                                                                                                                                                                          • Metadata about a captured exception, intended to provide a hint as to the means by which it was captured.

                                                                                                                                                                                                                                                                                                                          property data

                                                                                                                                                                                                                                                                                                                          data?: {
                                                                                                                                                                                                                                                                                                                          [key: string]: string | boolean;
                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                          • Arbitrary data to be associated with the mechanism (for example, errors coming from event handlers include the handler name and the event target. Will show up in the UI directly above the stacktrace.

                                                                                                                                                                                                                                                                                                                          property handled

                                                                                                                                                                                                                                                                                                                          handled: boolean;
                                                                                                                                                                                                                                                                                                                          • In theory, whether or not the exception has been handled by the user. In practice, whether or not we see it before it hits the global error/rejection handlers, whether through explicit handling by the user or auto instrumentation. Converted to a tag on ingest and used in various ways in the UI.

                                                                                                                                                                                                                                                                                                                          property synthetic

                                                                                                                                                                                                                                                                                                                          synthetic?: boolean;
                                                                                                                                                                                                                                                                                                                          • True when captureException is called with anything other than an instance of Error (or, in the case of browser, an instance of ErrorEvent, DOMError, or DOMException). causing us to create a synthetic error in an attempt to recreate the stacktrace.

                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                          type: string;
                                                                                                                                                                                                                                                                                                                          • For now, restricted to onerror, onunhandledrejection (both obvious), instrument (the result of auto-instrumentation), and generic (everything else). Converted to a tag on ingest.

                                                                                                                                                                                                                                                                                                                          interface MonitorConfig

                                                                                                                                                                                                                                                                                                                          interface MonitorConfig {}

                                                                                                                                                                                                                                                                                                                            property checkinMargin

                                                                                                                                                                                                                                                                                                                            checkinMargin?: SerializedMonitorConfig['checkin_margin'];

                                                                                                                                                                                                                                                                                                                              property maxRuntime

                                                                                                                                                                                                                                                                                                                              maxRuntime?: SerializedMonitorConfig['max_runtime'];

                                                                                                                                                                                                                                                                                                                                property schedule

                                                                                                                                                                                                                                                                                                                                schedule: MonitorSchedule;

                                                                                                                                                                                                                                                                                                                                  property timezone

                                                                                                                                                                                                                                                                                                                                  timezone?: SerializedMonitorConfig['timezone'];

                                                                                                                                                                                                                                                                                                                                    interface Options

                                                                                                                                                                                                                                                                                                                                    interface Options<TO extends BaseTransportOptions = BaseTransportOptions>
                                                                                                                                                                                                                                                                                                                                    extends Omit<
                                                                                                                                                                                                                                                                                                                                    Partial<ClientOptions<TO>>,
                                                                                                                                                                                                                                                                                                                                    'integrations' | 'transport' | 'stackParser'
                                                                                                                                                                                                                                                                                                                                    > {}
                                                                                                                                                                                                                                                                                                                                    • Base configuration options for every SDK.

                                                                                                                                                                                                                                                                                                                                    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.

                                                                                                                                                                                                                                                                                                                                    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 stackParser

                                                                                                                                                                                                                                                                                                                                    stackParser?: StackParser | StackLineParser[];
                                                                                                                                                                                                                                                                                                                                    • A stack parser implementation or an array of stack line parsers By default, a stack parser is supplied for all supported browsers

                                                                                                                                                                                                                                                                                                                                    property transport

                                                                                                                                                                                                                                                                                                                                    transport?: (transportOptions: TO) => Transport;
                                                                                                                                                                                                                                                                                                                                    • A function that takes transport options and returns the Transport object which is used to send events to Sentry. The function is invoked internally during SDK initialization. By default, the SDK initializes its default transports.

                                                                                                                                                                                                                                                                                                                                    interface OsContext

                                                                                                                                                                                                                                                                                                                                    interface OsContext extends Record<string, unknown> {}

                                                                                                                                                                                                                                                                                                                                      property build

                                                                                                                                                                                                                                                                                                                                      build?: string;

                                                                                                                                                                                                                                                                                                                                        property kernel_version

                                                                                                                                                                                                                                                                                                                                        kernel_version?: string;

                                                                                                                                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                                                                                                                                          name?: string;

                                                                                                                                                                                                                                                                                                                                            property version

                                                                                                                                                                                                                                                                                                                                            version?: string;

                                                                                                                                                                                                                                                                                                                                              interface Package

                                                                                                                                                                                                                                                                                                                                              interface Package {}
                                                                                                                                                                                                                                                                                                                                              • JSDoc

                                                                                                                                                                                                                                                                                                                                              property dependencies

                                                                                                                                                                                                                                                                                                                                              dependencies?: Record<string, string>;

                                                                                                                                                                                                                                                                                                                                                property devDependencies

                                                                                                                                                                                                                                                                                                                                                devDependencies?: Record<string, string>;

                                                                                                                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                                                                                                                  name: string;

                                                                                                                                                                                                                                                                                                                                                    property version

                                                                                                                                                                                                                                                                                                                                                    version: string;

                                                                                                                                                                                                                                                                                                                                                      interface PolymorphicEvent

                                                                                                                                                                                                                                                                                                                                                      interface PolymorphicEvent {}
                                                                                                                                                                                                                                                                                                                                                      • Event-like interface that's usable in browser and node.

                                                                                                                                                                                                                                                                                                                                                        Note: Here we mean the kind of events handled by event listeners, not our Event type.

                                                                                                                                                                                                                                                                                                                                                        Property availability taken from https://developer.mozilla.org/en-US/docs/Web/API/Event#browser_compatibility

                                                                                                                                                                                                                                                                                                                                                      property currentTarget

                                                                                                                                                                                                                                                                                                                                                      readonly currentTarget?: unknown;

                                                                                                                                                                                                                                                                                                                                                        property target

                                                                                                                                                                                                                                                                                                                                                        readonly target?: unknown;

                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                          readonly type: string;

                                                                                                                                                                                                                                                                                                                                                            index signature

                                                                                                                                                                                                                                                                                                                                                            [key: string]: unknown;

                                                                                                                                                                                                                                                                                                                                                              interface ReplayEvent

                                                                                                                                                                                                                                                                                                                                                              interface ReplayEvent extends Event {}
                                                                                                                                                                                                                                                                                                                                                              • NOTE: These types are still considered Beta and subject to change.

                                                                                                                                                                                                                                                                                                                                                              property error_ids

                                                                                                                                                                                                                                                                                                                                                              error_ids: string[];

                                                                                                                                                                                                                                                                                                                                                                property replay_id

                                                                                                                                                                                                                                                                                                                                                                replay_id: string;

                                                                                                                                                                                                                                                                                                                                                                  property replay_start_timestamp

                                                                                                                                                                                                                                                                                                                                                                  replay_start_timestamp?: number;

                                                                                                                                                                                                                                                                                                                                                                    property replay_type

                                                                                                                                                                                                                                                                                                                                                                    replay_type: ReplayRecordingMode;

                                                                                                                                                                                                                                                                                                                                                                      property segment_id

                                                                                                                                                                                                                                                                                                                                                                      segment_id: number;

                                                                                                                                                                                                                                                                                                                                                                        property trace_ids

                                                                                                                                                                                                                                                                                                                                                                        trace_ids: string[];

                                                                                                                                                                                                                                                                                                                                                                          property urls

                                                                                                                                                                                                                                                                                                                                                                          urls: 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 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 is sent.

                                                                                                                                                                                                                                                                                                                                                                                                  method addAttachment

                                                                                                                                                                                                                                                                                                                                                                                                  addAttachment: (attachment: Attachment) => this;
                                                                                                                                                                                                                                                                                                                                                                                                  • Adds an attachment to the scope

                                                                                                                                                                                                                                                                                                                                                                                                    Parameter attachment

                                                                                                                                                                                                                                                                                                                                                                                                    Attachment options

                                                                                                                                                                                                                                                                                                                                                                                                  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 clearAttachments

                                                                                                                                                                                                                                                                                                                                                                                                  clearAttachments: () => this;
                                                                                                                                                                                                                                                                                                                                                                                                  • Clears attachments from the scope

                                                                                                                                                                                                                                                                                                                                                                                                  method clearBreadcrumbs

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

                                                                                                                                                                                                                                                                                                                                                                                                  method getAttachments

                                                                                                                                                                                                                                                                                                                                                                                                  getAttachments: () => Attachment[];
                                                                                                                                                                                                                                                                                                                                                                                                  • Returns an array of attachments on the scope

                                                                                                                                                                                                                                                                                                                                                                                                  method getLastBreadcrumb

                                                                                                                                                                                                                                                                                                                                                                                                  getLastBreadcrumb: () => Breadcrumb | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                  • Get the last breadcrumb.

                                                                                                                                                                                                                                                                                                                                                                                                  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 | SeverityLevel) => this;
                                                                                                                                                                                                                                                                                                                                                                                                  • Sets the level on the scope for future events.

                                                                                                                                                                                                                                                                                                                                                                                                    Parameter level

                                                                                                                                                                                                                                                                                                                                                                                                    string SeverityLevel

                                                                                                                                                                                                                                                                                                                                                                                                  method setRequestSession

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

                                                                                                                                                                                                                                                                                                                                                                                                  method setSDKProcessingMetadata

                                                                                                                                                                                                                                                                                                                                                                                                  setSDKProcessingMetadata: (newData: { [key: string]: unknown }) => this;
                                                                                                                                                                                                                                                                                                                                                                                                  • Add data which will be accessible during event processing but won't get sent to Sentry

                                                                                                                                                                                                                                                                                                                                                                                                  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 | SeverityLevel;

                                                                                                                                                                                                                                                                                                                                                                                                          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 SentryWrappedXMLHttpRequest

                                                                                                                                                                                                                                                                                                                                                                                                                              interface SentryWrappedXMLHttpRequest {}

                                                                                                                                                                                                                                                                                                                                                                                                                                interface SentryXhrData

                                                                                                                                                                                                                                                                                                                                                                                                                                interface SentryXhrData {}

                                                                                                                                                                                                                                                                                                                                                                                                                                  property body

                                                                                                                                                                                                                                                                                                                                                                                                                                  body?: XHRSendInput;

                                                                                                                                                                                                                                                                                                                                                                                                                                    property method

                                                                                                                                                                                                                                                                                                                                                                                                                                    method?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property request_body_size

                                                                                                                                                                                                                                                                                                                                                                                                                                      request_body_size?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property request_headers

                                                                                                                                                                                                                                                                                                                                                                                                                                        request_headers: Record<string, string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                          property response_body_size

                                                                                                                                                                                                                                                                                                                                                                                                                                          response_body_size?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property status_code

                                                                                                                                                                                                                                                                                                                                                                                                                                            status_code?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property url

                                                                                                                                                                                                                                                                                                                                                                                                                                              url?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SerializedCheckIn

                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SerializedCheckIn {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property check_in_id

                                                                                                                                                                                                                                                                                                                                                                                                                                                  check_in_id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property duration

                                                                                                                                                                                                                                                                                                                                                                                                                                                    duration?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property environment

                                                                                                                                                                                                                                                                                                                                                                                                                                                      environment?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property monitor_config

                                                                                                                                                                                                                                                                                                                                                                                                                                                        monitor_config?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                        schedule: MonitorSchedule;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        checkin_margin?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        max_runtime?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        timezone?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property monitor_slug

                                                                                                                                                                                                                                                                                                                                                                                                                                                          monitor_slug: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property release

                                                                                                                                                                                                                                                                                                                                                                                                                                                            release?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property status

                                                                                                                                                                                                                                                                                                                                                                                                                                                              status: 'in_progress' | 'ok' | 'error';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SerializedSession

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SerializedSession {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property attrs

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property did

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    did?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property duration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      duration?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property errors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        errors: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property init

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          init: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property sid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            sid: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property started

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              started: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property status

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                status: SessionStatus;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property timestamp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  timestamp: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Session {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method toJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  toJSON: () => SerializedSession;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Overrides default JSON serialization of the Session because the Sentry servers expect a slightly different schema of a session which is described in the interface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • SerializedSession in this file.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      a Sentry-backend conforming JSON object of the session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SessionAggregates

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SessionAggregates {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • JSDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property aggregates

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  aggregates: Array<AggregationCounts>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property attrs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    attrs?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    environment?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    release?: 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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Span

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property data

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property instrumenter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        instrumenter: Instrumenter;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • The instrumenter that created this span.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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 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, '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 instrumenter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        instrumenter?: Instrumenter;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • The instrumenter that created this span.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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 debug_id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                debug_id?: 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 TextEncoderInternal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface TextEncoderInternal extends TextEncoderCommon {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method encode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            encode: (input?: string) => Uint8Array;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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 TraceContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TraceContext extends Record<string, unknown> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property data

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            description?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property op

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              op?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property parent_span_id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                parent_span_id?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property span_id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  span_id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property status

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    status?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property tags

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property trace_id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        trace_id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface Transaction

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property data

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property instrumenter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          instrumenter: Instrumenter;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • The instrumenter that created this transaction.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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 getDynamicSamplingContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getDynamicSamplingContext: () => Partial<DynamicSamplingContext>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Return the current Dynamic Sampling Context of this transaction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method setContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          setContext: (key: string, context: Context) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Set the context of a transaction event

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method setMeasurement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          setMeasurement: (name: string, value: number, unit: MeasurementUnit) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Set observed measurement for this transaction.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Name of the measurement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Value of the measurement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter unit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Unit of the measurement. (Defaults to an empty string)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method setMetadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          setMetadata: (newMetadata: Partial<TransactionMetadata>) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Set metadata for this transaction.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method setName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          setName: (name: string, source?: TransactionMetadata['source']) => 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?: Partial<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 TransactionEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface TransactionEvent extends Event {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: 'transaction';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface TransactionMetadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface TransactionMetadata {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property dynamicSamplingContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                dynamicSamplingContext?: Partial<DynamicSamplingContext>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • The Dynamic Sampling Context of a transaction. If provided during transaction creation, its Dynamic Sampling Context Will be frozen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property request

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                request?: PolymorphicRequest;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • For transactions tracing server-side request handling, the request being tracked.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property requestDataOptionsFromExpressHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                requestDataOptionsFromExpressHandler?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [key: string]: unknown;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Compatibility shim for transitioning to the RequestData integration. The options passed to our Express request handler controlling what request data is added to the event. TODO (v8): This should go away

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property requestPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                requestPath?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • TODO: If we rm -rf instrumentServer, this can go, too

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property sampleRate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                sampleRate?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • The sample rate used when sampling this transaction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property source

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                source: TransactionSource;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Information on how a transaction name was generated.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property spanMetadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                spanMetadata: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [spanId: string]: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [key: string]: unknown;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Metadata for the transaction's spans, keyed by spanId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Transport

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Transport {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method flush

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  flush: (timeout?: number) => PromiseLike<boolean>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method send

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    send: (request: Envelope) => PromiseLike<void | TransportMakeRequestResponse>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface User

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface User {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • JSDoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property email

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      email?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        id?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property ip_address

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ip_address?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property segment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            segment?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property username

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              username?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface UserFeedback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface UserFeedback {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property comments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    comments: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property email

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      email: User['email'];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property event_id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        event_id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface XhrBreadcrumbData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface XhrBreadcrumbData {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property request_body_size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  request_body_size?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property response_body_size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    response_body_size?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property status_code

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      status_code?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property url

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        url?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface XhrBreadcrumbHint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface XhrBreadcrumbHint {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property endTimestamp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            endTimestamp: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property input

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              input: unknown;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property startTimestamp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                startTimestamp: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property xhr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  xhr: unknown;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Enums

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    enum Severity

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Please use a SeverityLevel string instead of the Severity enum. Acceptable values are 'fatal', 'error', 'warning', 'log', 'info', and 'debug'.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type AttachmentItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type AttachmentItem = BaseEnvelopeItem<AttachmentItemHeaders, string | Uint8Array>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type BaseEnvelopeHeaders

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type BaseEnvelopeHeaders = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [key: string]: unknown;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      dsn?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      sdk?: SdkInfo;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type BaseEnvelopeItemHeaders

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type BaseEnvelopeItemHeaders = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [key: string]: unknown;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: EnvelopeItemType;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        length?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type BrowserClientReplayOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type BrowserClientReplayOptions = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * The sample rate for session-long replays.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * 1.0 will record all sessions and 0 will record none.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          replaysSessionSampleRate?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * The sample rate for sessions that has had an error occur.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * This is independent of `sessionSampleRate`.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * 1.0 will record all sessions and 0 will record none.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          replaysOnErrorSampleRate?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Options added to the Browser SDK's init options that are specific for Replay. Note: This type was moved to @sentry/types to avoid a circular dependency between Browser and Replay.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CaptureContext

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CheckIn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CheckIn = InProgressCheckIn | FinishedCheckIn;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CheckInEvelope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CheckInEvelope = BaseEnvelope<CheckInEnvelopeHeaders, CheckInItem>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CheckInItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CheckInItem = BaseEnvelopeItem<CheckInItemHeaders, SerializedCheckIn>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ClientReport

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ClientReport = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                timestamp: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                discarded_events: Outcome[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ClientReportEnvelope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ClientReportEnvelope = BaseEnvelope<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ClientReportEnvelopeHeaders,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ClientReportItem
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ClientReportItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ClientReportItem = BaseEnvelopeItem<ClientReportItemHeaders, ClientReport>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Context = Record<string, unknown>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DataCategory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type DataCategory =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'default'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'error'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'transaction'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'replay'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'security'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'attachment'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'session'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'internal'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'profile'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'monitor';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DebugImage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type DebugImage = WasmDebugImage | SourceMapDebugImage;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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 DurationUnit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DurationUnit =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'nanosecond'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'microsecond'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'millisecond'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'second'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'minute'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'hour'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'day'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'week';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • A time duration.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DynamicSamplingContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DynamicSamplingContext = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            trace_id: Transaction['traceId'];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            public_key: DsnComponents['publicKey'];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            sample_rate?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            release?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            environment?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            transaction?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            user_segment?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            replay_id?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Envelope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Envelope =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | EventEnvelope
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | SessionEnvelope
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | ClientReportEnvelope
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | ReplayEnvelope
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | CheckInEvelope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type EnvelopeItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type EnvelopeItem = Envelope[1][number];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type EnvelopeItemType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type EnvelopeItemType =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'client_report'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'user_report'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'session'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'sessions'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'transaction'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'attachment'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'event'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'profile'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'replay_event'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'replay_recording'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'check_in';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type EventDropReason

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type EventDropReason =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'before_send'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'event_processor'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'network_error'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'queue_overflow'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'ratelimit_backoff'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'sample_rate'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'send_error'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'internal_sdk_error';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type EventEnvelope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type EventEnvelope = BaseEnvelope<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      EventEnvelopeHeaders,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      EventItem | AttachmentItem | UserFeedbackItem
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type EventEnvelopeHeaders

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type EventEnvelopeHeaders = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        event_id: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sent_at: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        trace?: DynamicSamplingContext;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type EventItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type EventItem = BaseEnvelopeItem<EventItemHeaders, Event>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type EventType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type EventType = 'transaction' | 'profile' | 'replay_event' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • The type of an Event. Note that ErrorEvents do not have a type (hence its undefined), while all other events are required to have one.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Extra

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Extra = unknown;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Extras

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Extras = Record<string, Extra>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type FractionUnit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type FractionUnit = 'ratio' | 'percent';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Fractions such as percentages.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type HttpHeaderValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type HttpHeaderValue = string | string[] | number | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type InformationUnit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type InformationUnit =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'bit'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'byte'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'kilobyte'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'kibibyte'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'megabyte'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'mebibyte'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'gigabyte'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'terabyte'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'tebibyte'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'petabyte'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'exabyte'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'exbibyte';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Size of information derived from bytes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Instrumenter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Instrumenter = 'sentry' | 'otel';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Measurements

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type MeasurementUnit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type MeasurementUnit = LiteralUnion<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      DurationUnit | InformationUnit | FractionUnit | NoneUnit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type NoneUnit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type NoneUnit = '' | 'none';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Untyped value without a unit.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Outcome

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Outcome = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        reason: EventDropReason;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        category: DataCategory;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        quantity: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type PolymorphicRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type PolymorphicRequest = BaseRequest &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          BrowserRequest &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NodeRequest &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ExpressRequest &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          KoaRequest &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NextjsRequest;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • A Request type compatible with Node, Express, browser, etc., because everything is optional

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type