@sentry/node 10.61.0 → 10.63.0

package/build/types/integrations/tracing/prisma/vendored/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/integrations/tracing/prisma/vendored/types.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAErE,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE,OAAO,KAAK,CAAC,CAAC;AAEpE,MAAM,WAAW,mBAAoB,SAAQ,WAAW;IACtD,2BAA2B;IAC3B,IAAI,EAAE,MAAM,CAAC;IAEb,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,6CAA6C;IAC7C,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,wCAAwC;IACxC,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC;AAElC,MAAM,MAAM,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAEtC,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,UAAU,CAAC;AAEnD,MAAM,MAAM,UAAU,GAAG;IACvB,EAAE,EAAE,YAAY,CAAC;IACjB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,cAAc,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,KAAK,CAAC,EAAE,YAAY,EAAE,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;AAE/E,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,YAAY,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,QAAQ,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;QACpC,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,CAAC;CACH;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,MAAM,EAAE,gBAAgB,EAAE,CAAC;CAC5B;AAED,MAAM,WAAW,aAAa;IAC5B,SAAS,IAAI,OAAO,CAAC;IACrB,cAAc,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAC1C,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC;IAE/C,gBAAgB,IAAI,OAAO,GAAG,SAAS,CAAC;IAExC,cAAc,CAAC,CAAC,EAAE,aAAa,EAAE,MAAM,GAAG,mBAAmB,EAAE,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;CAC9F;AAED,MAAM,WAAW,gCAAgC;IAC/C,MAAM,CAAC,EAAE,aAAa,CAAC;CACxB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/integrations/tracing/prisma/vendored/types.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,UAAU,CAAC,EAAE,IAAI,KAAK,CAAC,CAAC;AAEpE,MAAM,WAAW,mBAAoB,SAAQ,WAAW;IACtD,2BAA2B;IAC3B,IAAI,EAAE,MAAM,CAAC;IAEb,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,6CAA6C;IAC7C,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC;AAElC,MAAM,MAAM,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAEtC,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,UAAU,CAAC;AAEnD,MAAM,MAAM,UAAU,GAAG;IACvB,EAAE,EAAE,YAAY,CAAC;IACjB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,cAAc,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,KAAK,CAAC,EAAE,YAAY,EAAE,CAAC;CACxB,CAAC;AAEF,MAAM,WAAW,aAAa;IAC5B,SAAS,IAAI,OAAO,CAAC;IACrB,cAAc,CAAC,IAAI,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC;IACpC,mBAAmB,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC;IAC/C,gBAAgB,IAAI,IAAI,GAAG,SAAS,CAAC;IACrC,cAAc,CAAC,CAAC,EAAE,aAAa,EAAE,MAAM,GAAG,mBAAmB,EAAE,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;CAC9F;AAED,MAAM,WAAW,gCAAgC;IAC/C,MAAM,CAAC,EAAE,aAAa,CAAC;CACxB"}

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

@@ -22,7 +22,7 @@ export declare const cacheResponseHook: IORedisResponseCustomAttributeFunction;
  * ("Redis"), all the instrumentations are generated in this one function
  */
 export declare const instrumentRedis: (() => void) & {
-    id: string;
+    id: "Redis";
 };
 /**
  * Adds Sentry tracing instrumentation for the [redis](https://www.npmjs.com/package/redis) and
@@ -39,6 +39,8 @@ export declare const instrumentRedis: (() => void) & {
  * });
  * ```
  */
