@sentry/core

@sentry/core

Version 10.61.0
Published 12 hours ago
6.62 MB
No dependencies
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 ANTHROPIC_AI_INTEGRATION_NAME

const ANTHROPIC_AI_INTEGRATION_NAME: string;

variable CONSOLE_LEVELS

const CONSOLE_LEVELS: readonly ConsoleLevel[];

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

const GOOGLE_GENAI_INTEGRATION_NAME: string;

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_ON_CLIENT_REQUEST

const HTTP_ON_CLIENT_REQUEST: string;

variable HTTP_ON_SERVER_REQUEST

const HTTP_ON_SERVER_REQUEST: string;

variable installedIntegrations

const installedIntegrations: string[];

variable LANGCHAIN_INTEGRATION_NAME

const LANGCHAIN_INTEGRATION_NAME: string;

variable LANGGRAPH_INTEGRATION_NAME

const LANGGRAPH_INTEGRATION_NAME: 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 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 OPENAI_INTEGRATION_NAME

const OPENAI_INTEGRATION_NAME: string;

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 profiler

const profiler: Profiler;

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

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., ["InboundFilters", "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")

variable SEMANTIC_ATTRIBUTE_SENTRY_SDK_VERSION

const SEMANTIC_ATTRIBUTE_SENTRY_SDK_VERSION: string;

The version of the Sentry SDK

variable SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_ID

const SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_ID: string;

The id of the segment that this span belongs to.

variable SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_NAME

const SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_NAME: string;

The segment name (e.g., "GET /users")

variable SEMANTIC_ATTRIBUTE_SENTRY_SOURCE

const SEMANTIC_ATTRIBUTE_SENTRY_SOURCE: string;

Use this attribute to represent the source of a span name. Must be one of: custom, url, route, view, component, task TODO(v11): rename this to sentry.span.source'

variable SEMANTIC_ATTRIBUTE_URL_FULL

const SEMANTIC_ATTRIBUTE_URL_FULL: string;

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 SPAN_KIND

const SPAN_KIND: {
    readonly INTERNAL: 0;
    readonly SERVER: 1;
    readonly CLIENT: 2;
    readonly PRODUCER: 3;
    readonly CONSUMER: 4;
};

The kind of a span, mirroring OpenTelemetry's SpanKind enum values.
Exported as a plain const object so SDK code can set a span's kind without importing @opentelemetry/api just for the enum. The numeric values must stay in sync with OpenTelemetry's SpanKind since they are passed through to the underlying OTel span and sampler.

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 SUPPRESS_TRACING_KEY

const SUPPRESS_TRACING_KEY: string;

variable TRACEPARENT_REGEXP

const TRACEPARENT_REGEXP: RegExp;

variable TRACING_DEFAULTS

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

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,
    skipNativeFetchCheck?: boolean
) => () => 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 addOutgoingRequestBreadcrumb

addOutgoingRequestBreadcrumb: (
    request: HttpClientRequest,
    response: HttpIncomingMessage | undefined
) => void;

Create a breadcrumb for a finished outgoing HTTP request.

function addVercelAiProcessors

addVercelAiProcessors: (client: Client) => void;

Add event processors to the given client to process Vercel AI spans.

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 callFrameToStackFrame

callFrameToStackFrame: (
    frame: CallFrame,
    url: string | undefined,
    getModuleFromFilename: (filename: string | undefined) => string | undefined
) => StackFrame;

Converts Debugger.CallFrame to Sentry StackFrame

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;

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;

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;

