@sentry/node 7.104.0 → 8.0.0-alpha.1

package/types/utils/prepareEvent.d.ts

@@ -0,0 +1,17 @@
+import type { CaptureContext, EventHint, ScopeContext } from '@sentry/types';
+/**
+ * This type makes sure that we get either a CaptureContext, OR an EventHint.
+ * It does not allow mixing them, which could lead to unexpected outcomes, e.g. this is disallowed:
+ * { user: { id: '123' }, mechanism: { handled: false } }
+ */
+export type ExclusiveEventHintOrCaptureContext = (CaptureContext & Partial<{
+    [key in keyof EventHint]: never;
+}>) | (EventHint & Partial<{
+    [key in keyof ScopeContext]: never;
+}>);
+/**
+ * Parse either an `EventHint` directly, or convert a `CaptureContext` to an `EventHint`.
+ * This is used to allow to update method signatures that used to accept a `CaptureContext` but should now accept an `EventHint`.
+ */
+export declare function parseEventHintOrCaptureContext(hint: ExclusiveEventHintOrCaptureContext | undefined): EventHint | undefined;
+//# sourceMappingURL=prepareEvent.d.ts.map

package/types/utils/prepareEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prepareEvent.d.ts","sourceRoot":"","sources":["../../../src/utils/prepareEvent.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,SAAS,EAA2B,YAAY,EAAE,MAAM,eAAe,CAAC;AAEtG;;;;GAIG;AACH,MAAM,MAAM,kCAAkC,GAC1C,CAAC,cAAc,GAAG,OAAO,CAAC;KAAG,GAAG,IAAI,MAAM,SAAS,GAAG,KAAK;CAAE,CAAC,CAAC,GAC/D,CAAC,SAAS,GAAG,OAAO,CAAC;KAAG,GAAG,IAAI,MAAM,YAAY,GAAG,KAAK;CAAE,CAAC,CAAC,CAAC;AAElE;;;GAGG;AACH,wBAAgB,8BAA8B,CAC5C,IAAI,EAAE,kCAAkC,GAAG,SAAS,GACnD,SAAS,GAAG,SAAS,CAiBvB"}

package/types-ts3.8/cron/index.d.ts

@@ -0,0 +1,10 @@
+import { instrumentCron } from './cron';
+import { instrumentNodeCron } from './node-cron';
+import { instrumentNodeSchedule } from './node-schedule';
+/** Methods to instrument cron libraries for Sentry check-ins */
+export declare const cron: {
+    instrumentCron: typeof instrumentCron;
+    instrumentNodeCron: typeof instrumentNodeCron;
+    instrumentNodeSchedule: typeof instrumentNodeSchedule;
+};
+//# sourceMappingURL=index.d.ts.map

package/types-ts3.8/index.d.ts

