@sentry/node 10.69.0 → 11.0.0-alpha.0

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

@@ -0,0 +1,67 @@
+import type { RequestOptions } from 'node:http';
+import type { HttpIncomingMessage, Integration } from '@sentry/core';
+import { recordRequestSession } from '@sentry/core';
+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 `trackIncomingRequestsAsSessions` 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,mBAAmB,EAAsB,WAAW,EAAiB,MAAM,cAAc,CAAC;AACxG,OAAO,EAML,oBAAoB,EACrB,MAAM,cAAc,CAAC;AAKtB,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, HttpClientRequest, HttpIncomingMessage, HttpServerResponse, Integration, Span } from '@sentry/core';
+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.
+     *
+     * @default `[[401, 404], [301, 303], [305, 399]]`
+     */
+    ignoreStatusCodes?: (number | [number, number])[];
+    /**
+     * @deprecated This is deprecated in favor of `incomingRequestSpanHook`.
+     */
+    instrumentation?: {
+        requestHook?: (span: Span, req: HttpClientRequest | HttpIncomingMessage) => void;
+        responseHook?: (span: Span, response: HttpIncomingMessage | HttpServerResponse) => void;
+        applyCustomAttributesOnSpan?: (span: Span, request: HttpClientRequest | HttpIncomingMessage, response: HttpIncomingMessage | HttpServerResponse) => void;
+    };
+    /**
+     * A hook that can be used to mutate the span for incoming requests.
+     * This is triggered after the span is created, but before it is recorded.
+     */
+    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":"AA0BA,OAAO,KAAK,EACV,KAAK,EACL,iBAAiB,EACjB,mBAAmB,EACnB,kBAAkB,EAClB,WAAW,EAEX,IAAI,EAGL,MAAM,cAAc,CAAC;AAqBtB,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;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,CAAC,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC;IAElD;;OAEG;IACH,eAAe,CAAC,EAAE;QAChB,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,iBAAiB,GAAG,mBAAmB,KAAK,IAAI,CAAC;QACjF,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,mBAAmB,GAAG,kBAAkB,KAAK,IAAI,CAAC;QACxF,2BAA2B,CAAC,EAAE,CAC5B,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,iBAAiB,GAAG,mBAAmB,EAChD,QAAQ,EAAE,mBAAmB,GAAG,kBAAkB,KAC/C,IAAI,CAAC;KACX,CAAC;IAEF;;;OAGG;IACH,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,mBAAmB,EAAE,QAAQ,EAAE,kBAAkB,KAAK,IAAI,CAAC;CAClG;AAmLD;;;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,127 @@
+import type { RequestOptions } from 'node:http';
+import type { HttpClientRequest, HttpIncomingMessage, HttpServerResponse, Span } from '@sentry/core';
+interface HttpOptions {
+    /**
+     * 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 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`.
+     */
+    trackIncomingRequestsAsSessions?: boolean;
+    /**
+     * Number of milliseconds until sessions tracked with `trackIncomingRequestsAsSessions` will be flushed as a session aggregate.
+     *
+     * Defaults to `60000` (60s).
+     */
+    sessionFlushingDelayMS?: number;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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.
+     */
+    incomingRequestSpanHook?: (span: Span, request: HttpIncomingMessage, response: HttpServerResponse) => void;
+    /**
+     * 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.
+     *
+     * @default `[[401, 404], [301, 303], [305, 399]]`
+     */
+    dropSpansForIncomingRequestStatusCodes?: (number | [number, 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.
+     */
+    ignoreIncomingRequestBody?: (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'
+     */
+    maxIncomingRequestBodySize?: 'none' | 'small' | 'medium' | 'always';
+    /**
+     * 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;
+    /**
+     * Additional instrumentation options that are passed to the underlying HttpInstrumentation.
+     */
+    instrumentation?: {
+        requestHook?: (span: Span, req: HttpIncomingMessage | HttpClientRequest) => void;
+        responseHook?: (span: Span, response: HttpIncomingMessage | HttpServerResponse) => void;
+        applyCustomAttributesOnSpan?: (span: Span, request: HttpIncomingMessage | HttpClientRequest, response: HttpIncomingMessage | HttpServerResponse) => void;
+    };
+}
+/**
+ * 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,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,KAAK,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAqBrG,UAAU,WAAW;IACnB;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB;;;;;OAKG;IACH,+BAA+B,CAAC,EAAE,OAAO,CAAC;IAE1C;;;;OAIG;IACH,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAEhC;;;;;;;;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;;;;;;;;;OASG;IACH,sBAAsB,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,mBAAmB,KAAK,OAAO,CAAC;IAEpF;;;OAGG;IACH,uBAAuB,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,mBAAmB,EAAE,QAAQ,EAAE,kBAAkB,KAAK,IAAI,CAAC;IAE3G;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAE7B;;;;;;OAMG;IACH,sCAAsC,CAAC,EAAE,CAAC,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC;IAEvE;;;;;;OAMG;IACH,yBAAyB,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,KAAK,OAAO,CAAC;IAE9E;;;;;;;;;;;;;OAaG;IACH,0BAA0B,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,CAAC;IAEpE;;;OAGG;IACH,2BAA2B,CAAC,EAAE,OAAO,CAAC;IAEtC;;OAEG;IACH,eAAe,CAAC,EAAE;QAChB,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,mBAAmB,GAAG,iBAAiB,KAAK,IAAI,CAAC;QACjF,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,mBAAmB,GAAG,kBAAkB,KAAK,IAAI,CAAC;QACxF,2BAA2B,CAAC,EAAE,CAC5B,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,mBAAmB,GAAG,iBAAiB,EAChD,QAAQ,EAAE,mBAAmB,GAAG,kBAAkB,KAC/C,IAAI,CAAC;KACX,CAAC;CACH;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe;;CAyE1B,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../../src/integrations/local-variables/common.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAGpD,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEhD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,eAAe,GAAG,SAAS,CAE1F;AAED,MAAM,MAAM,kBAAkB,GAAG,MAAM,IAAI,CAAC;AAE5C;;GAEG;AACH,eAAO,MAAM,mBAAmB,qCAAqC,CAAC;AAEtE;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,MAAM,IAAI,EAClB,OAAO,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,GACjC,kBAAkB,CA+BpB;AAGD,MAAM,MAAM,oBAAoB,GAAG,QAAQ,CAAC,mBAAmB,GAAG;IAChE,IAAI,EAAE;QAEJ,WAAW,EAAE,MAAM,CAAC;QACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;CACH,CAAC;AAEF,2CAA2C;AAC3C,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAE7D;AAED,6CAA6C;AAC7C,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,GAAG,SAAS,EAAE,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAExF;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,SAAS,CAAC;CAClB;AAED,MAAM,WAAW,gCAAgC;IAC/C;;;;;;;;;;;;;;OAcG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B;;OAEG;IACH,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC;;;;OAIG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC;AAED,MAAM,WAAW,wBAAyB,SAAQ,gCAAgC;IAChF;;OAEG;IACH,KAAK,EAAE,OAAO,CAAC;IACf;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB"}

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

@@ -0,0 +1,4 @@
+import type { Integration } from '@sentry/core';
+import type { LocalVariablesIntegrationOptions } from './common';
+export declare const localVariablesIntegration: (options?: LocalVariablesIntegrationOptions) => Integration;
+//# sourceMappingURL=index.d.ts.map

package/build/types/integrations/local-variables/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/integrations/local-variables/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,UAAU,CAAC;AAGjE,eAAO,MAAM,yBAAyB,aAAa,gCAAgC,KAAQ,WAE1F,CAAC"}

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

@@ -0,0 +1,9 @@
+import type { LocalVariablesIntegrationOptions } from './common';
+export declare const base64WorkerScript = "###LocalVariablesWorkerScript###";
+/**
+ * Adds local variables to exception frames
+ */
+export declare const localVariablesAsyncIntegration: (integrationOptions?: LocalVariablesIntegrationOptions | undefined) => import("@sentry/core").Integration & {
+    name: "LocalVariablesAsync";
+};
+//# sourceMappingURL=local-variables-async.d.ts.map

package/build/types/integrations/local-variables/local-variables-async.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-variables-async.d.ts","sourceRoot":"","sources":["../../../../src/integrations/local-variables/local-variables-async.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAkB,gCAAgC,EAA4B,MAAM,UAAU,CAAC;AAI3G,eAAO,MAAM,kBAAkB,qCAAqC,CAAC;AAMrE;;GAEG;AACH,eAAO,MAAM,8BAA8B;;CAoIhB,CAAC"}

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

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

package/build/types/integrations/local-variables/worker.d.ts.map

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

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

@@ -0,0 +1,17 @@
+type ModuleInfo = Record<string, string>;
+/**
+ * Add node modules / packages to the event.
+ * For this, multiple sources are used:
+ * - They can be injected at build time into the __SENTRY_SERVER_MODULES__ variable (e.g. in Next.js)
+ * - They are extracted from the dependencies & devDependencies in the package.json file
+ * - They are extracted from the require.cache (CJS only)
+ */
+export declare const modulesIntegration: () => {
+    name: "Modules";
+    processEvent(event: import("@sentry/core").Event): import("@sentry/core").Event;
+    getModules: typeof _getModules;
+};
+/** Fetches the list of modules and the versions loaded by the entry file for your node.js app. */
+declare function _getModules(): ModuleInfo;
+export {};
+//# sourceMappingURL=modules.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"modules.d.ts","sourceRoot":"","sources":["../../../src/integrations/modules.ts"],"names":[],"mappings":"AAIA,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AA2CzC;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB;;;;CAAsB,CAAC;AAsEtD,kGAAkG;AAClG,iBAAS,WAAW,IAAI,UAAU,CAKjC"}

package/build/types/integrations/node-fetch/index.d.ts

@@ -0,0 +1,9 @@
+import type { NodeFetchOptions } from './types';
+/**
+ * Instrument outgoing fetch requests made through the native node `fetch` API.
+ * This emits (depending on the integration options) spans and breadcrumbs, as well as injecting trace propagation headers into the request.
+ */
+export declare const nativeNodeFetchIntegration: (options?: NodeFetchOptions | undefined) => import("@sentry/core").Integration & {
+    name: "NodeFetch";
+};
+//# sourceMappingURL=index.d.ts.map

package/build/types/integrations/node-fetch/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/integrations/node-fetch/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAgBhD;;;GAGG;AACH,eAAO,MAAM,0BAA0B;;CAAiD,CAAC"}

package/build/types/integrations/node-fetch/types.d.ts

@@ -0,0 +1,95 @@
+import type { Span } from '@sentry/core';
+export interface UndiciRequest {
+    origin: string;
+    method: string;
+    path: string;
+    /**
+     * Serialized string of headers in the form `name: value\r\n` for v5
+     * Array of strings `[key1, value1, key2, value2]`, where values are
+     * `string | string[]` for v6
+     */
+    headers: string | (string | string[])[];
+    /**
+     * Helper method to add headers (from v6)
+     */
+    addHeader: (name: string, value: string) => void;
+    throwOnError: boolean;
+    completed: boolean;
+    aborted: boolean;
+    idempotent: boolean;
+    contentLength: number | null;
+    contentType: string | null;
+    body: any;
+}
+export interface UndiciResponse {
+    headers: Buffer[];
+    statusCode: number;
+    statusText: string;
+}
+export interface RequestHookFunction<T = UndiciRequest> {
+    (span: Span, request: T): void;
+}
+export interface ResponseHookFunction<RequestType = UndiciRequest, ResponseType = UndiciResponse> {
+    (span: Span, info: {
+        request: RequestType;
+        response: ResponseType;
+    }): void;
+}
+export interface RequestMessage {
+    request: UndiciRequest;
+}
+export interface RequestHeadersMessage {
+    request: UndiciRequest;
+    socket: any;
+}
+export interface ResponseHeadersMessage {
+    request: UndiciRequest;
+    response: UndiciResponse;
+}
+export interface RequestTrailersMessage {
+    request: UndiciRequest;
+    response: UndiciResponse;
+}
+export interface RequestErrorMessage {
+    request: UndiciRequest;
+    error: Error;
+}
+export interface UndiciInstrumentationConfig<RequestType = UndiciRequest, ResponseType = UndiciResponse> {
+    /**
+     * 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;
+    /** Function for adding custom attributes before request is handled */
+    requestHook?: RequestHookFunction<RequestType>;
+    /** Function called once response headers have been received */
+    responseHook?: ResponseHookFunction<RequestType, ResponseType>;
+    /** Map the following HTTP headers to span attributes. */
+    headersToSpanAttributes?: {
+        requestHeaders?: string[];
+        responseHeaders?: string[];
+    };
+}
+export interface NodeFetchOptions extends UndiciInstrumentationConfig {
+    /**
+     * Whether breadcrumbs should be recorded for requests.
+     *
+     * @default `true`
+     */
+    breadcrumbs?: boolean;
+    /**
+     * If set to false, do not emit any spans.
+     * Breadcrumbs and trace propagation for outgoing fetch requests are still applied.
+     *
+     * Defaults to `true` when tracing is enabled.
+     */
+    spans?: boolean;
+    /**
+     * This option only has an effect when `spans` is set to false. When spans are enabled, you cannot disable trace propagation here.
+     * Instead, configure `tracePropagationTargets` in the client options.
+     *
+     * @default `true`
+     */
+    tracePropagation?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/build/types/integrations/node-fetch/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/integrations/node-fetch/types.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,OAAO,EAAE,MAAM,GAAG,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,EAAE,CAAC;IACxC;;OAEG;IACH,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACjD,YAAY,EAAE,OAAO,CAAC;IACtB,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,OAAO,CAAC;IACpB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAE3B,IAAI,EAAE,GAAG,CAAC;CACX;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,mBAAmB,CAAC,CAAC,GAAG,aAAa;IACpD,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,GAAG,IAAI,CAAC;CAChC;AAED,MAAM,WAAW,oBAAoB,CAAC,WAAW,GAAG,aAAa,EAAE,YAAY,GAAG,cAAc;IAC9F,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE;QAAE,OAAO,EAAE,WAAW,CAAC;QAAC,QAAQ,EAAE,YAAY,CAAA;KAAE,GAAG,IAAI,CAAC;CAC5E;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,aAAa,CAAC;CACxB;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,aAAa,CAAC;IAEvB,MAAM,EAAE,GAAG,CAAC;CACb;AAED,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,aAAa,CAAC;IACvB,QAAQ,EAAE,cAAc,CAAC;CAC1B;AAED,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,aAAa,CAAC;IACvB,QAAQ,EAAE,cAAc,CAAC;CAC1B;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,aAAa,CAAC;IACvB,KAAK,EAAE,KAAK,CAAC;CACd;AAID,MAAM,WAAW,2BAA2B,CAAC,WAAW,GAAG,aAAa,EAAE,YAAY,GAAG,cAAc;IACrG;;;OAGG;IACH,sBAAsB,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;IAClD,sEAAsE;IACtE,WAAW,CAAC,EAAE,mBAAmB,CAAC,WAAW,CAAC,CAAC;IAC/C,+DAA+D;IAC/D,YAAY,CAAC,EAAE,oBAAoB,CAAC,WAAW,EAAE,YAAY,CAAC,CAAC;IAC/D,yDAAyD;IACzD,uBAAuB,CAAC,EAAE;QACxB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;QAC1B,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;KAC5B,CAAC;CACH;AAED,MAAM,WAAW,gBAAiB,SAAQ,2BAA2B;IACnE;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;;;;OAKG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B"}

package/build/types/integrations/node-fetch/undici-instrumentation.d.ts

@@ -0,0 +1,17 @@
+import type { NodeFetchOptions } from './types';
+/**
+ * Instrument outgoing HTTP requests made through `undici` or the global `fetch` API: emit `http.client`
+ * spans, record breadcrumbs, and propagate traces into the outgoing request headers.
+ *
+ * Span creation is gated by the `spans` option (defaults to `true`). When spans are disabled, breadcrumbs
+ * are still recorded and trace propagation headers are still injected (gated by `tracePropagation`).
+ *
+ * undici reports its request lifecycle via `diagnostics_channel`, so rather than patching any module we
+ * subscribe to those channels directly. This is idempotent — subsequent calls are no-ops once the
+ * channels have been subscribed to, and the config of the first call wins.
+ *
+ * A combination of https://github.com/elastic/apm-agent-nodejs and
+ * https://github.com/gadget-inc/opentelemetry-instrumentations/blob/main/packages/opentelemetry-instrumentation-undici/src/index.ts
+ */
+export declare function instrumentUndici(config?: NodeFetchOptions): void;
+//# sourceMappingURL=undici-instrumentation.d.ts.map

package/build/types/integrations/node-fetch/undici-instrumentation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"undici-instrumentation.d.ts","sourceRoot":"","sources":["../../../../src/integrations/node-fetch/undici-instrumentation.ts"],"names":[],"mappings":"AA2DA,OAAO,KAAK,EACV,gBAAgB,EAOjB,MAAM,SAAS,CAAC;AAgBjB;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,GAAE,gBAAqB,GAAG,IAAI,CAapE"}

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

@@ -0,0 +1,66 @@
+/**
+ * Normalizes a `collectionIntervalMs` value, enforcing a minimum of 1000ms.
+ * - Non-finite values (NaN, Infinity): warns and falls back to `defaultInterval`.
+ * - Values below the minimum: warns and clamps to 1000ms.
+ * @internal
+ */
+export declare function _INTERNAL_normalizeCollectionInterval(rawInterval: number, integrationName: string, defaultInterval: number): number;
+export interface NodeRuntimeMetricsOptions {
+    /**
+     * Which metrics to collect.
+     *
+     * Default on (8 metrics):
+     * - `cpuUtilization` — CPU utilization ratio
+     * - `memRss` — Resident Set Size (actual memory footprint)
+     * - `memHeapUsed` — V8 heap currently in use
+     * - `memHeapTotal` — total V8 heap allocated (headroom paired with `memHeapUsed`)
+     * - `eventLoopDelayP50` — median event loop delay (baseline latency)
+     * - `eventLoopDelayP99` — 99th percentile event loop delay (tail latency / spikes)
+     * - `eventLoopUtilization` — fraction of time the event loop was active
+     * - `uptime` — process uptime (detect restarts/crashes)
+     *
+     * Default off (opt-in):
+     * - `cpuTime` — raw user/system CPU time in seconds
+     * - `memExternal` — external/ArrayBuffer memory (relevant for native addons)
+     * - `eventLoopDelayMin` / `eventLoopDelayMax` / `eventLoopDelayMean` / `eventLoopDelayP90`
+     */
+    collect?: {
+        cpuUtilization?: boolean;
+        memHeapUsed?: boolean;
+        memRss?: boolean;
+        eventLoopDelayP99?: boolean;
+        eventLoopUtilization?: boolean;
+        uptime?: boolean;
+        cpuTime?: boolean;
+        memHeapTotal?: boolean;
+        memExternal?: boolean;
+        eventLoopDelayMin?: boolean;
+        eventLoopDelayMax?: boolean;
+        eventLoopDelayMean?: boolean;
+        eventLoopDelayP50?: boolean;
+        eventLoopDelayP90?: boolean;
+    };
+    /**
+     * How often to collect metrics, in milliseconds.
+     * Minimum allowed value is 1000ms.
+     * @default 30000
+     * @minimum 1000
+     */
+    collectionIntervalMs?: number;
+}
+/**
+ * Automatically collects Node.js runtime metrics and emits them to Sentry.
+ *
+ * @example
+ * ```ts
+ * Sentry.init({
+ *   integrations: [
+ *     Sentry.nodeRuntimeMetricsIntegration(),
+ *   ],
+ * });
+ * ```
+ */
+export declare const nodeRuntimeMetricsIntegration: (options?: NodeRuntimeMetricsOptions | undefined) => import("@sentry/core").Integration & {
+    name: "NodeRuntimeMetrics";
+};
+//# sourceMappingURL=nodeRuntimeMetrics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nodeRuntimeMetrics.d.ts","sourceRoot":"","sources":["../../../src/integrations/nodeRuntimeMetrics.ts"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,wBAAgB,qCAAqC,CACnD,WAAW,EAAE,MAAM,EACnB,eAAe,EAAE,MAAM,EACvB,eAAe,EAAE,MAAM,GACtB,MAAM,CAgBR;AAED,MAAM,WAAW,yBAAyB;IACxC;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,EAAE;QAER,cAAc,CAAC,EAAE,OAAO,CAAC;QACzB,WAAW,CAAC,EAAE,OAAO,CAAC;QACtB,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,iBAAiB,CAAC,EAAE,OAAO,CAAC;QAC5B,oBAAoB,CAAC,EAAE,OAAO,CAAC;QAC/B,MAAM,CAAC,EAAE,OAAO,CAAC;QAEjB,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,YAAY,CAAC,EAAE,OAAO,CAAC;QACvB,WAAW,CAAC,EAAE,OAAO,CAAC;QACtB,iBAAiB,CAAC,EAAE,OAAO,CAAC;QAC5B,iBAAiB,CAAC,EAAE,OAAO,CAAC;QAC5B,kBAAkB,CAAC,EAAE,OAAO,CAAC;QAC7B,iBAAiB,CAAC,EAAE,OAAO,CAAC;QAC5B,iBAAiB,CAAC,EAAE,OAAO,CAAC;KAC7B,CAAC;IACF;;;;;OAKG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,6BAA6B;;CAuLxC,CAAC"}