@sentry/node 10.70.0 → 11.0.0-alpha.1

package/build/types/types.d.ts

@@ -1,32 +1,35 @@
-import type { Span as WriteableSpan } from '@opentelemetry/api';
-import type { ReadableSpan } from '@opentelemetry/sdk-trace-base';
-import type { ClientOptions, Options, SamplingContext, Scope, Span } from '@sentry/core';
-import type { NodeTransportOptions, OpenTelemetryServerRuntimeOptions } from '@sentry/node-core';
+import type { ClientOptions, Options, Scope, ServerRuntimeOptions } from '@sentry/core';
+import type { NodeTransportOptions } from './transports';
 /**
  * Base options for the Sentry Node SDK.
- * Extends the common WinterTC options with OpenTelemetry support shared with Bun and other server-side SDKs.
  */
-export interface BaseNodeOptions extends OpenTelemetryServerRuntimeOptions {
+export interface BaseNodeOptions extends ServerRuntimeOptions {
     /**
-     * Sets profiling sample rate when @sentry/profiling-node is installed
+     * Controls whether the SDK registers its own Sentry OpenTelemetry tracer provider.
      *
-     * @deprecated
-     */
-    profilesSampleRate?: number;
-    /**
-     * Function to compute profiling sample rate dynamically and filter unwanted profiles.
-     *
-     * Profiling is enabled if either this or `profilesSampleRate` is defined. If both are defined, `profilesSampleRate` is
-     * ignored.
+     * When `false` (the default for most SDKs), no tracer provider is set up. The SDK isolates scopes
+     * with a native AsyncLocalStorage context strategy and still emits spans via its own
+     * instrumentation, but spans created through `@opentelemetry/api` are not captured.
      *
-     * Will automatically be passed a context object of default and optional custom data.
+     * When `true`, the SDK registers its own `SentryTracerProvider` (and `SentryPropagator`) as the
+     * global OpenTelemetry tracer provider, so spans created through `@opentelemetry/api` become Sentry
+     * spans. This is the default for the Next.js and SvelteKit SDKs. If you run your own tracer provider,
+     * keep this `false` so the SDK does not register a competing provider; note the SDK no longer feeds
+     * spans into a user-owned provider, so those spans stay in your OpenTelemetry pipeline.
      *
-     * @returns A sample rate between 0 and 1 (0 drops the profile, 1 guarantees it will be sent). Returning `true` is
-     * equivalent to returning 1 and returning `false` is equivalent to returning 0.
+     * @default false
+     */
+    enableOpenTelemetrySetup?: boolean;
+    /**
+     * Override the runtime name reported in events.
+     * Defaults to 'node' with the current process version if not specified.
      *
-     * @deprecated
+     * @hidden This is primarily used internally to support platforms like Next on OpenNext/Cloudflare.
      */
-    profilesSampler?: (samplingContext: SamplingContext) => number | boolean;
+    runtime?: {
+        name: string;
+        version?: string;
+    };
     /**
      * Sets profiling session sample rate for the entire profiling session (evaluated once per SDK initialization).
      *
@@ -50,15 +53,6 @@ export interface BaseNodeOptions extends OpenTelemetryServerRuntimeOptions {
      * Requires the `LocalVariables` integration.
      */
     includeLocalVariables?: boolean;
-    /**
-     * Whether to register ESM loader hooks to automatically instrument libraries.
-     * This is necessary to auto instrument libraries that are loaded via ESM imports, but it can cause issues
-     * with certain libraries. If you run into problems running your app with this enabled,
-     * please raise an issue in https://github.com/getsentry/sentry-javascript.
-     *
-     * Defaults to `true`.
-     */
-    registerEsmLoaderHooks?: boolean;
 }
 /**
  * Configuration options for the Sentry Node SDK
@@ -76,14 +70,4 @@ export interface CurrentScopes {
     scope: Scope;
     isolationScope: Scope;
 }
-/**
- * The base `Span` type is basically a `WriteableSpan`.
- * There are places where we basically want to allow passing _any_ span,
- * so in these cases we type this as `AbstractSpan` which could be either a regular `Span` or a `ReadableSpan`.
- * You'll have to make sur to check relevant fields before accessing them.
- *
- * Note that technically, the `Span` exported from `@opentelemetry/sdk-trace-base` matches this,
- * but we cannot be 100% sure that we are actually getting such a span, so this type is more defensive.
- */
-export type AbstractSpan = WriteableSpan | ReadableSpan | Span;
 //# sourceMappingURL=types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,IAAI,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAChE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,eAAe,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AACzF,OAAO,KAAK,EAAE,oBAAoB,EAAE,iCAAiC,EAAE,MAAM,mBAAmB,CAAC;AAEjG;;;GAGG;AACH,MAAM,WAAW,eAAgB,SAAQ,iCAAiC;IACxE;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAE5B;;;;;;;;;;;;OAYG;IACH,eAAe,CAAC,EAAE,CAAC,eAAe,EAAE,eAAe,KAAK,MAAM,GAAG,OAAO,CAAC;IAEzE;;;;OAIG;IACH,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAElC;;;;;;;;;OASG;IACH,gBAAgB,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC;IAEtC;;;;OAIG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAEhC;;;;;;;OAOG;IACH,sBAAsB,CAAC,EAAE,OAAO,CAAC;CAClC;AAED;;;GAGG;AACH,MAAM,WAAW,WAAY,SAAQ,OAAO,CAAC,oBAAoB,CAAC,EAAE,eAAe;CAAG;AAEtF;;;GAGG;AACH,MAAM,WAAW,iBAAkB,SAAQ,aAAa,CAAC,oBAAoB,CAAC,EAAE,eAAe;CAAG;AAElG,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,KAAK,CAAC;IACb,cAAc,EAAE,KAAK,CAAC;CACvB;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,GAAG,aAAa,GAAG,YAAY,GAAG,IAAI,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AACxF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAEzD;;GAEG;AACH,MAAM,WAAW,eAAgB,SAAQ,oBAAoB;IAC3D;;;;;;;;;;;;;;OAcG;IACH,wBAAwB,CAAC,EAAE,OAAO,CAAC;IAEnC;;;;;OAKG;IACH,OAAO,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC7C;;;;OAIG;IACH,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAElC;;;;;;;;;OASG;IACH,gBAAgB,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC;IAEtC;;;;OAIG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC;AAED;;;GAGG;AACH,MAAM,WAAW,WAAY,SAAQ,OAAO,CAAC,oBAAoB,CAAC,EAAE,eAAe;CAAG;AAEtF;;;GAGG;AACH,MAAM,WAAW,iBAAkB,SAAQ,aAAa,CAAC,oBAAoB,CAAC,EAAE,eAAe;CAAG;AAElG,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,KAAK,CAAC;IACb,cAAc,EAAE,KAAK,CAAC;CACvB"}

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

@@ -0,0 +1,5 @@
+import type { Span } from '@opentelemetry/api';
+import type { SpanOrigin } from '@sentry/core';
+/** Adds an origin to an OTEL Span. */
+export declare function addOriginToSpan(span: Span, origin: SpanOrigin): void;
+//# sourceMappingURL=addOriginToSpan.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"addOriginToSpan.d.ts","sourceRoot":"","sources":["../../../src/utils/addOriginToSpan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAG/C,sCAAsC;AACtC,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,GAAG,IAAI,CAEpE"}

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

@@ -0,0 +1,5 @@
+/**
+ * Was the debugger enabled when this function was first called?
+ */
+export declare function isDebuggerEnabled(): Promise<boolean>;
+//# sourceMappingURL=debug.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"debug.d.ts","sourceRoot":"","sources":["../../../src/utils/debug.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,OAAO,CAAC,CAY1D"}

package/build/types/utils/entry-point.d.ts

@@ -0,0 +1,24 @@
+export interface ProcessInterface {
+    execArgv: string[];
+    argv: string[];
+    cwd: () => string;
+}
+export interface ProcessArgs {
+    appPath: string;
+    importPaths: string[];
+    requirePaths: string[];
+}
+/**
+ * Parses the process arguments to determine the app path, import paths, and require paths.
+ */
+export declare function parseProcessPaths(proc: ProcessInterface): ProcessArgs;
+/**
+ * Gets the current entry point type.
+ *
+ * `app` means this function was most likely called via the app entry point.
+ * `import` means this function was most likely called from an --import cli arg.
+ * `require` means this function was most likely called from a --require cli arg.
+ * `unknown` means we couldn't determine for sure.
+ */
+export declare function getEntryPointType(proc?: ProcessInterface): 'import' | 'require' | 'app' | 'unknown';
+//# sourceMappingURL=entry-point.d.ts.map

package/build/types/utils/entry-point.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-point.d.ts","sourceRoot":"","sources":["../../../src/utils/entry-point.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,GAAG,EAAE,MAAM,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,gBAAgB,GAAG,WAAW,CAUrE;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,GAAE,gBAA0B,GAAG,QAAQ,GAAG,SAAS,GAAG,KAAK,GAAG,SAAS,CA2B5G"}

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

@@ -0,0 +1,5 @@
+/**
+ * @hidden
+ */
+export declare function logAndExitProcess(error: unknown): void;
+//# sourceMappingURL=errorhandling.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errorhandling.d.ts","sourceRoot":"","sources":["../../../src/utils/errorhandling.ts"],"names":[],"mappings":"AAMA;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CA4BtD"}

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

@@ -0,0 +1,3 @@
+/** Creates a function that gets the module name from a filename */
+export declare function createGetModuleFromFilename(basePath?: string, isWindows?: boolean): (filename: string | undefined) => string | undefined;
+//# sourceMappingURL=module.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../src/utils/module.ts"],"names":[],"mappings":"AAUA,mEAAmE;AACnE,wBAAgB,2BAA2B,CACzC,QAAQ,GAAE,MAAmE,EAC7E,SAAS,GAAE,OAAsB,GAChC,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,KAAK,MAAM,GAAG,SAAS,CAwCtD"}

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

@@ -0,0 +1,20 @@
+import type { LRUMap, Span } from '@sentry/core';
+import type { UndiciRequest, UndiciResponse } from '../integrations/node-fetch/types';
+/**
+ * Add trace propagation headers to an outgoing fetch/undici request.
+ *
+ * Checks if the request URL matches trace propagation targets,
+ * then injects sentry-trace, traceparent, and baggage headers.
+ *
+ * When a `span` is passed (the outgoing `http.client` span), its trace data is propagated so downstream
+ * services are parented to that span. Without a span, the active scope's trace data is used.
+ *
+ * Existing trace headers (e.g. set manually by the user via `getTraceData()`) always take precedence and
+ * are de-duplicated rather than overwritten, so we never emit two `sentry-trace`/`baggage` entries.
+ */
+export declare function addTracePropagationHeadersToFetchRequest(request: UndiciRequest, propagationDecisionMap: LRUMap<string, boolean>, span?: Span): void;
+/** Add a breadcrumb for an outgoing fetch/undici request. */
+export declare function addFetchRequestBreadcrumb(request: UndiciRequest, response: UndiciResponse): void;
+/** Get the absolute URL from an origin and path. */
+export declare function getAbsoluteUrl(origin: string, path?: string): string;
+//# sourceMappingURL=outgoingFetchRequest.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"outgoingFetchRequest.d.ts","sourceRoot":"","sources":["../../../src/utils/outgoingFetchRequest.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAwB,IAAI,EAAE,MAAM,cAAc,CAAC;AAiBvE,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAKtF;;;;;;;;;;;GAWG;AAEH,wBAAgB,wCAAwC,CACtD,OAAO,EAAE,aAAa,EACtB,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/C,IAAI,CAAC,EAAE,IAAI,GACV,IAAI,CAiFN;AA2GD,6DAA6D;AAC7D,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,cAAc,GAAG,IAAI,CAsBhG;AAmBD,oDAAoD;AACpD,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,GAAE,MAAY,GAAG,MAAM,CAkBzE"}

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

@@ -0,0 +1,17 @@
+import type { CaptureContext, EventHint, ScopeContext } from '@sentry/core';
+/**
+ * This type makes sure that we get either a CaptureContext, OR an EventHint.
+ * It does not allow mixing them, which could lead to unexpected outcomes, e.g. this is disallowed:
+ * { user: { id: '123' }, mechanism: { handled: false } }
+ */
+export type ExclusiveEventHintOrCaptureContext = (CaptureContext & Partial<{
+    [key in keyof EventHint]: never;
+}>) | (EventHint & Partial<{
+    [key in keyof ScopeContext]: never;
+}>);
+/**
+ * Parse either an `EventHint` directly, or convert a `CaptureContext` to an `EventHint`.
+ * This is used to allow to update method signatures that used to accept a `CaptureContext` but should now accept an `EventHint`.
+ */
+export declare function parseEventHintOrCaptureContext(hint: ExclusiveEventHintOrCaptureContext | undefined): EventHint | undefined;
+//# sourceMappingURL=prepareEvent.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prepareEvent.d.ts","sourceRoot":"","sources":["../../../src/utils/prepareEvent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,SAAS,EAA2B,YAAY,EAAE,MAAM,cAAc,CAAC;AAGrG;;;;GAIG;AACH,MAAM,MAAM,kCAAkC,GAC1C,CAAC,cAAc,GAAG,OAAO,CAAC;KAAG,GAAG,IAAI,MAAM,SAAS,GAAG,KAAK;CAAE,CAAC,CAAC,GAC/D,CAAC,SAAS,GAAG,OAAO,CAAC;KAAG,GAAG,IAAI,MAAM,YAAY,GAAG,KAAK;CAAE,CAAC,CAAC,CAAC;AAElE;;;GAGG;AACH,wBAAgB,8BAA8B,CAC5C,IAAI,EAAE,kCAAkC,GAAG,SAAS,GACnD,SAAS,GAAG,SAAS,CAiBvB"}

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

@@ -0,0 +1,8 @@
+/**
+ * Parse the spotlight option with proper precedence:
+ * - `false` or explicit string from options: use as-is
+ * - `true`: enable spotlight, but prefer a custom URL from the env var if set
+ * - `undefined`: defer entirely to the env var (bool or URL)
+ */
+export declare function getSpotlightConfig(optionsSpotlight: boolean | string | undefined): boolean | string | undefined;
+//# sourceMappingURL=spotlight.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"spotlight.d.ts","sourceRoot":"","sources":["../../../src/utils/spotlight.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,gBAAgB,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,GAAG,MAAM,GAAG,SAAS,CAgB/G"}

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@sentry/node",
-  "version": "10.70.0",
+  "version": "11.0.0-alpha.1",
   "description": "Sentry Node SDK using OpenTelemetry for performance instrumentation",
   "repository": "git://github.com/getsentry/sentry-javascript.git",
   "homepage": "https://github.com/getsentry/sentry-javascript/tree/master/packages/node",
   "author": "Sentry",
   "license": "MIT",
   "engines": {
-    "node": ">=18"
+    "node": ">=20.19.0 <22.0.0 || >=22.12.0 <23.0.0 || >=23.2.0"
   },
   "files": [
     "/build"
@@ -32,33 +32,45 @@
         "default": "./build/import-hook.mjs"
       }
     },