-export declare const redisIntegration: (options?: RedisOptions | undefined) => import("@sentry/core").Integration;
+export declare const redisIntegration: (options?: RedisOptions | undefined) => import("@sentry/core").Integration & {
+    name: "Redis";
+};
 export {};
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/tracing/redis/index.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAAE,sCAAsC,EAAE,MAAM,kBAAkB,CAAC;AAI/E,UAAU,YAAY;IACpB;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAKD,eAAO,IAAI,aAAa,EAAE,YAAiB,CAAC;AAG5C,eAAO,MAAM,iBAAiB,EAAE,sCAoD/B,CAAC;AAcF;;;GAGG;AACH,eAAO,MAAM,eAAe,SACtB,IAAI;;CAgBT,CAAC;AAYF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,4EAAuC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/tracing/redis/index.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAAE,sCAAsC,EAAE,MAAM,kBAAkB,CAAC;AAI/E,UAAU,YAAY;IACpB;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAKD,eAAO,IAAI,aAAa,EAAE,YAAiB,CAAC;AAG5C,eAAO,MAAM,iBAAiB,EAAE,sCAoD/B,CAAC;AAcF;;;GAGG;AACH,eAAO,MAAM,eAAe,SACtB,IAAI;;CAmBT,CAAC;AAYF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB;;CAAuC,CAAC"}

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