@@ -1,147 +1,35 @@
-export { Breadcrumb, BreadcrumbHint, PolymorphicRequest, Request, SdkInfo, Event, EventHint, Exception, Session, Severity, SeverityLevel, Span, StackFrame, Stacktrace, Thread, Transaction, User, } from '@sentry/types';
-export { AddRequestDataToEventOptions, TransactionNamingScheme } from '@sentry/utils';
-export { NodeOptions } from './types';
-export { addGlobalEventProcessor, addEventProcessor, addBreadcrumb, addIntegration, captureException, captureEvent, captureMessage, close, configureScope, createTransport, extractTraceparentData, flush, getActiveTransaction, getHubFromCarrier, getCurrentHub, getClient, isInitialized, getCurrentScope, getGlobalScope, getIsolationScope, Hub, lastEventId, makeMain, setCurrentClient, runWithAsyncContext, Scope, startTransaction, SDK_VERSION, setContext, setExtra, setExtras, setTag, setTags, setUser, spanStatusfromHttpCode, getSpanStatusFromHttpCode, setHttpStatus, trace, withScope, withIsolationScope, captureCheckIn, withMonitor, setMeasurement, getActiveSpan, startSpan, startActiveSpan, startInactiveSpan, startSpanManual, continueTrace, parameterize, metrics, functionToStringIntegration, inboundFiltersIntegration, linkedErrorsIntegration, requestDataIntegration, startSession, captureSession, endSession, } from '@sentry/core';
-export { SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE, } from '@sentry/core';
-export { SpanStatusType } from '@sentry/core';
-export { autoDiscoverNodePerformanceMonitoringIntegrations } from './tracing';
-export { NodeClient } from './client';
-export { makeNodeTransport } from './transports';
-export { defaultIntegrations, getDefaultIntegrations, init, defaultStackParser, getSentryRelease, } from './sdk';
-export { addRequestDataToEvent, DEFAULT_USER_INCLUDES, extractRequestData } from '@sentry/utils';
-export { deepReadDirSync } from './utils';
-import { createGetModuleFromFilename } from './module';
-/**
- * @deprecated use `createGetModuleFromFilename` instead.
- */
-export declare const getModuleFromFilename: (filename: string | undefined) => string | undefined;
-export { createGetModuleFromFilename };
-export { enableAnrDetection } from './integrations/anr/legacy';
-import * as Handlers from './handlers';
-import * as NodeIntegrations from './integrations';
-import * as TracingIntegrations from './tracing/integrations';
-export declare const Integrations: {
-    Apollo: typeof TracingIntegrations.Apollo;
-    Express: typeof TracingIntegrations.Express;
-    GraphQL: typeof TracingIntegrations.GraphQL;
-    Mongo: typeof TracingIntegrations.Mongo;
-    Mysql: typeof TracingIntegrations.Mysql;
-    Postgres: typeof TracingIntegrations.Postgres;
-    Prisma: typeof TracingIntegrations.Prisma;
-    Console: import("@sentry/types").IntegrationClass<import("@sentry/types").Integration & {
-        setup: (client: import("@sentry/types").Client<import("@sentry/types").ClientOptions<import("@sentry/types").BaseTransportOptions>>) => void;
-    }>;
-    Http: typeof NodeIntegrations.Http;
-    OnUncaughtException: import("@sentry/types").IntegrationClass<import("@sentry/types").Integration & {
-        setup: (client: import("./client").NodeClient) => void;
-    }> & (new (options?: Partial<{
-        exitEvenIfOtherHandlersAreRegistered: boolean;
-        onFatalError?(this: void, firstError: Error, secondError?: Error | undefined): void;
-    }> | undefined) => import("@sentry/types").Integration);
-    OnUnhandledRejection: import("@sentry/types").IntegrationClass<import("@sentry/types").Integration & {
-        setup: (client: import("@sentry/types").Client<import("@sentry/types").ClientOptions<import("@sentry/types").BaseTransportOptions>>) => void;
-    }> & (new (options?: Partial<{
-        mode: "warn" | "none" | "strict";
-    }> | undefined) => import("@sentry/types").Integration);
-    Modules: import("@sentry/types").IntegrationClass<import("@sentry/types").Integration & {
-        processEvent: (event: import("@sentry/types").Event) => import("@sentry/types").Event;
-    }>;
-    ContextLines: import("@sentry/types").IntegrationClass<import("@sentry/types").Integration & {
-        processEvent: (event: import("@sentry/types").Event) => Promise<import("@sentry/types").Event>;
-    }> & (new (options?: {
-        frameContextLines?: number | undefined;
-    } | undefined) => import("@sentry/types").Integration);
-    Context: import("@sentry/types").IntegrationClass<import("@sentry/types").Integration & {
-        processEvent: (event: import("@sentry/types").Event) => Promise<import("@sentry/types").Event>;
-    }> & (new (options?: {
-        app?: boolean | undefined;
-        os?: boolean | undefined;
-        device?: boolean | {
-            cpu?: boolean | undefined;
-            memory?: boolean | undefined;
-        } | undefined;
-        culture?: boolean | undefined;
-        cloudResource?: boolean | undefined;
-    } | undefined) => import("@sentry/types").Integration);
-    RequestData: import("@sentry/types").IntegrationClass<import("@sentry/types").Integration & {
-        processEvent: (event: import("@sentry/types").Event, hint: import("@sentry/types").EventHint, client: import("@sentry/types").Client<import("@sentry/types").ClientOptions<import("@sentry/types").BaseTransportOptions>>) => import("@sentry/types").Event;
-    }> & (new (options?: {
-        include?: {
-            cookies?: boolean | undefined;
-            data?: boolean | undefined;
-            headers?: boolean | undefined;
-            ip?: boolean | undefined;
-            query_string?: boolean | undefined;
-            url?: boolean | undefined;
-            user?: boolean | {
-                id?: boolean | undefined;
-                username?: boolean | undefined;
-                email?: boolean | undefined;
-            } | undefined;
-        } | undefined;
-        transactionNamingScheme?: import("@sentry/utils").TransactionNamingScheme | undefined;
-    } | undefined) => import("@sentry/types").Integration);
-    LocalVariables: import("@sentry/types").IntegrationClass<import("@sentry/types").Integration & {
-        processEvent: (event: import("@sentry/types").Event) => import("@sentry/types").Event;
-        setup: (client: import("./client").NodeClient) => void;
-    }> & (new (options?: import("./integrations/local-variables/common").LocalVariablesIntegrationOptions | undefined, session?: import("./integrations/local-variables/local-variables-sync").DebugSession | undefined) => import("@sentry/types").Integration);
-    Undici: typeof NodeIntegrations.Undici;
-    Spotlight: import("@sentry/types").IntegrationClass<import("@sentry/types").Integration & {
-        setup: (client: import("@sentry/types").Client<import("@sentry/types").ClientOptions<import("@sentry/types").BaseTransportOptions>>) => void;
-    }> & (new (options?: Partial<{
-        sidecarUrl?: string | undefined;
-    }> | undefined) => import("@sentry/types").Integration);
-    Anr: import("@sentry/types").IntegrationClass<import("@sentry/types").Integration & {
-        setup: (client: import("./client").NodeClient) => void;
-    }> & (new (options?: Partial<import("./integrations/anr/common").AnrIntegrationOptions> | undefined) => import("@sentry/types").Integration & {
-        setup(client: import("@sentry/types").Client<import("@sentry/types").ClientOptions<import("@sentry/types").BaseTransportOptions>>): void;
-    });
-    Hapi: import("@sentry/types").IntegrationClass<import("@sentry/types").Integration>;
-    FunctionToString: import("@sentry/types").IntegrationClass<import("@sentry/types").Integration & {
-        setupOnce: () => void;
-    }>;
-    InboundFilters: import("@sentry/types").IntegrationClass<import("@sentry/types").Integration & {
-        preprocessEvent: (event: import("@sentry/types").Event, hint: import("@sentry/types").EventHint, client: import("@sentry/types").Client<import("@sentry/types").ClientOptions<import("@sentry/types").BaseTransportOptions>>) => void;
-    }> & (new (options?: Partial<{
-        allowUrls: (string | RegExp)[];
-        denyUrls: (string | RegExp)[];
-        ignoreErrors: (string | RegExp)[];
-        ignoreTransactions: (string | RegExp)[];
-        ignoreInternal: boolean;
-        disableErrorDefaults: boolean;
-        disableTransactionDefaults: boolean;
-    }> | undefined) => import("@sentry/types").Integration);
-    LinkedErrors: import("@sentry/types").IntegrationClass<import("@sentry/types").Integration & {
-        preprocessEvent: (event: import("@sentry/types").Event, hint: import("@sentry/types").EventHint, client: import("@sentry/types").Client<import("@sentry/types").ClientOptions<import("@sentry/types").BaseTransportOptions>>) => void;
-    }> & (new (options?: {
-        key?: string | undefined;
-        limit?: number | undefined;
-    } | undefined) => import("@sentry/types").Integration);
-};
+export { httpIntegration } from './integrations/http';
+export { nativeNodeFetchIntegration } from './integrations/node-fetch';
 export { consoleIntegration } from './integrations/console';