-    "./loader": {
+    "./vite": {
       "import": {
-        "default": "./build/loader-hook.mjs"
+        "types": "./build/types/bundler-plugin/vite.d.ts",
+        "default": "./build/esm/bundler-plugin/vite.js"
+      },
+      "require": {
+        "types": "./build/types/bundler-plugin/vite.d.ts",
+        "default": "./build/cjs/bundler-plugin/vite.js"
       }
     },
-    "./init": {
+    "./rollup": {
       "import": {
-        "default": "./build/esm/init.js"
+        "types": "./build/types/bundler-plugin/rollup.d.ts",
+        "default": "./build/esm/bundler-plugin/rollup.js"
       },
       "require": {
-        "default": "./build/cjs/init.js"
+        "types": "./build/types/bundler-plugin/rollup.d.ts",
+        "default": "./build/cjs/bundler-plugin/rollup.js"
       }
     },
-    "./preload": {
+    "./webpack": {
       "import": {
-        "default": "./build/esm/preload.js"
+        "types": "./build/types/bundler-plugin/webpack.d.ts",
+        "default": "./build/esm/bundler-plugin/webpack.js"
       },
       "require": {
-        "default": "./build/cjs/preload.js"
+        "types": "./build/types/bundler-plugin/webpack.d.ts",
+        "default": "./build/cjs/bundler-plugin/webpack.js"
+      }
+    },
+    "./esbuild": {
+      "import": {
+        "types": "./build/types/bundler-plugin/esbuild.d.ts",
+        "default": "./build/esm/bundler-plugin/esbuild.js"
+      },
+      "require": {
+        "types": "./build/types/bundler-plugin/esbuild.d.ts",
+        "default": "./build/cjs/bundler-plugin/esbuild.js"
       }
-    }
-  },
-  "typesVersions": {
-    "<5.0": {
-      "build/types/index.d.ts": [
-        "build/types-ts3.8/index.d.ts"
-      ]
     }
   },
   "publishConfig": {
@@ -66,14 +78,11 @@
   },
   "dependencies": {
     "@opentelemetry/api": "^1.9.1",
-    "@opentelemetry/instrumentation": "^0.220.0",
-    "@opentelemetry/sdk-trace-base": "^2.9.0",
-    "@sentry/conventions": "^0.16.0",
-    "@sentry/core": "10.70.0",
-    "@sentry/node-core": "10.70.0",
-    "@sentry/opentelemetry": "10.70.0",
-    "@sentry/server-utils": "10.70.0",
-    "import-in-the-middle": "^3.0.0"
+    "@sentry/conventions": "^0.19.0",
+    "@sentry/core": "11.0.0-alpha.1",
+    "@sentry/opentelemetry": "11.0.0-alpha.1",
+    "@sentry/server-utils": "11.0.0-alpha.1",
+    "@sentry/bundler-plugins": "11.0.0-alpha.1"
   },
   "devDependencies": {
     "@types/node": "^18.19.1"
@@ -82,17 +91,15 @@
     "build": "run-p build:transpile build:types",
     "build:dev": "yarn build",
     "build:transpile": "rollup -c rollup.npm.config.mjs",
-    "build:types": "run-s build:types:core build:types:downlevel",
-    "build:types:core": "tsc -p tsconfig.types.json",
-    "build:types:downlevel": "yarn downlevel-dts build/types build/types-ts3.8 --to ts3.8",
+    "build:types": "tsc -p tsconfig.types.json",
     "build:watch": "run-p build:transpile:watch",
     "build:dev:watch": "yarn build:watch",
     "build:transpile:watch": "rollup -c rollup.npm.config.mjs --watch",
     "build:tarball": "npm pack",
     "circularDepCheck": "madge --circular src/index.ts",
     "clean": "rimraf build coverage sentry-node-*.tgz",
-    "lint:fix": "OXLINT_TSGOLINT_DANGEROUSLY_SUPPRESS_PROGRAM_DIAGNOSTICS=true oxlint . --fix --type-aware",
-    "lint": "OXLINT_TSGOLINT_DANGEROUSLY_SUPPRESS_PROGRAM_DIAGNOSTICS=true oxlint . --type-aware",
+    "lint:fix": "oxlint . --fix --type-aware",
+    "lint": "oxlint . --type-aware",
     "lint:es-compatibility": "es-check es2022 ./build/cjs/*.js && es-check es2022 ./build/esm/*.js --module",
     "test": "yarn test:unit",
     "test:unit": "vitest run",
@@ -111,8 +118,7 @@
           "{projectRoot}/build/cjs",
           "{projectRoot}/build/npm/esm",
           "{projectRoot}/build/npm/cjs",
-          "{projectRoot}/build/import-hook.mjs",
-          "{projectRoot}/build/loader-hook.mjs"
+          "{projectRoot}/build/import-hook.mjs"
         ]
       }
     }

