@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 free_memory

free_memory?: number;

property attachmentType

attachmentType?: AttachmentType;

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

property contentType

contentType?: string;

• The content type of the attachment payload. Defaults to application/octet-stream if not specified.

  Any valid [media type](https://www.iana.org/assignments/media-types/media-types.xhtml) is allowed.

property data

data: string | Uint8Array;

• The attachment data. Can be a string or a binary data (byte array)

property filename

filename: string;

• The name of the uploaded file without a path component

property url

url: string;

property category

category?: string;

• Typically it is a module name or a descriptive string. For instance, ui.click could be used to indicate that a click happened in the UI or flask could be used to indicate that the event originated in the Flask framework. Internally we render some crumbs' color and icon based on the provided category. For more information, see the description of recognized breadcrumb types. A dotted string indicating what the crumb is or from where it comes. https://develop.sentry.dev/sdk/event-payloads/breadcrumbs/#breadcrumb-types

property data

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

• Contains a dictionary whose contents depend on the breadcrumb type. Additional parameters that are unsupported by the type are rendered as a key/value table.

  Arbitrary data associated with this breadcrumb.

property event_id

event_id?: string;

property level

level?: SeverityLevel;

• Allowed values are, from highest to lowest: fatal, error, warning, info, and debug. Levels are used in the UI to emphasize and deemphasize the crumb. The default is info.

  This defines the severity level of the breadcrumb.

property message

message?: string;

• If a message is provided, it is rendered as text with all whitespace preserved.

  Human-readable message for the breadcrumb.

property timestamp

timestamp?: number;

• The format is a numeric (integer or float) value representing the number of seconds that have elapsed since the Unixepoch. Breadcrumbs are most useful when they include a timestamp, as it creates a timeline leading up to an event expection/error.

  The API supports a string as defined in RFC 3339, but the SDKs only support a numeric value for now.

  A timestamp representing when the breadcrumb occurred. https://develop.sentry.dev/sdk/event-payloads/breadcrumbs/#:~:text=is%20info.-,timestamp,-(recommended)

property type

type?: string;

• By default, all breadcrumbs are recorded as default, which makes them appear as a Debug entry, but Sentry provides other types that influence how the breadcrumbs are rendered. For more information, see the description of recognized breadcrumb types.

  The type of breadcrumb. https://develop.sentry.dev/sdk/event-payloads/breadcrumbs/#breadcrumb-types

index signature

[key: string]: any;

method addEventProcessor

addEventProcessor: (eventProcessor: EventProcessor) => void;

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

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.

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, currentScope?: Scope) => string;

• Captures a manually created event and sends it to Sentry.

  Unlike captureEvent exported from every SDK, this method requires that you pass it the current scope.

  Parameter event

  The event to send to Sentry.

  Parameter hint

  May contain additional information about the original exception.

  Parameter currentScope

  An optional scope containing event metadata.

  Returns

  The event id

method captureException

captureException: (
    exception: any,
    hint?: EventHint,
    currentScope?: Scope
) => string;

• Captures an exception event and sends it to Sentry.

  Unlike captureException exported from every SDK, this method requires that you pass it the current scope.

  Parameter exception

  An exception-like object.

  Parameter hint

  May contain additional information about the original exception.

  Parameter currentScope

  An optional scope containing event metadata.

  Returns

  The event id

method captureMessage

captureMessage: (
    message: string,
    level?: SeverityLevel,
    hint?: EventHint,
    currentScope?: Scope
) => string;

