@sentry/node

constructor

constructor(options?: HttpOptions);

property id

static id: string;

property name

name: string;

method setupOnce

setupOnce: (
    _addGlobalEventProcessor: (callback: EventProcessor) => void,
    setupOnceGetCurrentHub: () => Hub
) => void;

constructor

constructor(options: NodeClientOptions);

• Creates a new Node SDK instance.

  Parameter options

  Configuration options for this SDK.

constructor

constructor(_options?: Partial<UndiciOptions>);

property id

static id: string;

property name

name: string;

method setupOnce

setupOnce: (
    _addGlobalEventProcessor: (callback: EventProcessor) => void
) => void;

property anrThreshold

anrThreshold: number;

• Threshold in milliseconds to trigger an ANR event.

  Defaults to 5000ms.

property appRootPath

appRootPath: string | undefined;

• Internal use only.

  If this is supplied, stack frame filenames will be rewritten to be relative to this path.

property captureStackTrace

captureStackTrace: boolean;

• Whether to capture a stack trace when the ANR event is triggered.

  Defaults to false.

  This uses the node debugger which enables the inspector API and opens the required ports.

property pollInterval

pollInterval: number;

• Interval to send heartbeat messages to the ANR worker.

  Defaults to 50ms.

property staticTags

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

• Tags to include with ANR events.

method configureAndConnect

configureAndConnect: (
    onPause: (
        message: InspectorNotification<Debugger.PausedEventDataType>,
        complete: () => void
    ) => void,
    captureAll: boolean
) => void;

• Configures and connects to the debug session

method getLocalVariables

getLocalVariables: (
    objectId: string,
    callback: (vars: Variables) => void
) => void;

• Gets local variables for an objectId

method setPauseOnExceptions

setPauseOnExceptions: (captureAll: boolean) => void;

• Updates which kind of exceptions to capture

property captureAllExceptions

captureAllExceptions?: boolean;

• Capture local variables for both caught and uncaught exceptions

  - When false, only uncaught exceptions will have local variables - When true, both caught and uncaught exceptions will have local variables.

  Defaults to true.

  Capturing local variables for all exceptions can be expensive since the debugger pauses for every throw to collect local variables.

  To reduce the likelihood of this feature impacting app performance or throughput, this feature is rate-limited. Once the rate limit is reached, local variables will only be captured for uncaught exceptions until a timeout has been reached.

property maxExceptionsPerSecond

maxExceptionsPerSecond?: number;

• Maximum number of exceptions to capture local variables for per second before rate limiting is triggered.

variable trpcMiddleware

const trpcMiddleware: (
    options?: SentryTrpcMiddlewareOptions
) => <T>({ path, type, next, rawInput }: TrpcMiddlewareArguments<T>) => T;

• Sentry tRPC middleware that names the handling transaction after the called procedure.

  Use the Sentry tRPC middleware in combination with the Sentry server integration, e.g. Express Request Handlers or Next.js SDK.

  Deprecated

  Please use the top level export instead:

  // OLD
  import * as Sentry from '@sentry/node';
  Sentry.Handlers.trpcMiddleware();
  
  // NEW
  import * as Sentry from '@sentry/node';
  Sentry.trpcMiddleware();

function errorHandler

errorHandler: (options?: {
    shouldHandleError?(this: void, error: MiddlewareError): boolean;
}) => (
    error: MiddlewareError,
    req: http.IncomingMessage,
    res: http.ServerResponse,
    next: (error: MiddlewareError) => void
) => void;

• Express compatible error handler.

  See Also

  • Exposed as Handlers.errorHandler

function extractRequestData

extractRequestData: (
    req: { [key: string]: any },
    keys?: string[]
) => ExtractedNodeRequestData;

• Normalizes data from the request object, accounting for framework differences.

  Parameter req

  The request object from which to extract data

  Parameter keys

  An optional array of keys to include in the normalized data.

  Returns

  An object containing normalized request data

  Deprecated

  Handlers.extractRequestData is deprecated and will be removed in v8. Use extractRequestData instead.

function parseRequest

parseRequest: (
    event: Event,
    req: PolymorphicRequest,
    options?: ParseRequestOptions
) => Event;

• Enriches passed event with request data.

  Parameter event

  Will be mutated and enriched with req data

  Parameter req

  Request object

  Parameter options

  object containing flags to enable functionality

  Deprecated

  Handlers.parseRequest is deprecated and will be removed in v8. Use addRequestDataToEvent instead.

function requestHandler

requestHandler: (
    options?: RequestHandlerOptions
) => (
    req: http.IncomingMessage,
    res: http.ServerResponse,
    next: (error?: any) => void
) => void;

• Express compatible request handler.

  See Also

  • Exposed as Handlers.requestHandler

function tracingHandler

tracingHandler: () => (
    req: http.IncomingMessage,
    res: http.ServerResponse,
    next: (error?: any) => void
) => void;

• Express-compatible tracing handler.

  See Also

  • Exposed as Handlers.tracingHandler

type ExpressRequest

type ExpressRequest = PolymorphicRequest;

• Deprecated

  Handlers.ExpressRequest is deprecated and will be removed in v8. Use PolymorphicRequest instead.

type ParseRequestOptions

type ParseRequestOptions = AddRequestDataToEventOptions['include'] & {
    serverName?: boolean;
    version?: boolean;
};

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

  Deprecated

  Handlers.ParseRequestOptions is deprecated and will be removed in v8. Use AddRequestDataToEventOptions in @sentry/utils instead.

type RequestHandlerOptions

type RequestHandlerOptions = (ParseRequestOptions | AddRequestDataToEventOptions) & {
    flushTimeout?: number;
};