@@ -16,5 +16,7 @@ export declare const instrumentTedious: ((options?: unknown) => TediousInstrumen
  * });
  * ```
  */
-export declare const tediousIntegration: () => import("@sentry/core").Integration;
+export declare const tediousIntegration: () => import("@sentry/core").Integration & {
+    name: "Tedious";
+};
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/tracing/tedious/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AAOpE,eAAO,MAAM,iBAAiB;;CAAiF,CAAC;AAWhH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,kBAAkB,0CAAyC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/tracing/tedious/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AAOpE,eAAO,MAAM,iBAAiB;;CAAiF,CAAC;AAWhH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,kBAAkB;;CAAyC,CAAC"}

package/build/types/integrations/tracing/vercelai/constants.d.ts

@@ -1,2 +1,2 @@
-export declare const INTEGRATION_NAME = "VercelAI";
+export declare const INTEGRATION_NAME: "VercelAI";
 //# sourceMappingURL=constants.d.ts.map

package/build/types/integrations/tracing/vercelai/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/tracing/vercelai/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,aAAa,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/tracing/vercelai/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,EAAG,UAAmB,CAAC"}

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

@@ -5,7 +5,6 @@ export declare const instrumentVercelAi: ((options?: unknown) => SentryVercelAiI
 };
 /**
  * Adds Sentry tracing instrumentation for the [ai](https://www.npmjs.com/package/ai) library.
- * This integration is not enabled by default, you need to manually add it.
  *
  * For more information, see the [`ai` documentation](https://sdk.vercel.ai/docs/ai-sdk-core/telemetry).
  *
@@ -39,5 +38,7 @@ export declare const instrumentVercelAi: ((options?: unknown) => SentryVercelAiI
  *  experimental_telemetry: { isEnabled: true, recordInputs: true, recordOutputs: true },
  * });
  */
-export declare const vercelAIIntegration: (options?: VercelAiOptions | undefined) => import("@sentry/core").Integration;
+export declare const vercelAIIntegration: (options?: VercelAiOptions | undefined) => import("@sentry/core").Integration & {
+    name: "VercelAI";
+};
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/tracing/vercelai/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,6BAA6B,EAAE,MAAM,mBAAmB,CAAC;AAClE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,eAAO,MAAM,kBAAkB;;CAAwF,CAAC;AAkCxH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,mBAAmB,+EAA0C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/tracing/vercelai/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,6BAA6B,EAAE,MAAM,mBAAmB,CAAC;AAClE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,eAAO,MAAM,kBAAkB;;CAAwF,CAAC;AAmCxH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,eAAO,MAAM,mBAAmB;;CAA0C,CAAC"}

package/build/types/sdk/diagnosticsChannelInjection.d.ts

@@ -13,7 +13,7 @@ import type { Integration } from '@sentry/core';
  */
 export interface DiagnosticsChannelInjection {
     /** Channel-based integrations to register, replacing their OTel equivalents. */
-    integrations: Integration[];
+    integrations: Integration[] | readonly Integration[];
     /** OTel integration names these replace; filtered out of the default set. */
     replacedOtelIntegrationNames: string[];
     /** Installs the module hooks that inject the diagnostics channels. */

package/build/types/sdk/diagnosticsChannelInjection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"diagnosticsChannelInjection.d.ts","sourceRoot":"","sources":["../../../src/sdk/diagnosticsChannelInjection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,2BAA2B;IAC1C,gFAAgF;IAChF,YAAY,EAAE,WAAW,EAAE,CAAC;IAC5B,6EAA6E;IAC7E,4BAA4B,EAAE,MAAM,EAAE,CAAC;IACvC,sEAAsE;IACtE,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,qEAAqE;IACrE,MAAM,EAAE,MAAM,IAAI,CAAC;CACpB;AAKD;;;;;;GAMG;AACH,wBAAgB,oCAAoC,CAAC,IAAI,EAAE,MAAM,2BAA2B,GAAG,IAAI,CAElG;AAED,yEAAyE;AACzE,wBAAgB,oCAAoC,IAAI,OAAO,CAE9D;AAED;;;;;GAKG;AACH,wBAAgB,kCAAkC,IAAI,2BAA2B,GAAG,SAAS,CAK5F"}
+{"version":3,"file":"diagnosticsChannelInjection.d.ts","sourceRoot":"","sources":["../../../src/sdk/diagnosticsChannelInjection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,2BAA2B;IAC1C,gFAAgF;IAChF,YAAY,EAAE,WAAW,EAAE,GAAG,SAAS,WAAW,EAAE,CAAC;IACrD,6EAA6E;IAC7E,4BAA4B,EAAE,MAAM,EAAE,CAAC;IACvC,sEAAsE;IACtE,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,qEAAqE;IACrE,MAAM,EAAE,MAAM,IAAI,CAAC;CACpB;AAKD;;;;;;GAMG;AACH,wBAAgB,oCAAoC,CAAC,IAAI,EAAE,MAAM,2BAA2B,GAAG,IAAI,CAElG;AAED,yEAAyE;AACzE,wBAAgB,oCAAoC,IAAI,OAAO,CAE9D;AAED;;;;;GAKG;AACH,wBAAgB,kCAAkC,IAAI,2BAA2B,GAAG,SAAS,CAK5F"}

package/build/types/sdk/experimentalUseDiagnosticsChannelInjection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"experimentalUseDiagnosticsChannelInjection.d.ts","sourceRoot":"","sources":["../../../src/sdk/experimentalUseDiagnosticsChannelInjection.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,0CAA0C,IAAI,IAAI,CASjE"}
+{"version":3,"file":"experimentalUseDiagnosticsChannelInjection.d.ts","sourceRoot":"","sources":["../../../src/sdk/experimentalUseDiagnosticsChannelInjection.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,0CAA0C,IAAI,IAAI,CAYjE"}

package/build/types-ts3.8/integrations/featureFlagShims/launchDarkly.d.ts

@@ -2,7 +2,9 @@
  * This is a shim for the LaunchDarkly integration.
  * We need this in order to not throw runtime errors when accidentally importing this on the server through a meta framework like Next.js.
  */
-export declare const launchDarklyIntegrationShim: (_options?: unknown) => import("@sentry/core").Integration;
+export declare const launchDarklyIntegrationShim: (_options?: unknown) => import("@sentry/core").Integration & {
+    name: "LaunchDarkly";
+};
 /**
  * This is a shim for the LaunchDarkly flag used handler.
  */

package/build/types-ts3.8/integrations/featureFlagShims/openFeature.d.ts

@@ -2,7 +2,9 @@
  * This is a shim for the OpenFeature integration.
  * We need this in order to not throw runtime errors when accidentally importing this on the server through a meta framework like Next.js.
  */
-export declare const openFeatureIntegrationShim: (_options?: unknown) => import("@sentry/core").Integration;
+export declare const openFeatureIntegrationShim: (_options?: unknown) => import("@sentry/core").Integration & {
+    name: "OpenFeature";
+};
 /**
  * This is a shim for the OpenFeature integration hook.
  */

package/build/types-ts3.8/integrations/featureFlagShims/statsig.d.ts

@@ -2,5 +2,7 @@
  * This is a shim for the Statsig integration.
  * We need this in order to not throw runtime errors when accidentally importing this on the server through a meta framework like Next.js.
  */
-export declare const statsigIntegrationShim: (_options?: unknown) => import("@sentry/core").Integration;
+export declare const statsigIntegrationShim: (_options?: unknown) => import("@sentry/core").Integration & {
+    name: "Statsig";
+};
 //# sourceMappingURL=statsig.d.ts.map

package/build/types-ts3.8/integrations/featureFlagShims/unleash.d.ts

@@ -2,5 +2,7 @@
  * This is a shim for the Unleash integration.
  * We need this in order to not throw runtime errors when accidentally importing this on the server through a meta framework like Next.js.
  */
-export declare const unleashIntegrationShim: (_options?: unknown) => import("@sentry/core").Integration;
+export declare const unleashIntegrationShim: (_options?: unknown) => import("@sentry/core").Integration & {
+    name: "Unleash";
+};
 //# sourceMappingURL=unleash.d.ts.map

package/build/types-ts3.8/integrations/fs/index.d.ts

@@ -8,5 +8,7 @@ import { FsInstrumentationConfig } from './vendored/types';
  *
  * @param options Configuration for this integration.
  */
-export declare const fsIntegration: (options?: FsInstrumentationConfig | undefined) => import("@sentry/core").Integration;
+export declare const fsIntegration: (options?: FsInstrumentationConfig | undefined) => import("@sentry/core").Integration & {
+    name: "FileSystem";
+};
 //# sourceMappingURL=index.d.ts.map

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

@@ -127,6 +127,8 @@ export declare const instrumentSentryHttp: ((options?: SentryHttpInstrumentation
  * 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;
+export declare const httpIntegration: (options?: HttpOptions | undefined) => import("@sentry/core").Integration & {
+    name: "Http";
+};
 export {};
 //# sourceMappingURL=http.d.ts.map

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

@@ -1,36 +1,5 @@
-import { UndiciInstrumentationConfig } from './vendored/types';
-interface NodeFetchOptions extends Pick<UndiciInstrumentationConfig, 'requestHook' | 'responseHook' | 'headersToSpanAttributes'> {
-    /**
-     * Whether breadcrumbs should be recorded for requests.
-     * Defaults to true
-     */
-    breadcrumbs?: boolean;
-    /**
-     * If set to false, do not emit any spans.
-     * This will ensure that the default UndiciInstrumentation from OpenTelemetry is not setup,
-     * only the Sentry-specific instrumentation for breadcrumbs & trace propagation is applied.
-     *
-     * If `skipOpenTelemetrySetup: true` is configured, this defaults to `false`, otherwise it defaults to `true`.
-     */
-    spans?: boolean;
-    /**
-     * Whether to inject trace propagation headers (sentry-trace, baggage, traceparent) into outgoing fetch 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 `skipOpenTelemetrySetup: true` is configured and you want
-     * to avoid duplicate trace headers being injected by both Sentry and OpenTelemetry's UndiciInstrumentation.
-     *
-     * @default `true`
-     */
-    tracePropagation?: boolean;
-    /**
-     * Do not capture spans or breadcrumbs for outgoing fetch requests to URLs where the given callback returns `true`.
-     * This controls both span & breadcrumb creation - spans will be non recording if tracing is disabled.
-     */
-    ignoreOutgoingRequests?: (url: string) => boolean;
-}
-export declare const nativeNodeFetchIntegration: (options?: NodeFetchOptions | undefined) => import("@sentry/core").Integration;
-/** Exported only for tests. */
-export declare function _getConfigWithDefaults(options?: Partial<NodeFetchOptions>): UndiciInstrumentationConfig;
-export {};
+import { NodeFetchOptions } from './types';
+export declare const nativeNodeFetchIntegration: (options?: NodeFetchOptions | undefined) => import("@sentry/core").Integration & {
+    name: "NodeFetch";
+};
 //# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,96 @@
+import { 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.
+     * This will ensure that the default UndiciInstrumentation from OpenTelemetry is not setup,
+     * only the Sentry-specific instrumentation for breadcrumbs & trace propagation is applied.
+     *
+     * If `skipOpenTelemetrySetup: true` is configured, this defaults to `false`, otherwise it defaults to `true`.
+     */
+    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-ts3.8/integrations/node-fetch/undici-instrumentation.d.ts

@@ -0,0 +1,14 @@
+import { UndiciInstrumentationConfig } from './types';
+/**
+ * Instrument outgoing HTTP requests made through `undici` or the global `fetch` API: emit `http.client`
+ * spans and propagate traces into the outgoing request headers.
+ *
+ * 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?: UndiciInstrumentationConfig): void;
+//# sourceMappingURL=undici-instrumentation.d.ts.map

package/build/types-ts3.8/integrations/tracing/amqplib/index.d.ts

@@ -1,4 +1,4 @@
-import { AmqplibInstrumentation } from './vendored/amqplib';
+import { AmqplibInstrumentation } from './vendored/instrumentation';
 export declare const instrumentAmqplib: ((options?: unknown) => AmqplibInstrumentation) & {
     id: string;
 };
@@ -16,5 +16,7 @@ export declare const instrumentAmqplib: ((options?: unknown) => AmqplibInstrumen
  * });
  * ```
  */