• Captures a message event and sends it to Sentry.

  Unlike captureMessage exported from every SDK, this method requires that you pass it the current scope.

  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 currentScope

  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: 'spanStart', span: Span): void;
    (
        hook: 'beforeSampling',
        samplingData: {
            spanAttributes: SpanAttributes;
            spanName: string;
            parentSampled?: boolean;
            parentContext?: SpanContextData;
        },
        samplingDecision: { decision: boolean }
    ): void;
    (hook: 'spanEnd', span: Span): void;
    (hook: 'idleSpanEnableAutoFinish', span: Span): void;
    (hook: 'beforeEnvelope', envelope: Envelope): void;
    (hook: 'applyFrameMetadata', event: Event): void;
    (hook: 'beforeSendEvent', event: Event, hint?: EventHint): void;
    (hook: 'preprocessEvent', event: Event, hint?: EventHint): void;
    (
        hook: 'afterSendEvent',
        event: Event,
        sendResponse: TransportMakeRequestResponse
    ): void;
    (
        hook: 'beforeAddBreadcrumb',
        breadcrumb: Breadcrumb,
        hint?: BreadcrumbHint
    ): void;
    (hook: 'createDsc', dsc: DynamicSamplingContext, rootSpan?: Span): void;
    (
        hook: 'beforeSendFeedback',
        feedback: FeedbackEvent,
        options?: { includeReplay?: boolean }
    ): void;
    (
        hook: 'startPageLoadSpan',
        options: StartSpanOptions,
        traceOptions?: { sentryTrace?: string; baggage?: string }
    ): void;
    (hook: 'startNavigationSpan', options: StartSpanOptions): void;
    (hook: 'flush'): void;
    (hook: 'close'): void;
};

• Fire a hook whenever a span starts.

• A hook that is called every time before a span is sampled.

• Fire a hook whenever a span ends.

• Fire a hook indicating that an idle span is allowed to auto finish.

• 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 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 browser tracing integrations to trigger a span start for a page load.

• Emit a hook event for browser tracing integrations to trigger a span for a navigation.

• Emit a hook event for client flush

• Emit a hook event for client close

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

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;

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: 'spanStart', callback: (span: Span) => void): () => void;
    (
        hook: 'beforeSampling',
        callback: (
            samplingData: {
                spanAttributes: SpanAttributes;
                spanName: string;
                parentSampled?: boolean;
                parentContext?: SpanContextData;
            },
            samplingDecision: { decision: boolean }
        ) => void
    ): void;
    (hook: 'spanEnd', callback: (span: Span) => void): () => void;
    (
        hook: 'idleSpanEnableAutoFinish',
        callback: (span: Span) => void
    ): () => void;
    (hook: 'beforeEnvelope', callback: (envelope: Envelope) => void): () => void;
    (hook: 'applyFrameMetadata', callback: (event: Event) => 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: TransportMakeRequestResponse
        ) => void
    ): () => void;
    (
        hook: 'beforeAddBreadcrumb',
        callback: (breadcrumb: Breadcrumb, hint?: BreadcrumbHint) => void
    ): () => void;
    (
        hook: 'createDsc',
        callback: (dsc: DynamicSamplingContext, rootSpan?: Span) => void
    ): () => void;
    (
        hook: 'beforeSendFeedback',
        callback: (
            feedback: FeedbackEvent,
            options?: { includeReplay?: boolean }
        ) => void
    ): () => void;
    (
        hook: 'startPageLoadSpan',
        callback: (
            options: StartSpanOptions,
            traceOptions?: { sentryTrace?: string; baggage?: string }
        ) => void
    ): () => void;
    (
        hook: 'startNavigationSpan',
        callback: (options: StartSpanOptions) => void
    ): () => void;
    (hook: 'flush', callback: () => void): () => void;
    (hook: 'close', callback: () => void): () => void;
};

• Register a callback for whenever a span is started. Receives the span as argument.

  Returns

  A function that, when executed, removes the registered callback.

• Register a callback before span sampling runs. Receives a samplingDecision object argument with a decision property that can be used to make a sampling decision that will be enforced, before any span sampling runs.

  Returns

  A function that, when executed, removes the registered callback.

• Register a callback for whenever a span is ended. Receives the span as argument.

  Returns

  A function that, when executed, removes the registered callback.

• Register a callback for when an idle span is allowed to auto-finish.

  Returns

  A function that, when executed, removes the registered callback.

• Register a callback for transaction start and finish.

  Returns

  A function that, when executed, removes the registered callback.

• Register a callback that runs when stack frame metadata should be applied to an event.

  Returns

  A function that, when executed, removes the registered callback.

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

  Returns

  A function that, when executed, removes the registered callback.

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

  Returns

  A function that, when executed, removes the registered callback.

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

  Returns

  A function that, when executed, removes the registered callback.

• Register a callback before a breadcrumb is added.

  Returns

  A function that, when executed, removes the registered callback.

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

  Returns

  A function that, when executed, removes the registered callback.

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

  Returns

  A function that, when executed, removes the registered callback.

• A hook for the browser tracing integrations to trigger a span start for a page load.

  Returns

  A function that, when executed, removes the registered callback.

