@depup/sentry__node 10.75.2-depup.0 → 11.0.0-depup.0

package/build/types/integrations/anr/common.d.ts

@@ -0,0 +1,79 @@
+import type { Contexts, DsnComponents, Primitive, SdkMetadata } from '@sentry/core';
+/**
+ * Configuration options for the ANR (Application Not Responding) integration.
+ *
+ * These options control how the ANR detection system monitors the Node.js event loop
+ * and reports blocking events.
+ *
+ * @deprecated The ANR integration has been deprecated. Use `eventLoopBlockIntegration` from `@sentry/node-native` instead.
+ */
+export interface AnrIntegrationOptions {
+    /**
+     * Interval to send heartbeat messages to the ANR worker thread.
+     *
+     * The main thread sends heartbeat messages to the worker thread at this interval
+     * to indicate that the event loop is still responsive. Lower values provide more
+     * precise detection but may increase overhead.
+     *
+     * @default 50 (milliseconds)
+     */
+    pollInterval: number;
+    /**
+     * Threshold in milliseconds to trigger an ANR event.
+     *
+     * When the worker thread doesn't receive a heartbeat message for this duration,
+     * it considers the main thread to be blocked and triggers an ANR event.
+     *
+     * @default 5000 (milliseconds)
+     */
+    anrThreshold: number;
+    /**
+     * Whether to capture a stack trace when the ANR event is triggered.
+     *
+     * When enabled, uses the Node.js inspector API to capture the stack trace
+     * of the blocking code. This provides more detailed information about what
+     * caused the ANR but requires the debugger to be enabled.
+     *
+     * **Note:** This opens the inspector API and required ports.
+     *
+     * @default false
+     */
+    captureStackTrace: boolean;
+    /**
+     * Maximum number of ANR events to send per application session.
+     *
+     * Once this limit is reached, the ANR worker thread will exit to prevent
+     * sending duplicate events. This helps avoid spamming Sentry with repeated
+     * ANR events from the same blocking issue.
+     *
+     * @default 1
+     */
+    maxAnrEvents: number;
+    /**
+     * Static tags to include with all ANR events.
+     *
+     * These tags will be attached to every ANR event sent by this integration,
+     * useful for categorizing or filtering ANR events in Sentry.
+     */
+    staticTags: {
+        [key: string]: Primitive;
+    };
+    /**
+     * @ignore Internal use only.
+     *
+     * If this is supplied, stack frame filenames will be rewritten to be relative to this path.
+     * This is used internally for better stack trace readability.
+     */
+    appRootPath: string | undefined;
+}
+export interface WorkerStartData extends AnrIntegrationOptions {
+    debug: boolean;
+    sdkMetadata: SdkMetadata;
+    dsn: DsnComponents;
+    tunnel: string | undefined;
+    release: string | undefined;
+    environment: string;
+    dist: string | undefined;
+    contexts: Contexts;
+}
+//# sourceMappingURL=common.d.ts.map

package/build/types/integrations/anr/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../../src/integrations/anr/common.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEpF;;;;;;;GAOG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;;;;;OAQG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;;;;;;OAOG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;;;;;;;;;OAUG;IACH,iBAAiB,EAAE,OAAO,CAAC;IAE3B;;;;;;;;OAQG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;;;;OAKG;IACH,UAAU,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,CAAC;IAEzC;;;;;OAKG;IACH,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;CACjC;AAGD,MAAM,WAAW,eAAgB,SAAQ,qBAAqB;IAC5D,KAAK,EAAE,OAAO,CAAC;IACf,WAAW,EAAE,WAAW,CAAC;IACzB,GAAG,EAAE,aAAa,CAAC;IACnB,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,QAAQ,EAAE,QAAQ,CAAC;CACpB"}

package/build/types/integrations/anr/index.d.ts