-export { onUncaughtExceptionIntegration } from './integrations/onuncaughtexception';
-export { onUnhandledRejectionIntegration } from './integrations/onunhandledrejection';
-export { modulesIntegration } from './integrations/modules';
-export { contextLinesIntegration } from './integrations/contextlines';
 export { nodeContextIntegration } from './integrations/context';
+export { contextLinesIntegration } from './integrations/contextlines';
 export { localVariablesIntegration } from './integrations/local-variables';
-export { spotlightIntegration } from './integrations/spotlight';
+export { modulesIntegration } from './integrations/modules';
+export { onUncaughtExceptionIntegration } from './integrations/onuncaughtexception';
+export { onUnhandledRejectionIntegration } from './integrations/onunhandledrejection';
 export { anrIntegration } from './integrations/anr';
-export { hapiIntegration } from './integrations/hapi';
-export { Undici, nativeNodeFetchintegration } from './integrations/undici';
-export { Http, httpIntegration } from './integrations/http';
-export { LocalVariablesIntegrationOptions } from './integrations/local-variables/common';
-export { DebugSession } from './integrations/local-variables/local-variables-sync';
-export { AnrIntegrationOptions } from './integrations/anr/common';
-export { Handlers };
-export { hapiErrorPlugin } from './integrations/hapi';
-import { instrumentCron } from './cron/cron';
-import { instrumentNodeCron } from './cron/node-cron';
-import { instrumentNodeSchedule } from './cron/node-schedule';
-/** Methods to instrument cron libraries for Sentry check-ins */
-export declare const cron: {
-    instrumentCron: typeof instrumentCron;
-    instrumentNodeCron: typeof instrumentNodeCron;
-    instrumentNodeSchedule: typeof instrumentNodeSchedule;
-};
+export { expressIntegration, expressErrorHandler, setupExpressErrorHandler } from './integrations/tracing/express';
+export { fastifyIntegration } from './integrations/tracing/fastify';
+export { graphqlIntegration } from './integrations/tracing/graphql';
+export { mongoIntegration } from './integrations/tracing/mongo';
+export { mongooseIntegration } from './integrations/tracing/mongoose';
+export { mysqlIntegration } from './integrations/tracing/mysql';
+export { mysql2Integration } from './integrations/tracing/mysql2';
+export { nestIntegration } from './integrations/tracing/nest';
+export { postgresIntegration } from './integrations/tracing/postgres';
+export { prismaIntegration } from './integrations/tracing/prisma';
+export { hapiIntegration, setupHapiErrorHandler } from './integrations/tracing/hapi';
+export { init, getDefaultIntegrations } from './sdk/init';
+export { getAutoPerformanceIntegrations } from './integrations/tracing';
+export { getClient, getSentryRelease, defaultStackParser, makeMain, } from './sdk/api';
+export { createGetModuleFromFilename } from './utils/module';
+export { makeNodeTransport } from './transports';
+export { NodeClient } from './sdk/client';
+export { getCurrentHub } from './sdk/hub';
+export { cron } from './cron';
+export { Span, NodeOptions } from './types';
+export { startSpan, startSpanManual, startInactiveSpan, getActiveSpan, withActiveSpan, } from '@sentry/opentelemetry';
+export { addRequestDataToEvent, DEFAULT_USER_INCLUDES, extractRequestData, } from '@sentry/utils';
+export { addBreadcrumb, isInitialized, getGlobalScope, close, createTransport, flush, Hub, SDK_VERSION, getSpanStatusFromHttpCode, setHttpStatus, captureCheckIn, withMonitor, requestDataIntegration, functionToStringIntegration, inboundFiltersIntegration, linkedErrorsIntegration, addEventProcessor, setContext, setExtra, setExtras, setTag, setTags, setUser, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE, setCurrentClient, Scope, setMeasurement, continueTrace, parameterize, getCurrentScope, getIsolationScope, withScope, withIsolationScope, captureException, captureEvent, captureMessage, captureConsoleIntegration, debugIntegration, dedupeIntegration, extraErrorDataIntegration, rewriteFramesIntegration, sessionTimingIntegration, } from '@sentry/core';
+export { Breadcrumb, BreadcrumbHint, PolymorphicRequest, Request, SdkInfo, Event, EventHint, Exception, Session, SeverityLevel, StackFrame, Stacktrace, Thread, Transaction, User, } from '@sentry/types';
 //# sourceMappingURL=index.d.ts.map