• A hook for browser tracing integrations to trigger a span for a navigation.

  Returns

  A function that, when executed, removes the registered callback.

• A hook that is called when the client is flushing

  Returns

  A function that, when executed, removes the registered callback.

• A hook that is called when the client is closing

  Returns

  A function that, when executed, removes the registered callback.

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 sendEnvelope

sendEnvelope: (envelope: Envelope) => PromiseLike<TransportMakeRequestResponse>;

• Sends an envelope to Sentry

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

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<ErrorEvent | null> | ErrorEvent | 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 beforeSendSpan

beforeSendSpan?: (span: SpanJSON) => SpanJSON | null;

• This function can be defined to modify or entirely drop a child span before it's sent. Returning null will cause this span to be dropped.

  Note that this function is only called for child spans and not for the root span (formerly known as transaction). If you want to modify or drop the root span, use Options.beforeSendTransaction instead.

  Parameter span

  The span generated by the SDK.

  Returns

  A new span that will be sent or null if the span should not be sent.

property beforeSendTransaction

beforeSendTransaction?: (
    event: TransactionEvent,
    hint: EventHint
) => PromiseLike<TransactionEvent | null> | TransactionEvent | 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, spans 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.

  Deprecated

  This option is deprecated and will be removed in the next major version. If you want to enable performance monitoring, please use the tracesSampleRate or tracesSampler options instead. If you wan't to disable performance monitoring, remove the tracesSampler and tracesSampleRate options.

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

parentSpanIsAlwaysRootSpan?: boolean;

• If this is enabled, any spans started will always have their parent be the active root span, if there is any active span.

  This is necessary because in some environments (e.g. browser), we cannot guarantee an accurate active span. Because we cannot properly isolate execution environments, you may get wrong results when using e.g. nested startSpan() calls.

  To solve this, in these environments we'll by default enable this option.

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. When calling Sentry.init(), this option defaults to true.

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 and/or Regular Expressions used to determine which outgoing requests will have sentry-trace and baggage headers attached.

  **Default:** If this option is not provided, tracing headers will be attached to all outgoing requests. If you are using a browser SDK, by default, tracing headers will only be attached to outgoing requests to the same origin.

  **Disclaimer:** Carelessly setting this option in browser environments may result into CORS errors! Only attach tracing headers to requests to the same origin, or to requests to services you can control CORS headers of. Cross-origin requests, meaning requests to a different domain, for example a request to https://api.example.com/ while you're on https://example.com/, take special care. If you are attaching headers to cross-origin requests, make sure the backend handling the request returns a "Access-Control-Allow-Headers: sentry-trace, baggage" header to ensure your requests aren't blocked.

  If you provide a tracePropagationTargets array, the entries you provide will be matched against the entire URL of the outgoing request. If you are using a browser SDK, the entries will also be matched against the pathname of the outgoing requests. This is so you can have matchers for relative requests, for example, /^\/api/ if you want to trace requests to your /api routes on the same domain.

  If any of the two match any of the provided values, tracing headers will be attached to the outgoing request. Both, the string values, and the RegExes you provide in the array will match if they partially match the URL or pathname.

  Examples: - tracePropagationTargets: [/^\/api/] and request to https://same-origin.com/api/posts: - Tracing headers will be attached because the request is sent to the same origin and the regex matches the pathname "/api/posts". - tracePropagationTargets: [/^\/api/] and request to https://different-origin.com/api/posts: - Tracing headers will not be attached because the pathname will only be compared when the request target lives on the same origin. - tracePropagationTargets: [/^\/api/, 'https://external-api.com'] and request to https://external-api.com/v1/data: - Tracing headers will be attached because the request URL matches the string 'https://external-api.com'.

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 profile

profile?: ProfileContext;

property response

response?: ResponseContext;

property state

state?: StateContext;

property trace

trace?: TraceContext;

method initialize

initialize: (client: T) => void;

method start

start: () => void;

method stop

stop: () => void;

property frames

frames: ThreadCpuFrame[];

property queue_metadata

queue_metadata?: Record<
    string,
    {
        label: string;
    }
>;

property samples

samples: ContinuousThreadCpuSample[];

property stacks

stacks: ThreadCpuStack[];

property thread_metadata

thread_metadata: Record<
    ThreadId,
    {
        name?: string;
        priority?: number;
    }
>;

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