@sentry/core

@sentry/core

Version 11.0.0
Published 5 hours ago
4.88 MB
1 dependency
MIT license

Install

npm i @sentry/core

yarn add @sentry/core

pnpm add @sentry/core

Overview

Base implementation for all Sentry JavaScript SDKs

Index

Variables

variable BROWSER_NAVIGATION_TIMING_SPAN_NAMES

const BROWSER_NAVIGATION_TIMING_SPAN_NAMES: {
    readonly 'browser.cache': 'Cache lookup';
    readonly 'browser.dns': 'DNS lookup';
    readonly 'browser.connect': 'Connect';
    readonly 'browser.tls_ssl': 'TLS handshake';
    readonly 'browser.redirect': 'Redirect';
    readonly 'browser.request': 'Request';
    readonly 'browser.response': 'Response';
    readonly 'browser.unload_event': 'Unload event';
    readonly 'browser.dom_content_loaded_event': 'DOMContentLoaded event';
    readonly 'browser.load_event': 'Load event';
};

Span names for the browser navigation timing ops, keyed by op. None of these ops has an attribute template, so the static name is the only name they can get.
See Also
- https://getsentry.github.io/sentry-conventions/names/#browser-navigation-timing

variable CACHE_OPERATION_NAMES

const CACHE_OPERATION_NAMES: {
    readonly 'cache.get': 'get';
    readonly 'cache.put': 'put';
    readonly 'cache.remove': 'remove';
};

The cache.operation attribute value each cache op carries. Cache span names are cache.{{cache.operation}}, so the op constant itself doubles as the low-cardinality span name.
See Also
- https://getsentry.github.io/sentry-conventions/names/#cache

variable CONSOLE_LEVELS

const CONSOLE_LEVELS: readonly ConsoleLevel[];

variable DB_SPAN_NAME_FALLBACK

const DB_SPAN_NAME_FALLBACK: string;

Fallback name for db spans when no better-suited span name is available.
See Also
- https://getsentry.github.io/sentry-conventions/names/#db-queries

variable debug

const debug: {
    enable: typeof enable;
    disable: typeof disable;
    isEnabled: typeof isEnabled;
    log: typeof log;
    warn: typeof warn;
    error: typeof error;
};

This is a logger singleton which either logs things or no-ops if logging is not enabled.

variable DEFAULT_ENVIRONMENT

const DEFAULT_ENVIRONMENT: string;

variable DEFAULT_RETRY_AFTER

const DEFAULT_RETRY_AFTER: number;

variable DEV_ENVIRONMENT

const DEV_ENVIRONMENT: string;

variable featureFlagsIntegration

const featureFlagsIntegration: IntegrationFn<FeatureFlagsIntegration>;

Sentry integration for buffering feature flag evaluations manually with an API, and capturing them on error events and spans.

See the [feature flag documentation](https://develop.sentry.dev/sdk/expected-features/#feature-flags) for more information.

Example 1

import * as Sentry from '@sentry/browser';
import { type FeatureFlagsIntegration } from '@sentry/browser';

// Setup
Sentry.init(..., integrations: [Sentry.featureFlagsIntegration()])

// Verify
const flagsIntegration = Sentry.getClient()?.getIntegrationByName<FeatureFlagsIntegration>('FeatureFlags');
if (flagsIntegration) {
  flagsIntegration.addFeatureFlag('my-flag', true);
} else {
  // check your setup
}
Sentry.captureException(Exception('broke')); // 'my-flag' should be captured to this Sentry event.

variable fmt

const fmt: (
    strings: TemplateStringsArray,
    ...values: unknown[]
) => ParameterizedString;

Tagged template function which returns parameterized representation of the message.
Parameter strings
An array of string values splitted between expressions
Parameter values
Expressions extracted from template string
Returns
A ParameterizedString object that can be passed into captureMessage or Sentry.logger.X methods.

variable FUNCTION_SPAN_NAME_FALLBACK

const FUNCTION_SPAN_NAME_FALLBACK: string;

Fallback name for function execution spans when no better-suited span name is available.
See Also
- https://getsentry.github.io/sentry-conventions/names/#function

variable GEN_AI_AGENT_SPAN_NAME_FALLBACK

const GEN_AI_AGENT_SPAN_NAME_FALLBACK: string;

Fallback name for gen_ai agent spans when no better-suited span name is available.
See Also
- https://getsentry.github.io/sentry-conventions/names/#gen_ai-agent

variable GEN_AI_CONVERSATION_ID_ATTRIBUTE

const GEN_AI_CONVERSATION_ID_ATTRIBUTE: string;

The conversation ID for linking messages across API calls. For OpenAI Assistants API: thread_id For LangGraph: configurable.thread_id

variable GEN_AI_INFERENCE_SPAN_NAME_FALLBACK

const GEN_AI_INFERENCE_SPAN_NAME_FALLBACK: string;

Fallback name for gen_ai model spans when no better-suited span name is available.
See Also
- https://getsentry.github.io/sentry-conventions/names/#gen_ai-inference

variable getRootSpan

const getRootSpan: (span: SpanWithPotentialChildren) => Span;

Returns the root span of a given span.

variable GLOBAL_OBJ

const GLOBAL_OBJ: InternalGlobal;

Get's the global object for the current JavaScript runtime

variable GRAPHQL_SPAN_NAME_FALLBACK

const GRAPHQL_SPAN_NAME_FALLBACK: string;

Fallback name for graphql spans when no better-suited span name is available.
See Also
- https://getsentry.github.io/sentry-conventions/names/#graphql-graphql

variable growthbookIntegration

const growthbookIntegration: IntegrationFn<Integration>;

Sentry integration for capturing feature flag evaluations from GrowthBook.

Only boolean results are captured at this time.

Example 1

import { GrowthBook } from '@growthbook/growthbook';
import * as Sentry from '@sentry/browser'; // or '@sentry/node'

Sentry.init({
  dsn: 'your-dsn',
  integrations: [
    Sentry.growthbookIntegration({ growthbookClass: GrowthBook })
  ]
});

variable HTTP_SPAN_NAME_FALLBACK

const HTTP_SPAN_NAME_FALLBACK: string;

Fallback name for http.(client|server) spans when no better-suited span name is available.
See Also
- https://getsentry.github.io/sentry-conventions/names/#http

variable installedIntegrations

const installedIntegrations: string[];

variable MAX_BAGGAGE_STRING_LENGTH

const MAX_BAGGAGE_STRING_LENGTH: number;

Max length of a serialized baggage string
https://www.w3.org/TR/baggage/#limits

variable MAX_BODY_BYTE_LENGTH

const MAX_BODY_BYTE_LENGTH: number;

Hard cap on captured body size, even when maxRequestBodySize is 'always'.

variable MCP_NOTIFICATION_SPAN_NAME_FALLBACK

const MCP_NOTIFICATION_SPAN_NAME_FALLBACK: string;

Fallback name for mcp notification spans when no better-suited span name is available.
See Also
- https://getsentry.github.io/sentry-conventions/names/#mcp-notification

variable MCP_SERVER_SPAN_NAME_FALLBACK

const MCP_SERVER_SPAN_NAME_FALLBACK: string;

Fallback name for mcp server spans when no better-suited span name is available.
See Also
- https://getsentry.github.io/sentry-conventions/names/#mcp-server

variable MESSAGING_SPAN_NAME_FALLBACK

const MESSAGING_SPAN_NAME_FALLBACK: string;

Fallback name for messaging spans when no better-suited span name is available.
See Also
- https://getsentry.github.io/sentry-conventions/names/#messaging

variable MULTIPLEXED_TRANSPORT_EXTRA_KEY

const MULTIPLEXED_TRANSPORT_EXTRA_KEY: string;

Key used in event.extra to provide routing information for the multiplexed transport. Should contain an array of { dsn: string, release?: string } objects.

variable NAVIGATION_SPAN_NAME_FALLBACK

const NAVIGATION_SPAN_NAME_FALLBACK: string;

Fallback name for navigation spans when no better-suited span name is available.
See Also
- https://getsentry.github.io/sentry-conventions/names/#browser-navigation

variable originalConsoleMethods

const originalConsoleMethods: Partial<{
    log(...args: Parameters<typeof console.log>): void;
    info(...args: Parameters<typeof console.info>): void;
    warn(...args: Parameters<typeof console.warn>): void;
    error(...args: Parameters<typeof console.error>): void;
    debug(...args: Parameters<typeof console.debug>): void;
    assert(condition?: boolean, ...data: any[]): void;
    trace(...args: Parameters<typeof console.trace>): void;
}>;

This may be mutated by the console instrumentation.

variable PAGELOAD_SPAN_NAME_FALLBACK

const PAGELOAD_SPAN_NAME_FALLBACK: string;

Fallback name for pageload spans when no better-suited span name is available.
See Also
- https://getsentry.github.io/sentry-conventions/names/#browser-pageload

variable profiler

const profiler: Profiler;

Profiler namespace for controlling the profiler in 'manual' mode.
Requires the nodeProfilingIntegration from the @sentry/profiling-node package.

variable REQUEST_HANDLER_SPAN_NAME_FALLBACK

const REQUEST_HANDLER_SPAN_NAME_FALLBACK: string;

Fallback name for request handler spans when no better-suited span name is available.
See Also
- https://getsentry.github.io/sentry-conventions/names/#web_server-request-handler

variable RESOURCE_SPAN_NAME_FALLBACK

const RESOURCE_SPAN_NAME_FALLBACK: string;

Fallback name for resource spans when no better-suited span name is available.
See Also
- https://getsentry.github.io/sentry-conventions/names/#resource-resources

variable ROUTER_SPAN_NAME_FALLBACK

const ROUTER_SPAN_NAME_FALLBACK: string;

Fallback name for router spans when no better-suited span name is available.
See Also
- https://getsentry.github.io/sentry-conventions/names/#routing-router

variable SDK_VERSION

const SDK_VERSION: string;

variable SEMANTIC_ATTRIBUTE_CACHE_HIT

const SEMANTIC_ATTRIBUTE_CACHE_HIT: string;

variable SEMANTIC_ATTRIBUTE_CACHE_ITEM_SIZE

const SEMANTIC_ATTRIBUTE_CACHE_ITEM_SIZE: string;

variable SEMANTIC_ATTRIBUTE_CACHE_KEY

const SEMANTIC_ATTRIBUTE_CACHE_KEY: string;

variable SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME

const SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME: string;

variable SEMANTIC_ATTRIBUTE_HTTP_REQUEST_METHOD

const SEMANTIC_ATTRIBUTE_HTTP_REQUEST_METHOD: string;

TODO: Remove these once we update to latest semantic conventions

variable SEMANTIC_ATTRIBUTE_PROFILE_ID

const SEMANTIC_ATTRIBUTE_PROFILE_ID: string;

The id of the profile that this span occurred in.

variable SEMANTIC_ATTRIBUTE_SENTRY_ENVIRONMENT

const SEMANTIC_ATTRIBUTE_SENTRY_ENVIRONMENT: string;

The environment name (e.g., "production", "staging", "development")

variable SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON

const SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON: string;

The reason why an idle span finished.

variable SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_UNIT

const SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_UNIT: string;

The unit of a measurement, which may be stored as a TimedEvent.

variable SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_VALUE

const SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_VALUE: string;

The value of a measurement, which may be stored as a TimedEvent.

variable SEMANTIC_ATTRIBUTE_SENTRY_OP

const SEMANTIC_ATTRIBUTE_SENTRY_OP: string;

Use this attribute to represent the operation of a span.

variable SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN

const SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN: string;

Use this attribute to represent the origin of a span.

variable SEMANTIC_ATTRIBUTE_SENTRY_PREVIOUS_TRACE_SAMPLE_RATE

const SEMANTIC_ATTRIBUTE_SENTRY_PREVIOUS_TRACE_SAMPLE_RATE: string;

Attribute holding the sample rate of the previous trace. This is used to sample consistently across subsequent traces in the browser SDK.
Note: Only defined on root spans, if opted into consistent sampling

variable SEMANTIC_ATTRIBUTE_SENTRY_RELEASE

const SEMANTIC_ATTRIBUTE_SENTRY_RELEASE: string;

The release version of the application

variable SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE

const SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE: string;

Attributes that holds the sample rate that was locally applied to a span. If this attribute is not defined, it means that the span inherited a sampling decision.
NOTE: Is only defined on root spans.

variable SEMANTIC_ATTRIBUTE_SENTRY_SDK_INTEGRATIONS

const SEMANTIC_ATTRIBUTE_SENTRY_SDK_INTEGRATIONS: string;

The list of integrations enabled in the Sentry SDK (e.g., ["EventFilters", "BrowserTracing"])

variable SEMANTIC_ATTRIBUTE_SENTRY_SDK_NAME

const SEMANTIC_ATTRIBUTE_SENTRY_SDK_NAME: string;

The name of the Sentry SDK (e.g., "sentry.php", "sentry.javascript")
Deprecated
Use SENTRY_SDK_NAME @sentry/conventions/attributes instead.

variable SEMANTIC_ATTRIBUTE_SENTRY_SDK_VERSION

const SEMANTIC_ATTRIBUTE_SENTRY_SDK_VERSION: string;

The version of the Sentry SDK
Deprecated
Use SENTRY_SDK_VERSION @sentry/conventions/attributes instead.

variable SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_ID

const SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_ID: string;

The id of the segment that this span belongs to.
Deprecated
Use SENTRY_SEGMENT_ID @sentry/conventions/attributes instead.

variable SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_NAME

const SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_NAME: string;

The segment name (e.g., "GET /users")
Deprecated
Use SENTRY_SEGMENT_NAME @sentry/conventions/attributes instead.

variable SEMANTIC_ATTRIBUTE_SENTRY_STATUS_MESSAGE

const SEMANTIC_ATTRIBUTE_SENTRY_STATUS_MESSAGE: string;

Holds the human-readable span status message (e.g. set via span.setStatus({ code, message })).
Streamed (v2) span statuses are reduced to ok/error, so we preserve the message as an attribute instead of dropping it. This mirrors the attribute Sentry's OTLP ingestion uses for the same purpose.

variable SEMANTIC_ATTRIBUTE_URL_FULL

const SEMANTIC_ATTRIBUTE_URL_FULL: string;

Deprecated
Use URL_FULL @sentry/conventions/attributes instead.

variable SEMANTIC_ATTRIBUTE_USER_EMAIL

const SEMANTIC_ATTRIBUTE_USER_EMAIL: string;

The user email

variable SEMANTIC_ATTRIBUTE_USER_ID

const SEMANTIC_ATTRIBUTE_USER_ID: string;

The user ID

variable SEMANTIC_ATTRIBUTE_USER_IP_ADDRESS

const SEMANTIC_ATTRIBUTE_USER_IP_ADDRESS: string;

The user IP address

variable SEMANTIC_ATTRIBUTE_USER_USERNAME

const SEMANTIC_ATTRIBUTE_USER_USERNAME: string;

The user username

variable SEMANTIC_LINK_ATTRIBUTE_LINK_TYPE

const SEMANTIC_LINK_ATTRIBUTE_LINK_TYPE: string;

A span link attribute to mark the link as a special span link.
Known values: - previous_trace: The span links to the frontend root span of the previous trace. - next_trace: The span links to the frontend root span of the next trace. (Not set by the SDK)
Other values may be set as appropriate.
See Also
- https://develop.sentry.dev/sdk/telemetry/traces/span-links/#link-types

variable SENTRY_API_VERSION

const SENTRY_API_VERSION: string;

variable SENTRY_BAGGAGE_KEY_PREFIX

const SENTRY_BAGGAGE_KEY_PREFIX: string;

variable SENTRY_BAGGAGE_KEY_PREFIX_REGEX

const SENTRY_BAGGAGE_KEY_PREFIX_REGEX: RegExp;

variable SENTRY_BUFFER_FULL_ERROR

const SENTRY_BUFFER_FULL_ERROR: Symbol;

variable SERVERLESS_FUNCTION_SPAN_NAME_FALLBACK

const SERVERLESS_FUNCTION_SPAN_NAME_FALLBACK: string;

Fallback name for serverless function execution spans when no better-suited span name is available.
See Also
- https://getsentry.github.io/sentry-conventions/names/#faas-serverless-function-execution

variable SPAN_STATUS_ERROR

const SPAN_STATUS_ERROR: number;

variable SPAN_STATUS_OK

const SPAN_STATUS_OK: number;

variable SPAN_STATUS_UNSET

const SPAN_STATUS_UNSET: number;

variable supportsFetch

const supportsFetch: () => boolean;

Tells whether current environment supports Fetch API supportsFetch.
Returns
Answer to the given question.
Deprecated
This is no longer used and will be removed in a future major version.

variable TRACEPARENT_REGEXP

const TRACEPARENT_REGEXP: RegExp;

variable TRACING_DEFAULTS

const TRACING_DEFAULTS: {
    idleTimeout: number;
    finalTimeout: number;
    childSpanTimeout: number;
};

variable UI_ACTION_CLICK_SPAN_NAME_FALLBACK

const UI_ACTION_CLICK_SPAN_NAME_FALLBACK: string;

Fallback name for ui.action.click spans when no better-suited span name is available.
See Also
- https://getsentry.github.io/sentry-conventions/names/#ui-click-action

variable UI_ACTION_SPAN_NAME_FALLBACK

const UI_ACTION_SPAN_NAME_FALLBACK: string;

Fallback name for ui.action spans when no better-suited span name is available.
See Also
- https://getsentry.github.io/sentry-conventions/names/#ui-ui-action

variable UI_INTERACTION_CLICK_SPAN_NAME_FALLBACK

const UI_INTERACTION_CLICK_SPAN_NAME_FALLBACK: string;

Fallback name for ui.interaction.click spans when no better-suited span name is available.
See Also
- https://getsentry.github.io/sentry-conventions/names/#ui-click-interaction

variable UI_INTERACTION_DRAG_SPAN_NAME_FALLBACK

const UI_INTERACTION_DRAG_SPAN_NAME_FALLBACK: string;

Fallback name for ui.interaction.drag spans when no better-suited span name is available.
See Also
- https://getsentry.github.io/sentry-conventions/names/#ui-drag-interaction

variable UI_INTERACTION_HOVER_SPAN_NAME_FALLBACK

const UI_INTERACTION_HOVER_SPAN_NAME_FALLBACK: string;

Fallback name for ui.interaction.hover spans when no better-suited span name is available.
See Also
- https://getsentry.github.io/sentry-conventions/names/#ui-hover-interaction

variable UI_INTERACTION_PRESS_SPAN_NAME_FALLBACK

const UI_INTERACTION_PRESS_SPAN_NAME_FALLBACK: string;

Fallback name for ui.interaction.press spans when no better-suited span name is available.
See Also
- https://getsentry.github.io/sentry-conventions/names/#ui-key-press-interaction

variable UI_LONG_TASK_SPAN_NAME_FALLBACK

const UI_LONG_TASK_SPAN_NAME_FALLBACK: string;

Fallback name for ui.long_task and ui.long_animation_frame spans when no better-suited span name is available.
See Also
- https://getsentry.github.io/sentry-conventions/names/#ui-main-ui-thread-blocked

variable UI_MOUNT_SPAN_NAME_FALLBACK

const UI_MOUNT_SPAN_NAME_FALLBACK: string;

Fallback name for ui.mount spans when no better-suited span name is available.
See Also
- https://getsentry.github.io/sentry-conventions/names/#ui-component-mount

variable UI_RENDER_SPAN_NAME_FALLBACK

const UI_RENDER_SPAN_NAME_FALLBACK: string;

Fallback name for ui.render spans when no better-suited span name is available.
See Also
- https://getsentry.github.io/sentry-conventions/names/#ui-component-render

variable UI_RESOLVE_SPAN_NAME_FALLBACK

const UI_RESOLVE_SPAN_NAME_FALLBACK: string;

Fallback name for ui.resolve spans when no better-suited span name is available.
See Also
- https://getsentry.github.io/sentry-conventions/names/#ui-component-resolve

variable UI_SPAN_NAME_FALLBACK

const UI_SPAN_NAME_FALLBACK: string;

Fallback name for generic ui spans when no better-suited span name is available.
See Also
- https://getsentry.github.io/sentry-conventions/names/#ui-ui

variable UI_TASK_SPAN_NAME_FALLBACK

const UI_TASK_SPAN_NAME_FALLBACK: string;

Fallback name for ui.task spans when no better-suited span name is available.
See Also
- https://getsentry.github.io/sentry-conventions/names/#ui-ui-task

variable UI_UNMOUNT_SPAN_NAME_FALLBACK

const UI_UNMOUNT_SPAN_NAME_FALLBACK: string;

Fallback name for ui.unmount spans when no better-suited span name is available.
See Also
- https://getsentry.github.io/sentry-conventions/names/#ui-component-unmount

variable UI_UPDATE_SPAN_NAME_FALLBACK

const UI_UPDATE_SPAN_NAME_FALLBACK: string;

Fallback name for ui.update spans when no better-suited span name is available.
See Also
- https://getsentry.github.io/sentry-conventions/names/#ui-component-update

variable UI_WEBVITAL_CLS_SPAN_NAME_FALLBACK

const UI_WEBVITAL_CLS_SPAN_NAME_FALLBACK: string;

Fallback name for ui.webvital.cls spans when no better-suited span name is available.
See Also
- https://getsentry.github.io/sentry-conventions/names/#ui-layout-shift

variable UI_WEBVITAL_LCP_SPAN_NAME_FALLBACK

const UI_WEBVITAL_LCP_SPAN_NAME_FALLBACK: string;

Fallback name for ui.webvital.lcp spans when no better-suited span name is available.
See Also
- https://getsentry.github.io/sentry-conventions/names/#ui-largest-contentful-paint

variable UNKNOWN_FUNCTION

const UNKNOWN_FUNCTION: string;

Functions

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

function addChildSpanToSpan

addChildSpanToSpan: (span: SpanWithPotentialChildren, childSpan: Span) => void;

Adds an opaque child span reference to a span.

function addConsoleInstrumentationFilter

addConsoleInstrumentationFilter: (filter: (string | RegExp)[]) => () => void;

Add a filter to the console instrumentation to filter out console messages that match the given strings or regular expressions. Returns a function to remove the filter.

function addConsoleInstrumentationHandler

addConsoleInstrumentationHandler: (
    handler: (data: HandlerDataConsole) => void
) => () => void;

Add an instrumentation handler for when a console.xxx method is called. Returns a function to remove the handler.
Use at your own risk, this might break without changelog notice, only used internally.

function addContextToFrame

addContextToFrame: (
    lines: string[],
    frame: StackFrame,
    linesOfContext?: number
) => void;

This function adds context (pre/post/line) lines to the provided frame
Parameter lines
string[] containing all lines
Parameter frame
StackFrame that will be mutated
Parameter linesOfContext
number of context lines we want to add pre/post

function addEventProcessor

addEventProcessor: (callback: EventProcessor) => void;

Add an event processor. This will be added to the current isolation scope, ensuring any event that is processed in the current execution context will have the processor applied.

function addExceptionMechanism

addExceptionMechanism: (event: Event, newMechanism?: Partial<Mechanism>) => void;

Adds exception mechanism data to a given event. Uses defaults if the second parameter is not passed.
Parameter event
The event to modify.
Parameter newMechanism
Mechanism data to add to the event.

function addExceptionTypeValue

addExceptionTypeValue: (event: Event, value?: string, type?: string) => void;

Adds exception values, type and value to an synthetic Exception.
Parameter event
The event to modify.
Parameter value
Value of the exception.
Parameter type
Type of the exception.

function addFetchEndInstrumentationHandler

addFetchEndInstrumentationHandler: (
    handler: (data: HandlerDataFetch) => void
) => () => void;

Add an instrumentation handler for long-lived fetch requests, like consuming server-sent events (SSE) via fetch. The handler will resolve the request body and emit the actual endTimestamp, so that the span can be updated accordingly. Returns a function to remove the handler.
Only used internally

function addFetchInstrumentationHandler

addFetchInstrumentationHandler: (
    handler: (data: HandlerDataFetch) => void
) => () => void;

Add an instrumentation handler for when a fetch request happens. The handler function is called once when the request starts and once when it ends, which can be identified by checking if it has an endTimestamp. Returns a function to remove the handler.
Use at your own risk, this might break without changelog notice, only used internally.

function addGlobalErrorInstrumentationHandler

addGlobalErrorInstrumentationHandler: (
    handler: (data: HandlerDataError) => void
) => void;

Add an instrumentation handler for when an error is captured by the global error handler.
Use at your own risk, this might break without changelog notice, only used internally.

function addGlobalUnhandledRejectionInstrumentationHandler

addGlobalUnhandledRejectionInstrumentationHandler: (
    handler: (data: HandlerDataUnhandledRejection) => void
) => void;

Add an instrumentation handler for when an unhandled promise rejection is captured.
Use at your own risk, this might break without changelog notice, only used internally.

function addHandler

addHandler: (
    type: InstrumentHandlerType,
    handler: InstrumentHandlerCallback
) => () => void;

Add a handler function. Returns a function to remove the handler.

function addIntegration

addIntegration: (integration: Integration) => void;

Add an integration to the current scope's client.

function addItemToEnvelope

addItemToEnvelope: <E extends Envelope>(envelope: E, newItem: E[1][number]) => E;

Add an item to an envelope. Make sure to always explicitly provide the generic to this function so that the envelope types resolve correctly.

function addNonEnumerableProperty

addNonEnumerableProperty: (
    obj: object,
    name: string | symbol,
    value: unknown
) => void;

Defines a non-enumerable property on the given object.
Parameter obj
The object on which to set the property
Parameter name
The name of the property to be set
Parameter value
The value to which to set the property

function applyAggregateErrorsToEvent

applyAggregateErrorsToEvent: (
    exceptionFromErrorImplementation: (
        stackParser: StackParser,
        ex: Error
    ) => Exception,
    parser: StackParser,
    key: string,
    limit: number,
    event: Event,
    hint?: EventHint
) => void;

Creates exceptions inside event.exception.values for errors that are nested on properties based on the key parameter.

function applyScopeDataToEvent

applyScopeDataToEvent: (event: Event, data: ScopeData) => void;

Applies data from the scope to the event and runs all event processors on it.

function applySdkMetadata

applySdkMetadata: (
    options: CoreOptions,
    name: string,
    names?: string[],
    source?: string
) => void;

A builder for the SDK metadata in the options for the SDK initialization.
Note: This function is identical to buildMetadata in Remix and NextJS and SvelteKit. We don't extract it for bundle size reasons.
Parameter options
SDK options object that gets mutated
Parameter names
list of package names
See Also
- https://github.com/getsentry/sentry-javascript/pull/7404
- https://github.com/getsentry/sentry-javascript/pull/4196
  If you make changes to this function consider updating the others as well.

function baggageHeaderToDynamicSamplingContext

baggageHeaderToDynamicSamplingContext: (
    baggageHeader: string | string[] | number | null | undefined | boolean
) => Partial<DynamicSamplingContext> | undefined;

Takes a baggage header and turns it into Dynamic Sampling Context, by extracting all the "sentry-" prefixed values from it.
Parameter baggageHeader
A very bread definition of a baggage header as it might appear in various frameworks.
Returns
The Dynamic Sampling Context that was found on baggageHeader, if there was any, undefined otherwise.

function basename

basename: (path: string, ext?: string) => string;

JSDoc

function bindScopeToEmitter

bindScopeToEmitter: <T extends object>(emitter: T, scope?: Scope) => T;

Binds a scope to the given event emitter, so that any listener added to it runs with that scope (and therefore the active span) active — even if the listener fires later, in a different async context.
By default the currently active scope is bound, captured at the time this function is called. Pass an explicit scope to bind a different one.
This is useful when instrumenting APIs that hand back an event emitter (e.g. a streamed database query) whose 'data' / 'error' / 'end' listeners would otherwise lose the trace context.
Works with both Node.js EventEmitters (on, addListener, ...) and DOM EventTargets (addEventListener). Objects exposing none of these methods are returned untouched.
The isolation scope is intentionally not captured — it is carried along by the active async context. This mirrors the event-emitter behavior of OpenTelemetry's ContextManager.bind.

function browserPerformanceTimeOrigin

browserPerformanceTimeOrigin: () => number | undefined;

The number of milliseconds since the UNIX epoch. This value is only usable in a browser, and only when the performance API is available.

function captureBodyFromWinterCGRequest

captureBodyFromWinterCGRequest: (
    request: WebFetchRequest,
    isolationScope: Scope,
    maxRequestBodySize: Exclude<MaxRequestBodySize, 'none'>
) => Promise<void>;

Captures the body from a Web Fetch API Request and adds it to the isolation scope.
This function clones the request to read the body without affecting the original. Only textual content types are captured - binary data is skipped.
This is used by WinterCG-compatible runtimes (Cloudflare Workers, Deno, Bun, Vercel Edge, etc.) that use the Web Fetch API Request object.
Parameter request
The incoming Web Fetch API Request
Parameter isolationScope
The isolation scope to add the body to
Parameter maxRequestBodySize
The maximum size of the request body to capture ('small' = 1KB, 'medium' = 10KB, 'always' = 1MB)

function captureCheckIn

captureCheckIn: (
    checkIn: CheckIn,
    upsertMonitorConfig?: MonitorConfig
) => string;

Create a cron monitor check in and send it to Sentry.
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.

function captureConsoleIntegration

captureConsoleIntegration: (
    options?: CaptureConsoleOptions | undefined
) => import('..').Integration & { name: 'CaptureConsole' };

Send Console API calls as Sentry Events.

function 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
Optional additional data to attach to the Sentry event.
Returns
the id of the captured event.

function captureException

captureException: (
    exception: unknown,
    hint?: ExclusiveEventHintOrCaptureContext
) => string;

Captures an exception event and sends it to Sentry.
Parameter exception
The exception to capture.
Parameter hint
Optional additional data to attach to the Sentry event.
Returns
the id of the captured Sentry event.

function captureFeedback

captureFeedback: (
    params: SendFeedbackParams,
    hint?: EventHint & { includeReplay?: boolean },
    scope?: import('./scope').Scope
) => string;

Send user feedback to Sentry.

function captureMessage

captureMessage: (
    message: string,
    captureContext?: CaptureContext | SeverityLevel
) => string;

Captures a message event and sends it to Sentry.
Parameter message
The message to send to Sentry.
Parameter captureContext
Define the level of the message or pass in additional data to attach to the message.
Returns
the id of the captured message.

function captureSession

captureSession: (end?: boolean) => void;

Sends the current session on the scope to Sentry
Parameter end
If set the session will be marked as exited and removed from the scope. Defaults to false.

function captureSpan

captureSpan: (
    span: Span,
    client: Client
) => SerializedStreamedSpanWithSegmentSpan;

Captures a span and returns a JSON representation to be enqueued for sending.
IMPORTANT: This function converts the span to JSON immediately to avoid writing to an already-ended OTel span instance (which is blocked by the OTel Span class).
Returns
the final serialized span with a reference to its segment span. This reference is needed later on to compute the DSC for the span envelope.

function checkOrSetAlreadyCaught

checkOrSetAlreadyCaught: (exception: unknown) => boolean;

Checks whether or not we've already captured the given exception (note: not an identical exception - the very object in question), and marks it captured if not.
This is useful because it's possible for an error to get captured by more than one mechanism. After we intercept and record an error, we rethrow it (assuming we've intercepted it before it's reached the top-level global handlers), so that we don't interfere with whatever effects the error might have had were the SDK not there. At that point, because the error has been rethrown, it's possible for it to bubble up to some other code we've instrumented. If it's not caught after that, it will bubble all the way up to the global handlers (which of course we also instrument). This function helps us ensure that even if we encounter the same error more than once, we only record it the first time we see it.
Note: It will ignore primitives (always return false and not mark them as seen), as properties can't be set on them. {@link: Object.objectify} can be used on exceptions to convert any that are primitives into their equivalent object wrapper forms so that this check will always work. However, because we need to flag the exact object which will get rethrown, and because that rethrowing happens outside of the event processing pipeline, the objectification must be done before the exception captured.
Parameter A
thrown exception to check or flag as having been seen
Returns
true if the exception has already been captured, false if not (with the side effect of marking it seen)

function close

close: (timeout?: number) => Promise<boolean>;

Call close() on the current client, if there is one. See Client.close.
Parameter timeout
Maximum time in ms the client should wait to flush its event queue 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 queue successfully drains before the timeout, or false if it doesn't (or if there's no client defined).