package/types-ts3.8/integrations/anr/index.d.ts

@@ -1,18 +1,3 @@
-import { Client, Integration, IntegrationClass } from '@sentry/types';
-import { NodeClient } from '../../client';
 import { AnrIntegrationOptions } from './common';
 export declare const anrIntegration: (options?: Partial<AnrIntegrationOptions> | undefined) => import("@sentry/types").IntegrationFnResult;
-/**
- * Starts a thread to detect App Not Responding (ANR) events
- *
- * ANR detection requires Node 16.17.0 or later
- *
- * @deprecated Use `anrIntegration()` instead.
- */
-export declare const Anr: IntegrationClass<Integration & {
-    setup: (client: NodeClient) => void;
-}> & (new (options?: Partial<AnrIntegrationOptions>) => Integration & {
-    setup(client: Client): void;
-});
-export type Anr = typeof Anr;
 //# sourceMappingURL=index.d.ts.map

package/types-ts3.8/integrations/console.d.ts

@@ -1,11 +1,5 @@
-import { Client, Integration, IntegrationClass } from '@sentry/types';
-export declare const consoleIntegration: () => import("@sentry/types").IntegrationFnResult;
 /**
- * Console module integration.
- * @deprecated Use `consoleIntegration()` instead.
+ * Capture console logs as breadcrumbs.
  */
