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

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,104 @@
+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>;
+    /**
+     * Capture the listed HTTP headers as span attributes
+     * (`http.request.header.<name>` / `http.response.header.<name>`).
+     *
+     * Privacy filtering still applies to every header listed here. A header keeps its value only if
+     * `dataCollection.httpHeaders` permits it:
+     * - Sensitive names (`authorization`, `cookie`, ...) always show up as `[Filtered]`.
+     * - Names on the `deny` list show up as `[Filtered]`.
+     * - If an `allow` list is configured, a header must appear there as well, or it shows up as `[Filtered]`.
+     */
+    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;;;;;;;;;OASG;IACH,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":"AAgEA,OAAO,KAAK,EACV,gBAAgB,EAOjB,MAAM,SAAS,CAAC;AAcjB;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,GAAE,gBAAqB,GAAG,IAAI,CAcpE"}

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":"AASA;;;;;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"}

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

@@ -0,0 +1,33 @@
+import type { NodeClient } from '../sdk/client';
+interface OnUncaughtExceptionOptions {
+    /**
+     * Controls if the SDK should register a handler to exit the process on uncaught errors:
+     * - `true`: The SDK will exit the process on all uncaught errors.
+     * - `false`: The SDK will only exit the process when there are no other `uncaughtException` handlers attached.
+     *
+     * Default: `false`
+     */
+    exitEvenIfOtherHandlersAreRegistered: boolean;
+    /**
+     * This is called when an uncaught error would cause the process to exit.
+     *
+     * @param firstError Uncaught error causing the process to exit
+     * @param secondError Will be set if the handler was called multiple times. This can happen either because
+     * `onFatalError` itself threw, or because an independent error happened somewhere else while `onFatalError`
+     * was running.
+     */
+    onFatalError?(this: void, firstError: Error, secondError?: Error): void;
+}
+/**
+ * Add a global exception handler.
+ */
+export declare const onUncaughtExceptionIntegration: (options?: Partial<OnUncaughtExceptionOptions> | undefined) => import("@sentry/core").Integration & {
+    name: "OnUncaughtException";
+};
+type ErrorHandler = {
+    _errorHandler: boolean;
+} & ((error: Error) => void);
+/** Exported only for tests */
+export declare function makeErrorHandler(client: NodeClient, options: OnUncaughtExceptionOptions): ErrorHandler;
+export {};
+//# sourceMappingURL=onuncaughtexception.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"onuncaughtexception.d.ts","sourceRoot":"","sources":["../../../src/integrations/onuncaughtexception.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAKhD,UAAU,0BAA0B;IAClC;;;;;;OAMG;IACH,oCAAoC,EAAE,OAAO,CAAC;IAE9C;;;;;;;OAOG;IACH,YAAY,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,WAAW,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC;CACzE;AAID;;GAEG;AACH,eAAO,MAAM,8BAA8B;;CAkBzC,CAAC;AAEH,KAAK,YAAY,GAAG;IAAE,aAAa,EAAE,OAAO,CAAA;CAAE,GAAG,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC,CAAC;AAE1E,8BAA8B;AAC9B,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,0BAA0B,GAAG,YAAY,CAqGtG"}

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

@@ -0,0 +1,22 @@
+import type { Client } from '@sentry/core';
+type UnhandledRejectionMode = 'none' | 'warn' | 'strict';
+type IgnoreMatcher = {
+    name?: string | RegExp;
+    message?: string | RegExp;
+};
+interface OnUnhandledRejectionOptions {
+    /**
+     * Option deciding what to do after capturing unhandledRejection,
+     * that mimicks behavior of node's --unhandled-rejection flag.
+     */
+    mode: UnhandledRejectionMode;
+    /** Rejection Errors to ignore (don't capture or warn). */
+    ignore?: IgnoreMatcher[];
+}
+export declare const onUnhandledRejectionIntegration: (options?: Partial<OnUnhandledRejectionOptions> | undefined) => import("@sentry/core").Integration & {
+    name: string;
+};
+/** Core handler */
+export declare function makeUnhandledPromiseHandler(client: Client, options: OnUnhandledRejectionOptions): (reason: unknown, promise: unknown) => void;
+export {};
+//# sourceMappingURL=onunhandledrejection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"onunhandledrejection.d.ts","sourceRoot":"","sources":["../../../src/integrations/onunhandledrejection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAsC,MAAM,cAAc,CAAC;AAY/E,KAAK,sBAAsB,GAAG,MAAM,GAAG,MAAM,GAAG,QAAQ,CAAC;AAEzD,KAAK,aAAa,GAAG;IAAE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,CAAC;AAE3E,UAAU,2BAA2B;IACnC;;;OAGG;IACH,IAAI,EAAE,sBAAsB,CAAC;IAC7B,0DAA0D;IAC1D,MAAM,CAAC,EAAE,aAAa,EAAE,CAAC;CAC1B;AA2BD,eAAO,MAAM,+BAA+B;;CAAsD,CAAC;AAgCnG,mBAAmB;AACnB,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,2BAA2B,GACnC,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,CAwC7C"}

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