Captures calls to the console API as logs in Sentry. Requires the enableLogs option to be enabled.
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({ enableLogs: true, 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;

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. Requires the enableLogs option to be enabled.

**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({
  enableLogs: true,
});

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 createLangChainCallbackHandler

createLangChainCallbackHandler: (
    options?: LangChainOptions
) => LangChainCallbackHandler;

Creates a Sentry callback handler for LangChain Returns a plain object that LangChain will call via duck-typing
This is a stateful handler that tracks spans across multiple LangChain executions.

function createSessionEnvelope

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

Creates an envelope from a Session

function createSpanEnvelope

createSpanEnvelope: (
    spans: [SentrySpan, ...SentrySpan[]],
    client?: Client
) => SpanEnvelope;

Create envelope from Span item.
Takes an optional client and runs spans through beforeSendSpan if available.

function createSpanEnvelopeItem

createSpanEnvelopeItem: (spanJson: Partial<SpanJSON>) => SpanItem;

Creates envelope item for a single span

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;

Deduplication filter.

function defineIntegration

defineIntegration: <Fn extends IntegrationFn<Integration>>(
    fn: Fn
) => (...args: Parameters<Fn>) => Integration;

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;

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 expressErrorHandler

expressErrorHandler: (options?: ExpressHandlerOptions) => ExpressErrorMiddleware;

An Express-compatible error handler, used by setupExpressErrorHandler

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;

function filenameIsInApp

filenameIsInApp: (filename: string, isNative?: boolean) => boolean;

Does this filename look like it's part of the app code?

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

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: () => Span | undefined;

Returns the currently active span.

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 getComponentName

getComponentName: (elem: unknown, maxTraverseHeight?: number) => string | null;

Given a DOM element, traverses up the tree until it finds the first ancestor node that has the data-sentry-component or data-sentry-element attribute with data-sentry-component taking precedence. This attribute is added at build-time by projects that have the component name annotation plugin installed.
Returns
a string representation of the component for the provided DOM element, or null if not found

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

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('./shared-exports').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 getHttpClientSubscriptions

getHttpClientSubscriptions: (
    options: HttpInstrumentationOptions
) => HttpClientSubscriptions;

function getHttpServerSubscriptions

getHttpServerSubscriptions: (
    options: HttpInstrumentationOptions
) => HttpServerSubscriptions;

function getHttpSpanDetailsFromUrlObject

getHttpSpanDetailsFromUrlObject: (
    urlObject: URLObject | undefined,
    kind: 'server' | 'client',
    spanOrigin: string,
    request?: PartialRequest,
    routeName?: string
) => [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
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 getLocationHref

getLocationHref: () => string;

A safe form of location.href

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 getRequestOptions

getRequestOptions: (request: HttpClientRequest) => HttpRequestOptions;

Convert an outgoing request to request options.

function getRequestUrl

getRequestUrl: (requestOptions: HttpRequestOptions) => string;

function getRequestUrlFromClientRequest

getRequestUrlFromClientRequest: (request: HttpClientRequest) => string;

Build the full URL string from a Node.js ClientRequest.

function getRequestUrlObject

getRequestUrlObject: (requestOptions: HttpRequestOptions) => URL;

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

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 handleCallbackErrors

handleCallbackErrors: {
    <Fn extends () => Promise<any>, PromiseValue = AwaitedPromise<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 htmlTreeAsString

htmlTreeAsString: (
    elem: unknown,
    options?: string[] | { keyAttrs?: string[]; maxStringLength?: number }
) => string;

Given a child DOM element, returns a query-selector statement describing that and its ancestors e.g. [HTMLElement] => body > div > input#foo.btn[name=baz]
Returns
generated DOM path
Deprecated
This is browser-specific and will be removed from @sentry/core in a future major version. Import htmlTreeAsString from @sentry/browser-utils instead.

function httpHeadersToSpanAttributes

httpHeadersToSpanAttributes: (
    headers: Record<string, string | string[] | undefined>,
    dataCollection?: ResolvedDataCollection | boolean,
    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 with dashes converted to underscores.
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 inboundFiltersIntegration

inboundFiltersIntegration: (
    options?: Partial<EventFiltersOptions> | undefined
) => import('..').Integration;

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.
Deprecated
this integration was renamed and will be removed in a future major version. Use eventFiltersIntegration instead.

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 instrumentAnthropicAiClient

instrumentAnthropicAiClient: <T extends object>(
    anthropicAiClient: T,
    options?: AnthropicAiOptions
) => T;

Instrument an Anthropic AI client with Sentry tracing Can be used across Node.js, Cloudflare Workers, and Vercel Edge
T - The type of the client that extends object
Parameter client
The Anthropic AI client to instrument
Parameter options
Optional configuration for recording inputs and outputs
Returns
The instrumented client with the same type as the input

function instrumentCreateReactAgent

instrumentCreateReactAgent: (
    originalCreateReactAgent: (...args: unknown[]) => CompiledGraph,
    options?: LangGraphOptions
) => (...args: unknown[]) => CompiledGraph;

Instruments createReactAgent to create invoke_agent and execute_tool spans.

function instrumentFetchRequest

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

Create and track fetch request spans for usage in combination with addFetchInstrumentationHandler.
Returns
Span if a span was created, otherwise void.
Deprecated
pass an options object instead of the spanOrigin parameter
Create and track fetch request spans for usage in combination with addFetchInstrumentationHandler.
Returns
Span if a span was created, otherwise void.

function instrumentGoogleGenAIClient

instrumentGoogleGenAIClient: <T extends object>(
    client: T,
    options?: GoogleGenAIOptions
) => T;

Instrument a Google GenAI client with Sentry tracing Can be used across Node.js, Cloudflare Workers, and Vercel Edge

T - The type of the client that extends client object

Parameter client

The Google GenAI client to instrument

Parameter options

Optional configuration for recording inputs and outputs

Returns

The instrumented client with the same type as the input

Example 1

import { GoogleGenAI } from '@google/genai';
import { instrumentGoogleGenAIClient } from '@sentry/core';

const genAI = new GoogleGenAI({ apiKey: process.env.GOOGLE_GENAI_API_KEY });
const instrumentedClient = instrumentGoogleGenAIClient(genAI);

// Now both chats.create and sendMessage will be instrumented
const chat = instrumentedClient.chats.create({ model: 'gemini-1.5-pro' });
const response = await chat.sendMessage({ message: 'Hello' });

function instrumentLangChainEmbeddings

instrumentLangChainEmbeddings: <T extends object>(
    instance: T,
    options?: LangChainOptions
) => T;

Wraps a LangChain embeddings instance to create Sentry spans for embedQuery and embedDocuments calls.

Use this in non-Node runtimes (Cloudflare, browser, etc.) where auto-instrumentation is not available.

Example 1

import * as Sentry from '@sentry/cloudflare';
import { OpenAIEmbeddings } from '@langchain/openai';

const embeddings = Sentry.instrumentLangChainEmbeddings(
  new OpenAIEmbeddings({ model: 'text-embedding-3-small' })
);

await embeddings.embedQuery('Hello world');
await embeddings.embedDocuments(['doc1', 'doc2']);

function instrumentLangGraph

instrumentLangGraph: <T extends { compile: (...args: any[]) => any }>(
    stateGraph: T,
    options?: LangGraphOptions
) => T;

Directly instruments a StateGraph instance to add tracing spans

This function can be used to manually instrument LangGraph StateGraph instances in environments where automatic instrumentation is not available or desired.

Parameter stateGraph

The StateGraph instance to instrument

Parameter options

Optional configuration for recording inputs/outputs

Example 1

import { instrumentLangGraph } from '@sentry/cloudflare';
import { StateGraph } from '@langchain/langgraph';

const graph = new StateGraph(MessagesAnnotation)
  .addNode('agent', mockLlm)
  .addEdge(START, 'agent')
  .addEdge('agent', END);

instrumentLangGraph(graph, { recordInputs: true, recordOutputs: true });
const compiled = graph.compile({ name: 'my_agent' });

function instrumentOpenAiClient

instrumentOpenAiClient: <T extends object>(
    client: T,
    options?: OpenAiOptions
) => T;

Instrument an OpenAI client with Sentry tracing Can be used across Node.js, Cloudflare Workers, and Vercel Edge

function instrumentPostgresJsSql

instrumentPostgresJsSql: <T>(
    sql: T,
    options?: PostgresJsSqlInstrumentationOptions
) => T;

Instruments a postgres.js sql instance with Sentry tracing.

This is a portable instrumentation function that works in any environment (Node.js, Cloudflare Workers, etc.) without depending on OpenTelemetry.

Example 1

import postgres from 'postgres';
import * as Sentry from '@sentry/cloudflare'; // or '@sentry/deno'

const sql = Sentry.instrumentPostgresJsSql(
  postgres({ host: 'localhost', database: 'mydb' })
);

// All queries now create Sentry spans
await sql`SELECT * FROM users WHERE id = ${userId}`;

function instrumentStateGraphCompile

instrumentStateGraphCompile: (
    originalCompile: (...args: unknown[]) => CompiledGraph,
    options: LangGraphOptions
) => (...args: unknown[]) => CompiledGraph;

Instruments StateGraph's compile method to create spans for agent creation and invocation
Wraps the compile() method to: - Create a gen_ai.create_agent span when compile() is called - Automatically wrap the invoke() method on the returned compiled graph with a gen_ai.invoke_agent span

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 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 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: any, base: any) => wat is T;

Checks whether given value's type is an instance of provided constructor. isInstanceOf.
Parameter wat
A value to be checked.
Parameter base
A constructor to be used in a check.
Returns
A boolean representing the result.

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 isNodeEnv

isNodeEnv: () => boolean;

Checks whether we're in the Node.js or Browser environment
Returns
Answer to given question

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 isStaticAssetRequest

isStaticAssetRequest: (urlPath: string) => boolean;

function isStreamedBeforeSendSpanCallback

isStreamedBeforeSendSpanCallback: (
    callback: unknown
) => callback is BeforeSendStreamedSpanCallback;

Typesafe check to identify if a beforeSendSpan callback expects the streamed span JSON format.
Parameter callback
The beforeSendSpan callback to check.
Returns
true if the callback was wrapped with withStreamedSpan.

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 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 in beforeSend) could be returned.
Returns
The last event id of the isolation scope.

function linkedErrorsIntegration

linkedErrorsIntegration: (
    options?: LinkedErrorsOptions | undefined
) => import('..').Integration;

function loadModule

loadModule: <T>(moduleName: string, existingModule?: any) => T | undefined;

Helper for dynamically loading module that should work with linked dependencies. The problem is that we _should_ be using require(require.resolve(moduleName, { paths: [cwd()] })) However it's _not possible_ to do that with Webpack, as it has to know all the dependencies during build time. require.resolve is also not available in any other way, so we cannot create, a fake helper like we do with dynamicRequire.
We always prefer to use local package, thus the value is not returned early from each try/catch block. That is to mimic the behavior of require.resolve exactly.
Parameter moduleName
module name to require
Parameter existingModule
module to use for requiring
Returns
possibly required module

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 markSpanForOtelSourceInference

markSpanForOtelSourceInference: (span: Span) => void;

Mark a span as eligible for OTel-style sentry.source inference at span end. Set by SentryTraceProvider on the spans it creates; read by SentrySpan.updateName() and applyOtelSpanData().

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;

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 node

node: (getModule?: GetModuleFn) => StackLineParserFn;

Node Stack line parser

function nodeStackLineParser

nodeStackLineParser: (getModule?: GetModuleFn) => StackLineParser;

Node.js stack line parser
This is in @sentry/core so it can be used from the Electron SDK in the browser for when nodeIntegration == true. This allows it to be used without referencing or importing any node specific code which causes bundlers to complain

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
) => 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 patchExpressModule

patchExpressModule: {
    (
        moduleExports: ExpressModuleExport,
        getOptions: () => ExpressIntegrationOptions
    ): ExpressModuleExport;
    (
        options: ExpressIntegrationOptions & { express: ExpressModuleExport }
    ): ExpressModuleExport;
};

This is a portable instrumentatiton function that works in any environment where Express can be loaded, without depending on OpenTelemetry.

Example 1

import express from 'express';
import * as Sentry from '@sentry/deno'; // or any SDK that extends core

Sentry.patchExpressModule(express, () => ({}));

Deprecated
Pass the Express module export as the first argument and options getter as the second argument.

function patchHttpModuleClient

patchHttpModuleClient: (
    httpModuleExport: HttpModuleExport,
    options?: HttpInstrumentationOptions
) => HttpModuleExport;

Patch an node:http or node:https module-shaped export so that every outgoing request is tracked by Sentry.

Example 1

import http from 'http';
import { patchHttpModule } from '@sentry/core';
patchHttpModule(http, { propagateTrace: true });

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.

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 recordRequestSession

recordRequestSession: (
    client: Client,
    {
        requestIsolationScope,
        response,
        sessionFlushingDelayMS,
    }: {
        requestIsolationScope: Scope;
        response: HttpServerResponse;
        sessionFlushingDelayMS?: number;
    }
) => void;

Starts a session and tracks it in the context of a given isolation scope. When the passed response is finished, the session is put into a task and is aggregated with other sessions that may happen in a certain time window (sessionFlushingDelayMs).
The sessions are always aggregated by the client that is on the current scope at the time of ending the response (if there is one).

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;

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;

Rewrite event frames paths.

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

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 setupExpressErrorHandler

setupExpressErrorHandler: (
    app: { use: (middleware: any) => unknown },
    options?: ExpressHandlerOptions
) => void;

Add an Express error handler to capture errors to Sentry.

The error handler must be before any other middleware and after all controllers.

Parameter app

The Express instances

Parameter options

Configuration options for the handler

Example 1

import * as Sentry from 'sentry/deno'; // or any other @sentry/<platform>
import * as express from 'express';

Sentry.instrumentExpress(express);

const app = express();

// Add your routes, etc.

// Add this after all routes,
// but before any and other error-handling middlewares are defined
Sentry.setupExpressErrorHandler(app);

app.listen(3000);

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

spanShouldInferOtelSource: (span: Span) => boolean;

Whether a span is marked for OTel-style sentry.source inference (see markSpanForOtelSourceInference).

function spanStreamingIntegration

spanStreamingIntegration: () => import('..').Integration;

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) => SpanJSON;

Convert a span to a JSON representation.

function spanToStreamedSpanJSON

spanToStreamedSpanJSON: (span: Span) => StreamedSpanJSON;

Convert a span to the intermediate StreamedSpanJSON 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 startIdleSpan

startIdleSpan: (
    startSpanOptions: StartSpanOptions,
    options?: Partial<IdleSpanOptions>
) => Span;

An idle span is a span that automatically finishes. It does this by tracking child spans as activities. An idle span is always the active span.

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

function supportsDOMError

supportsDOMError: () => boolean;

Tells whether current environment supports DOMError objects supportsDOMError.
Returns
Answer to the given question.

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 supportsHistory

supportsHistory: () => boolean;

Tells whether current environment supports History API supportsHistory.
Returns
Answer to the given question.

function supportsNativeFetch

supportsNativeFetch: () => boolean;

Tells whether current environment supports Fetch API natively supportsNativeFetch.
Returns
true if window.fetch is natively implemented, false otherwise

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 supportsReportingObserver

supportsReportingObserver: () => boolean;

Tells whether current environment supports ReportingObserver API supportsReportingObserver.
Returns
Answer to the given question.

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;

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 trpcMiddleware

trpcMiddleware: (
    options?: SentryTrpcMiddlewareOptions
) => <T>(opts: SentryTrpcMiddlewareArguments<T>) => SentryTrpcMiddleware<T>;

Sentry tRPC middleware that captures errors and creates spans for tRPC procedures.

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

vercelWaitUntil: (task: Promise<unknown>) => void;

Function that delays closing of a Vercel lambda until the provided promise is resolved.
Vendored from https://www.npmjs.com/package/@vercel/functions

function watchdogTimer

watchdogTimer: (
    createTimer: CreateTimerImpl,
    pollInterval: number,
    anrThreshold: number,
    callback: () => void
) => WatchdogReturn;

A node.js watchdog timer
Parameter pollInterval
The interval that we expect to get polled at
Parameter anrThreshold
The threshold for when we consider ANR
Parameter callback
The callback to call for ANR
Returns
An object with poll and enabled functions WatchdogReturn

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 withStreamedSpan

withStreamedSpan: (
    callback: (span: StreamedSpanJSON) => StreamedSpanJSON
) => StaticBeforeSendSpanCallback & { _streamed: true };

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

function wrapMcpServerWithSentry

wrapMcpServerWithSentry: <S extends object>(
    mcpServerInstance: S,
    options?: McpServerWrapperOptions
) => S;

Wraps a MCP Server instance from the @modelcontextprotocol/sdk package with Sentry instrumentation.
Compatible with versions ^1.9.0 of the @modelcontextprotocol/sdk package (legacy tool/resource/prompt API) and versions that expose the newer registerTool/registerResource/registerPrompt API (introduced in 1.x, sole API in 2.x). Automatically instruments transport methods and handler functions for comprehensive monitoring.
Both call orderings are supported: wrapping before or after registering tools, resources, and prompts. Sentry patches the registration methods for future handlers and retroactively wraps any already-registered ones. Wrapping at construction time is recommended by convention (consistent with other SDK integrations), but is not required.
Parameter mcpServerInstance
MCP server instance to instrument
Parameter options
Optional configuration for recording inputs and outputs
Returns
Instrumented server instance (same reference)
Example 1
import * as Sentry from '@sentry/core'; import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'; import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js'; // Wrap first, then register tools — this is the correct order const server = Sentry.wrapMcpServerWithSentry( new McpServer({ name: "my-server", version: "1.0.0" }) ); server.registerTool('my-tool', schema, handler); // Explicitly control input/output capture const server = Sentry.wrapMcpServerWithSentry( new McpServer({ name: "my-server", version: "1.0.0" }), { recordInputs: true, recordOutputs: false } ); const transport = new StreamableHTTPServerTransport(); await server.connect(transport);

function zodErrorsIntegration

zodErrorsIntegration: (
    options?: ZodErrorsOptions | undefined
) => import('..').Integration;

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: 'beforeSampling',
        samplingData: {
            spanAttributes: SpanAttributes;
            spanName: string;
            parentSampled?: boolean;
            parentSampleRate?: number;
            parentContext?: SpanContextData;
        },
        samplingDecision: { decision: boolean }
    ): void;
    (hook: 'spanEnd', span: Span): void;
    (hook: 'afterSpanEnd', immutableSpan: Readonly<Span>): void;
    (hook: 'afterSegmentSpanEnd', immutableSegmentSpan: Readonly<Span>): void;
    (
        hook: 'preprocessSpan',
        streamedSpanJSON: StreamedSpanJSON,
        hint?: { spanKind?: number }
    ): void;
    (hook: 'processSpan', streamedSpanJSON: StreamedSpanJSON): void;
    (hook: 'processSegmentSpan', streamedSpanJSON: StreamedSpanJSON): void;
    (hook: 'idleSpanEnableAutoFinish', span: Span): void;
    (hook: 'beforeEnvelope', 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 }
    ): void;
    (
        hook: 'startNavigationSpan',
        options: StartSpanOptions,
        navigationOptions?: { isRedirect?: boolean }
    ): void;
    (
        hook: 'beforeOutgoingRequestSpan',
        span: Span,
        hint: XhrBreadcrumbHint | FetchBreadcrumbHint
    ): void;
    (
        hook: 'beforeOutgoingRequestBreadcrumb',
        breadcrumb: Breadcrumb,
        hint: XhrBreadcrumbHint | FetchBreadcrumbHint
    ): void;
    (hook: 'flush'): 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;
};

