@sentry/core

@sentry/core

Version 8.47.0
Published 6 days ago
3.57 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 BAGGAGE_HEADER_NAME

const BAGGAGE_HEADER_NAME: string;

Deprecated
Use a "baggage" string directly

variable browserPerformanceTimeOrigin

const browserPerformanceTimeOrigin: number;

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

variable CONSOLE_LEVELS

const CONSOLE_LEVELS: readonly ConsoleLevel[];

variable DEFAULT_ENVIRONMENT

const DEFAULT_ENVIRONMENT: string;

variable DEFAULT_RETRY_AFTER

const DEFAULT_RETRY_AFTER: number;

variable DEFAULT_USER_INCLUDES

const DEFAULT_USER_INCLUDES: string[];

variable getCurrentHub

const getCurrentHub: () => Hub;

Returns the default hub instance.
If a hub is already registered in the global carrier but this module contains a more recent version, it replaces the registered version. Otherwise, the currently registered hub will be returned.
Deprecated
Use the respective replacement method directly instead.

variable GLOBAL_OBJ

const GLOBAL_OBJ: InternalGlobal;

Get's the global object for the current JavaScript runtime

variable logger

const logger: Logger;

This is a logger singleton which either logs things or no-ops if logging is not enabled. The logger is a singleton on the carrier, to ensure that a consistent logger is used throughout the SDK.

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 metrics

const metrics: {
    increment: typeof increment;
    distribution: typeof distribution;
    set: typeof set;
    gauge: typeof gauge;
    timing: typeof timing;
    getMetricsAggregatorForClient: typeof getMetricsAggregatorForClient;
};

The metrics API is used to capture custom metrics in Sentry.
Deprecated
The Sentry metrics beta has ended. This export will be removed in a future release.

variable metricsDefault

const metricsDefault: Metrics & {
    getMetricsAggregatorForClient: typeof getMetricsAggregatorForClient;
};

The metrics API is used to capture custom metrics in Sentry.
Deprecated
The Sentry metrics beta has ended. This export will be removed in a future release.

variable originalConsoleMethods

const originalConsoleMethods: {
    error?: (...args: unknown[]) => void;
    log?: (...args: unknown[]) => void;
    info?: (...args: unknown[]) => void;
    debug?: (...args: unknown[]) => void;
    warn?: (...args: unknown[]) => void;
    assert?: (...args: unknown[]) => void;
    trace?: (...args: unknown[]) => void;
};

This may be mutated by the console instrumentation.

variable profiler

const profiler: Profiler;

variable Scope

const Scope: typeof ScopeClass;

Holds additional event information.

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_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_SAMPLE_RATE

const SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE: string;

Use this attribute to represent the sample rate used for a span.

variable SEMANTIC_ATTRIBUTE_SENTRY_SOURCE

const SEMANTIC_ATTRIBUTE_SENTRY_SOURCE: string;

Use this attribute to represent the source of a span. Should be one of: custom, url, route, view, component, task, unknown

variable SEMANTIC_ATTRIBUTE_URL_FULL

const SEMANTIC_ATTRIBUTE_URL_FULL: 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 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 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;

variable validSeverityLevels

const validSeverityLevels: string[];

Deprecated
This variable has been deprecated and will be removed in the next major version.

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 addConsoleInstrumentationHandler

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

Add an instrumentation handler for when a console.xxx method is called.
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.
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.
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.

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, 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 addNormalizedRequestDataToEvent

addNormalizedRequestDataToEvent: (
    event: Event,
    req: RequestEventData,
    additionalData: { ipAddress?: string; user?: Record<string, unknown> },
    options: AddRequestDataToEventOptions
) => void;

Add already normalized request data to an event. This mutates the passed in event.

function addRequestDataToEvent

addRequestDataToEvent: (
    event: Event,
    req: PolymorphicRequest,
    options?: AddRequestDataToEventOptions
) => Event;

Add data from the given request to the given event
Parameter event
The event to which the request data will be added
Parameter req
Request object
Parameter
options.include Flags to control what data is included
Parameter
options.deps Injected platform-specific dependencies
Returns
The mutated Event object
Deprecated
Use addNormalizedRequestDataToEvent instead.

function addTracingExtensions

addTracingExtensions: () => void;

Deprecated
Use registerSpanErrorInstrumentation() instead. In v9, this function will be removed. Note that you don't need to call this in Node-based SDKs or when using browserTracingIntegration.

function addTracingHeadersToFetchRequest

addTracingHeadersToFetchRequest: (
    request: string | unknown,
    _client: Client | undefined,
    _scope: Scope | undefined,
    fetchOptionsObj: {
        headers?: PolymorphicRequestHeaders | { [key: string]: string | string[] };
    },
    span?: Span
) => PolymorphicRequestHeaders | undefined;

Adds sentry-trace and baggage headers to the various forms of fetch headers.
Deprecated
This function will not be exported anymore in v9.

function applyAggregateErrorsToEvent