@@ -0,0 +1,61 @@
+import type { LogSeverityLevel } from '@sentry/core';
+type PinoOptions = {
+    /**
+     * Automatically instrument all Pino loggers.
+     *
+     * When set to `false`, only loggers marked with `pinoIntegration.trackLogger(logger)` will be captured.
+     *
+     * @default true
+     */
+    autoInstrument: boolean;
+    /**
+     * Options to enable capturing of error events.
+     */
+    error: {
+        /**
+         * Levels that trigger capturing of events.
+         *
+         * @default []
+         */
+        levels: LogSeverityLevel[];
+        /**
+         * By default, Sentry will mark captured errors as handled.
+         * Set this to `false` if you want to mark them as unhandled instead.
+         *
+         * @default true
+         */
+        handled: boolean;
+    };
+    /**
+     * Options to enable capturing of logs.
+     */
+    log: {
+        /**
+         * Levels that trigger capturing of logs.
+         *
+         * @default ["trace", "debug", "info", "warn", "error", "fatal"]
+         */
+        levels: LogSeverityLevel[];
+    };
+};
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? Partial<T[P]> : T[P];
+};
+/**
+ * Integration for Pino logging library.
+ * Captures Pino logs as Sentry logs and optionally captures some log levels as events.
+ *
+ * By default, all Pino loggers will be captured. To ignore a specific logger, use `pinoIntegration.untrackLogger(logger)`.
+ *
+ * If you disable automatic instrumentation with `autoInstrument: false`, you can mark specific loggers to be tracked with `pinoIntegration.trackLogger(logger)`.
+ *
+ * Requires Pino >=v8.0.0
+ */
+export declare const pinoIntegration: ((userOptions?: DeepPartial<PinoOptions> | undefined) => import("@sentry/core").Integration & {
+    name: string;
+}) & {
+    trackLogger(logger: unknown): void;
+    untrackLogger(logger: unknown): void;
+};
+export {};
+//# sourceMappingURL=pino.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pino.d.ts","sourceRoot":"","sources":["../../../src/integrations/pino.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAiB,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAgDpE,KAAK,WAAW,GAAG;IACjB;;;;;;OAMG;IACH,cAAc,EAAE,OAAO,CAAC;IACxB;;OAEG;IACH,KAAK,EAAE;QACL;;;;WAIG;QACH,MAAM,EAAE,gBAAgB,EAAE,CAAC;QAC3B;;;;;WAKG;QACH,OAAO,EAAE,OAAO,CAAC;KAClB,CAAC;IACF;;OAEG;IACH,GAAG,EAAE;QACH;;;;WAIG;QACH,MAAM,EAAE,gBAAgB,EAAE,CAAC;KAC5B,CAAC;CACH,CAAC;AAQF,KAAK,WAAW,CAAC,CAAC,IAAI;KACnB,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAC5D,CAAC;AA8GF;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe;;;wBACN,OAAO,GAAG,IAAI;0BAKZ,OAAO,GAAG,IAAI;CAKpC,CAAC"}

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

@@ -0,0 +1,7 @@
+/**
+ * Records a Session for the current process to track release health.
+ */
+export declare const processSessionIntegration: () => import("@sentry/core").Integration & {
+    name: "ProcessSession";
+};
+//# sourceMappingURL=processSession.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"processSession.d.ts","sourceRoot":"","sources":["../../../src/integrations/processSession.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,eAAO,MAAM,yBAAyB;;CAuBpC,CAAC"}

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