Fire a hook whenever a span starts.
A hook that is called every time before a span is sampled.
Fire a hook whenever a span ends.
Fire a hook 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 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
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.

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: '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: 'afterSpanEnd',
        callback: (immutableSegmentSpan: Readonly<Span>) => void
    ): () => void;
    (
        hook: 'afterSegmentSpanEnd',
        callback: (immutableSegmentSpan: Readonly<Span>) => void
    ): () => void;
    (
        hook: 'preprocessSpan',
        callback: (
            streamedSpanJSON: StreamedSpanJSON,
            hint?: { spanKind?: number }
        ) => 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: '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 }
        ) => void
    ): () => void;
    (
        hook: 'startNavigationSpan',
        callback: (
            options: StartSpanOptions,
            navigationOptions?: { isRedirect?: boolean }
        ) => 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: '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;
};

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 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 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. The optional hint exposes additional context about the originating span (e.g. the OTel spanKind).
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 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 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.

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();

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 clear

clear: () => this;

Clears the current scope and resets its properties. Note: The client will not be cleared.

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 ServerRuntimeClient

class ServerRuntimeClient<
    O extends ClientOptions & ServerRuntimeClientOptions = ServerRuntimeClientOptions
> extends Client<O> {}

The Sentry Server Runtime Client SDK.

