@depup/sentry__node 10.44.0-depup.0

package/build/esm/integrations/featureFlagShims/openFeature.js

@@ -0,0 +1,52 @@
+import { defineIntegration, isBrowser, consoleSandbox } from '@sentry/core';
+
+/**
+ * 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.
+ */
+const openFeatureIntegrationShim = defineIntegration((_options) => {
+  if (!isBrowser()) {
+    consoleSandbox(() => {
+      // eslint-disable-next-line no-console
+      console.warn('The openFeatureIntegration() can only be used in the browser.');
+    });
+  }
+
+  return {
+    name: 'OpenFeature',
+  };
+});
+
+/**
+ * This is a shim for the OpenFeature integration hook.
+ */
+class OpenFeatureIntegrationHookShim {
+  /**
+   *
+   */
+   constructor() {
+    if (!isBrowser()) {
+      consoleSandbox(() => {
+        // eslint-disable-next-line no-console
+        console.warn('The OpenFeatureIntegrationHook can only be used in the browser.');
+      });
+    }
+  }
+
+  /**
+   *
+   */
+   after() {
+    // No-op
+  }
+
+  /**
+   *
+   */
+   error() {
+    // No-op
+  }
+}
+
+export { OpenFeatureIntegrationHookShim, openFeatureIntegrationShim };
+//# sourceMappingURL=openFeature.js.map

package/build/esm/integrations/featureFlagShims/openFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"openFeature.js","sources":["../../../../src/integrations/featureFlagShims/openFeature.ts"],"sourcesContent":["import { consoleSandbox, defineIntegration, isBrowser } from '@sentry/core';\n\n/**\n * This is a shim for the OpenFeature integration.\n * We need this in order to not throw runtime errors when accidentally importing this on the server through a meta framework like Next.js.\n */\nexport const openFeatureIntegrationShim = defineIntegration((_options?: unknown) => {\n  if (!isBrowser()) {\n    consoleSandbox(() => {\n      // eslint-disable-next-line no-console\n      console.warn('The openFeatureIntegration() can only be used in the browser.');\n    });\n  }\n\n  return {\n    name: 'OpenFeature',\n  };\n});\n\n/**\n * This is a shim for the OpenFeature integration hook.\n */\nexport class OpenFeatureIntegrationHookShim {\n  /**\n   *\n   */\n  public constructor() {\n    if (!isBrowser()) {\n      consoleSandbox(() => {\n        // eslint-disable-next-line no-console\n        console.warn('The OpenFeatureIntegrationHook can only be used in the browser.');\n      });\n    }\n  }\n\n  /**\n   *\n   */\n  public after(): void {\n    // No-op\n  }\n\n  /**\n   *\n   */\n  public error(): void {\n    // No-op\n  }\n}\n"],"names":[],"mappings":";;AAEA;AACA;AACA;AACA;AACO,MAAM,6BAA6B,iBAAiB,CAAC,CAAC,QAAQ,KAAe;AACpF,EAAE,IAAI,CAAC,SAAS,EAAE,EAAE;AACpB,IAAI,cAAc,CAAC,MAAM;AACzB;AACA,MAAM,OAAO,CAAC,IAAI,CAAC,+DAA+D,CAAC;AACnF,IAAI,CAAC,CAAC;AACN,EAAE;;AAEF,EAAE,OAAO;AACT,IAAI,IAAI,EAAE,aAAa;AACvB,GAAG;AACH,CAAC;;AAED;AACA;AACA;AACO,MAAM,8BAAA,CAA+B;AAC5C;AACA;AACA;AACA,GAAS,WAAW,GAAG;AACvB,IAAI,IAAI,CAAC,SAAS,EAAE,EAAE;AACtB,MAAM,cAAc,CAAC,MAAM;AAC3B;AACA,QAAQ,OAAO,CAAC,IAAI,CAAC,iEAAiE,CAAC;AACvF,MAAM,CAAC,CAAC;AACR,IAAI;AACJ,EAAE;;AAEF;AACA;AACA;AACA,GAAS,KAAK,GAAS;AACvB;AACA,EAAE;;AAEF;AACA;AACA;AACA,GAAS,KAAK,GAAS;AACvB;AACA,EAAE;AACF;;;;"}

package/build/esm/integrations/featureFlagShims/statsig.js

@@ -0,0 +1,21 @@
+import { defineIntegration, isBrowser, consoleSandbox } from '@sentry/core';
+
+/**
+ * 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.
+ */
+const statsigIntegrationShim = defineIntegration((_options) => {
+  if (!isBrowser()) {
+    consoleSandbox(() => {
+      // eslint-disable-next-line no-console
+      console.warn('The statsigIntegration() can only be used in the browser.');
+    });
+  }
+
+  return {
+    name: 'Statsig',
+  };
+});
+
+export { statsigIntegrationShim };
+//# sourceMappingURL=statsig.js.map