@@ -0,0 +1,60 @@
+import type { Integration } from '@sentry/core';
+import type { AnrIntegrationOptions } from './common';
+export declare const base64WorkerScript = "###AnrWorkerScript###";
+type AnrInternal = {
+    startWorker: () => void;
+    stopWorker: () => void;
+    waitUntilWorkerReady: () => Promise<void>;
+};
+type AnrReturn = (options?: Partial<AnrIntegrationOptions>) => Integration & AnrInternal;
+/**
+ * Application Not Responding (ANR) integration for Node.js applications.
+ *
+ * @deprecated The ANR integration has been deprecated. Use `eventLoopBlockIntegration` from `@sentry/node-native` instead.
+ *
+ * Detects when the Node.js main thread event loop is blocked for more than the configured
+ * threshold (5 seconds by default) and reports these as Sentry events.
+ *
+ * ANR detection uses a worker thread to monitor the event loop in the main app thread.
+ * The main app thread sends a heartbeat message to the ANR worker thread every 50ms by default.
+ * If the ANR worker does not receive a heartbeat message for the configured threshold duration,
+ * it triggers an ANR event.
+ *
+ * - Node.js 16.17.0 or higher
+ * - Only supported in the Node.js runtime (not browsers)
+ * - Not supported for Node.js clusters
+ *
+ * Overhead should be minimal:
+ * - Main thread: Only polling the ANR worker over IPC every 50ms
+ * - Worker thread: Consumes around 10-20 MB of RAM
+ * - When ANR detected: Brief pause in debugger to capture stack trace (negligible compared to the blocking)
+ *
+ * @example
+ * ```javascript
+ * Sentry.init({
+ *   dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",
+ *   integrations: [
+ *     Sentry.anrIntegration({
+ *       anrThreshold: 5000,
+ *       captureStackTrace: true,
+ *       pollInterval: 50,
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+export declare const anrIntegration: AnrReturn;
+/**
+ * @see {@link disableBlockDetectionForCallback}
+ *
+ * @deprecated The ANR integration has been deprecated. Use `eventLoopBlockIntegration` from `@sentry/node-native` instead.
+ */
+export declare function disableAnrDetectionForCallback<T>(callback: () => T): T;
+/**
+ * @see {@link disableBlockDetectionForCallback}
+ *
+ * @deprecated The ANR integration has been deprecated. Use `eventLoopBlockIntegration` from `@sentry/node-native` instead.
+ */
+export declare function disableAnrDetectionForCallback<T>(callback: () => Promise<T>): Promise<T>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/build/types/integrations/anr/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/integrations/anr/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAA8B,WAAW,EAA4B,MAAM,cAAc,CAAC;AAatG,OAAO,KAAK,EAAE,qBAAqB,EAAmB,MAAM,UAAU,CAAC;AAKvE,eAAO,MAAM,kBAAkB,0BAA0B,CAAC;AA0C1D,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,IAAI,CAAC;IACxB,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB,oBAAoB,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3C,CAAC;AAsDF,KAAK,SAAS,GAAG,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,qBAAqB,CAAC,KAAK,WAAW,GAAG,WAAW,CAAC;AAEzF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,cAAc,EAAyC,SAAS,CAAC;AAkH9E;;;;GAIG;AACH,wBAAgB,8BAA8B,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC;AACxE;;;;GAIG;AACH,wBAAgB,8BAA8B,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC"}

package/build/types/integrations/anr/worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=worker.d.ts.map

package/build/types/integrations/anr/worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../../../../src/integrations/anr/worker.ts"],"names":[],"mappings":""}

package/build/types/integrations/childProcess.d.ts

@@ -0,0 +1,17 @@
+interface Options {
+    /**
+     * Whether to include child process arguments in breadcrumbs data.
+     *
+     * @default false
+     */
+    includeChildProcessArgs?: boolean;
+}
+/**
+ * Capture breadcrumbs and events for child processes.
+ * For worker thread events, use `workerThreadsIntegration()` instead.
+ */
+export declare const childProcessIntegration: (options?: Options | undefined) => import("@sentry/core").Integration & {
+    name: "ChildProcess";
+};
+export {};
+//# sourceMappingURL=childProcess.d.ts.map

package/build/types/integrations/childProcess.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"childProcess.d.ts","sourceRoot":"","sources":["../../../src/integrations/childProcess.ts"],"names":[],"mappings":"AAIA,UAAU,OAAO;IACf;;;;OAIG;IACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC;AAID;;;GAGG;AACH,eAAO,MAAM,uBAAuB;;CAWlC,CAAC"}

package/build/types/integrations/console.d.ts

@@ -0,0 +1,23 @@
+import type { ConsoleLevel } from '@sentry/core';
+interface ConsoleIntegrationOptions {
+    levels: ConsoleLevel[];
+    /**
+     * Filter out console messages that match the given strings or regular expressions.
+     * These will neither be passed to the handler, and they will also not be logged to the user, unless they have debug enabled.
+     */
+    filter?: (string | RegExp)[];
+}
+/**
+ * Node-specific console integration that captures breadcrumbs and handles
+ * the AWS Lambda runtime replacing console methods after our patch.
+ *
+ * In Lambda, console methods are patched via `Object.defineProperty` so that
+ * external replacements (by the Lambda runtime) are absorbed as the delegate
+ * while our wrapper stays in place. Outside Lambda, this delegates entirely
+ * to the core `consoleIntegration` which uses the simpler `fill`-based patch.
+ */
+export declare const consoleIntegration: (options?: Partial<ConsoleIntegrationOptions> | undefined) => import("@sentry/core").Integration & {
+    name: "Console";
+};
+export {};
+//# sourceMappingURL=console.d.ts.map