constructor

constructor(
    options: ClientOptions<BaseTransportOptions> & ServerRuntimeClientOptions
);

Creates a new Edge SDK instance.
Parameter options
Configuration options for this SDK.

method captureCheckIn

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

method captureEvent

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

method captureException

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

method dispose

dispose: () => void;

Disposes of the client and releases all resources.
This method clears all internal state to allow the client to be garbage collected. It clears hooks, event processors, integrations, transport, and other internal references.
Call this method after flushing to allow the client to be garbage collected. After calling dispose(), the client should not be used anymore.
Subclasses should override this method to clean up their own resources and call super.dispose().

method eventFromException

eventFromException: (exception: unknown, hint?: EventHint) => PromiseLike<Event>;

method eventFromMessage

eventFromMessage: (
    message: ParameterizedString,
    level?: SeverityLevel,
    hint?: EventHint
) => PromiseLike<Event>;

method registerCleanup

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

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 AnthropicAiClient

interface AnthropicAiClient {}

Basic interface for Anthropic AI client with only the instrumented methods This provides type safety while being generic enough to work with different client implementations

property completions

completions?: {
    create: (...args: unknown[]) => Promise<AnthropicAiResponse>;
};

property messages

messages?: {
    create: (...args: unknown[]) => Promise<AnthropicAiResponse>;
    countTokens: (...args: unknown[]) => Promise<AnthropicAiResponse>;
};

property models

models?: {
    list: (...args: unknown[]) => Promise<AnthropicAiResponse>;
    get: (...args: unknown[]) => Promise<AnthropicAiResponse>;
};

interface AnthropicAiOptions

interface AnthropicAiOptions {}

property enableTruncation

enableTruncation?: boolean;

Enable or disable truncation of recorded input messages. Defaults to true.

property recordInputs

recordInputs?: boolean;

Enable or disable input recording.

property recordOutputs

recordOutputs?: boolean;

Enable or disable output recording.

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 startInactiveSpan

startInactiveSpan?: typeof startInactiveSpan;

Start an inactive span.

property startNewTrace

startNewTrace?: typeof startNewTrace;

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

property startSpan

startSpan?: typeof startSpan;

Start an active span.

property startSpanManual

startSpanManual?: typeof startSpanManual;

Start an active manual span.

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;

When enabled, stack traces are automatically attached to all events captured with Sentry.captureMessage.
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.
false

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?: ((span: SpanJSON) => SpanJSON) & {
    _streamed?: true;
};

This function can be defined to modify a child span before it's sent.
When using traceLifecycle: 'stream', wrap your callback with withStreamedSpan to receive and return StreamedSpanJSON instead.
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.
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 dataCollection

dataCollection?: DataCollection;

Controls what data the SDK collects and sends to Sentry. All fields are optional — omitted fields use the documented defaults.
This replaces the deprecated ClientOptions.sendDefaultPii option and lets you control 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 enableLogs

enableLogs?: boolean;

If logs support should be enabled.
false

property enableMetrics

enableMetrics?: boolean;

If metrics support should be enabled.
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.
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.
[]

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 sendDefaultPii

sendDefaultPii?: boolean;

Controls if potentially sensitive data should be sent to Sentry by default. Note that this only applies to data that the SDK is sending by default but not data that was explicitly set (e.g. by calling Sentry.setUser()).
false
Deprecated
Use the ClientOptions.dataCollection option instead, which lets you control each category of collected data individually. sendDefaultPii will be removed in the next major version (v11). For backwards compatibility, setting sendDefaultPii: true currently behaves like enabling all dataCollection categories. If both sendDefaultPii and dataCollection are set, sendDefaultPii will be ignored.

property stackParser

stackParser: StackParser;

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

property streamGenAiSpans

streamGenAiSpans?: boolean;

Unless set to false, gen_ai spans will be extracted from transactions and sent as v2 span envelope items.
This enables streaming gen_ai spans, avoiding payload size limits of usual transactions.
Because the v2 span format is not subject to the transaction payload-size limits that gen_ai message truncation exists to work around, this also disables gen_ai input truncation by default. Set enableTruncation: true on the respective AI integration to opt back into truncation, or set this option to false to send gen_ai spans as part of the transaction (which re-enables truncation by default).
true

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

property tracePropagationTargets

tracePropagationTargets?: TracePropagationTargets;

List of strings and/or Regular Expressions used to determine which outgoing requests will have sentry-trace and baggage headers attached.
**Default:** If this option is not provided, tracing headers will be attached to all outgoing requests. If you are using a browser SDK, by default, tracing headers will only be attached to outgoing requests to the same origin.
**Disclaimer:** Carelessly setting this option in browser environments may result into CORS errors! Only attach tracing headers to requests to the same origin, or to requests to services you can control CORS headers of. Cross-origin requests, meaning requests to a different domain, for example a request to https://api.example.com/ while you're on https://example.com/, take special care. If you are attaching headers to cross-origin requests, make sure the backend handling the request returns a "Access-Control-Allow-Headers: sentry-trace, baggage" header to ensure your requests aren't blocked.
If you provide a tracePropagationTargets array, the entries you provide will be matched against the entire URL of the outgoing request. If you are using a browser SDK, the entries will also be matched against the pathname of the outgoing requests. This is so you can have matchers for relative requests, for example, /^\/api/ if you want to trace requests to your /api routes on the same domain.
If any of the two match any of the provided values, tracing headers will be attached to the outgoing request. Both, the string values, and the RegExes you provide in the array will match if they partially match the URL or pathname.
Examples: - tracePropagationTargets: [/^\/api/] and request to https://same-origin.com/api/posts: - Tracing headers will be attached because the request is sent to the same origin and the regex matches the pathname "/api/posts". - tracePropagationTargets: [/^\/api/] and request to https://different-origin.com/api/posts: - Tracing headers will not be attached because the pathname will only be compared when the request target lives on the same origin. - tracePropagationTargets: [/^\/api/, 'https://external-api.com'] and request to https://external-api.com/v1/data: - Tracing headers will be attached because the request URL matches the string 'https://external-api.com'.