-export declare const Console: IntegrationClass<Integration & {
-    setup: (client: Client) => void;
-}>;
-export type Console = typeof Console;
+export declare const consoleIntegration: () => import("@sentry/types").IntegrationFnResult;
 //# sourceMappingURL=console.d.ts.map

package/types-ts3.8/integrations/context.d.ts

@@ -1,7 +1,6 @@
 /// <reference types="node" />
 import { readFile, readdir } from 'fs';
-import * as os from 'os';
-import { DeviceContext, Event, Integration, IntegrationClass } from '@sentry/types';
+import { DeviceContext } from '@sentry/types';
 export declare const readFileAsync: typeof readFile.__promisify__;
 export declare const readDirAsync: typeof readdir.__promisify__;
 interface DeviceContextOptions {
@@ -15,24 +14,10 @@ interface ContextOptions {
     culture?: boolean;
     cloudResource?: boolean;
 }
-export declare const nodeContextIntegration: (options?: ContextOptions | undefined) => import("@sentry/types").IntegrationFnResult;
 /**
- * Add node modules / packages to the event.
- * @deprecated Use `nodeContextIntegration()` instead.
+ * Capture context about the environment and the device that the client is running on, to events.
  */
-export declare const Context: IntegrationClass<Integration & {
-    processEvent: (event: Event) => Promise<Event>;
-}> & (new (options?: {
-    app?: boolean;
-    os?: boolean;
-    device?: {
-        cpu?: boolean;
-        memory?: boolean;
-    } | boolean;
-    culture?: boolean;
-    cloudResource?: boolean;
-}) => Integration);
-export type Context = typeof Context;
+export declare const nodeContextIntegration: (options?: ContextOptions | undefined) => import("@sentry/types").IntegrationFnResult;
 /**
  * Gets device information from os
  */

package/types-ts3.8/integrations/contextlines.d.ts

@@ -1,4 +1,4 @@
-import { Event, Integration, IntegrationClass } from '@sentry/types';
+import { Event } from '@sentry/types';
 /**
  * Resets the file cache. Exists for testing purposes.
  * @hidden
@@ -13,16 +13,14 @@ interface ContextLinesOptions {
      **/
     frameContextLines?: number;
 }
-export declare const contextLinesIntegration: (options?: ContextLinesOptions | undefined) => import("@sentry/types").IntegrationFnResult;
+/** Exported only for tests, as a type-safe variant. */
+export declare const _contextLinesIntegration: (options?: ContextLinesOptions) => {
+    name: string;
+    processEvent(event: Event): Promise<Event>;
+};
 /**
- * Add node modules / packages to the event.
- * @deprecated Use `contextLinesIntegration()` instead.
+ * Capture the lines before and after the frame's context.
  */
-export declare const ContextLines: IntegrationClass<Integration & {
-    processEvent: (event: Event) => Promise<Event>;
-}> & (new (options?: {
-    frameContextLines?: number;
-}) => Integration);
-export type ContextLines = typeof ContextLines;
+export declare const contextLinesIntegration: (options?: ContextLinesOptions | undefined) => import("@sentry/types").IntegrationFnResult;
 export {};
 //# sourceMappingURL=contextlines.d.ts.map

package/types-ts3.8/integrations/http.d.ts