package/build/esm/integrations/featureFlagShims/statsig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"statsig.js","sources":["../../../../src/integrations/featureFlagShims/statsig.ts"],"sourcesContent":["import { consoleSandbox, defineIntegration, isBrowser } from '@sentry/core';\n\n/**\n * This is a shim for the Statsig integration.\n * We need this in order to not throw runtime errors when accidentally importing this on the server through a meta framework like Next.js.\n */\nexport const statsigIntegrationShim = defineIntegration((_options?: unknown) => {\n  if (!isBrowser()) {\n    consoleSandbox(() => {\n      // eslint-disable-next-line no-console\n      console.warn('The statsigIntegration() can only be used in the browser.');\n    });\n  }\n\n  return {\n    name: 'Statsig',\n  };\n});\n"],"names":[],"mappings":";;AAEA;AACA;AACA;AACA;AACO,MAAM,yBAAyB,iBAAiB,CAAC,CAAC,QAAQ,KAAe;AAChF,EAAE,IAAI,CAAC,SAAS,EAAE,EAAE;AACpB,IAAI,cAAc,CAAC,MAAM;AACzB;AACA,MAAM,OAAO,CAAC,IAAI,CAAC,2DAA2D,CAAC;AAC/E,IAAI,CAAC,CAAC;AACN,EAAE;;AAEF,EAAE,OAAO;AACT,IAAI,IAAI,EAAE,SAAS;AACnB,GAAG;AACH,CAAC;;;;"}

package/build/esm/integrations/featureFlagShims/unleash.js

@@ -0,0 +1,21 @@
+import { defineIntegration, isBrowser, consoleSandbox } from '@sentry/core';
+
+/**
+ * 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.
+ */
+const unleashIntegrationShim = defineIntegration((_options) => {
+  if (!isBrowser()) {
+    consoleSandbox(() => {
+      // eslint-disable-next-line no-console
+      console.warn('The unleashIntegration() can only be used in the browser.');
+    });
+  }
+
+  return {
+    name: 'Unleash',
+  };
+});
+
+export { unleashIntegrationShim };
+//# sourceMappingURL=unleash.js.map