applyAggregateErrorsToEvent: (
    exceptionFromErrorImplementation: (
        stackParser: StackParser,
        ex: Error
    ) => Exception,
    parser: StackParser,
    maxValueLimit: number | undefined,
    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: Options,
    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 arrayify

arrayify: <T = unknown>(maybeArray: T | T[]) => T[];

Checks whether the given input is already an array, and if it isn't, wraps it in one.
Parameter maybeArray
Input to turn into an array, if necessary
Returns
The input, if already an array, or an array with the input as the only element, if not
Deprecated
This function has been deprecated and will not be replaced.

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 callFrameToStackFrame

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

Converts Debugger.CallFrame to Sentry StackFrame

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('../types-hoist').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('./types-hoist').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 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 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>(
    {
        sentryTrace,
        baggage,
    }: {
        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 convertToPlainObject

convertToPlainObject: <V>(
    value: V
) =>
    | V
    | {
          [ownProps: string]: unknown;
          type: string;
          target: string;
          currentTarget: string;
          detail?: unknown;
      }
    | { [ownProps: string]: unknown; message: string; name: string; stack?: string };

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 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 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.
TODO(v8): Return type should be rounded.

function debugIntegration

debugIntegration: (
    options?: DebugOptions | undefined
) => import('../types-hoist').Integration;

Integration to debug sent Sentry events. This integration should not be used in production.
Deprecated
This integration is deprecated and will be removed in the next major version of the SDK. To log outgoing events, use [Hook Options](https://docs.sentry.io/platforms/javascript/configuration/options/#hooks) (beforeSend, beforeSendTransaction, ...).

function dedupeIntegration

dedupeIntegration: () => import('../types-hoist').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 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.

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 dynamicRequire

dynamicRequire: (mod: any, request: string) => any;

Requires a module which is protected against bundler minification.
Parameter request
The module path to resolve
Deprecated
This function will be removed in the next major version.

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

extractExceptionKeysForMessage: (
    exception: Record<string, unknown>,
    maxLength?: number
) => 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 extractPathForTransaction

extractPathForTransaction: (
    req: PolymorphicRequest,
    options?: { path?: boolean; method?: boolean; customRoute?: string }
) => [string, TransactionSource];

Extracts a complete and parameterized path from the request object and uses it to construct transaction name. If the parameterized transaction name cannot be extracted, we fall back to the raw URL.
Additionally, this function determines and returns the transaction name source
eg. GET /mountpoint/user/:id
Parameter req
A request object
Parameter options
What to include in the transaction name (method, path, or a custom route name to be used instead of the request's route)
Returns
A tuple of the fully constructed transaction name [0] and its source [1] (can be either 'route' or 'url')
Deprecated
This method will be removed in v9. It is not in use anymore.

function extractQueryParamsFromUrl

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

Extract the query params from an URL.

function extractRequestData

extractRequestData: (
    req: PolymorphicRequest,
    options?: { include?: string[] }
) => ExtractedNodeRequestData;

Normalize data from the request object, accounting for framework differences.
Parameter req
The request object from which to extract data
Parameter
options.include An optional array of keys to include in the normalized data. Defaults to DEFAULT_REQUEST_INCLUDES if not provided.
Parameter
options.deps Injected, platform-specific dependencies
Returns
An object containing normalized request data
Deprecated
Instead manually normalize the request data into a format that fits addNormalizedRequestDataToEvent.

function extractTraceparentData

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

Extract transaction context data from a sentry-trace header.
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('../types-hoist').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.
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 flatten

flatten: <T>(input: NestedArray<T>) => T[];

Flattens a multi-dimensional array
Deprecated
This function is deprecated and will be removed in the next major version.

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('../types-hoist').Integration;

Patch toString calls to return proper name for wrapped functions.

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

function generatePropagationContext

generatePropagationContext: () => PropagationContext;

Returns a new minimal propagation context.
Deprecated
Use generateTraceId and generateSpanId instead.

function generateSentryTraceHeader

generateSentryTraceHeader: (
    traceId?: string,
    spanId?: string,
    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 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.

function getClient

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

Get the currently active client.

function getComponentName

getComponentName: (elem: unknown) => 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 getCurrentHubShim

getCurrentHubShim: () => Hub;

This is for legacy reasons, and returns a proxy object instead of a hub to be used.
Deprecated
Use the methods directly from the top level Sentry API (e.g. Sentry.withScope) For more information see our migration guide for [replacing getCurrentHub and Hub](https://github.com/getsentry/sentry-javascript/blob/develop/MIGRATION.md#deprecate-hub) usage

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 getDomElement

getDomElement: <E = any>(selector: string) => E | null;

Gets a DOM element by using document.querySelector.
This wrapper will first check for the existence of the function before actually calling it so that we don't have to take care of this check, every time we want to access the DOM.
Reason: DOM/querySelector is not available in all environments.
We have to cast to any because utils can be consumed by a variety of environments, and we don't want to break TS users. If you know what element will be selected by document.querySelector, specify it as part of the generic call. For example, const element = getDomElement<Element>('selector');
Parameter selector
the selector string passed on to document.querySelector

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 getFilenameToDebugIdMap

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

Returns a map of filenames to debug identifiers.

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: <T>(
    name: keyof SentryCarrier,
    creator: () => T,
    obj?: unknown
) => T;

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 getIntegrationsToSetup

getIntegrationsToSetup: (
    options: Pick<Options, '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 getMetricSummaryJsonForSpan

getMetricSummaryJsonForSpan: (
    span: Span
) => Record<string, Array<MetricSummary>> | undefined;

Fetches the metric summary if it exists for the passed span

function getNumberOfUrlSegments

getNumberOfUrlSegments: (url: string) => number;

Returns number of URL segments of a passed string URL.
Deprecated
This function will be removed in the next major version.

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: { [key: string]: any; user?: { name?: string; email?: string } }
) => string;

Returns the url to the report dialog endpoint.

function getRootSpan

getRootSpan: (span: SpanWithPotentialChildren) => Span;

Returns the root span of a given span.

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 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 unknown_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 }) => 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 to strings. 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.
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: () => 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 () => any>(
    fn: Fn,
    onError: (error: unknown) => void,
    onFinally?: () => void
) => ReturnType<Fn>;

Wrap a callback function with error handling. If an error is thrown, it will be passed to the onError callback and re-thrown.
If the return value of the function is a promise, it will be handled with maybeHandlePromiseRejection.
If an onFinally callback is provided, this will be called when the callback has finished - so if it returns a promise, once the promise resolved/rejected, else once the callback has finished executing. The onFinally callback will _always_ be called, no matter if an error was thrown or not.

function hasTracingEnabled

hasTracingEnabled: (
    maybeOptions?:
        | Pick<Options, 'tracesSampleRate' | 'tracesSampler' | 'enableTracing'>
        | undefined
) => boolean;

Determines if tracing is currently enabled.
Tracing is enabled when at least one of tracesSampleRate and tracesSampler is defined in the SDK config.

function headersToDict

headersToDict: (
    reqHeaders: Record<string, string | string[] | undefined>
) => 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

function httpRequestToRequestData

httpRequestToRequestData: (request: {
    method?: string;
    url?: string;
    headers?: { [key: string]: string | string[] };
    protocol?: string;
    socket?: unknown;
}) => 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<InboundFiltersOptions> | undefined
) => import('../types-hoist').Integration;

function initAndBind

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

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

function instrumentFetchRequest

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

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

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.

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

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: RegExp | string,
    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 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 SyntheticEvent isSyntheticEvent.
Parameter wat
A value to be checked.
Returns
A boolean representing the result.

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 isVueViewModel

isVueViewModel: (wat: unknown) => boolean;

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

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('../types-hoist').Integration;

function loadModule

loadModule: <T>(moduleName: string) => 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
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 makeFifoCache

makeFifoCache: <Key extends string, Value>(
    size: number
) => {
    get: (key: Key) => Value | undefined;
    add: (key: Key, value: Value) => void;
    delete: (key: Key) => boolean;
    clear: () => void;
    size: () => number;
};

Creates a cache that evicts keys in fifo order
Parameter size
Deprecated
This function is deprecated and will be removed in the next major version.

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.

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

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

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

function memoBuilder

memoBuilder: () => MemoFunc;

Helper to decycle json objects
Deprecated
This function is deprecated and will be removed in the next major version.

function mergeScopeData

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

Merge data of two scopes together.

function moduleMetadataIntegration

moduleMetadataIntegration: () => import('../types-hoist').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 parameterize

parameterize: (
    strings: TemplateStringsArray,
    ...values: string[]
) => 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
String with template information in __sentry_template_string__ and __sentry_template_values__ properties

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 parseUrl

parseUrl: (url: string) => PartialURL;

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

function prepareEvent

prepareEvent: (
    options: ClientOptions,
    event: Event,
    hint: EventHint,
    scope?: ScopeInterface,
    client?: Client,
    isolationScope?: ScopeInterface
) => 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 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 requestDataIntegration

requestDataIntegration: (
    options?: RequestDataIntegrationOptions | undefined
) => import('../types-hoist').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('../types-hoist').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 sampleSpan

sampleSpan: (
    options: Pick<Options, 'tracesSampleRate' | 'tracesSampler' | 'enableTracing'>,
    samplingContext: SamplingContext
) => [sampled: boolean, sampleRate?: number];

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 sessionTimingIntegration

sessionTimingIntegration: () => import('../types-hoist').Integration;

This function adds duration since the sessionTimingIntegration was initialized till the time event was sent.
Deprecated
This integration is deprecated and will be removed in the next major version of the SDK. To capture session durations alongside events, use [Context](https://docs.sentry.io/platforms/javascript/enriching-events/context/) (Sentry.setContext()).

function setAsyncContextStrategy

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

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

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 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('../types-hoist').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 setTag

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

Set key:value that will be sent as tags data with the event.
Can also be used to unset a tag, by passing undefined.
Parameter key
String key of tag
Parameter value
Value of tag

function setTags

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

Set an object that will be merged sent as tags data with the event.
Parameter tags
Tags context object to merge into current context.

function setUser

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

Updates user context information for future events.
Parameter user
User context object to be set in the current context. Pass null to unset the user.

function severityLevelFromString

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

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

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

Convert a span to a JSON representation.

function spanToTraceContext

spanToTraceContext: (span: Span) => TraceContext;

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

function spanToTraceHeader

spanToTraceHeader: (span: Span) => string;

Convert a Span to a Sentry trace header.

function stackParserFromStackParserOptions

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

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

function 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. You'll have to call span.end() manually.
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?: Array<string | RegExp>,
    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 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 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 supportsFetch

supportsFetch: () => boolean;

Tells whether current environment supports Fetch API supportsFetch.
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.

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('../types-hoist').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
- BaseClient.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 urlEncode

urlEncode: (object: { [key: string]: any }) => string;

Encodes given object into url-friendly format
Parameter object
An object that contains serializable values
Returns
string Encoded
Deprecated
This function is deprecated and will be removed in the next major version of the SDK.

function uuid4

uuid4: () => string;

UUID4 generator
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 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 zodErrorsIntegration

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

Classes

class BaseClient

abstract class BaseClient<O extends ClientOptions> implements Client<O> {}

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 BaseClient._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 BaseClient { 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;

method addIntegration

addIntegration: (integration: Integration) => void;

method captureEvent

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

method captureException

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

method captureMessage

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

method captureSession

captureSession: (session: Session) => void;

method close

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

method emit

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

method eventFromException

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

method eventFromMessage

abstract eventFromMessage: (
    _message: ParameterizedString,
    _level?: SeverityLevel,
    _hint?: EventHint
) => PromiseLike<Event>;

method flush

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

method getDsn

getDsn: () => DsnComponents | undefined;

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
The installed integration or undefined if no integration with that name was installed.

method getOptions

getOptions: () => O;

method getSdkMetadata

getSdkMetadata: () => SdkMetadata | undefined;

See Also
- SdkMetadata
  The metadata of the SDK

method getTransport

getTransport: () => Transport | undefined;

method init

init: () => void;

method on

on: {
    (hook: 'spanStart', callback: (span: Span) => void): () => void;
    (hook: 'spanEnd', callback: (span: Span) => void): () => void;
    (
        hook: 'idleSpanEnableAutoFinish',
        callback: (span: Span) => void
    ): () => void;
    (hook: 'beforeEnvelope', callback: (envelope: Envelope) => void): () => void;
    (
        hook: 'beforeSendEvent',
        callback: (event: Event, hint?: EventHint) => void
    ): () => void;
    (
        hook: 'preprocessEvent',
        callback: (event: Event, hint?: EventHint) => void
    ): () => void;
    (
        hook: 'afterSendEvent',
        callback: (
            event: Event,
            sendResponse: 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: 'beforeSampling',
        callback: (
            samplingData: {
                spanAttributes: SpanAttributes;
                spanName: string;
                parentSampled?: boolean;
                parentContext?: SpanContextData;
            },
            samplingDecision: { decision: boolean }
        ) => void
    ): void;
    (
        hook: 'startPageLoadSpan',
        callback: (
            options: StartSpanOptions,
            traceOptions?: { sentryTrace?: string; baggage?: string }
        ) => void
    ): () => void;
    (
        hook: 'startNavigationSpan',
        callback: (options: StartSpanOptions) => void
    ): () => void;
    (hook: 'flush', callback: () => void): () => void;
    (hook: 'close', callback: () => void): () => void;
    (hook: 'applyFrameMetadata', callback: (event: Event) => void): () => void;
};

method recordDroppedEvent

recordDroppedEvent: (
    reason: EventDropReason,
    category: DataCategory,
    eventOrCount?: Event | number
) => void;

method sendEnvelope

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

method sendEvent

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

method sendSession

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

class BrowserMetricsAggregator

class BrowserMetricsAggregator implements MetricsAggregator {}

A simple metrics aggregator that aggregates metrics in memory and flushes them periodically. Default flush interval is 5 seconds.
This API is experimental and might change in the future.
Modifiers
- @experimental

constructor

constructor(_client: Client<ClientOptions<BaseTransportOptions>>);

method add

add: (
    metricType: MetricType,
    unsanitizedName: string,
    value: number | string,
    unsanitizedUnit?: MeasurementUnit | undefined,
    unsanitizedTags?: Record<string, Primitive> | undefined,
    maybeFloatTimestamp?: number | undefined
) => void;

method close

close: () => void;

method flush

flush: () => void;

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 SentryError

class SentryError extends Error {}

An error emitted by Sentry SDKs and related utilities.

constructor

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

property logLevel

logLevel: ConsoleLevel;

property message

message: string;

property name

name: string;

Display name of this error instance.

class SentryNonRecordingSpan

class SentryNonRecordingSpan implements Span {}

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

constructor

constructor(spanContext?: SentrySpanArguments);

method addEvent

addEvent: (
    _name: string,
    _attributesOrStartTime?: SpanAttributes | SpanTimeInput,
    _startTime?: SpanTimeInput
) => 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 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 BaseClient<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 close

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

method eventFromException

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

method eventFromMessage

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

method initSessionFlusher

initSessionFlusher: () => void;

Initializes an instance of SessionFlusher on the client which will aggregate and periodically flush session data.
NOTICE: This method will implicitly create an interval that is periodically called. To clean up this resources, call .close() when you no longer intend to use the client. Not doing so will result in a memory leak.

class SessionFlusher

class SessionFlusher implements SessionFlusherLike {}

Deprecated
SessionFlusher is deprecated and will be removed in the next major version of the SDK.

constructor

constructor(
    client: Client<ClientOptions<BaseTransportOptions>>,
    attrs: ReleaseHealthAttributes
);

property flushTimeout

readonly flushTimeout: number;

method close

close: () => void;

JSDoc

method flush

flush: () => void;

Checks if pendingAggregates has entries, and if it does flushes them by calling sendSession

method getSessionAggregates

getSessionAggregates: () => SessionAggregates;

Massages the entries in pendingAggregates and returns aggregated sessions

method incrementSessionStatusCount

incrementSessionStatusCount: () => void;

Wrapper function for _incrementSessionStatusCount that checks if the instance of SessionFlusher is enabled then fetches the session status of the request from Scope.getRequestSession().status on the scope and passes them to _incrementSessionStatusCount along with the start date

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: (
        resolve: (value?: T | PromiseLike<T> | null) => void,
        reject: (reason?: any) => void
    ) => void
);

method catch

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

JSDoc

method finally

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

JSDoc

method then

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

JSDoc

Interfaces

interface AggregationCounts

interface AggregationCounts {}

property crashed

crashed?: number;

property errored

errored?: number;

property exited

exited?: number;

property started

started: string;

interface AppContext

interface AppContext extends Record<string, unknown> {}

property app_identifier

app_identifier?: string;

property app_memory

app_memory?: number;

property app_name

app_name?: string;

property app_start_time

app_start_time?: string;

property app_version

app_version?: string;

property build_type

build_type?: string;

property free_memory

free_memory?: number;

interface AsyncContextStrategy

interface AsyncContextStrategy {}

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

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 startInactiveSpan

startInactiveSpan?: typeof startInactiveSpan;

Start an inactive span.

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

interface Client<O extends ClientOptions = ClientOptions> {}

User-Facing Sentry SDK Client.
This interface contains all methods to interface with the SDK once it has been installed. It allows to send events to Sentry, record breadcrumbs and set a context included in every event. Since the SDK mutates its environment, there will only be one instance during runtime.

method addEventProcessor

addEventProcessor: (eventProcessor: EventProcessor) => void;

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

method addIntegration

addIntegration: (integration: Integration) => void;

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

method captureCheckIn

captureCheckIn: (
    checkIn: CheckIn,
    monitorConfig?: MonitorConfig,
    scope?: Scope
) => string;

Create a cron monitor check in and send it to Sentry. This method is not available on all clients.
Parameter checkIn
An object that describes a check in.
Parameter upsertMonitorConfig
An optional object that describes a monitor config. Use this if you want to create a monitor automatically when sending a check in.
Parameter scope
An optional scope containing event metadata.
Returns
A string representing the id of the check in.

method captureEvent

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

Captures a manually created event and sends it to Sentry.
Unlike captureEvent exported from every SDK, this method requires that you pass it the current scope.
Parameter event
The event to send to Sentry.
Parameter hint
May contain additional information about the original exception.
Parameter currentScope
An optional scope containing event metadata.
Returns
The event id

method captureException

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

Captures an exception event and sends it to Sentry.
Unlike captureException exported from every SDK, this method requires that you pass it the current scope.
Parameter exception
An exception-like object.
Parameter hint
May contain additional information about the original exception.
Parameter currentScope
An optional scope containing event metadata.
Returns
The event id

method captureMessage

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

Captures a message event and sends it to Sentry.
Unlike captureMessage exported from every SDK, this method requires that you pass it the current scope.
Parameter message
The message to send to Sentry.
Parameter level
Define the level of the message.
Parameter hint
May contain additional information about the original exception.
Parameter currentScope
An optional scope containing event metadata.
Returns
The event id

method captureSession

captureSession: (session: Session) => void;

Captures a session
Parameter session
Session to be delivered

method close

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

Flush the event queue and set the client to enabled = false. See Client.flush.
Parameter timeout
Maximum time in ms the client should wait before shutting down. Omitting this parameter will cause the client to wait until all events are sent before disabling itself.
Returns
A promise which resolves to true if the flush completes successfully before the timeout, or false if it doesn't.

method emit

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

Fire a hook whenever a span starts.
A hook that is called every time before a span is sampled.
Fire a hook whenever a span ends.
Fire a hook indicating that an idle span is allowed to auto finish.
Fire a hook event before sending an event. This is called right before an event is sent and should not be used to mutate the event. Expects to be given an Event & EventHint as the second/third argument.
Fire a hook event to process events before they are passed to (global) event processors. Expects to be given an Event & EventHint as the second/third argument.
Fire a hook for when a breadcrumb is added. Expects the breadcrumb as second argument.
Fire a hook for when a DSC (Dynamic Sampling Context) is created. Expects the DSC as second argument.
Fire a hook event for after preparing a feedback event. Events to be given a feedback event as the second argument, and an optional options object as third argument.
Emit a hook event for browser tracing integrations to trigger a span start for a page load.
Emit a hook event for browser tracing integrations to trigger a span for a navigation.
Emit a hook event for client flush
Emit a hook event for client close

method eventFromException

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

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

method eventFromMessage

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

Creates an Event from primitive inputs to captureMessage.

method flush

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

Wait for all events to be sent or the timeout to expire, whichever comes first.
Parameter timeout
Maximum time in ms the client should wait for events to be flushed. Omitting this parameter will cause the client to wait until all events are sent before resolving the promise.
Returns
A promise that will resolve with true if all events are sent before the timeout, or false if there are still events in the queue when the timeout is reached.

method getDsn

getDsn: () => DsnComponents | undefined;

Returns the current Dsn.

method getEventProcessors

getEventProcessors: () => EventProcessor[];

Get all added event processors for this client.

method getIntegrationByName

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

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

method getOptions

getOptions: () => O;

Returns the current options.

method getSdkMetadata

getSdkMetadata: () => SdkMetadata | undefined;

method getTransport

getTransport: () => Transport | undefined;

Returns the transport that is used by the client. Please note that the transport gets lazy initialized so it will only be there once the first event has been sent.
Returns
The transport.

method init

init: () => void;

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

method on

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

Register a callback for whenever a span is started. Receives the span as argument.
Returns
A function that, when executed, removes the registered callback.
Register a callback before span sampling runs. Receives a samplingDecision object argument with a decision property that can be used to make a sampling decision that will be enforced, before any span sampling runs.
Returns
A function that, when executed, removes the registered callback.
Register a callback for whenever a span is ended. Receives the span as argument.
Returns
A function that, when executed, removes the registered callback.
Register a callback for when an idle span is allowed to auto-finish.
Returns
A function that, when executed, removes the registered callback.
Register a callback for transaction start and finish.
Returns
A function that, when executed, removes the registered callback.
Register a callback that runs when stack frame metadata should be applied to an event.
Returns
A function that, when executed, removes the registered callback.
Register a callback for before sending an event. This is called right before an event is sent and should not be used to mutate the event. Receives an Event & EventHint as arguments.
Returns
A function that, when executed, removes the registered callback.
Register a callback for preprocessing an event, before it is passed to (global) event processors. Receives an Event & EventHint as arguments.
Returns
A function that, when executed, removes the registered callback.
Register a callback for when an event has been sent.
Returns
A function that, when executed, removes the registered callback.
Register a callback before a breadcrumb is added.
Returns
A function that, when executed, removes the registered callback.
Register a callback when a DSC (Dynamic Sampling Context) is created.
Returns
A function that, when executed, removes the registered callback.
Register a callback when a Feedback event has been prepared. This should be used to mutate the event. The options argument can hint about what kind of mutation it expects.
Returns
A function that, when executed, removes the registered callback.
A hook for the browser tracing integrations to trigger a span start for a page load.
Returns
A function that, when executed, removes the registered callback.
A hook for browser tracing integrations to trigger a span for a navigation.
Returns
A function that, when executed, removes the registered callback.
A hook that is called when the client is flushing
Returns
A function that, when executed, removes the registered callback.
A hook that is called when the client is closing
Returns
A function that, when executed, removes the registered callback.

method recordDroppedEvent

recordDroppedEvent: (
    reason: EventDropReason,
    dataCategory: DataCategory,
    event?: Event
) => void;

Record on the client that an event got dropped (ie, an event that will not be sent to sentry).
Parameter reason
The reason why the event got dropped.
Parameter category
The data category of the dropped event.
Parameter event
The dropped event.

method sendEnvelope

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

Sends an envelope to Sentry

method sendEvent

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

Submits the event to Sentry

method sendSession

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

Submits the session to Sentry

interface ClientOptions

interface ClientOptions<TO extends BaseTransportOptions = BaseTransportOptions> {}

property allowUrls

allowUrls?: Array<string | RegExp>;

A pattern for error URLs which should exclusively be sent to Sentry. This is the opposite of Options.denyUrls. By default, all errors will be sent.
Requires the use of the InboundFilters integration.

property attachStacktrace

attachStacktrace?: boolean;

Attaches stacktraces to pure capture message / log integrations

property autoSessionTracking

autoSessionTracking?: boolean;

A flag enabling Sessions Tracking feature. By default, Session Tracking is enabled.
Deprecated
Setting the autoSessionTracking option is deprecated. To enable session tracking, it is recommended to unset autoSessionTracking and ensure that either, in browser environments the browserSessionIntegration is added, or in server environments the httpIntegration is added. To disable session tracking, it is recommended unset autoSessionTracking and to remove the browserSessionIntegration in browser environments, or in server environments configure the httpIntegration with the trackIncomingRequestsAsSessions option set to 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 beforeSendSpan

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

This function can be defined to modify or entirely drop a child span before it's sent. Returning null will cause this span to be dropped.
Note that this function is only called for child spans and not for the root span (formerly known as transaction). If you want to modify or drop the root span, use Options.beforeSendTransaction instead.
Parameter span
The span generated by the SDK.
Returns
A new span that will be sent or null if the span should not be sent.

property beforeSendTransaction

beforeSendTransaction?: (
    event: TransactionEvent,
    hint: EventHint
) => PromiseLike<TransactionEvent | null> | TransactionEvent | null;

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

property debug

debug?: boolean;

Enable debug functionality in the SDK itself

property denyUrls

denyUrls?: Array<string | RegExp>;

A pattern for error URLs which should not be sent to Sentry. To allow certain errors instead, use Options.allowUrls. By default, all errors will be sent.
Requires the use of the InboundFilters integration.

property dist

dist?: string;

Sets the distribution for all events

property dsn

dsn?: string;

The Dsn used to connect to Sentry and identify the project. If omitted, the SDK will not send any data to Sentry.

property enabled

enabled?: boolean;

Specifies whether this SDK should send events to Sentry. Defaults to true.

property enableTracing

enableTracing?: boolean;

If this is enabled, spans and trace data will be generated and captured. This will set the tracesSampleRate to the recommended default of 1.0 if tracesSampleRate is undefined. Note that tracesSampleRate and tracesSampler take precedence over this option.
Deprecated
This option is deprecated and will be removed in the next major version. If you want to enable performance monitoring, please use the tracesSampleRate or tracesSampler options instead. If you wan't to disable performance monitoring, remove the tracesSampler and tracesSampleRate options.

property environment

environment?: string;

The current environment of your application (e.g. "production").

property ignoreErrors

ignoreErrors?: Array<string | RegExp>;

A pattern for error messages which should not be sent to Sentry. By default, all errors will be sent.

property ignoreTransactions

ignoreTransactions?: Array<string | RegExp>;

A pattern for transaction names which should not be sent to Sentry. By default, all transactions will be sent.

property initialScope

initialScope?: CaptureContext;

Initial data to populate scope.

property integrations

integrations: Integration[];

List of integrations that should be installed after SDK was initialized.

property maxBreadcrumbs

maxBreadcrumbs?: number;

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

property maxValueLength

maxValueLength?: number;

Maximum number of chars a single value can have before it will be truncated.

property normalizeDepth

normalizeDepth?: number;

Maximum number of levels that normalization algorithm will traverse in objects and arrays. Used when normalizing an event before sending, on all of the listed attributes: - breadcrumbs.data - user - contexts - extra Defaults to 3. Set to 0 to disable.

property normalizeMaxBreadth

normalizeMaxBreadth?: number;

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

property parentSpanIsAlwaysRootSpan

parentSpanIsAlwaysRootSpan?: boolean;

If this is enabled, any spans started will always have their parent be the active root span, if there is any active span.
This is necessary because in some environments (e.g. browser), we cannot guarantee an accurate active span. Because we cannot properly isolate execution environments, you may get wrong results when using e.g. nested startSpan() calls.
To solve this, in these environments we'll by default enable this option.

property release

release?: string;

The release identifier used when uploading respective source maps. Specify this value to allow Sentry to resolve the correct source maps when processing events.

property sampleRate

sampleRate?: number;

A global sample rate to apply to all events.
0.0 = 0% chance of a given event being sent (send no events) 1.0 = 100% chance of a given event being sent (send all events)

property sendClientReports

sendClientReports?: boolean;

Send SDK Client Reports. When calling Sentry.init(), this option defaults to true.

property sendDefaultPii

sendDefaultPii?: boolean;

Controls if potentially sensitive data should be sent to Sentry by default. Note that this only applies to data that the SDK is sending by default but not data that was explicitly set (e.g. by calling Sentry.setUser()).
Defaults to false.
NOTE: This option currently controls only a few data points in a selected set of SDKs. The goal for this option is to eventually control all sensitive data the SDK sets by default. However, this would be a breaking change so until the next major update this option only controls data points which were added in versions above 7.9.0.

property shutdownTimeout

shutdownTimeout?: number;

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

property stackParser

stackParser: StackParser;

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

property tracePropagationTargets

tracePropagationTargets?: TracePropagationTargets;

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

property tracesSampler

tracesSampler?: (samplingContext: SamplingContext) => number | boolean;

Function to compute tracing sample rate dynamically and filter unwanted traces.
Tracing is enabled if either this or tracesSampleRate is defined. If both are defined, tracesSampleRate is ignored.
Will automatically be passed a context object of default and optional custom data. See Transaction.samplingContext and Hub.startTransaction.
Returns
A sample rate between 0 and 1 (0 drops the trace, 1 guarantees it will be sent). Returning true is equivalent to returning 1 and returning false is equivalent to returning 0.

property tracesSampleRate

tracesSampleRate?: number;

Sample rate to determine trace sampling.
0.0 = 0% chance of a given trace being sent (send no traces) 1.0 = 100% chance of a given trace being sent (send all traces)
Tracing is enabled if either this or tracesSampler is defined. If both are defined, tracesSampleRate is ignored.

property transport

transport: (transportOptions: TO) => Transport;

A function that takes transport options and returns the Transport object which is used to send events to Sentry. The function is invoked internally when the client is initialized.

property transportOptions

transportOptions?: Partial<TO>;

Options for the default transport that the SDK uses.

property tunnel

tunnel?: string;

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

interface CloudResourceContext

interface CloudResourceContext extends Record<string, unknown> {}

property ['cloud.account.id']

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

property ['cloud.availability_zone']

['cloud.availability_zone']?: string;

property ['cloud.platform']

['cloud.platform']?: string;

property ['cloud.provider']

['cloud.provider']?: string;

property ['cloud.region']

['cloud.region']?: string;

property ['host.id']

['host.id']?: string;

property ['host.type']

['host.type']?: string;

interface Contexts

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

property app

app?: AppContext;

property cloud_resource

cloud_resource?: CloudResourceContext;

property culture

culture?: CultureContext;

property device

device?: DeviceContext;

property flags

flags?: FeatureFlagContext;

property os

os?: OsContext;

property profile

profile?: ProfileContext;

property response

response?: ResponseContext;

property state

state?: StateContext;

property trace

trace?: TraceContext;

interface ContinuousProfiler

interface ContinuousProfiler<T extends Client> {}

method initialize

initialize: (client: T) => void;

method start

start: () => void;

method stop

stop: () => void;

interface ContinuousThreadCpuProfile

interface ContinuousThreadCpuProfile {}

property frames

frames: ThreadCpuFrame[];

property queue_metadata

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

property samples

samples: ContinuousThreadCpuSample[];

property stacks

stacks: ThreadCpuStack[];

property thread_metadata

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

interface CultureContext

interface CultureContext extends Record<string, unknown> {}

property calendar

calendar?: string;

property display_name

display_name?: string;

property is_24_hour_format

is_24_hour_format?: boolean;

property locale

locale?: string;

property timezone

timezone?: string;

interface CustomSamplingContext

interface CustomSamplingContext {}

Context data passed by the user when starting a transaction, to be used by the tracesSampler method.

index signature

[key: string]: any;

interface DebugMeta

interface DebugMeta {}

Holds meta information to customize the behavior of Sentry's server-side event processing.

property images

images?: Array<DebugImage>;

interface DeviceContext

interface DeviceContext extends Record<string, unknown> {}

property arch

arch?: string;

property battery_level

battery_level?: number;

property battery_status

battery_status?: string;

property boot_time

boot_time?: string;

property brand

brand?: string;

property charging

charging?: boolean;

property cpu_description

cpu_description?: string;

property device_type

device_type?: string;

property device_unique_identifier

device_unique_identifier?: string;

property external_free_storage

external_free_storage?: number;

property external_storage_size

external_storage_size?: number;

property family

family?: string;

property free_memory

free_memory?: number;

property free_storage

free_storage?: number;

property low_memory

low_memory?: boolean;

property manufacturer

manufacturer?: string;

property memory_size

memory_size?: number;

property model

model?: string;

property model_id

model_id?: string;

property name

name?: string;

property online

online?: boolean;

property orientation

orientation?: 'portrait' | 'landscape';

property processor_count

processor_count?: number;

property processor_frequency

processor_frequency?: number;

property screen_density

screen_density?: number;

property screen_dpi

screen_dpi?: number;

property screen_height_pixels

screen_height_pixels?: number;

property screen_resolution

screen_resolution?: string;

property screen_width_pixels

screen_width_pixels?: number;

property simulator

simulator?: boolean;

property storage_size

storage_size?: number;

property supports_accelerometer

supports_accelerometer?: boolean;

property supports_audio

supports_audio?: boolean;

property supports_gyroscope

supports_gyroscope?: boolean;

property supports_location_service

supports_location_service?: boolean;

property supports_vibration

supports_vibration?: boolean;

property usable_memory

usable_memory?: number;

interface DsnComponents

interface DsnComponents {}

Primitive components of a Dsn.

property host

host: string;

Hostname of the Sentry instance.

property pass

pass?: string;

Private authorization key (deprecated, optional).

property path

path?: string;

Sub path/

property port

port?: string;

Port of the Sentry instance.

property projectId

projectId: string;

Project ID

property protocol

protocol: DsnProtocol;

Protocol used to connect to Sentry.

property publicKey

publicKey?: string;

Public authorization key.

interface ErrorEvent

interface ErrorEvent extends Event {}

property type

type: undefined;

interface Event

interface Event {}

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

property logger

logger?: string;

property measurements

measurements?: Measurements;

property message

message?: string;

property modules

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

property platform

platform?: string;

property release

release?: string;

property request

request?: RequestEventData;

property sdk

sdk?: SdkInfo;

property sdkProcessingMetadata

sdkProcessingMetadata?: {
    [key: string]: unknown;
} & {
    request?: PolymorphicRequest;
    normalizedRequest?: RequestEventData;
    dynamicSamplingContext?: Partial<DynamicSamplingContext>;
    capturedSpanScope?: Scope;
    capturedSpanIsolationScope?: Scope;
    spanCountBeforeProcessing?: number;
};

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;

property type

type?: string;

property value

value?: string;

interface ExtendedError

interface ExtendedError extends Error {}

Just an Error object with arbitrary attributes attached to it.

index signature

[key: string]: any;

interface ExtractedNodeRequestData

interface ExtractedNodeRequestData {}

Data extracted from an incoming request to a node server

property cookies

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

String representing the cookies sent along with the request

property data

data?: string;

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

property headers

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

Specific headers from the request

property method

method?: string;

The request's method

property query_string

query_string?: QueryParams;

The request's query params

property url

url?: string;

The request's URL, including query string

index signature

[key: string]: any;

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

property to

to: string;

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 Hub

interface Hub {}

Internal class used to make sure we always have the latest internal functions working in case we have a version conflict.
Deprecated
This interface will be removed in a future major version of the SDK in favour of Scope and Client objects and APIs.
Most APIs referencing Hub are themselves and will be removed in version 8 of the SDK. More information: - [Migration Guide](https://github.com/getsentry/sentry-javascript/blob/develop/MIGRATION.md#deprecate-hub)

method addBreadcrumb

addBreadcrumb: (breadcrumb: Breadcrumb, hint?: BreadcrumbHint) => void;

Records a new breadcrumb which will be attached to future events.
Breadcrumbs will be added to subsequent events to provide more context on user's actions prior to an error or crash.
Parameter breadcrumb
The breadcrumb to record.
Parameter hint
May contain additional information about the original breadcrumb.
Deprecated
Use Sentry.addBreadcrumb() instead.

method bindClient

bindClient: (client?: Client) => void;

This binds the given client to the current scope.
Parameter client
An SDK client (client) instance.
Deprecated
Use initAndBind() directly.

method captureEvent

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

Captures a manually created event and sends it to Sentry.
Parameter event
The event to send to Sentry.
Parameter hint
May contain additional information about the original exception.
Deprecated
Use Sentry.captureEvent() instead.

method captureException

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

Captures an exception event and sends it to Sentry.
Parameter exception
An exception-like object.
Parameter hint
May contain additional information about the original exception.
Returns
The generated eventId.
Deprecated
Use Sentry.captureException() instead.

method captureMessage

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

Captures a message event and sends it to Sentry.
Parameter message
The message to send to Sentry.
Parameter level
Define the level of the message.
Parameter hint
May contain additional information about the original exception.
Returns
The generated eventId.
Deprecated
Use Sentry.captureMessage() instead.

method captureSession

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

Sends the current session on the scope to Sentry
Parameter endSession
If set the session will be marked as exited and removed from the scope
Deprecated
Use top-level captureSession instead.

method endSession

endSession: () => void;

Ends the session that lives on the current scope and sends it to Sentry
Deprecated
Use top-level endSession instead.

method getClient

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

Returns the client of the top stack.
Deprecated
Use Sentry.getClient() instead.

method getIntegration

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

Returns the integration if installed on the current client.
Deprecated
Use Sentry.getClient().getIntegration() instead.

method getIsolationScope

getIsolationScope: () => Scope;

Get the currently active isolation scope. The isolation scope is used to isolate data between different hubs.
Deprecated
Use Sentry.getIsolationScope() instead.

method getScope

getScope: () => Scope;

Returns the scope of the top stack.
Deprecated
Use Sentry.getCurrentScope() instead.

method setContext

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

Sets context data with the given name.
Parameter name
of the context
Parameter context
Any kind of data. This data will be normalized.
Deprecated
Use Sentry.setContext() instead.

method setExtra

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

Set key:value that will be sent as extra data with the event.
Parameter key
String of extra
Parameter extra
Any kind of data. This data will be normalized.
Deprecated
Use Sentry.setExtra() instead.

method setExtras

setExtras: (extras: Extras) => void;

Set an object that will be merged sent as extra data with the event.
Parameter extras
Extras object to merge into current context.
Deprecated
Use Sentry.setExtras() instead.

method setTag

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

Set key:value that will be sent as tags data with the event.
Can also be used to unset a tag, by passing undefined.
Parameter key
String key of tag
Parameter value
Value of tag
Deprecated
Use Sentry.setTag() instead.

method setTags

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

Set an object that will be merged sent as tags data with the event.
Parameter tags
Tags context object to merge into current context.
Deprecated
Use Sentry.setTags() instead.

method setUser

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

Updates user context information for future events.
Parameter user
User context object to be set in the current context. Pass null to unset the user.
Deprecated
Use Sentry.setUser() instead.

method startSession

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

Starts a new Session, sets on the current scope and returns it.
To finish a session, it has to be passed directly to client.captureSession, which is done automatically when using hub.endSession() for the session currently stored on the scope.
When there's already an existing session on the scope, it'll be automatically ended.
Parameter context
Optional properties of the new Session.
Returns
The session which was just started
Deprecated
Use top-level startSession instead.

method withScope

withScope: <T>(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.
This is essentially a convenience function for:
pushScope(); callback(); popScope();
Parameter callback
that will be enclosed into push/popScope.
Deprecated
Use Sentry.withScope() instead.

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

interface IntegrationClass<T> {}

Integration Class Interface

property id

id: string;

Property that holds the integration name

construct signature

new (...args: any[]): T;

interface InternalBaseTransportOptions

interface InternalBaseTransportOptions {}

property bufferSize

bufferSize?: number;

property recordDroppedEvent

recordDroppedEvent: Client['recordDroppedEvent'];

property tunnel

tunnel?: string;

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

interface LegacyCSPReport

interface LegacyCSPReport {}

property 'csp-report'

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

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

interface MetricBucketItem {}

property metric

metric: MetricInstance;

property metricType

metricType: 'c' | 'g' | 's' | 'd';

property name

name: string;

property tags

tags: Record<string, string>;

property timestamp

timestamp: number;

property unit

unit: MeasurementUnit;

interface MetricData

interface MetricData {}

property client

client?: Client;

property tags

tags?: Record<string, Primitive>;

property timestamp

timestamp?: number;

property unit

unit?: MeasurementUnit;

interface MetricInstance

interface MetricInstance {}

An abstract definition of the minimum required API for a metric instance.

property weight

weight: number;

Returns the weight of the metric.

method add

add: (value: number | string) => void;

Adds a value to a metric.

method toString

toString: () => string;

Serializes the metric into a statsd format string.

interface Metrics

interface Metrics {}

method distribution

distribution: (name: string, value: number, data?: MetricData) => void;

Adds a value to a distribution metric
This API is experimental and might have breaking changes in the future.
Modifiers
- @experimental

method gauge

gauge: (name: string, value: number, data?: MetricData) => void;

Adds a value to a gauge metric
This API is experimental and might have breaking changes in the future.
Modifiers
- @experimental

method increment

increment: (name: string, value?: number, data?: MetricData) => void;

Adds a value to a counter metric
This API is experimental and might have breaking changes in the future.
Modifiers
- @experimental

method set

set: (name: string, value: number | string, data?: MetricData) => void;

Adds a value to a set metric. Value must be a string or integer.
This API is experimental and might have breaking changes in the future.
Modifiers
- @experimental

method timing

timing: {
    (
        name: string,
        value: number,
        unit?: DurationUnit,
        data?: Omit<MetricData, 'unit'>
    ): void;
    <T>(
        name: string,
        callback: () => T,
        unit?: DurationUnit,
        data?: Omit<MetricData, 'unit'>
    ): T;
};

Adds a timing metric. The metric is added as a distribution metric.
You can either directly capture a numeric value, or wrap a callback function in timing. In the latter case, the duration of the callback execution will be captured as a span & a metric.
This API is experimental and might have breaking changes in the future.
Modifiers
- @experimental

interface MetricsAggregator

interface MetricsAggregator {}

A metrics aggregator that aggregates metrics in memory and flushes them periodically.

method add

add: (
    metricType: 'c' | 'g' | 's' | 'd',
    name: string,
    value: number | string,
    unit?: MeasurementUnit,
    tags?: Record<string, Primitive>,
    timestamp?: number
) => void;

Add a metric to the aggregator.

method close

close: () => void;

Shuts down metrics aggregator and clears all metrics.

method flush

flush: () => void;

Flushes the current metrics to the transport via the transport.

method toString

toString: () => string;

Returns a string representation of the aggregator.

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

interface Options

interface Options<TO extends BaseTransportOptions = BaseTransportOptions>
    extends Omit<
        Partial<ClientOptions<TO>>,
        'integrations' | 'transport' | 'stackParser'
    > {}

Base configuration options for every SDK.

property defaultIntegrations

defaultIntegrations?: false | Integration[];

If this is set to false, default integrations will not be added, otherwise this will internally be set to the recommended default integrations.

property integrations

integrations?: Integration[] | ((integrations: Integration[]) => Integration[]);

List of integrations that should be installed after SDK was initialized. Accepts either a list of integrations or a function that receives default integrations and returns a new, updated list.

property stackParser

stackParser?: StackParser | StackLineParser[];

A stack parser implementation or an array of stack line parsers By default, a stack parser is supplied for all supported browsers

property transport

transport?: (transportOptions: TO) => Transport;

A function that takes transport options and returns the Transport object which is used to send events to Sentry. The function is invoked internally during SDK initialization. By default, the SDK initializes its default transports.

interface OsContext

interface OsContext extends Record<string, unknown> {}

property build

build?: string;

property kernel_version

kernel_version?: string;

property name

name?: string;

property version

version?: string;

interface Package

interface Package {}

JSDoc

property dependencies

dependencies?: Record<string, string>;

property devDependencies

devDependencies?: Record<string, string>;

property name

name: string;

property version

version: string;

interface PolymorphicEvent

interface PolymorphicEvent {}

Event-like interface that's usable in browser and node.
Note: Here we mean the kind of events handled by event listeners, not our Event type.
Property availability taken from https://developer.mozilla.org/en-US/docs/Web/API/Event#browser_compatibility

property currentTarget

readonly currentTarget?: unknown;

property target

readonly target?: unknown;

property type

readonly type: string;

index signature

[key: string]: unknown;

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

method stopProfiler

stopProfiler: () => void;

interface ProfilingIntegration

interface ProfilingIntegration<T extends Client> extends Integration {}

interface PromiseBuffer

interface PromiseBuffer<T> {}

property $

$: Array<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 sampled

sampled?: boolean;

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

property spanId

spanId: string;

Represents the execution context of the current SDK. This acts as a fallback value to associate events with a particular execution context when performance monitoring is disabled.
The ID of a current span (if one exists) should have precedence over this value when propagating trace data.
Deprecated
This value will not be used anymore in the future, and should not be set or read anymore.

property traceId

traceId: string;

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

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 RequestEventData

interface RequestEventData {}

Request data included in an event as sent to Sentry.

property cookies

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

property data

data?: any;

property env

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

property headers

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

property method

method?: string;

property query_string

query_string?: QueryParams;

property url

url?: string;

interface RequestSession

interface RequestSession {}

Deprecated
This type is deprecated and will be removed in the next major version of the SDK.

property status

status?: RequestSessionStatus;

interface Runtime

interface Runtime {}

Runtime Context.

property name

name?: string;

property version

version?: string;

interface SamplingContext

interface SamplingContext extends CustomSamplingContext {}

Data passed to the tracesSampler function, which forms the basis for whatever decisions it might make.
Adds default data to data provided by the user. See Hub.startTransaction

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

parentSampled?: boolean;

Sampling decision from the parent transaction, if any.

property request

request?: ExtractedNodeRequestData;

Object representing the incoming request to a node server. Passed by default when using the TracingHandler.

property transactionContext

transactionContext: {
    name: string;
    parentSampled?: boolean | undefined;
};

Context data with which transaction being sampled was created.
Deprecated
This is duplicate data and will be removed eventually.

interface ScopeContext

interface ScopeContext {}

JSDocs

property contexts

contexts: Contexts;

property extra

extra: Extras;

property fingerprint

fingerprint: string[];

property level

level: SeverityLevel;

property propagationContext

propagationContext: PropagationContext;

property requestSession

requestSession: RequestSession;

property tags

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

property user

user: User;

interface ScopeData

interface ScopeData {}

property attachments

attachments: Attachment[];

property breadcrumbs

breadcrumbs: Breadcrumb[];

property contexts

contexts: Contexts;

property eventProcessors

eventProcessors: EventProcessor[];

property extra

extra: Extras;

property fingerprint

fingerprint: string[];

property level

level?: SeverityLevel;

property propagationContext

propagationContext: PropagationContext;

property sdkProcessingMetadata

sdkProcessingMetadata: {
    [key: string]: unknown;
};

property span

span?: Span;

property tags

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

property transactionName

transactionName?: string;

property user

user: User;

interface SdkInfo

interface SdkInfo {}

property integrations

integrations?: string[];

property name

name?: string;

property packages

packages?: Package[];

property version

version?: string;

interface SdkMetadata

interface SdkMetadata {}

property sdk

sdk?: SdkInfo;

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

interface ServerRuntimeClientOptions

interface ServerRuntimeClientOptions extends ClientOptions<BaseTransportOptions> {}

property platform

platform?: string;

property runtime

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

property serverName

serverName?: string;

interface Session

interface Session {}

property abnormal_mechanism

abnormal_mechanism?: string;

property did

did?: string | number;

property duration

duration?: number;

property environment

environment?: string;

property errors

errors: number;

property ignoreDuration

ignoreDuration: boolean;

property init

init: boolean;

property ipAddress

ipAddress?: string;

property release

release?: string;

property sid

sid: string;

property started

started: number;

property status

status: SessionStatus;

property timestamp

timestamp: number;

property user

user?: User | null;

property userAgent

userAgent?: string;

method toJSON

toJSON: () => SerializedSession;

Overrides default JSON serialization of the Session because the Sentry servers expect a slightly different schema of a session which is described in the interface
See Also
- SerializedSession in this file.
  a Sentry-backend conforming JSON object of the session

interface SessionAggregates

interface SessionAggregates {}

JSDoc

property aggregates

aggregates: Array<AggregationCounts>;

property attrs

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

interface SessionFlusherLike

interface SessionFlusherLike {}

Deprecated
This type is deprecated and will be removed in the next major version of the SDK.

method close

close: () => void;

Clears setInterval and calls flush

method flush

flush: () => void;

Empties Aggregate Buckets and Sends them to Transport Buffer

method incrementSessionStatusCount

incrementSessionStatusCount: () => void;

Increments the Session Status bucket in SessionAggregates Object corresponding to the status of the session captured

interface Span

interface Span {}

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: unknown) => this;

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

method addLinks

addLinks: (links: unknown) => this;

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

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?: {
    [key: string]: any;
};

property description

description?: string;

property exclusive_time

exclusive_time?: number;

property is_segment

is_segment?: boolean;

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 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 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 defined, start this span off this scope instead off the current scope.

property startTime

startTime?: SpanTimeInput;

A manually specified start time for the created Span object.

interface Thread

interface Thread {}

JSDoc

property crashed

crashed?: boolean;

property current

current?: boolean;

property id

id?: number;

property name

name?: string;

property stacktrace

stacktrace?: Stacktrace;

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

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 headers

readonly headers: WebFetchHeaders;

property method

readonly method: string;

property url

readonly url: string;

method clone

clone: () => WebFetchRequest;

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 AddRequestDataToEventOptions

type AddRequestDataToEventOptions = {
    /** Flags controlling whether each type of data should be added to the event */
    include?: {
        ip?: boolean;
        request?: boolean | Array<(typeof DEFAULT_REQUEST_INCLUDES)[number]>;
        /** @deprecated This option will be removed in v9. It does not do anything anymore, the `transcation` is set in other places. */
        transaction?: boolean | TransactionNamingScheme;
        user?: boolean | Array<(typeof DEFAULT_USER_INCLUDES)[number]>;
    };
    /** Injected platform-specific dependencies */
    deps?: {
        cookie: {
            parse: (cookieStr: string) => Record<string, string>;
        };
        url: {
            parse: (urlStr: string) => {
                query: string | null;
            };
        };
    };
};

Options deciding what parts of the request to use when enhancing an event

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.
     */
    profilesSampleRate?: number;
};

type BrowserClientReplayOptions

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

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

type CaptureContext

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

JSDocs

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 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'
    | 'metric_bucket'
    | 'span'
    | '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;
};

type Envelope

type Envelope =
    | EventEnvelope
    | SessionEnvelope
    | ClientReportEnvelope
    | ProfileChunkEnvelope
    | ReplayEnvelope
    | CheckInEnvelope
    | StatsdEnvelope
    | SpanEnvelope
    | RawSecurityEnvelope;

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'
    | 'statsd'
    | 'span'
    | 'raw_security';

type EventDropReason

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

type EventEnvelope

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

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 Extra

type Extra = unknown;

type Extras

type Extras = Record<string, Extra>;

type FeatureFlag

type FeatureFlag = {
    readonly flag: string;
    readonly result: boolean;
};

type FeedbackFormData

type FeedbackFormData = {
    name: string;
    email: string;
    message: string;
    attachments: Attachment[] | undefined;
};

type FeedbackItem

type FeedbackItem = BaseEnvelopeItem<FeedbackItemHeaders, FeedbackEvent>;

type FractionUnit

type FractionUnit = 'ratio' | 'percent';

Fractions such as percentages.

type FrameId

type FrameId = number;

type HandlerDataUnhandledRejection

type HandlerDataUnhandledRejection = unknown;

type HttpHeaderValue

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

type InformationUnit

type InformationUnit =
    | 'bit'
    | 'byte'
    | 'kilobyte'
    | 'kibibyte'
    | 'megabyte'
    | 'mebibyte'
    | 'gigabyte'
    | 'terabyte'
    | 'tebibyte'
    | 'petabyte'
    | 'exabyte'
    | 'exbibyte';

Size of information derived from bytes.

type 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;
    };
    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>;
    __SENTRY__: Record<Exclude<string, 'version'>, SentryCarrier> & {
        version?: string;
    } & BackwardsCompatibleSentryCarrier;
    /**
     * Raw module metadata that is injected by bundler plugins.
     *
     * Keys are `error.stack` strings, values are the metadata.
     */
    _sentryModuleMetadata?: Record<string, any>;
    _sentryEsmLoaderHookRegistered?: boolean;
};

Internal global with common properties and Sentry extensions

type Measurements

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

type MeasurementUnit

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

type MetricSummary

type MetricSummary = {
    min: number;
    max: number;
    count: number;
    sum: number;
    tags?: Record<string, Primitive> | undefined;
};

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__?: string[];
};

type PolymorphicRequest

type PolymorphicRequest = BaseRequest &
    BrowserRequest &
    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 Request

type Request = RequestEventData;

Request data included in an event as sent to Sentry. @deprecated: This type will be removed in v9. Use RequestEventData instead.

type RequestDataIntegrationOptions

type RequestDataIntegrationOptions = {
    /**
     * Controls what data is pulled from the request and added to the event
     */
    include?: {
        cookies?: boolean;
        data?: boolean;
        headers?: boolean;
        ip?: boolean;
        query_string?: boolean;
        url?: boolean;
        user?:
            | boolean
            | {
                  id?: boolean;
                  username?: boolean;
                  email?: boolean;
              };
    };
    /**
     * Whether to identify transactions by parameterized path, parameterized path with method, or handler name.
     * @deprecated This option does not do anything anymore, and will be removed in v9.
     */
    transactionNamingScheme?: 'path' | 'methodPath' | 'handler';
};

type RequestSessionStatus

type RequestSessionStatus = 'ok' | 'errored' | 'crashed';

Deprecated
This type is deprecated and will be removed in the next major version of the SDK.

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 Scope

type Scope = ScopeInterface;

Holds additional event information.

type SdkSource

type SdkSource = 'npm' | 'cdn' | 'loader';

type SendFeedback

type SendFeedback = (
    params: SendFeedbackParams,
    hint?: EventHint & {
        includeReplay?: boolean;
    }
) => 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 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 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 StatsdEnvelope

type StatsdEnvelope = BaseEnvelope<StatsdEnvelopeHeaders, StatsdItem>;

type StatsdItem

type StatsdItem = BaseEnvelopeItem<StatsdItemHeaders, string>;

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 TransactionNamingScheme

type TransactionNamingScheme = 'path' | 'methodPath' | 'handler';

Deprecated
This type will be removed in v9. It is not in use anymore.

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;
    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 & {
    [key: string]: any;
    __sentry_wrapped__?: WrappedFunction<T>;
    __sentry_original__?: T;
};

A function that is possibly wrapped by Sentry.

Package Files (172)

Dependencies (0)

No dependencies.

Dev Dependencies (2)

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 5 days ago.
Package analyzed in 14106 ms.
Missing or incorrect documentation? Open an issue for this package.

@sentry/core

Install

Overview

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Variables

variable BAGGAGE_HEADER_NAME

Deprecated

variable browserPerformanceTimeOrigin

variable CONSOLE_LEVELS

variable DEFAULT_ENVIRONMENT

variable DEFAULT_RETRY_AFTER

variable DEFAULT_USER_INCLUDES

variable getCurrentHub

Deprecated

variable GLOBAL_OBJ

variable logger

variable MAX_BAGGAGE_STRING_LENGTH

variable metrics

Deprecated

variable metricsDefault

Deprecated

variable originalConsoleMethods

variable profiler

variable Scope

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_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_SAMPLE_RATE

variable SEMANTIC_ATTRIBUTE_SENTRY_SOURCE

variable SEMANTIC_ATTRIBUTE_URL_FULL

variable SENTRY_BAGGAGE_KEY_PREFIX

variable SENTRY_BAGGAGE_KEY_PREFIX_REGEX

variable SPAN_STATUS_ERROR

variable SPAN_STATUS_OK

variable SPAN_STATUS_UNSET

variable TRACEPARENT_REGEXP

variable TRACING_DEFAULTS

variable UNKNOWN_FUNCTION

variable validSeverityLevels

Deprecated

Functions

function addBreadcrumb

function addChildSpanToSpan

function addConsoleInstrumentationHandler

function addContextToFrame

Parameter lines

Parameter frame

Parameter linesOfContext

function addEventProcessor

function addExceptionMechanism

Parameter event

Parameter newMechanism

function addExceptionTypeValue

Parameter event

Parameter value

Parameter type

function addFetchEndInstrumentationHandler

function addFetchInstrumentationHandler

function addGlobalErrorInstrumentationHandler

function addGlobalUnhandledRejectionInstrumentationHandler

function addHandler

function addIntegration

function addItemToEnvelope

function addNonEnumerableProperty

Parameter obj

Parameter name