-export declare const amqplibIntegration: () => import("@sentry/core").Integration;
+export declare const amqplibIntegration: () => import("@sentry/core").Integration & {
+    name: "Amqplib";
+};
 //# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/integrations/tracing/amqplib/vendored/instrumentation.d.ts

@@ -0,0 +1,11 @@
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
+import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+export declare class AmqplibInstrumentation extends InstrumentationBase<InstrumentationConfig> {
+    constructor(config?: InstrumentationConfig);
+    protected init(): InstrumentationNodeModuleDefinition;
+    private patchConnect;
+    private unpatchConnect;
+    private patchChannelModel;
+    private unpatchChannelModel;
+}
+//# sourceMappingURL=instrumentation.d.ts.map

package/build/types-ts3.8/integrations/tracing/amqplib/vendored/patches.d.ts

@@ -0,0 +1,11 @@
+import { Connection, Options, Replies } from './amqplib-types';
+import { EndOperation, ConsumeMessage, Message } from './types';
+import { InstrumentationConsumeChannel, InstrumentationPublishChannel } from './utils';
+export declare function getConnectPatch(original: (url: string | Options.Connect, socketOptions: any, openCallback: (err: any, connection: Connection) => void) => Connection): (this: unknown, url: string | Options.Connect, socketOptions: any, openCallback: Function) => Connection;
+export declare function getChannelEmitPatch(original: Function): (this: InstrumentationConsumeChannel, eventName: string) => void;
+export declare function getAckAllPatch(isRejected: boolean, endOperation: EndOperation): (original: Function) => (this: InstrumentationConsumeChannel, requeueOrEmpty?: boolean) => void;
+export declare function getAckPatch(isRejected: boolean, endOperation: EndOperation): (original: Function) => (this: InstrumentationConsumeChannel, message: Message, allUpToOrRequeue?: boolean, requeue?: boolean) => void;
+export declare function getConsumePatch(original: Function): (this: InstrumentationConsumeChannel, queue: string, onMessage: (msg: ConsumeMessage | null) => void, options?: Options.Consume) => Promise<Replies.Consume>;
+export declare function getConfirmedPublishPatch(original: Function): (this: InstrumentationPublishChannel, exchange: string, routingKey: string, content: Buffer, options?: Options.Publish, callback?: (err: any, ok: Replies.Empty) => void) => boolean;
+export declare function getPublishPatch(original: Function): (this: InstrumentationPublishChannel, exchange: string, routingKey: string, content: Buffer, options?: Options.Publish) => boolean;
+//# sourceMappingURL=patches.d.ts.map

