@sentry/types

property crashed

crashed?: number;

property errored

errored?: number;

property exited

exited?: number;

property started

started: string;

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;

property attachmentType

attachmentType?: AttachmentType;

• The type of the attachment. Defaults to event.attachment if not specified.

property contentType

contentType?: string;

property data

data: string | Uint8Array;

property filename

filename: string;

property url

url: string;

property category

category?: string;

property data

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

property event_id

event_id?: string;

property level

level?: Severity | SeverityLevel;

property message

message?: string;

property timestamp

timestamp?: number;

property type

type?: string;

index signature

[key: string]: any;

method addEventProcessor

addEventProcessor: (eventProcessor: EventProcessor) => void;

• Adds an event processor that applies to any event processed by this client.

  TODO (v8): Make this a required method.

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 captureAggregateMetrics

captureAggregateMetrics: (metricBucketItems: Array<MetricBucketItem>) => void;

• Captures serialized metrics and sends them to Sentry.

  This API is experimental and might experience breaking changes

  Modifiers

  • @experimental

method captureCheckIn

captureCheckIn: (
    checkIn: CheckIn,
    monitorConfig?: MonitorConfig,
    scope?: Scope
) => 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.

  Parameter scope

  An optional scope containing event metadata.

  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', transaction: Transaction): void;
    (hook: 'finishTransaction', transaction: Transaction): void;
    (hook: 'beforeEnvelope', envelope: Envelope): void;
    (hook: 'beforeSendEvent', event: Event, hint?: EventHint): void;
    (hook: 'preprocessEvent', event: Event, hint?: EventHint): void;
    (
        hook: 'afterSendEvent',
        event: Event,
        sendResponse: void | TransportMakeRequestResponse
    ): void;
    (
        hook: 'beforeAddBreadcrumb',
        breadcrumb: Breadcrumb,
        hint?: BreadcrumbHint
    ): void;
    (hook: 'createDsc', dsc: DynamicSamplingContext): void;
    (
        hook: 'otelSpanEnd',
        otelSpan: unknown,
        mutableOptions: { drop: boolean }
    ): void;
    (
        hook: 'beforeSendFeedback',
        feedback: FeedbackEvent,
        options?: { includeReplay?: boolean }
    ): void;
    (hook: 'startPageLoadSpan', options: StartSpanOptions): void;
    (hook: 'startNavigationSpan', options: StartSpanOptions): void;
};

• Fire a hook event for transaction start. Expects to be given a transaction as the second argument.

• Fire a hook event for transaction finish. Expects to be given a transaction as the second argument.

• Fire a hook event before sending an event. This is called right before an event is sent and should not be used to mutate the event. Expects to be given an Event & EventHint as the second/third argument.

• Fire a hook event to process events before they are passed to (global) event processors. Expects to be given an Event & EventHint as the second/third 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.

• Fire a hook for when an OpenTelemetry span is ended (in @sentry/opentelemetry-node). Expects the OTEL span & as second argument, and an option object as third argument. The option argument may be mutated to drop the span.

• Fire a hook event for after preparing a feedback event. Events to be given a feedback event as the second argument, and an optional options object as third argument.

• Emit a hook event for BrowserTracing to trigger a span start for a page load.

• Emit a hook event for BrowserTracing to trigger a span for a navigation.

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: ParameterizedString,
    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 getEventProcessors

getEventProcessors: () => EventProcessor[];

• Get all added event processors for this client.

  TODO (v8): Make this a required method.

method getIntegration

getIntegration: <T extends Integration>(
    integration: IntegrationClass<T>
) => T | null;

• Returns the client's instance of the given integration class, it any.

  Deprecated

  Use getIntegrationByName() instead.

method getIntegrationByName

getIntegrationByName: <T extends Integration = Integration>(
    name: string
) => T | undefined;

• Get the instance of the integration with the given name on the client, if it was added.

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 init

init: () => void;

• Initialize this client. Call this after the client was set on a scope.

method on

