@depup/sentry__node 10.47.0-depup.1 → 10.67.0-depup.0

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

@@ -1 +1 @@
-{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/tracing/vercelai/instrumentation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,+BAA+B,EAAE,MAAM,gCAAgC,CAAC;AAC7G,OAAO,EAAE,mBAAmB,EAAuC,MAAM,gCAAgC,CAAC;AAsC1G,UAAU,gBAAgB;IACxB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AA6BD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAY5D;AAgDD;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,IAAI,CAWxE;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CACxC,2BAA2B,EAAE,gBAAgB,GAAG,SAAS,EACzD,sBAAsB,EAAE,gBAAgB,EACxC,0BAA0B,EAAE,OAAO,GAAG,SAAS,EAC/C,uBAAuB,EAAE,OAAO,GAC/B;IAAE,YAAY,EAAE,OAAO,CAAC;IAAC,aAAa,EAAE,OAAO,CAAA;CAAE,CAoBnD;AAED;;;;;GAKG;AACH,qBAAa,6BAA8B,SAAQ,mBAAmB;IACpE,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,UAAU,CAAsB;gBAErB,MAAM,GAAE,qBAA0B;IAIrD;;OAEG;IACI,IAAI,IAAI,+BAA+B;IAK9C;;;OAGG;IACI,eAAe,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI;IAQlD;;OAEG;IACH,OAAO,CAAC,MAAM;CA6Ef"}
+{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/tracing/vercelai/instrumentation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,+BAA+B,EAAE,MAAM,gCAAgC,CAAC;AAC7G,OAAO,EAAE,mBAAmB,EAAuC,MAAM,gCAAgC,CAAC;AAsC1G,UAAU,gBAAgB;IACxB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AA6BD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAY5D;AAgDD;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,IAAI,CAWxE;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CACxC,2BAA2B,EAAE,gBAAgB,GAAG,SAAS,EACzD,sBAAsB,EAAE,gBAAgB,EACxC,0BAA0B,EAAE,OAAO,GAAG,SAAS,EAC/C,oBAAoB,EAAE,OAAO,EAC7B,qBAAqB,EAAE,OAAO,GAC7B;IAAE,YAAY,EAAE,OAAO,CAAC;IAAC,aAAa,EAAE,OAAO,CAAA;CAAE,CAoBnD;AAED;;;;;GAKG;AACH,qBAAa,6BAA8B,SAAQ,mBAAmB;IACpE,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,UAAU,CAAsB;gBAErB,MAAM,GAAE,qBAA0B;IAIrD;;OAEG;IACI,IAAI,IAAI,+BAA+B;IAK9C;;;OAGG;IACI,eAAe,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI;IAQlD;;OAEG;IACH,OAAO,CAAC,MAAM;CA8Ef"}

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

@@ -38,13 +38,15 @@ export type TelemetrySettings = {
 export declare type AttributeValue = string | number | boolean | Array<null | undefined | string> | Array<null | undefined | number> | Array<null | undefined | boolean>;
 export interface VercelAiOptions {
     /**
-     * Enable or disable input recording. Enabled if `sendDefaultPii` is `true`
-     * or if you set `isEnabled` to `true` in your ai SDK method telemetry settings
+     * Enable or disable input recording. Enabled if `dataCollection.genAI.inputs` (or the deprecated `sendDefaultPii` option) is `true`
+     * or if you set `isEnabled` to `true` in your ai SDK method telemetry settings.
+     * Integration-level options take precedence over global `dataCollection` config.
      */
     recordInputs?: boolean;
     /**
-     * Enable or disable output recording. Enabled if `sendDefaultPii` is `true`
-     * or if you set `isEnabled` to `true` in your ai SDK method telemetry settings
+     * Enable or disable output recording. Enabled if `dataCollection.genAI.outputs` (or the deprecated `sendDefaultPii` option) is `true`
+     * or if you set `isEnabled` to `true` in your ai SDK method telemetry settings.
+     * Integration-level options take precedence over global `dataCollection` config.
      */
     recordOutputs?: boolean;
     /**
@@ -52,6 +54,11 @@ export interface VercelAiOptions {
      * If you want to register the span processors even when the ai package usage cannot be detected, you can set `force` to `true`.
      */
     force?: boolean;
+    /**
+     * Enable or disable truncation of recorded input messages.
+     * Defaults to `true`.
+     */
+    enableTruncation?: boolean;
 }
 export interface VercelAiIntegration extends Integration {
     options: VercelAiOptions;

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/tracing/vercelai/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;CAC3C,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,OAAO,MAAM,cAAc,GAC9B,MAAM,GACN,MAAM,GACN,OAAO,GACP,KAAK,CAAC,IAAI,GAAG,SAAS,GAAG,MAAM,CAAC,GAChC,KAAK,CAAC,IAAI,GAAG,SAAS,GAAG,MAAM,CAAC,GAChC,KAAK,CAAC,IAAI,GAAG,SAAS,GAAG,OAAO,CAAC,CAAC;AAEtC,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,mBAAoB,SAAQ,WAAW;IACtD,OAAO,EAAE,eAAe,CAAC;CAC1B"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/integrations/tracing/vercelai/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;CAC3C,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,OAAO,MAAM,cAAc,GAC9B,MAAM,GACN,MAAM,GACN,OAAO,GACP,KAAK,CAAC,IAAI,GAAG,SAAS,GAAG,MAAM,CAAC,GAChC,KAAK,CAAC,IAAI,GAAG,SAAS,GAAG,MAAM,CAAC,GAChC,KAAK,CAAC,IAAI,GAAG,SAAS,GAAG,OAAO,CAAC,CAAC;AAEtC,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;;OAIG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,MAAM,WAAW,mBAAoB,SAAQ,WAAW;IACtD,OAAO,EAAE,eAAe,CAAC;CAC1B"}

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

@@ -0,0 +1,41 @@
+import type { Integration } from '@sentry/core';
+/**
+ * The orchestrion-driven pieces, resolved lazily by the opt-in loader.
+ *
+ * IMPORTANT: this module (and everything `init()` imports) must NOT reference
+ * the orchestrion code (`@sentry/server-utils/orchestrion/*`). The only
+ * reference lives inside `experimentalUseDiagnosticsChannelInjection()` (a
+ * separate module, reachable solely through that public export). That's the
+ * tree-shaking boundary: if an app never calls the opt-in function, then a
+ * bundler drops the entire orchestrion subtree, including its transitive
+ * dependencies, while an app that does call it gets it bundled
+ * normally.
+ */
+export interface DiagnosticsChannelInjection {
+    /** Channel-based integrations to register, replacing their OTel equivalents. */
+    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. */
+    register: () => void;
+    /** Warns (DEBUG only) about missing or doubled channel injection. */
+    detect: () => void;
+}
+/**
+ * Set by `experimentalUseDiagnosticsChannelInjection()`. The loader
+ * is the only thing that pulls in the orchestrion modules; see
+ * {@link DiagnosticsChannelInjection) re tree-shaking concerns this addresses.
+ *
+ * @internal
+ */
+export declare function setDiagnosticsChannelInjectionLoader(load: () => DiagnosticsChannelInjection): void;
+/** Whether `experimentalUseDiagnosticsChannelInjection()` was called. */
+export declare function isDiagnosticsChannelInjectionEnabled(): boolean;
+/**
+ * Resolve and memoize the orchestrion pieces. This is what actually loads
+ * the orchestrion modules. Returns `undefined` if the app never opted in.
+ * Callers gate this on span recording, so the modules load only when both
+ * opted in and tracing is enabled.
+ */
+export declare function resolveDiagnosticsChannelInjection(): DiagnosticsChannelInjection | undefined;
+//# sourceMappingURL=diagnosticsChannelInjection.d.ts.map

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

@@ -0,0 +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,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

@@ -0,0 +1,37 @@
+import { channelIntegrations } from '@sentry/server-utils/orchestrion';
+import type { RegisterDiagnosticsChannelInjectionOptions } from '@sentry/server-utils/orchestrion/register';
+export declare function diagnosticsChannelInjectionIntegrations(): typeof channelIntegrations;
+/**
+ * EXPERIMENTAL: opt into diagnostics-channel-based auto-instrumentation.
+ *
+ * Call this BEFORE `Sentry.init()`:
+ *
+ * ```ts
+ * import * as Sentry from '@sentry/node';
+ *
+ * Sentry.experimentalUseDiagnosticsChannelInjection();
+ * Sentry.init({
+ *   dsn: '__DSN__',
+ *   // other settings...
+ * });
+ * ```
+ *
+ * When this has been called AND span recording is enabled, `Sentry.init()`
+ * uses the diagnostics-channel-injection-based integrations instead of the
+ * OpenTelemetry ones, and installs the module hooks that inject the channels
+ * (so libraries imported after `init()` publish the channel events).
+ *
+ * This is a standalone function rather than an `init()` option so that a
+ * bundler drops all of it (and its transitive deps) when this function isn't
+ * called. `init()` reads the loader registered below.
+ *
+ * An app that DOES call it gets the orchestrion code bundled as intended.
+ *
+ * In an unbundled (server-side runtime) app this eagerly loads only the small
+ * subscriber/channel modules; the heavy code-transform dependencies stay lazy
+ * inside `register()` and load only when injection actually runs.
+ *
+ * @experimental May change or be removed in any release.
+ */
+export declare function experimentalUseDiagnosticsChannelInjection(options?: RegisterDiagnosticsChannelInjectionOptions): void;
+//# sourceMappingURL=experimentalUseDiagnosticsChannelInjection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"experimentalUseDiagnosticsChannelInjection.d.ts","sourceRoot":"","sources":["../../../src/sdk/experimentalUseDiagnosticsChannelInjection.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EAIpB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,KAAK,EAAE,0CAA0C,EAAE,MAAM,2CAA2C,CAAC;AAM5G,wBAAgB,uCAAuC,IAAI,OAAO,mBAAmB,CAEpF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,0CAA0C,CAIxD,OAAO,CAAC,EAAE,0CAA0C,GACnD,IAAI,CAwBN"}

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

@@ -7,6 +7,24 @@ import type { NodeOptions } from '../types';
 export declare function getDefaultIntegrationsWithoutPerformance(): Integration[];
 /** Get the default integrations for the Node SDK. */
 export declare function getDefaultIntegrations(options: Options): Integration[];
+/**
+ * When the app opted into diagnostics-channel injection (via
+ * `experimentalUseDiagnosticsChannelInjection()`) AND span recording is enabled, drop the OTel
+ * integrations that have a channel-based replacement and append the FULL channel-integration set,
+ * so the two never both instrument the same library. Otherwise returns `integrations` unchanged.
+ *
+ * `_init` applies the same swap to `defaultIntegrations`, but SDKs that seed their integrations
+ * through the user `integrations` option instead (e.g. the `@sentry/aws-serverless` Lambda layer
+ * entry) never hit that path, so they call this directly from their own `getDefaultIntegrations`.
+ *
+ * Note the asymmetry: appended channel integrations are not limited to ones whose OTel counterpart
+ * was in `integrations`. For `@sentry/node` that makes no difference (the incoming list carries the
+ * whole OTel performance set), but a caller with a narrower list (e.g. `@sentry/aws-serverless`)
+ * gains channel coverage for libraries it never shipped OTel integrations for. Channel integrations
+ * produce nothing but spans, so this is gated on span recording. Exported so SDKs that build their
+ * own default-integration set can apply the same logic instead of duplicating it.
+ */
+export declare function applyDiagnosticsChannelInjectionIntegrations(integrations: Integration[], options: Options): Integration[];
 /**
  * Initialize Sentry for Node.
  */

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/sdk/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AASpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAG5C;;GAEG;AACH,wBAAgB,wCAAwC,IAAI,WAAW,EAAE,CAOxE;AAED,qDAAqD;AACrD,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,WAAW,EAAE,CAStE;AAED;;GAEG;AACH,wBAAgB,IAAI,CAAC,OAAO,GAAE,WAAW,GAAG,SAAc,GAAG,UAAU,GAAG,SAAS,CAElF;AA4BD;;GAEG;AACH,wBAAgB,8BAA8B,CAAC,OAAO,GAAE,WAAW,GAAG,SAAc,GAAG,UAAU,GAAG,SAAS,CAE5G"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/sdk/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AASpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAO5C;;GAEG;AACH,wBAAgB,wCAAwC,IAAI,WAAW,EAAE,CAOxE;AAED,qDAAqD;AACrD,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,WAAW,EAAE,CAStE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,4CAA4C,CAC1D,YAAY,EAAE,WAAW,EAAE,EAC3B,OAAO,EAAE,OAAO,GACf,WAAW,EAAE,CASf;AAED;;GAEG;AACH,wBAAgB,IAAI,CAAC,OAAO,GAAE,WAAW,GAAG,SAAc,GAAG,UAAU,GAAG,SAAS,CAElF;AAsED;;GAEG;AACH,wBAAgB,8BAA8B,CAAC,OAAO,GAAE,WAAW,GAAG,SAAc,GAAG,UAAU,GAAG,SAAS,CAE5G"}

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

@@ -1,7 +1,6 @@
 import type { SpanProcessor } from '@opentelemetry/sdk-trace-base';
-import { BasicTracerProvider } from '@opentelemetry/sdk-trace-base';
 import { type NodeClient } from '@sentry/node-core';
-import { type AsyncLocalStorageLookup } from '@sentry/opentelemetry';
+import { type AsyncLocalStorageLookup, type OpenTelemetryTracerProvider } from '@sentry/opentelemetry';
 interface AdditionalOpenTelemetryOptions {
     /** Additional SpanProcessor instances that should be used. */
     spanProcessors?: SpanProcessor[];
@@ -21,7 +20,7 @@ interface NodePreloadOptions {
  */
 export declare function preloadOpenTelemetry(options?: NodePreloadOptions): void;
 /** Just exported for tests. */
-export declare function setupOtel(client: NodeClient, options?: AdditionalOpenTelemetryOptions): [BasicTracerProvider, AsyncLocalStorageLookup];
+export declare function setupOtel(client: NodeClient, options?: AdditionalOpenTelemetryOptions): [OpenTelemetryTracerProvider | undefined, AsyncLocalStorageLookup | undefined];
 /** Just exported for tests. */
 export declare function _clampSpanProcessorTimeout(maxSpanWaitDuration: number | undefined): number | undefined;
 export {};

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

@@ -1 +1 @@
-{"version":3,"file":"initOtel.d.ts","sourceRoot":"","sources":["../../../src/sdk/initOtel.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AACnE,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AAOpE,OAAO,EAEL,KAAK,UAAU,EAGhB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,KAAK,uBAAuB,EAI7B,MAAM,uBAAuB,CAAC;AAO/B,UAAU,8BAA8B;IACtC,8DAA8D;IAC9D,cAAc,CAAC,EAAE,aAAa,EAAE,CAAC;CAClC;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,GAAE,8BAAmC,GAAG,IAAI,CAQxG;AAED,UAAU,kBAAkB;IAC1B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,GAAE,kBAAuB,GAAG,IAAI,CAiB3E;AAgBD,+BAA+B;AAC/B,wBAAgB,SAAS,CACvB,MAAM,EAAE,UAAU,EAClB,OAAO,GAAE,8BAAmC,GAC3C,CAAC,mBAAmB,EAAE,uBAAuB,CAAC,CA6BhD;AAED,+BAA+B;AAC/B,wBAAgB,0BAA0B,CAAC,mBAAmB,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAiBtG"}
+{"version":3,"file":"initOtel.d.ts","sourceRoot":"","sources":["../../../src/sdk/initOtel.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAGnE,OAAO,EAEL,KAAK,UAAU,EAGhB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAEL,KAAK,uBAAuB,EAG5B,KAAK,2BAA2B,EAMjC,MAAM,uBAAuB,CAAC;AA8D/B,UAAU,8BAA8B;IACtC,8DAA8D;IAC9D,cAAc,CAAC,EAAE,aAAa,EAAE,CAAC;CAClC;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,GAAE,8BAAmC,GAAG,IAAI,CAQxG;AAED,UAAU,kBAAkB;IAC1B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,GAAE,kBAAuB,GAAG,IAAI,CAiB3E;AAgBD,+BAA+B;AAC/B,wBAAgB,SAAS,CACvB,MAAM,EAAE,UAAU,EAClB,OAAO,GAAE,8BAAmC,GAC3C,CAAC,2BAA2B,GAAG,SAAS,EAAE,uBAAuB,GAAG,SAAS,CAAC,CAkChF;AAqDD,+BAA+B;AAC/B,wBAAgB,0BAA0B,CAAC,mBAAmB,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAiBtG"}

package/build/types/utils/redisCache.d.ts

@@ -1,4 +1,4 @@
-import type { CommandArgs as IORedisCommandArgs } from '@opentelemetry/instrumentation-ioredis';
+export type IORedisCommandArgs = Array<string | Buffer | number | unknown[]>;
 export declare const GET_COMMANDS: string[];
 export declare const SET_COMMANDS: string[];
 /** Checks if a given command is in the list of redis commands.

package/build/types/utils/redisCache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"redisCache.d.ts","sourceRoot":"","sources":["../../../src/utils/redisCache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,IAAI,kBAAkB,EAAE,MAAM,wCAAwC,CAAC;AAIhG,eAAO,MAAM,YAAY,UAAkB,CAAC;AAC5C,eAAO,MAAM,YAAY,UAAmB,CAAC;AAG7C;6FAC6F;AAC7F,wBAAgB,YAAY,CAAC,aAAa,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAE9E;AAED,yDAAyD;AACzD,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,GACd,WAAW,GAAG,WAAW,GAAG,cAAc,GAAG,aAAa,GAAG,SAAS,CAQxE;AAMD,2FAA2F;AAC3F,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,kBAAkB,GAAG,MAAM,EAAE,GAAG,SAAS,CA0BzG;AAED;uEACuE;AACvE,wBAAgB,sBAAsB,CAAC,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAWxG;AAED,wDAAwD;AACxD,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAmB5E"}
+{"version":3,"file":"redisCache.d.ts","sourceRoot":"","sources":["../../../src/utils/redisCache.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG,KAAK,CAAC,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,EAAE,CAAC,CAAC;AAI7E,eAAO,MAAM,YAAY,UAAkB,CAAC;AAC5C,eAAO,MAAM,YAAY,UAAmB,CAAC;AAG7C;6FAC6F;AAC7F,wBAAgB,YAAY,CAAC,aAAa,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAE9E;AAED,yDAAyD;AACzD,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,GACd,WAAW,GAAG,WAAW,GAAG,cAAc,GAAG,aAAa,GAAG,SAAS,CAQxE;AAMD,2FAA2F;AAC3F,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,kBAAkB,GAAG,MAAM,EAAE,GAAG,SAAS,CA0BzG;AAED;uEACuE;AACvE,wBAAgB,sBAAsB,CAAC,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAWxG;AAED,wDAAwD;AACxD,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAmB5E"}

package/build/types/utils/setHttpServerSpanRouteAttribute.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Set the `http.route` attribute on the root HTTP server span for the current trace.
+ *
+ * No-op when there is no active span, no root span, or the root span is not an
+ * `http.server` span — so framework instrumentations can call this unconditionally
+ * without risking attribute pollution on non-HTTP root spans.
+ */
+export declare function setHttpServerSpanRouteAttribute(route: string): void;
+//# sourceMappingURL=setHttpServerSpanRouteAttribute.d.ts.map

package/build/types/utils/setHttpServerSpanRouteAttribute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setHttpServerSpanRouteAttribute.d.ts","sourceRoot":"","sources":["../../../src/utils/setHttpServerSpanRouteAttribute.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAanE"}

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

@@ -13,7 +13,7 @@ export { mysql2Integration } from './integrations/tracing/mysql2';
 export { redisIntegration } from './integrations/tracing/redis';
 export { postgresIntegration } from './integrations/tracing/postgres';
 export { postgresJsIntegration } from './integrations/tracing/postgresjs';
-export { prismaIntegration } from './integrations/tracing/prisma';
+export { prismaIntegration } from '@sentry/server-utils';
 export { hapiIntegration, setupHapiErrorHandler } from './integrations/tracing/hapi';
 export { honoIntegration, setupHonoErrorHandler } from './integrations/tracing/hono';
 export { koaIntegration, setupKoaErrorHandler } from './integrations/tracing/koa';
@@ -31,12 +31,14 @@ export { langChainIntegration } from './integrations/tracing/langchain';
 export { langGraphIntegration } from './integrations/tracing/langgraph';
 export { launchDarklyIntegration, buildLaunchDarklyFlagUsedHandler, openFeatureIntegration, OpenFeatureIntegrationHook, statsigIntegration, unleashIntegration, growthbookIntegration, } from './integrations/featureFlagShims';
 export { firebaseIntegration } from './integrations/tracing/firebase';
-export { init, getDefaultIntegrations, getDefaultIntegrationsWithoutPerformance, initWithoutDefaultIntegrations, } from './sdk';
+export { init, getDefaultIntegrations, getDefaultIntegrationsWithoutPerformance, initWithoutDefaultIntegrations, applyDiagnosticsChannelInjectionIntegrations, } from './sdk';
+export { experimentalUseDiagnosticsChannelInjection, diagnosticsChannelInjectionIntegrations, } from './sdk/experimentalUseDiagnosticsChannelInjection';
+export { isDiagnosticsChannelInjectionEnabled } from './sdk/diagnosticsChannelInjection';
 export { initOpenTelemetry, preloadOpenTelemetry } from './sdk/initOtel';
 export { getAutoPerformanceIntegrations } from './integrations/tracing';
 export { NodeOptions } from './types';
 export { setOpenTelemetryContextAsyncContextStrategy as setNodeAsyncContextStrategy, } from '@sentry/opentelemetry';
-export { addBreadcrumb, isInitialized, isEnabled, getGlobalScope, lastEventId, close, createTransport, flush, SDK_VERSION, getSpanStatusFromHttpCode, setHttpStatus, captureCheckIn, withMonitor, requestDataIntegration, functionToStringIntegration, inboundFiltersIntegration, eventFiltersIntegration, linkedErrorsIntegration, addEventProcessor, setContext, setExtra, setExtras, setTag, setTags, setUser, setConversationId, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE, setCurrentClient, Scope, setMeasurement, getSpanDescendants, parameterize, getClient, getCurrentScope, getIsolationScope, getTraceData, getTraceMetaTags, httpHeadersToSpanAttributes, winterCGHeadersToDict, continueTrace, withScope, withIsolationScope, captureException, captureEvent, captureMessage, captureFeedback, captureConsoleIntegration, dedupeIntegration, extraErrorDataIntegration, rewriteFramesIntegration, startSession, captureSession, endSession, addIntegration, startSpan, startSpanManual, startInactiveSpan, startNewTrace, suppressTracing, getActiveSpan, withActiveSpan, getRootSpan, spanToJSON, spanToTraceHeader, spanToBaggageHeader, trpcMiddleware, updateSpanName, supabaseIntegration, instrumentSupabaseClient, instrumentOpenAiClient, instrumentAnthropicAiClient, instrumentGoogleGenAIClient, zodErrorsIntegration, profiler, consoleLoggingIntegration, createConsolaReporter, consoleIntegration, wrapMcpServerWithSentry, featureFlagsIntegration, createLangChainCallbackHandler, instrumentLangGraph, instrumentStateGraphCompile, } from '@sentry/core';
+export { addBreadcrumb, isInitialized, isEnabled, getGlobalScope, lastEventId, close, createTransport, flush, SDK_VERSION, getSpanStatusFromHttpCode, setHttpStatus, captureCheckIn, withMonitor, requestDataIntegration, functionToStringIntegration, inboundFiltersIntegration, eventFiltersIntegration, linkedErrorsIntegration, addEventProcessor, setContext, setExtra, setExtras, setTag, setTags, setAttribute, setAttributes, setUser, setConversationId, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE, setCurrentClient, Scope, setMeasurement, getSpanDescendants, parameterize, getClient, getCurrentScope, getIsolationScope, getTraceData, getTraceMetaTags, httpHeadersToSpanAttributes, winterCGHeadersToDict, continueTrace, withScope, withIsolationScope, captureException, captureEvent, captureMessage, captureFeedback, captureConsoleIntegration, dedupeIntegration, extraErrorDataIntegration, rewriteFramesIntegration, startSession, captureSession, endSession, addIntegration, startSpan, startSpanManual, startInactiveSpan, startNewTrace, bindScopeToEmitter, suppressTracing, getActiveSpan, withActiveSpan, getRootSpan, spanToJSON, spanToTraceHeader, spanToBaggageHeader, trpcMiddleware, updateSpanName, supabaseIntegration, instrumentSupabaseClient, instrumentOpenAiClient, instrumentAnthropicAiClient, instrumentGoogleGenAIClient, zodErrorsIntegration, profiler, consoleLoggingIntegration, createConsolaReporter, wrapMcpServerWithSentry, featureFlagsIntegration, spanStreamingIntegration, createLangChainCallbackHandler, instrumentLangChainEmbeddings, instrumentLangGraph, instrumentStateGraphCompile, } from '@sentry/core';
 export { Breadcrumb, BreadcrumbHint, PolymorphicRequest, RequestEventData, SdkInfo, Event, EventHint, ErrorEvent, Exception, Session, SeverityLevel, StackFrame, Stacktrace, Thread, User, Span, Metric, Log, LogSeverityLevel, FeatureFlagsIntegration, ExclusiveEventHintOrCaptureContext, CaptureContext, } from '@sentry/core';
-export { logger, metrics, httpServerIntegration, httpServerSpansIntegration, nodeContextIntegration, contextLinesIntegration, localVariablesIntegration, modulesIntegration, onUncaughtExceptionIntegration, onUnhandledRejectionIntegration, anrIntegration, disableAnrDetectionForCallback, spotlightIntegration, childProcessIntegration, processSessionIntegration, nodeRuntimeMetricsIntegration, NodeRuntimeMetricsOptions, pinoIntegration, createSentryWinstonTransport, SentryContextManager, systemErrorIntegration, generateInstrumentOnce, getSentryRelease, defaultStackParser, createGetModuleFromFilename, makeNodeTransport, NodeClient, cron, NODE_VERSION, validateOpenTelemetrySetup } from '@sentry/node-core';
+export { logger, metrics, httpServerIntegration, httpServerSpansIntegration, nodeContextIntegration, contextLinesIntegration, localVariablesIntegration, modulesIntegration, onUncaughtExceptionIntegration, onUnhandledRejectionIntegration, anrIntegration, disableAnrDetectionForCallback, spotlightIntegration, childProcessIntegration, processSessionIntegration, nodeRuntimeMetricsIntegration, NodeRuntimeMetricsOptions, consoleIntegration, pinoIntegration, createSentryWinstonTransport, SentryContextManager, systemErrorIntegration, generateInstrumentOnce, getSentryRelease, defaultStackParser, createGetModuleFromFilename, makeNodeTransport, NodeClient, cron, NODE_VERSION, validateOpenTelemetrySetup, withStreamedSpan, _INTERNAL_normalizeCollectionInterval } from '@sentry/node-core';
 //# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,14 @@
+import { FsInstrumentationConfig } from './vendored/types';
+/**
+ * This integration will create spans for `fs` API operations, like reading and writing files.
+ *
+ * **WARNING:** This integration may add significant overhead to your application. Especially in scenarios with a lot of
+ * file I/O, like for example when running a framework dev server, including this integration can massively slow down
+ * your application.
+ *
+ * @param options Configuration for this 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/fs/vendored/constants.d.ts

@@ -0,0 +1,5 @@
+import { FMember, FPMember } from './types';
+export declare const PROMISE_FUNCTIONS: FPMember[];
+export declare const CALLBACK_FUNCTIONS: FMember[];
+export declare const SYNC_FUNCTIONS: FMember[];
+//# sourceMappingURL=constants.d.ts.map

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

@@ -0,0 +1,3 @@
+import { FsInstrumentationConfig } from './types';
+export declare function enableFsInstrumentation(config?: FsInstrumentationConfig): void;
+//# sourceMappingURL=instrumentation.d.ts.map

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

@@ -0,0 +1,23 @@
+import * as fs from 'fs';
+export type GenericFunction = (...args: any[]) => unknown;
+export type FunctionPropertyNames<T> = Exclude<{
+    [K in keyof T]: T[K] extends Function ? K : never;
+}[keyof T], undefined>;
+export type FunctionPropertyNamesTwoLevels<T> = Exclude<{
+    [K in keyof T]: {
+        [L in keyof T[K]]: L extends string ? T[K][L] extends Function ? K extends string ? L extends string ? string : never : never : never : never;
+    }[keyof T[K]];
+}[keyof T], undefined>;
+export type FMember = FunctionPropertyNames<typeof fs> | FunctionPropertyNamesTwoLevels<typeof fs>;
+export type FPMember = FunctionPropertyNames<(typeof fs)['promises']> | FunctionPropertyNamesTwoLevels<(typeof fs)['promises']>;
+export interface FsInstrumentationConfig {
+    /**
+     * Setting this option to `true` will include any filepath arguments from your `fs` API calls as span attributes.
+     */
+    recordFilePaths?: boolean;
+    /**
+     * Setting this option to `true` will include the error messages of failed `fs` API calls as a span attribute.
+     */
+    recordErrorMessagesAsSpanAttributes?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,15 @@
+import * as fs from 'fs';
+import { FMember, FunctionPropertyNames, GenericFunction } from './types';
+type FS = typeof fs;
+export declare function splitTwoLevels<FSObject>(functionName: FMember): [
+    FunctionPropertyNames<FSObject> & string
+] | [
+    FunctionPropertyNames<FSObject> & string,
+    string
+];
+export declare function indexFs<FSObject extends FS | FS['promises']>(fs: FSObject, member: FMember): {
+    objectToPatch: Record<string, GenericFunction>;
+    functionNameToPatch: string;
+};
+export {};
+//# sourceMappingURL=utils.d.ts.map

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

@@ -1,8 +1,6 @@
-import { ClientRequest, IncomingMessage, RequestOptions, ServerResponse } from 'node:http';
-import { HttpInstrumentationConfig } from '@opentelemetry/instrumentation-http';
-import { Span } from '@sentry/core';
-import { HTTPModuleRequestIncomingMessage, SentryHttpInstrumentationOptions } from '@sentry/node-core';
-import { NodeClientOptions } from '../types';
+import { RequestOptions } from 'node:http';
+import { HttpClientRequest, HttpIncomingMessage, HttpServerResponse, Span } from '@sentry/core';
+import { instrumentHttpOutgoingRequests } from '@sentry/node-core';
 interface HttpOptions {
     /**
      * Whether breadcrumbs should be recorded for outgoing requests.
@@ -61,12 +59,12 @@ interface HttpOptions {
      * 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: IncomingMessage) => boolean;
+    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: IncomingMessage, response: ServerResponse) => void;
+    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.
@@ -117,23 +115,20 @@ interface HttpOptions {
      * Additional instrumentation options that are passed to the underlying HttpInstrumentation.
      */
     instrumentation?: {
-        requestHook?: (span: Span, req: ClientRequest | HTTPModuleRequestIncomingMessage) => void;
-        responseHook?: (span: Span, response: HTTPModuleRequestIncomingMessage | ServerResponse) => void;
-        applyCustomAttributesOnSpan?: (span: Span, request: ClientRequest | HTTPModuleRequestIncomingMessage, response: HTTPModuleRequestIncomingMessage | ServerResponse) => void;
+        requestHook?: (span: Span, req: HttpIncomingMessage | HttpClientRequest) => void;
+        responseHook?: (span: Span, response: HttpIncomingMessage | HttpServerResponse) => void;
+        applyCustomAttributesOnSpan?: (span: Span, request: HttpIncomingMessage | HttpClientRequest, response: HttpIncomingMessage | HttpServerResponse) => void;
     };
 }
-export declare const instrumentSentryHttp: ((options?: SentryHttpInstrumentationOptions | undefined) => import("@opentelemetry/instrumentation").Instrumentation<import("@opentelemetry/instrumentation").InstrumentationConfig>) & {
+export declare const instrumentSentryHttp: typeof instrumentHttpOutgoingRequests & {
     id: string;
 };
-export declare const instrumentOtelHttp: ((options?: HttpInstrumentationConfig | undefined) => import("@opentelemetry/instrumentation").Instrumentation<import("@opentelemetry/instrumentation").InstrumentationConfig>) & {
-    id: string;
-};
-/** Exported only for tests. */
-export declare function _shouldUseOtelHttpInstrumentation(options: HttpOptions, clientOptions?: Partial<NodeClientOptions>): boolean;
 /**
  * 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.d.ts

@@ -1,36 +1,9 @@
-import { UndiciInstrumentationConfig } from '@opentelemetry/instrumentation-undici';
-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 '@sentry/node-core';
+/**
+ * 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=node-fetch.d.ts.map

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

@@ -0,0 +1,9 @@
+import { InstrumentationModuleFile } from '@opentelemetry/instrumentation';
+export declare class InstrumentationNodeModuleFile implements InstrumentationModuleFile {
+    name: string;
+    supportedVersions: string[];
+    patch: (moduleExports: any, moduleVersion?: string) => any;
+    unpatch: (moduleExports?: any, moduleVersion?: string) => void;
+    constructor(name: string, supportedVersions: string[], patch: (moduleExports: any, moduleVersion?: string) => any, unpatch: (moduleExports?: any, moduleVersion?: string) => void);
+}
+//# sourceMappingURL=InstrumentationNodeModuleFile.d.ts.map

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

@@ -1,4 +1,4 @@
-import { AmqplibInstrumentation } from '@opentelemetry/instrumentation-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;
-//# sourceMappingURL=amqplib.d.ts.map
+export declare const amqplibIntegration: () => import("@sentry/core").Integration & {
+    name: "Amqplib";
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,44 @@
+export interface Connection {
+    connection: {
+        serverProperties: {
+            product?: string;
+            [key: string]: any;
+        };
+    };
+    [key: string]: any;
+}
+export interface Channel {
+    connection: Connection;
+    [key: string]: any;
+}
+export interface ConfirmChannel extends Channel {
+}
+export declare namespace Options {
+    interface Connect {
+        protocol?: string;
+        hostname?: string;
+        port?: number;
+        username?: string;
+        vhost?: string;
+    }
+    interface Consume {
+        consumerTag?: string;
+        noLocal?: boolean;
+        noAck?: boolean;
+        exclusive?: boolean;
+        priority?: number;
+        arguments?: any;
+    }
+    interface Publish {
+        headers?: any;
+        [key: string]: any;
+    }
+}
+export declare namespace Replies {
+    interface Empty {
+    }
+    interface Consume {
+        consumerTag: string;
+    }
+}
+//# sourceMappingURL=amqplib-types.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

@@ -0,0 +1,23 @@
+/** A string identifying the kind of message consumption. */
+export declare const ATTR_MESSAGING_OPERATION: "messaging.operation";
+/** 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