function closeSession

closeSession: (session: Session, status?: Exclude<SessionStatus, 'ok'>) => void;

Closes a session by setting its status and updating the session object with it. Internally calls updateSession to update the passed session object.
Note that this function mutates the passed session (@see updateSession for explanation).
Parameter session
the Session object to be closed
Parameter status
the SessionStatus with which the session was closed. If you don't pass a status, this function will keep the previously set status, unless it was 'ok' in which case it is changed to 'exited'.

function consoleIntegration

consoleIntegration: (
    options?: Partial<ConsoleIntegrationOptions> | undefined
) => import('..').Integration & { name: 'Console' };

Captures calls to the console API as breadcrumbs in Sentry.
By default the integration instruments console.debug, console.info, console.warn, console.error, console.log, console.trace, and console.assert. You can use the levels option to customize which levels are captured.
Example 1
Sentry.init({ integrations: [Sentry.consoleIntegration({ levels: ['error', 'warn'] })], });

function consoleLoggingIntegration

consoleLoggingIntegration: (
    options?: Partial<CaptureConsoleOptions> | undefined
) => import('..').Integration & { name: 'ConsoleLogs' };

Captures calls to the console API as logs in Sentry.
This feature is experimental and may be changed or removed in future versions.
By default the integration instruments console.debug, console.info, console.warn, console.error, console.log, console.trace, and console.assert. You can use the levels option to customize which levels are captured.
Example 1
import * as Sentry from '@sentry/browser'; Sentry.init({ integrations: [Sentry.consoleLoggingIntegration({ levels: ['error', 'warn'] })], });
Modifiers
- @experimental

function consoleSandbox

consoleSandbox: <T>(callback: () => T) => T;

Temporarily disable sentry console instrumentations.
Parameter callback
The function to run against the original console messages
Returns
The results of the callback

function continueTrace

continueTrace: <V>(
    options: {
        sentryTrace: Parameters<typeof propagationContextFromHeaders>[0];
        baggage: Parameters<typeof propagationContextFromHeaders>[1];
    },
    callback: () => V
) => V;

Continue a trace from sentry-trace and baggage values. These values can be obtained from incoming request headers, or in the browser from <meta name="sentry-trace"> and <meta name="baggage"> HTML tags.
Spans started with startSpan, startSpanManual and startInactiveSpan, within the callback will automatically be attached to the incoming trace.

function conversationIdIntegration

conversationIdIntegration: () => import('..').Integration & {
    name: 'ConversationId';
};

Automatically applies conversation ID from scope to spans.
This integration reads the conversation ID from the current or isolation scope and applies it to spans when they start. This ensures the conversation ID is available for all AI-related operations.

function convertSpanLinksForEnvelope

convertSpanLinksForEnvelope: (links?: SpanLink[]) => SpanLinkJSON[] | undefined;

Converts the span links array to a flattened version to be sent within an envelope.
If the links array is empty, it returns undefined so the empty value can be dropped before it's sent.

function convertToPlainObject

convertToPlainObject: <V>(value: V) => Record<string, unknown> | V;

Transforms any Error or Event into a plain object with all of their enumerable properties, and some of their non-enumerable properties attached.
Parameter value
Initial source that we have to transform in order for it to be usable by the serializer
Returns
An Event or Error turned into an object - or the value argument itself, when value is neither an Event nor an Error.

function createAttachmentEnvelopeItem

createAttachmentEnvelopeItem: (attachment: Attachment) => AttachmentItem;

Creates attachment envelope items

function createCheckInEnvelope

createCheckInEnvelope: (
    checkIn: SerializedCheckIn,
    dynamicSamplingContext?: Partial<DynamicSamplingContext>,
    metadata?: SdkMetadata,
    tunnel?: string,
    dsn?: DsnComponents
) => CheckInEnvelope;

Create envelope from check in item.

function createClientReportEnvelope

createClientReportEnvelope: (
    discarded_events: ClientReport['discarded_events'],
    dsn?: string,
    timestamp?: number
) => ClientReportEnvelope;

Creates client report envelope
Parameter discarded_events
An array of discard events
Parameter dsn
A DSN that can be set on the header. Optional.

function createConsolaReporter

createConsolaReporter: (options?: ConsolaReporterOptions) => ConsolaReporter;

Creates a new Sentry reporter for Consola that forwards logs to Sentry.

**Note: This integration supports Consola v3.x only.** The reporter interface and log object structure may differ in other versions of Consola.

Parameter options

Configuration options for the reporter.

Returns

A Consola reporter that can be added to consola instances.

Example 1

import * as Sentry from '@sentry/node';
import { consola } from 'consola';

Sentry.init({
  dsn: '__DSN__',
});

const sentryReporter = Sentry.createConsolaReporter({
  // Optional: filter levels to capture
  levels: ['error', 'warn', 'info'],
});

consola.addReporter(sentryReporter);

// Now consola logs will be captured by Sentry
consola.info('This will be sent to Sentry');
consola.error('This error will also be sent to Sentry');

function createEnvelope

createEnvelope: <E extends Envelope>(headers: E[0], items?: E[1]) => E;

Creates an envelope. Make sure to always explicitly provide the generic to this function so that the envelope types resolve correctly.

function createEventEnvelope

createEventEnvelope: (
    event: Event,
    dsn?: DsnComponents,
    metadata?: SdkMetadata,
    tunnel?: string
) => EventEnvelope;

Create an Envelope from an event.

function createEventEnvelopeHeaders

createEventEnvelopeHeaders: (
    event: Event,
    sdkInfo: SdkInfo | undefined,
    tunnel: string | undefined,
    dsn?: DsnComponents
) => EventEnvelopeHeaders;

Creates event envelope headers, based on event, sdk info and tunnel Note: This function was extracted from the core package to make it available in Replay

function createFetchIntegration

createFetchIntegration: ({
    name,
    spanOrigin,
}: CreateFetchIntegrationOptions) => (
    options?: FetchIntegrationOptions
) => Integration;

Builds an integration that instruments the global fetch function: creates http.client spans, records breadcrumbs, and attaches trace propagation headers.
Runtimes that patch the global fetch (Bun, Cloudflare Workers, Deno, Vercel Edge) differ only in the integration name and span origin, so they all share this implementation. Node is not one of them: it instruments undici through diagnostics channels instead. Neither is the browser, whose fetch tracing is driven by browserTracingIntegration and shares its span map with XHR.

function createSessionEnvelope

createSessionEnvelope: (
    session: Session | SessionAggregates,
    dsn?: DsnComponents,
    metadata?: SdkMetadata,
    tunnel?: string
) => SessionEnvelope;

Creates an envelope from a Session

function createStackParser

createStackParser: (...parsers: StackLineParser[]) => StackParser;

Creates a stack parser with the supplied line parsers
StackFrames are returned in the correct order for Sentry Exception frames and with Sentry SDK internal frames removed from the top and bottom

function createTransport

createTransport: (
    options: InternalBaseTransportOptions,
    makeRequest: TransportRequestExecutor,
    buffer?: PromiseBuffer<TransportMakeRequestResponse>
) => Transport;

Creates an instance of a Sentry Transport
Parameter options
Parameter makeRequest

function dateTimestampInSeconds

dateTimestampInSeconds: () => number;

Returns a timestamp in seconds since the UNIX epoch using the Date API.

function debounce

debounce: (
    func: CallbackFunction,
    wait: number,
    options?: DebounceOptions
) => DebouncedCallback;

Heavily simplified debounce function based on lodash.debounce.
This function takes a callback function (@param fun) and delays its invocation by
Parameter wait
milliseconds. Optionally, a maxWait can be specified in
Parameter options
, which ensures that the callback is invoked at least once after the specified max. wait time.
Parameter func
the function whose invocation is to be debounced
Parameter wait
the minimum time until the function is invoked after it was called once
Parameter options
the options object, which can contain the maxWait property
Parameter func
's return value. The debounced function has two additional properties: - flush: Invokes the debounced function immediately and returns its return value - cancel: Cancels the debouncing process and resets the debouncing timer
Returns
the debounced version of the function, which needs to be called at least once to start the debouncing process. Subsequent calls will reset the debouncing timer and, in case was already invoked in the meantime, return

function dedupeIntegration

dedupeIntegration: () => import('..').Integration & { name: 'Dedupe' };

Deduplication filter.

function defineIntegration

defineIntegration: <Fn extends IntegrationFn<Integration>>(
    fn: Fn
) => (...args: Parameters<Fn>) => Integration & { name: ReturnType<Fn>['name'] };

Define an integration function that can be used to create an integration instance. Note that this by design hides the implementation details of the integration, as they are considered internal.

function derefWeakRef

derefWeakRef: <T extends object>(
    ref: MaybeWeakRef<T> | undefined
) => T | undefined;

Resolves a potentially weak reference, returning the underlying object or undefined if the reference has been garbage collected.
Parameter ref
A MaybeWeakRef or undefined
Returns
The referenced object, or undefined if GC'd or ref was undefined

function dirname

dirname: (path: string) => string;

JSDoc

function disabledUntil

disabledUntil: (limits: RateLimits, dataCategory: DataCategory) => number;

Gets the time that the given category is disabled until for rate limiting. In case no category-specific limit is set but a general rate limit across all categories is active, that time is returned.
the time in ms that the category is disabled until or 0 if there's no active rate limit.

function dropUndefinedKeys

dropUndefinedKeys: <T>(inputValue: T) => T;

Given any object, return a new object having removed all fields whose value was undefined. Works recursively on objects and arrays.
Attention: This function keeps circular references in the returned object.
Deprecated
This function is no longer used by the SDK and will be removed in a future major version.

function dsnFromString

dsnFromString: (str: string) => DsnComponents | undefined;

Parses a Dsn from a given string.
Parameter str
A Dsn as string
Parameter str
is not a valid DSN string
Returns
Dsn as DsnComponents or undefined if

function dsnToString

dsnToString: (dsn: DsnComponents, withPassword?: boolean) => string;

Renders the string representation of this Dsn.
By default, this will render the public representation without the password component. To get the deprecated private representation, set withPassword to true.
Parameter withPassword
When set to true, the password will be included.

function dynamicSamplingContextToSentryBaggageHeader

dynamicSamplingContextToSentryBaggageHeader: (
    dynamicSamplingContext?: Partial<DynamicSamplingContext>
) => string | undefined;

Turns a Dynamic Sampling Object into a baggage header by prefixing all the keys on the object with "sentry-".
Parameter dynamicSamplingContext
The Dynamic Sampling Context to turn into a header. For convenience and compatibility with the getDynamicSamplingContext method on the Transaction class ,this argument can also be undefined. If it is undefined the function will return undefined.
Returns
a baggage header, created from dynamicSamplingContext, or undefined either if dynamicSamplingContext was undefined, or if dynamicSamplingContext didn't contain any values.

function endSession

endSession: () => void;

End the session on the current isolation scope.

function envelopeContainsItemType

envelopeContainsItemType: (
    envelope: Envelope,
    types: EnvelopeItemType[]
) => boolean;

Returns true if the envelope contains any of the given envelope item types

function envelopeItemTypeToDataCategory

envelopeItemTypeToDataCategory: (type: EnvelopeItemType) => DataCategory;

Maps the type of an envelope item to a data category.

function envToBool

envToBool: {
    (value: unknown, options?: LooseBoolCast): boolean;
    (value: unknown, options: StrictBoolCast): boolean;
    (value: unknown, options?: BoolCastOptions): boolean;
};

function escapeStringForRegex

escapeStringForRegex: (regexString: string) => string;

Given a string, escape characters which have meaning in the regex grammar, such that the result is safe to feed to new RegExp().
Parameter regexString
The string to escape
Returns
An version of the string with all special regex characters escaped

function eventFiltersIntegration

eventFiltersIntegration: (
    options?: Partial<EventFiltersOptions> | undefined
) => import('..').Integration & { name: 'EventFilters' };

An integration that filters out events (errors and transactions) based on:
- (Errors) A curated list of known low-value or irrelevant errors (see DEFAULT_IGNORE_ERRORS) - (Errors) A list of error messages or urls/filenames passed in via - Top level Sentry.init options (ignoreErrors, denyUrls, allowUrls) - The same options passed to the integration directly via
Parameter options
(Transactions/Spans) A list of root span (transaction) names passed in via - Top level Sentry.init option (ignoreTransactions) - The same option passed to the integration directly via
Parameter options
Events filtered by this integration will not be sent to Sentry.

function eventFromMessage

eventFromMessage: (
    stackParser: StackParser,
    message: ParameterizedString,
    level?: SeverityLevel,
    hint?: EventHint,
    attachStacktrace?: boolean
) => Event;

Builds and Event from a Message

function eventFromUnknownInput

eventFromUnknownInput: (
    client: Client,
    stackParser: StackParser,
    exception: unknown,
    hint?: EventHint
) => Event;

Builds and Event from a Exception

function exceptionFromError

exceptionFromError: (stackParser: StackParser, error: Error) => Exception;

Extracts stack frames from the error and builds a Sentry Exception

function extendIntegration

extendIntegration: <
    Base extends Integration,
    Extended extends Partial<IntegrationWithOtherProperties>
>(
    integration: Base,
    extendedIntegration: Extended
) => ExtendedIntegration<Base, Extended>;

Wrap a parent integration with an extended integration. Any passed integration function will call the parent integration function first, if it exists.

Example usage:

Example 1

const parentIntegration = defineIntegration(() => ({
  name: 'ParentIntegration',
  setupOnce: () => {
    console.log('ParentIntegration setupOnce');
  },
}));

const extendedIntegration = extendIntegration(parentIntegration, {
  setupOnce: () => {
    console.log('ExtendedIntegration setupOnce');
  },
});

function extractExceptionKeysForMessage

extractExceptionKeysForMessage: (exception: Record<string, unknown>) => string;

Given any captured exception, extract its keys and create a sorted and truncated list that will be used inside the event message. eg. Non-error exception captured with keys: foo, bar, baz

function extractQueryParamsFromUrl

extractQueryParamsFromUrl: (url: string) => string | undefined;

Extract the query params from an URL.

function extractTraceparentData

extractTraceparentData: (traceparent?: string) => TraceparentData | undefined;

Extract transaction context data from a sentry-trace header.
This is terrible naming but the function has nothing to do with the W3C traceparent header. It can only parse the sentry-trace header and extract the "trace parent" data.
Parameter traceparent
Traceparent string
Returns
Object containing data from the header, or undefined if traceparent string is malformed

function extraErrorDataIntegration

extraErrorDataIntegration: (
    options?: Partial<ExtraErrorDataOptions> | undefined
) => import('..').Integration & { name: 'ExtraErrorData' };

function fill

fill: (
    source: { [key: string]: any },
    name: string,
    replacementFactory: (...args: any[]) => any
) => void;

Replace a method in an object with a wrapped version of itself.
If the method on the passed object is not a function, the wrapper will not be applied.
Parameter source
An object that contains a method to be wrapped.
Parameter name
The name of the method to be wrapped.
Parameter replacementFactory
A higher-order function that takes the original version of the given method and returns a wrapped version. Note: The function returned by replacementFactory needs to be a non-arrow function, in order to preserve the correct value of this, and the original method must be called using `origMethod.call(this, <other args>) or origMethod.apply(this, [<other args>]) (rather than being called directly), again to preserve this`.
Returns
void

function filterCollectedUrl

filterCollectedUrl: {
    (url: string, client?: Client): string;
    (url: string, client?: Client<ClientOptions<BaseTransportOptions>>): string;
};

Applies dataCollection.urlQueryParams to a URL the SDK collected itself, for use as url.full.
Call this at every site where instrumentation records a URL. Routing the SDK's own URLs through a helper is what makes the filtering provenance-correct: a URL a user attaches themselves never passes through here, and dataCollection is only meant to gate automatically collected data.
Pass the client the URL belongs to whenever one is at hand — falling back to getClient() resolves against the current scope, which is the wrong client in a multi-client setup.

function filterCollectedUrlQuery

filterCollectedUrlQuery: (
    query: string | undefined,
    client?: Client
) => string | undefined;

Applies dataCollection.urlQueryParams to a query string the SDK collected itself, for use as url.query. Returns undefined when the query must not be collected at all.
See filterCollectedUrl for why this is a helper and why passing client is preferred.

function flush

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

Call flush() on the current client, if there is one. See Client.flush.
Parameter timeout
Maximum time in ms the client should wait to flush its event queue. Omitting this parameter will cause the client to wait until all events are sent before resolving the promise.
Returns
A promise which resolves to true if the queue successfully drains before the timeout, or false if it doesn't (or if there's no client defined).

function forEachEnvelopeItem

forEachEnvelopeItem: <E extends Envelope>(
    envelope: Envelope,
    callback: (
        envelopeItem: E[1][number],
        envelopeItemType: E[1][number][0]['type']
    ) => boolean | void
) => boolean;

Convenience function to loop through the items and item types of an envelope. (This function was mostly created because working with envelope types is painful at the moment)
If the callback returns true, the rest of the items will be skipped.

function functionToStringIntegration

functionToStringIntegration: () => import('..').Integration & {
    name: 'FunctionToString';
};

Patch toString calls to return proper name for wrapped functions.

Sentry.init({
  integrations: [
    functionToStringIntegration(),
  ],
});

function generateSentryTraceHeader

generateSentryTraceHeader: (
    traceId?: string | undefined,
    spanId?: string | undefined,
    sampled?: boolean
) => string;

Create sentry-trace header from span context values.

function generateSpanId

generateSpanId: () => string;

Generate a random, valid span ID.

function generateTraceId

generateTraceId: () => string;

Generate a random, valid trace ID.

function generateTraceparentHeader

generateTraceparentHeader: (
    traceId?: string | undefined,
    spanId?: string | undefined,
    sampled?: boolean
) => string;

Creates a W3C traceparent header from the given trace and span ids.

function getActiveSpan

getActiveSpan: (scope?: Scope) => Span | undefined;

Returns the currently active span.

function getAsyncContextStrategy

getAsyncContextStrategy: (carrier: Carrier) => AsyncContextStrategy;

Get the current async context strategy. If none has been setup, the default will be used.

function getBreadcrumbLogLevelFromHttpStatusCode

getBreadcrumbLogLevelFromHttpStatusCode: (
    statusCode: number | undefined
) => SeverityLevel | undefined;

Determine a breadcrumb's log level (only warning or error) based on an HTTP status code.

function getCapturedScopesOnSpan

getCapturedScopesOnSpan: (span: Span) => {
    scope?: Scope;
    isolationScope?: Scope;
};

Grabs the scope and isolation scope off a span that were active when the span was started. If WeakRef was used and scopes have been garbage collected, returns undefined for those scopes.

function getClient

getClient: <C extends Client<ClientOptions<BaseTransportOptions>>>() =>
    | C
    | undefined;

Get the currently active client.

function getCombinedScopeData

getCombinedScopeData: (
    isolationScope: Scope | undefined,
    currentScope: Scope | undefined
) => ScopeData;

Get the scope data for the current scope after merging with the global scope and isolation scope.
Parameter currentScope
The current scope.
Returns
The scope data.

function getContentLengthFromHeaders

getContentLengthFromHeaders: (
    headers: Record<string, string | string[] | undefined>
) => number | undefined;

Read the content-length header as a number, if it holds a valid one.
content-length is the encoded (on-the-wire) body size whether or not a content-encoding is applied, so it maps to http.request.body.size / http.response.body.size. The decoded body size cannot be derived from it.

function getCurrentScope

getCurrentScope: () => Scope;

Get the currently active scope.

function getDebugImagesForResources

getDebugImagesForResources: (
    stackParser: StackParser,
    resource_paths: ReadonlyArray<string>
) => DebugImage[];

Returns a list of debug images for the given resources.

function getDefaultCurrentScope

getDefaultCurrentScope: () => Scope;

Get the default current scope.

function getDefaultIsolationScope

getDefaultIsolationScope: () => Scope;

Get the default isolation scope.

function getDynamicSamplingContextFromClient

getDynamicSamplingContextFromClient: (
    trace_id: string,
    client: Client
) => DynamicSamplingContext;

Creates a dynamic sampling context from a client.
Dispatches the createDsc lifecycle hook as a side effect.

function getDynamicSamplingContextFromScope

getDynamicSamplingContextFromScope: (
    client: Client,
    scope: Scope
) => Partial<DynamicSamplingContext> | undefined;

Get the dynamic sampling context for the currently active scopes.

function getDynamicSamplingContextFromSpan

getDynamicSamplingContextFromSpan: (
    span: Span
) => Readonly<Partial<DynamicSamplingContext>>;

Creates a dynamic sampling context from a span (and client and scope)
Parameter span
the span from which a few values like the root span name and sample rate are extracted.
Returns
a dynamic sampling context

function getEnvelopeEndpointWithUrlEncodedAuth

getEnvelopeEndpointWithUrlEncodedAuth: (
    dsn: DsnComponents,
    tunnel?: string,
    sdkInfo?: SdkInfo
) => string;

Returns the envelope endpoint URL with auth in the query string.
Sending auth as part of the query string and not as custom HTTP headers avoids CORS preflight requests.

function getEventDescription

getEventDescription: (event: Event) => string;

Extracts either message or type+value from an event that can be used for user-facing logs
Returns
event's description

function getExternalPropagationContext

getExternalPropagationContext: () =>
    | { traceId: string; spanId: string }
    | undefined;

Get the external propagation context, if a provider has been registered.

function getFilenameToDebugIdMap

getFilenameToDebugIdMap: (stackParser: StackParser) => Record<string, string>;

Returns a map of filenames to debug identifiers. Supports both proprietary _sentryDebugIds and native _debugIds (e.g., from Vercel) formats.

function getFilenameToMetadataMap

getFilenameToMetadataMap: (parser: StackParser) => Record<string, any>;

Builds a map of filenames to module metadata from the global _sentryModuleMetadata object. This is useful for forwarding metadata from web workers to the main thread.
Parameter parser
Stack parser to use for extracting filenames from stack traces
Returns
A map of filename to metadata object

function getFramesFromEvent

getFramesFromEvent: (event: Event) => StackFrame[] | undefined;

Get's stack frames from an event without needing to check for undefined properties.

function getFunctionName

getFunctionName: (fn: unknown) => string;

Safely extract function name from itself

function getGlobalScope

getGlobalScope: () => Scope;

Get the global scope. This scope is applied to _all_ events.

function getGlobalSingleton