on: {
    (
        hook: 'startTransaction',
        callback: (transaction: Transaction) => void
    ): void;
    (
        hook: 'finishTransaction',
        callback: (transaction: Transaction) => void
    ): void;
    (hook: 'beforeEnvelope', callback: (envelope: Envelope) => void): void;
    (
        hook: 'beforeSendEvent',
        callback: (event: Event, hint?: EventHint) => void
    ): void;
    (
        hook: 'preprocessEvent',
        callback: (event: Event, hint?: EventHint) => 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;
    (
        hook: 'otelSpanEnd',
        callback: (otelSpan: unknown, mutableOptions: { drop: boolean }) => void
    ): void;
    (
        hook: 'beforeSendFeedback',
        callback: (
            feedback: FeedbackEvent,
            options?: { includeReplay?: boolean }
        ) => void
    ): void;
    (
        hook: 'startPageLoadSpan',
        callback: (options: StartSpanOptions) => void
    ): void;
    (
        hook: 'startNavigationSpan',
        callback: (options: StartSpanOptions) => void
    ): void;
};

• Register a callback for transaction start. Receives the transaction as argument.

• Register a callback for transaction finish. Receives the transaction as argument.

• Register a callback for transaction start and finish.

• Register a callback for before sending an event. This is called right before an event is sent and should not be used to mutate the event. Receives an Event & EventHint as arguments.

• Register a callback for preprocessing an event, before it is passed to (global) event processors. Receives an Event & EventHint as arguments.

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

• Register a callback before a breadcrumb is added.

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

• Register a callback when an OpenTelemetry span is ended (in @sentry/opentelemetry-node). The option argument may be mutated to drop the span.

• Register a callback when a Feedback event has been prepared. This should be used to mutate the event. The options argument can hint about what kind of mutation it expects.

• A hook for BrowserTracing to trigger a span start for a page load.

• A hook for BrowserTracing to trigger a span for a navigation.

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: (forceInitialize?: boolean) => void;

• This is an internal function to setup all integrations that should run on the client.

  Deprecated

  Use client.init() instead.

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 tracePropagationTargets

tracePropagationTargets?: TracePropagationTargets;

• List of strings/regex controlling to which outgoing requests the SDK will attach tracing headers.

  By default the SDK will attach those headers to all requests to localhost and same origin. If this option is provided, the SDK will match the request URL of outgoing requests against the items in this array, and only attach tracing headers if a match was found.

  Example 1

  Sentry.init({
    tracePropagationTargets: ['api.site.com'],
  });

  Default: ['localhost', /^//]

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.

property ['cloud.account.id']

['cloud.account.id']?: string;

property ['cloud.availability_zone']

['cloud.availability_zone']?: string;

property ['cloud.platform']

['cloud.platform']?: string;

property ['cloud.provider']

['cloud.provider']?: string;

property ['cloud.region']

['cloud.region']?: string;

property ['host.id']

['host.id']?: string;

property ['host.type']

['host.type']?: string;

property app

app?: AppContext;

property cloud_resource

cloud_resource?: CloudResourceContext;

property culture

culture?: CultureContext;

property device

device?: DeviceContext;

property os

os?: OsContext;

property response

response?: ResponseContext;

property state

state?: StateContext;

property trace

trace?: TraceContext;

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;

index signature

[key: string]: any;

property images

images?: Array<DebugImage>;

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;

property host

host: string;

• Hostname of the Sentry instance.

property pass

pass?: string;

• Private authorization key (deprecated, optional).

property path

path?: string;

• Sub path/

property port

port?: string;

• Port of the Sentry instance.

property projectId

projectId: string;

• Project ID

property protocol

protocol: DsnProtocol;

• Protocol used to connect to Sentry.

property publicKey

publicKey?: string;

• Public authorization key.

property type

type: undefined;

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 logentry

logentry?: {
    message?: string;
    params?: string[];
};

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;

property attachments

attachments?: Attachment[];

property captureContext

captureContext?: CaptureContext;

property data

data?: any;