package/build/cjs/init.js

@@ -1,4 +0,0 @@
-const index = require('./sdk/index.js');
-
-index.init();
-//# sourceMappingURL=init.js.map

package/build/cjs/init.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"init.js","sources":["../../src/init.ts"],"sourcesContent":["import { init } from './sdk';\n\n/**\n * The @sentry/node/init export can be used with the node --import and --require args to initialize the SDK entirely via\n * environment variables.\n *\n * > SENTRY_DSN=https://examplePublicKey@o0.ingest.sentry.io/0 SENTRY_TRACES_SAMPLE_RATE=1.0 node --import=@sentry/node/init app.mjs\n */\ninit();\n"],"names":["init"],"mappings":";;AAQAA,UAAA,EAAK;;"}

package/build/cjs/integrations/http.js

@@ -1,69 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-const core = require('@sentry/core');
-const nodeCore = require('@sentry/node-core');
-const attributes = require('@sentry/conventions/attributes');
-
-const INTEGRATION_NAME = "Http";
-const instrumentSentryHttp = Object.assign(nodeCore.instrumentHttpOutgoingRequests, {
-  id: `${INTEGRATION_NAME}.sentry`
-});
-const httpIntegration = core.defineIntegration((options = {}) => {
-  const spans = options.spans ?? true;
-  const disableIncomingRequestSpans = options.disableIncomingRequestSpans;
-  const enableServerSpans = spans && !disableIncomingRequestSpans;
-  const serverOptions = {
-    sessions: options.trackIncomingRequestsAsSessions,
-    sessionFlushingDelayMS: options.sessionFlushingDelayMS,
-    ignoreRequestBody: options.ignoreIncomingRequestBody,
-    maxRequestBodySize: options.maxIncomingRequestBodySize
-  };
-  const serverSpansOptions = {
-    ignoreIncomingRequests: options.ignoreIncomingRequests,
-    ignoreStaticAssets: options.ignoreStaticAssets,
-    ignoreStatusCodes: options.dropSpansForIncomingRequestStatusCodes,
-    instrumentation: options.instrumentation,
-    onSpanCreated: options.incomingRequestSpanHook
-  };
-  const server = nodeCore.httpServerIntegration(serverOptions);
-  const serverSpans = nodeCore.httpServerSpansIntegration(serverSpansOptions);
-  return {
-    name: INTEGRATION_NAME,
-    setup(client) {
-      const clientOptions = client.getOptions();
-      if (enableServerSpans && core.hasSpansEnabled(clientOptions)) {
-        serverSpans.setup(client);
-      }
-    },
-    setupOnce() {
-      server.setupOnce();
-      const sentryHttpInstrumentationOptions = {
-        breadcrumbs: options.breadcrumbs,
-        spans,
-        propagateTraceInOutgoingRequests: options.tracePropagation ?? true,
-        createSpansForOutgoingRequests: spans,
-        ignoreOutgoingRequests: options.ignoreOutgoingRequests,
-        outgoingRequestHook: (span, request) => {
-          const url = core.getRequestUrlFromClientRequest(request);
-          if (url.startsWith("data:")) {
-            const sanitizedUrl = core.stripDataUrlContent(url);
-            span.setAttribute("http.url", sanitizedUrl);
-            span.setAttribute(attributes.URL_FULL, sanitizedUrl);
-            span.updateName(`${request.method || "GET"} ${sanitizedUrl}`);
-          }
-          options.instrumentation?.requestHook?.(span, request);
-        },
-        outgoingResponseHook: options.instrumentation?.responseHook,
-        outgoingRequestApplyCustomAttributes: options.instrumentation?.applyCustomAttributesOnSpan
-      };
-      nodeCore.instrumentHttpOutgoingRequests(sentryHttpInstrumentationOptions);
-    },
-    processEvent(event) {
-      return serverSpans.processEvent(event);
-    }
-  };
-});
-
-exports.httpIntegration = httpIntegration;
-exports.instrumentSentryHttp = instrumentSentryHttp;
-//# sourceMappingURL=http.js.map