package/build/esm/integrations/featureFlagShims/unleash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unleash.js","sources":["../../../../src/integrations/featureFlagShims/unleash.ts"],"sourcesContent":["import { consoleSandbox, defineIntegration, isBrowser } from '@sentry/core';\n\n/**\n * This is a shim for the Unleash integration.\n * We need this in order to not throw runtime errors when accidentally importing this on the server through a meta framework like Next.js.\n */\nexport const unleashIntegrationShim = defineIntegration((_options?: unknown) => {\n  if (!isBrowser()) {\n    consoleSandbox(() => {\n      // eslint-disable-next-line no-console\n      console.warn('The unleashIntegration() can only be used in the browser.');\n    });\n  }\n\n  return {\n    name: 'Unleash',\n  };\n});\n"],"names":[],"mappings":";;AAEA;AACA;AACA;AACA;AACO,MAAM,yBAAyB,iBAAiB,CAAC,CAAC,QAAQ,KAAe;AAChF,EAAE,IAAI,CAAC,SAAS,EAAE,EAAE;AACpB,IAAI,cAAc,CAAC,MAAM;AACzB;AACA,MAAM,OAAO,CAAC,IAAI,CAAC,2DAA2D,CAAC;AAC/E,IAAI,CAAC,CAAC;AACN,EAAE;;AAEF,EAAE,OAAO;AACT,IAAI,IAAI,EAAE,SAAS;AACnB,GAAG;AACH,CAAC;;;;"}

package/build/esm/integrations/fs.js

@@ -0,0 +1,140 @@
+import { FsInstrumentation } from '@opentelemetry/instrumentation-fs';
+import { defineIntegration, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_OP } from '@sentry/core';
+import { generateInstrumentOnce } from '@sentry/node-core';
+
+const INTEGRATION_NAME = 'FileSystem';
+
+/**
+ * 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.
+ */
+const fsIntegration = defineIntegration(
+  (
+    options
+
+ = {},
+  ) => {
+    return {
+      name: INTEGRATION_NAME,
+      setupOnce() {
+        generateInstrumentOnce(
+          INTEGRATION_NAME,
+          () =>
+            new FsInstrumentation({
+              requireParentSpan: true,
+              endHook(functionName, { args, span, error }) {
+                span.updateName(`fs.${functionName}`);
+
+                span.setAttributes({
+                  [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'file',
+                  [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.file.fs',
+                });
+
+                if (options.recordErrorMessagesAsSpanAttributes) {
+                  if (typeof args[0] === 'string' && FS_OPERATIONS_WITH_PATH_ARG.includes(functionName)) {
+                    span.setAttribute('path_argument', args[0]);
+                  } else if (
+                    typeof args[0] === 'string' &&
+                    typeof args[1] === 'string' &&
+                    FS_OPERATIONS_WITH_TARGET_PATH.includes(functionName)
+                  ) {
+                    span.setAttribute('target_argument', args[0]);
+                    span.setAttribute('path_argument', args[1]);
+                  } else if (typeof args[0] === 'string' && FS_OPERATIONS_WITH_PREFIX.includes(functionName)) {
+                    span.setAttribute('prefix_argument', args[0]);
+                  } else if (
+                    typeof args[0] === 'string' &&
+                    typeof args[1] === 'string' &&
+                    FS_OPERATIONS_WITH_EXISTING_PATH_NEW_PATH.includes(functionName)
+                  ) {
+                    span.setAttribute('existing_path_argument', args[0]);
+                    span.setAttribute('new_path_argument', args[1]);
+                  } else if (
+                    typeof args[0] === 'string' &&
+                    typeof args[1] === 'string' &&
+                    FS_OPERATIONS_WITH_SRC_DEST.includes(functionName)
+                  ) {
+                    span.setAttribute('src_argument', args[0]);
+                    span.setAttribute('dest_argument', args[1]);
+                  } else if (
+                    typeof args[0] === 'string' &&
+                    typeof args[1] === 'string' &&
+                    FS_OPERATIONS_WITH_OLD_PATH_NEW_PATH.includes(functionName)
+                  ) {
+                    span.setAttribute('old_path_argument', args[0]);
+                    span.setAttribute('new_path_argument', args[1]);
+                  }
+                }
+
+                if (error && options.recordErrorMessagesAsSpanAttributes) {
+                  span.setAttribute('fs_error', error.message);
+                }
+              },
+            }),
+        )();
+      },
+    };
+  },
+);
+
+const FS_OPERATIONS_WITH_OLD_PATH_NEW_PATH = ['rename', 'renameSync'];
+const FS_OPERATIONS_WITH_SRC_DEST = ['copyFile', 'cp', 'copyFileSync', 'cpSync'];
+const FS_OPERATIONS_WITH_EXISTING_PATH_NEW_PATH = ['link', 'linkSync'];
+const FS_OPERATIONS_WITH_PREFIX = ['mkdtemp', 'mkdtempSync'];
+const FS_OPERATIONS_WITH_TARGET_PATH = ['symlink', 'symlinkSync'];
+const FS_OPERATIONS_WITH_PATH_ARG = [
+  'access',
+  'appendFile',
+  'chmod',
+  'chown',
+  'exists',
+  'mkdir',
+  'lchown',
+  'lstat',
+  'lutimes',
+  'open',
+  'opendir',
+  'readdir',
+  'readFile',
+  'readlink',
+  'realpath',
+  'realpath.native',
+  'rm',
+  'rmdir',
+  'stat',
+  'truncate',
+  'unlink',
+  'utimes',
+  'writeFile',
+  'accessSync',
+  'appendFileSync',
+  'chmodSync',
+  'chownSync',
+  'existsSync',
+  'lchownSync',
+  'lstatSync',
+  'lutimesSync',
+  'opendirSync',
+  'mkdirSync',
+  'openSync',
+  'readdirSync',
+  'readFileSync',
+  'readlinkSync',
+  'realpathSync',
+  'realpathSync.native',
+  'rmdirSync',
+  'rmSync',
+  'statSync',
+  'truncateSync',
+  'unlinkSync',
+  'utimesSync',
+  'writeFileSync',
+];
+
+export { fsIntegration };
+//# sourceMappingURL=fs.js.map

package/build/esm/integrations/fs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs.js","sources":["../../../src/integrations/fs.ts"],"sourcesContent":["import { FsInstrumentation } from '@opentelemetry/instrumentation-fs';\nimport { defineIntegration, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '@sentry/core';\nimport { generateInstrumentOnce } from '@sentry/node-core';\n\nconst INTEGRATION_NAME = 'FileSystem';\n\n/**\n * This integration will create spans for `fs` API operations, like reading and writing files.\n *\n * **WARNING:** This integration may add significant overhead to your application. Especially in scenarios with a lot of\n * file I/O, like for example when running a framework dev server, including this integration can massively slow down\n * your application.\n *\n * @param options Configuration for this integration.\n */\nexport const fsIntegration = defineIntegration(\n  (\n    options: {\n      /**\n       * Setting this option to `true` will include any filepath arguments from your `fs` API calls as span attributes.\n       *\n       * Defaults to `false`.\n       */\n      recordFilePaths?: boolean;\n\n      /**\n       * Setting this option to `true` will include the error messages of failed `fs` API calls as a span attribute.\n       *\n       * Defaults to `false`.\n       */\n      recordErrorMessagesAsSpanAttributes?: boolean;\n    } = {},\n  ) => {\n    return {\n      name: INTEGRATION_NAME,\n      setupOnce() {\n        generateInstrumentOnce(\n          INTEGRATION_NAME,\n          () =>\n            new FsInstrumentation({\n              requireParentSpan: true,\n              endHook(functionName, { args, span, error }) {\n                span.updateName(`fs.${functionName}`);\n\n                span.setAttributes({\n                  [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'file',\n                  [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.file.fs',\n                });\n\n                if (options.recordErrorMessagesAsSpanAttributes) {\n                  if (typeof args[0] === 'string' && FS_OPERATIONS_WITH_PATH_ARG.includes(functionName)) {\n                    span.setAttribute('path_argument', args[0]);\n                  } else if (\n                    typeof args[0] === 'string' &&\n                    typeof args[1] === 'string' &&\n                    FS_OPERATIONS_WITH_TARGET_PATH.includes(functionName)\n                  ) {\n                    span.setAttribute('target_argument', args[0]);\n                    span.setAttribute('path_argument', args[1]);\n                  } else if (typeof args[0] === 'string' && FS_OPERATIONS_WITH_PREFIX.includes(functionName)) {\n                    span.setAttribute('prefix_argument', args[0]);\n                  } else if (\n                    typeof args[0] === 'string' &&\n                    typeof args[1] === 'string' &&\n                    FS_OPERATIONS_WITH_EXISTING_PATH_NEW_PATH.includes(functionName)\n                  ) {\n                    span.setAttribute('existing_path_argument', args[0]);\n                    span.setAttribute('new_path_argument', args[1]);\n                  } else if (\n                    typeof args[0] === 'string' &&\n                    typeof args[1] === 'string' &&\n                    FS_OPERATIONS_WITH_SRC_DEST.includes(functionName)\n                  ) {\n                    span.setAttribute('src_argument', args[0]);\n                    span.setAttribute('dest_argument', args[1]);\n                  } else if (\n                    typeof args[0] === 'string' &&\n                    typeof args[1] === 'string' &&\n                    FS_OPERATIONS_WITH_OLD_PATH_NEW_PATH.includes(functionName)\n                  ) {\n                    span.setAttribute('old_path_argument', args[0]);\n                    span.setAttribute('new_path_argument', args[1]);\n                  }\n                }\n\n                if (error && options.recordErrorMessagesAsSpanAttributes) {\n                  span.setAttribute('fs_error', error.message);\n                }\n              },\n            }),\n        )();\n      },\n    };\n  },\n);\n\nconst FS_OPERATIONS_WITH_OLD_PATH_NEW_PATH = ['rename', 'renameSync'];\nconst FS_OPERATIONS_WITH_SRC_DEST = ['copyFile', 'cp', 'copyFileSync', 'cpSync'];\nconst FS_OPERATIONS_WITH_EXISTING_PATH_NEW_PATH = ['link', 'linkSync'];\nconst FS_OPERATIONS_WITH_PREFIX = ['mkdtemp', 'mkdtempSync'];\nconst FS_OPERATIONS_WITH_TARGET_PATH = ['symlink', 'symlinkSync'];\nconst FS_OPERATIONS_WITH_PATH_ARG = [\n  'access',\n  'appendFile',\n  'chmod',\n  'chown',\n  'exists',\n  'mkdir',\n  'lchown',\n  'lstat',\n  'lutimes',\n  'open',\n  'opendir',\n  'readdir',\n  'readFile',\n  'readlink',\n  'realpath',\n  'realpath.native',\n  'rm',\n  'rmdir',\n  'stat',\n  'truncate',\n  'unlink',\n  'utimes',\n  'writeFile',\n  'accessSync',\n  'appendFileSync',\n  'chmodSync',\n  'chownSync',\n  'existsSync',\n  'lchownSync',\n  'lstatSync',\n  'lutimesSync',\n  'opendirSync',\n  'mkdirSync',\n  'openSync',\n  'readdirSync',\n  'readFileSync',\n  'readlinkSync',\n  'realpathSync',\n  'realpathSync.native',\n  'rmdirSync',\n  'rmSync',\n  'statSync',\n  'truncateSync',\n  'unlinkSync',\n  'utimesSync',\n  'writeFileSync',\n];\n"],"names":[],"mappings":"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"}

package/build/esm/integrations/http.js

@@ -0,0 +1,219 @@
+import { diag } from '@opentelemetry/api';
+import { HttpInstrumentation } from '@opentelemetry/instrumentation-http';
+import { defineIntegration, getClient, hasSpansEnabled, stripDataUrlContent, SEMANTIC_ATTRIBUTE_URL_FULL } from '@sentry/core';
+import { NODE_VERSION, generateInstrumentOnce, SentryHttpInstrumentation, httpServerIntegration, httpServerSpansIntegration, getRequestUrl, addOriginToSpan } from '@sentry/node-core';
+
+const INTEGRATION_NAME = 'Http';
+
+const INSTRUMENTATION_NAME = '@opentelemetry_sentry-patched/instrumentation-http';
+
+// The `http.client.request.created` diagnostics channel, needed for trace propagation,
+// was added in Node 22.12.0 (backported from 23.2.0). Earlier 22.x versions don't have it.
+const FULLY_SUPPORTS_HTTP_DIAGNOSTICS_CHANNEL =
+  (NODE_VERSION.major === 22 && NODE_VERSION.minor >= 12) ||
+  (NODE_VERSION.major === 23 && NODE_VERSION.minor >= 2) ||
+  NODE_VERSION.major >= 24;
+
+const instrumentSentryHttp = generateInstrumentOnce(
+  `${INTEGRATION_NAME}.sentry`,
+  options => {
+    return new SentryHttpInstrumentation(options);
+  },
+);
+
+const instrumentOtelHttp = generateInstrumentOnce(INTEGRATION_NAME, config => {
+  const instrumentation = new HttpInstrumentation({
+    ...config,
+    // This is hard-coded and can never be overridden by the user
+    disableIncomingRequestInstrumentation: true,
+  });
+
+  // We want to update the logger namespace so we can better identify what is happening here
+  try {
+    instrumentation['_diag'] = diag.createComponentLogger({
+      namespace: INSTRUMENTATION_NAME,
+    });
+    // @ts-expect-error We are writing a read-only property here...
+    instrumentation.instrumentationName = INSTRUMENTATION_NAME;
+  } catch {
+    // ignore errors here...
+  }
+
+  // The OTel HttpInstrumentation (>=0.213.0) has a guard (`_httpPatched`/`_httpsPatched`)
+  // that prevents patching `http`/`https` when loaded by both CJS `require()` and ESM `import`.
+  // In environments like AWS Lambda, the runtime loads `http` via CJS first (for the Runtime API),
+  // and then the user's ESM handler imports `node:http`. The guard blocks ESM patching after CJS,
+  // which breaks HTTP spans for ESM handlers. We disable this guard to allow both to be patched.
+  // TODO(andrei): Remove once https://github.com/open-telemetry/opentelemetry-js/issues/6489 is fixed.
+  try {
+    const noopDescriptor = { get: () => false, set: () => {} };
+    Object.defineProperty(instrumentation, '_httpPatched', noopDescriptor);
+    Object.defineProperty(instrumentation, '_httpsPatched', noopDescriptor);
+  } catch {
+    // ignore errors here...
+  }
+
+  return instrumentation;
+});
+
+/** Exported only for tests. */
+function _shouldUseOtelHttpInstrumentation(
+  options,
+  clientOptions = {},
+) {
+  // If `spans` is passed in, it takes precedence
+  // Else, we by default emit spans, unless `skipOpenTelemetrySetup` is set to `true` or spans are not enabled
+  if (typeof options.spans === 'boolean') {
+    return options.spans;
+  }
+
+  if (clientOptions.skipOpenTelemetrySetup) {
+    return false;
+  }
+
+  // IMPORTANT: We only disable span instrumentation when spans are not enabled _and_ we are on a Node version
+  // that fully supports the necessary diagnostics channels for trace propagation
+  if (!hasSpansEnabled(clientOptions) && FULLY_SUPPORTS_HTTP_DIAGNOSTICS_CHANNEL) {
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * 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.
+ */
+const httpIntegration = defineIntegration((options = {}) => {
+  const spans = options.spans ?? true;
+  const disableIncomingRequestSpans = options.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 = httpServerIntegration(serverOptions);
+  const serverSpans = httpServerSpansIntegration(serverSpansOptions);
+
+  const enableServerSpans = spans && !disableIncomingRequestSpans;
+
+  return {
+    name: INTEGRATION_NAME,
+    setup(client) {
+      const clientOptions = client.getOptions();
+
+      if (enableServerSpans && hasSpansEnabled(clientOptions)) {
+        serverSpans.setup(client);
+      }
+    },
+    setupOnce() {
+      const clientOptions = (getClient()?.getOptions() || {}) ;
+      const useOtelHttpInstrumentation = _shouldUseOtelHttpInstrumentation(options, clientOptions);
+
+      server.setupOnce();
+
+      const sentryHttpInstrumentationOptions = {
+        breadcrumbs: options.breadcrumbs,
+        propagateTraceInOutgoingRequests:
+          typeof options.tracePropagation === 'boolean'
+            ? options.tracePropagation
+            : FULLY_SUPPORTS_HTTP_DIAGNOSTICS_CHANNEL || !useOtelHttpInstrumentation,
+        createSpansForOutgoingRequests: FULLY_SUPPORTS_HTTP_DIAGNOSTICS_CHANNEL,
+        spans: options.spans,
+        ignoreOutgoingRequests: options.ignoreOutgoingRequests,
+        outgoingRequestHook: (span, request) => {
+          // Sanitize data URLs to prevent long base64 strings in span attributes
+          const url = getRequestUrl(request);
+          if (url.startsWith('data:')) {
+            const sanitizedUrl = stripDataUrlContent(url);
+            span.setAttribute('http.url', sanitizedUrl);
+            span.setAttribute(SEMANTIC_ATTRIBUTE_URL_FULL, sanitizedUrl);
+            span.updateName(`${request.method || 'GET'} ${sanitizedUrl}`);
+          }
+
+          options.instrumentation?.requestHook?.(span, request);
+        },
+        outgoingResponseHook: options.instrumentation?.responseHook,
+        outgoingRequestApplyCustomAttributes: options.instrumentation?.applyCustomAttributesOnSpan,
+      } ;
+
+      // This is Sentry-specific instrumentation for outgoing request breadcrumbs & trace propagation
+      instrumentSentryHttp(sentryHttpInstrumentationOptions);
+
+      // This is the "regular" OTEL instrumentation that emits outgoing request spans
+      if (useOtelHttpInstrumentation) {
+        const instrumentationConfig = getConfigWithDefaults(options);
+        instrumentOtelHttp(instrumentationConfig);
+      }
+    },
+    processEvent(event) {
+      // Note: We always run this, even if spans are disabled
+      // The reason being that e.g. the remix integration disables span creation here but still wants to use the ignore status codes option
+      return serverSpans.processEvent(event);
+    },
+  };
+});
+
+function getConfigWithDefaults(options = {}) {
+  const instrumentationConfig = {
+    // This is handled by the SentryHttpInstrumentation on Node 22+
+    disableOutgoingRequestInstrumentation: FULLY_SUPPORTS_HTTP_DIAGNOSTICS_CHANNEL,
+
+    ignoreOutgoingRequestHook: request => {
+      const url = getRequestUrl(request);
+
+      if (!url) {
+        return false;
+      }
+
+      const _ignoreOutgoingRequests = options.ignoreOutgoingRequests;
+      if (_ignoreOutgoingRequests?.(url, request)) {
+        return true;
+      }
+
+      return false;
+    },
+
+    requireParentforOutgoingSpans: false,
+    requestHook: (span, req) => {
+      addOriginToSpan(span, 'auto.http.otel.http');
+
+      // Sanitize data URLs to prevent long base64 strings in span attributes
+      const url = getRequestUrl(req );
+      if (url.startsWith('data:')) {
+        const sanitizedUrl = stripDataUrlContent(url);
+        span.setAttribute('http.url', sanitizedUrl);
+        span.setAttribute(SEMANTIC_ATTRIBUTE_URL_FULL, sanitizedUrl);
+        span.updateName(`${(req ).method || 'GET'} ${sanitizedUrl}`);
+      }
+
+      options.instrumentation?.requestHook?.(span, req);
+    },
+    responseHook: (span, res) => {
+      options.instrumentation?.responseHook?.(span, res);
+    },
+    applyCustomAttributesOnSpan: (
+      span,
+      request,
+      response,
+    ) => {
+      options.instrumentation?.applyCustomAttributesOnSpan?.(span, request, response);
+    },
+  } ;
+
+  return instrumentationConfig;
+}
+
+export { _shouldUseOtelHttpInstrumentation, httpIntegration, instrumentOtelHttp, instrumentSentryHttp };
+//# sourceMappingURL=http.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"http.js","sources":["../../../src/integrations/http.ts"],"sourcesContent":["import type { ClientRequest, IncomingMessage, RequestOptions, ServerResponse } from 'node:http';\nimport { diag } from '@opentelemetry/api';\nimport type { HttpInstrumentationConfig } from '@opentelemetry/instrumentation-http';\nimport { HttpInstrumentation } from '@opentelemetry/instrumentation-http';\nimport type { Span } from '@sentry/core';\nimport {\n  defineIntegration,\n  getClient,\n  hasSpansEnabled,\n  SEMANTIC_ATTRIBUTE_URL_FULL,\n  stripDataUrlContent,\n} from '@sentry/core';\nimport type { HTTPModuleRequestIncomingMessage, NodeClient, SentryHttpInstrumentationOptions } from '@sentry/node-core';\nimport {\n  addOriginToSpan,\n  generateInstrumentOnce,\n  getRequestUrl,\n  httpServerIntegration,\n  httpServerSpansIntegration,\n  NODE_VERSION,\n  SentryHttpInstrumentation,\n} from '@sentry/node-core';\nimport type { NodeClientOptions } from '../types';\n\nconst INTEGRATION_NAME = 'Http';\n\nconst INSTRUMENTATION_NAME = '@opentelemetry_sentry-patched/instrumentation-http';\n\n// The `http.client.request.created` diagnostics channel, needed for trace propagation,\n// was added in Node 22.12.0 (backported from 23.2.0). Earlier 22.x versions don't have it.\nconst FULLY_SUPPORTS_HTTP_DIAGNOSTICS_CHANNEL =\n  (NODE_VERSION.major === 22 && NODE_VERSION.minor >= 12) ||\n  (NODE_VERSION.major === 23 && NODE_VERSION.minor >= 2) ||\n  NODE_VERSION.major >= 24;\n\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: IncomingMessage) => 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: IncomingMessage, response: ServerResponse) => 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: ClientRequest | HTTPModuleRequestIncomingMessage) => void;\n    responseHook?: (span: Span, response: HTTPModuleRequestIncomingMessage | ServerResponse) => void;\n    applyCustomAttributesOnSpan?: (\n      span: Span,\n      request: ClientRequest | HTTPModuleRequestIncomingMessage,\n      response: HTTPModuleRequestIncomingMessage | ServerResponse,\n    ) => void;\n  };\n}\n\nexport const instrumentSentryHttp = generateInstrumentOnce<SentryHttpInstrumentationOptions>(\n  `${INTEGRATION_NAME}.sentry`,\n  options => {\n    return new SentryHttpInstrumentation(options);\n  },\n);\n\nexport const instrumentOtelHttp = generateInstrumentOnce<HttpInstrumentationConfig>(INTEGRATION_NAME, config => {\n  const instrumentation = new HttpInstrumentation({\n    ...config,\n    // This is hard-coded and can never be overridden by the user\n    disableIncomingRequestInstrumentation: true,\n  });\n\n  // We want to update the logger namespace so we can better identify what is happening here\n  try {\n    instrumentation['_diag'] = diag.createComponentLogger({\n      namespace: INSTRUMENTATION_NAME,\n    });\n    // @ts-expect-error We are writing a read-only property here...\n    instrumentation.instrumentationName = INSTRUMENTATION_NAME;\n  } catch {\n    // ignore errors here...\n  }\n\n  // The OTel HttpInstrumentation (>=0.213.0) has a guard (`_httpPatched`/`_httpsPatched`)\n  // that prevents patching `http`/`https` when loaded by both CJS `require()` and ESM `import`.\n  // In environments like AWS Lambda, the runtime loads `http` via CJS first (for the Runtime API),\n  // and then the user's ESM handler imports `node:http`. The guard blocks ESM patching after CJS,\n  // which breaks HTTP spans for ESM handlers. We disable this guard to allow both to be patched.\n  // TODO(andrei): Remove once https://github.com/open-telemetry/opentelemetry-js/issues/6489 is fixed.\n  try {\n    const noopDescriptor = { get: () => false, set: () => {} };\n    Object.defineProperty(instrumentation, '_httpPatched', noopDescriptor);\n    Object.defineProperty(instrumentation, '_httpsPatched', noopDescriptor);\n  } catch {\n    // ignore errors here...\n  }\n\n  return instrumentation;\n});\n\n/** Exported only for tests. */\nexport function _shouldUseOtelHttpInstrumentation(\n  options: HttpOptions,\n  clientOptions: Partial<NodeClientOptions> = {},\n): 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  if (typeof options.spans === 'boolean') {\n    return options.spans;\n  }\n\n  if (clientOptions.skipOpenTelemetrySetup) {\n    return false;\n  }\n\n  // IMPORTANT: We only disable span instrumentation when spans are not enabled _and_ we are on a Node version\n  // that fully supports the necessary diagnostics channels for trace propagation\n  if (!hasSpansEnabled(clientOptions) && FULLY_SUPPORTS_HTTP_DIAGNOSTICS_CHANNEL) {\n    return false;\n  }\n\n  return true;\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\n  const serverOptions = {\n    sessions: options.trackIncomingRequestsAsSessions,\n    sessionFlushingDelayMS: options.sessionFlushingDelayMS,\n    ignoreRequestBody: options.ignoreIncomingRequestBody,\n    maxRequestBodySize: options.maxIncomingRequestBodySize,\n  } satisfies Parameters<typeof httpServerIntegration>[0];\n\n  const serverSpansOptions = {\n    ignoreIncomingRequests: options.ignoreIncomingRequests,\n    ignoreStaticAssets: options.ignoreStaticAssets,\n    ignoreStatusCodes: options.dropSpansForIncomingRequestStatusCodes,\n    instrumentation: options.instrumentation,\n    onSpanCreated: options.incomingRequestSpanHook,\n  } satisfies Parameters<typeof httpServerSpansIntegration>[0];\n\n  const server = httpServerIntegration(serverOptions);\n  const serverSpans = httpServerSpansIntegration(serverSpansOptions);\n\n  const enableServerSpans = spans && !disableIncomingRequestSpans;\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      const clientOptions = (getClient<NodeClient>()?.getOptions() || {}) satisfies Partial<NodeClientOptions>;\n      const useOtelHttpInstrumentation = _shouldUseOtelHttpInstrumentation(options, clientOptions);\n\n      server.setupOnce();\n\n      const sentryHttpInstrumentationOptions = {\n        breadcrumbs: options.breadcrumbs,\n        propagateTraceInOutgoingRequests:\n          typeof options.tracePropagation === 'boolean'\n            ? options.tracePropagation\n            : FULLY_SUPPORTS_HTTP_DIAGNOSTICS_CHANNEL || !useOtelHttpInstrumentation,\n        createSpansForOutgoingRequests: FULLY_SUPPORTS_HTTP_DIAGNOSTICS_CHANNEL,\n        spans: options.spans,\n        ignoreOutgoingRequests: options.ignoreOutgoingRequests,\n        outgoingRequestHook: (span: Span, request: ClientRequest) => {\n          // Sanitize data URLs to prevent long base64 strings in span attributes\n          const url = getRequestUrl(request);\n          if (url.startsWith('data:')) {\n            const sanitizedUrl = stripDataUrlContent(url);\n            span.setAttribute('http.url', sanitizedUrl);\n            span.setAttribute(SEMANTIC_ATTRIBUTE_URL_FULL, sanitizedUrl);\n            span.updateName(`${request.method || 'GET'} ${sanitizedUrl}`);\n          }\n\n          options.instrumentation?.requestHook?.(span, request);\n        },\n        outgoingResponseHook: options.instrumentation?.responseHook,\n        outgoingRequestApplyCustomAttributes: options.instrumentation?.applyCustomAttributesOnSpan,\n      } satisfies SentryHttpInstrumentationOptions;\n\n      // This is Sentry-specific instrumentation for outgoing request breadcrumbs & trace propagation\n      instrumentSentryHttp(sentryHttpInstrumentationOptions);\n\n      // This is the \"regular\" OTEL instrumentation that emits outgoing request spans\n      if (useOtelHttpInstrumentation) {\n        const instrumentationConfig = getConfigWithDefaults(options);\n        instrumentOtelHttp(instrumentationConfig);\n      }\n    },\n    processEvent(event) {\n      // Note: We always run this, even if spans are disabled\n      // The reason being that e.g. the remix integration disables span creation here but still wants to use the ignore status codes option\n      return serverSpans.processEvent(event);\n    },\n  };\n});\n\nfunction getConfigWithDefaults(options: Partial<HttpOptions> = {}): HttpInstrumentationConfig {\n  const instrumentationConfig = {\n    // This is handled by the SentryHttpInstrumentation on Node 22+\n    disableOutgoingRequestInstrumentation: FULLY_SUPPORTS_HTTP_DIAGNOSTICS_CHANNEL,\n\n    ignoreOutgoingRequestHook: request => {\n      const url = getRequestUrl(request);\n\n      if (!url) {\n        return false;\n      }\n\n      const _ignoreOutgoingRequests = options.ignoreOutgoingRequests;\n      if (_ignoreOutgoingRequests?.(url, request)) {\n        return true;\n      }\n\n      return false;\n    },\n\n    requireParentforOutgoingSpans: false,\n    requestHook: (span, req) => {\n      addOriginToSpan(span, 'auto.http.otel.http');\n\n      // Sanitize data URLs to prevent long base64 strings in span attributes\n      const url = getRequestUrl(req as ClientRequest);\n      if (url.startsWith('data:')) {\n        const sanitizedUrl = stripDataUrlContent(url);\n        span.setAttribute('http.url', sanitizedUrl);\n        span.setAttribute(SEMANTIC_ATTRIBUTE_URL_FULL, sanitizedUrl);\n        span.updateName(`${(req as ClientRequest).method || 'GET'} ${sanitizedUrl}`);\n      }\n\n      options.instrumentation?.requestHook?.(span, req);\n    },\n    responseHook: (span, res) => {\n      options.instrumentation?.responseHook?.(span, res);\n    },\n    applyCustomAttributesOnSpan: (\n      span: Span,\n      request: ClientRequest | HTTPModuleRequestIncomingMessage,\n      response: HTTPModuleRequestIncomingMessage | ServerResponse,\n    ) => {\n      options.instrumentation?.applyCustomAttributesOnSpan?.(span, request, response);\n    },\n  } satisfies HttpInstrumentationConfig;\n\n  return instrumentationConfig;\n}\n"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,105 @@
+import { UndiciInstrumentation } from '@opentelemetry/instrumentation-undici';
+import { defineIntegration, stripDataUrlContent, SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME, SEMANTIC_ATTRIBUTE_URL_FULL, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, getClient, hasSpansEnabled } from '@sentry/core';
+import { generateInstrumentOnce, SentryNodeFetchInstrumentation } from '@sentry/node-core';
+
+const INTEGRATION_NAME = 'NodeFetch';
+
+const instrumentOtelNodeFetch = generateInstrumentOnce(
+  INTEGRATION_NAME,
+  UndiciInstrumentation,
+  (options) => {
+    return _getConfigWithDefaults(options);
+  },
+);
+
+const instrumentSentryNodeFetch = generateInstrumentOnce(
+  `${INTEGRATION_NAME}.sentry`,
+  SentryNodeFetchInstrumentation,
+  (options) => {
+    return options;
+  },
+);
+
+const _nativeNodeFetchIntegration = ((options = {}) => {
+  return {
+    name: 'NodeFetch',
+    setupOnce() {
+      const instrumentSpans = _shouldInstrumentSpans(options, getClient()?.getOptions());
+
+      // This is the "regular" OTEL instrumentation that emits spans
+      if (instrumentSpans) {
+        instrumentOtelNodeFetch(options);
+      }
+
+      // This is the Sentry-specific instrumentation that creates breadcrumbs & propagates traces
+      // This must be registered after the OTEL one, to ensure that the core trace propagation logic takes presedence
+      // Otherwise, the sentry-trace header may be set multiple times
+      instrumentSentryNodeFetch(options);
+    },
+  };
+}) ;
+
+const nativeNodeFetchIntegration = defineIntegration(_nativeNodeFetchIntegration);
+
+// Matching the behavior of the base instrumentation
+function getAbsoluteUrl(origin, path = '/') {
+  const url = `${origin}`;
+
+  if (url.endsWith('/') && path.startsWith('/')) {
+    return `${url}${path.slice(1)}`;
+  }
+
+  if (!url.endsWith('/') && !path.startsWith('/')) {
+    return `${url}/${path}`;
+  }
+
+  return `${url}${path}`;
+}
+
+function _shouldInstrumentSpans(options, clientOptions = {}) {
+  // If `spans` is passed in, it takes precedence
+  // Else, we by default emit spans, unless `skipOpenTelemetrySetup` is set to `true` or spans are not enabled
+  return typeof options.spans === 'boolean'
+    ? options.spans
+    : !clientOptions.skipOpenTelemetrySetup && hasSpansEnabled(clientOptions);
+}
+
+/** Exported only for tests. */
+function _getConfigWithDefaults(options = {}) {
+  const instrumentationConfig = {
+    requireParentforSpans: false,
+    ignoreRequestHook: request => {
+      const url = getAbsoluteUrl(request.origin, request.path);
+      const _ignoreOutgoingRequests = options.ignoreOutgoingRequests;
+      const shouldIgnore = _ignoreOutgoingRequests && url && _ignoreOutgoingRequests(url);
+
+      return !!shouldIgnore;
+    },
+    startSpanHook: request => {
+      const url = getAbsoluteUrl(request.origin, request.path);
+
+      // Sanitize data URLs to prevent long base64 strings in span attributes
+      if (url.startsWith('data:')) {
+        const sanitizedUrl = stripDataUrlContent(url);
+        return {
+          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.http.otel.node_fetch',
+          'http.url': sanitizedUrl,
+          [SEMANTIC_ATTRIBUTE_URL_FULL]: sanitizedUrl,
+          [SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME]: `${request.method || 'GET'} ${sanitizedUrl}`,
+        };
+      }
+
+      return {
+        [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.http.otel.node_fetch',
+      };
+    },
+    requestHook: options.requestHook,
+    responseHook: options.responseHook,
+    headersToSpanAttributes: options.headersToSpanAttributes,
+  } ;
+
+  return instrumentationConfig;
+}
+
+export { _getConfigWithDefaults, nativeNodeFetchIntegration };
+//# sourceMappingURL=node-fetch.js.map