package/build/types/integrations/console.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console.d.ts","sourceRoot":"","sources":["../../../src/integrations/console.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAmB,MAAM,cAAc,CAAC;AAalE,UAAU,yBAAyB;IACjC,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB;;;OAGG;IACH,MAAM,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;CAC9B;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB;;CAoB7B,CAAC"}

package/build/types/integrations/context.d.ts

@@ -0,0 +1,33 @@
+import { readdir, readFile } from 'node:fs';
+import type { AppContext, Contexts, DeviceContext } from '@sentry/core';
+export declare const readFileAsync: typeof readFile.__promisify__;
+export declare const readDirAsync: typeof readdir.__promisify__;
+interface DeviceContextOptions {
+    cpu?: boolean;
+    memory?: boolean;
+}
+interface ContextOptions {
+    app?: boolean;
+    os?: boolean;
+    device?: DeviceContextOptions | boolean;
+    culture?: boolean;
+    cloudResource?: boolean;
+}
+/**
+ * Capture context about the environment and the device that the client is running on, to events.
+ */
+export declare const nodeContextIntegration: (options?: ContextOptions | undefined) => import("@sentry/core").Integration & {
+    name: "Context";
+};
+export declare function contextsToSpanAttributes(contexts: Contexts): Record<string, unknown>;
+export declare function getDynamicSpanAttributes(appContext: AppContext | undefined, deviceContext: DeviceContext | undefined): Record<string, unknown>;
+/**
+ * Get app context information from process
+ */
+export declare function getAppContext(): AppContext;
+/**
+ * Gets device information from os
+ */
+export declare function getDeviceContext(deviceOpt: DeviceContextOptions | true): DeviceContext;
+export {};
+//# sourceMappingURL=context.d.ts.map

package/build/types/integrations/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/integrations/context.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAI5C,OAAO,KAAK,EACV,UAAU,EAEV,QAAQ,EAER,aAAa,EAId,MAAM,cAAc,CAAC;AAGtB,eAAO,MAAM,aAAa,+BAAsB,CAAC;AACjD,eAAO,MAAM,YAAY,8BAAqB,CAAC;AAU/C,UAAU,oBAAoB;IAC5B,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,UAAU,cAAc;IACtB,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,EAAE,CAAC,EAAE,OAAO,CAAC;IACb,MAAM,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC;IACxC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAuFD;;GAEG;AACH,eAAO,MAAM,sBAAsB;;CAA6C,CAAC;AA0BjF,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAkEpF;AAED,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,UAAU,GAAG,SAAS,EAClC,aAAa,EAAE,aAAa,GAAG,SAAS,GACvC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAmBzB;AA2DD;;GAEG;AACH,wBAAgB,aAAa,IAAI,UAAU,CAe1C;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,oBAAoB,GAAG,IAAI,GAAG,aAAa,CAqCtF"}

package/build/types/integrations/contextlines.d.ts

@@ -0,0 +1,35 @@
+import type { Event, StackFrame } from '@sentry/core';
+export declare const MAX_CONTEXTLINES_COLNO: number;
+export declare const MAX_CONTEXTLINES_LINENO: number;
+interface ContextLinesOptions {
+    /**
+     * Sets the number of context lines for each frame when loading a file.
+     * Defaults to `dataCollection.frameContextLines` (5).
+     *
+     * Set to 0 to disable loading and inclusion of source files.
+     *
+     * When set, this option takes precedence over `dataCollection.frameContextLines`.
+     **/
+    frameContextLines?: number;
+}
+/**
+ * Exported for testing purposes.
+ */
+export declare function resetFileContentCache(): void;
+/**
+ * Resolves context lines before and after the given line number and appends them to the frame;
+ */
+export declare function addContextToFrame(lineno: number, frame: StackFrame, contextLines: number, contents: Record<number, string> | undefined): void;
+/** Exported only for tests, as a type-safe variant. */
+export declare const _contextLinesIntegration: (options?: ContextLinesOptions) => {
+    name: "ContextLines";
+    processEvent(event: Event, _hint: import("@sentry/core").EventHint, client: import("@sentry/core").Client<import("@sentry/core").ClientOptions<import("@sentry/core").BaseTransportOptions>>): Promise<Event>;
+};
+/**
+ * Capture the lines before and after the frame's context.
+ */
+export declare const contextLinesIntegration: (options?: ContextLinesOptions | undefined) => import("@sentry/core").Integration & {
+    name: "ContextLines";
+};
+export {};
+//# sourceMappingURL=contextlines.d.ts.map