package/build/cjs/integrations/http.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"http.js","sources":["../../../src/integrations/http.ts"],"sourcesContent":["import type { RequestOptions } from 'node:http';\nimport type { HttpClientRequest, HttpIncomingMessage, HttpServerResponse, Span } from '@sentry/core';\nimport { defineIntegration, hasSpansEnabled, stripDataUrlContent, getRequestUrlFromClientRequest } from '@sentry/core';\nimport type {\n  NodeClient,\n  SentryHttpInstrumentationOptions,\n  HttpServerIntegrationOptions,\n  HttpServerSpansIntegrationOptions,\n} from '@sentry/node-core';\nimport { httpServerIntegration, httpServerSpansIntegration, instrumentHttpOutgoingRequests } from '@sentry/node-core';\nimport { URL_FULL } from '@sentry/conventions/attributes';\n\nconst INTEGRATION_NAME = 'Http' as const;\n\n// TODO(v11): Consolidate all the various HTTP integration options into one,\n// and deprecate the duplicated and aliased options.\ninterface HttpOptions {\n  /**\n   * Whether breadcrumbs should be recorded for outgoing requests.\n   * Defaults to true\n   */\n  breadcrumbs?: boolean;\n\n  /**\n   * If set to false, do not emit any spans.\n   * This will ensure that the default HttpInstrumentation from OpenTelemetry is not setup,\n   * only the Sentry-specific instrumentation for request isolation is applied.\n   *\n   * If `skipOpenTelemetrySetup: true` is configured, this defaults to `false`, otherwise it defaults to `true`.\n   */\n  spans?: boolean;\n\n  /**\n   * Whether the integration should create [Sessions](https://docs.sentry.io/product/releases/health/#sessions) for incoming requests to track the health and crash-free rate of your releases in Sentry.\n   * Read more about Release Health: https://docs.sentry.io/product/releases/health/\n   *\n   * Defaults to `true`.\n   */\n  trackIncomingRequestsAsSessions?: boolean;\n\n  /**\n   * Number of milliseconds until sessions tracked with `trackIncomingRequestsAsSessions` will be flushed as a session aggregate.\n   *\n   * Defaults to `60000` (60s).\n   */\n  sessionFlushingDelayMS?: number;\n\n  /**\n   * Whether to inject trace propagation headers (sentry-trace, baggage, traceparent) into outgoing HTTP requests.\n   *\n   * When set to `false`, Sentry will not inject any trace propagation headers, but will still create breadcrumbs\n   * (if `breadcrumbs` is enabled). This is useful when `skipOpenTelemetrySetup: true` is configured and you want\n   * to avoid duplicate trace headers being injected by both Sentry and OpenTelemetry's HttpInstrumentation.\n   *\n   * @default `true`\n   */\n  tracePropagation?: boolean;\n\n  /**\n   * Do not capture spans or breadcrumbs for outgoing HTTP requests to URLs where the given callback returns `true`.\n   * This controls both span & breadcrumb creation - spans will be non recording if tracing is disabled.\n   *\n   * The `url` param contains the entire URL, including query string (if any), protocol, host, etc. of the outgoing request.\n   * For example: `'https://someService.com/users/details?id=123'`\n   *\n   * The `request` param contains the original {@type RequestOptions} object used to make the outgoing request.\n   * You can use it to filter on additional properties like method, headers, etc.\n   */\n  ignoreOutgoingRequests?: (url: string, request: RequestOptions) => boolean;\n\n  /**\n   * Do not capture spans for incoming HTTP requests to URLs where the given callback returns `true`.\n   * Spans will be non recording if tracing is disabled.\n   *\n   * The `urlPath` param consists of the URL path and query string (if any) of the incoming request.\n   * For example: `'/users/details?id=123'`\n   *\n   * The `request` param contains the original {@type IncomingMessage} object of the incoming request.\n   * You can use it to filter on additional properties like method, headers, etc.\n   */\n  ignoreIncomingRequests?: (urlPath: string, request: HttpIncomingMessage) => boolean;\n\n  /**\n   * A hook that can be used to mutate the span for incoming requests.\n   * This is triggered after the span is created, but before it is recorded.\n   */\n  incomingRequestSpanHook?: (span: Span, request: HttpIncomingMessage, response: HttpServerResponse) => void;\n\n  /**\n   * Whether to automatically ignore common static asset requests like favicon.ico, robots.txt, etc.\n   * This helps reduce noise in your transactions.\n   *\n   * @default `true`\n   */\n  ignoreStaticAssets?: boolean;\n\n  /**\n   * Do not capture spans for incoming HTTP requests with the given status codes.\n   * By default, spans with some 3xx and 4xx status codes are ignored (see @default).\n   * Expects an array of status codes or a range of status codes, e.g. [[300,399], 404] would ignore 3xx and 404 status codes.\n   *\n   * @default `[[401, 404], [301, 303], [305, 399]]`\n   */\n  dropSpansForIncomingRequestStatusCodes?: (number | [number, number])[];\n\n  /**\n   * Do not capture the request body for incoming HTTP requests to URLs where the given callback returns `true`.\n   * This can be useful for long running requests where the body is not needed and we want to avoid capturing it.\n   *\n   * @param url Contains the entire URL, including query string (if any), protocol, host, etc. of the incoming request.\n   * @param request Contains the {@type RequestOptions} object used to make the incoming request.\n   */\n  ignoreIncomingRequestBody?: (url: string, request: RequestOptions) => boolean;\n\n  /**\n   * Controls the maximum size of incoming HTTP request bodies attached to events.\n   *\n   * Available options:\n   * - 'none': No request bodies will be attached\n   * - 'small': Request bodies up to 1,000 bytes will be attached\n   * - 'medium': Request bodies up to 10,000 bytes will be attached (default)\n   * - 'always': Request bodies will always be attached\n   *\n   * Note that even with 'always' setting, bodies exceeding 1MB will never be attached\n   * for performance and security reasons.\n   *\n   * @default 'medium'\n   */\n  maxIncomingRequestBodySize?: 'none' | 'small' | 'medium' | 'always';\n\n  /**\n   * If true, do not generate spans for incoming requests at all.\n   * This is used by Remix to avoid generating spans for incoming requests, as it generates its own spans.\n   */\n  disableIncomingRequestSpans?: boolean;\n\n  /**\n   * Additional instrumentation options that are passed to the underlying HttpInstrumentation.\n   */\n  instrumentation?: {\n    requestHook?: (span: Span, req: HttpIncomingMessage | HttpClientRequest) => void;\n    responseHook?: (span: Span, response: HttpIncomingMessage | HttpServerResponse) => void;\n    applyCustomAttributesOnSpan?: (\n      span: Span,\n      request: HttpIncomingMessage | HttpClientRequest,\n      response: HttpIncomingMessage | HttpServerResponse,\n    ) => void;\n  };\n}\n\nexport const instrumentSentryHttp = Object.assign(instrumentHttpOutgoingRequests, {\n  id: `${INTEGRATION_NAME}.sentry`,\n});\n\n/**\n * The http integration instruments Node's internal http and https modules.\n * It creates breadcrumbs and spans for outgoing HTTP requests which will be attached to the currently active span.\n */\nexport const httpIntegration = defineIntegration((options: HttpOptions = {}) => {\n  const spans = options.spans ?? true;\n  const disableIncomingRequestSpans = options.disableIncomingRequestSpans;\n  const enableServerSpans = spans && !disableIncomingRequestSpans;\n\n  const serverOptions = {\n    sessions: options.trackIncomingRequestsAsSessions,\n    sessionFlushingDelayMS: options.sessionFlushingDelayMS,\n    ignoreRequestBody: options.ignoreIncomingRequestBody,\n    maxRequestBodySize: options.maxIncomingRequestBodySize,\n  } satisfies HttpServerIntegrationOptions;\n\n  const serverSpansOptions: HttpServerSpansIntegrationOptions = {\n    ignoreIncomingRequests: options.ignoreIncomingRequests,\n    ignoreStaticAssets: options.ignoreStaticAssets,\n    ignoreStatusCodes: options.dropSpansForIncomingRequestStatusCodes,\n    instrumentation: options.instrumentation,\n    onSpanCreated: options.incomingRequestSpanHook,\n  };\n\n  const server = httpServerIntegration(serverOptions);\n  const serverSpans = httpServerSpansIntegration(serverSpansOptions);\n\n  return {\n    name: INTEGRATION_NAME,\n    setup(client: NodeClient) {\n      const clientOptions = client.getOptions();\n\n      if (enableServerSpans && hasSpansEnabled(clientOptions)) {\n        serverSpans.setup(client);\n      }\n    },\n    setupOnce() {\n      server.setupOnce();\n\n      const sentryHttpInstrumentationOptions: SentryHttpInstrumentationOptions = {\n        breadcrumbs: options.breadcrumbs,\n        spans,\n        propagateTraceInOutgoingRequests: options.tracePropagation ?? true,\n        createSpansForOutgoingRequests: spans,\n        ignoreOutgoingRequests: options.ignoreOutgoingRequests,\n        outgoingRequestHook: (span: Span, request: HttpClientRequest) => {\n          // Sanitize data URLs to prevent long base64 strings in span attributes\n          const url = getRequestUrlFromClientRequest(request);\n          if (url.startsWith('data:')) {\n            const sanitizedUrl = stripDataUrlContent(url);\n            // TODO(v11): Update these to the Sentry semantic attributes.\n            // https://getsentry.github.io/sentry-conventions/attributes/\n            span.setAttribute('http.url', sanitizedUrl);\n            span.setAttribute(URL_FULL, sanitizedUrl);\n            span.updateName(`${request.method || 'GET'} ${sanitizedUrl}`);\n          }\n          options.instrumentation?.requestHook?.(span, request);\n        },\n        outgoingResponseHook: options.instrumentation?.responseHook,\n        outgoingRequestApplyCustomAttributes: options.instrumentation?.applyCustomAttributesOnSpan,\n      };\n\n      // This is Sentry-specific instrumentation for outgoing request\n      // breadcrumbs & trace propagation. It uses the diagnostic channels on\n      // node versions that support it, falling back to monkey-patching when\n      // needed.\n      instrumentHttpOutgoingRequests(sentryHttpInstrumentationOptions);\n    },\n    processEvent(event) {\n      // Always run this, even if spans are disabled\n      // The reason being that e.g. the remix integration disables span\n      // creation here but still wants to use the ignore status codes option\n      return serverSpans.processEvent(event);\n    },\n  };\n});\n"],"names":["instrumentHttpOutgoingRequests","defineIntegration","httpServerIntegration","httpServerSpansIntegration","hasSpansEnabled","getRequestUrlFromClientRequest","stripDataUrlContent","URL_FULL"],"mappings":";;;;;;AAYA,MAAM,gBAAA,GAAmB,MAAA;AA0IlB,MAAM,oBAAA,GAAuB,MAAA,CAAO,MAAA,CAAOA,uCAAA,EAAgC;AAAA,EAChF,EAAA,EAAI,GAAG,gBAAgB,CAAA,OAAA;AACzB,CAAC;AAMM,MAAM,eAAA,GAAkBC,sBAAA,CAAkB,CAAC,OAAA,GAAuB,EAAC,KAAM;AAC9E,EAAA,MAAM,KAAA,GAAQ,QAAQ,KAAA,IAAS,IAAA;AAC/B,EAAA,MAAM,8BAA8B,OAAA,CAAQ,2BAAA;AAC5C,EAAA,MAAM,iBAAA,GAAoB,SAAS,CAAC,2BAAA;AAEpC,EAAA,MAAM,aAAA,GAAgB;AAAA,IACpB,UAAU,OAAA,CAAQ,+BAAA;AAAA,IAClB,wBAAwB,OAAA,CAAQ,sBAAA;AAAA,IAChC,mBAAmB,OAAA,CAAQ,yBAAA;AAAA,IAC3B,oBAAoB,OAAA,CAAQ;AAAA,GAC9B;AAEA,EAAA,MAAM,kBAAA,GAAwD;AAAA,IAC5D,wBAAwB,OAAA,CAAQ,sBAAA;AAAA,IAChC,oBAAoB,OAAA,CAAQ,kBAAA;AAAA,IAC5B,mBAAmB,OAAA,CAAQ,sCAAA;AAAA,IAC3B,iBAAiB,OAAA,CAAQ,eAAA;AAAA,IACzB,eAAe,OAAA,CAAQ;AAAA,GACzB;AAEA,EAAA,MAAM,MAAA,GAASC,+BAAsB,aAAa,CAAA;AAClD,EAAA,MAAM,WAAA,GAAcC,oCAA2B,kBAAkB,CAAA;AAEjE,EAAA,OAAO;AAAA,IACL,IAAA,EAAM,gBAAA;AAAA,IACN,MAAM,MAAA,EAAoB;AACxB,MAAA,MAAM,aAAA,GAAgB,OAAO,UAAA,EAAW;AAExC,MAAA,IAAI,iBAAA,IAAqBC,oBAAA,CAAgB,aAAa,CAAA,EAAG;AACvD,QAAA,WAAA,CAAY,MAAM,MAAM,CAAA;AAAA,MAC1B;AAAA,IACF,CAAA;AAAA,IACA,SAAA,GAAY;AACV,MAAA,MAAA,CAAO,SAAA,EAAU;AAEjB,MAAA,MAAM,gCAAA,GAAqE;AAAA,QACzE,aAAa,OAAA,CAAQ,WAAA;AAAA,QACrB,KAAA;AAAA,QACA,gCAAA,EAAkC,QAAQ,gBAAA,IAAoB,IAAA;AAAA,QAC9D,8BAAA,EAAgC,KAAA;AAAA,QAChC,wBAAwB,OAAA,CAAQ,sBAAA;AAAA,QAChC,mBAAA,EAAqB,CAAC,IAAA,EAAY,OAAA,KAA+B;AAE/D,UAAA,MAAM,GAAA,GAAMC,oCAA+B,OAAO,CAAA;AAClD,UAAA,IAAI,GAAA,CAAI,UAAA,CAAW,OAAO,CAAA,EAAG;AAC3B,YAAA,MAAM,YAAA,GAAeC,yBAAoB,GAAG,CAAA;AAG5C,YAAA,IAAA,CAAK,YAAA,CAAa,YAAY,YAAY,CAAA;AAC1C,YAAA,IAAA,CAAK,YAAA,CAAaC,qBAAU,YAAY,CAAA;AACxC,YAAA,IAAA,CAAK,WAAW,CAAA,EAAG,OAAA,CAAQ,UAAU,KAAK,CAAA,CAAA,EAAI,YAAY,CAAA,CAAE,CAAA;AAAA,UAC9D;AACA,UAAA,OAAA,CAAQ,eAAA,EAAiB,WAAA,GAAc,IAAA,EAAM,OAAO,CAAA;AAAA,QACtD,CAAA;AAAA,QACA,oBAAA,EAAsB,QAAQ,eAAA,EAAiB,YAAA;AAAA,QAC/C,oCAAA,EAAsC,QAAQ,eAAA,EAAiB;AAAA,OACjE;AAMA,MAAAP,uCAAA,CAA+B,gCAAgC,CAAA;AAAA,IACjE,CAAA;AAAA,IACA,aAAa,KAAA,EAAO;AAIlB,MAAA,OAAO,WAAA,CAAY,aAAa,KAAK,CAAA;AAAA,IACvC;AAAA,GACF;AACF,CAAC;;;;;"}