property tracesSampler

tracesSampler?: (
    samplingContext: 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 CompiledGraph

interface CompiledGraph {}

Basic interface for compiled graph

property builder

builder?: StateGraphBuilder;

property graph_name

graph_name?: string;

property invoke

invoke?: (...args: unknown[]) => Promise<unknown>;

property lc_kwargs

lc_kwargs?: {
    [key: string]: unknown;
    name?: string;
};

property name

name?: string;

index signature

[key: string]: unknown;

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

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 frameContextLines

frameContextLines?: number;

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

property genAI

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

Controls generative AI input/output recording. { inputs: true, outputs: 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?: {
    request?: CollectBehavior;
    response?: CollectBehavior;
};

Controls HTTP header collection for requests and responses. { request: true, response: true }

property queryParams

queryParams?: CollectBehavior;

Controls query parameter collection and sensitive value filtering. true

property stackFrameVariables

stackFrameVariables?: boolean;

Capture local variable values in stack frames. true

property userInfo

userInfo?: boolean;

Automatically populate user.* fields from instrumentation sources. false

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 ExpressHandlerOptions

interface ExpressHandlerOptions {}

method shouldHandleError

shouldHandleError: (this: void, error: MiddlewareError) => boolean;

Callback method deciding whether error should be captured and sent to Sentry
Parameter error
Captured middleware error

interface ExtendedError

interface ExtendedError extends Error {}

Just an Error object with arbitrary attributes attached to it.

index signature

[key: string]: any;

interface ExtractedNodeRequestData

interface ExtractedNodeRequestData {}

Data extracted from an incoming request to a node server

property cookies

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

String representing the cookies sent along with the request

property data

data?: string;

Any data sent in the request's body, as a JSON string

property headers

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

Specific headers from the request

property method

method?: string;

The request's method

property query_string

query_string?: QueryParams;

The request's query params

property url

url?: string;

The request's URL, including query string

index signature

[key: string]: any;

interface 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 method

method: string;

property request_body_size

request_body_size?: number;

property response_body_size

response_body_size?: number;

property status_code

status_code?: number;

property url

url: string;

interface FetchBreadcrumbHint

interface FetchBreadcrumbHint {}

property data

data?: unknown;

property endTimestamp

endTimestamp?: number;

property input

input: any[];

property response

response?: unknown;

property startTimestamp

startTimestamp: number;

interface 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 GoogleGenAIChat

interface GoogleGenAIChat {}

Google GenAI Chat interface for chat instances created via chats.create()

property sendMessage

sendMessage: (...args: unknown[]) => Promise<GenerateContentResponse>;

property sendMessageStream

sendMessageStream: (
    ...args: unknown[]
) => Promise<AsyncGenerator<GenerateContentResponse, any, unknown>>;

interface GoogleGenAIClient

interface GoogleGenAIClient {}

Basic interface for Google GenAI client with only the instrumented methods This provides type safety while being generic enough to work with different client implementations

property chats

chats: {
    create: (...args: unknown[]) => GoogleGenAIChat;
};

property models

models: {
    generateContent: (...args: unknown[]) => Promise<GenerateContentResponse>;
    generateContentStream: (
        ...args: unknown[]
    ) => Promise<AsyncGenerator<GenerateContentResponse, any, unknown>>;
    embedContent: (...args: unknown[]) => Promise<unknown>;
};

interface GoogleGenAIOptions

interface GoogleGenAIOptions {}

property enableTruncation

enableTruncation?: boolean;

Enable or disable truncation of recorded input messages. Defaults to true.

property recordInputs

recordInputs?: boolean;

Enable or disable input recording.

property recordOutputs

recordOutputs?: boolean;

Enable or disable output recording.

interface HandlerDataConsole

interface HandlerDataConsole {}

property args

args: any[];

property level

level: ConsoleLevel;

interface HandlerDataDom

interface HandlerDataDom {}

property event

event:
    | object
    | {
          target: object;
      };

property global

global?: boolean;

property name

name: string;

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 HandlerDataHistory

interface HandlerDataHistory {}

property from

from: string | undefined;

The full URL of the previous page

property to

to: string;

The full URL of the new page

interface HandlerDataXhr

interface HandlerDataXhr {}

property endTimestamp

endTimestamp?: number;

property error

error?: unknown;

property startTimestamp

startTimestamp?: number;

property virtualError

virtualError?: unknown;

property xhr

xhr: SentryWrappedXMLHttpRequest;

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 HttpClientRequest

interface HttpClientRequest {}

Minimal interface for a Node.js http.ClientRequest

property host

host?: string;

property method

method?: string;

property path

path?: string;

property port

port?: number;

property protocol

protocol?: string;

method end

end: () => void;

method getHeader

getHeader: (name: string) => string | string[] | number | undefined;

method getHeaders

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

method listenerCount

listenerCount: (event: string | symbol) => number;

method on

on: (event: string | symbol, listener: (...args: unknown[]) => void) => this;

method once

once: (event: string | symbol, listener: (...args: unknown[]) => void) => this;

method prependListener

prependListener: {
    (event: 'response', listener: (res: HttpIncomingMessage) => void): this;
    (event: string | symbol, listener: (...args: unknown[]) => void): this;
};

method removeHeader

removeHeader: (name: string) => void;

method removeListener

removeListener: (
    event: string | symbol,
    listener: (...args: unknown[]) => void
) => this;

method setHeader

setHeader: (name: string, value: string | string[] | number) => void;

interface HttpIncomingMessage

interface HttpIncomingMessage {}

Minimal interface for a Node.js http.IncomingMessage

property aborted

aborted?: boolean;

property complete

complete?: boolean;

property headers

headers: Record<string, string | string[] | undefined>;

property httpVersion

httpVersion?: string;

property method

method?: string;

property socket

socket?: HttpSocket;

property statusCode

statusCode?: number;

property statusMessage

statusMessage?: string;

property url

url?: string;

method addListener

addListener: {
    (event: 'end', listener: () => void): this;
    (event: string | symbol, listener: (...args: unknown[]) => void): this;
};

method off

off: (event: string | symbol, listener: (...args: unknown[]) => void) => this;

method on

on: {
    (event: 'end', listener: () => void): this;
    (event: string | symbol, listener: (...args: unknown[]) => void): this;
};

method removeListener

removeListener: (
    event: string | symbol,
    listener: (...args: unknown[]) => void
) => this;

method resume

resume: () => void;

interface HttpInstrumentationOptions

interface HttpInstrumentationOptions {}

property applyCustomAttributesOnSpan

applyCustomAttributesOnSpan?: (
    span: Span,
    request: HttpClientRequest,
    response: HttpIncomingMessage
) => void;

Called when both the request and response are available (after the response ends). Useful for adding attributes based on both objects.

property breadcrumbs

breadcrumbs?: boolean;

Whether breadcrumbs should be recorded for outgoing requests. true

property errorMonitor

errorMonitor?: symbol | string;

Symbol to use for observing errors on EventEmitters without consuming them. Pass EventEmitter.errorMonitor from Node.js events module. Falls back to the plain 'error' event string when not provided.
Using the real errorMonitor symbol ensures that Sentry does not swallow errors before they reach user-supplied 'error' handlers.

property http

http?: HttpModuleExport;

Optional: pass in the http and https modules in order to detect whether a standalone OTel instrumentation is attempting to wrap them as well. This is fine, as long as spans option is disabled, but will result in double-emitting spans otherwise.
Since this cannot be fully prevented due to module load timing, and isn't necessarily harmful per se (just noisy/annoying), and there are a number of reasonable approaches to fix it (disable the OTel instrumentation, disable this instrumentation, or keep both and disable spans in one or the other), we simply print a warning so the user can hopefully make an informed decision about how to address it (if at all).

property https

https?: HttpModuleExport;

property ignoreIncomingRequests

ignoreIncomingRequests?: (
    urlPath: string,
    request: HttpIncomingMessage
) => boolean;

Do not capture spans for incoming HTTP requests to URLs where the given callback returns true. Spans will be non recording if tracing is disabled.
The urlPath param consists of the URL path and query string (if any) of the incoming request. For example: '/users/details?id=123'
The request param contains the original object of the incoming request. You can use it to filter on additional properties like method, headers, etc.

property ignoreOutgoingRequests

ignoreOutgoingRequests?: (url: string, request: HttpClientRequest) => boolean;

Skip span / breadcrumb creation for requests to matching URLs. Receives the full URL string and the outgoing request object.

property ignoreRequestBody

ignoreRequestBody?: (url: string, request: HttpIncomingMessage) => boolean;

Do not capture the request body for incoming HTTP requests to URLs where the given callback returns true. This can be useful for long running requests where the body is not needed and we want to avoid capturing it.
Parameter url
Contains the entire URL, including query string (if any), protocol, host, etc. of the incoming request.
Parameter request
Contains the object used to make the incoming request.

property ignoreStaticAssets

ignoreStaticAssets?: boolean;

Whether to automatically ignore common static asset requests like favicon.ico, robots.txt, etc. This helps reduce noise in your transactions.
true

property ignoreStatusCodes

ignoreStatusCodes?: (number | [number, number])[];

Do not capture spans for incoming HTTP requests with the given status codes. By default, spans with some 3xx and 4xx status codes are ignored (see @default). Expects an array of status codes or a range of status codes, e.g. [[300,399], 404] would ignore 3xx and 404 status codes.
[[401, 404], [301, 303], [305, 399]]

property maxRequestBodySize

maxRequestBodySize?: 'none' | 'small' | 'medium' | 'always';

Controls the maximum size of incoming HTTP request bodies attached to events.
Available options: - '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 (default) - 'always': Request bodies will always be attached
Note that even with 'always' setting, bodies exceeding 1MB will never be attached for performance and security reasons.
'medium'

property onSpanCreated

onSpanCreated?: (
    span: Span,
    request: HttpIncomingMessage,
    response: HttpServerResponse
) => void;

A hook that can be used to mutate the span for incoming requests. This is triggered after the span is created, but before it is recorded.

property onSpanEnd

onSpanEnd?: (
    span: Span,
    request: HttpIncomingMessage,
    response: HttpServerResponse
) => void;

A hook that can be used to mutate the span one last time when the response is finished, eg to update the transaction name based on the RPC metadata.

property outgoingRequestHook

outgoingRequestHook?: (span: Span, request: HttpClientRequest) => void;

Called after the outgoing-request span is created by the client. Use this to add custom attributes to the span.

property outgoingResponseHook

outgoingResponseHook?: (span: Span, response: HttpIncomingMessage) => void;

Called when the response is received by the client.

property propagateTrace

propagateTrace?: boolean;

Whether to inject distributed trace propagation headers (sentry-trace, baggage, traceparent) into outgoing requests. false

property sessionFlushingDelayMS

sessionFlushingDelayMS?: number;

Number of milliseconds until sessions tracked with trackIncomingRequestsAsSessions will be flushed as a session aggregate.
Defaults to 60000 (60s).

property sessions

sessions?: boolean;

Whether the integration should create [Sessions](https://docs.sentry.io/product/releases/health/#sessions) for incoming requests to track the health and crash-free rate of your releases in Sentry. Read more about Release Health: https://docs.sentry.io/product/releases/health/
Defaults to true.

property spans

spans?: boolean;

Whether to create spans for HTTP requests. Applies to both outgoing (getHttpClientSubscriptions) and incoming (getHttpServerSubscriptions) request instrumentation. Defaults to the client's tracing configuration (hasSpansEnabled) when unset.

property suppressOtelWarning

suppressOtelWarning?: boolean;

suppress the warning about double-wrapping with OTel

property wrapServerEmitRequest

wrapServerEmitRequest?: (
    request: HttpIncomingMessage,
    response: HttpServerResponse,
    normalizedRequest: RequestEventData,
    next: () => void
) => void;

Optional callback that can be used by integrations to emit the 'request' event within a given Sentry or OTEL context, possibly after creating a span, as in the HttpServerSpansIntegration.
**Important**: next() **must** be called synchronously, or else the http.Server.emit return value will be lost, and the proxy will return false even if there are listeners.

interface HttpServerResponse

interface HttpServerResponse {}

Minimal interface for a Node.js http.ServerResponse

property headers

headers: Record<string, string | undefined | string[] | number>;

property statusCode

statusCode: number;

property statusMessage

statusMessage?: string;

method on

on: (ev: string | symbol, handler: (...data: unknown[]) => void) => this;

method once

once: {
    (ev: string | symbol, handler: (...data: unknown[]) => void): this;
    (ev: 'close', handler: () => void): this;
};

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 LangChainIntegration

interface LangChainIntegration {}

Integration interface for type safety

property name

name: string;

property options

options: LangChainOptions;

interface LangChainOptions

interface LangChainOptions {}

Options for LangChain integration

property enableTruncation

enableTruncation?: boolean;

Enable or disable truncation of recorded input messages. Defaults to true.

property recordInputs

recordInputs?: boolean;

Whether to record input messages/prompts false (respects dataCollection.genAI.inputs, or sendDefaultPii when dataCollection is not configured)

property recordOutputs

recordOutputs?: boolean;

Whether to record output text and responses false (respects dataCollection.genAI.outputs, or sendDefaultPii when dataCollection is not configured)

interface LangGraphIntegration

interface LangGraphIntegration {}

LangGraph Integration interface for type safety

property name

name: string;

property options

options: LangGraphOptions;

interface LangGraphOptions

interface LangGraphOptions {}

property enableTruncation

enableTruncation?: boolean;

Enable or disable truncation of recorded input messages. Defaults to true.

property recordInputs

recordInputs?: boolean;

Enable or disable input recording.

property recordOutputs

recordOutputs?: boolean;

Enable or disable output recording.

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

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

The unit of the metric value.

interface MissingInstrumentationContext

interface MissingInstrumentationContext extends Record<string, unknown> {}

property ['javascript.is_cjs']

['javascript.is_cjs']?: boolean;

property package

package: 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 OpenAiClient

interface OpenAiClient {}

property chat

chat?: {
    completions?: {
        create: (...args: unknown[]) => Promise<unknown>;
    };
};

property responses

responses?: {
    create: (...args: unknown[]) => Promise<unknown>;
};

interface OpenAiOptions

interface OpenAiOptions {}

property enableTruncation

enableTruncation?: boolean;

Enable or disable truncation of recorded input messages. Defaults to true.

property recordInputs

recordInputs?: boolean;

Enable or disable input recording.

property recordOutputs

recordOutputs?: boolean;

Enable or disable output recording.

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

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 span

span?: Span;

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. This is only used for the legacy span/transaction creation and will go away in v8.

property attributes

attributes?: SpanAttributes;

Attributes of the Span.

property endTimestamp

endTimestamp?: number | undefined;

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

property isStandalone

isStandalone?: boolean | undefined;

Set to true if this span should be sent as a standalone segment span as opposed to a transaction.
this option is currently experimental and should only be used within SDK code. It might be removed or changed in the future.
Modifiers
- @experimental

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 SentryWrappedXMLHttpRequest

interface SentryWrappedXMLHttpRequest {}

property getResponseHeader

getResponseHeader?: (key: string) => string | null;

property setRequestHeader

setRequestHeader?: (key: string, val: string) => void;

interface SentryXhrData

interface SentryXhrData {}

property body

body?: XHRSendInput;

property method

method: string;

property request_body_size

request_body_size?: number;

property request_headers

request_headers: Record<string, string>;

property response_body_size

response_body_size?: number;

property status_code

status_code?: number;

property url

url: string;

interface SerializedCheckIn

interface SerializedCheckIn {}

property check_in_id

check_in_id: string;

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

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 ServerRuntimeClientOptions

interface ServerRuntimeClientOptions extends ClientOptions<BaseTransportOptions> {}

property platform

platform?: string;

property runtime

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

property serverName

serverName?: string;

interface ServerRuntimeOptions

interface ServerRuntimeOptions {}

Base options for WinterTC-compatible server-side JavaScript runtimes. This interface contains common configuration options shared between SDKs.

property clientReportFlushInterval

clientReportFlushInterval?: number;

Configures in which interval client reports will be flushed. Defaults to 60_000 (milliseconds).

property disableInstrumentationWarnings

disableInstrumentationWarnings?: boolean;

By default, the SDK will try to identify problems with your instrumentation setup and warn you about it. If you want to disable these warnings, set this to true.

property includeServerName

includeServerName?: boolean;

If set to false, the SDK will not automatically detect the serverName.
This is useful if you are using the SDK in a CLI app or Electron where the hostname might be considered PII.
true

property maxSpanWaitDuration

maxSpanWaitDuration?: number;

The max. duration in seconds that the SDK will wait for parent spans to be finished before discarding a span. The SDK will automatically clean up spans that have no finished parent after this duration. This is necessary to prevent memory leaks in case of parent spans that are never finished or otherwise dropped/missing. However, if you have very long-running spans in your application, a shorter duration might cause spans to be discarded too early. In this case, you can increase this duration to a value that fits your expected data.
Defaults to 300 seconds (5 minutes).

property serverName

serverName?: string;

Sets an optional server name (device name).
This is useful for identifying which server or instance is sending events.

property shutdownTimeout

shutdownTimeout?: number;

Controls how many milliseconds to wait before shutting down. The default is 2 seconds. Setting this too low can cause problems for sending events from command line applications. Setting it too high can cause the application to block for users with network connectivity problems.

property spotlight

spotlight?: boolean | string;

If you use Spotlight by Sentry during development, use this option to forward captured Sentry events to Spotlight.
Either set it to true, or provide a specific Spotlight Sidecar URL.
More details: https://spotlightjs.com/
IMPORTANT: Only set this option to true while developing, not in production!

property tracePropagationTargets

tracePropagationTargets?: TracePropagationTargets;

List of strings/regex controlling to which outgoing requests the SDK will attach tracing headers.
By default the SDK will attach those headers to all outgoing requests. If this option is provided, the SDK will match the request URL of outgoing requests against the items in this array, and only attach tracing headers if a match was found.
Example 1
Sentry.init({ tracePropagationTargets: ['api.site.com'], });

method onFatalError

onFatalError: (this: void, error: Error) => void;

Callback that is executed when a fatal global error occurs.

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?: number) => 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?: any;

property platform

platform?: string;

property post_context

post_context?: string[];

property pre_context

pre_context?: string[];

property vars

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

interface Stacktrace

interface Stacktrace {}

JSDoc

property frames

frames?: StackFrame[];

property frames_omitted

frames_omitted?: [number, number];

interface StartSpanOptions

interface StartSpanOptions {}

property attributes

attributes?: SpanAttributes;

Attributes for the span.

property experimental

experimental?: {
    /**
     * If set to true, always start a standalone span which will be sent as a
     * standalone segment span envelope instead of a transaction envelope.
     *
     * @internal this option is currently experimental and should only be
     * used within SDK code. It might be removed or changed in the future.
     * The payload ("envelope") of the resulting request sending the span to
     * Sentry might change at any time.
     *
     * @hidden
     */
    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.

property kind

kind?: SpanKindValue;

The kind of the span, following OpenTelemetry's SpanKind enum. - 0 = INTERNAL (default) - 1 = SERVER - 2 = CLIENT - 3 = PRODUCER - 4 = CONSUMER
This is used by OpenTelemetry-based SDK implementations to set the correct span kind on the underlying OTel span, which affects how the span is displayed and sampled.

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;

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

The ALS instance that will be bound to the channel.

property getStoreWithActiveSpan

getStoreWithActiveSpan: (span: Span) => unknown;

Activates a span for the tracing channels nested invocations, the return value must be the same type as the asyncLocalStorage inner value.

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

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

interface XhrBreadcrumbData

interface XhrBreadcrumbData {}

property method

method?: string;

property request_body_size

request_body_size?: number;

property response_body_size

response_body_size?: number;

property status_code

status_code?: number;

property url

url?: string;

interface XhrBreadcrumbHint

interface XhrBreadcrumbHint {}

property endTimestamp

endTimestamp: number;

property input

input: unknown;

property startTimestamp

startTimestamp: number;

property xhr

xhr: unknown;

Type Aliases

type AnthropicAiInstrumentedMethod

type AnthropicAiInstrumentedMethod = keyof typeof ANTHROPIC_METHOD_REGISTRY;

Deprecated
This type is no longer used and will be removed in the next major version.

type AnthropicAiResponse

type AnthropicAiResponse = SuccessfulResponse | MessageError;

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 BrowserClientProfilingOptions

type BrowserClientProfilingOptions = {
    /**
     * The sample rate for profiling
     * 1.0 will profile all transactions and 0 will profile none.
     *
     * @deprecated Use `profileSessionSampleRate` and `profileLifecycle` instead.
     */
    profilesSampleRate?: number;
    /**
     * Sets profiling session sample rate for the entire profiling session.
     *
     * A profiling session corresponds to a user session, meaning it is set once at integration initialization and
     * persisted until the next page reload. This rate determines what percentage of user sessions will have profiling enabled.
     * @default 0
     */
    profileSessionSampleRate?: number;
    /**
     * Set the lifecycle mode of the profiler.
     * - **manual**: The profiler will be manually started and stopped via `startProfiler`/`stopProfiler`.
     *    If a session is sampled, is dependent on the `profileSessionSampleRate`.
     * - **trace**: The profiler will be automatically started when a root span exists and stopped when there are no
     *    more sampled root spans. Whether a session is sampled, is dependent on the `profileSessionSampleRate` and the
     *    existing sampling configuration for tracing (`tracesSampleRate`/`tracesSampler`).
     *
     * @default 'manual'
     */
    profileLifecycle?: 'manual' | 'trace';
};

type BrowserClientReplayOptions

type BrowserClientReplayOptions = {
    /**
     * The sample rate for session-long replays.
     * 1.0 will record all sessions and 0 will record none.
     */
    replaysSessionSampleRate?: number;
    /**
     * The sample rate for sessions that has had an error occur.
     * This is independent of `sessionSampleRate`.
     * 1.0 will record all sessions and 0 will record none.
     */
    replaysOnErrorSampleRate?: number;
};

Options added to the Browser SDK's init options that are specific for Replay. Note: This type was moved to @sentry/core to avoid a circular dependency between Browser and Replay.

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
    | SpanEnvelope
    | 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'
    | '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 ExpressErrorMiddleware

type ExpressErrorMiddleware = (
    error: MiddlewareError,
    req: ExpressRequest,
    res: ExpressResponse,
    next: (error: MiddlewareError) => void
) => void;

type ExpressIntegrationOptions

type ExpressIntegrationOptions = {
    /**
     * @deprecated Pass the express module as the first argument, and an
     * options getter as the second argument to patchExpressModule.
     */
    express?: ExpressModuleExport;
    /** Ignore specific based on their name */
    ignoreLayers?: IgnoreMatcher[];
    /** Ignore specific layers based on their type */
    ignoreLayersType?: ExpressLayerType[];
    /**
     * Optional callback invoked each time a layer resolves the matched HTTP route.
     * Platform-specific integrations (e.g. Node.js) use this to propagate the
     * resolved route to the underlying transport layer (e.g. OTel RPCMetadata).
     */
    onRouteResolved?: (route: string | undefined) => void;
};

type ExpressMiddleware

type ExpressMiddleware = (
    req: ExpressRequest,
    res: ExpressResponse,
    next: () => void
) => void;

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 GoogleGenAIInstrumentedMethod

type GoogleGenAIInstrumentedMethod = keyof typeof GOOGLE_GENAI_METHOD_REGISTRY;

type GoogleGenAIIstrumentedMethod

type GoogleGenAIIstrumentedMethod = GoogleGenAIInstrumentedMethod;

Deprecated
Use GoogleGenAIInstrumentedMethod instead. This alias preserves backwards compatibility with the misspelled name and will be removed in the next major version.

type GoogleGenAIResponse

type GoogleGenAIResponse = GenerateContentResponse;

type HandlerDataUnhandledRejection

type HandlerDataUnhandledRejection = unknown;

type HttpBodyCollectionTarget

type HttpBodyCollectionTarget =
    | 'incomingRequest'
    | 'outgoingRequest'
    | 'incomingResponse'
    | 'outgoingResponse';

type HttpHeaderValue

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

type HttpModuleExport

type HttpModuleExport =
    | HttpExport
    | (HttpExport & {
          default: HttpExport;
      });

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 InstrumentedMethod

type InstrumentedMethod = keyof typeof OPENAI_METHOD_REGISTRY;

Deprecated
This type is no longer used and will be removed in the next major version.

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>;
    _sentryEsmLoaderHookRegistered?: boolean;
    _sentryWrappedDepth?: number;
} & 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 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 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<DataCollection> & {
    httpHeaders: Required<NonNullable<DataCollection['httpHeaders']>>;
    genAI: Required<NonNullable<DataCollection['genAI']>>;
};

Fully resolved DataCollection with all defaults applied.

type SanitizedRequestData

type SanitizedRequestData = {
    url: string;
    'http.method': string;
    'http.fragment'?: string;
    'http.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'> & {
    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 difference: Attributes are converted to Attributes, thus including the type annotation.

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

type SeverityLevel

type SeverityLevel = 'fatal' | 'error' | 'warning' | 'log' | 'info' | 'debug';

type SpanAttributes

type SpanAttributes = Partial<{
    'sentry.origin': string;
    'sentry.op': string;
    'sentry.source': TransactionSource;
    'sentry.sample_rate': number;
}> &
    Record<string, SpanAttributeValue | undefined>;

type SpanAttributeValue

type SpanAttributeValue =
    | string
    | number
    | boolean
    | Array<null | undefined | string>
    | Array<null | undefined | number>
    | Array<null | undefined | boolean>;

type SpanEnvelope

type SpanEnvelope = BaseEnvelope<SpanEnvelopeHeaders, SpanItem>;

type SpanItem

type SpanItem = BaseEnvelopeItem<SpanItemHeaders, Partial<SpanJSON>>;

type SpanKindValue

type SpanKindValue = (typeof SPAN_KIND)[keyof typeof SPAN_KIND];

type SpanOrigin

type SpanOrigin =
    | SpanOriginType
    | `${SpanOriginType}.${SpanOriginCategory}`
    | `${SpanOriginType}.${SpanOriginCategory}.${SpanOriginIntegrationName}`
    | `${SpanOriginType}.${SpanOriginCategory}.${SpanOriginIntegrationName}.${SpanOriginIntegrationPart}`;

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. Requires the enableLogs option to be enabled.
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. Requires the enableLogs option to be enabled.
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. Requires the enableLogs option to be enabled.

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. Requires the enableLogs option to be enabled.
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. Requires the enableLogs option to be enabled.
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. Requires the enableLogs option to be enabled.
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?: string;

The unit of the metric value.

Package Files (214)

Dependencies (0)

No dependencies.

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 13489 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 ANTHROPIC_AI_INTEGRATION_NAME

variable CONSOLE_LEVELS

variable debug

variable DEFAULT_ENVIRONMENT

variable DEFAULT_RETRY_AFTER

variable DEV_ENVIRONMENT

variable featureFlagsIntegration

Example 1

variable fmt

Parameter strings

Parameter values

Returns

variable GEN_AI_CONVERSATION_ID_ATTRIBUTE

variable getRootSpan

variable GLOBAL_OBJ

variable GOOGLE_GENAI_INTEGRATION_NAME

variable growthbookIntegration

Example 1

variable HTTP_ON_CLIENT_REQUEST

variable HTTP_ON_SERVER_REQUEST

variable installedIntegrations

variable LANGCHAIN_INTEGRATION_NAME

variable LANGGRAPH_INTEGRATION_NAME

variable MAX_BAGGAGE_STRING_LENGTH

variable MAX_BODY_BYTE_LENGTH

variable MULTIPLEXED_TRANSPORT_EXTRA_KEY

variable OPENAI_INTEGRATION_NAME

variable originalConsoleMethods

variable profiler

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

variable SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE

variable SEMANTIC_ATTRIBUTE_SENTRY_SDK_INTEGRATIONS

variable SEMANTIC_ATTRIBUTE_SENTRY_SDK_NAME

variable SEMANTIC_ATTRIBUTE_SENTRY_SDK_VERSION

variable SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_ID

variable SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_NAME

variable SEMANTIC_ATTRIBUTE_SENTRY_SOURCE

variable SEMANTIC_ATTRIBUTE_URL_FULL

variable SEMANTIC_ATTRIBUTE_USER_EMAIL

variable SEMANTIC_ATTRIBUTE_USER_ID

variable SEMANTIC_ATTRIBUTE_USER_IP_ADDRESS

variable SEMANTIC_ATTRIBUTE_USER_USERNAME

variable SEMANTIC_LINK_ATTRIBUTE_LINK_TYPE

See Also

variable SENTRY_API_VERSION

variable SENTRY_BAGGAGE_KEY_PREFIX

variable SENTRY_BAGGAGE_KEY_PREFIX_REGEX

variable SENTRY_BUFFER_FULL_ERROR

variable SPAN_KIND

variable SPAN_STATUS_ERROR

variable SPAN_STATUS_OK

variable SPAN_STATUS_UNSET

variable supportsFetch

Returns

Deprecated