package/build/types-ts3.8/integrations/tracing/amqplib/vendored/semconv.d.ts

@@ -1,41 +1,29 @@
-/**
- * Deprecated, use `messaging.operation.type` instead.
- *
- * @example publish
- * @example create
- * @example process
- *
- * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
- *
- * @deprecated Replaced by `messaging.operation.type`.
- */
-export declare const ATTR_MESSAGING_OPERATION: "messaging.operation";
-/**
- * The messaging system as identified by the client instrumentation.
- *
- * @note The actual messaging system may differ from the one known by the client. For example, when using Kafka client libraries to communicate with Azure Event Hubs, the `messaging.system` is set to `kafka` based on the instrumentation's best knowledge.
- *
- * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
- */
+/** The messaging system as identified by the client instrumentation, e.g. `rabbitmq`. */
 export declare const ATTR_MESSAGING_SYSTEM: "messaging.system";
-/**
- * Deprecated, use `server.address` on client spans and `client.address` on server spans.
- *
- * @example example.com
- *
- * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
- *
- * @deprecated Replaced by `server.address` on client spans and `client.address` on server spans.
- */
+/** A string identifying the kind of message consumption. */
+export declare const ATTR_MESSAGING_OPERATION: "messaging.operation";
+/** Host name of the message broker. */
 export declare const ATTR_NET_PEER_NAME: "net.peer.name";