package/build/cjs/integrations/node-fetch.js

@@ -1,24 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-const nodeCore = require('@sentry/node-core');
-const core = require('@sentry/core');
-
-const _nativeNodeFetchIntegration = ((options = {}) => {
-  return {
-    name: "NodeFetch",
-    setupOnce() {
-      const clientOptions = core.getClient()?.getOptions();
-      nodeCore.instrumentUndici({
-        ...options,
-        spans: _shouldInstrumentSpans(options, clientOptions)
-      });
-    }
-  };
-});
-const nativeNodeFetchIntegration = core.defineIntegration(_nativeNodeFetchIntegration);
-function _shouldInstrumentSpans(options, clientOptions = {}) {
-  return options.spans ?? (!clientOptions.skipOpenTelemetrySetup && core.hasSpansEnabled(clientOptions));
-}
-
-exports.nativeNodeFetchIntegration = nativeNodeFetchIntegration;
-//# sourceMappingURL=node-fetch.js.map

package/build/cjs/integrations/node-fetch.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"node-fetch.js","sources":["../../../src/integrations/node-fetch.ts"],"sourcesContent":["import { instrumentUndici, type NodeFetchOptions } from '@sentry/node-core';\nimport type { NodeClientOptions } from '../types';\nimport type { IntegrationFn } from '@sentry/core';\nimport { defineIntegration, getClient, hasSpansEnabled } from '@sentry/core';\n\n/**\n * This is a variant of the node-core integration where the default for spans is different.\n * In v11, this will be the only implementation.\n */\nconst _nativeNodeFetchIntegration = ((options: NodeFetchOptions = {}) => {\n  return {\n    name: 'NodeFetch' as const,\n    setupOnce() {\n      const clientOptions = getClient()?.getOptions();\n      instrumentUndici({\n        ...options,\n        spans: _shouldInstrumentSpans(options, clientOptions),\n      });\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Instrument outgoing fetch requests made through the native node `fetch` API.\n * This emits (depending on the integration options) spans and breadcrumbs, as well as injecting trace propagation headers into the request.\n */\nexport const nativeNodeFetchIntegration = defineIntegration(_nativeNodeFetchIntegration);\n\nfunction _shouldInstrumentSpans(options: NodeFetchOptions, clientOptions: Partial<NodeClientOptions> = {}): boolean {\n  // If `spans` is passed in, it takes precedence\n  // Else, we by default emit spans, unless `skipOpenTelemetrySetup` is set to `true` or spans are not enabled\n  return options.spans ?? (!clientOptions.skipOpenTelemetrySetup && hasSpansEnabled(clientOptions));\n}\n"],"names":["getClient","instrumentUndici","defineIntegration","hasSpansEnabled"],"mappings":";;;;;AASA,MAAM,2BAAA,IAA+B,CAAC,OAAA,GAA4B,EAAC,KAAM;AACvE,EAAA,OAAO;AAAA,IACL,IAAA,EAAM,WAAA;AAAA,IACN,SAAA,GAAY;AACV,MAAA,MAAM,aAAA,GAAgBA,cAAA,EAAU,EAAG,UAAA,EAAW;AAC9C,MAAAC,yBAAA,CAAiB;AAAA,QACf,GAAG,OAAA;AAAA,QACH,KAAA,EAAO,sBAAA,CAAuB,OAAA,EAAS,aAAa;AAAA,OACrD,CAAA;AAAA,IACH;AAAA,GACF;AACF,CAAA,CAAA;AAMO,MAAM,0BAAA,GAA6BC,uBAAkB,2BAA2B;AAEvF,SAAS,sBAAA,CAAuB,OAAA,EAA2B,aAAA,GAA4C,EAAC,EAAY;AAGlH,EAAA,OAAO,QAAQ,KAAA,KAAU,CAAC,aAAA,CAAc,sBAAA,IAA0BC,qBAAgB,aAAa,CAAA,CAAA;AACjG;;;;"}