getGlobalSingleton: <Prop extends keyof SentryCarrier>(
    name: Prop,
    creator: () => NonNullable<SentryCarrier[Prop]>,
    obj?: import('.').InternalGlobal
) => NonNullable<SentryCarrier[Prop]>;

Returns a global singleton contained in the global __SENTRY__[] object.
If the singleton doesn't already exist in __SENTRY__, it will be created using the given factory function and added to the __SENTRY__ object.
Parameter name
name of the global singleton on __SENTRY__
Parameter creator
creator Factory function to create the singleton if it doesn't already exist on __SENTRY__
Parameter obj
(Optional) The global object on which to look for __SENTRY__, if not GLOBAL_OBJ's return value
Returns
the singleton

function getHttpSpanDetailsFromUrlObject

getHttpSpanDetailsFromUrlObject: (
    urlObject: URLObject | undefined,
    kind: 'server' | 'client',
    spanOrigin: string,
    request?: PartialRequest,
    routeName?: string,
    client?: Client
) => [name: string, attributes: SpanAttributes];

Takes a parsed URL object and returns a set of attributes for the span that represents the HTTP request for that url. This is used for both server and client http spans.
Follows https://opentelemetry.io/docs/specs/semconv/http/.
Parameter urlObject
see parseStringToURLObject
Parameter kind
The type of HTTP operation (server or client)
Parameter spanOrigin
The origin of the span
Parameter request
The request object, see PartialRequest
Parameter routeName
The name of the route, must be low cardinality
Parameter client
The client the span belongs to, used to resolve dataCollection.urlQueryParams. Falls back to the current scope's client when omitted, which is the wrong one in a multi-client setup.
Returns
The span name and attributes for the HTTP operation

function getIntegrationsToSetup

getIntegrationsToSetup: (
    options: Pick<CoreOptions, 'defaultIntegrations' | 'integrations'>
) => Integration[];

Gets integrations to install

function getIsolationScope

getIsolationScope: () => Scope;

Get the currently active isolation scope. The isolation scope is active for the current execution context.

function getMainCarrier

getMainCarrier: () => Carrier;

Returns the global shim registry.
FIXME: This function is problematic, because despite always returning a valid Carrier, it has an optional __SENTRY__ property, which then in turn requires us to always perform an unnecessary check at the call-site. We always access the carrier through this function, so we can guarantee that __SENTRY__ is there.

function getMaxBodyByteLength

getMaxBodyByteLength: (
    maxRequestBodySize: Exclude<MaxRequestBodySize, 'none'>
) => number;

Convert a maxRequestBodySize setting to a maximum byte length.

function getOriginalFunction

getOriginalFunction: <T extends Function>(
    func: WrappedFunction<T>
) => T | undefined;

This extracts the original function if available. See markFunctionWrapped for more information.
Parameter func
the function to unwrap
Returns
the unwrapped version of the function if available.

function getReportDialogEndpoint

getReportDialogEndpoint: (
    dsnLike: DsnLike,
    dialogOptions: ReportDialogOptions
) => string;

Returns the url to the report dialog endpoint.

function getSanitizedUrlString

getSanitizedUrlString: (url: PartialURL) => string;

Takes a URL object and returns a sanitized string which is safe to use as span name see: https://develop.sentry.dev/sdk/data-handling/#structuring-data

function getSanitizedUrlStringFromUrlObject

getSanitizedUrlStringFromUrlObject: (url: URLObject) => string;

Takes a URL object and returns a sanitized string which is safe to use as span name see: https://develop.sentry.dev/sdk/data-handling/#structuring-data

function getSdkMetadataForEnvelopeHeader

getSdkMetadataForEnvelopeHeader: (
    metadataOrEvent?: SdkMetadata | Event
) => SdkInfo | undefined;

Extracts the minimal SDK info from the metadata or an events

function getSDKSource

getSDKSource: () => SdkSource;

Get source of SDK.

function getSpanDescendants

getSpanDescendants: (span: SpanWithPotentialChildren) => Span[];

Returns an array of the given span and all of its descendants.

function getSpanStatusFromHttpCode

getSpanStatusFromHttpCode: (httpStatus: number) => SpanStatus;

Converts a HTTP status code into a sentry status with a message.
Parameter httpStatus
The HTTP response status code.
Returns
The span status or internal_error.

function getStatusMessage

getStatusMessage: (status: SpanStatus | undefined) => string;

Get the status message to use for a JSON representation of a span.

function getTraceContextFromScope

getTraceContextFromScope: (scope: Scope) => TraceContext;

Get a trace context for the given scope.

function getTraceData

getTraceData: (options?: {
    span?: Span;
    scope?: Scope;
    client?: Client;
    propagateTraceparent?: boolean;
}) => SerializedTraceData;

Extracts trace propagation data from the current span or from the client's scope (via transaction or propagation context) and serializes it to sentry-trace and baggage values. These values can be used to propagate a trace via our tracing Http headers or Html <meta> tags.
This function also applies some validation to the generated sentry-trace and baggage values to ensure that only valid strings are returned.
When an external propagation context is registered (e.g. via the OTLP integration) and there is no active Sentry span, this function returns an empty object to defer outgoing request propagation to the external propagator (e.g. an OpenTelemetry propagator).
If (@param options.propagateTraceparent) is true, the function will also generate a traceparent value, following the W3C traceparent header format.
Returns
an object with the tracing data values. The object keys are the name of the tracing key to be used as header or meta tag name.

function getTraceMetaTags

getTraceMetaTags: (traceData?: SerializedTraceData) => string;

Returns a string of meta tags that represent the current trace data.
You can use this to propagate a trace from your server-side rendered Html to the browser. This function returns up to two meta tags, sentry-trace and baggage, depending on the current trace data state.
Example 1
Usage example:
function renderHtml() { return ` <head> ${getTraceMetaTags()} </head> `; }

function getUrlDomain

getUrlDomain: (url: string, base?: string) => string | undefined;

The domain a request goes to, for the url.domain attribute and low-cardinality span names.
Relative URLs need a base to resolve against — browsers have the page origin, server runtimes do not. URLs with no domain at all, such as data URLs, return undefined.

function getUrlFragment

getUrlFragment: (fragment: string | undefined) => string | undefined;