-/**
- * Deprecated, use `server.port` on client spans and `client.port` on server spans.
- *
- * @example 8080
- *
- * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
- *
- * @deprecated Replaced by `server.port` on client spans and `client.port` on server spans.
- */
+/** Port of the message broker. */
 export declare const ATTR_NET_PEER_PORT: "net.peer.port";
+/** The message destination name (the exchange for amqplib). */
+export declare const ATTR_MESSAGING_DESTINATION: "messaging.destination";
+/** The kind of message destination. */
+export declare const ATTR_MESSAGING_DESTINATION_KIND: "messaging.destination_kind";
+/** RabbitMQ message routing key. */
+export declare const ATTR_MESSAGING_RABBITMQ_ROUTING_KEY: "messaging.rabbitmq.routing_key";
+/** The name of the transport protocol. */
+export declare const ATTR_MESSAGING_PROTOCOL: "messaging.protocol";
+/** The version of the transport protocol. */
+export declare const ATTR_MESSAGING_PROTOCOL_VERSION: "messaging.protocol_version";
+/** Connection string. */
+export declare const ATTR_MESSAGING_URL: "messaging.url";
+/** A value used by the messaging system as an identifier for the message, represented as a string. */
+export declare const OLD_ATTR_MESSAGING_MESSAGE_ID: "messaging.message_id";
+/** The conversation ID (a.k.a. correlation ID) identifying the conversation the message belongs to. */
+export declare const ATTR_MESSAGING_CONVERSATION_ID: "messaging.conversation_id";
+/** Value for `messaging.destination_kind` when the destination is a topic. */
+export declare const MESSAGING_DESTINATION_KIND_VALUE_TOPIC: "topic";
+/** Value for `messaging.operation` when the message is being processed by a consumer. */
+export declare const MESSAGING_OPERATION_VALUE_PROCESS: "process";
 //# sourceMappingURL=semconv.d.ts.map

package/build/types-ts3.8/integrations/tracing/amqplib/vendored/types.d.ts