package/build/cjs/integrations/tracing/InstrumentationNodeModuleFile.js

@@ -1,15 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-const path = require('path');
-
-class InstrumentationNodeModuleFile {
-  constructor(name, supportedVersions, patch, unpatch) {
-    this.name = path.normalize(name);
-    this.supportedVersions = supportedVersions;
-    this.patch = patch;
-    this.unpatch = unpatch;
-  }
-}
-
-exports.InstrumentationNodeModuleFile = InstrumentationNodeModuleFile;
-//# sourceMappingURL=InstrumentationNodeModuleFile.js.map

package/build/cjs/integrations/tracing/InstrumentationNodeModuleFile.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"InstrumentationNodeModuleFile.js","sources":["../../../../src/integrations/tracing/InstrumentationNodeModuleFile.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n * NOTICE from the Sentry authors:\n * - Vendored locally from @opentelemetry/instrumentation to work around a Bun\n *   --bytecode bug (https://github.com/getsentry/sentry-javascript/issues/21256).\n * - The upstream class imports `normalize` via an indirect platform/index\n *   re-export chain, which Bun's bytecode bundler renames and loses scope for.\n * - This copy imports `normalize` directly from 'path' to break that chain.\n */\n/* oxlint-disable */\n\nimport { normalize } from 'path';\nimport type { InstrumentationModuleFile } from '@opentelemetry/instrumentation';\n\nexport class InstrumentationNodeModuleFile implements InstrumentationModuleFile {\n  public name: string;\n  public supportedVersions: string[];\n  public patch: (moduleExports: any, moduleVersion?: string) => any;\n  public unpatch: (moduleExports?: any, moduleVersion?: string) => void;\n\n  constructor(\n    name: string,\n    supportedVersions: string[],\n    patch: (moduleExports: any, moduleVersion?: string) => any,\n    unpatch: (moduleExports?: any, moduleVersion?: string) => void,\n  ) {\n    this.name = normalize(name);\n    this.supportedVersions = supportedVersions;\n    this.patch = patch;\n    this.unpatch = unpatch;\n  }\n}\n"],"names":["normalize"],"mappings":";;;;AA2BO,MAAM,6BAAA,CAAmE;AAAA,EAM9E,WAAA,CACE,IAAA,EACA,iBAAA,EACA,KAAA,EACA,OAAA,EACA;AACA,IAAA,IAAA,CAAK,IAAA,GAAOA,eAAU,IAAI,CAAA;AAC1B,IAAA,IAAA,CAAK,iBAAA,GAAoB,iBAAA;AACzB,IAAA,IAAA,CAAK,KAAA,GAAQ,KAAA;AACb,IAAA,IAAA,CAAK,OAAA,GAAU,OAAA;AAAA,EACjB;AACF;;;;"}