@@ -1,101 +1,20 @@
-import { Hub } from '@sentry/core';
-import { ClientOptions, EventProcessor, Integration, IntegrationFnResult, TracePropagationTargets } from '@sentry/types';
-import { NodeClientOptions } from '../types';
-interface TracingOptions {
-    /**
-     * List of strings/regex controlling to which outgoing requests
-     * the SDK will attach tracing headers.
-     *
-     * By default the SDK will attach those headers to all outgoing
-     * requests. If this option is provided, the SDK will match the
-     * request URL of outgoing requests against the items in this
-     * array, and only attach tracing headers if a match was found.
-     *
-     * @deprecated Use top level `tracePropagationTargets` option instead.
-     * This option will be removed in v8.
-     *
-     * ```
-     * Sentry.init({
-     *   tracePropagationTargets: ['api.site.com'],
-     * })
-     */
-    tracePropagationTargets?: TracePropagationTargets;
-    /**
-     * Function determining whether or not to create spans to track outgoing requests to the given URL.
-     * By default, spans will be created for all outgoing requests.
-     */
-    shouldCreateSpanForRequest?: (url: string) => boolean;
-    /**
-     * This option is just for compatibility with v7.
-     * In v8, this will be the default behavior.
-     */
-    enableIfHasTracingEnabled?: boolean;
-}
 interface HttpOptions {
     /**
-     * Whether breadcrumbs should be recorded for requests
+     * Whether breadcrumbs should be recorded for requests.
      * Defaults to true
      */
     breadcrumbs?: boolean;
     /**
-     * Whether tracing spans should be created for requests
-     * Defaults to false
-     */
-    tracing?: TracingOptions | boolean;
-}
-interface HttpIntegrationOptions {
-    /**
-     * Whether breadcrumbs should be recorded for requests
-     * Defaults to true.
-     */
-    breadcrumbs?: boolean;
-    /**
-     * Whether tracing spans should be created for requests
-     * If not set, this will be enabled/disabled based on if tracing is enabled.
-     */
-    tracing?: boolean;
-    /**
-     * Function determining whether or not to create spans to track outgoing requests to the given URL.
-     * By default, spans will be created for all outgoing requests.
-     */
-    shouldCreateSpanForRequest?: (url: string) => boolean;
-}
-/**
- * The http module integration instruments Node's internal http module. It creates breadcrumbs, spans for outgoing
- * http requests, and attaches trace data when tracing is enabled via its `tracing` option.
- *
- * By default, this will always create breadcrumbs, and will create spans if tracing is enabled.
- */
-export declare const httpIntegration: (options?: HttpIntegrationOptions | undefined) => IntegrationFnResult;
-/**
- * The http module integration instruments Node's internal http module. It creates breadcrumbs, transactions for outgoing
- * http requests and attaches trace data when tracing is enabled via its `tracing` option.
- *
- * @deprecated Use `httpIntegration()` instead.
- */
-export declare class Http implements Integration {
-    /**
-     * @inheritDoc
-     */
-    static id: string;
-    /**
-     * @inheritDoc
-     */
-    name: string;
-    private readonly _breadcrumbs;
-    private readonly _tracing;
-    /**
-     * @inheritDoc
+     * Do not capture spans or breadcrumbs for outgoing HTTP requests to URLs where the given callback returns `true`.
+     * This controls both span & breadcrumb creation - spans will be non recording if tracing is disabled.
      */
-    constructor(options?: HttpOptions);
+    ignoreOutgoingRequests?: (url: string) => boolean;
     /**
-     * @inheritDoc
+     * Do not capture spans or breadcrumbs for incoming HTTP requests to URLs where the given callback returns `true`.
+     * This controls both span & breadcrumb creation - spans will be non recording if tracing is disabled.
      */
-    setupOnce(_addGlobalEventProcessor: (callback: EventProcessor) => void, setupOnceGetCurrentHub: () => Hub): void;
+    ignoreIncomingRequests?: (url: string) => boolean;
 }
-/** Exported for tests only. */
-export declare function _shouldCreateSpans(tracingOptions: TracingOptions | undefined, clientOptions: Partial<ClientOptions> | undefined): boolean;
-/** Exported for tests only. */
-export declare function _getShouldCreateSpanForRequest(shouldCreateSpans: boolean, tracingOptions: TracingOptions | undefined, clientOptions: Partial<NodeClientOptions> | undefined): undefined | ((url: string) => boolean);
+export declare const httpIntegration: (options?: HttpOptions | undefined) => import("@sentry/types").IntegrationFnResult;
 export {};
 //# sourceMappingURL=http.d.ts.map

package/types-ts3.8/integrations/local-variables/index.d.ts

@@ -1,13 +1,2 @@
-import { LocalVariablesSync } from './local-variables-sync';
-/**
- * Adds local variables to exception frames.
- *
- * @deprecated Use `localVariablesIntegration()` instead.
- */
-export declare const LocalVariables: import("@sentry/types").IntegrationClass<import("@sentry/types").Integration & {
-    processEvent: (event: import("@sentry/types").Event) => import("@sentry/types").Event;
-    setup: (client: import("../..").NodeClient) => void;
-}> & (new (options?: import("./common").LocalVariablesIntegrationOptions | undefined, session?: import("./local-variables-sync").DebugSession | undefined) => import("@sentry/types").Integration);
-export type LocalVariables = LocalVariablesSync;
 export declare const localVariablesIntegration: (options?: import("./common").LocalVariablesIntegrationOptions | undefined, session?: import("./local-variables-sync").DebugSession | undefined) => import("@sentry/types").IntegrationFnResult;
 //# sourceMappingURL=index.d.ts.map