package/build/types/integrations/contextlines.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contextlines.d.ts","sourceRoot":"","sources":["../../../src/integrations/contextlines.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAiB,UAAU,EAAE,MAAM,cAAc,CAAC;AAWrE,eAAO,MAAM,sBAAsB,EAAE,MAAa,CAAC;AACnD,eAAO,MAAM,uBAAuB,EAAE,MAAc,CAAC;AAErD,UAAU,mBAAmB;IAC3B;;;;;;;QAOI;IACJ,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAE5C;AA0SD;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,UAAU,EACjB,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,GAC3C,IAAI,CA2CN;AAkBD,uDAAuD;AACvD,eAAO,MAAM,wBAAwB,aAAc,mBAAmB;;;CAS5C,CAAC;AAE3B;;GAEG;AACH,eAAO,MAAM,uBAAuB;;CAA8C,CAAC"}

package/build/types/integrations/featureFlagShims/openFeature.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"openFeature.d.ts","sourceRoot":"","sources":["../../../../src/integrations/featureFlagShims/openFeature.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,eAAO,MAAM,0BAA0B;;CAWrC,CAAC;AAEH;;GAEG;AACH,qBAAa,8BAA8B;IACzC;;OAEG;;IAUH;;OAEG;IACI,KAAK,IAAI,IAAI;IAIpB;;OAEG;IACI,KAAK,IAAI,IAAI;CAGrB"}
+{"version":3,"file":"openFeature.d.ts","sourceRoot":"","sources":["../../../../src/integrations/featureFlagShims/openFeature.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,eAAO,MAAM,0BAA0B;;CAWrC,CAAC;AAEH;;GAEG;AACH,qBAAa,8BAA8B;IACzC;;OAEG;IACH,cAOC;IAED;;OAEG;IACI,KAAK,IAAI,IAAI,CAEnB;IAED;;OAEG;IACI,KAAK,IAAI,IAAI,CAEnB;CACF"}

package/build/types/integrations/fs/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/integrations/fs/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AAIhE;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa;;CAOxB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/integrations/fs/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AAIhE;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa;;CAUxB,CAAC"}

package/build/types/integrations/fs/vendored/instrumentation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/fs/vendored/instrumentation.ts"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAAqB,uBAAuB,EAAmB,MAAM,SAAS,CAAC;AA+P3F,wBAAgB,uBAAuB,CAAC,MAAM,GAAE,uBAA4B,GAAG,IAAI,CAqBlF"}
+{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/fs/vendored/instrumentation.ts"],"names":[],"mappings":"AAgCA,OAAO,KAAK,EAAqB,uBAAuB,EAAmB,MAAM,SAAS,CAAC;AA+P3F,wBAAgB,uBAAuB,CAAC,MAAM,GAAE,uBAA4B,GAAG,IAAI,CAqBlF"}

package/build/types/integrations/http/SentryHttpInstrumentation.d.ts

@@ -0,0 +1,48 @@
+import type { ClientRequest, IncomingMessage } from 'node:http';
+import type { Span } from '@sentry/core';
+import type { HttpClientRequest, HttpIncomingMessage } from '@sentry/core/server';
+import * as http from 'node:http';
+export interface OutgoingHttpRequestInstrumentationOptions {
+    /**
+     * Whether breadcrumbs should be recorded for outgoing requests.
+     *
+     * @default `true`
+     */
+    breadcrumbs?: boolean;
+    /**
+     * Whether to create spans for outgoing requests.
+     *
+     * @default `true`
+     */
+    spans?: boolean;
+    /**
+     * Whether to propagate Sentry trace headers in outgoing requests.
+     *
+     * @default `true`
+     */
+    tracePropagation?: boolean;
+    /**
+     * Do not instrument outgoing HTTP requests to URLs where the given callback returns `true`.
+     * When it returns `true`, the request is skipped entirely: no breadcrumb and no span are created,
+     * and no trace headers are propagated for that request.
+     *
+     * @param url Contains the entire URL, including query string (if any), protocol, host, etc. of the outgoing request.
+     * @param request Contains the {@type RequestOptions} object used to make the outgoing request.
+     */
+    ignoreOutgoingRequests?: (url: string, request: http.RequestOptions) => boolean;
+    /**
+     * Hooks for outgoing request spans, only called when spans are created for outgoing requests
+     * (i.e. when `spans` is enabled).
+     */
+    outgoingRequestHook?: (span: Span, request: ClientRequest) => void;
+    outgoingResponseHook?: (span: Span, response: IncomingMessage) => void;
+    outgoingRequestApplyCustomAttributes?: (span: Span, request: HttpClientRequest, response: HttpIncomingMessage) => void;
+}
+/**
+ * This instruments the http modules for outgoing requests.
+ * It uses the diagnostics channel if available, otherwise it falls back to monkey-patching.
+ *
+ * The instrumentation will start spans, create breadcrumbs, and propagate trace headers in outgoing requests (depending on the settings).
+ */
+export declare function instrumentHttpOutgoingRequests(instrumentationOptions?: OutgoingHttpRequestInstrumentationOptions): void;
+//# sourceMappingURL=SentryHttpInstrumentation.d.ts.map

package/build/types/integrations/http/SentryHttpInstrumentation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SentryHttpInstrumentation.d.ts","sourceRoot":"","sources":["../../../../src/integrations/http/SentryHttpInstrumentation.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAChE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,OAAO,KAAK,EAAE,iBAAiB,EAAE,mBAAmB,EAA8B,MAAM,qBAAqB,CAAC;AAS9G,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAOlC,MAAM,WAAW,yCAAyC;IACxD;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;;;OAIG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B;;;;;;;OAOG;IACH,sBAAsB,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,cAAc,KAAK,OAAO,CAAC;IAEhF;;;OAGG;IACH,mBAAmB,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,aAAa,KAAK,IAAI,CAAC;IACnE,oBAAoB,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,eAAe,KAAK,IAAI,CAAC;IACvE,oCAAoC,CAAC,EAAE,CACrC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,iBAAiB,EAC1B,QAAQ,EAAE,mBAAmB,KAC1B,IAAI,CAAC;CACX;AAED;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAC5C,sBAAsB,GAAE,yCAA8C,GACrE,IAAI,CAiDN"}

package/build/types/integrations/http/httpServerIntegration.d.ts

@@ -0,0 +1,68 @@
+import type { RequestOptions } from 'node:http';
+import type { Integration } from '@sentry/core';
+import type { HttpIncomingMessage } from '@sentry/core/server';
+import { recordRequestSession } from '@sentry/core/server';
+export { recordRequestSession };
+interface WeakRefImpl<T> {
+    deref(): T | undefined;
+}
+type StartSpanCallback = (next: () => boolean) => boolean;
+type RequestWithOptionalStartSpanCallback = HttpIncomingMessage & {
+    _startSpanCallback?: WeakRefImpl<StartSpanCallback>;
+};
+export interface HttpServerIntegrationOptions {
+    /**
+     * Whether the integration should create [Sessions](https://docs.sentry.io/product/releases/health/#sessions) for incoming requests to track the health and crash-free rate of your releases in Sentry.
+     * Read more about Release Health: https://docs.sentry.io/product/releases/health/
+     *
+     * Defaults to `true`.
+     */
+    sessions?: boolean;
+    /**
+     * Number of milliseconds until sessions tracked with `sessions` will be flushed as a session aggregate.
+     *
+     * Defaults to `60000` (60s).
+     */
+    sessionFlushingDelayMS?: number;
+    /**
+     * Do not capture the request body for incoming HTTP requests to URLs where the given callback returns `true`.
+     * This can be useful for long running requests where the body is not needed and we want to avoid capturing it.
+     *
+     * @param url Contains the entire URL, including query string (if any), protocol, host, etc. of the incoming request.
+     * @param request Contains the {@type RequestOptions} object used to make the incoming request.
+     */
+    ignoreRequestBody?: (url: string, request: RequestOptions) => boolean;
+    /**
+     * Controls the maximum size of incoming HTTP request bodies attached to events.
+     *
+     * Available options:
+     * - 'none': No request bodies will be attached
+     * - 'small': Request bodies up to 1,000 bytes will be attached
+     * - 'medium': Request bodies up to 10,000 bytes will be attached (default)
+     * - 'always': Request bodies will always be attached
+     *
+     * Note that even with 'always' setting, bodies exceeding 1MB will never be attached
+     * for performance and security reasons.
+     *
+     * @default 'medium'
+     */
+    maxRequestBodySize?: 'none' | 'small' | 'medium' | 'always';
+}
+/**
+ * Add a callback to the request object that will be called when the request is started.
+ * The callback will receive the next function to continue processing the request.
+ */
+export declare function addStartSpanCallback(request: RequestWithOptionalStartSpanCallback, callback: StartSpanCallback): void;
+/**
+ * This integration handles request isolation, trace continuation and other core Sentry functionality around incoming http requests
+ * handled via the node `http` module.
+ *
+ * This version uses OpenTelemetry for context propagation and span management.
+ *
+ * @see {@link ../../light/integrations/httpServerIntegration.ts} for the lightweight version without OpenTelemetry
+ */
+export declare const httpServerIntegration: (options?: HttpServerIntegrationOptions) => Integration & {
+    name: 'Http.Server';
+    setupOnce: () => void;
+};
+//# sourceMappingURL=httpServerIntegration.d.ts.map

package/build/types/integrations/http/httpServerIntegration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"httpServerIntegration.d.ts","sourceRoot":"","sources":["../../../../src/integrations/http/httpServerIntegration.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAEhD,OAAO,KAAK,EAAE,WAAW,EAAiB,MAAM,cAAc,CAAC;AAE/D,OAAO,KAAK,EAAE,mBAAmB,EAAsB,MAAM,qBAAqB,CAAC;AACnF,OAAO,EAAsD,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAK/G,OAAO,EAAE,oBAAoB,EAAE,CAAC;AAMhC,UAAU,WAAW,CAAC,CAAC;IACrB,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;CACxB;AAED,KAAK,iBAAiB,GAAG,CAAC,IAAI,EAAE,MAAM,OAAO,KAAK,OAAO,CAAC;AAC1D,KAAK,oCAAoC,GAAG,mBAAmB,GAAG;IAChE,kBAAkB,CAAC,EAAE,WAAW,CAAC,iBAAiB,CAAC,CAAC;CACrD,CAAC;AAEF,MAAM,WAAW,4BAA4B;IAC3C;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;;;OAIG;IACH,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAEhC;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,KAAK,OAAO,CAAC;IAEtE;;;;;;;;;;;;;OAaG;IACH,kBAAkB,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,CAAC;CAC7D;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,oCAAoC,EAAE,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAErH;AAmFD;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,EAA6B,CAC7D,OAAO,CAAC,EAAE,4BAA4B,KACnC,WAAW,GAAG;IACjB,IAAI,EAAE,aAAa,CAAC;IACpB,SAAS,EAAE,MAAM,IAAI,CAAC;CACvB,CAAC"}

package/build/types/integrations/http/httpServerSpansIntegration.d.ts

@@ -0,0 +1,59 @@
+import type { Event, Integration, Span } from '@sentry/core';
+import type { HttpIncomingMessage, HttpServerResponse } from '@sentry/core/server';
+import type { NodeClient } from '../../sdk/client';
+export interface HttpServerSpansIntegrationOptions {
+    /**
+     * Do not capture spans for incoming HTTP requests to URLs where the given callback returns `true`.
+     * Spans will be non recording if tracing is disabled.
+     *
+     * The `urlPath` param consists of the URL path and query string (if any) of the incoming request.
+     * For example: `'/users/details?id=123'`
+     *
+     * The `request` param contains the original {@type IncomingMessage} object of the incoming request.
+     * You can use it to filter on additional properties like method, headers, etc.
+     */
+    ignoreIncomingRequests?: (urlPath: string, request: HttpIncomingMessage) => boolean;
+    /**
+     * Whether to automatically ignore common static asset requests like favicon.ico, robots.txt, etc.
+     * This helps reduce noise in your transactions.
+     *
+     * @default `true`
+     */
+    ignoreStaticAssets?: boolean;
+    /**
+     * Do not capture spans for incoming HTTP requests with the given status codes.
+     * By default, spans with some 3xx and 4xx status codes are ignored (see @default).
+     * Expects an array of status codes or a range of status codes, e.g. [[300,399], 404] would ignore 3xx and 404 status codes.
+     *
+     * Important: This option is ignored by default! It only has an effect if `traceLifecycle` is set to `'static'`.
+     *
+     * @default `[[401, 404], [301, 303], [305, 399]]`
+     *
+     * @deprecated This option only has an effect if `traceLifecycle` is set to `'static'`. With span streaming
+     * (`traceLifecycle: 'stream'`, the default), the SDK ignores it: child spans are sent as they end, before the
+     * response status code is known, so a request's spans cannot be dropped retroactively. `ignoreStatusCodes` will be
+     * removed in v12 of the SDK, without replacement.
+     */
+    ignoreStatusCodes?: (number | [number, number])[];
+    /**
+     * A hook that can be used to mutate the span for incoming requests.
+     * This is triggered after the span is created, but before it is recorded.
+     */
+    onSpanCreated?: (span: Span, request: HttpIncomingMessage, response: HttpServerResponse) => void;
+}
+/**
+ * This integration emits spans for incoming requests handled via the node `http` module.
+ * It requires the `httpServerIntegration` to be present.
+ */
+export declare const httpServerSpansIntegration: (options?: HttpServerSpansIntegrationOptions) => Integration & {
+    name: 'Http.ServerSpans';
+    setup: (client: NodeClient) => void;
+    processEvent: (event: Event) => Event | null;
+};
+/**
+ * Check if a request is for a common static asset that should be ignored by default.
+ *
+ * Only exported for tests.
+ */
+export declare function isStaticAssetRequest(urlPath: string): boolean;
+//# sourceMappingURL=httpServerSpansIntegration.d.ts.map

package/build/types/integrations/http/httpServerSpansIntegration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"httpServerSpansIntegration.d.ts","sourceRoot":"","sources":["../../../../src/integrations/http/httpServerSpansIntegration.ts"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAiB,IAAI,EAA8B,MAAM,cAAc,CAAC;AACxG,OAAO,KAAK,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAuBnF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAQnD,MAAM,WAAW,iCAAiC;IAChD;;;;;;;;;OASG;IACH,sBAAsB,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,mBAAmB,KAAK,OAAO,CAAC;IAEpF;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAE7B;;;;;;;;;;;;;OAaG;IACH,iBAAiB,CAAC,EAAE,CAAC,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC;IAElD;;;OAGG;IACH,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,mBAAmB,EAAE,QAAQ,EAAE,kBAAkB,KAAK,IAAI,CAAC;CAClG;AAmJD;;;GAGG;AACH,eAAO,MAAM,0BAA0B,EAAkC,CACvE,OAAO,CAAC,EAAE,iCAAiC,KACxC,WAAW,GAAG;IACjB,IAAI,EAAE,kBAAkB,CAAC;IACzB,KAAK,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,IAAI,CAAC;IACpC,YAAY,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,KAAK,GAAG,IAAI,CAAC;CAC9C,CAAC;AAOF;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAa7D"}

package/build/types/integrations/http/index.d.ts

@@ -0,0 +1,69 @@
+import type { RequestOptions } from 'node:http';
+import type { HttpServerIntegrationOptions } from './httpServerIntegration';
+import type { HttpServerSpansIntegrationOptions } from './httpServerSpansIntegration';
+import type { OutgoingHttpRequestInstrumentationOptions } from './SentryHttpInstrumentation';
+interface HttpOptions extends HttpServerIntegrationOptions, HttpServerSpansIntegrationOptions {
+    /**
+     * Whether breadcrumbs should be recorded for outgoing requests.
+     * Defaults to true
+     */
+    breadcrumbs?: boolean;
+    /**
+     * If set to false, do not emit any spans.
+     * This will ensure that the default HttpInstrumentation from OpenTelemetry is not setup,
+     * only the Sentry-specific instrumentation for request isolation is applied.
+     *
+     * Defaults to `true` when tracing is enabled.
+     */
+    spans?: boolean;
+    /**
+     * Whether to inject trace propagation headers (sentry-trace, baggage, traceparent) into outgoing HTTP requests.
+     *
+     * When set to `false`, Sentry will not inject any trace propagation headers, but will still create breadcrumbs
+     * (if `breadcrumbs` is enabled). This is useful when you run your own OpenTelemetry `HttpInstrumentation` and
+     * want to avoid duplicate trace headers being injected by both Sentry and OpenTelemetry.
+     *
+     * @default `true`
+     */
+    tracePropagation?: boolean;
+    /**
+     * 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.
+     *
+     * The `url` param contains the entire URL, including query string (if any), protocol, host, etc. of the outgoing request.
+     * For example: `'https://someService.com/users/details?id=123'`
+     *
+     * The `request` param contains the original {@type RequestOptions} object used to make the outgoing request.
+     * You can use it to filter on additional properties like method, headers, etc.
+     */
+    ignoreOutgoingRequests?: (url: string, request: RequestOptions) => boolean;
+    /**
+     * If true, do not generate spans for incoming requests at all.
+     * This is used by Remix to avoid generating spans for incoming requests, as it generates its own spans.
+     */
+    disableIncomingRequestSpans?: boolean;
+    /**
+     * Called after an outgoing request span is created.
+     * Only invoked when spans are created for outgoing requests.
+     */
+    outgoingRequestHook?: OutgoingHttpRequestInstrumentationOptions['outgoingRequestHook'];
+    /**
+     * Called when the outgoing request receives a response.
+     * Only invoked when spans are created for outgoing requests.
+     */
+    outgoingResponseHook?: OutgoingHttpRequestInstrumentationOptions['outgoingResponseHook'];
+    /**
+     * Called when both the outgoing request and response are available.
+     * Only invoked when spans are created for outgoing requests.
+     */
+    outgoingRequestApplyCustomAttributes?: OutgoingHttpRequestInstrumentationOptions['outgoingRequestApplyCustomAttributes'];
+}
+/**
+ * The http integration instruments Node's internal http and https modules.
+ * It creates breadcrumbs and spans for outgoing HTTP requests which will be attached to the currently active span.
+ */
+export declare const httpIntegration: (options?: HttpOptions | undefined) => import("@sentry/core").Integration & {
+    name: "Http";
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

package/build/types/integrations/http/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/integrations/http/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,cAAc,EAAE,MAAM,WAAW,CAAC;AAY/D,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,yBAAyB,CAAC;AAE5E,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,8BAA8B,CAAC;AAEtF,OAAO,KAAK,EAAE,yCAAyC,EAAE,MAAM,6BAA6B,CAAC;AAK7F,UAAU,WAAY,SAAQ,4BAA4B,EAAE,iCAAiC;IAC3F;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB;;;;;;;;OAQG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B;;;;;;;;;OASG;IACH,sBAAsB,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,KAAK,OAAO,CAAC;IAE3E;;;OAGG;IACH,2BAA2B,CAAC,EAAE,OAAO,CAAC;IAEtC;;;OAGG;IACH,mBAAmB,CAAC,EAAE,yCAAyC,CAAC,qBAAqB,CAAC,CAAC;IAEvF;;;OAGG;IACH,oBAAoB,CAAC,EAAE,yCAAyC,CAAC,sBAAsB,CAAC,CAAC;IAEzF;;;OAGG;IACH,oCAAoC,CAAC,EAAE,yCAAyC,CAAC,sCAAsC,CAAC,CAAC;CAC1H;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe;;CA0D1B,CAAC"}

package/build/types/integrations/local-variables/common.d.ts

@@ -0,0 +1,79 @@
+import type { Debugger } from 'node:inspector';
+import type { CollectBehavior } from '@sentry/core';
+export type Variables = Record<string, unknown>;
+/**
+ * Filters captured frame variables by name according to a `dataCollection.stackFrameVariables` behavior.
+ *
+ * `true` keeps all variables (built-in sensitive names are still scrubbed), `false` drops them all, and the
+ * `{ allow: [...] }` / `{ deny: [...] }` forms filter by variable name.
+ */
+export declare function filterFrameVariables(vars: Variables, behavior: CollectBehavior): Variables;
+export type RateLimitIncrement = () => void;
+/**
+ * The key used to store the local variables on the error object.
+ */
+export declare const LOCAL_VARIABLES_KEY = "__SENTRY_ERROR_LOCAL_VARIABLES__";
+/**
+ * Creates a rate limiter that will call the disable callback when the rate limit is reached and the enable callback
+ * when a timeout has occurred.
+ * @param maxPerSecond Maximum number of calls per second
+ * @param enable Callback to enable capture
+ * @param disable Callback to disable capture
+ * @returns A function to call to increment the rate limiter count
+ */
+export declare function createRateLimiter(maxPerSecond: number, enable: () => void, disable: (seconds: number) => void): RateLimitIncrement;
+export type PausedExceptionEvent = Debugger.PausedEventDataType & {
+    data: {
+        description: string;
+        objectId?: string;
+    };
+};
+/** Could this be an anonymous function? */
+export declare function isAnonymous(name: string | undefined): boolean;
+/** Do the function names appear to match? */
+export declare function functionNamesMatch(a: string | undefined, b: string | undefined): boolean;
+export interface FrameVariables {
+    function: string;
+    vars?: Variables;
+}
+export interface LocalVariablesIntegrationOptions {
+    /**
+     * 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.
+     */
+    captureAllExceptions?: boolean;
+    /**
+     * Maximum number of exceptions to capture local variables for per second before rate limiting is triggered.
+     */
+    maxExceptionsPerSecond?: number;
+    /**
+     * When true, local variables will be captured for all frames, including those that are not in_app.
+     *
+     * Defaults to `false`.
+     */
+    includeOutOfAppFrames?: boolean;
+}
+export interface LocalVariablesWorkerArgs extends LocalVariablesIntegrationOptions {
+    /**
+     * Whether to enable debug logging.
+     */
+    debug: boolean;
+    /**
+     * Base path used to calculate module name.
+     *
+     * Defaults to `dirname(process.argv[1])` and falls back to `process.cwd()`
+     */
+    basePath?: string;
+}
+//# sourceMappingURL=common.d.ts.map