@@ -1,37 +1,3 @@
-import { Span } from '@opentelemetry/api';
-import { InstrumentationConfig } from '@opentelemetry/instrumentation';
-export interface PublishInfo {
-    moduleVersion: string | undefined;
-    exchange: string;
-    routingKey: string;
-    content: Buffer;
-    options?: AmqplibPublishOptions;
-    isConfirmChannel?: boolean;
-}
-export interface PublishConfirmedInfo extends PublishInfo {
-    confirmError?: any;
-}
-export interface ConsumeInfo {
-    moduleVersion: string | undefined;
-    msg: ConsumeMessage;
-}
-export interface ConsumeEndInfo {
-    msg: ConsumeMessage;
-    rejected: boolean | null;
-    endOperation: EndOperation;
-}
-export interface AmqplibPublishCustomAttributeFunction {
-    (span: Span, publishInfo: PublishInfo): void;
-}
-export interface AmqplibPublishConfirmCustomAttributeFunction {
-    (span: Span, publishConfirmedInto: PublishConfirmedInfo): void;
-}
-export interface AmqplibConsumeCustomAttributeFunction {
-    (span: Span, consumeInfo: ConsumeInfo): void;
-}
-export interface AmqplibConsumeEndCustomAttributeFunction {
-    (span: Span, consumeEndInfo: ConsumeEndInfo): void;
-}
 export declare enum EndOperation {
     AutoAck = "auto ack",
     Ack = "ack",
@@ -43,53 +9,6 @@ export declare enum EndOperation {
     ChannelError = "channel error",
     InstrumentationTimeout = "instrumentation timeout"
 }
-export interface AmqplibInstrumentationConfig extends InstrumentationConfig {
-    /** hook for adding custom attributes before publish message is sent */
-    publishHook?: AmqplibPublishCustomAttributeFunction;
-    /** hook for adding custom attributes after publish message is confirmed by the broker */
-    publishConfirmHook?: AmqplibPublishConfirmCustomAttributeFunction;
-    /** hook for adding custom attributes before consumer message is processed */
-    consumeHook?: AmqplibConsumeCustomAttributeFunction;
-    /** hook for adding custom attributes after consumer message is acked to server */
-    consumeEndHook?: AmqplibConsumeEndCustomAttributeFunction;
-    /**
-     * When user is setting up consume callback, it is user's responsibility to call
-     * ack/nack etc on the msg to resolve it in the server.
-     * If user is not calling the ack, the message will stay in the queue until
-     * channel is closed, or until server timeout expires (if configured).
-     * While we wait for the ack, a reference to the message is stored in plugin, which
-     * will never be garbage collected.
-     * To prevent memory leak, plugin has it's own configuration of timeout, which
-     * will close the span if user did not call ack after this timeout.
-     * If timeout is not big enough, span might be closed with 'InstrumentationTimeout',
-     * and then received valid ack from the user later which will not be instrumented.
-     *
-     * Default is 1 minute
-     */
-    consumeTimeoutMs?: number;
-    /** option to use a span link for the consume message instead of continuing a trace */
-    useLinksForConsume?: boolean;
-}
-export declare const DEFAULT_CONFIG: AmqplibInstrumentationConfig;
-export interface AmqplibPublishOptions {
-    expiration?: string | number;
-    userId?: string;
-    CC?: string | string[];
-    mandatory?: boolean;
-    persistent?: boolean;
-    deliveryMode?: boolean | number;
-    BCC?: string | string[];
-    contentType?: string;
-    contentEncoding?: string;
-    headers?: any;
-    priority?: number;
-    correlationId?: string;
-    replyTo?: string;
-    messageId?: string;
-    timestamp?: number;
-    type?: string;
-    appId?: string;
-}
 export interface Message {
     content: Buffer;
     fields: MessageFields;

package/build/types-ts3.8/integrations/tracing/amqplib/vendored/utils.d.ts

@@ -1,16 +1,17 @@
-import { Context, Span, Attributes } from '@opentelemetry/api';
-import { SemconvStability } from '@opentelemetry/instrumentation';
-import { Connection, Channel, ConfirmChannel, Options } from './amqplib-types';
+import { Span, SpanAttributes } from '@sentry/core';
+import { Channel, ConfirmChannel, Connection, Options } from './amqplib-types';
 import { ConsumeMessage, Message } from './types';
 export declare const MESSAGE_STORED_SPAN: unique symbol;
 export declare const CHANNEL_SPANS_NOT_ENDED: unique symbol;
 export declare const CHANNEL_CONSUME_TIMEOUT_TIMER: unique symbol;
 export declare const CONNECTION_ATTRIBUTES: unique symbol;
+export declare const CHANNEL_IS_CONFIRM_PUBLISHING: unique symbol;
 export type InstrumentationConnection = Connection & {
-    [CONNECTION_ATTRIBUTES]?: Attributes;
+    [CONNECTION_ATTRIBUTES]?: SpanAttributes;
 };
 export type InstrumentationPublishChannel = (Channel | ConfirmChannel) & {
     connection: InstrumentationConnection;
+    [CHANNEL_IS_CONFIRM_PUBLISHING]?: boolean;
 };
 export type InstrumentationConsumeChannel = Channel & {
     connection: InstrumentationConnection;
@@ -27,9 +28,15 @@ export type InstrumentationConsumeMessage = ConsumeMessage & {
     [MESSAGE_STORED_SPAN]?: Span;
 };
 export declare const normalizeExchange: (exchangeName: string) => string;
-export declare const getConnectionAttributesFromServer: (conn: Connection) => Attributes;
-export declare const getConnectionAttributesFromUrl: (url: string | Options.Connect, netSemconvStability: SemconvStability) => Attributes;
-export declare const markConfirmChannelTracing: (context: Context) => Context;
-export declare const unmarkConfirmChannelTracing: (context: Context) => Context;
-export declare const isConfirmChannelTracing: (context: Context) => boolean;
+export declare const getConnectionAttributesFromServer: (conn: Connection) => SpanAttributes;
+export declare const getConnectionAttributesFromUrl: (url: string | Options.Connect) => SpanAttributes;
+/** Reads a propagation header value off an amqplib message as a string. */
+export declare function getHeaderAsString(headers: Record<string, unknown> | undefined, key: string): string | undefined;
+/** Starts an inactive producer span and propagates its trace into the publish `options.headers`. */
+export declare function startPublishSpan(exchange: string, routingKey: string, channel: InstrumentationPublishChannel, options?: Options.Publish): {
+    span: Span;
+    modifiedOptions: Options.Publish;
+};
+/** Starts an inactive consumer (process) span carrying the amqplib messaging attributes. */
+export declare function startConsumeSpan(queue: string, msg: InstrumentationConsumeMessage, channel: InstrumentationConsumeChannel): Span;
 //# sourceMappingURL=utils.d.ts.map

package/build/types-ts3.8/integrations/tracing/anthropic-ai/index.d.ts

@@ -56,5 +56,7 @@ export declare const instrumentAnthropicAi: ((options?: AnthropicAiOptions | und
  * ```
  *
  */
-export declare const anthropicAIIntegration: (options?: AnthropicAiOptions | undefined) => import("@sentry/core").Integration;
+export declare const anthropicAIIntegration: (options?: AnthropicAiOptions | undefined) => import("@sentry/core").Integration & {
+    name: "Anthropic_AI";
+};
 //# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/integrations/tracing/connect/index.d.ts

@@ -21,7 +21,9 @@ export declare const instrumentConnect: ((options?: unknown) => ConnectInstrumen
  * })
  * ```
  */
-export declare const connectIntegration: () => import("@sentry/core").Integration;
+export declare const connectIntegration: () => import("@sentry/core").Integration & {
+    name: "Connect";
+};
 /**
  * Add a Connect middleware to capture errors to Sentry.
  *

package/build/types-ts3.8/integrations/tracing/dataloader/index.d.ts

@@ -16,5 +16,7 @@ export declare const instrumentDataloader: ((options?: unknown) => DataloaderIns
  * });
  * ```
  */
-export declare const dataloaderIntegration: () => import("@sentry/core").Integration;
+export declare const dataloaderIntegration: () => import("@sentry/core").Integration & {
+    name: "Dataloader";
+};
 //# sourceMappingURL=index.d.ts.map

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

@@ -13,5 +13,7 @@ export declare class ExpressInstrumentation extends InstrumentationBase<ExpressI
     constructor(config?: ExpressInstrumentationConfig);
     init(): InstrumentationNodeModuleDefinition;
 }
-export declare const expressIntegration: (options?: ExpressInstrumentationConfig | undefined) => import("@sentry/core").Integration;
+export declare const expressIntegration: (options?: ExpressInstrumentationConfig | undefined) => import("@sentry/core").Integration & {
+    name: "Express";
+};
 //# sourceMappingURL=express.d.ts.map