package/types-ts3.8/integrations/local-variables/local-variables-async.d.ts

@@ -1,5 +1,5 @@
 import { Event, Integration, IntegrationClass } from '@sentry/types';
-import { NodeClient } from '../../client';
+import { NodeClient } from '../../sdk/client';
 import { LocalVariablesIntegrationOptions } from './common';
 export declare const localVariablesAsyncIntegration: (options?: LocalVariablesIntegrationOptions | undefined) => import("@sentry/types").IntegrationFnResult;
 /**

package/types-ts3.8/integrations/local-variables/local-variables-sync.d.ts

@@ -1,6 +1,6 @@
 import { Event, Integration, IntegrationClass } from '@sentry/types';
 import { Debugger, InspectorNotification } from 'inspector';
-import { NodeClient } from '../../client';
+import { NodeClient } from '../../sdk/client';
 import { LocalVariablesIntegrationOptions, Variables } from './common';
 type OnPauseEvent = InspectorNotification<Debugger.PausedEventDataType>;
 export interface DebugSession {

package/types-ts3.8/integrations/modules.d.ts

@@ -1,11 +1,5 @@
-import { Event, Integration, IntegrationClass } from '@sentry/types';
-export declare const modulesIntegration: () => import("@sentry/types").IntegrationFnResult;
 /**
  * Add node modules / packages to the event.
- * @deprecated Use `modulesIntegration()` instead.
  */
-export declare const Modules: IntegrationClass<Integration & {
-    processEvent: (event: Event) => Event;
-}>;
-export type Modules = typeof Modules;
+export declare const modulesIntegration: () => import("@sentry/types").IntegrationFnResult;
 //# sourceMappingURL=modules.d.ts.map

package/types-ts3.8/integrations/node-fetch.d.ts

@@ -0,0 +1,15 @@
+interface NodeFetchOptions {
+    /**
+     * Whether breadcrumbs should be recorded for requests.
+     * Defaults to true
+     */
+    breadcrumbs?: boolean;
+    /**
+     * Do not capture spans or breadcrumbs for outgoing fetch requests to URLs where the given callback returns `true`.
+     * This controls both span & breadcrumb creation - spans will be non recording if tracing is disabled.
+     */
+    ignoreOutgoingRequests?: (url: string) => boolean;
+}
+export declare const nativeNodeFetchIntegration: (options?: NodeFetchOptions | undefined) => import("@sentry/types").IntegrationFnResult;
+export {};
+//# sourceMappingURL=node-fetch.d.ts.map

package/types-ts3.8/integrations/onuncaughtexception.d.ts

@@ -1,5 +1,4 @@
-import { Integration, IntegrationClass } from '@sentry/types';
-import { NodeClient } from '../client';
+import { NodeClient } from '../sdk/client';
 interface OnUncaughtExceptionOptions {
     /**
      * Controls if the SDK should register a handler to exit the process on uncaught errors:
@@ -19,18 +18,10 @@ interface OnUncaughtExceptionOptions {
      */
     onFatalError?(this: void, firstError: Error, secondError?: Error): void;
 }
-export declare const onUncaughtExceptionIntegration: (options?: Partial<OnUncaughtExceptionOptions> | undefined) => import("@sentry/types").IntegrationFnResult;
 /**
- * Global Exception handler.
- * @deprecated Use `onUncaughtExceptionIntegration()` instead.
+ * Add a global exception handler.
  */
-export declare const OnUncaughtException: IntegrationClass<Integration & {
-    setup: (client: NodeClient) => void;
-}> & (new (options?: Partial<{
-    exitEvenIfOtherHandlersAreRegistered: boolean;
-    onFatalError?(this: void, firstError: Error, secondError?: Error): void;
-}> | undefined) => Integration);
-export type OnUncaughtException = typeof OnUncaughtException;
+export declare const onUncaughtExceptionIntegration: (options?: Partial<OnUncaughtExceptionOptions> | undefined) => import("@sentry/types").IntegrationFnResult;
 type ErrorHandler = {
     _errorHandler: boolean;
 } & ((error: Error) => void);

package/types-ts3.8/integrations/onunhandledrejection.d.ts

@@ -1,4 +1,4 @@
-import { Client, Integration, IntegrationClass } from '@sentry/types';
+import { Client } from '@sentry/types';
 type UnhandledRejectionMode = 'none' | 'warn' | 'strict';
 interface OnUnhandledRejectionOptions {
     /**
@@ -7,17 +7,10 @@ interface OnUnhandledRejectionOptions {
      */
     mode: UnhandledRejectionMode;
 }