package/build/cjs/integrations/tracing/amqplib/index.js

@@ -1,21 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-const core = require('@sentry/core');
-const nodeCore = require('@sentry/node-core');
-const instrumentation = require('./vendored/instrumentation.js');
-
-const INTEGRATION_NAME = "Amqplib";
-const instrumentAmqplib = nodeCore.generateInstrumentOnce(INTEGRATION_NAME, () => new instrumentation.AmqplibInstrumentation());
-const _amqplibIntegration = (() => {
-  return {
-    name: INTEGRATION_NAME,
-    setupOnce() {
-      instrumentAmqplib();
-    }
-  };
-});
-const amqplibIntegration = core.defineIntegration(_amqplibIntegration);
-
-exports.amqplibIntegration = amqplibIntegration;
-exports.instrumentAmqplib = instrumentAmqplib;
-//# sourceMappingURL=index.js.map

package/build/cjs/integrations/tracing/amqplib/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../src/integrations/tracing/amqplib/index.ts"],"sourcesContent":["import type { IntegrationFn } from '@sentry/core';\nimport { defineIntegration } from '@sentry/core';\nimport { generateInstrumentOnce } from '@sentry/node-core';\nimport { AmqplibInstrumentation } from './vendored/instrumentation';\n\nconst INTEGRATION_NAME = 'Amqplib' as const;\n\nexport const instrumentAmqplib = generateInstrumentOnce(INTEGRATION_NAME, () => new AmqplibInstrumentation());\n\nconst _amqplibIntegration = (() => {\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      instrumentAmqplib();\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Adds Sentry tracing instrumentation for the [amqplib](https://www.npmjs.com/package/amqplib) library.\n *\n * For more information, see the [`amqplibIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/amqplib/).\n *\n * @example\n * ```javascript\n * const Sentry = require('@sentry/node');\n *\n * Sentry.init({\n *  integrations: [Sentry.amqplibIntegration()],\n * });\n * ```\n */\nexport const amqplibIntegration = defineIntegration(_amqplibIntegration);\n"],"names":["generateInstrumentOnce","AmqplibInstrumentation","defineIntegration"],"mappings":";;;;;;AAKA,MAAM,gBAAA,GAAmB,SAAA;AAElB,MAAM,oBAAoBA,+BAAA,CAAuB,gBAAA,EAAkB,MAAM,IAAIC,wCAAwB;AAE5G,MAAM,uBAAuB,MAAM;AACjC,EAAA,OAAO;AAAA,IACL,IAAA,EAAM,gBAAA;AAAA,IACN,SAAA,GAAY;AACV,MAAA,iBAAA,EAAkB;AAAA,IACpB;AAAA,GACF;AACF,CAAA,CAAA;AAgBO,MAAM,kBAAA,GAAqBC,uBAAkB,mBAAmB;;;;;"}