@@ -0,0 +1,18 @@
+type SpotlightConnectionOptions = {
+    /**
+     * Set this if the Spotlight Sidecar is not running on localhost:8969
+     * By default, the Url is set to http://localhost:8969/stream
+     */
+    sidecarUrl?: string;
+};
+export declare const INTEGRATION_NAME: 'Spotlight';
+/**
+ * Use this integration to send errors and transactions to Spotlight.
+ *
+ * Learn more about spotlight at https://spotlightjs.com
+ */
+export declare const spotlightIntegration: (options?: Partial<SpotlightConnectionOptions> | undefined) => import("@sentry/core").Integration & {
+    name: "Spotlight";
+};
+export {};
+//# sourceMappingURL=spotlight.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"spotlight.d.ts","sourceRoot":"","sources":["../../../src/integrations/spotlight.ts"],"names":[],"mappings":"AAIA,KAAK,0BAA0B,GAAG;IAChC;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAG,WAAoB,CAAC;AAsBrD;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;;CAA2C,CAAC"}

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

@@ -0,0 +1,14 @@
+type Options = {
+    /**
+     * If true, includes the `path` and `dest` properties in the error context.
+     */
+    includePaths?: boolean;
+};
+/**
+ * Captures context for Node.js SystemError errors.
+ */
+export declare const systemErrorIntegration: (options?: Options | undefined) => import("@sentry/core").Integration & {
+    name: "NodeSystemError";
+};
+export {};
+//# sourceMappingURL=systemError.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"systemError.d.ts","sourceRoot":"","sources":["../../../src/integrations/systemError.ts"],"names":[],"mappings":"AAkCA,KAAK,OAAO,GAAG;IACb;;OAEG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,sBAAsB;;CAsCjC,CAAC"}

package/build/types/integrations/tracing/hapi.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Add a Hapi plugin to capture errors to Sentry.
+ *
+ * @deprecated The error handler is now registered automatically when the Hapi
+ * server starts (via the orchestrion `@hapi/hapi` instrumentation), so calling
+ * this is no longer necessary. It remains a safe, idempotent operation when the
+ * handler is already attached, and is kept for setups where auto-registration is
+ * unavailable. This will be removed in a future major version.
+ *
+ * @param server The Hapi server to attach the error handler to
+ */
+export declare function setupHapiErrorHandler(server: unknown): Promise<void>;
+//# sourceMappingURL=hapi.d.ts.map

package/build/types/integrations/tracing/hapi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hapi.d.ts","sourceRoot":"","sources":["../../../../src/integrations/tracing/hapi.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,wBAAsB,qBAAqB,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAG1E"}

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

@@ -1,12 +1,3 @@
 import type { Integration } from '@sentry/core';
-/**
- * With OTEL, all performance integrations will be added, as OTEL only initializes them when the patched package is actually required.
- */
 export declare function getAutoPerformanceIntegrations(): Integration[];
-/**
- * Get a list of methods to instrument OTEL, when preload instrumentation.
- */
-export declare function getOpenTelemetryInstrumentationToPreload(): (((options?: any) => void) & {
-    id: string;
-})[];
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/integrations/tracing/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AA8BhD;;GAEG;AACH,wBAAgB,8BAA8B,IAAI,WAAW,EAAE,CAiC9D;AAED;;GAEG;AAEH,wBAAgB,wCAAwC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,GAAG,KAAK,IAAI,CAAC,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC,EAAE,CA+BzG"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/integrations/tracing/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAGhD,wBAAgB,8BAA8B,IAAI,WAAW,EAAE,CAE9D"}