-export declare const onUnhandledRejectionIntegration: (options?: Partial<OnUnhandledRejectionOptions> | undefined) => import("@sentry/types").IntegrationFnResult;
 /**
- * Global Promise Rejection handler.
- * @deprecated Use `onUnhandledRejectionIntegration()` instead.
+ * Add a global promise rejection handler.
  */
-export declare const OnUnhandledRejection: IntegrationClass<Integration & {
-    setup: (client: Client) => void;
-}> & (new (options?: Partial<{
-    mode: UnhandledRejectionMode;
-}>) => Integration);
-export type OnUnhandledRejection = typeof OnUnhandledRejection;
+export declare const onUnhandledRejectionIntegration: (options?: Partial<OnUnhandledRejectionOptions> | undefined) => import("@sentry/types").IntegrationFnResult;
 /**
  * Send an exception with reason
  * @param reason string

package/types-ts3.8/integrations/spotlight.d.ts

@@ -1,5 +1,4 @@
 import * as http from 'http';
-import { Client, Integration, IntegrationClass } from '@sentry/types';
 type SpotlightConnectionOptions = {
     /**
      * Set this if the Spotlight Sidecar is not running on localhost:8969
@@ -7,22 +6,14 @@ type SpotlightConnectionOptions = {
      */
     sidecarUrl?: string;
 };
-export declare const spotlightIntegration: (options?: Partial<SpotlightConnectionOptions> | undefined) => import("@sentry/types").IntegrationFnResult;
 /**
  * Use this integration to send errors and transactions to Spotlight.
  *
  * Learn more about spotlight at https://spotlightjs.com
  *
  * Important: This integration only works with Node 18 or newer.
- *
- * @deprecated Use `spotlightIntegration()` instead.
  */
-export declare const Spotlight: IntegrationClass<Integration & {
-    setup: (client: Client) => void;
-}> & (new (options?: Partial<{
-    sidecarUrl?: string;
-}>) => Integration);
-export type Spotlight = typeof Spotlight;
+export declare const spotlightIntegration: (options?: Partial<SpotlightConnectionOptions> | undefined) => import("@sentry/types").IntegrationFnResult;
 type HttpRequestImpl = typeof http.request;
 /**
  * We want to get an unpatched http request implementation to avoid capturing our own calls.

package/types-ts3.8/integrations/tracing/express.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="node" />
+import * as http from 'http';
+/**
+ * Express integration
+ *
+ * Capture tracing data for express.
+ * In order to capture exceptions, you have to call `setupExpressErrorHandler(app)` before any other middleware and after all controllers.
+ */
+export declare const expressIntegration: () => import("@sentry/types").IntegrationFnResult;
+interface MiddlewareError extends Error {
+    status?: number | string;
+    statusCode?: number | string;
+    status_code?: number | string;
+    output?: {
+        statusCode?: number | string;
+    };
+}
+type ExpressMiddleware = (error: MiddlewareError, req: http.IncomingMessage, res: http.ServerResponse, next: (error: MiddlewareError) => void) => void;
+/**
+ * An Express-compatible error handler.
+ */
+export declare function expressErrorHandler(options?: {
+    /**
+     * Callback method deciding whether error should be captured and sent to Sentry
+     * @param error Captured middleware error
+     */
+    shouldHandleError?(this: void, error: MiddlewareError): boolean;
+}): ExpressMiddleware;
+/**
+ * Setup an error handler for Express.
+ * The error handler must be before any other middleware and after all controllers.
+ */
+export declare function setupExpressErrorHandler(app: {
+    use: (middleware: ExpressMiddleware) => unknown;
+}): void;
+export {};
+//# sourceMappingURL=express.d.ts.map

package/types-ts3.8/integrations/tracing/fastify.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Express integration
+ *
+ * Capture tracing data for fastify.
+ */
+export declare const fastifyIntegration: () => import("@sentry/types").IntegrationFnResult;
+//# sourceMappingURL=fastify.d.ts.map

package/types-ts3.8/integrations/tracing/graphql.d.ts

@@ -0,0 +1,7 @@
+/**
+ * GraphQL integration
+ *
+ * Capture tracing data for GraphQL.
+ */
+export declare const graphqlIntegration: () => import("@sentry/types").IntegrationFnResult;
+//# sourceMappingURL=graphql.d.ts.map