Normalizes a fragment for the url.fragment attribute, which is specced without the leading #.
Accepts either a raw fragment (URL.hash, which includes the #) or an already-stripped one. Empty results become undefined so callers can assign the return value to an attribute unconditionally — setting an attribute to undefined is a no-op.

function getUrlQuery

getUrlQuery: (query: string | undefined) => string | undefined;

Normalizes a query string for the url.query attribute, which is specced without the leading ?.
Accepts either a raw query string (URL.search, which includes the ?) or an already-stripped one. Empty results become undefined so callers can assign the return value to an attribute unconditionally — setting an attribute to undefined is a no-op.

function getVercelEnv

getVercelEnv: () => string | undefined;

Returns the Vercel environment the code is running in, determined by the VERCEL_TARGET_ENV environment variable with VERCEL_ENV as fallback. Returns undefined outside of Vercel.
VERCEL_TARGET_ENV also carries the name of custom Vercel environments, whereas VERCEL_ENV only ever holds production, preview or development. SDKs use this as the default environment and the bundler plugins use it for the deploys they create, so the two stay in sync and deploys show up next to events.

function handleCallbackErrors

handleCallbackErrors: {
    <Fn extends () => Promise<any>, PromiseValue = Awaited<ReturnType<Fn>>>(
        fn: Fn,
        onError: (error: unknown) => void,
        onFinally?: () => void,
        onSuccess?: (result: PromiseValue) => void
    ): ReturnType<Fn>;
    <Fn extends () => any>(
        fn: Fn,
        onError: (error: unknown) => void,
        onFinally?: () => void,
        onSuccess?: (result: ReturnType<Fn>) => void
    ): ReturnType<Fn>;
};

function handleTunnelRequest

handleTunnelRequest: (options: HandleTunnelRequestOptions) => Promise<Response>;

Core Sentry tunnel handler - framework agnostic.
Validates the envelope DSN against allowed DSNs, then forwards the envelope to the Sentry ingest endpoint.
Returns
A Response — either the upstream Sentry response on success, or an error response.

function hasExternalPropagationContext

hasExternalPropagationContext: () => boolean;

Check if an external propagation context provider has been registered.

function hasSpansEnabled

hasSpansEnabled: (
    maybeOptions?:
        | Pick<CoreOptions, 'tracesSampleRate' | 'tracesSampler'>
        | undefined
) => boolean;

Determines if span recording is currently enabled.
Spans are recorded when at least one of tracesSampleRate and tracesSampler is defined in the SDK config. This function does not make any assumption about sampling decisions, it only checks if the SDK is configured to record spans.
Important: This function only determines if span recording is enabled. Trace continuation and propagation is separately controlled and not covered by this function. If this function returns false, traces can still be propagated (which is what we refer to by "Tracing without Performance")
Parameter maybeOptions
An SDK options object to be passed to this function. If this option is not provided, the function will use the current client's options.
See Also
- https://develop.sentry.dev/sdk/telemetry/traces/tracing-without-performance/

function hasSpanStreamingEnabled

hasSpanStreamingEnabled: (client: Client) => boolean;

Determines if span streaming is enabled for the given client

function headersToDict

headersToDict: (
    reqHeaders: Record<string, string | string[] | undefined | number>
) => Record<string, string>;

Convert common request headers to a simple dictionary.

function httpHeadersToSpanAttributes

httpHeadersToSpanAttributes: (
    headers: Record<string, string | string[] | undefined>,
    dataCollection: ResolvedDataCollection,
    lifecycle?: 'request' | 'response'
) => Record<string, string[]>;

Converts incoming HTTP request or response headers to OpenTelemetry span attributes following semantic conventions. Header names are converted to the format: http.<request|response>.header. where is the header name in lowercase. Header values are always emitted as a string array.
Parameter lifecycle
The lifecycle of the headers, either 'request' or 'response'
See Also
- https://opentelemetry.io/docs/specs/semconv/registry/attributes/http/#http-request-header
- https://opentelemetry.io/docs/specs/semconv/registry/attributes/http/#http-response-header
- https://getsentry.github.io/sentry-conventions/attributes/http/#http-request-header-key
- https://getsentry.github.io/sentry-conventions/attributes/http/#http-response-header-key

function httpRequestToRequestData

httpRequestToRequestData: (request: {
    method?: string;
    url?: string;
    headers?: { [key: string]: string | string[] };
    protocol?: string;
    socket?: { encrypted?: boolean; remoteAddress?: string };
}) => RequestEventData;

Convert a HTTP request object to RequestEventData to be passed as normalizedRequest. Instead of allowing PolymorphicRequest to be passed, we want to be more specific and generally require a http.IncomingMessage-like object.

function initAndBind

initAndBind: <
    F extends Client<ClientOptions<BaseTransportOptions>>,
    O extends ClientOptions<BaseTransportOptions>
>(
    clientClass: ClientClass<F, O>,
    options: O
) => Client;

Internal function to create a new SDK client instance. The client is installed and then bound to the current scope.
Parameter clientClass
The client class to instantiate.
Parameter options
Options to pass to the client.

function instrumentFetchRequest

instrumentFetchRequest: (
    handlerData: HandlerDataFetch,
    shouldCreateSpan: (url: string) => boolean,
    shouldAttachHeaders: (url: string) => boolean,
    spans: Record<string, Span>,
    instrumentFetchRequestOptions?: InstrumentFetchRequestOptions
) => Span | undefined;

Create and track fetch request spans for usage in combination with addFetchInstrumentationHandler.
Returns
Span if a span was created, otherwise void.

function instrumentSupabaseClient

instrumentSupabaseClient: (
    supabaseClient: unknown,
    options?: { sendOperationData?: boolean }
) => void;

function INTERNAL_getSegmentSpan

INTERNAL_getSegmentSpan: (span: SpanWithPotentialChildren) => Span;

Returns the segment span of a given span.

function INTERNAL_setSegmentNameSourceIfSegment

INTERNAL_setSegmentNameSourceIfSegment: (
    span: Span,
    source: TransactionSource
) => void;

Sets sentry.segment.name.source only when span is the segment span. No-op for child spans — the attribute must exclusively live on the segment.

function isAbsolute

isAbsolute: (path: string) => boolean;

JSDoc

function isBrowser

isBrowser: () => boolean;

Returns true if we are in the browser.

function isBrowserBundle

isBrowserBundle: () => boolean;

Figures out if we're building a browser bundle.
Returns
true if this is a browser bundle build.

function isContinuingTrace

isContinuingTrace: (propagationContext: PropagationContext) => boolean;

Whether a propagation context continues an incoming trace, rather than being the head of a new one.
Both fields have to be checked. parentSpanId is unset when the incoming sentry-trace header carried no span id, which the header format allows. dsc is unset when a remote parent arrived without any incoming baggage. Either one on its own therefore misses a continued trace.

function isDOMError

isDOMError: (wat: unknown) => boolean;

Checks whether given value's type is DOMError isDOMError.
Parameter wat
A value to be checked.
Returns
A boolean representing the result.

function isDOMException

isDOMException: (wat: unknown) => boolean;

Checks whether given value's type is DOMException isDOMException.
Parameter wat
A value to be checked.
Returns
A boolean representing the result.

function isElement

isElement: (wat: unknown) => boolean;

Checks whether given value's type is an Element instance isElement.
Parameter wat
A value to be checked.
Returns
A boolean representing the result.
Deprecated
This is browser-specific and will be removed from @sentry/core in a future major version. Import isElement from @sentry/browser-utils instead.

function isEnabled

isEnabled: () => boolean;

If the SDK is initialized & enabled.

function isError

isError: (wat: unknown) => wat is Error;

Checks whether given value's type is one of a few Error or Error-like isError.
Parameter wat
A value to be checked.
Returns
A boolean representing the result.

function isErrorEvent

isErrorEvent: (wat: unknown) => boolean;

Checks whether given value's type is ErrorEvent isErrorEvent.
Parameter wat
A value to be checked.
Returns
A boolean representing the result.

function isEvent

isEvent: (wat: unknown) => wat is PolymorphicEvent;

Checks whether given value's type is an Event instance isEvent.
Parameter wat
A value to be checked.
Returns
A boolean representing the result.

function isInitialized

isInitialized: () => boolean;

Returns true if Sentry has been properly initialized.

function isInstanceOf

isInstanceOf: {
    <T>(wat: unknown, base: Constructor<T>): wat is T;
    (wat: unknown, base: unknown): boolean;
};

function isMatchingPattern

isMatchingPattern: (
    value: string,
    pattern: string | RegExp | ((value: string) => boolean),
    requireExactStringMatch?: boolean
) => boolean;

Checks if the given value matches a regex or string
Parameter value
The string to test
Parameter pattern
Either a regex or a string against which value will be matched
Parameter requireExactStringMatch
If true, value must match pattern exactly. If false, value will match pattern if it contains pattern. Only applies to string-type patterns.

function isNativeFunction

isNativeFunction: (func: Function) => boolean;

isNative checks if the given function is a native implementation

function isObjectLike

isObjectLike: (wat: unknown) => wat is Record<PropertyKey, unknown>;

Checks whether given value is a non-null object (i.e. typeof is 'object' and it is not null). Unlike isPlainObject, this also accepts arrays and class instances - it only rules out null, primitives, and functions. isObjectLike.
Parameter wat
A value to be checked.
Returns
A boolean representing the result.

function isParameterizedString

isParameterizedString: (wat: unknown) => wat is ParameterizedString;

Checks whether given string is parameterized isParameterizedString.
Parameter wat
A value to be checked.
Returns
A boolean representing the result.

function isPlainObject

isPlainObject: (wat: unknown) => wat is Record<string, unknown>;

Checks whether given value's type is an object literal, or a class instance. isPlainObject.
Parameter wat
A value to be checked.
Returns
A boolean representing the result.

function isPrimitive

isPrimitive: (wat: unknown) => wat is Primitive;

Checks whether given value is a primitive (undefined, null, number, boolean, string, bigint, symbol) isPrimitive.
Parameter wat
A value to be checked.
Returns
A boolean representing the result.

function isRateLimited

isRateLimited: (
    limits: RateLimits,
    dataCategory: DataCategory,
    now?: number
) => boolean;

Checks if a category is rate limited

function isRegExp

isRegExp: (wat: unknown) => wat is RegExp;

Checks whether given value's type is an regexp isRegExp.
Parameter wat
A value to be checked.
Returns
A boolean representing the result.

function isSentryRequestUrl

isSentryRequestUrl: (url: string, client: Client | undefined) => boolean;

Checks whether given url points to Sentry server
Parameter url
url to verify

function isStatusErrorMessageValid

isStatusErrorMessageValid: (message: string) => boolean;

function isString

isString: (wat: unknown) => wat is string;

Checks whether given value's type is a string isString.
Parameter wat
A value to be checked.
Returns
A boolean representing the result.

function isSyntheticEvent

isSyntheticEvent: (wat: unknown) => boolean;

Checks whether given value's type is a React SyntheticEvent isSyntheticEvent.
Parameter wat
A value to be checked.
Returns
A boolean representing the result.
Deprecated
This is React-specific and will be removed from @sentry/core in a future major version. Use the equivalent helper that ships with @sentry/react instead.

function isThenable

isThenable: (wat: any) => wat is PromiseLike<any>;

Checks whether given value has a then function.
Parameter wat
A value to be checked.

function isTracingSuppressed

isTracingSuppressed: (scope?: Scope) => boolean;

Check if tracing is suppressed.

function isURLObjectRelative

isURLObjectRelative: (url: URLObject) => url is RelativeURL;

Checks if the URL object is relative
Parameter url
The URL object to check
Returns
True if the URL object is relative, false otherwise

function isVueViewModel

isVueViewModel: (wat: unknown) => wat is VueViewModel | VNode;

Checks whether given value's type is a Vue ViewModel or a VNode.
Parameter wat
A value to be checked.
Returns
A boolean representing the result.
Deprecated
This is Vue-specific and will be removed from @sentry/core in a future major version. Use the equivalent helper that ships with @sentry/vue instead.

function join

join: (...args: string[]) => string;

JSDoc

function lastEventId

lastEventId: () => string | undefined;

The last error event id of the isolation scope.
Warning: This function really returns the last recorded error event id on the current isolation scope. If you call this function after handling a certain error and another error is captured in between, the last one is returned instead of the one you might expect. Also, ids of events that were never sent to Sentry (for example because they were dropped by sampling or beforeSend) could be returned.
Returns
The last event id of the isolation scope.

function linkedErrorsIntegration

linkedErrorsIntegration: (
    options?: LinkedErrorsOptions | undefined
) => import('..').Integration & { name: 'LinkedErrors' };

function logSpanEnd

logSpanEnd: (span: Span) => void;

Print a log message for an ended span.

function logSpanStart

logSpanStart: (span: Span) => void;

Print a log message for a started span.

function makeDsn

makeDsn: (from: DsnLike) => DsnComponents | undefined;

Creates a valid Sentry Dsn object, identifying a Sentry instance and project.
Parameter from
is an invalid DSN source
Returns
a valid DsnComponents object or undefined if

function makeMultiplexedTransport

makeMultiplexedTransport: <TO extends BaseTransportOptions>(
    createTransport: (options: TO) => Transport,
    matcher?: Matcher
) => (options: TO) => Transport;

Creates a transport that can send events to different DSNs depending on the envelope contents.
If no matcher is provided, the transport will look for routing information in event.extra[MULTIPLEXED_TRANSPORT_EXTRA_KEY], which should contain an array of { dsn: string, release?: string } objects.

function makeOfflineTransport

makeOfflineTransport: <TO>(
    createTransport: (options: TO) => Transport
) => (options: TO & OfflineTransportOptions) => Transport;

Wraps a transport and stores and retries events when they fail to send.
Parameter createTransport
The transport to wrap.

function makePromiseBuffer

makePromiseBuffer: <T>(limit?: number) => PromiseBuffer<T>;

Creates an new PromiseBuffer object with the specified limit
Parameter limit
max number of promises that can be stored in the buffer

function makeSession

makeSession: (context?: Omit<SessionContext, 'started' | 'status'>) => Session;

Creates a new Session object by setting certain default parameters. If optional
Parameter context
is passed, the passed properties are applied to the session object.
Parameter context
(optional) additional properties to be applied to the returned session object
Returns
a new Session object

function makeWeakRef

makeWeakRef: <T extends object>(value: T) => MaybeWeakRef<T>;

Creates a weak reference to an object if WeakRef is available, otherwise returns the object directly.
This is useful for breaking circular references while maintaining compatibility with environments that don't support WeakRef (e.g., older browsers).
Parameter value
The object to create a weak reference to
Returns
A WeakRef wrapper if available, or the original object as fallback

function markFunctionWrapped

markFunctionWrapped: (
    wrapped: WrappedFunction,
    original: WrappedFunction
) => void;

Remembers the original function on the wrapped function and patches up the prototype.
Parameter wrapped
the wrapper function
Parameter original
the original function that gets wrapped

function markSpanAsTracerProviderSpan

markSpanAsTracerProviderSpan: (span: Span) => void;

Mark a span as created by the SentryTracerProvider (via the OTel tracer). Set by SentryTracer on every span it creates; read by SentrySpan.end() to seal the span against further writes once it has ended, mirroring OTel SDK spans (which are immutable after end()).

function matchesTracePropagationTargets

matchesTracePropagationTargets: (
    value: string,
    tracePropagationTargets: TracePropagationTargets,
    requireExactStringMatch?: boolean
) => boolean;

Check if a value matches any of the given tracePropagationTargets.
The value is usually a URL, but it can be anything a propagation decision is made on, such as a Cloudflare binding name. String targets match as a substring unless requireExactStringMatch is set.
Matching is case-insensitive: URL normalization (e.g. new URL()) lower-cases the origin, so a target written with the same casing as the request ('myApi.com', /^myApi\.com/) would otherwise never match.

function maybeInstrument

maybeInstrument: (type: InstrumentHandlerType, instrumentFn: () => void) => void;

Maybe run an instrumentation function, unless it was already called.

function mergeBaggageHeaders

mergeBaggageHeaders: <Existing extends string | number | string[]>(
    existing: Existing,
    incoming: string
) => string | undefined | Existing;

Merge two baggage headers into one. - Sentry-specific entries (keys starting with "sentry-") from the new baggage take precedence - Non-Sentry entries from existing baggage take precedence
The order of the existing baggage will be preserved, and new entries will be added to the end.
This matches the behavior of OTEL's propagation.inject() which uses baggage.setEntry() to overwrite existing entries with the same key.

function mergeScopeData

mergeScopeData: (data: ScopeData, mergeData: ScopeData) => void;

Merge data of two scopes together.

function moduleMetadataIntegration

moduleMetadataIntegration: () => import('..').Integration & {
    name: 'ModuleMetadata';
};

Adds module metadata to stack frames.
Metadata can be injected by the Sentry bundler plugins using the moduleMetadata config option.
When this integration is added, the metadata passed to the bundler plugin is added to the stack frames of all events under the module_metadata property. This can be used to help in tagging or routing of events from different teams our sources

function normalize

normalize: (input: unknown, depth?: number, maxProperties?: number) => any;

Recursively normalizes the given object.
- Creates a copy to prevent original input mutation - Skips non-enumerable properties - When stringifying, calls toJSON if implemented - Removes circular references - Translates non-serializable values (undefined/NaN/functions) to serializable format - Translates known global objects/classes to a string representations - Takes care of Error object serialization - Optionally limits depth of final output - Optionally limits number of properties/elements included in any single object/array
Parameter input
The object to be normalized.
Parameter depth
The max depth to which to normalize the object. (Anything deeper stringified whole.)
Parameter maxProperties
The max number of elements or properties to be included in any single array or object in the normalized output.
Returns
A normalized version of the object, or "**non-serializable**" if any errors are thrown during normalization.

function normalizePath

normalizePath: (path: string) => string;

JSDoc

function normalizeToSize

normalizeToSize: <T>(
    object: { [key: string]: any },
    depth?: number,
    maxSize?: number
) => T;

JSDoc

function normalizeUrlToBase

normalizeUrlToBase: (url: string, basePath: string) => string;

Normalizes URLs in exceptions and stacktraces to a base path so Sentry can fingerprint across platforms and working directory.
Parameter url
The URL to be normalized.
Parameter basePath
The application base path.
Returns
The normalized URL.

function notifyEventProcessors

notifyEventProcessors: (
    processors: EventProcessor[],
    event: Event | null,
    hint: EventHint,
    index?: number,
    onDrop?: (reason: EventProcessorDropReason) => void
) => PromiseLike<Event | null>;

Process an array of event processors, returning the processed event (or null if the event was dropped).

function objectify

objectify: (wat: unknown) => typeof Object;

Ensure that something is an object.
Turns undefined and null into Strings and all other primitives into instances of their respective wrapper classes (String, Boolean, Number, etc.). Acts as the identity function on non-primitives.
Parameter wat
The subject of the objectification
Returns
A version of wat which can safely be used with Object class methods

function objectToBaggageHeader

objectToBaggageHeader: (object: Record<string, string>) => string | undefined;

Turns a flat object (key-value pairs) into a baggage header, which is also just key-value pairs.
Parameter object
The object to turn into a baggage header.
Returns
a baggage header string, or undefined if the object didn't have any values, since an empty baggage header is not spec compliant.

function parameterize

parameterize: (
    strings: TemplateStringsArray,
    ...values: unknown[]
) => ParameterizedString;

Tagged template function which returns parameterized representation of the message For example: parameterizeThis is a log statement with ${x} and ${y} params, would return: "__sentry_template_string__": 'This is a log statement with %s and %s params', "__sentry_template_values__": ['first', 'second']
Parameter strings
An array of string values splitted between expressions
Parameter values
Expressions extracted from template string
Returns
A ParameterizedString object that can be passed into captureMessage or Sentry.logger.X methods.

function parseBaggageHeader

parseBaggageHeader: (
    baggageHeader: string | string[] | number | null | undefined | boolean
) => Record<string, string> | undefined;

Take a baggage header and parse it into an object.

function parseEnvelope

parseEnvelope: (env: string | Uint8Array) => Envelope;

Parses an envelope

function parseRetryAfterHeader

parseRetryAfterHeader: (header: string, now?: number) => number;

Extracts Retry-After value from the request header or returns default value
Parameter header
string representation of 'Retry-After' header
Parameter now
current unix timestamp

function parseSampleRate

parseSampleRate: (sampleRate: unknown) => number | undefined;

Parse a sample rate from a given value. This will either return a boolean or number sample rate, if the sample rate is valid (between 0 and 1). If a string is passed, we try to convert it to a number.
Any invalid sample rate will return undefined.

function parseSemver

parseSemver: (input: string) => SemVer;

Parses input into a SemVer interface
Parameter input
string representation of a semver version

function parseStackFrames

parseStackFrames: (stackParser: StackParser, error: Error) => StackFrame[];

Extracts stack frames from the error.stack string

function parseStringToURLObject

parseStringToURLObject: (
    url: string,
    urlBase?: string | URL | undefined
) => URLObject | undefined;

Parses string to a URL object
Parameter url
The URL to parse
Returns
The parsed URL object or undefined if the URL is invalid

function parseUrl

parseUrl: (url: string) => PartialURL;

Parses string form of URL into an object // borrowed from https://tools.ietf.org/html/rfc3986#appendix-B // intentionally using regex and not href parsing trick because React Native and other // environments where DOM might not be available
Returns
parsed URL object

function prepareEvent

prepareEvent: (
    options: ClientOptions,
    event: Event,
    hint: EventHint,
    scope?: Scope,
    client?: Client,
    isolationScope?: Scope
) => PromiseLike<Event | null>;

Adds common information to events.
The information includes release and environment from options, breadcrumbs and context (extra, tags and user) from the scope.
Information that is already present in the event is never overwritten. For nested objects, such as the context, keys are merged.
Parameter event
The original event.
Parameter hint
May contain additional information about the original exception.
Parameter scope
A scope containing event metadata.
Returns
A new event with more information, or null if an event processor dropped it (or threw). In that case the drop has already been recorded on the client, so callers must not record it again.

function propagationContextFromHeaders

propagationContextFromHeaders: (
    sentryTrace: string | undefined,
    baggage: string | number | boolean | string[] | null | undefined
) => PropagationContext;

Create a propagation context from incoming headers or creates a minimal new one if the headers are undefined.

function registerExternalPropagationContext

registerExternalPropagationContext: (
    fn: () => { traceId: string; spanId: string } | undefined
) => void;

Register an external propagation context provider function. When registered, trace context will be read from the external source (e.g. OpenTelemetry) instead of from the Sentry scope's propagation context.

function registerSpanErrorInstrumentation

registerSpanErrorInstrumentation: () => void;

Ensure that global errors automatically set the active span status.

function rejectedSyncPromise

rejectedSyncPromise: <T = never>(reason?: any) => PromiseLike<T>;

Creates a rejected sync promise.
Parameter value
the value to reject the promise with
Returns
the rejected sync promise

function relative

relative: (from: string, to: string) => string;

JSDoc

function replaceExports

replaceExports: (
    exports: { [key: string]: unknown },
    exportName: string,
    wrappedConstructor: unknown
) => void;

Replaces constructor functions in module exports, handling read-only properties, and both default and named exports by wrapping them with the constructor.
Parameter exports
The module exports object to modify
Parameter exportName
The name of the export to replace (e.g., 'GoogleGenAI', 'Anthropic', 'OpenAI')
Parameter wrappedConstructor
The wrapped constructor function to replace the original with
Returns
void

function requestDataIntegration

requestDataIntegration: (
    options?: RequestDataIntegrationOptions | undefined
) => import('..').Integration & { name: 'RequestData' };

Add data about a request to an event. Primarily for use in Node-based SDKs, but included in @sentry/core so it can be used in cross-platform SDKs like @sentry/nextjs.

function resetInstrumentationHandlers

resetInstrumentationHandlers: () => void;

Reset all instrumentation handlers. This can be used by tests to ensure we have a clean slate of instrumentation handlers.

function resolve

resolve: (...args: string[]) => string;

JSDoc

function resolvedSyncPromise

resolvedSyncPromise: {
    (): PromiseLike<void>;
    <T>(value: T | PromiseLike<T>): PromiseLike<T>;
};

function rewriteFramesIntegration

rewriteFramesIntegration: (
    options?: RewriteFramesOptions | undefined
) => import('..').Integration & { name: 'RewriteFrames' };

Rewrite event frames paths.

function safeCallback

safeCallback: <T>(
    message: string,
    fn: () => T,
    fallback: (error: unknown) => T
) => T;

Invokes a user-provided callback (e.g. beforeSend, tracesSampler, an integration hook) so that neither a synchronous throw nor a rejected promise escapes into the caller. On failure the error is logged and fallback(error) supplies the result instead.
Not for startSpan bodies: those must re-throw and are handled by handleCallbackErrors.
Parameter message
Logged via debug.error together with the error. Pass it as DEBUG_BUILD ? '...' : '' so the string is tree-shaken from non-debug bundles.
Parameter fn
Invokes the callback.
Parameter fallback
Produces the result to use when the callback throws or rejects.

function safeJoin

safeJoin: (input: unknown[], delimiter?: string) => string;

Join values in array
Parameter input
array of values to be joined together
Parameter delimiter
string to be placed in-between values
Returns
Joined values

function safeSetSpanJSONAttributes

safeSetSpanJSONAttributes: (
    spanJSON: StreamedSpanJSON,
    newAttributes: RawAttributes<Record<string, unknown>>
) => void;

Safely set attributes on a span JSON. If an attribute already exists, it will not be overwritten.

function sampleSpan

sampleSpan: (
    options: Pick<CoreOptions, 'tracesSampleRate' | 'tracesSampler'>,
    samplingContext: SamplingContext,
    sampleRand: number
) => [
    sampled: boolean,
    sampleRate?: number,
    localSampleRateWasApplied?: boolean,
    dropReason?: 'callback_error'
];

Makes a sampling decision for the given options.
Called every time a root span is created. Only root spans which emerge with a sampled value of true will be sent to Sentry.

function serializeEnvelope

serializeEnvelope: (envelope: Envelope) => string | Uint8Array;

Serializes an envelope.

function setAsyncContextStrategy

setAsyncContextStrategy: (strategy: AsyncContextStrategy | undefined) => void;

Private API with no semver guarantees!
Sets the global async context strategy

function setAttribute

setAttribute: <
    T extends RawAttribute<T> extends { value: any } | { unit: any }
        ? AttributeObject
        : unknown
>(
    key: string,
    value: RawAttribute<T>
) => void;

Sets an attribute on the isolation scope.
These attributes are applied to logs, metrics and streamed spans.
Supported attribute value types are string, number, boolean, string[], number[] and boolean[].
Parameter key
The attribute key.
Parameter value
The attribute value.
Example 1
Sentry.setAttribute('is_admin', true); Sentry.setAttribute('render_duration', 150);

function setAttributes

setAttributes: <T extends Record<string, unknown>>(
    attributes: RawAttributes<T>
) => void;

Sets attributes on the isolation scope.
These attributes are applied to logs, metrics and streamed spans.
Supported attribute value types are string, number, boolean, string[], number[] and boolean[].
Parameter attributes
The attributes to set on the scope, as key-value pairs.
Example 1
Sentry.setAttributes({ is_admin: true, payment_selection: 'credit_card', render_duration: 150, });

function setCapturedScopesOnSpan

setCapturedScopesOnSpan: (
    span: Span | undefined,
    scope: Scope,
    isolationScope: Scope
) => void;

Store the scope & isolation scope for a span, which can the be used when it is finished.

function setContext

setContext: (name: string, context: { [key: string]: unknown }) => void;

Sets context data with the given name.
Parameter name
of the context
Parameter context
Any kind of data. This data will be normalized.

function setConversationId

setConversationId: (conversationId: string | null | undefined) => void;

Sets the conversation ID for the current isolation scope.
Parameter conversationId
The conversation ID to set. Pass null or undefined to unset the conversation ID.

function setCurrentClient

setCurrentClient: (client: Client) => void;

Make the given client the current client.

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

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

function setHttpStatus

setHttpStatus: (span: Span, httpStatus: number) => void;

Sets the Http status attributes on the current span based on the http code. Additionally, the span's status is updated, depending on the http code.

function setMeasurement

setMeasurement: (
    name: string,
    value: number,
    unit: MeasurementUnit,
    activeSpan?: import('..').Span | undefined
) => void;

Adds a measurement to the active transaction on the current global scope. You can optionally pass in a different span as the 4th parameter.

function setNormalizationDepthOverrideHint

setNormalizationDepthOverrideHint: (obj: object, depth: number) => void;

Overrides remaining normalization depth from this object downward (e.g. Redux / Pinia state).

function setNormalizeStringifier

setNormalizeStringifier: (newStringifier: Stringifier | undefined) => void;

Set a custom stringifier for the normalize function. If this returns a non-empty string, it will be used instead of the default stringification. Return undefined to fall back to the generic behavior.

function setSkipNormalizationHint

setSkipNormalizationHint: (obj: object) => void;

Marks an object so normalize returns it unchanged (already-normalized SDK data).

function 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

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

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

function severityLevelFromString

severityLevelFromString: (level: SeverityLevel | string) => SeverityLevel;

Converts a string-based level into a SeverityLevel, normalizing it along the way.
Parameter level
String representation of desired SeverityLevel.
Returns
The SeverityLevel corresponding to the given string, or 'log' if the string isn't a valid level.

function shouldContinueTrace

shouldContinueTrace: (client: Client, baggageOrgId?: string) => boolean;

Determines whether a new trace should be continued based on the provided baggage org ID and the client's strictTraceContinuation option. If the trace should not be continued, a new trace will be started.
The result is dependent on the strictTraceContinuation option in the client. See https://develop.sentry.dev/sdk/telemetry/traces/#stricttracecontinuation

function shouldIgnoreSpan

shouldIgnoreSpan: (
    span: Pick<SpanJSON, 'description' | 'op'> & {
        attributes?: Record<string, unknown>;
    },
    ignoreSpans: Required<ClientOptions>['ignoreSpans']
) => boolean;

Check if a span should be ignored based on the ignoreSpans configuration.

function shouldPropagateTraceForUrl

shouldPropagateTraceForUrl: (
    url: string | undefined,
    tracePropagationTargets: Options['tracePropagationTargets'],
    decisionMap?: LRUMap<string, boolean>
) => boolean;

Check if a given URL should be propagated to or not. If no url is defined, or no trace propagation targets are defined, this will always return true. You can also optionally provide a decision map, to cache decisions and avoid repeated regex lookups.

function snipLine

snipLine: (line: string, colno: number) => string;

This is basically just trim_line from https://github.com/getsentry/sentry/blob/master/src/sentry/lang/javascript/processor.py#L67
Parameter str
An object that contains serializable values
Parameter max
Maximum number of characters in truncated string
Returns
string Encoded

function spanIsIgnored

spanIsIgnored: (span: Span) => span is SentryNonRecordingSpan;

Whether a span is an ignored (ignoreSpans) placeholder. Such a span must not be set as the active span when it has a parent, so its children attach to that parent and get re-parented rather than dropped with it. Shared with the OTel-based provider so both span pipelines apply the same rule.

function spanIsSampled

spanIsSampled: (span: Span) => boolean;

Returns true if a span is sampled. In most cases, you should just use span.isRecording() instead. However, this has a slightly different semantic, as it also returns false if the span is finished. So in the case where this distinction is important, use this method.

function spanIsSentrySpan

spanIsSentrySpan: (span: Span) => span is SentrySpan;

Sadly, due to circular dependency checks we cannot actually import the Span class here and check for instanceof. :( So instead we approximate this by checking if it has the getSpanJSON method.

function spanIsTracerProviderSpan

spanIsTracerProviderSpan: (span: Span) => boolean;

Whether a span was created by the SentryTracerProvider (see markSpanAsTracerProviderSpan).

function spanKindToName

spanKindToName: (kind: number) => SpanKind | undefined;

Resolve the string name of a span kind value (e.g. 1 → 'SERVER'), mirroring the reverse mapping of OpenTelemetry's SpanKind enum. Used for the otel.kind span attribute, so SDK code doesn't need to import @opentelemetry/api just for that reverse lookup.

function spanStreamingIntegration

spanStreamingIntegration: (
    options?: SpanStreamingOptions | undefined
) => import('..').Integration & { name: 'SpanStreaming' };

function spanTimeInputToSeconds

spanTimeInputToSeconds: (input: SpanTimeInput | undefined) => number;

Convert a span time input into a timestamp in seconds.

function spanToBaggageHeader

spanToBaggageHeader: (span: Span) => string | undefined;

Convert a Span to a baggage header.

function spanToJSON

spanToJSON: (span: Span) => StreamedSpanJSON;

Convert a span to a JSON representation.

function spanToStaticSpanJSON

spanToStaticSpanJSON: (span: Span) => SpanJSON;

Convert a span to a static JSON representation.

function spanToTraceContext

spanToTraceContext: (span: Span) => TraceContext;

Convert a span to a trace context, which can be sent as the trace context in a non-transaction event.

function spanToTraceHeader

spanToTraceHeader: (span: Span) => string;

Convert a Span to a Sentry trace header.

function stackParserFromStackParserOptions

stackParserFromStackParserOptions: (
    stackParser: StackParser | StackLineParser[]
) => StackParser;

Gets a stack parser implementation from Options.stackParser
See Also
- Options
  If options contains an array of line parsers, it is converted into a parser

function startInactiveSpan

startInactiveSpan: (options: StartSpanOptions) => Span;

Creates a span. This span is not set as active, so will not get automatic instrumentation spans as children or be able to be accessed via Sentry.getActiveSpan().
If you want to create a span that is set as active, use startSpan.
This function will always return a span, it may just be a non-recording span if the span is not sampled or if tracing is disabled.

function startNewTrace

startNewTrace: <T>(callback: () => T) => T;

Starts a new trace for the duration of the provided callback. Spans started within the callback will be part of the new trace instead of a potentially previously started trace.
Important: Only use this function if you want to override the default trace lifetime and propagation mechanism of the SDK for the duration and scope of the provided callback. The newly created trace will also be the root of a new distributed trace, for example if you make http requests within the callback. This function might be useful if the operation you want to instrument should not be part of a potentially ongoing trace.
Default behavior: - Server-side: A new trace is started for each incoming request. - Browser: A new trace is started for each page our route. Navigating to a new route or page will automatically create a new trace.

function startSession

startSession: (context?: SessionContext) => Session;

Start a session on the current isolation scope.
Parameter context
(optional) additional properties to be applied to the returned session object
Returns
the new active session

function startSpan

startSpan: <T>(options: StartSpanOptions, callback: (span: Span) => T) => T;

Wraps a function with a transaction/span and finishes the span after the function is done. The created span is the active span and will be used as parent by other spans created inside the function and can be accessed via Sentry.getActiveSpan(), as long as the function is executed while the scope is active.
If you want to create a span that is not set as active, use startInactiveSpan.
You'll always get a span passed to the callback, it may just be a non-recording span if the span is not sampled or if tracing is disabled.

function startSpanManual

startSpanManual: <T>(
    options: StartSpanOptions,
    callback: (span: Span, finish: () => void) => T
) => T;

Similar to Sentry.startSpan. Wraps a function with a transaction/span, but does not finish the span after the function is done automatically. Use span.end() to end the span.
The created span is the active span and will be used as parent by other spans created inside the function and can be accessed via Sentry.getActiveSpan(), as long as the function is executed while the scope is active.
You'll always get a span passed to the callback, it may just be a non-recording span if the span is not sampled or if tracing is disabled.

function stringify

stringify: (
    value: unknown,
    fallback?: string | ((value: unknown) => string)
) => string | undefined;

Coerce a value to a string without ever throwing. Strings pass through unchanged (so an already-serialized value isn't double-encoded and a plain string isn't wrapped in quotes); anything else is JSON.stringify-ed, falling back to fallback if that throws (e.g. on circular references or BigInt). Returns undefined for values JSON.stringify itself drops (top-level undefined, functions, symbols), matching JSON.stringify's own runtime behavior.
Parameter value
the value to stringify
Parameter fallback
returned when serialization throws, or, if a function, called with value to produce the fallback. Defaults to '[unserializable]'.

function stringMatchesSomePattern

stringMatchesSomePattern: (
    testString: string,
    patterns?:
        | (string | RegExp | ((value: string) => boolean))[]
        | Set<string | RegExp | ((value: string) => boolean)>,
    requireExactStringMatch?: boolean
) => boolean;

Test the given string against an array of strings and regexes. By default, string matching is done on a substring-inclusion basis rather than a strict equality basis
Parameter testString
The string to test
Parameter patterns
The patterns against which to test the string
Parameter requireExactStringMatch
If true, testString must match one of the given string patterns exactly in order to count. If false, testString will match a string pattern if it contains that pattern.
Returns

function stripDataUrlContent

stripDataUrlContent: (url: string, includeDataPrefix?: boolean) => string;

Strips the content from a data URL, returning a placeholder with the MIME type.
Data URLs can be very long (e.g. base64 encoded scripts for Web Workers), with little valuable information, often leading to envelopes getting dropped due to size limit violations. Therefore, we strip data URLs and replace them with a placeholder.
Parameter url
The URL to process
Parameter includeDataPrefix
If true, includes the first 10 characters of the data stream for debugging (e.g., to identify magic bytes like WASM's AGFzbQ). Defaults to true.
Returns
For data URLs, returns a short format like data:text/javascript;base64,SGVsbG8gV2... [truncated]. For non-data URLs, returns the original URL unchanged.

function stripSentryFramesAndReverse

stripSentryFramesAndReverse: (stack: ReadonlyArray<StackFrame>) => StackFrame[];

Removes Sentry frames from the top and bottom of the stack if present and enforces a limit of max number of frames. Assumes stack input is ordered from top to bottom and returns the reverse representation so call site of the function that caused the crash is the last frame in the array.

function stripUrlQueryAndFragment

stripUrlQueryAndFragment: (urlPath: string) => string;

Strip the query string and fragment off of a given URL or path (if present)
Parameter urlPath
Full URL or path, including possible query string and/or fragment
Returns
URL or path without query string or fragment

function supabaseIntegration

supabaseIntegration: (
    options: SupabaseIntegrationOptions
) => import('..').Integration & { name: 'Supabase' };

function supportsDOMException

supportsDOMException: () => boolean;

Tells whether current environment supports DOMException objects supportsDOMException.
Returns
Answer to the given question.

function supportsErrorEvent

supportsErrorEvent: () => boolean;

Tells whether current environment supports ErrorEvent objects supportsErrorEvent.
Returns
Answer to the given question.

function supportsReferrerPolicy

supportsReferrerPolicy: () => boolean;

Tells whether current environment supports Referrer Policy API supportsReferrerPolicy.
Returns
Answer to the given question.
Deprecated
This is no longer used and will be removed in a future major version.

function suppressTracing

suppressTracing: <T>(callback: () => T) => T;

Suppress tracing in the given callback, ensuring no spans are generated inside of it.

function thirdPartyErrorFilterIntegration

thirdPartyErrorFilterIntegration: (
    options: Options
) => import('..').Integration & { name: 'ThirdPartyErrorsFilter' };

This integration allows you to filter out, or tag error events that do not come from user code marked with a bundle key via the Sentry bundler plugins.

function timedEventsToMeasurements

timedEventsToMeasurements: (events: TimedEvent[]) => Measurements | undefined;

Convert timed events to measurements.

function timestampInSeconds

timestampInSeconds: () => number;

Returns a timestamp in seconds since the UNIX epoch using either the Performance or Date APIs, depending on the availability of the Performance API.
BUG: Note that because of how browsers implement the Performance API, the clock might stop when the computer is asleep. This creates a skew between dateTimestampInSeconds and timestampInSeconds. The skew can grow to arbitrary amounts like days, weeks or months. See https://github.com/getsentry/sentry-javascript/issues/2590.

function triggerHandlers

triggerHandlers: (type: InstrumentHandlerType, data: unknown) => void;

Trigger handlers for a given instrumentation type.

function truncate

truncate: (str: string, max?: number) => string;

Truncates given string to the maximum characters count
Parameter str
An object that contains serializable values
Parameter max
Maximum number of characters in truncated string (0 = unlimited)
Returns
string Encoded

function uniq

uniq: <T>(input: T[]) => T[];

Return a new array with duplicate values removed, preserving first-occurrence order.
Parameter input
the array to deduplicate
Returns
a new array containing each distinct value once, in the order it first appeared

function updateRateLimits

updateRateLimits: (
    limits: RateLimits,
    { statusCode, headers }: TransportMakeRequestResponse,
    now?: number
) => RateLimits;

Update ratelimits from incoming headers.
the updated RateLimits object.

function updateSession

updateSession: (session: Session, context?: SessionContext) => void;

Updates a session object with the properties passed in the context.
Note that this function mutates the passed object and returns void. (Had to do this instead of returning a new and updated session because closing and sending a session makes an update to the session after it was passed to the sending logic.
Parameter session
the Session to update
Parameter context
the SessionContext holding the properties that should be updated in
Parameter session
See Also
- Client.captureSession )

function updateSpanName

updateSpanName: (span: Span, name: string) => void;

Updates the name of the given span and ensures that the span name is not overwritten by the Sentry SDK.
Use this function instead of span.updateName() if you want to make sure that your name is kept. For some spans, for example root http.server spans the Sentry SDK would otherwise overwrite the span name with a high-quality name it infers when the span ends.
Use this function in server code or when your span is started on the server and on the client (browser). If you only update a span name on the client, you can also use span.updateName() the SDK does not overwrite the name.
Parameter span
The span to update the name of.
Parameter name
The name to set on the span.

function uuid4

uuid4: (crypto?: CryptoInternal | undefined) => string;

UUID4 generator
Parameter crypto
Object that provides the crypto API.
Returns
string Generated UUID4.

function waitForTracingChannelBinding

waitForTracingChannelBinding: (callback: () => void, retries?: number) => void;

Execute a callback whenever the tracing channel binding is available. If it is not available after retry, the callback is not executed.

function winterCGHeadersToDict

winterCGHeadersToDict: (
    winterCGHeaders: WebFetchHeaders
) => Record<string, string>;

Transforms a Headers object that implements the Web Fetch API (https://developer.mozilla.org/en-US/docs/Web/API/Headers) into a simple key-value dict. The header keys will be lower case: e.g. A "Content-Type" header will be stored as "content-type".

function winterCGRequestToRequestData

winterCGRequestToRequestData: (req: WebFetchRequest) => RequestEventData;

Converts a Request object that implements the Web Fetch API (https://developer.mozilla.org/en-US/docs/Web/API/Headers) into the format that the RequestData integration understands.

function withActiveSpan

withActiveSpan: <T>(span: Span | null, callback: (scope: Scope) => T) => T;

Forks the current scope and sets the provided span as active span in the context of the provided callback. Can be passed null to start an entirely new span tree.
Parameter span
Spans started in the context of the provided callback will be children of this span. If null is passed, spans started within the callback will not be attached to a parent span.
Parameter callback
Execution context in which the provided span will be active. Is passed the newly forked scope.
Returns
the value returned from the provided callback function.

function withIsolationScope

withIsolationScope: {
    <T>(callback: (isolationScope: Scope) => T): T;
    <T>(isolationScope: Scope, callback: (isolationScope: Scope) => T): T;
};

Attempts to fork the current isolation scope and the current scope based on the current async context strategy. If no async context strategy is set, the isolation scope and the current scope will not be forked (this is currently the case, for example, in the browser).
Usage of this function in environments without async context strategy is discouraged and may lead to unexpected behaviour.
This function is intended for Sentry SDK and SDK integration development. It is not recommended to be used in "normal" applications directly because it comes with pitfalls. Use at your own risk!
Set the provided isolation scope as active in the given callback. If no async context strategy is set, the isolation scope and the current scope will not be forked (this is currently the case, for example, in the browser).
Usage of this function in environments without async context strategy is discouraged and may lead to unexpected behaviour.
This function is intended for Sentry SDK and SDK integration development. It is not recommended to be used in "normal" applications directly because it comes with pitfalls. Use at your own risk!
If you pass in undefined as a scope, it will fork a new isolation scope, the same as if no scope is passed.

function withMonitor

withMonitor: <T>(
    monitorSlug: CheckIn['monitorSlug'],
    callback: () => T,
    upsertMonitorConfig?: MonitorConfig
) => T;

Wraps a callback with a cron monitor check in. The check in will be sent to Sentry when the callback finishes.
Parameter monitorSlug
The distinct slug of the monitor.
Parameter callback
Callback to be monitored
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.

function withScope

withScope: {
    <T>(callback: (scope: Scope) => T): T;
    <T>(scope: Scope, callback: (scope: Scope) => T): T;
};

Creates a new scope with and executes the given operation within. The scope is automatically removed once the operation finishes or throws.
Set the given scope as the active scope in the callback.

function withStaticSpan

withStaticSpan: (
    callback: BeforeSendStaticSpanCallback
) => BeforeSendStreamedSpanCallback;

A wrapper to use the static, transaction-based span format in your beforeSendSpan callback.
When using traceLifecycle: 'static', wrap your callback with this function to receive and return a static span instead of a StreamedSpanJSON.
Parameter callback
A BeforeSendStaticSpanCallback that receives and returns a static span.
Returns
A callback that is compatible with the beforeSendSpan option when using traceLifecycle: 'static'.
Example 1
Sentry.init({ traceLifecycle: 'static', beforeSendSpan: withStaticSpan((span) => { // span is of type SpanJSON return span; }), });

function withStreamedSpan

withStreamedSpan: (
    callback: (span: StreamedSpanJSON) => StreamedSpanJSON
) => BeforeSendStreamedSpanCallback;

A wrapper to explicitly use the streamed span format in your beforeSendSpan callback.
Parameter callback
The callback function that receives and returns a StreamedSpanJSON.
Returns
The provided callback.
Deprecated
beforeSendSpan callbacks receive StreamedSpanJSON by default. This function returns the callback unchanged and will be removed in SDK version 12.

function zodErrorsIntegration

zodErrorsIntegration: (
    options?: ZodErrorsOptions | undefined
) => import('..').Integration & { name: 'ZodErrors' };

Sentry integration to process Zod errors, making them easier to work with in Sentry.

Classes

class Client

abstract class Client<O extends ClientOptions = ClientOptions> {}

Base implementation for all JavaScript SDK clients.
Call the constructor with the corresponding options specific to the client subclass. To access these options later, use Client.getOptions.
If a Dsn is specified in the options, it will be parsed and stored. Use Client.getDsn to retrieve the Dsn at any moment. In case the Dsn is invalid, the constructor will throw a SentryException. Note that without a valid Dsn, the SDK will not send any events to Sentry.
Before sending an event, it is passed through Client._prepareEvent to add SDK information and scope data (breadcrumbs and context). To add more custom information, override this method and extend the resulting prepared event.
To issue automatically created events (e.g. via instrumentation), use Client.captureEvent. It will prepare the event and pass it through the callback lifecycle. To issue auto-breadcrumbs, use Client.addBreadcrumb.
Example 1
class NodeClient extends Client { public constructor(options: NodeOptions) { super(options); }
// ... }

constructor

protected constructor(options: ClientOptions<BaseTransportOptions>);

Initializes this client instance.
Parameter options
Options for the client.

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.

method captureException

captureException: (
    exception: unknown,
    hint?: EventHint,
    scope?: 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.

method captureMessage

captureMessage: (
    message: ParameterizedString,
    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.

method captureSession

captureSession: (session: Session) => void;

Captures a session.

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
{Promise} A promise which resolves to true if the flush completes successfully before the timeout, or false if it doesn't.

method dispose

dispose: () => void;

Disposes of the client and releases all resources.
Subclasses should override this method to clean up their own resources, including invoking any callbacks registered via Client.registerCleanup. The base implementation is a no-op and does NOT execute registered cleanup callbacks.
After calling dispose(), the client should not be used anymore.

method emit

emit: {
    (hook: 'spanStart', span: Span): void;
    (
        hook: 'prepareSpanScope',
        spanScope: { scope: Scope; parentSpan: Span }
    ): void;
    (
        hook: 'beforeSampling',
        samplingData: {
            spanAttributes: SpanAttributes;
            spanName: string;
            parentSampled?: boolean;
            parentSampleRate?: number;
            parentContext?: SpanContextData;
        },
        samplingDecision: { decision: boolean }
    ): void;
    (hook: 'spanEnd', span: Span): void;
    (hook: 'beforeIdleSpanEnd', idleSpan: Span): void;
    (hook: 'afterSpanEnd', immutableSpan: Readonly<Span>): void;
    (hook: 'afterSegmentSpanEnd', immutableSegmentSpan: Readonly<Span>): void;
    (hook: 'preprocessSpan', streamedSpanJSON: StreamedSpanJSON): void;
    (hook: 'processSpan', streamedSpanJSON: StreamedSpanJSON): void;
    (hook: 'processSegmentSpan', streamedSpanJSON: StreamedSpanJSON): void;
    (hook: 'idleSpanEnableAutoFinish', span: Span): void;
    (hook: 'beforeEnvelope', envelope: Envelope): void;
    (hook: 'afterEnvelope', envelope: Envelope): void;
    (hook: 'applyFrameMetadata', event: Event): void;
    (hook: 'beforeSendEvent', event: Event, hint?: EventHint): void;
    (hook: 'beforeSendSession', session: SessionAggregates | Session): void;
    (hook: 'preprocessEvent', event: Event, hint?: EventHint): void;
    (hook: 'postprocessEvent', 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: 'openFeedbackWidget'): void;
    (hook: 'replayStart', event: ReplayStartEvent): void;
    (hook: 'replayEnd', event: ReplayEndEvent): void;
    (
        hook: 'startPageLoadSpan',
        options: StartSpanOptions,
        traceOptions?: { sentryTrace?: string; baggage?: string }
    ): void;
    (hook: 'endPageloadSpan'): void;
    (hook: 'afterStartPageLoadSpan', span: Span): void;
    (
        hook: 'beforeStartNavigationSpan',
        options: StartSpanOptions,
        navigationOptions?: { isRedirect?: boolean; url?: string }
    ): void;
    (
        hook: 'startNavigationSpan',
        options: StartSpanOptions,
        navigationOptions?: { isRedirect?: boolean; url?: string }
    ): void;
    (
        hook: 'beforeOutgoingRequestSpan',
        span: Span,
        hint: XhrBreadcrumbHint | FetchBreadcrumbHint
    ): void;
    (
        hook: 'beforeOutgoingRequestBreadcrumb',
        breadcrumb: Breadcrumb,
        hint: XhrBreadcrumbHint | FetchBreadcrumbHint
    ): void;
    (hook: 'flush'): void;
    (hook: 'flushTraceSpans', traceId: string): void;
    (hook: 'close'): void;
    (hook: 'beforeCaptureLog', log: Log): void;
    (hook: 'afterCaptureLog', log: Log): void;
    (hook: 'flushLogs'): void;
    (hook: 'afterCaptureMetric', metric: Metric): void;
    (hook: 'flushMetrics'): void;
    (hook: 'processMetric', metric: Metric): void;
    (
        hook: 'httpServerRequest',
        request: unknown,
        response: unknown,
        normalizedRequest: RequestEventData
    ): void;
    (hook: 'startUIProfiler'): void;
    (hook: 'stopUIProfiler'): void;
    (hook: 'orchestrion.module-injected', moduleName: string): void;
};

Fire a hook whenever a span starts.
A hook that is called right before a span is created; listeners mutate the passed object.
A hook that is called every time before a span is sampled.
Fire a hook whenever a span ends.
Fire a hook before an idle span ends and its end timestamp is finalized.
Fire a hook event after a span ends and the spanEnd hook has run.
Fire a hook event after a segment span ends and the spanEnd hook has run.
Fire a hook event to preprocess a span JSON before the processSpan and processSegmentSpan hooks run.
Fire a hook event when a span JSON is processed, to add some data to the span JSON.
Fire a hook event for when a segment span JSON is processed, to add some data to the segment span JSON.
Fire a hook indicating that an idle span is allowed to auto finish.
Fire a hook event for envelope creation and sending. Expects to be given an envelope as the second argument.
Fire a hook event after an envelope has been accepted by the transport.
Fire a hook indicating that stack frame metadata should be applied to the event passed to the hook.
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 before sending a session/aggregates. Expects to be given the prepared session/aggregates as second 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 event to process a user on an event before it is sent to Sentry, after all other processors have run. Expects to be given an Event & EventHint as the second/third argument.
Fire a hook event after sending an event. Expects to be given an Event 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.
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.
Fire a hook event for when the feedback widget is opened in a user's browser
Fire a hook event when a replay session starts recording.
Fire a hook event when a replay session stops recording.
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 the end of a page load span.
Emit a hook event for browser tracing integrations to trigger after the pageload span was started.
Emit a hook event for triggering right before a navigation span is started.
Emit a hook event for browser tracing integrations to trigger a span for a navigation.
Emit a hook event for GraphQL client integration to enhance a span with request data.
Emit a hook event for GraphQL client integration to enhance a breadcrumb with request data.
Emit a hook event for client flush
Fire a hook event indicating that spans of a single trace should be flushed eagerly.
Emit a hook event for client close
Emit a hook event for client before capturing a log. This hooks runs before beforeSendLog is fired.
Emit a hook event for client after capturing a log.
Emit a hook event for client flush logs
Emit a hook event for client after capturing a metric.
Emit a hook event for client flush metrics
Emit a hook event for client to process a metric before it is captured. This hook is called before the beforeSendMetric callback is fired.
Emit a hook event for client when a http server request is started. This hook is called after request isolation, but before the request is processed.
Emit a hook event for starting the UI Profiler.
Emit a hook event for stopping the UI Profiler.
Emit a hook when an instrumented module is injected (runtime module hook or bundler-transformed module load).

method eventFromException

abstract eventFromException: (
    _exception: unknown,
    _hint?: EventHint
) => PromiseLike<Event>;

Creates an Event from all inputs to captureException and non-primitive inputs to captureMessage.

method eventFromMessage

abstract 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 getDataCollectionOptions

getDataCollectionOptions: () => ResolvedDataCollection;

Get the resolved data collection configuration.

method getDsn

getDsn: () => DsnComponents | undefined;

Get the current Dsn.

method getEventProcessors

getEventProcessors: () => EventProcessor[];

Get all installed event processors.

method getIntegrationByName

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

Gets an installed integration by its name.
Returns
{Integration|undefined} The installed integration or undefined if no integration with that name was installed.

method getIntegrationNames

getIntegrationNames: () => string[];

Returns the names of all installed integrations.

method getOptions

getOptions: () => O;

Get the current options.

method getSdkMetadata

getSdkMetadata: () => SdkMetadata | undefined;

Get the SDK metadata.
See Also
- SdkMetadata

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.

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: 'prepareSpanScope',
        callback: (spanScope: { scope: Scope; parentSpan: Span }) => void
    ): () => void;
    (
        hook: 'beforeSampling',
        callback: (
            samplingData: {
                spanAttributes: SpanAttributes;
                spanName: string;
                parentSampled?: boolean;
                parentSampleRate?: number;
                parentContext?: SpanContextData;
            },
            samplingDecision: { decision: boolean }
        ) => void
    ): void;
    (hook: 'spanEnd', callback: (span: Span) => void): () => void;
    (hook: 'beforeIdleSpanEnd', callback: (idleSpan: Span) => void): () => void;
    (
        hook: 'afterSpanEnd',
        callback: (immutableSegmentSpan: Readonly<Span>) => void
    ): () => void;
    (
        hook: 'afterSegmentSpanEnd',
        callback: (immutableSegmentSpan: Readonly<Span>) => void
    ): () => void;
    (
        hook: 'preprocessSpan',
        callback: (streamedSpanJSON: StreamedSpanJSON) => void
    ): () => void;
    (
        hook: 'processSpan',
        callback: (streamedSpanJSON: StreamedSpanJSON) => void
    ): () => void;
    (
        hook: 'processSegmentSpan',
        callback: (streamedSpanJSON: StreamedSpanJSON) => void
    ): () => void;
    (
        hook: 'idleSpanEnableAutoFinish',
        callback: (span: Span) => void
    ): () => void;
    (hook: 'beforeEnvelope', callback: (envelope: Envelope) => void): () => void;
    (hook: 'afterEnvelope', callback: (envelope: Envelope) => void): () => void;
    (hook: 'applyFrameMetadata', callback: (event: Event) => void): () => void;
    (
        hook: 'beforeSendEvent',
        callback: (event: Event, hint?: EventHint) => void
    ): () => void;
    (
        hook: 'beforeSendSession',
        callback: (session: SessionAggregates | Session) => void
    ): () => void;
    (
        hook: 'preprocessEvent',
        callback: (event: Event, hint?: EventHint) => void
    ): () => void;
    (
        hook: 'postprocessEvent',
        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: 'openFeedbackWidget', callback: () => void): () => void;
    (
        hook: 'replayStart',
        callback: (event: ReplayStartEvent) => void
    ): () => void;
    (hook: 'replayEnd', callback: (event: ReplayEndEvent) => void): () => void;
    (
        hook: 'startPageLoadSpan',
        callback: (
            options: StartSpanOptions,
            traceOptions?: { sentryTrace?: string; baggage?: string }
        ) => void
    ): () => void;
    (hook: 'endPageloadSpan', callback: () => void): () => void;
    (hook: 'afterStartPageLoadSpan', callback: (span: Span) => void): () => void;
    (
        hook: 'beforeStartNavigationSpan',
        callback: (
            options: StartSpanOptions,
            navigationOptions?: { isRedirect?: boolean; url?: string }
        ) => void
    ): () => void;
    (
        hook: 'startNavigationSpan',
        callback: (
            options: StartSpanOptions,
            navigationOptions?: { isRedirect?: boolean; url?: string }
        ) => void
    ): () => void;
    (
        hook: 'beforeOutgoingRequestSpan',
        callback: (
            span: Span,
            hint: XhrBreadcrumbHint | FetchBreadcrumbHint
        ) => void
    ): () => void;
    (
        hook: 'beforeOutgoingRequestBreadcrumb',
        callback: (
            breadcrumb: Breadcrumb,
            hint: XhrBreadcrumbHint | FetchBreadcrumbHint
        ) => void
    ): () => void;
    (hook: 'flush', callback: () => void): () => void;
    (hook: 'flushTraceSpans', callback: (traceId: string) => void): () => void;
    (hook: 'close', callback: () => void): () => void;
    (hook: 'beforeCaptureLog', callback: (log: Log) => void): () => void;
    (hook: 'afterCaptureLog', callback: (log: Log) => void): () => void;
    (hook: 'flushLogs', callback: () => void): () => void;
    (hook: 'afterCaptureMetric', callback: (metric: Metric) => void): () => void;
    (hook: 'flushMetrics', callback: () => void): () => void;
    (hook: 'processMetric', callback: (metric: Metric) => void): () => void;
    (
        hook: 'httpServerRequest',
        callback: (
            request: unknown,
            response: unknown,
            normalizedRequest: RequestEventData
        ) => void
    ): () => void;
    (hook: 'startUIProfiler', callback: () => void): () => void;
    (hook: 'stopUIProfiler', callback: () => void): () => void;
    (
        hook: 'orchestrion.module-injected',
        callback: (moduleName: string) => void
    ): () => void;
};

Register a callback for whenever a span is started. Receives the span as argument.
Returns
{() => void} A function that, when executed, removes the registered callback.
Register a callback that can adjust the scope and the parent span right before a span is created. Listeners mutate the passed spanScope object. The Node SDK uses this to continue the trace of a remote (incoming) parent through the propagation context of a forked scope.
Returns
{() => void} 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
{() => void} A function that, when executed, removes the registered callback.
Register a callback for after a span is ended. NOTE: The span cannot be mutated anymore in this callback. Receives the span as argument.
Returns
{() => void} A function that, when executed, removes the registered callback.
Register a callback before an idle span ends and its end timestamp is finalized.
Register a callback for after a span is ended and the spanEnd hook has run. NOTE: The span cannot be mutated anymore in this callback.
Register a callback for after a segment span is ended and the segmentSpanEnd hook has run. NOTE: The segment span cannot be mutated anymore in this callback.
Register a callback to preprocess a span JSON _before_ it is passed to the processSpan and processSegmentSpan hooks. Use this to backfill data that subsequent hooks rely on.
Register a callback for when a span JSON is processed, to add some data to the span JSON.
Register a callback for when a segment span JSON is processed, to add some data to the segment span JSON.
Register a callback for when an idle span is allowed to auto-finish.
Returns
{() => void} A function that, when executed, removes the registered callback.
Register a callback for transaction start and finish.
Returns
{() => void} A function that, when executed, removes the registered callback.
Register a callback for after an envelope has been accepted by the transport.
Returns
{() => void} 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
{() => void} 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
{() => void} A function that, when executed, removes the registered callback.
Register a callback for before sending a session or session aggregrates.. Receives the session/aggregate as second argument.
Returns
{() => void} 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
{() => void} A function that, when executed, removes the registered callback.
Register a callback for postprocessing an event, after it was passed to (global) event processors, before it is being sent. Receives an Event & EventHint as arguments.
Returns
{() => void} A function that, when executed, removes the registered callback.
Register a callback for when an event has been sent.
Returns
{() => void} A function that, when executed, removes the registered callback.
Register a callback before a breadcrumb is added.
Returns
{() => void} A function that, when executed, removes the registered callback.
Register a callback when a DSC (Dynamic Sampling Context) is created.
Returns
{() => void} 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
{() => void} A function that, when executed, removes the registered callback.
Register a callback when the feedback widget is opened in a user's browser
A hook that is called when a replay session starts recording (either session or buffer mode).
Returns
{() => void} A function that, when executed, removes the registered callback.
A hook that is called when a replay session stops recording, either manually or due to an internal condition such as maxReplayDuration expiry, send failure, or mutation limit.
Returns
{() => void} 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
{() => void} A function that, when executed, removes the registered callback.
A hook for the browser tracing integrations to trigger the end of a page load span.
Returns
{() => void} A function that, when executed, removes the registered callback.
A hook for the browser tracing integrations to trigger after the pageload span was started.
Returns
{() => void} A function that, when executed, removes the registered callback.
A hook for triggering right before a navigation span is started.
Returns
{() => void} A function that, when executed, removes the registered callback.
A hook for browser tracing integrations to trigger a span for a navigation.
Returns
{() => void} A function that, when executed, removes the registered callback.
A hook for GraphQL client integration to enhance a span with request data.
Returns
A function that, when executed, removes the registered callback.
A hook for GraphQL client integration to enhance a breadcrumb with request data.
Returns
A function that, when executed, removes the registered callback.
A hook that is called when the client is flushing
Returns
{() => void} A function that, when executed, removes the registered callback.
A hook that is called when spans of a single trace should be flushed eagerly, ahead of the trace's regular flush point. Only runtimes with a span streaming buffer (e.g. the Cloudflare SDK) listen to this hook.
Returns
{() => void} A function that, when executed, removes the registered callback.
A hook that is called when the client is closing
Returns
{() => void} A function that, when executed, removes the registered callback.
A hook that is called before a log is captured. This hooks runs before beforeSendLog is fired.
Returns
{() => void} A function that, when executed, removes the registered callback.
A hook that is called after a log is captured
Returns
{() => void} A function that, when executed, removes the registered callback.
A hook that is called when the client is flushing logs
Returns
{() => void} A function that, when executed, removes the registered callback.
A hook that is called after capturing a metric. This hooks runs after beforeSendMetric is fired.
Returns
{() => void} A function that, when executed, removes the registered callback.
A hook that is called when the client is flushing metrics
Returns
{() => void} A function that, when executed, removes the registered callback.
A hook that is called when a metric is processed before it is captured and before the beforeSendMetric callback is fired.
Returns
{() => void} A function that, when executed, removes the registered callback.
A hook that is called when a http server request is started. This hook is called after request isolation, but before the request is processed.
Returns
{() => void} A function that, when executed, removes the registered callback.
A hook that is called when the UI Profiler should start profiling.
This hook is called when running Sentry.uiProfiler.startProfiler().
Returns
{() => void} A function that, when executed, removes the registered callback.
A hook that is called when the UI Profiler should stop profiling.
This hook is called when running Sentry.uiProfiler.stopProfiler().
Returns
{() => void} A function that, when executed, removes the registered callback.
A hook that is called when an instrumented module is injected — at runtime by the module hook, or at load of a bundler-transformed module. Channel-based integrations use it to subscribe their diagnostics-channel listeners lazily, only once the module they instrument is actually loaded. Receives the injected module name.
Returns
{() => void} A function that, when executed, removes the registered callback.

method recordDroppedEvent

recordDroppedEvent: (
    reason: EventDropReason,
    category: DataCategory,
    count?: number
) => void;

Record on the client that an event got dropped (ie, an event that will not be sent to Sentry).

method registerCleanup

registerCleanup: (callback: () => void) => void;

Register a cleanup function to be called when the client is disposed. This is useful for integrations that need to clean up global state.
NOTE: This is a no-op in the base Client class. Subclasses like ServerRuntimeClient override this method to actually register and execute cleanup callbacks.

method sendEnvelope

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

Send an envelope to Sentry.

method sendEvent

sendEvent: (event: Event, hint?: EventHint) => void;

Send a fully prepared event to Sentry.

method sendSession

sendSession: (session: Session | SessionAggregates) => void;

Send a session or session aggregrates to Sentry.

class LRUMap

class LRUMap<K, V> {}

A simple Least Recently Used map

constructor

constructor(_maxSize: number);

property size

readonly size: number;

Get the current size of the cache

method clear

clear: () => void;

Clear all entries

method get

get: (key: K) => V | undefined;

Get an entry or undefined if it was not in the cache. Re-inserts to update the recently used order

method keys

keys: () => Array<K>;

Get all the keys

method remove

remove: (key: K) => V | undefined;

Remove an entry and return the entry if it was in the cache

method set

set: (key: K, value: V) => void;

Insert an entry and evict an older entry if we've reached maxSize

method values

values: () => Array<V>;

Get all the values

class Scope

class Scope {}

Holds additional event information.

constructor

constructor();

property refs

refs: Record<string, unknown>;

A place to stash references to objects that are associated with this scope but should not be serialized, such as the currently active span (core) or the OpenTelemetry context (opentelemetry). These are cloned as-is (shallow) when the scope is cloned, so they survive clone().
This is non-enumerable so it does not leak into toJSON, Object.keys or structural comparisons.

method addAttachment

addAttachment: (attachment: Attachment) => this;

Add an attachment to the scope.

method addBreadcrumb

addBreadcrumb: (breadcrumb: Breadcrumb, maxBreadcrumbs?: number) => this;

Adds a breadcrumb to the scope. By default, the last 100 breadcrumbs are kept.

method addEventProcessor

addEventProcessor: (callback: EventProcessor) => this;

Add an event processor that will be called before an event is sent.

method addScopeListener

addScopeListener: (callback: (scope: Scope) => void) => void;

method captureEvent

captureEvent: (event: Event, hint?: EventHint) => string;

Capture a Sentry event for this scope.
Returns
{string} The id of the captured event.

method captureException

captureException: (exception: unknown, hint?: EventHint) => string;

Capture an exception for this scope.
Returns
{string} The id of the captured Sentry event.

method captureMessage

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

Capture a message for this scope.
Returns
{string} The id of the captured message.

method clearAttachments

clearAttachments: () => this;

Clear all attachments from the scope.

method clearBreadcrumbs

clearBreadcrumbs: () => this;

Clear all breadcrumbs from the scope.

method clone

clone: () => Scope;

Clone all data from this scope into a new scope.

method getClient

getClient: <C extends Client<ClientOptions<BaseTransportOptions>>>() =>
    | C
    | undefined;

Get the client assigned to this scope.

method getLastBreadcrumb

getLastBreadcrumb: () => Breadcrumb | undefined;

Get the last breadcrumb of the scope.

method getPropagationContext

getPropagationContext: () => PropagationContext;

Get propagation context from the scope, used for distributed tracing

method getScopeData

getScopeData: () => ScopeData;

Get the data of this scope, which should be applied to an event during processing.

method getSession

getSession: () => Session | undefined;

Get the session from the scope.

method getUser

getUser: () => User | undefined;

Get the user from this scope.

method lastEventId

lastEventId: () => string | undefined;

Get the ID of the last captured error event. This is generally only available on the isolation scope.

method removeAttribute

removeAttribute: (key: string) => this;

Removes the attribute with the given key from the scope.
Parameter key
The attribute key.
Example 1
scope.removeAttribute('is_admin');

method setAttribute

setAttribute: <
    T extends RawAttribute<T> extends { value: any } | { unit: any }
        ? AttributeObject
        : unknown
>(
    key: string,
    value: RawAttribute<T>
) => this;

Sets an attribute onto the scope.
These attributes are applied to logs, metrics and streamed spans.
Supported attribute value types are string, number, boolean, string[], number[] and boolean[].
Parameter key
The attribute key.
Parameter value
The attribute value.
Example 1
scope.setAttribute('is_admin', true); scope.setAttribute('render_duration', 150);

method setAttributes

setAttributes: <T extends Record<string, unknown>>(
    newAttributes: RawAttributes<T>
) => this;

Sets attributes onto the scope.
These attributes are applied to logs, metrics and streamed spans.
Supported attribute value types are string, number, boolean, string[], number[] and boolean[].
Parameter newAttributes
The attributes to set on the scope, as key-value pairs.
Example 1
scope.setAttributes({ is_admin: true, payment_selection: 'credit_card', render_duration: 150, });

method setClient

setClient: (client: Client | undefined) => void;

Update the client assigned to this scope. Note that not every scope will have a client assigned - isolation scopes & the global scope will generally not have a client, as well as manually created scopes.

method setContext

setContext: (key: string, context: Context | null) => this;

Sets context data with the given name. Data passed as context will be normalized. You can also pass null to unset the context. Note that context data will not be merged - calling setContext will overwrite an existing context with the same key.

method setConversationId

setConversationId: (conversationId: string | null | undefined) => this;

Set the conversation ID for this scope. Set to null to unset the conversation ID.

method setExtra

setExtra: (key: string, extra: Extra) => this;

Set a single key:value extra entry that will be sent as extra data with the event.

method setExtras

setExtras: (extras: Extras) => this;

Set an object that will be merged into existing extra on the scope, and will be sent as extra data with the event.

method setFingerprint

setFingerprint: (fingerprint: string[]) => this;

Sets the fingerprint on the scope to send with the events.
Parameter fingerprint
Fingerprint to group events in Sentry.

method setLastEventId

setLastEventId: (lastEventId: string | undefined) => void;

Set the ID of the last captured error event. This is generally only captured on the isolation scope.

method setLevel

setLevel: (level: SeverityLevel) => this;

Sets the level on the scope for future events.

method setPropagationContext

setPropagationContext: (context: PropagationContext) => this;

Add propagation context to the scope, used for distributed tracing

method setSDKProcessingMetadata

setSDKProcessingMetadata: (newData: SdkProcessingMetadata) => this;

Add data which will be accessible during event processing but won't get sent to Sentry.

method setSession

setSession: (session?: Session) => this;

Set the session for the scope.

method setTag

setTag: (key: string, value: Primitive) => this;

Set a single tag that will be sent as tags data with the event.

method setTags

setTags: (tags: { [key: string]: Primitive }) => this;

Set an object that will be merged into existing tags on the scope, and will be sent as tags data with the event.

method setTransactionName

setTransactionName: (name?: string) => this;

Sets the transaction name on the scope so that the name of e.g. taken server route or the page location is attached to future events.
IMPORTANT: Calling this function does NOT change the name of the currently active root span. If you want to change the name of the active root span, use Sentry.updateSpanName(rootSpan, 'new name') instead.
By default, the SDK updates the scope's transaction name automatically on sensible occasions, such as a page navigation or when handling a new request on the server.

method setUser

setUser: (user: User | null) => this;

Set the user for this scope. Set to 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

class SentryError

class SentryError extends Error {}

An error emitted by Sentry SDKs and related utilities.
Deprecated
This class is no longer used and will be removed in a future version. Use Error instead.

constructor

constructor(message: string, logLevel?: ConsoleLevel);

property logLevel

logLevel: ConsoleLevel;

property message

message: string;

class SentryNonRecordingSpan

class SentryNonRecordingSpan implements Span {}

A Sentry Span that is non-recording, meaning it will not be sent to Sentry.

constructor

constructor(spanContext?: SentryNonRecordingSpanArguments);

property dropReason

dropReason?: EventDropReason;

Reason why this span was dropped, if applicable ('ignored' or 'sample_rate'). Used to propagate the correct client report outcome to descendant spans when span streaming is enabled.

method addEvent

addEvent: (
    _name: string,
    _attributesOrStartTime?: SpanAttributes | SpanTimeInput,
    _startTime?: SpanTimeInput
) => this;

method addLink

addLink: (_link: unknown) => this;

method addLinks

addLinks: (_links: unknown[]) => this;

method end

end: (_timestamp?: SpanTimeInput) => void;

method isRecording

isRecording: () => boolean;

method setAttribute

setAttribute: (_key: string, _value: SpanAttributeValue | undefined) => this;

method setAttributes

setAttributes: (_values: SpanAttributes) => this;

method setStatus

setStatus: (_status: SpanStatus) => this;

method spanContext

spanContext: () => SpanContextData;

method updateName

updateName: (_name: string) => this;

class SentrySpan

class SentrySpan implements Span {}

Span contains all data about a span

method addEvent

addEvent: (
    name: string,
    attributesOrStartTime?: SpanAttributes | SpanTimeInput,
    startTime?: SpanTimeInput
) => this;

method addLink

addLink: (link: SpanLink) => this;

method addLinks

addLinks: (links: SpanLink[]) => this;

method end

end: (endTimestamp?: SpanTimeInput) => void;

method isRecording

isRecording: () => boolean;

method setAttribute

setAttribute: (key: string, value: SpanAttributeValue | undefined) => this;

method setAttributes

setAttributes: (attributes: SpanAttributes) => this;

method setStatus

setStatus: (value: SpanStatus) => this;

method spanContext

spanContext: () => SpanContextData;

method updateName

updateName: (name: string) => this;

class SpanBuffer

class SpanBuffer {}

A buffer for serialized streamed span JSON objects that flushes them to Sentry in Span v2 envelopes. Handles per-trace timeout-based flushing, size thresholds, and graceful shutdown. Also handles computation of the Dynamic Sampling Context (DSC) for the trace, if it wasn't yet frozen onto the segment span.
For this, we need the reference to the segment span instance, from which we compute the DSC. Doing this in the buffer ensures that we compute the DSC as late as possible, allowing span name and data updates up to this point. Worth noting here that the segment span is likely still active and modifyable when child spans are added to the buffer.

constructor

constructor(
    client: Client<ClientOptions<BaseTransportOptions>>,
    options?: SpanBufferOptions
);

method add

add: (spanJSON: SerializedStreamedSpanWithSegmentSpan) => void;

Add a span to the buffer.

method drain

drain: () => void;

Drain and flush all buffered traces.

method flush

flush: (traceId: string) => void;

Flush spans of a specific trace. In contrast to SpanBuffer.drain, this method does not flush all traces, but only the one with the given traceId.

class SyncPromise

class SyncPromise<T> implements PromiseLike<T> {}

Thenable class that behaves like a Promise and follows it's interface but is not async internally

constructor

constructor(executor: Executor<T>);

method catch

catch: <TResult = never>(
    onrejected?: (reason: any) => TResult | PromiseLike<TResult>
) => PromiseLike<T | TResult>;

method finally

finally: <TResult>(onfinally?: (() => void) | null) => PromiseLike<TResult>;

method then

then: <TResult1 = T, TResult2 = never>(
    onfulfilled?: (value: T) => TResult1 | PromiseLike<TResult1>,
    onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>
) => PromiseLike<TResult1 | TResult2>;

Interfaces

interface AggregationCounts

interface AggregationCounts {}

property crashed

crashed?: number;

Number of sessions that had unhandled errors

property errored

errored?: number;

Number of sessions that had handled errors

property exited

exited?: number;

Number of sessions that did not have errors

property started

started: string;

ISO Timestamp rounded to the second

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;

property free_memory

free_memory?: number;

interface AsyncContextStrategy

interface AsyncContextStrategy {}

Private API with no semver guarantees!
Strategy used to track async context.

property continueTrace

continueTrace?: typeof continueTrace;

Continue a trace from sentry-trace and baggage values. These values can be obtained from incoming request headers, or in the browser from <meta name="sentry-trace"> and <meta name="baggage"> HTML tags.

property getActiveSpan

getActiveSpan?: typeof getActiveSpan;

Get the currently active span.

property getCurrentScope

getCurrentScope: () => Scope;

Get the currently active scope.

property getIsolationScope

getIsolationScope: () => Scope;

Get the currently active isolation scope.

property getTraceData

getTraceData?: typeof getTraceData;

Get trace data as serialized string values for propagation via sentry-trace and baggage.

property getTracingChannelBinding

getTracingChannelBinding?: () => TracingChannelBinding | undefined;

Get the runtime store required to bind tracing channels to an active span.

property isTracingSuppressed

isTracingSuppressed?: typeof isTracingSuppressed;

If tracing is suppressed in the given scope.

property startNewTrace

startNewTrace?: typeof startNewTrace;

Start a new trace, ensuring all spans in the callback share the same traceId.

property suppressTracing

suppressTracing?: typeof suppressTracing;

Suppress tracing in the given callback, ensuring no spans are generated inside of it.

property withActiveSpan

withActiveSpan?: typeof withActiveSpan;

Make a span the active span in the context of the callback.

property withIsolationScope

withIsolationScope: <T>(callback: (isolationScope: Scope) => T) => T;

Fork the isolation scope inside of the provided callback.

property withScope

withScope: <T>(callback: (isolationScope: Scope) => T) => T;

Fork the current scope inside of the provided callback.

property withSetIsolationScope

withSetIsolationScope: <T>(
    isolationScope: Scope,
    callback: (isolationScope: Scope) => T
) => T;

Set the provided isolation as the current isolation scope inside of the provided callback.

property withSetScope

withSetScope: <T>(scope: Scope, callback: (scope: Scope) => T) => T;

Set the provided scope as the current scope inside of the provided callback.

interface Attachment

interface Attachment {}

An attachment to an event. This is used to upload arbitrary data to Sentry.
Please take care to not add sensitive information in attachments.
https://develop.sentry.dev/sdk/envelopes/#attachment

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

interface BaseTransportOptions

interface BaseTransportOptions extends InternalBaseTransportOptions {}

property headers

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

Custom HTTP headers to be added to requests made by the transport.

property url

url: string;

interface Breadcrumb {}

Sentry uses breadcrumbs to create a trail of events that happened prior to an issue. These events are very similar to traditional logs but can record more rich structured data.
https://develop.sentry.dev/sdk/event-payloads/breadcrumbs/

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

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.

event_id?: string;

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.

message?: string;

If a message is provided, it is rendered as text with all whitespace preserved.
Human-readable message for the breadcrumb.

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)

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

interface BreadcrumbHint

interface BreadcrumbHint {}

JSDoc

index signature

[key: string]: any;

interface Carrier

interface Carrier {}

An object that contains globally accessible properties and maintains a scope stack.

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 CoreOptions.denyUrls. By default, all errors will be sent.
Behavior of the allowUrls option is controlled by the Sentry.eventFiltersIntegration integration. If the event filters integration is not installed, the allowUrls option will not have any effect.
[]

property attachStacktrace

attachStacktrace?: boolean;

Stack traces are automatically attached to events that don't otherwise have one. This applies to events captured with Sentry.captureMessage and to non-Error values passed to Sentry.captureException. Set this to false to disable attaching these stack traces.
Grouping in Sentry is different for events with stack traces and without. As a result, you will get new groups as you enable or disable this flag for certain events.
true

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 beforeSendLog

beforeSendLog?: (log: Log) => Log | null;

An event-processing callback for logs, guaranteed to be invoked after all other log processors. This allows a log to be modified or dropped before it's sent.
Note that you must return a valid log from this callback. If you do not wish to modify the log, simply return it at the end. Returning null will cause the log to be dropped.
undefined
Parameter log
The log generated by the SDK.
Returns
A new log that will be sent | null.

property beforeSendMetric

beforeSendMetric?: (metric: Metric) => Metric | null;

An event-processing callback for metrics, guaranteed to be invoked after all other metric processors. This allows a metric to be modified or dropped before it's sent.
Note that you must return a valid metric from this callback. If you do not wish to modify the metric, simply return it at the end. Returning null will cause the metric to be dropped.
undefined
Parameter metric
The metric generated by the SDK.
Returns
A new metric that will be sent | null.

property beforeSendSpan

beforeSendSpan?: BeforeSendStreamedSpanCallback;

This function can be defined to modify a span before it's sent.
The callback receives and returns a StreamedSpanJSON, matching the default traceLifecycle: 'stream'. When using traceLifecycle: 'static', wrap your callback with withStaticSpan to receive and return a SpanJSON instead.
A callback that doesn't match the configured traceLifecycle is never invoked.
Parameter span
The span generated by the SDK.
Returns
The modified span payload that will 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.
Important: This callback is ignored by default! It only runs if traceLifecycle is set to 'static'.
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 transaction event generated by the SDK.
Parameter hint
Event metadata useful for processing.
Returns
A new event that will be sent | null.
See Also
- ClientOptions.beforeSendSpan
Deprecated
This option only has an effect if traceLifecycle is set to 'static'. With span streaming (traceLifecycle: 'stream', the default), the SDK ignores it. Use beforeSendSpan instead, which works with both trace lifecycles. beforeSendTransaction will be removed in v12 of the SDK.

property dataCollection

dataCollection?: DataCollection;

Controls what data the SDK collects and sends to Sentry. All fields are optional — omitted fields use the documented defaults.
Configure each category of collected data (user info, cookies, headers, query params, request/response bodies, gen AI inputs/outputs, etc.) individually.

property debug

debug?: boolean;

Enable debug functionality in the SDK itself. If debug is set to true the SDK will attempt to print out useful debugging information about what the SDK is doing.
false

property denyUrls

denyUrls?: Array<string | RegExp>;

A pattern for error URLs which should not be sent to Sentry. To allow certain errors instead, use CoreOptions.allowUrls. By default, all errors will be sent.
Behavior of the denyUrls option is controlled by the Sentry.eventFiltersIntegration integration. If the event filters integration is not installed, the denyUrls option will not have any effect.
[]

property dist

dist?: string | undefined;

Sets the distribution of the application. Distributions are used to disambiguate build or deployment variants of the same release of an application.
undefined

property dsn

dsn?: string | undefined;

The DSN tells the SDK where to send the events. If this is not set, the SDK will not send any events to Sentry.
undefined

property enabled

enabled?: boolean;

Specifies whether this SDK should send events to Sentry. Setting this to enabled: false doesn't prevent all overhead from Sentry instrumentation. To disable Sentry completely, depending on environment, call `Sentry.init conditionally.
true

property enhanceFetchErrorMessages

enhanceFetchErrorMessages?: 'always' | 'report-only' | false;

Controls whether and how to enhance fetch error messages by appending the request hostname. Generic fetch errors like "Failed to fetch" will be enhanced to include the hostname (e.g., "Failed to fetch (example.com)").
- 'always' (default): Modifies the actual error message directly. This may break third-party packages that rely on exact message matching (e.g., is-network-error, p-retry). - 'report-only': Only enhances the message when sending to Sentry. The original error message remains unchanged, preserving compatibility with third-party packages. - false: Disables hostname enhancement completely.
'always'

property environment

environment?: string | undefined;

The current environment of your application (e.g. "production").
Environments are case-sensitive. The environment name can't contain newlines, spaces or forward slashes, can't be the string "None", or exceed 64 characters. You can't delete environments, but you can hide them.
"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.
Behavior of the ignoreErrors option is controlled by the Sentry.eventFiltersIntegration integration. If the event filters integration is not installed, the ignoreErrors option will not have any effect.
[]

property ignoreSpans

ignoreSpans?: (string | RegExp | IgnoreSpanFilter)[];

A list of span names or patterns to ignore.
If you specify a pattern IgnoreSpanFilter, at least one of the properties (name, op, or attributes) must be set. When multiple properties are set, all must match for the span to be ignored.
[]

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.
Important: This option is ignored by default! It only has an effect if traceLifecycle is set to 'static'. Use ignoreSpans instead, which works with both trace lifecycles.
Behavior of the ignoreTransactions option is controlled by the Sentry.eventFiltersIntegration integration. If the event filters integration is not installed, the ignoreTransactions option will not have any effect.
[]
See Also
- ClientOptions.ignoreSpans
Deprecated
This option only has an effect if traceLifecycle is set to 'static'. With span streaming (traceLifecycle: 'stream', the default), the SDK ignores it. Use ignoreSpans instead, which works with both trace lifecycles. ignoreTransactions will be removed in v12.

property initialScope

initialScope?: CaptureContext;

Initial data to populate scope.
undefined

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. Sentry has a maximum payload size of 1MB and any events exceeding that payload size will be dropped.
100

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
3

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
1000

property orgId

orgId?: `${number}` | number;

The organization ID for your Sentry project.
The SDK will try to extract the organization ID from the DSN. If it cannot be found, or if you need to override it, you can provide the ID with this option. The organization ID is used for trace propagation and for features like strictTraceContinuation.

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 propagateTraceparent

propagateTraceparent?: boolean;

If set to true, the SDK propagates the W3C traceparent header to any outgoing requests, in addition to the sentry-trace and baggage headers. Use the CoreOptions.tracePropagationTargets option to control to which outgoing requests the header will be attached.
**Important:** If you set this option to true, make sure that you configured your servers' CORS settings to allow the traceparent header. Otherwise, requests might get blocked.
See Also
- https://www.w3.org/TR/trace-context/
  false

property release

release?: string | undefined;

Sets the release. Release names are strings, but some formats are detected by Sentry and might be rendered differently. Learn more about how to send release data so Sentry can tell you about regressions between releases and identify the potential source in the [releases documentation](https://docs.sentry.io/product/releases/)
undefined

property sampleRate

sampleRate?: number;

A global sample rate to apply to all error 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)
1.0

property sendClientReports

sendClientReports?: boolean;

Send SDK Client Reports, which are used to emit outcomes about events that the SDK dropped or failed to capture.
true

property stackParser

stackParser: StackParser;

A stack parser implementation. By default, a stack parser is supplied for all supported platforms.

property strictTraceContinuation

strictTraceContinuation?: boolean;

If set to true, the SDK will only continue a trace if the organization ID of the incoming trace found in the baggage header matches the organization ID of the current Sentry client.
The client's organization ID is extracted from the DSN or can be set with the orgId option.
If the organization IDs do not match, the SDK will start a new trace instead of continuing the incoming one. This is useful to prevent traces of unknown third-party services from being continued in your application.
false

property traceLifecycle

traceLifecycle?: 'static' | 'stream';

The trace lifecycle, determining whether spans are sent statically when the entire local span tree is complete, or streamed in batches, following interval- and action-based triggers.
'stream'

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. Matching is case-insensitive, so 'myApi.com' and /^myApi\.com/ both match a request to https://myapi.com.
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: TracesSamplerSamplingContext
) => 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. Set this and tracesSampleRate to undefined to disable tracing.
Will automatically be passed a context object of default and optional custom data.
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. Set this and tracesSampler to undefined to disable tracing.
undefined

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

interface CloudResourceContext

interface CloudResourceContext extends Record<string, unknown> {}

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;

interface Contexts

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

property app

app?: AppContext;

property cloud_resource

cloud_resource?: CloudResourceContext;

property culture

culture?: CultureContext;

property device

device?: DeviceContext;

property flags

flags?: FeatureFlagContext;

property os

os?: OsContext;

property profile

profile?: ProfileContext;

property response

response?: ResponseContext;

property state

state?: StateContext;

property trace

trace?: TraceContext;

interface ContinuousProfiler

interface ContinuousProfiler<T extends Client> {}

method initialize

initialize: (client: T) => void;

method start

start: () => void;

method stop

stop: () => void;

interface ContinuousThreadCpuProfile

interface ContinuousThreadCpuProfile {}

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

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]: unknown;

interface DataCollection

interface DataCollection {}

Controls what data the SDK collects and sends to Sentry.
All fields are optional. Omitted fields use the documented defaults.

property cookies

cookies?: CollectBehavior;

Controls cookie collection and sensitive value filtering. true

property databaseQueryData

databaseQueryData?: boolean;

Include data associated with database queries. This controls collection of bound query parameters, data payloads for write operations, and returned result data.
Sanitized or parameterized DB statements (db.query.text) are **not** controlled by this property. Structural metadata such as the database system, query summary, operation name, or the table being acted upon is also **always** collected. true

property frameContextLines

frameContextLines?: number;

Number of source code context lines to capture around stack frames. 5

property genAI

genAI?: {
    inputs?: boolean;
    outputs?: boolean;
};

Allow generative AI input/output recording when using the SDK's AI integrations.
These options do not add AI instrumentation on their own. The corresponding integration must still be enabled for any data to be captured. Integration-level options, when set, take precedence over these values. { inputs: true, outputs: true }

property graphQL

graphQL?: {
    document?: boolean;
    variables?: boolean;
};

Allow collection of GraphQL operation data when using the SDK's GraphQL integrations
These options do not add GraphQL instrumentation on their own. The corresponding integration must still be enabled for any data to be captured.
- document: attach the GraphQL document (query/mutation source text). - variables: attach the variables passed to GraphQL operations. { document: true, variables: true }

property httpBodies

httpBodies?: HttpBodyCollectionTarget[];

Which HTTP body types to collect. An omitted value collects all body types valid for the platform; an empty array ([]) disables body collection. ['incomingRequest', 'outgoingRequest', 'incomingResponse', 'outgoingResponse']

property httpHeaders

httpHeaders?: CollectBehavior | HttpHeadersCollection;

Controls HTTP header collection for requests and responses.
Accepts a CollectBehavior applied to both directions, or { request, response } to control each independently. { request: true, response: true }

property queues

queues?: boolean;

Include arguments passed to tasks within queues.
Structural metadata such as the messaging system, destination name, or operation is always collected. true

property stackFrameVariables

stackFrameVariables?: boolean | CollectBehavior;

Capture local variable values in stack frames.
Accepts a Boolean (true collects all variables, false collects none) or a CollectBehavior to filter which variables are sent by name ({ allow: [...] } / { deny: [...] }), matching against variable names.
Note: filtering by name requires knowing the variable names **as they appear after bundling**. Minifiers and other build-time transforms frequently rename local variables (e.g. password becomes a), so allow/deny terms configured against source names may not match the names captured at runtime. true

property urlQueryParams

urlQueryParams?: CollectBehavior;

Controls URL query parameter collection and sensitive value filtering. true

property userInfo

userInfo?: boolean;

Automatically populate user.* fields from instrumentation sources. true

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 {}

An event to be sent to Sentry.

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

property logentry

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

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?: RequestEventData;

property sdk

sdk?: SdkInfo;

property sdkProcessingMetadata

sdkProcessingMetadata?: SdkProcessingMetadata;

property server_name

server_name?: string;

property spans

spans?: SpanJSON[];

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 mechanism

mechanism?: Partial<Mechanism>;

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 sent. 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 | string;

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]: unknown;

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]: unknown;

interface FeatureFlagsIntegration

interface FeatureFlagsIntegration extends Integration {}

property addFeatureFlag

addFeatureFlag: (name: string, value: unknown) => void;

interface FeedbackEvent

interface FeedbackEvent extends Event {}

NOTE: These types are still considered Alpha and subject to change.

property contexts

contexts: Event['contexts'] & {
    feedback: FeedbackContext;
};

property type

type: 'feedback';

interface FeedbackInternalOptions

interface FeedbackInternalOptions
    extends FeedbackGeneralConfiguration,
        FeedbackThemeConfiguration,
        FeedbackTextConfiguration,
        FeedbackCallbacks {}

The integration's internal options member where every value should be set

interface FeedbackModalIntegration

interface FeedbackModalIntegration extends Integration {}

property createDialog

createDialog: (props: CreateDialogProps) => FeedbackDialog;

interface FeedbackScreenshotIntegration

interface FeedbackScreenshotIntegration extends Integration {}

property createInput

createInput: (props: CreateInputProps) => FeedbackScreenshotInput;

interface FetchBreadcrumbData

interface FetchBreadcrumbData {}

property 'url.fragment'

'url.fragment'?: string;

property 'url.query'

'url.query'?: string;

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;

Sanitized URL: the query string and fragment live in their own fields below.

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 FetchIntegrationOptions

interface FetchIntegrationOptions {}

property breadcrumbs

breadcrumbs?: boolean;

Whether breadcrumbs should be recorded for requests.
true

property shouldCreateSpanForRequest

shouldCreateSpanForRequest?: (url: string) => boolean;

Function determining whether or not to create spans to track outgoing requests to the given URL. By default, spans will be created for all outgoing requests.

property tracePropagation

tracePropagation?: boolean;

Whether to inject trace propagation headers (sentry-trace, baggage) into outgoing requests.
To scope propagation to specific URLs, configure tracePropagationTargets in the client options instead. Turn this off only to suppress propagation entirely, for example alongside shouldCreateSpanForRequest, which suppresses the span but not the headers.
Covers the global fetch only. A runtime that also instruments another HTTP client switches that one separately, for example denoHttpIntegration({ tracePropagation: false }).
true

interface FinishedCheckIn

interface FinishedCheckIn {}

property checkInId

checkInId: SerializedCheckIn['check_in_id'];

Check-In ID (unique and client generated).

property duration

duration?: SerializedCheckIn['duration'];

The duration of the check-in in seconds. Will only take effect if the status is ok or error.

property monitorSlug

monitorSlug: SerializedCheckIn['monitor_slug'];

The distinct slug of the monitor.

property status

status: 'ok' | 'error';

The status of the check-in.

interface HandlerDataConsole

interface HandlerDataConsole {}

property args

args: any[];

property level

level: ConsoleLevel;

interface HandlerDataError

interface HandlerDataError {}

property column

column?: number;

property error

error?: Error;

property line

line?: number;

property msg

msg: string | object;

property url

url?: string;

interface HandlerDataFetch

interface HandlerDataFetch {}

property args

args: any[];

property endTimestamp

endTimestamp?: number;

property error

error?: unknown;

property fetchData

fetchData: SentryFetchData;

property headers

headers?: WebFetchHeaders;

Headers that the user passed to the fetch request.

property response

response?: {
    readonly ok: boolean;
    readonly status: number;
    readonly url: string;
    headers: WebFetchHeaders;
};

property startTimestamp

startTimestamp: number;

property virtualError

virtualError?: unknown;

interface HandleTunnelRequestOptions

interface HandleTunnelRequestOptions {}

property allowedDsns

allowedDsns: Array<string>;

Pre-parsed array of allowed DSN strings

property request

request: Request;

Incoming request containing the Sentry envelope as its body

interface HttpHeadersCollection

interface HttpHeadersCollection {}

Controls HTTP header collection per direction.

property request

request?: CollectBehavior;

property response

response?: CollectBehavior;

interface InProgressCheckIn

interface InProgressCheckIn {}

property monitorSlug

monitorSlug: SerializedCheckIn['monitor_slug'];

The distinct slug of the monitor.

property status

status: 'in_progress';

The status of the check-in.

interface Integration

interface Integration {}

Integration interface

property name

name: string;

The name of the integration.

method afterAllSetup

afterAllSetup: (client: Client) => void;

This hook is triggered after setupOnce() and setup() have been called for all integrations. You can use it if it is important that all other integrations have been run before.

method beforeSetup

beforeSetup: (client: Client) => void;

Called before the setup hook of any integration is called. This is useful if an integration needs to e.g. modify client options prior to other integrations reading client options.
Parameter client

method preprocessEvent

preprocessEvent: (
    event: Event,
    hint: EventHint | undefined,
    client: Client
) => void;

An optional hook that allows to preprocess an event _before_ it is passed to all other event processors.

method processEvent

processEvent: (
    event: Event,
    hint: EventHint,
    client: Client
) => Event | null | PromiseLike<Event | null>;

An optional hook that allows to process an event. Return null to drop the event, or mutate the event & return it. This receives the client that the integration was installed for as third argument.

method processSegmentSpan

processSegmentSpan: (span: StreamedSpanJSON, client: Client) => void;

An optional hook that allows modifications to a segment span. This hook runs after the segment span is ended, during captureSpan and before the segment span is passed to users' beforeSendSpan callback. Use this hook to modify a segment span in-place.

method processSpan

processSpan: (span: StreamedSpanJSON, client: Client) => void;

An optional hook that allows modifications to a span. This hook runs after the span is ended, during captureSpan and before the span is passed to users' beforeSendSpan callback. Use this hook to modify a span in-place.

method setup

setup: (client: Client) => void;

Set up an integration for the given client. Receives the client as argument.
Whenever possible, prefer this over setupOnce, as that is only run for the first client, whereas setup runs for each client. Only truly global things (e.g. registering global handlers) should be done in setupOnce.

method setupOnce

setupOnce: () => void;

This hook is only called once, even if multiple clients are created. It does not receives any arguments, and should only use for e.g. global monkey patching and similar things.

interface InternalBaseTransportOptions

interface InternalBaseTransportOptions {}

property bufferSize

bufferSize?: number;

property recordDroppedEvent

recordDroppedEvent: Client['recordDroppedEvent'];

property tunnel

tunnel?: string;

Users should pass the tunnel property via the init/client options. This is only used by the SDK to pass the tunnel to the transport.

interface LegacyCSPReport

interface LegacyCSPReport {}

property 'csp-report'

readonly 'csp-report': {
    readonly 'document-uri'?: string;
    readonly referrer?: string;
    readonly 'blocked-uri'?: string;
    readonly 'effective-directive'?: string;
    readonly 'violated-directive'?: string;
    readonly 'original-policy'?: string;
    readonly disposition: 'enforce' | 'report' | 'reporting';
    readonly 'status-code'?: number;
    readonly status?: string;
    readonly 'script-sample'?: string;
    readonly sample?: string;
};

interface Log

interface Log {}

property attributes

attributes?: Record<string, unknown>;

Arbitrary structured data that stores information about the log - e.g., userId: 100.

property level

level: LogSeverityLevel;

The severity level of the log.
Allowed values are, from highest to lowest: critical, fatal, error, warn, info, debug, trace.
The log level changes how logs are filtered and displayed. Critical level logs are emphasized more than trace level logs.

property message

message: ParameterizedString;

The message to be logged.

property severityNumber

severityNumber?: number;

The severity number.

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 exception_id

exception_id?: number;

An identifier for the exception inside the event.exception.values array. This identifier is referenced to via the parent_id attribute to link and aggregate errors.

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 is_exception_group

is_exception_group?: boolean;

Indicates whether the exception is an AggregateException.

property parent_id

parent_id?: number;

References another exception via the exception_id field to indicate that this exception is a child of that exception in the case of aggregate or linked errors.

property source

source?: string;

Describes the source of the exception, in the case that this is a derived (linked or aggregate) error.
This should be populated with the name of the property where the exception was found on the parent exception. E.g. "cause", "errors[0]", "errors[1]"

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 Metric

interface Metric {}

property attributes

attributes?: Record<string, unknown>;

Arbitrary structured data that stores information about the metric.

property name

name: string;

The name of the metric.

property type

type: MetricType;

The type of metric.

property unit

unit?: MetricUnit;

The unit of the metric value.

property value

value: number;

The value of the metric.

interface MetricOptions

interface MetricOptions {}

Options for capturing a metric.

property attributes

attributes?: Metric['attributes'];

Arbitrary structured data that stores information about the metric.

property scope

scope?: Scope;

The scope to capture the metric with.

property unit

unit?: MetricUnit;

The unit of the metric value.

interface ModuleMetadata

interface ModuleMetadata {}

Arbitrary metadata associated with a built application.

index signature

[key: string]: any;

interface ModuleMetadataCallbackArgs

interface ModuleMetadataCallbackArgs {}

Arguments passed to a ModuleMetadataCallback.

property org

org?: string;

property project

project?: string;

property projects

projects?: string[];

property release

release?: string;

interface MonitorConfig

interface MonitorConfig {}

property checkinMargin

checkinMargin?: SerializedMonitorConfig['checkin_margin'];

The allowed allowed margin of minutes after the expected check-in time that the monitor will not be considered missed for.

property failureIssueThreshold

failureIssueThreshold?: SerializedMonitorConfig['failure_issue_threshold'];

How many consecutive failed check-ins it takes to create an issue.

property isolateTrace

isolateTrace?: boolean;

If set to true, creates a new trace for the monitor callback instead of continuing the current trace. This allows distinguishing between different cron job executions.

property maxRuntime

maxRuntime?: SerializedMonitorConfig['max_runtime'];

The allowed allowed duration in minutes that the monitor may be in_progress for before being considered failed due to timeout.

property recoveryThreshold

recoveryThreshold?: SerializedMonitorConfig['recovery_threshold'];

How many consecutive OK check-ins it takes to resolve an issue.

property schedule

schedule: MonitorSchedule;

The schedule on which the monitor should run. Either a crontab schedule string or an interval.

property timezone

timezone?: SerializedMonitorConfig['timezone'];

A tz database string representing the timezone which the monitor's execution schedule is in. See: https://en.wikipedia.org/wiki/List_of_tz_database_time_zones

interface OfflineStore

interface OfflineStore {}

method push

push: (env: Envelope) => Promise<void>;

method shift

shift: () => Promise<Envelope | undefined>;

method unshift

unshift: (env: Envelope) => Promise<void>;

interface OfflineTransportOptions

interface OfflineTransportOptions extends InternalBaseTransportOptions {}

property createStore

createStore?: CreateOfflineStore;

A function that creates the offline store instance.

property flushAtStartup

flushAtStartup?: boolean;

Flush the offline store shortly after startup.
Defaults: false

property shouldSend

shouldSend?: (envelope: Envelope) => boolean | Promise<boolean>;

Should an attempt be made to send the envelope to Sentry.
If this function is supplied and returns false, shouldStore will be called to determine if the envelope should be stored.
Parameter envelope
The envelope that will be sent.
Returns
Whether we should attempt to send the envelope

property shouldStore

shouldStore?: (
    envelope: Envelope,
    error: Error,
    retryDelay: number
) => boolean | Promise<boolean>;

Called before an event is stored.
Return false to drop the envelope rather than store it.
Parameter envelope
The envelope that failed to send.
Parameter error
The error that occurred.
Parameter retryDelay
The current retry delay in milliseconds.
Returns
Whether the envelope should be stored.

interface Options

interface CoreOptions<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 Profile

interface Profile extends BaseProfile<ThreadCpuProfile> {}

property debug_meta

debug_meta?: {
    images: DebugImage[];
};

property device

device: {
    architecture: string;
    is_emulator: boolean;
    locale: string;
    manufacturer: string;
    model: string;
};

property environment

environment: string;

property event_id

event_id: string;

property measurements

measurements?: Record<
    string,
    {
        unit: MeasurementUnit;
        values: {
            elapsed_since_start_ns: number;
            value: number;
        }[];
    }
>;

property os

os: {
    name: string;
    version: string;
    build_number?: string;
};

property platform

platform: string;

property profile

profile: ThreadCpuProfile;

property release

release: string;

property runtime

runtime: {
    name: string;
    version: string;
};

property timestamp

timestamp: string;

property transaction

transaction?: {
    name: string;
    id: string;
    trace_id: string;
    active_thread_id: string;
};

property transactions

transactions?: {
    name: string;
    id: string;
    trace_id: string;
    active_thread_id: string;
    relative_start_ns: string;
    relative_end_ns: string;
}[];

property version

version: string;

interface ProfileChunk

interface ProfileChunk extends BaseProfile<ContinuousThreadCpuProfile> {}

property chunk_id

chunk_id: string;

property client_sdk

client_sdk: {
    name: string;
    version: string;
};

property profiler_id

profiler_id: string;

interface Profiler

interface Profiler {}

method startProfiler

startProfiler: () => void;

Starts the profiler.

method stopProfiler

stopProfiler: () => void;

Stops the profiler.

interface ProfilingIntegration

interface ProfilingIntegration<T extends Client = Client> extends Integration {}

interface PromiseBuffer

interface PromiseBuffer<T> {}

property $

$: PromiseLike<T>[];

method add

add: (taskProducer: () => PromiseLike<T>) => PromiseLike<T>;

method drain

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

interface PropagationContext

interface PropagationContext {}

PropagationContext represents the data from an incoming trace. It should be constructed from incoming trace data, usually represented by sentry-trace and baggage HTTP headers.
There is always a propagation context present in the SDK (or rather on Scopes), holding at least a traceId. This is to ensure that there is always a trace we can attach events onto, even if performance monitoring is disabled. If there was no incoming traceId, the traceId will be generated by the current SDK.

property dsc

dsc?: Partial<DynamicSamplingContext>;

An undefined dsc in the propagation context means that the current SDK invocation is the head of trace and still free to modify and set the DSC for outgoing requests.
The current SDK should not modify this value!

property parentSpanId

parentSpanId?: string;

The parentSpanId denotes the ID of the incoming client span. If there is no parentSpanId on the propagation context, it means that the the incoming trace didn't come from a span.
The current SDK should not modify this value!

property propagationSpanId

propagationSpanId?: string;

A span ID that should be used for the trace context of various event types, and for propagation of a parentSpanId to downstream services, when performance is disabled or when there is no active span. This value should be set by the SDK in an informed way when the same span ID should be used for one unit of execution (e.g. a request, usually tied to the isolation scope). If this value is undefined on the propagation context, the SDK will generate a random span ID for trace contexts and trace propagation.

property sampled

sampled?: boolean;

Represents the sampling decision of the incoming trace.
The current SDK should not modify this value!

property sampleRand

sampleRand: number;

A random between 0 an 1 (including 0, excluding 1) used for sampling in the current execution context. This should be newly generated when a new trace is started.

property traceId

traceId: string;

Either represents the incoming traceId or the traceId generated by the current SDK, if there was no incoming trace.

interface ReactComponentAnnotationOptions

interface ReactComponentAnnotationOptions {}

Options related to React component name annotations.
Only applicable to React-based SDKs, which is why this is deliberately not part of BuildTimeOptionsBase.

property enabled

enabled?: boolean;

Whether the component name annotate plugin should be enabled or not.

property ignoredComponents

ignoredComponents?: string[];

A list of strings representing the names of components to ignore. The plugin will not apply data-sentry annotations on the DOM element for these components.

interface ReplayEndEvent

interface ReplayEndEvent {}

Payload emitted on the replayEnd client hook when a replay stops recording.

property reason

reason: ReplayStopReason;

property sessionId

sessionId?: string;

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 segment_names

segment_names: string[];

property trace_ids

trace_ids: string[];

property urls

urls: string[];

interface ReplayStartEvent

interface ReplayStartEvent {}

Payload emitted on the replayStart client hook when a replay begins recording.

property recordingMode

recordingMode: ReplayRecordingMode;

property sessionId

sessionId: string;

interface ReportDialogOptions

interface ReportDialogOptions extends Record<string, unknown> {}

All properties the report dialog supports

property dsn

dsn?: DsnLike;

property errorFormEntry

errorFormEntry?: string;

property errorGeneric

errorGeneric?: string;

property eventId

eventId?: string;

property labelClose

labelClose?: string;

property labelComments

labelComments?: string;

property labelEmail

labelEmail?: string;

property labelName

labelName?: string;

property labelSubmit

labelSubmit?: string;

property lang

lang?: string;

property subtitle

subtitle?: string;

property subtitle2

subtitle2?: string;

property successMessage

successMessage?: string;

property title

title?: string;

property user

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

method onClose

onClose: (this: void) => void;

Callback after reportDialog closed

method onLoad

onLoad: (this: void) => void;

Callback after reportDialog showed up

interface RequestEventData

interface RequestEventData {}

Request data included in an event as sent to Sentry.

property cookies

cookies?: Record<string, string>;

property data

data?: unknown;

property env

env?: Record<string, string>;

property headers

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

property method

method?: string;

property query_string

query_string?: QueryParams;

property url

url?: string;

interface RequestHookInfo

interface RequestHookInfo {}

property headers

headers?: WebFetchHeaders;

interface ResponseHookInfo

interface ResponseHookInfo {}

property error

error?: unknown;

Error that may have occurred during the request.

property headers

headers?: WebFetchHeaders;

Headers from the response.

interface Runtime

interface Runtime {}

Runtime Context.

property name

name?: string;

property version

version?: string;

interface SamplingContext

interface SamplingContext extends CustomSamplingContext {}

Auxiliary data for various sampling mechanisms in the Sentry SDK.

property attributes

attributes: RawAttributes<Record<string, unknown>>;

Initial attributes that have been passed to the span being sampled.

property location

location?: WorkerLocation;

Object representing the URL of the current page or worker script. Passed by default when using the BrowserTracing integration.

property name

name: string;

The name of the span being sampled.

property normalizedRequest

normalizedRequest?: RequestEventData;

Object representing the incoming request to a node server in a normalized format.

property parentSampled

parentSampled?: boolean;

Sampling decision from the parent transaction, if any.

property parentSampleRate

parentSampleRate?: number;

Sample rate that is coming from an incoming trace (if there is one).

interface ScopeContext

interface ScopeContext {}

Data that can be converted to a Scope.

property attributes

attributes?: RawAttributes<Record<string, unknown>>;

property contexts

contexts: Contexts;

property conversationId

conversationId?: string;

property extra

extra: Extras;

property fingerprint

fingerprint: string[];

property level

level: SeverityLevel;

property propagationContext

propagationContext: PropagationContext;

property tags

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

property user

user: User;

interface ScopeData

interface ScopeData {}

Normalized data of the Scope, ready to be used.

property attachments

attachments: Attachment[];

property attributes

attributes: RawAttributes<Record<string, unknown>>;

property breadcrumbs

breadcrumbs: Breadcrumb[];

property contexts

contexts: Contexts;

property conversationId

conversationId?: string;

property eventProcessors

eventProcessors: EventProcessor[];

property extra

extra: Extras;

property fingerprint

fingerprint: string[];

property level

level?: SeverityLevel;

property propagationContext

propagationContext: PropagationContext;

property sdkProcessingMetadata

sdkProcessingMetadata: SdkProcessingMetadata;

property tags

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

property transactionName

transactionName?: string;

property user

user: User;

interface SdkInfo

interface SdkInfo {}

See https://develop.sentry.dev/sdk/data-model/event-payloads/sdk/#attributes

property integrations

integrations?: string[];

property name

name?: string;

property packages

packages?: Package[];

property settings

settings?: {
    infer_ip?: 'auto' | 'never';
};

property version

version?: string;

interface SdkMetadata

interface SdkMetadata {}

property sdk

sdk?: SdkInfo;

interface SendFeedbackParams

interface SendFeedbackParams {}

property associatedEventId

associatedEventId?: string;

property email

email?: string;

property message

message: string;

property name

name?: string;

property source

source?: string;

property tags

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

Set an object that will be merged sent as tags data with the event.

property url

url?: string;

interface SentryDebugLogger

interface SentryDebugLogger {}

method disable

disable: () => void;

method enable

enable: () => void;

method error

error: (...args: Parameters<typeof console.error>) => void;

method isEnabled

isEnabled: () => boolean;

method log

log: (...args: Parameters<typeof console.log>) => void;

method warn

warn: (...args: Parameters<typeof console.warn>) => void;

interface SentrySpanArguments

interface SentrySpanArguments {}

Interface holding all properties that can be set on a Span on creation.

property attributes

attributes?: SpanAttributes;

Attributes of the Span.

property links

links?: SpanLink[];

Links to associate with the new span. Setting links here is preferred over addLink() as certain context information is only available during span creation.

property name

name?: string | undefined;

Human-readable identifier for the span.

property op

op?: string | undefined;

Operation of the Span.

property parentSpanId

parentSpanId?: string | undefined;

Parent Span ID

property sampled

sampled?: boolean | undefined;

Was this span chosen to be sent as part of the sample?

property spanId

spanId?: string | undefined;

Span ID

property startTimestamp

startTimestamp?: number | undefined;

Timestamp in seconds (epoch time) indicating when the span started.

property traceId

traceId?: string | undefined;

Trace ID

interface SerializedCheckIn

interface SerializedCheckIn {}

property check_in_id

check_in_id: string;

Check-In ID (unique and client generated).

property contexts

contexts?: {
    trace?: TraceContext;
};

property duration

duration?: number;

The duration of the check-in in seconds. Will only take effect if the status is ok or error.

property environment

environment?: string;

property monitor_config

monitor_config?: {
    schedule: MonitorSchedule;
    /**
     * The allowed allowed margin of minutes after the expected check-in time that
     * the monitor will not be considered missed for.
     */
    checkin_margin?: number;
    /**
     * The allowed allowed duration in minutes that the monitor may be `in_progress`
     * for before being considered failed due to timeout.
     */
    max_runtime?: number;
    /**
     * A tz database string representing the timezone which the monitor's execution schedule is in.
     * See: https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
     */
    timezone?: string;
    /** How many consecutive failed check-ins it takes to create an issue. */
    failure_issue_threshold?: number;
    /** How many consecutive OK check-ins it takes to resolve an issue. */
    recovery_threshold?: number;
};

property monitor_slug

monitor_slug: string;

The distinct slug of the monitor.

property release

release?: string;

property status

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

The status of the check-in.

interface SerializedLog

interface SerializedLog {}

property attributes

attributes?: Attributes;

Arbitrary structured data that stores information about the log - e.g., userId: 100.

property body

body: Log['message'];

The log body.

property level

level: LogSeverityLevel;

The severity level of the log. One of trace, debug, info, warn, error, fatal.

property severity_number

severity_number?: Log['severityNumber'];

The severity number.

property timestamp

timestamp: number;

Timestamp in seconds (epoch time) indicating when the log occurred.

property trace_id

trace_id?: string;

The trace ID for this log

interface SerializedMetric

interface SerializedMetric {}

property attributes

attributes?: Attributes;

Arbitrary structured data that stores information about the metric.

property name

name: string;

The name of the metric.

property span_id

span_id?: string;

The span ID for this metric.

property timestamp

timestamp: number;

Timestamp in seconds (epoch time) indicating when the metric was recorded.

property trace_id

trace_id: string;

The trace ID for this metric.

property type

type: MetricType;

The type of metric.

property unit

unit?: MetricUnit;

The unit of the metric value.

property value

value: number;

The value of the metric.

interface SerializedSession

interface SerializedSession {}

property abnormal_mechanism

abnormal_mechanism?: string;

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 SerializedTraceData

interface SerializedTraceData {}

An object holding trace data, like span and trace ids, sampling decision, and dynamic sampling context in a serialized form. Both keys are expected to be used as Http headers or Html meta tags.

property 'sentry-trace'

'sentry-trace'?: string;

property baggage

baggage?: string;

property traceparent

traceparent?: string;

interface Session

interface Session {}

property abnormal_mechanism

abnormal_mechanism?: string;

property did

did?: string | number;

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;
    ip_address?: string | null;
};

interface Span

interface Span {}

A generic Span which holds trace data.

method addEvent

addEvent: (
    name: string,
    attributesOrStartTime?: SpanAttributes | SpanTimeInput,
    startTime?: SpanTimeInput
) => this;

Adds an event to the Span.

method addLink

addLink: (link: SpanLink) => this;

Associates this span with a related span. Links can reference spans from the same or different trace and are typically used for batch operations, cross-trace scenarios, or scatter/gather patterns.
Prefer setting links directly when starting a span (e.g. Sentry.startSpan()) as some context information is only available during span creation.
Parameter link
The link containing the context of the span to link to and optional attributes

method addLinks

addLinks: (links: SpanLink[]) => this;

Associates this span with multiple related spans. See addLink for more details.
Prefer setting links directly when starting a span (e.g. Sentry.startSpan()) as some context information is only available during span creation.
Parameter links
Array of links to associate with this span

method end

end: (endTimestamp?: SpanTimeInput) => void;

End the current span.

method isRecording

isRecording: () => boolean;

If this is span is actually recording data. This will return false if tracing is disabled, this span was not sampled or if the span is already finished.

method recordException

recordException: (exception: unknown, time?: SpanTimeInput) => void;

NOT USED IN SENTRY, only added for compliance with OTEL Span interface

method setAttribute

setAttribute: (key: string, value: SpanAttributeValue | undefined) => this;

Set a single attribute on the span. Set it to undefined to remove the attribute.

method setAttributes

setAttributes: (attributes: SpanAttributes) => this;

Set multiple attributes on the span. Any attribute set to undefined will be removed.

method setStatus

setStatus: (status: SpanStatus) => this;

Sets the status attribute on the current span.

method spanContext

spanContext: () => SpanContextData;

Get context data for this span. This includes the spanId & the traceId.

method updateName

updateName: (name: string) => this;

Update the name of the span.
**Important:** You most likely want to use Sentry.updateSpanName(span, name) instead!
This method will update the current span name but cannot guarantee that the new name will be the final name of the span. Instrumentation might still overwrite the name with an automatically computed name, for example in http.server or db spans.
You can ensure that your name is kept and not overwritten by calling Sentry.updateSpanName(span, name)
Parameter name
the new name of the span

interface SpanContextData

interface SpanContextData {}

property isRemote

isRemote?: boolean | undefined;

Only true if the SentrySpanArguments was propagated from a remote parent.

property spanId

spanId: string;

The ID of the Span. It is globally unique with practically sufficient probability by being made as 8 randomly generated bytes, encoded as a 16 lowercase hex characters corresponding to 64 bits.

property traceFlags

traceFlags: TraceFlag | number;

Trace flags to propagate.
It is represented as 1 byte (bitmap). Bit to represent whether trace is sampled or not. When set, the least significant bit documents that the caller may have recorded trace data. A caller who does not record trace data out-of-band leaves this flag unset.

property traceId

traceId: string;

The ID of the trace that this span belongs to. It is worldwide unique with practically sufficient probability by being made as 16 randomly generated bytes, encoded as a 32 lowercase hex characters corresponding to 128 bits.

property traceState

traceState?: TraceState | undefined;

In OpenTelemetry, this can be used to store trace state, which are basically key-value pairs.

interface SpanJSON

interface SpanJSON {}

A JSON representation of a span.

property data

data: SpanAttributes;

property description

description?: string;

property exclusive_time

exclusive_time?: number;

property is_segment

is_segment?: boolean;

property links

links?: SpanLinkJSON[];

property measurements

measurements?: Measurements;

property op

op?: string;

property origin

origin?: SpanOrigin;

property parent_span_id

parent_span_id?: string;

property profile_id

profile_id?: string;

property segment_id

segment_id?: string;

property span_id

span_id: string;

property start_timestamp

start_timestamp: number;

property status

status: string;

property timestamp

timestamp?: number;

property trace_id

trace_id: string;

interface SpanLink

interface SpanLink {}

property attributes

attributes?: SpanLinkAttributes;

A key-value pair with primitive values or an array of primitive values

property context

context: SpanContextData;

Contains the SpanContext of the span to link to

interface SpanStatus

interface SpanStatus {}

The status of a span. This can optionally contain a human-readable message.

property code

code: SpanStatusCode;

The status code of this message. 0 = UNSET 1 = OK 2 = ERROR

property message

message?: SpanStatusType | string;

A developer-facing error message.

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 module_metadata

module_metadata?: Record<string, unknown>;

property platform

platform?: string;

property post_context

post_context?: string[];

property pre_context

pre_context?: string[];

property vars

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

interface Stacktrace

interface Stacktrace {}

JSDoc

property frames

frames?: StackFrame[];

property frames_omitted

frames_omitted?: [number, number];

interface StartSpanOptions

interface StartSpanOptions {}

property attributes

attributes?: SpanAttributes;

Attributes for the span.

property experimental

experimental?: {
    /**
     * If set to true, the span is sent on its own as a v2 streamed span instead of being folded
     * into a transaction. Used internally for late web vital spans (INP) when span streaming is
     * disabled.
     *
     * @internal this option is currently experimental and should only be used within SDK code. It
     * might be removed or changed in the future.
     * @hidden
     *
     * @deprecated This option is deprecated and will be removed in the future.
     *
     * TODO(standalone): remove once the static (transaction) trace lifecycle is dropped.
     */
    standalone?: boolean;
};

Experimental options without any stability guarantees. Use with caution!

property forceTransaction

forceTransaction?: boolean;

If set to true, this span will be forced to be treated as a transaction in the Sentry UI, if possible and applicable. Note that it is up to the SDK to decide how exactly the span will be sent, which may change in future SDK versions. It is not guaranteed that a span started with this flag set to true will be sent as a transaction.
Example 1
Making a span a root span:
Sentry.withActiveSpan(null, () => { Sentry.startSpan({ name: 'span-that-should-be-a-root' }, () => { // ... }); });
Example 2
Keeping the root span attached to a specific trace:
Sentry.continueTrace({ sentryTrace, baggage }, () => Sentry.withActiveSpan(null, () => Sentry.startSpan({ name: 'span-that-should-be-a-root' }, () => { // ... }), ), );
Deprecated
This option will be removed in the next major version of the SDK. There is no longer a concrete use case for it: all spans are indexed and searchable in Sentry, so a span no longer needs to be a transaction to be queried, filtered or aggregated on. In most cases, simply drop the option. The span is still sent, just as a child of its parent span, if a parent span is active. If you do need the span to be a segment (root) span, follow the examples below:.

property links

links?: SpanLink[];

Links to associate with the new span. Setting links here is preferred over addLink() as it allows sampling decisions to consider the link information.

property name

name: string;

The name of the span.

property onlyIfParent

onlyIfParent?: boolean;

If set to true, only start a span if a parent span exists.

property op

op?: string;

An op for the span. This is a categorization for spans.

property parentSpan

parentSpan?: Span | null;

If provided, make the new span a child of this span. If this is not provided, the new span will be a child of the currently active span. If this is set to null, the new span will have no parent span.

property scope

scope?: Scope;

If set, start the span on a fork of this scope instead of on the current scope. To ensure proper span cleanup, the passed scope is cloned for the duration of the span.
If you want to modify the passed scope inside the callback, calling getCurrentScope() will return the cloned scope, meaning all scope modifications will be reset once the callback finishes
If you want to modify the passed scope and have the changes persist after the callback ends, modify the scope directly instead of using getCurrentScope()

property startTime

startTime?: SpanTimeInput;

A manually specified start time for the created Span object.

interface StreamedSpanJSON

interface StreamedSpanJSON {}

Intermediate JSON reporesentation of a v2 span, which users and our SDK integrations will interact with. This is NOT the final serialized JSON span, but an intermediate step still holding raw attributes. The final, serialized span is a SerializedStreamedSpan. Main reason: Make it easier and safer for users to work with attributes.

property attributes

attributes: RawAttributes<Record<string, unknown>>;

property end_timestamp

end_timestamp?: number;

Only set once the span has ended.

property is_segment

is_segment: boolean;

property links

links?: SpanLinkJSON<RawAttributes<Record<string, unknown>>>[];

property name

name: string;

property parent_span_id

parent_span_id?: string;

property span_id

span_id: string;

property start_timestamp

start_timestamp: number;

property status

status: 'ok' | 'error';

property trace_id

trace_id: string;

interface Thread

interface Thread {}

JSDoc

property crashed

crashed?: boolean;

property current

current?: boolean;

property id

id?: number | string;

property main

main?: boolean;

property name

name?: string;

property stacktrace

stacktrace?: Stacktrace;

interface ThreadCpuProfile

interface ThreadCpuProfile {}

property frames

frames: ThreadCpuFrame[];

property queue_metadata

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

property samples

samples: ThreadCpuSample[];

property stacks

stacks: ThreadCpuStack[];

property thread_metadata

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

interface ThreadCpuSample

interface ThreadCpuSample {}

property elapsed_since_start_ns

elapsed_since_start_ns: string;

property queue_address

queue_address?: string;

property stack_id

stack_id: StackId;

property thread_id

thread_id: ThreadId;

interface TimedEvent

interface TimedEvent {}

property attributes

attributes?: SpanAttributes;

property name

name: string;

property time

time: SpanTimeInput;

interface TraceContext

interface TraceContext extends Record<string, unknown> {}

property data

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

property links

links?: SpanLinkJSON[];

property op

op?: string;

property origin

origin?: SpanOrigin;

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 TraceparentData

interface TraceparentData {}

Data pulled from a sentry-trace header

property parentSampled

parentSampled?: boolean | undefined;

If this transaction has a parent, the parent's sampling decision

property parentSpanId

parentSpanId?: string | undefined;

Parent Span ID

property traceId

traceId?: string | undefined;

Trace ID

interface TracesSamplerSamplingContext

interface TracesSamplerSamplingContext extends SamplingContext {}

Auxiliary data passed to the tracesSampler function.

property inheritOrSampleWith

inheritOrSampleWith: (fallbackSampleRate: number) => number;

Returns a sample rate value that matches the sampling decision from the incoming trace, or falls back to the provided fallbackSampleRate.

interface TracingChannelBinding

interface TracingChannelBinding {}

property asyncLocalStorage

asyncLocalStorage: NonNullable<unknown>;

The ALS instance that will be bound to the channel.

interface TransactionEvent

interface TransactionEvent extends Event {}

property type

type: 'transaction';

interface Transport

interface Transport {}

method flush

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

method send

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

interface User

interface User {}

An interface describing a user of an application or a handled request.

property email

email?: string;

property geo

geo?: GeoLocation;

property id

id?: string | number;

property ip_address

ip_address?: string | null;

property username

username?: string;

index signature

[key: string]: unknown;

interface UserFeedback

interface UserFeedback {}

Crash report feedback object

property comments

comments: string;

property email

email: User['email'];

property event_id

event_id: string;

property name

name: string;

interface WebFetchHeaders

interface WebFetchHeaders {}

method append

append: (name: string, value: string) => void;

method delete

delete: (name: string) => void;

method forEach

forEach: (
    callbackfn: (value: string, key: string, parent: WebFetchHeaders) => void
) => void;

method get

get: (name: string) => string | null;

method has

has: (name: string) => boolean;

method set

set: (name: string, value: string) => void;

interface WebFetchRequest

interface WebFetchRequest {}

property body

readonly body?: unknown;

property headers

readonly headers: WebFetchHeaders;

property method

readonly method: string;

property url

readonly url: string;

method clone

clone: () => WebFetchRequest;

method text

text: () => Promise<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

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 CaptureContext

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

A context to be used for capturing an event. This can either be a Scope, or a partial ScopeContext, or a callback that receives the current scope and returns a new scope to use.

type CheckIn

type CheckIn = HeartbeatCheckIn | InProgressCheckIn | FinishedCheckIn;

type CheckInEnvelope

type CheckInEnvelope = 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 CollectBehavior

type CollectBehavior =
    | boolean
    | {
          allow: string[];
      }
    | {
          deny: string[];
      };

Controls how key-value data (headers, cookies, query params) is collected and filtered.
- true: Collect all data without filtering (empty denylist). Sensitive values like keys and tokens are always filtered out. - false: Do not collect any data. - { allow: string[] }: Collect only the specified keys. - { deny: string[] }: Collect all keys except the specified ones.

type ConsoleLevel

type ConsoleLevel = 'debug' | 'info' | 'warn' | 'error' | 'log' | 'assert' | 'trace';

type Context

type Context = Record<string, unknown>;

type DataCategory

type DataCategory =
    | 'default'
    | 'error'
    | 'transaction'
    | 'replay'
    | 'security'
    | 'attachment'
    | 'session'
    | 'internal'
    | 'profile'
    | 'monitor'
    | 'feedback'
    | 'span'
    | 'log_item'
    | 'log_byte'
    | 'metric'
    | 'unknown';

type DebugImage

type DebugImage = WasmDebugImage | SourceMapDebugImage | MachoDebugImage;

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: string;
    public_key: DsnComponents['publicKey'];
    sample_rate?: string;
    release?: string;
    environment?: string;
    transaction?: string;
    replay_id?: string;
    sampled?: string;
    sample_rand?: string;
    org_id?: string;
};

type Envelope

type Envelope =
    | EventEnvelope
    | SessionEnvelope
    | ClientReportEnvelope
    | ProfileChunkEnvelope
    | ReplayEnvelope
    | CheckInEnvelope
    | StreamedSpanEnvelope
    | RawSecurityEnvelope
    | LogEnvelope
    | MetricEnvelope;

type EnvelopeItem

type EnvelopeItem = Envelope[1][number];

type EnvelopeItemType

type EnvelopeItemType =
    | 'client_report'
    | 'user_report'
    | 'feedback'
    | 'session'
    | 'sessions'
    | 'transaction'
    | 'attachment'
    | 'event'
    | 'profile'
    | 'profile_chunk'
    | 'replay_event'
    | 'replay_recording'
    | 'check_in'
    | 'span'
    | 'log'
    | 'metric'
    | 'trace_metric'
    | 'raw_security';

type EventDropReason

type EventDropReason =
    | 'before_send'
    | 'callback_error'
    | 'event_processor'
    | 'network_error'
    | 'queue_overflow'
    | 'ratelimit_backoff'
    | 'sample_rate'
    | 'send_error'
    | 'internal_sdk_error'
    | 'buffer_overflow'
    | 'ignored'
    | 'invalid'
    | 'no_parent_span';

type EventEnvelope

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

type EventEnvelopeHeaders

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

type EventItem

type EventItem = BaseEnvelopeItem<EventItemHeaders, Event>;

type EventType

type EventType = 'transaction' | 'profile' | 'replay_event' | 'feedback' | 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 ExclusiveEventHintOrCaptureContext

type ExclusiveEventHintOrCaptureContext =
    | (CaptureContext &
          Partial<{
              [key in keyof EventHint]: never;
          }>)
    | (EventHint &
          Partial<{
              [key in keyof ScopeContext]: never;
          }>);

This type makes sure that we get either a CaptureContext, OR an EventHint. It does not allow mixing them, which could lead to unexpected outcomes, e.g. this is disallowed: { user: { id: '123' }, mechanism: { handled: false } }

type Extra

type Extra = unknown;

type Extras

type Extras = Record<string, Extra>;

type FeatureFlag

type FeatureFlag = {
    readonly flag: string;
    readonly result: boolean;
};

Ordered LRU cache for storing feature flags in the scope context. The name of each flag in the buffer is unique, and the output of getAll() is ordered from oldest to newest.

type FeedbackErrorCode

type FeedbackErrorCode =
    | 'ERROR_EMPTY_MESSAGE'
    | 'ERROR_NO_CLIENT'
    | 'ERROR_TIMEOUT'
    | 'ERROR_FORBIDDEN'
    | 'ERROR_GENERIC';

type FeedbackErrorMessages

type FeedbackErrorMessages = Partial<Record<FeedbackErrorCode, string>>;

type FeedbackFormData

type FeedbackFormData = {
    name: string;
    email: string;
    message: string;
    attachments: Attachment[] | undefined;
};

type FeedbackItem

type FeedbackItem = BaseEnvelopeItem<FeedbackItemHeaders, FeedbackEvent>;

type FractionUnit

type FractionUnit = 'ratio' | 'percent';

Fractions such as percentages.

type FrameId

type FrameId = number;

type HandlerDataUnhandledRejection

type HandlerDataUnhandledRejection = unknown;

type HttpBodyCollectionTarget

type HttpBodyCollectionTarget =
    | 'incomingRequest'
    | 'outgoingRequest'
    | 'incomingResponse'
    | 'outgoingResponse';

type HttpHeaderValue

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

type InformationUnit

type InformationUnit =
    | 'bit'
    | 'byte'
    | 'kilobyte'
    | 'kibibyte'
    | 'megabyte'
    | 'mebibyte'
    | 'gigabyte'
    | 'gibibyte'
    | 'terabyte'
    | 'tebibyte'
    | 'petabyte'
    | 'pebibyte'
    | 'exabyte'
    | 'exbibyte';

Size of information derived from bytes.

type IntegrationFn

type IntegrationFn<IntegrationType = Integration> = (
    ...rest: any[]
) => IntegrationType;

An integration in function form. This is expected to return an integration.

type IntegrationIndex

type IntegrationIndex = {
    [key: string]: Integration;
};

Map of integrations assigned to a client

type InternalGlobal

type InternalGlobal = {
    navigator?: {
        userAgent?: string;
        maxTouchPoints?: number;
    };
    console: Console;
    PerformanceObserver?: any;
    Sentry?: any;
    onerror?: {
        (
            event: object | string,
            source?: string,
            lineno?: number,
            colno?: number,
            error?: Error
        ): any;
        __SENTRY_INSTRUMENTED__?: true;
    };
    onunhandledrejection?: {
        (event: unknown): boolean;
        __SENTRY_INSTRUMENTED__?: true;
    };
    SENTRY_ENVIRONMENT?: string;
    SENTRY_DSN?: string;
    SENTRY_RELEASE?: {
        id?: string;
    };
    SENTRY_SDK_SOURCE?: SdkSource;
    /**
     * Debug IDs are indirectly injected by Sentry CLI or bundler plugins to directly reference a particular source map
     * for resolving of a source file. The injected code will place an entry into the record for each loaded bundle/JS
     * file.
     */
    _sentryDebugIds?: Record<string, string>;
    /**
     * Native debug IDs implementation (e.g., from Vercel).
     * This uses the same format as _sentryDebugIds but with a different global name.
     * Keys are `error.stack` strings, values are debug IDs.
     */
    _debugIds?: Record<string, string>;
    /**
     * Raw module metadata that is injected by bundler plugins.
     *
     * Keys are `error.stack` strings, values are the metadata.
     */
    _sentryModuleMetadata?: Record<string, any>;
    _sentryWrappedDepth?: number;
    /**
     * Bundler and runtime instrumentation detection.
     */
    __SENTRY_ORCHESTRION__?: {
        /** Empty array signifies runtime hooked */
        runtime?: string[];
        /**
         * The resolved `file:` URL of a transformed file for each runtime-injected
         * module, keyed by module name (e.g. `@mastra/core`). Lets an integration
         * anchor `createRequire` on the app's actual copy of a dependency without
         * relying on `process.cwd()` or the CJS `require.cache` — the latter is
         * always empty for ESM-loaded modules. Only the runtime `--import`/hook path
         * populates this; the bundler path inlines modules and records none.
         */
        runtimeFiles?: Record<string, string>;
        /**
         * Module names recorded as each bundler-transformed module loads (the
         * injected snippet calls `orchestrionModuleInjected`). The bundler plugin's
         * entry banner ensures an empty `Set` at boot, so a defined set — even
         * empty — signifies the plugin ran.
         */
        bundler?: Set<string>;
        /**
         * Channel-subscriber integration factories stored by the snippet the
         * bundler transform splices into each instrumented module, keyed by module
         * name. A factory shared by several packages (e.g. pg/pg-pool) appears
         * under several keys; integration-name deduplication collapses them at
         * setup. A bundler-only SDK (e.g. `@sentry/cloudflare`) reads these at
         * `init()` and instantiates them.
         */
        integrations?: Map<string, () => Integration>;
        /**
         * Set once `registerDiagnosticsChannelInjection()` has run but could not
         * install the runtime module hooks — most commonly because
         * `@sentry/server-runtime-injection` was bundled into the app (which strips its vendored
         * code transformer) or the Node runtime lacks the required module-hook API.
         * Dedupes the one-time warning and short-circuits repeat calls.
         */
        runtimeUnavailable?: boolean;
        /**
         * Module namespaces stashed by build-time provider imports, keyed by module
         * name (e.g. `@mastra/observability`). A bundler plugin can splice a static
         * `import * as ns from '<pkg>'` into an integration and record `ns` here, so
         * the integration can read a bundled peer dependency it cannot `createRequire`
         * in a bundled runtime such as Cloudflare Workers.
         */
        providedModules?: Record<string, Record<string, unknown>>;
    };
} & Carrier;

Internal global with common properties and Sentry extensions

type LogEnvelope

type LogEnvelope = BaseEnvelope<LogEnvelopeHeaders, LogContainerItem>;

type LogSeverityLevel

type LogSeverityLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';

type MaxRequestBodySize

type MaxRequestBodySize = 'none' | 'small' | 'medium' | 'always';

Maximum size of incoming HTTP request bodies attached to events.
- 'none': No request bodies will be attached - 'small': Request bodies up to 1,000 bytes will be attached - 'medium': Request bodies up to 10,000 bytes will be attached - 'always': Request bodies will always be attached (up to 1MB hard cap)

type MaybeWeakRef

type MaybeWeakRef<T extends object> = WeakRefLike<T> | T;

A wrapper type that represents either a WeakRef-like object or a direct reference. Used for optional weak referencing in environments where WeakRef may not be available.

type Measurements

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

type MeasurementUnit

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

type MetricEnvelope

type MetricEnvelope = BaseEnvelope<MetricEnvelopeHeaders, MetricContainerItem>;

type MetricType

type MetricType = 'counter' | 'gauge' | 'distribution';

type MetricUnit

type MetricUnit = LiteralUnion<DurationUnit | InformationUnit | FractionUnit>;

type ModuleMetadataCallback

type ModuleMetadataCallback = (args: ModuleMetadataCallbackArgs) => ModuleMetadata;

type NoneUnit

type NoneUnit = '' | 'none';

Untyped value without a unit.

type Outcome

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

type ParameterizedString

type ParameterizedString = string & {
    __sentry_template_string__?: string;
    __sentry_template_values__?: unknown[];
};

type PolymorphicRequest

type PolymorphicRequest = BaseRequest &
    NodeRequest &
    ExpressRequest &
    KoaRequest &
    NextjsRequest;

A Request type compatible with Node, Express, browser, etc., because everything is optional

type Primitive

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

type ProfileChunkEnvelope

type ProfileChunkEnvelope = BaseEnvelope<BaseEnvelopeHeaders, ProfileChunkItem>;

type ProfileChunkItem

type ProfileChunkItem = BaseEnvelopeItem<ProfileChunkItemHeaders, ProfileChunk>;

type ProfileItem

type ProfileItem = BaseEnvelopeItem<ProfileItemHeaders, Profile>;

type QueryParams

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

type RateLimits

type RateLimits = Record<string, number>;

type RawAttributes

type RawAttributes<T> = T & ValidatedAttributes<T>;

type RawSecurityEnvelope

type RawSecurityEnvelope = BaseEnvelope<BaseEnvelopeHeaders, RawSecurityItem>;

type RawSecurityItem

type RawSecurityItem = BaseEnvelopeItem<RawSecurityHeaders, LegacyCSPReport>;

type ReplayEnvelope

type ReplayEnvelope = [
    ReplayEnvelopeHeaders,
    [ReplayEventItem, ReplayRecordingItem]
];

type ReplayRecordingData

type ReplayRecordingData = string | Uint8Array;

NOTE: These types are still considered Beta and subject to change.

type ReplayRecordingMode

type ReplayRecordingMode = 'session' | 'buffer';

NOTE: These types are still considered Beta and subject to change.

type ReplayStopReason

type ReplayStopReason =
    | 'manual'
    | 'sessionExpired'
    | 'sendError'
    | 'mutationLimit'
    | 'eventBufferError'
    | 'eventBufferOverflow';

Reason a replay recording stopped, passed to the replayEnd client hook.
- manual: user called replay.stop(). - sessionExpired: session hit maxReplayDuration or the idle-expiry threshold. - sendError: a replay segment failed to send after retries. - mutationLimit: DOM mutation budget for the session was exhausted. - eventBufferError: the event buffer threw an unexpected error. - eventBufferOverflow: the event buffer ran out of space.

type ResolvedDataCollection

type ResolvedDataCollection = Required<Omit<DataCollection, 'httpHeaders'>> & {
    httpHeaders: Required<HttpHeadersCollection>;
    graphQL: Required<NonNullable<DataCollection['graphQL']>>;
    genAI: Required<NonNullable<DataCollection['genAI']>>;
};

Fully resolved DataCollection with all defaults applied.

type ResolveSourceMapHook

type ResolveSourceMapHook = (
    artifactPath: string,
    sourceMappingUrl: string | undefined
) => string | undefined | Promise<string | undefined>;

Hook to customize source map file resolution.
The hook is called with the absolute path of the build artifact and the value of its //# sourceMappingURL= comment, if present. It should return an absolute path (or a promise resolving to one) indicating where to find the artifact's corresponding source map file. If no path is returned, or the returned path doesn't exist, the standard resolution process is used.

type SanitizedRequestData

type SanitizedRequestData = {
    /**
     * The sanitized URL. Named `url` rather than `url.full` because this shape is also used for
     * `http` breadcrumb data, where `url` is the field the Sentry UI renders (see
     * {@link FetchBreadcrumbData}). Span attributes use `url.full` instead.
     */
    url: string;
    [HTTP_REQUEST_METHOD]: string;
    [URL_FRAGMENT]?: string;
    [URL_QUERY]?: string;
};

Request data that is considered safe for span.data on http.client spans and for http breadcrumbs See https://develop.sentry.dev/sdk/data-handling/#structuring-data

type SdkSource

type SdkSource = 'npm' | 'cdn' | 'loader' | 'aws-lambda-layer';

type SendFeedback

type SendFeedback = (
    params: SendFeedbackParams,
    hint?: EventHint & {
        includeReplay?: boolean;
        errorMessages?: FeedbackErrorMessages;
    }
) => Promise<string>;

type SentryCoreCurrentScopes

type ClientClass<F extends Client, O extends ClientOptions> = new (options: O) => F;

A class object that can instantiate Client objects.

type SerializedLogContainer

type SerializedLogContainer = {
    version?: number;
    ingest_settings?: {
        infer_ip?: 'auto' | 'never';
        infer_user_agent?: 'auto' | 'never';
    };
    items: Array<SerializedLog>;
};

type SerializedMetricAttributeValue

type SerializedMetricAttributeValue = TypedAttributeValue;

Deprecated
this was not intended for public consumption

type SerializedMetricContainer

type SerializedMetricContainer = {
    version?: number;
    ingest_settings?: {
        infer_ip?: 'auto' | 'never';
        infer_user_agent?: 'auto' | 'never';
    };
    items: Array<SerializedMetric>;
};

type SerializedStreamedSpan

type SerializedStreamedSpan = Omit<
    StreamedSpanJSON,
    'attributes' | 'links' | 'end_timestamp'
> & {
    end_timestamp: number;
    attributes: Attributes;
    links?: SpanLinkJSON<Attributes>[];
};

Serialized span item. This is the final, serialized span format that is sent to Sentry. The intermediate representation is StreamedSpanJSON. Main differences: Attributes are converted to Attributes, thus including the type annotation, and end_timestamp is guaranteed to be set (we only ever send ended spans).

type SerializedStreamedSpanContainer

type SerializedStreamedSpanContainer = {
    version?: number;
    ingest_settings?: {
        infer_ip?: 'auto' | 'never';
        infer_user_agent?: 'auto' | 'never';
    };
    items: Array<SerializedStreamedSpan>;
};

Envelope span item container.

type SessionContext

type SessionContext = Partial<Session>;

type SessionEnvelope

type SessionEnvelope = BaseEnvelope<SessionEnvelopeHeaders, SessionItem>;

type SessionItem

type SessionItem =
    | BaseEnvelopeItem<SessionItemHeaders, SerializedSession>
    | BaseEnvelopeItem<SessionAggregatesItemHeaders, SessionAggregates>;

type SessionStatus

type SessionStatus = 'ok' | 'exited' | 'crashed' | 'abnormal' | 'unhandled';

type SeverityLevel

type SeverityLevel = 'fatal' | 'error' | 'warning' | 'log' | 'info' | 'debug';

type SpanAttributes

type SpanAttributes = Partial<{
    'sentry.origin': string;
    'sentry.op': string;
    'sentry.segment.name.source': TransactionSource;
    'sentry.sample_rate': number;
    'sentry.kind': SpanKind;
}> &
    Record<string, SpanAttributeValue | undefined>;

type SpanAttributeValue

type SpanAttributeValue =
    | string
    | number
    | boolean
    | Array<null | undefined | string>
    | Array<null | undefined | number>
    | Array<null | undefined | boolean>;

type SpanKind

type SpanKind = 'server' | 'client' | 'producer' | 'consumer';

type SpanKindNumber

type SpanKindNumber = 0 | 1 | 2 | 3 | 4;

type SpanOrigin

type SpanOrigin =
    | SpanOriginType
    | `${SpanOriginType}.${SpanOriginCategory}`
    | `${SpanOriginType}.${SpanOriginCategory}.${SpanOriginIntegrationName}`
    | `${SpanOriginType}.${SpanOriginCategory}.${SpanOriginIntegrationName}.${SpanOriginIntegrationPart}`;

type SpanStatusType

type SpanStatusType = (typeof SPAN_STATUS_TYPES)[number];

type SpanTimeInput

type SpanTimeInput = HrTime | number | Date;

This type is aligned with the OpenTelemetry TimeInput type.

type StackId

type StackId = number;

type StackLineParser

type StackLineParser = [number, StackLineParserFn];

type StackLineParserFn

type StackLineParserFn = (line: string) => StackFrame | undefined;

type StackParser

type StackParser = (
    stack: string,
    skipFirstLines?: number,
    framesToPop?: number
) => StackFrame[];

type StreamedSpanEnvelope

type StreamedSpanEnvelope = BaseEnvelope<
    StreamedSpanEnvelopeHeaders,
    SpanContainerItem
>;

type ThreadCpuFrame

type ThreadCpuFrame = {
    function?: string;
    file?: string;
    lineno?: number;
    colno?: number;
    abs_path?: string;
    platform?: string;
    instruction_addr?: string;
    module?: string;
    in_app?: boolean;
};

type ThreadCpuStack

type ThreadCpuStack = FrameId[];

type ThreadId

type ThreadId = string;

type TraceFlag

type TraceFlag = TraceFlagNone | TraceFlagSampled;

type TracePropagationTargets

type TracePropagationTargets = (string | RegExp)[];

type TransactionSource

type TransactionSource =
    /** User-defined name */
    | 'custom'
    /** Raw URL, potentially containing identifiers */
    | 'url'
    /** Parametrized URL / route */
    | 'route'
    /** Name of the view handling the request */
    | 'view'
    /** Named after a software component, such as a function or class name. */
    | 'component'
    /** Name of a background task (e.g. a Celery task) */
    | 'task';

Contains information about how the name of the transaction was determined. This will be used by the server to decide whether or not to scrub identifiers from the transaction name, or replace the entire name with a placeholder.

type TransportMakeRequestResponse

type TransportMakeRequestResponse = {
    statusCode?: number;
    headers?: {
        [key: string]: string | null;
        'x-sentry-rate-limits': string | null;
        'retry-after': string | null;
    };
};

type TransportRequest

type TransportRequest = {
    body: string | Uint8Array;
};

type TransportRequestExecutor

type TransportRequestExecutor = (
    request: TransportRequest
) => PromiseLike<TransportMakeRequestResponse>;

type UserFeedbackItem

type UserFeedbackItem = BaseEnvelopeItem<UserFeedbackItemHeaders, UserFeedback>;

type ViewHierarchyData

type ViewHierarchyData = {
    rendering_system: string;
    positioning?: 'absolute' | 'relative';
    windows: ViewHierarchyWindow[];
};

type ViewHierarchyWindow

type ViewHierarchyWindow = {
    alpha: number;
    height: number;
    type: string;
    visible: boolean;
    width: number;
    x: number;
    y: number;
    z?: number;
    children?: ViewHierarchyWindow[];
    depth?: number;
    identifier?: string;
} & Record<string, string | number | boolean>;

type WrappedFunction

type WrappedFunction<T extends Function = Function> = T & {
    __sentry_wrapped__?: WrappedFunction<T>;
    __sentry_original__?: T;
};

A function that is possibly wrapped by Sentry.

Namespaces

namespace logger

module 'build/types/logs/public-api.d.ts' {}

Additional metadata to capture the log with.

variable fmt

const fmt: (
    strings: TemplateStringsArray,
    ...values: unknown[]
) => ParameterizedString;

Tagged template function which returns parameterized representation of the message.
Parameter strings
An array of string values splitted between expressions
Parameter values
Expressions extracted from template string
Returns
A ParameterizedString object that can be passed into captureMessage or Sentry.logger.X methods.

function debug

debug: (
    message: ParameterizedString,
    attributes?: Log['attributes'],
    { scope }?: CaptureLogMetadata
) => void;

Capture a log with the debug level.
Parameter message
The message to log.
Parameter attributes
Arbitrary structured data that stores information about the log - e.g., { component: 'Header', state: 'loading' }.
Parameter metadata
additional metadata to capture the log with.
Example 1
Sentry.logger.debug('Component mounted', { component: 'UserProfile', props: { userId: 123 }, renderTime: 150 });
Example 2
With template strings
Sentry.logger.debug(Sentry.logger.fmt`API request to ${endpoint} failed`, { statusCode: 404, requestId: 'req-123', duration: 250 });

function error

error: (
    message: ParameterizedString,
    attributes?: Log['attributes'],
    { scope }?: CaptureLogMetadata
) => void;

Capture a log with the error level.

Parameter message

The message to log.

Parameter attributes

Arbitrary structured data that stores information about the log - e.g., { error: 'NetworkError', url: '/api/data' }.

Parameter metadata

additional metadata to capture the log with.

Example 1

Sentry.logger.error('Failed to load user data', {
  error: 'NetworkError',
  url: '/api/users/123',
  statusCode: 500,
  retryCount: 3
});

Example 2

With template strings

Sentry.logger.error(Sentry.logger.fmt`Payment processing failed for order ${orderId}`, {
  error: 'InsufficientFunds',
  amount: 100.00,
  currency: 'USD',
  userId: 'user-456'
});

function fatal

fatal: (
    message: ParameterizedString,
    attributes?: Log['attributes'],
    { scope }?: CaptureLogMetadata
) => void;

Capture a log with the fatal level.

Parameter message

The message to log.

Parameter attributes

Arbitrary structured data that stores information about the log - e.g., { appState: 'corrupted', sessionId: 'abc-123' }.

Parameter metadata

additional metadata to capture the log with.

Example 1

Sentry.logger.fatal('Application state corrupted', {
  lastKnownState: 'authenticated',
  sessionId: 'session-123',
  timestamp: Date.now(),
  recoveryAttempted: true
});

Example 2

With template strings

Sentry.logger.fatal(Sentry.logger.fmt`Critical system failure in ${service}`, {
  service: 'payment-processor',
  errorCode: 'CRITICAL_FAILURE',
  affectedUsers: 150,
  timestamp: Date.now()
});

function info

info: (
    message: ParameterizedString,
    attributes?: Log['attributes'],
    { scope }?: CaptureLogMetadata
) => void;

Capture a log with the info level.
Parameter message
The message to log.
Parameter attributes
Arbitrary structured data that stores information about the log - e.g., { feature: 'checkout', status: 'completed' }.
Parameter metadata
additional metadata to capture the log with.
Example 1
Sentry.logger.info('User completed checkout', { orderId: 'order-123', amount: 99.99, paymentMethod: 'credit_card' });
Example 2
With template strings
Sentry.logger.info(Sentry.logger.fmt`User ${user} updated profile picture`, { userId: 'user-123', imageSize: '2.5MB', timestamp: Date.now() });

function trace

trace: (
    message: ParameterizedString,
    attributes?: Log['attributes'],
    { scope }?: CaptureLogMetadata
) => void;

Capture a log with the trace level.
Parameter message
The message to log.
Parameter attributes
Arbitrary structured data that stores information about the log - e.g., { userId: 100, route: '/dashboard' }.
Parameter metadata
additional metadata to capture the log with.
Example 1
Sentry.logger.trace('User clicked submit button', { buttonId: 'submit-form', formId: 'user-profile', timestamp: Date.now() });
Example 2
With template strings
Sentry.logger.trace(Sentry.logger.fmt`User ${user} navigated to ${page}`, { userId: '123', sessionId: 'abc-xyz' });

function warn

warn: (
    message: ParameterizedString,
    attributes?: Log['attributes'],
    { scope }?: CaptureLogMetadata
) => void;

Capture a log with the warn level.

Parameter message

The message to log.

Parameter attributes

Arbitrary structured data that stores information about the log - e.g., { browser: 'Chrome', version: '91.0' }.

Parameter metadata

additional metadata to capture the log with.

Example 1

Sentry.logger.warn('Browser compatibility issue detected', {
  browser: 'Safari',
  version: '14.0',
  feature: 'WebRTC',
  fallback: 'enabled'
});

Example 2

With template strings

Sentry.logger.warn(Sentry.logger.fmt`API endpoint ${endpoint} is deprecated`, {
  recommendedEndpoint: '/api/v2/users',
  sunsetDate: '2024-12-31',
  clientVersion: '1.2.3'
});

namespace metrics

module 'build/types/metrics/public-api.d.ts' {}

Options for capturing a metric.

function count

count: (name: string, value?: number, options?: MetricOptions) => void;

Increment a counter metric.

Parameter name

The name of the counter metric.

Parameter value

The value to increment by (defaults to 1).

Parameter options

Options for capturing the metric.

Example 1

Sentry.metrics.count('api.requests', 1, {
  attributes: {
    endpoint: '/api/users',
    method: 'GET',
    status: 200
  }
});

Example 2

With custom value

Sentry.metrics.count('items.processed', 5, {
  attributes: {
    processor: 'batch-processor',
    queue: 'high-priority'
  }
});

function distribution

distribution: (name: string, value: number, options?: MetricOptions) => void;

Record a value in a distribution metric.

Parameter name

The name of the distribution metric.

Parameter value

The value to record in the distribution.

Parameter options

Options for capturing the metric.

Example 1

Sentry.metrics.distribution('task.duration', 500, {
  unit: 'millisecond',
  attributes: {
    task: 'data-processing',
    priority: 'high'
  }
});

Example 2

Without unit

Sentry.metrics.distribution('batch.size', 100, {
  attributes: {
    processor: 'batch-1',
    type: 'async'
  }
});

function gauge

gauge: (name: string, value: number, options?: MetricOptions) => void;

Set a gauge metric to a specific value.

Parameter name

The name of the gauge metric.

Parameter value

The current value of the gauge.

Parameter options

Options for capturing the metric.

Example 1

Sentry.metrics.gauge('memory.usage', 1024, {
  unit: 'megabyte',
  attributes: {
    process: 'web-server',
    region: 'us-east-1'
  }
});

Example 2

Without unit

Sentry.metrics.gauge('active.connections', 42, {
  attributes: {
    server: 'api-1',
    protocol: 'websocket'
  }
});

interface MetricOptions

interface MetricOptions {}

Options for capturing a metric.

property attributes

attributes?: Metric['attributes'];

Arbitrary structured data that stores information about the metric.

property scope

scope?: Scope;

The scope to capture the metric with.

property unit

unit?: MetricUnit;

The unit of the metric value.

Package Files (187)

Dependencies (1)

@sentry/conventions

Dev Dependencies (1)

Peer Dependencies (0)

No peer dependencies.

Badge

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

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

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@sentry/core)

HTML

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

Updated 1 second ago.
Package analyzed in 15577 ms.
Missing or incorrect documentation? Open an issue for this package.

@sentry/core

Install

Overview

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Namespaces

Variables

variable BROWSER_NAVIGATION_TIMING_SPAN_NAMES

See Also

variable CACHE_OPERATION_NAMES

See Also

variable CONSOLE_LEVELS

variable DB_SPAN_NAME_FALLBACK

See Also

variable debug

variable DEFAULT_ENVIRONMENT

variable DEFAULT_RETRY_AFTER

variable DEV_ENVIRONMENT

variable featureFlagsIntegration

Example 1

variable fmt

Parameter strings

Parameter values

Returns

variable FUNCTION_SPAN_NAME_FALLBACK

See Also

variable GEN_AI_AGENT_SPAN_NAME_FALLBACK

See Also

variable GEN_AI_CONVERSATION_ID_ATTRIBUTE

variable GEN_AI_INFERENCE_SPAN_NAME_FALLBACK

See Also

variable getRootSpan

variable GLOBAL_OBJ

variable GRAPHQL_SPAN_NAME_FALLBACK

See Also

variable growthbookIntegration

Example 1

variable HTTP_SPAN_NAME_FALLBACK

See Also

variable installedIntegrations

variable MAX_BAGGAGE_STRING_LENGTH

variable MAX_BODY_BYTE_LENGTH

variable MCP_NOTIFICATION_SPAN_NAME_FALLBACK

See Also

variable MCP_SERVER_SPAN_NAME_FALLBACK

See Also

variable MESSAGING_SPAN_NAME_FALLBACK

See Also

variable MULTIPLEXED_TRANSPORT_EXTRA_KEY

variable NAVIGATION_SPAN_NAME_FALLBACK

See Also

variable originalConsoleMethods

variable PAGELOAD_SPAN_NAME_FALLBACK

See Also

variable profiler

variable REQUEST_HANDLER_SPAN_NAME_FALLBACK

See Also

variable RESOURCE_SPAN_NAME_FALLBACK

See Also

variable ROUTER_SPAN_NAME_FALLBACK

See Also

variable SDK_VERSION

variable SEMANTIC_ATTRIBUTE_CACHE_HIT

variable SEMANTIC_ATTRIBUTE_CACHE_ITEM_SIZE

variable SEMANTIC_ATTRIBUTE_CACHE_KEY

variable SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME

variable SEMANTIC_ATTRIBUTE_HTTP_REQUEST_METHOD

variable SEMANTIC_ATTRIBUTE_PROFILE_ID

variable SEMANTIC_ATTRIBUTE_SENTRY_ENVIRONMENT

variable SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON

variable SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_UNIT

variable SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_VALUE

variable SEMANTIC_ATTRIBUTE_SENTRY_OP

variable SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN

variable SEMANTIC_ATTRIBUTE_SENTRY_PREVIOUS_TRACE_SAMPLE_RATE

variable SEMANTIC_ATTRIBUTE_SENTRY_RELEASE