package/build/types/integrations/tracing/koa.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Add a Koa error handler to capture errors to Sentry.
+ *
+ * @deprecated The error handler is now registered automatically when the Koa app
+ * starts (via the orchestrion `koa` instrumentation), so calling this is no
+ * longer necessary. It remains a safe, idempotent operation, and is kept for
+ * setups where auto-registration is unavailable. This will be removed in a
+ * future major version.
+ *
+ * @param app The Koa app instance
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ * const Koa = require("koa");
+ *
+ * const app = new Koa();
+ *
+ * // Add your routes, etc.
+ *
+ * app.listen(3000);
+ * ```
+ */
+export declare const setupKoaErrorHandler: (app: {
+    on: (event: 'error', listener: (...args: any[]) => void) => unknown;
+}) => void;
+//# sourceMappingURL=koa.d.ts.map

package/build/types/integrations/tracing/koa.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"koa.d.ts","sourceRoot":"","sources":["../../../../src/integrations/tracing/koa.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,eAAO,MAAM,oBAAoB,QAAS;IAExC,EAAE,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,KAAK,OAAO,CAAC;CACrE,KAAG,IAGH,CAAC"}

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

@@ -0,0 +1,55 @@
+import type { LogSeverityLevel } from '@sentry/core';
+/**
+ * Options for the Sentry Winston transport.
+ */
+interface WinstonTransportOptions {
+    /**
+     * Use this option to filter which levels should be captured. By default, all levels are captured.
+     *
+     * @example
+     * ```ts
+     * const SentryWinstonTransport = Sentry.createSentryWinstonTransport(Transport, {
+     *   // Only capture error and warn logs
+     *   levels: ['error', 'warn'],
+     * });
+     * ```
+     */
+    levels?: Array<LogSeverityLevel>;
+    /**
+     * Use this option to map custom levels to Sentry log severity levels.
+     *
+     * @example
+     * ```ts
+     * const SentryWinstonTransport = Sentry.createSentryWinstonTransport(Transport, {
+     *   customLevelMap: {
+     *     myCustomLevel: 'info',
+     *     customError: 'error',
+     *   },
+     * });
+     * ```
+     */
+    customLevelMap?: Record<string, LogSeverityLevel>;
+}
+/**
+ * Creates a new Sentry Winston transport that fowards logs to Sentry.
+ *
+ * Supports Winston 3.x.x.
+ *
+ * @param TransportClass - The Winston transport class to extend.
+ * @returns The extended transport class.
+ *
+ * @example
+ * ```ts
+ * const winston = require('winston');
+ * const Transport = require('winston-transport');
+ *
+ * const SentryWinstonTransport = Sentry.createSentryWinstonTransport(Transport);
+ *
+ * const logger = winston.createLogger({
+ *   transports: [new SentryWinstonTransport()],
+ * });
+ * ```
+ */
+export declare function createSentryWinstonTransport<TransportStreamInstance extends object>(TransportClass: new (options?: any) => TransportStreamInstance, sentryWinstonOptions?: WinstonTransportOptions): typeof TransportClass;
+export {};
+//# sourceMappingURL=winston.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"winston.d.ts","sourceRoot":"","sources":["../../../src/integrations/winston.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAYrD;;GAEG;AACH,UAAU,uBAAuB;IAC/B;;;;;;;;;;OAUG;IACH,MAAM,CAAC,EAAE,KAAK,CAAC,gBAAgB,CAAC,CAAC;IAEjC;;;;;;;;;;;;OAYG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;CACnD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,4BAA4B,CAAC,uBAAuB,SAAS,MAAM,EAEjF,cAAc,EAAE,KAAK,OAAO,CAAC,EAAE,GAAG,KAAK,uBAAuB,EAC9D,oBAAoB,CAAC,EAAE,uBAAuB,GAC7C,OAAO,cAAc,CA4DvB"}

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

@@ -0,0 +1,8 @@
+/**
+ * Capture events and errors of worker threads.
+ * For child process events, use `childProcessIntegration()` instead.
+ */
+export declare const workerThreadsIntegration: () => import("@sentry/core").Integration & {
+    name: "WorkerThreads";
+};
+//# sourceMappingURL=workerThreads.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workerThreads.d.ts","sourceRoot":"","sources":["../../../src/integrations/workerThreads.ts"],"names":[],"mappings":"AAMA;;;GAGG;AACH,eAAO,MAAM,wBAAwB;;CAWnC,CAAC"}

package/build/types/logs/capture.d.ts

@@ -0,0 +1,29 @@
+import type { Log, LogSeverityLevel, ParameterizedString, Scope } from '@sentry/core';
+/**
+ * Additional metadata to capture the log with.
+ */
+interface CaptureLogMetadata {
+    scope?: Scope;
+}
+type CaptureLogArgWithTemplate = [
+    messageTemplate: string,
+    messageParams: Array<unknown>,
+    attributes?: Log['attributes'],
+    metadata?: CaptureLogMetadata
+];
+type CaptureLogArgWithoutTemplate = [
+    message: ParameterizedString,
+    attributes?: Log['attributes'],
+    metadata?: CaptureLogMetadata
+];
+export type CaptureLogArgs = CaptureLogArgWithTemplate | CaptureLogArgWithoutTemplate;
+/**
+ * Capture a log with the given level.
+ *
+ * @param level - The level of the log.
+ * @param message - The message to log.
+ * @param attributes - Arbitrary structured data that stores information about the log - e.g., userId: 100.
+ */
+export declare function captureLog(level: LogSeverityLevel, ...args: CaptureLogArgs): void;
+export {};
+//# sourceMappingURL=capture.d.ts.map