@sentry/core 10.51.0 → 10.53.0

package/build/esm/integrations/http/client-patch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-patch.js","sources":["../../../../src/integrations/http/client-patch.ts"],"sourcesContent":["/**\n * Platform-portable HTTP(S) outgoing-request patching integration\n *\n * Patches the `http` and `https` Node.js built-in module exports to create\n * Sentry spans for outgoing requests and optionally inject distributed trace\n * propagation headers.\n *\n * @module\n *\n * This Sentry integration is a derivative work based on the OpenTelemetry\n * HTTP instrumentation.\n *\n * <https://github.com/open-telemetry/opentelemetry-js/tree/main/experimental/packages/opentelemetry-instrumentation-http>\n *\n * Extended under the terms of the Apache 2.0 license linked below:\n *\n * ----\n *\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\nimport { getDefaultExport } from '../../utils/get-default-export';\nimport { HTTP_ON_CLIENT_REQUEST } from './constants';\nimport type { HttpExport, HttpModuleExport, HttpInstrumentationOptions, HttpClientRequest } from './types';\nimport { getOriginalFunction, wrapMethod } from '../../utils/object';\nimport { getHttpClientSubscriptions } from './client-subscriptions';\n\nfunction patchHttpRequest(httpModule: HttpExport, options: HttpInstrumentationOptions): void {\n  // avoid double-wrap\n  if (!getOriginalFunction(httpModule.request)) {\n    const { [HTTP_ON_CLIENT_REQUEST]: onHttpClientRequestCreated } = getHttpClientSubscriptions({\n      ...options,\n      http: httpModule,\n    });\n\n    const originalRequest = httpModule.request;\n    wrapMethod(httpModule, 'request', function patchedRequest(this: HttpExport, ...args: unknown[]) {\n      const request = originalRequest.apply(this, args) as HttpClientRequest;\n      onHttpClientRequestCreated({ request }, HTTP_ON_CLIENT_REQUEST);\n      return request;\n    });\n  }\n}\n\n// This simply ensures that http.get calls http.request, which we patched.\n// Call it from the object each time, to ensure that any subsequent patches\n// or other mutations are also respected.\nfunction patchHttpGet(httpModule: HttpExport) {\n  if (!getOriginalFunction(httpModule.get)) {\n    // match node's normalization to exactly 3 arguments.\n    wrapMethod(httpModule, 'get', function patchedGet(this: HttpExport, input: unknown, options: unknown, cb: unknown) {\n      // http.get is like http.request but automatically calls .end()\n      const request = httpModule.request.call(this, input, options, cb) as HttpClientRequest;\n      request.end();\n      return request;\n    });\n  }\n}\n\nfunction patchModule(httpModuleExport: HttpModuleExport, options: HttpInstrumentationOptions = {}): HttpModuleExport {\n  const httpDefault = getDefaultExport(httpModuleExport);\n  const httpModule = httpModuleExport as HttpExport;\n  // if we have a default, patch that, and copy to the import container\n  if (httpDefault !== httpModuleExport) {\n    patchModule(httpDefault, options);\n    // copy with defineProperty because these might be configured oddly\n    for (const method of ['get', 'request']) {\n      const desc = Object.getOwnPropertyDescriptor(httpDefault, method);\n      /* v8 ignore start - will always be set at this point */\n      if (desc) {\n        Object.defineProperty(httpModule, method, desc);\n      }\n      /* v8 ignore stop */\n    }\n    return httpModule;\n  }\n  patchHttpRequest(httpModule, options);\n  patchHttpGet(httpModule);\n  return httpModuleExport;\n}\n\n/**\n * Patch an `node:http` or `node:https` module-shaped export so that every\n * outgoing request is tracked by Sentry.\n *\n * @example\n * ```javascript\n * import http from 'http';\n * import { patchHttpModule } from '@sentry/core';\n * patchHttpModule(http, { propagateTrace: true });\n * ```\n */\nexport const patchHttpModuleClient = (\n  httpModuleExport: HttpModuleExport,\n  options: HttpInstrumentationOptions = {},\n): HttpModuleExport => patchModule(httpModuleExport, options);\n"],"names":[],"mappings":";;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAQA,SAAS,gBAAgB,CAAC,UAAU,EAAc,OAAO,EAAoC;AAC7F;AACA,EAAE,IAAI,CAAC,mBAAmB,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE;AAChD,IAAI,MAAM,EAAE,CAAC,sBAAsB,GAAG,0BAAA,EAA2B,GAAI,0BAA0B,CAAC;AAChG,MAAM,GAAG,OAAO;AAChB,MAAM,IAAI,EAAE,UAAU;AACtB,KAAK,CAAC;;AAEN,IAAI,MAAM,eAAA,GAAkB,UAAU,CAAC,OAAO;AAC9C,IAAI,UAAU,CAAC,UAAU,EAAE,SAAS,EAAE,SAAS,cAAc,EAAmB,GAAG,IAAI,EAAa;AACpG,MAAM,MAAM,OAAA,GAAU,eAAe,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAA;AACtD,MAAM,0BAA0B,CAAC,EAAE,SAAS,EAAE,sBAAsB,CAAC;AACrE,MAAM,OAAO,OAAO;AACpB,IAAI,CAAC,CAAC;AACN,EAAE;AACF;;AAEA;AACA;AACA;AACA,SAAS,YAAY,CAAC,UAAU,EAAc;AAC9C,EAAE,IAAI,CAAC,mBAAmB,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE;AAC5C;AACA,IAAI,UAAU,CAAC,UAAU,EAAE,KAAK,EAAE,SAAS,UAAU,EAAmB,KAAK,EAAW,OAAO,EAAW,EAAE,EAAW;AACvH;AACA,MAAM,MAAM,OAAA,GAAU,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,CAAA;AACtE,MAAM,OAAO,CAAC,GAAG,EAAE;AACnB,MAAM,OAAO,OAAO;AACpB,IAAI,CAAC,CAAC;AACN,EAAE;AACF;;AAEA,SAAS,WAAW,CAAC,gBAAgB,EAAoB,OAAO,GAA+B,EAAE,EAAoB;AACrH,EAAE,MAAM,WAAA,GAAc,gBAAgB,CAAC,gBAAgB,CAAC;AACxD,EAAE,MAAM,UAAA,GAAa,gBAAA;AACrB;AACA,EAAE,IAAI,WAAA,KAAgB,gBAAgB,EAAE;AACxC,IAAI,WAAW,CAAC,WAAW,EAAE,OAAO,CAAC;AACrC;AACA,IAAI,KAAK,MAAM,MAAA,IAAU,CAAC,KAAK,EAAE,SAAS,CAAC,EAAE;AAC7C,MAAM,MAAM,IAAA,GAAO,MAAM,CAAC,wBAAwB,CAAC,WAAW,EAAE,MAAM,CAAC;AACvE;AACA,MAAM,IAAI,IAAI,EAAE;AAChB,QAAQ,MAAM,CAAC,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,CAAC;AACvD,MAAM;AACN;AACA,IAAI;AACJ,IAAI,OAAO,UAAU;AACrB,EAAE;AACF,EAAE,gBAAgB,CAAC,UAAU,EAAE,OAAO,CAAC;AACvC,EAAE,YAAY,CAAC,UAAU,CAAC;AAC1B,EAAE,OAAO,gBAAgB;AACzB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAM,wBAAwB;AACrC,EAAE,gBAAgB;AAClB,EAAE,OAAO,GAA+B,EAAE;AAC1C,KAAuB,WAAW,CAAC,gBAAgB,EAAE,OAAO;;;;"}

package/build/esm/integrations/http/client-subscriptions.js

@@ -0,0 +1,164 @@
+import { addOutgoingRequestBreadcrumb } from './add-outgoing-request-breadcrumb.js';
+import { DEBUG_BUILD } from '../../debug-build.js';
+import { debug } from '../../utils/debug-logger.js';
+import { getCurrentScope, getClient } from '../../currentScopes.js';
+import { getSpanStatusFromHttpCode, SPAN_STATUS_ERROR, SPAN_STATUS_UNSET } from '../../tracing/spanstatus.js';
+import { hasSpansEnabled } from '../../utils/hasSpansEnabled.js';
+import { SUPPRESS_TRACING_KEY, startInactiveSpan, withActiveSpan } from '../../tracing/trace.js';
+import { LRUMap } from '../../utils/lru.js';
+import { getOutgoingRequestSpanData, setIncomingResponseSpanData } from './get-outgoing-span-data.js';
+import { getRequestUrlFromClientRequest } from './get-request-url.js';
+import { injectTracePropagationHeaders } from './inject-trace-propagation-headers.js';
+import { HTTP_ON_CLIENT_REQUEST, LOG_PREFIX } from './constants.js';
+import { doubleWrapWarning } from './double-wrap-warning.js';
+
+function getHttpClientSubscriptions(options) {
+  const propagationDecisionMap = new LRUMap(100);
+  const getConfig = () => getClient()?.getOptions();
+
+  const onHttpClientRequestCreated = (data) => {
+    // Skip all instrumentation if tracing is suppressed
+    // (e.g., Sentry's own transport uses this to avoid self-instrumentation)
+    if (getCurrentScope().getScopeData().sdkProcessingMetadata[SUPPRESS_TRACING_KEY] === true) {
+      return;
+    }
+
+    const clientOptions = getConfig();
+    const {
+      errorMonitor = 'error',
+      spans: createSpans = clientOptions ? hasSpansEnabled(clientOptions) : true,
+      propagateTrace = false,
+      breadcrumbs = true,
+      http,
+      https,
+      suppressOtelWarning = false,
+    } = options;
+
+    const { request } = data ;
+
+    // check if request is ignored. if so, we do nothing at all.
+    if (options.ignoreOutgoingRequests?.(getRequestUrlFromClientRequest(request), request)) {
+      return;
+    }
+
+    // guard against adding breadcrumbs multiple times, or when not enabled
+    let addedBreadcrumbs = false;
+    function addBreadcrumbs(request, response) {
+      if (!addedBreadcrumbs) {
+        addedBreadcrumbs = true;
+        addOutgoingRequestBreadcrumb(request, response);
+      }
+    }
+
+    // called if spans and/or trace propagation are disabled
+    function breadcrumbsOnly(request) {
+      request.on(errorMonitor, () => addBreadcrumbs(request, undefined));
+      request.prependListener('response', response => {
+        if (request.listenerCount('response') <= 1) {
+          response.resume();
+        }
+        response.on('end', () => addBreadcrumbs(request, response));
+        response.on(errorMonitor, () => addBreadcrumbs(request, response));
+      });
+    }
+
+    if (!createSpans) {
+      // no spans, but maybe tracing and/or breadcrumbs
+      if (breadcrumbs) {
+        breadcrumbsOnly(request);
+      }
+      if (propagateTrace) {
+        injectTracePropagationHeaders(request, propagationDecisionMap);
+      }
+      return;
+    }
+
+    // guard against OTel wrapping the same module and emitting double-spans
+    // this doesn't prevent it, just prints a debug warning for the user.
+    if (!suppressOtelWarning) {
+      if (http) doubleWrapWarning(http);
+      if (https) doubleWrapWarning(https);
+    }
+
+    // spans are enabled
+    const span = startInactiveSpan(getOutgoingRequestSpanData(request));
+    options.outgoingRequestHook?.(span, request);
+
+    // Inject trace headers after span creation so sentry-trace contains the
+    // outgoing span's ID (not the parent's), enabling downstream services to
+    // link to this span.
+    if (propagateTrace) {
+      if (span.isRecording()) {
+        withActiveSpan(span, () => {
+          injectTracePropagationHeaders(request, propagationDecisionMap);
+        });
+      } else {
+        injectTracePropagationHeaders(request, propagationDecisionMap);
+      }
+    }
+
+    let spanEnded = false;
+    function endSpan(status) {
+      if (!spanEnded) {
+        spanEnded = true;
+        span.setStatus(status);
+        span.end();
+      }
+    }
+
+    // Fallback: end span if the connection closes before any response.
+    // This is removed if we do get a response, because in that case
+    // we want to only end the span when the response is finished.
+    const requestOnClose = () => endSpan({ code: SPAN_STATUS_UNSET });
+    request.on('close', requestOnClose);
+
+    request.on(errorMonitor, error => {
+      DEBUG_BUILD && debug.log(LOG_PREFIX, 'outgoingRequest on request error()', error);
+      if (breadcrumbs) {
+        addBreadcrumbs(request, undefined);
+      }
+      endSpan({ code: SPAN_STATUS_ERROR });
+    });
+
+    request.prependListener('response', response => {
+      // no longer need this, listen on response now.
+      // do not end the span until the response finishes
+      request.removeListener('close', requestOnClose);
+      if (request.listenerCount('response') <= 1) {
+        response.resume();
+      }
+      setIncomingResponseSpanData(response, span);
+      options.outgoingResponseHook?.(span, response);
+
+      let finished = false;
+      function finishWithResponse(error) {
+        if (!finished) {
+          finished = true;
+          if (error) {
+            DEBUG_BUILD && debug.log(LOG_PREFIX, 'outgoingRequest on response error()', error);
+          }
+          if (breadcrumbs) {
+            addBreadcrumbs(request, response);
+          }
+          const aborted = response.aborted && !response.complete;
+          const status =
+            error || typeof response.statusCode !== 'number' || aborted
+              ? { code: SPAN_STATUS_ERROR }
+              : getSpanStatusFromHttpCode(response.statusCode);
+          options.applyCustomAttributesOnSpan?.(span, request, response);
+          endSpan(status);
+        }
+      }
+
+      response.on('end', () => finishWithResponse());
+      response.on(errorMonitor, finishWithResponse);
+    });
+  };
+
+  return {
+    [HTTP_ON_CLIENT_REQUEST]: onHttpClientRequestCreated,
+  };
+}
+
+export { getHttpClientSubscriptions };
+//# sourceMappingURL=client-subscriptions.js.map

package/build/esm/integrations/http/client-subscriptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-subscriptions.js","sources":["../../../../src/integrations/http/client-subscriptions.ts"],"sourcesContent":["/**\n * Define the channels and subscription methods to subscribe to in order to\n * instrument the `node:http` module. Note that this does *not* actually\n * register the subscriptions, it simply returns a data object with the\n * channel names and the subscription handlers. Attach these to diagnostic\n * channels on Node versions where they are supported (ie, >=22.12.0).\n *\n * If any other platforms that do support diagnostic channels eventually add\n * channel coverage for the `node:http` client, then these methods can be\n * used on those platforms as well.\n *\n * This implementation is used in the client-patch strategy, by simply\n * calling the handlers with the relevant data at the appropriate time.\n */\n\nimport type { SpanStatus } from '../../types-hoist/spanStatus';\nimport { addOutgoingRequestBreadcrumb } from './add-outgoing-request-breadcrumb';\nimport {\n  getSpanStatusFromHttpCode,\n  SPAN_STATUS_ERROR,\n  SPAN_STATUS_UNSET,\n  startInactiveSpan,\n  SUPPRESS_TRACING_KEY,\n  withActiveSpan,\n} from '../../tracing';\nimport { debug } from '../../utils/debug-logger';\nimport { LRUMap } from '../../utils/lru';\nimport { getOutgoingRequestSpanData, setIncomingResponseSpanData } from './get-outgoing-span-data';\nimport { getRequestUrlFromClientRequest } from './get-request-url';\nimport { injectTracePropagationHeaders } from './inject-trace-propagation-headers';\nimport type { HttpInstrumentationOptions, HttpClientRequest, HttpIncomingMessage } from './types';\nimport { DEBUG_BUILD } from '../../debug-build';\nimport { LOG_PREFIX, HTTP_ON_CLIENT_REQUEST } from './constants';\nimport type { ClientSubscriptionName } from './constants';\nimport { getClient, getCurrentScope } from '../../currentScopes';\nimport { hasSpansEnabled } from '../../utils/hasSpansEnabled';\nimport { doubleWrapWarning } from './double-wrap-warning';\n\ntype ChannelListener = (message: unknown, name: string | symbol) => void;\n\nexport type HttpClientSubscriptions = Record<ClientSubscriptionName, ChannelListener>;\n\nexport function getHttpClientSubscriptions(options: HttpInstrumentationOptions): HttpClientSubscriptions {\n  const propagationDecisionMap = new LRUMap<string, boolean>(100);\n  const getConfig = () => getClient()?.getOptions();\n\n  const onHttpClientRequestCreated: ChannelListener = (data: unknown): void => {\n    // Skip all instrumentation if tracing is suppressed\n    // (e.g., Sentry's own transport uses this to avoid self-instrumentation)\n    if (getCurrentScope().getScopeData().sdkProcessingMetadata[SUPPRESS_TRACING_KEY] === true) {\n      return;\n    }\n\n    const clientOptions = getConfig();\n    const {\n      errorMonitor = 'error',\n      spans: createSpans = clientOptions ? hasSpansEnabled(clientOptions) : true,\n      propagateTrace = false,\n      breadcrumbs = true,\n      http,\n      https,\n      suppressOtelWarning = false,\n    } = options;\n\n    const { request } = data as { request: HttpClientRequest };\n\n    // check if request is ignored. if so, we do nothing at all.\n    if (options.ignoreOutgoingRequests?.(getRequestUrlFromClientRequest(request), request)) {\n      return;\n    }\n\n    // guard against adding breadcrumbs multiple times, or when not enabled\n    let addedBreadcrumbs = false;\n    function addBreadcrumbs(request: HttpClientRequest, response: HttpIncomingMessage | undefined) {\n      if (!addedBreadcrumbs) {\n        addedBreadcrumbs = true;\n        addOutgoingRequestBreadcrumb(request, response);\n      }\n    }\n\n    // called if spans and/or trace propagation are disabled\n    function breadcrumbsOnly(request: HttpClientRequest) {\n      request.on(errorMonitor, () => addBreadcrumbs(request, undefined));\n      request.prependListener('response', response => {\n        if (request.listenerCount('response') <= 1) {\n          response.resume();\n        }\n        response.on('end', () => addBreadcrumbs(request, response));\n        response.on(errorMonitor, () => addBreadcrumbs(request, response));\n      });\n    }\n\n    if (!createSpans) {\n      // no spans, but maybe tracing and/or breadcrumbs\n      if (breadcrumbs) {\n        breadcrumbsOnly(request);\n      }\n      if (propagateTrace) {\n        injectTracePropagationHeaders(request, propagationDecisionMap);\n      }\n      return;\n    }\n\n    // guard against OTel wrapping the same module and emitting double-spans\n    // this doesn't prevent it, just prints a debug warning for the user.\n    if (!suppressOtelWarning) {\n      if (http) doubleWrapWarning(http);\n      if (https) doubleWrapWarning(https);\n    }\n\n    // spans are enabled\n    const span = startInactiveSpan(getOutgoingRequestSpanData(request));\n    options.outgoingRequestHook?.(span, request);\n\n    // Inject trace headers after span creation so sentry-trace contains the\n    // outgoing span's ID (not the parent's), enabling downstream services to\n    // link to this span.\n    if (propagateTrace) {\n      if (span.isRecording()) {\n        withActiveSpan(span, () => {\n          injectTracePropagationHeaders(request, propagationDecisionMap);\n        });\n      } else {\n        injectTracePropagationHeaders(request, propagationDecisionMap);\n      }\n    }\n\n    let spanEnded = false;\n    function endSpan(status: SpanStatus): void {\n      if (!spanEnded) {\n        spanEnded = true;\n        span.setStatus(status);\n        span.end();\n      }\n    }\n\n    // Fallback: end span if the connection closes before any response.\n    // This is removed if we do get a response, because in that case\n    // we want to only end the span when the response is finished.\n    const requestOnClose = () => endSpan({ code: SPAN_STATUS_UNSET });\n    request.on('close', requestOnClose);\n\n    request.on(errorMonitor, error => {\n      DEBUG_BUILD && debug.log(LOG_PREFIX, 'outgoingRequest on request error()', error);\n      if (breadcrumbs) {\n        addBreadcrumbs(request, undefined);\n      }\n      endSpan({ code: SPAN_STATUS_ERROR });\n    });\n\n    request.prependListener('response', response => {\n      // no longer need this, listen on response now.\n      // do not end the span until the response finishes\n      request.removeListener('close', requestOnClose);\n      if (request.listenerCount('response') <= 1) {\n        response.resume();\n      }\n      setIncomingResponseSpanData(response, span);\n      options.outgoingResponseHook?.(span, response);\n\n      let finished = false;\n      function finishWithResponse(error?: unknown): void {\n        if (!finished) {\n          finished = true;\n          if (error) {\n            DEBUG_BUILD && debug.log(LOG_PREFIX, 'outgoingRequest on response error()', error);\n          }\n          if (breadcrumbs) {\n            addBreadcrumbs(request, response);\n          }\n          const aborted = response.aborted && !response.complete;\n          const status: SpanStatus =\n            error || typeof response.statusCode !== 'number' || aborted\n              ? { code: SPAN_STATUS_ERROR }\n              : getSpanStatusFromHttpCode(response.statusCode);\n          options.applyCustomAttributesOnSpan?.(span, request, response);\n          endSpan(status);\n        }\n      }\n\n      response.on('end', () => finishWithResponse());\n      response.on(errorMonitor, finishWithResponse);\n    });\n  };\n\n  return {\n    [HTTP_ON_CLIENT_REQUEST]: onHttpClientRequestCreated,\n  };\n}\n"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,6 @@
+const LOG_PREFIX = '@sentry/instrumentation-http';
+const HTTP_ON_CLIENT_REQUEST = 'http.client.request.created';
+const HTTP_ON_SERVER_REQUEST = 'http.server.request.start';
+
+export { HTTP_ON_CLIENT_REQUEST, HTTP_ON_SERVER_REQUEST, LOG_PREFIX };
+//# sourceMappingURL=constants.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sources":["../../../../src/integrations/http/constants.ts"],"sourcesContent":["export const LOG_PREFIX = '@sentry/instrumentation-http';\nexport const HTTP_ON_CLIENT_REQUEST = 'http.client.request.created';\nexport const HTTP_ON_SERVER_REQUEST = 'http.server.request.start';\nexport type ClientSubscriptionName = typeof HTTP_ON_CLIENT_REQUEST;\nexport type ServerSubscriptionName = typeof HTTP_ON_SERVER_REQUEST;\n"],"names":[],"mappings":"AAAO,MAAM,UAAA,GAAa;AACnB,MAAM,sBAAA,GAAyB;AAC/B,MAAM,sBAAA,GAAyB;;;;"}

package/build/esm/integrations/http/double-wrap-warning.js

@@ -0,0 +1,26 @@
+import { DEBUG_BUILD } from '../../debug-build.js';
+import { debug } from '../../utils/debug-logger.js';
+
+const isOtelWrapped = (fn) =>
+  typeof fn.__unwrap === 'function';
+
+// exported for tess
+const warning =
+  'Double-wrapped http.client detected. Either disable spans in Sentry.httpIntegration, or disable the OpenTelemetry HTTP instrumentation.';
+
+let didDoubleWrapWarning = false;
+// no-op in non-debug builds
+const doubleWrapWarning = DEBUG_BUILD
+  ? (http) => {
+      if (!didDoubleWrapWarning) {
+        if (isOtelWrapped(http.request) || isOtelWrapped(http.get)) {
+          // TODO: add link to documentation
+          didDoubleWrapWarning = true;
+          debug.warn(warning);
+        }
+      }
+    }
+  : () => {};
+
+export { doubleWrapWarning, warning };
+//# sourceMappingURL=double-wrap-warning.js.map

package/build/esm/integrations/http/double-wrap-warning.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"double-wrap-warning.js","sources":["../../../../src/integrations/http/double-wrap-warning.ts"],"sourcesContent":["import { DEBUG_BUILD } from '../../debug-build';\nimport { debug } from '../../utils/debug-logger';\nimport type { HttpModuleExport } from './types';\n\nconst isOtelWrapped = (fn: Function & { __unwrap?: Function }): fn is Function & { __unwrap: Function } =>\n  typeof fn.__unwrap === 'function';\n\n// exported for tess\nexport const warning =\n  'Double-wrapped http.client detected. Either disable spans in Sentry.httpIntegration, or disable the OpenTelemetry HTTP instrumentation.';\n\nlet didDoubleWrapWarning = false;\n// no-op in non-debug builds\nexport const doubleWrapWarning = DEBUG_BUILD\n  ? (http: HttpModuleExport) => {\n      if (!didDoubleWrapWarning) {\n        if (isOtelWrapped(http.request) || isOtelWrapped(http.get)) {\n          // TODO: add link to documentation\n          didDoubleWrapWarning = true;\n          debug.warn(warning);\n        }\n      }\n    }\n  : () => {};\n"],"names":[],"mappings":";;;AAIA,MAAM,aAAA,GAAgB,CAAC,EAAE;AACzB,EAAE,OAAO,EAAE,CAAC,QAAA,KAAa,UAAU;;AAEnC;MACa,OAAA;AACb,EAAE;;AAEF,IAAI,oBAAA,GAAuB,KAAK;AAChC;AACO,MAAM,oBAAoB;AACjC,IAAI,CAAC,IAAI,KAAuB;AAChC,MAAM,IAAI,CAAC,oBAAoB,EAAE;AACjC,QAAQ,IAAI,aAAa,CAAC,IAAI,CAAC,OAAO,CAAA,IAAK,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;AACpE;AACA,UAAU,oBAAA,GAAuB,IAAI;AACrC,UAAU,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC;AAC7B,QAAQ;AACR,MAAM;AACN,IAAI;AACJ,IAAI,MAAM,CAAC;;;;"}

package/build/esm/integrations/http/get-outgoing-span-data.js

@@ -0,0 +1,85 @@
+import { SEMANTIC_ATTRIBUTE_SENTRY_OP } from '../../semanticAttributes.js';
+import { getHttpSpanDetailsFromUrlObject, parseStringToURLObject } from '../../utils/url.js';
+import { getRequestUrlFromClientRequest } from './get-request-url.js';
+
+/**
+ * Build the initial span name and attributes for an outgoing HTTP request.
+ * This is called before the span is created, to get the initial details.
+ */
+function getOutgoingRequestSpanData(request) {
+  const url = getRequestUrlFromClientRequest(request);
+  const [name, attributes] = getHttpSpanDetailsFromUrlObject(
+    parseStringToURLObject(url),
+    'client',
+    'auto.http.client',
+    request,
+  );
+
+  const userAgent = request.getHeader('user-agent');
+
+  return {
+    name,
+    attributes: {
+      // TODO(v11): Update these to the Sentry semantic attributes for urls.
+      // https://getsentry.github.io/sentry-conventions/attributes/
+      [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'http.client',
+      'otel.kind': 'CLIENT',
+      'http.url': url,
+      'http.method': request.method,
+      'http.target': request.path || '/',
+      'net.peer.name': request.host,
+      'http.host': request.getHeader('host') ,
+      ...(userAgent ? { 'user_agent.original': userAgent  } : {}),
+      ...attributes,
+    },
+    onlyIfParent: true,
+  };
+}
+
+/**
+ * Add span attributes once the response is received.
+ */
+function setIncomingResponseSpanData(response, span) {
+  const { statusCode, statusMessage, httpVersion, socket } = response;
+  const transport = httpVersion?.toUpperCase() !== 'QUIC' ? 'ip_tcp' : 'ip_udp';
+
+  span.setAttributes({
+    'http.response.status_code': statusCode,
+    'network.protocol.version': httpVersion,
+    // TODO(v11): Update these to the Sentry semantic attributes for urls.
+    // https://getsentry.github.io/sentry-conventions/attributes/
+    'http.flavor': httpVersion,
+    'network.transport': transport,
+    'net.transport': transport,
+    'http.status_text': statusMessage?.toUpperCase(),
+    'http.status_code': statusCode,
+    ...getResponseContentLengthAttributes(response),
+    ...getSocketAttrs(socket),
+  });
+}
+
+function getSocketAttrs(socket) {
+  if (!socket) return {};
+  const { remoteAddress, remotePort } = socket;
+  return {
+    'network.peer.address': remoteAddress,
+    'network.peer.port': remotePort,
+    'net.peer.ip': remoteAddress,
+    'net.peer.port': remotePort,
+  };
+}
+
+function getResponseContentLengthAttributes(response) {
+  const { headers } = response;
+  const contentLengthHeader = headers['content-length'];
+  const length = contentLengthHeader ? parseInt(String(contentLengthHeader), 10) : -1;
+  const encoding = headers['content-encoding'];
+  return length >= 0
+    ? encoding && encoding !== 'identity'
+      ? { 'http.response_content_length': length }
+      : { 'http.response_content_length_uncompressed': length }
+    : {};
+}
+
+export { getOutgoingRequestSpanData, setIncomingResponseSpanData };
+//# sourceMappingURL=get-outgoing-span-data.js.map

package/build/esm/integrations/http/get-outgoing-span-data.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-outgoing-span-data.js","sources":["../../../../src/integrations/http/get-outgoing-span-data.ts"],"sourcesContent":["import type { Span, SpanAttributes } from '../../types-hoist/span';\nimport { SEMANTIC_ATTRIBUTE_SENTRY_OP } from '../../semanticAttributes';\nimport { getHttpSpanDetailsFromUrlObject, parseStringToURLObject } from '../../utils/url';\nimport type { HttpClientRequest, HttpIncomingMessage } from './types';\nimport { getRequestUrlFromClientRequest } from './get-request-url';\nimport type { StartSpanOptions } from '../../types-hoist/startSpanOptions';\n\n/**\n * Build the initial span name and attributes for an outgoing HTTP request.\n * This is called before the span is created, to get the initial details.\n */\nexport function getOutgoingRequestSpanData(request: HttpClientRequest): StartSpanOptions {\n  const url = getRequestUrlFromClientRequest(request);\n  const [name, attributes] = getHttpSpanDetailsFromUrlObject(\n    parseStringToURLObject(url),\n    'client',\n    'auto.http.client',\n    request,\n  );\n\n  const userAgent = request.getHeader('user-agent');\n\n  return {\n    name,\n    attributes: {\n      // TODO(v11): Update these to the Sentry semantic attributes for urls.\n      // https://getsentry.github.io/sentry-conventions/attributes/\n      [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'http.client',\n      'otel.kind': 'CLIENT',\n      'http.url': url,\n      'http.method': request.method,\n      'http.target': request.path || '/',\n      'net.peer.name': request.host,\n      'http.host': request.getHeader('host') as string | undefined,\n      ...(userAgent ? { 'user_agent.original': userAgent as string } : {}),\n      ...attributes,\n    },\n    onlyIfParent: true,\n  };\n}\n\n/**\n * Add span attributes once the response is received.\n */\nexport function setIncomingResponseSpanData(response: HttpIncomingMessage, span: Span): void {\n  const { statusCode, statusMessage, httpVersion, socket } = response;\n  const transport = httpVersion?.toUpperCase() !== 'QUIC' ? 'ip_tcp' : 'ip_udp';\n\n  span.setAttributes({\n    'http.response.status_code': statusCode,\n    'network.protocol.version': httpVersion,\n    // TODO(v11): Update these to the Sentry semantic attributes for urls.\n    // https://getsentry.github.io/sentry-conventions/attributes/\n    'http.flavor': httpVersion,\n    'network.transport': transport,\n    'net.transport': transport,\n    'http.status_text': statusMessage?.toUpperCase(),\n    'http.status_code': statusCode,\n    ...getResponseContentLengthAttributes(response),\n    ...getSocketAttrs(socket),\n  });\n}\n\nfunction getSocketAttrs(socket: HttpIncomingMessage['socket']): SpanAttributes {\n  if (!socket) return {};\n  const { remoteAddress, remotePort } = socket;\n  return {\n    'network.peer.address': remoteAddress,\n    'network.peer.port': remotePort,\n    'net.peer.ip': remoteAddress,\n    'net.peer.port': remotePort,\n  };\n}\n\nfunction getResponseContentLengthAttributes(response: HttpIncomingMessage): SpanAttributes {\n  const { headers } = response;\n  const contentLengthHeader = headers['content-length'];\n  const length = contentLengthHeader ? parseInt(String(contentLengthHeader), 10) : -1;\n  const encoding = headers['content-encoding'];\n  return length >= 0\n    ? encoding && encoding !== 'identity'\n      ? { 'http.response_content_length': length }\n      : { 'http.response_content_length_uncompressed': length }\n    : {};\n}\n"],"names":[],"mappings":";;;;AAOA;AACA;AACA;AACA;AACO,SAAS,0BAA0B,CAAC,OAAO,EAAuC;AACzF,EAAE,MAAM,GAAA,GAAM,8BAA8B,CAAC,OAAO,CAAC;AACrD,EAAE,MAAM,CAAC,IAAI,EAAE,UAAU,CAAA,GAAI,+BAA+B;AAC5D,IAAI,sBAAsB,CAAC,GAAG,CAAC;AAC/B,IAAI,QAAQ;AACZ,IAAI,kBAAkB;AACtB,IAAI,OAAO;AACX,GAAG;;AAEH,EAAE,MAAM,YAAY,OAAO,CAAC,SAAS,CAAC,YAAY,CAAC;;AAEnD,EAAE,OAAO;AACT,IAAI,IAAI;AACR,IAAI,UAAU,EAAE;AAChB;AACA;AACA,MAAM,CAAC,4BAA4B,GAAG,aAAa;AACnD,MAAM,WAAW,EAAE,QAAQ;AAC3B,MAAM,UAAU,EAAE,GAAG;AACrB,MAAM,aAAa,EAAE,OAAO,CAAC,MAAM;AACnC,MAAM,aAAa,EAAE,OAAO,CAAC,IAAA,IAAQ,GAAG;AACxC,MAAM,eAAe,EAAE,OAAO,CAAC,IAAI;AACnC,MAAM,WAAW,EAAE,OAAO,CAAC,SAAS,CAAC,MAAM,CAAA;AAC3C,MAAM,IAAI,SAAA,GAAY,EAAE,qBAAqB,EAAE,SAAA,GAAoB,GAAI,EAAE,CAAC;AAC1E,MAAM,GAAG,UAAU;AACnB,KAAK;AACL,IAAI,YAAY,EAAE,IAAI;AACtB,GAAG;AACH;;AAEA;AACA;AACA;AACO,SAAS,2BAA2B,CAAC,QAAQ,EAAuB,IAAI,EAAc;AAC7F,EAAE,MAAM,EAAE,UAAU,EAAE,aAAa,EAAE,WAAW,EAAE,MAAA,EAAO,GAAI,QAAQ;AACrE,EAAE,MAAM,SAAA,GAAY,WAAW,EAAE,WAAW,EAAC,KAAM,MAAA,GAAS,QAAA,GAAW,QAAQ;;AAE/E,EAAE,IAAI,CAAC,aAAa,CAAC;AACrB,IAAI,2BAA2B,EAAE,UAAU;AAC3C,IAAI,0BAA0B,EAAE,WAAW;AAC3C;AACA;AACA,IAAI,aAAa,EAAE,WAAW;AAC9B,IAAI,mBAAmB,EAAE,SAAS;AAClC,IAAI,eAAe,EAAE,SAAS;AAC9B,IAAI,kBAAkB,EAAE,aAAa,EAAE,WAAW,EAAE;AACpD,IAAI,kBAAkB,EAAE,UAAU;AAClC,IAAI,GAAG,kCAAkC,CAAC,QAAQ,CAAC;AACnD,IAAI,GAAG,cAAc,CAAC,MAAM,CAAC;AAC7B,GAAG,CAAC;AACJ;;AAEA,SAAS,cAAc,CAAC,MAAM,EAAiD;AAC/E,EAAE,IAAI,CAAC,MAAM,EAAE,OAAO,EAAE;AACxB,EAAE,MAAM,EAAE,aAAa,EAAE,UAAA,EAAW,GAAI,MAAM;AAC9C,EAAE,OAAO;AACT,IAAI,sBAAsB,EAAE,aAAa;AACzC,IAAI,mBAAmB,EAAE,UAAU;AACnC,IAAI,aAAa,EAAE,aAAa;AAChC,IAAI,eAAe,EAAE,UAAU;AAC/B,GAAG;AACH;;AAEA,SAAS,kCAAkC,CAAC,QAAQ,EAAuC;AAC3F,EAAE,MAAM,EAAE,OAAA,EAAQ,GAAI,QAAQ;AAC9B,EAAE,MAAM,mBAAA,GAAsB,OAAO,CAAC,gBAAgB,CAAC;AACvD,EAAE,MAAM,MAAA,GAAS,mBAAA,GAAsB,QAAQ,CAAC,MAAM,CAAC,mBAAmB,CAAC,EAAE,EAAE,CAAA,GAAI,EAAE;AACrF,EAAE,MAAM,QAAA,GAAW,OAAO,CAAC,kBAAkB,CAAC;AAC9C,EAAE,OAAO,UAAU;AACnB,MAAM,QAAA,IAAY,QAAA,KAAa;AAC/B,QAAQ,EAAE,8BAA8B,EAAE,MAAA;AAC1C,QAAQ,EAAE,2CAA2C,EAAE,MAAA;AACvD,MAAM,EAAE;AACR;;;;"}

package/build/esm/integrations/http/get-request-url.js

@@ -0,0 +1,49 @@
+/** Convert an outgoing request to request options. */
+function getRequestOptions(request) {
+  // request.host may be 'hostname:port' when the caller passed
+  // { host: 'hostname:port' } to http.request(). Split it so that
+  // `hostname` is always port-free (matching the http.RequestOptions contract)
+  // and the port is not lost when request.port is undefined.
+  const hostWithPort = request.host || '';
+  const portInHost = /^(.*):(\d+)$/.exec(hostWithPort);
+  const hostname = portInHost ? portInHost[1] : hostWithPort;
+  const port = request.port ?? (portInHost ? Number(portInHost[2]) : undefined);
+
+  return {
+    method: request.method,
+    port,
+    protocol: request.protocol,
+    host: request.host,
+    hostname,
+    path: request.path,
+    headers: request.getHeaders(),
+  };
+}
+
+function getRequestUrl(requestOptions) {
+  return String(getRequestUrlObject(requestOptions));
+}
+
+function getRequestUrlObject(requestOptions) {
+  const protocol = requestOptions.protocol || 'http:';
+  const hostHeader = requestOptions.headers?.host && String(requestOptions.headers?.host);
+  const hostname = hostHeader || requestOptions.hostname || requestOptions.host || '';
+  // Don't log standard :80 (http) and :443 (https) ports to reduce the noise
+  // Also don't add port if the hostname already includes a port
+  const port =
+    !requestOptions.port || requestOptions.port === 80 || requestOptions.port === 443 || /^(.*):(\d+)$/.test(hostname)
+      ? ''
+      : `:${requestOptions.port}`;
+  const path = requestOptions.path ? requestOptions.path : '/';
+  return new URL(path, `${protocol}//${hostname}${port}`);
+}
+
+/**
+ * Build the full URL string from a Node.js ClientRequest.
+ */
+function getRequestUrlFromClientRequest(request) {
+  return String(getRequestUrl(getRequestOptions(request)));
+}
+
+export { getRequestOptions, getRequestUrl, getRequestUrlFromClientRequest, getRequestUrlObject };
+//# sourceMappingURL=get-request-url.js.map

package/build/esm/integrations/http/get-request-url.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-request-url.js","sources":["../../../../src/integrations/http/get-request-url.ts"],"sourcesContent":["import type { HttpClientRequest, HttpRequestOptions } from './types';\n\n/** Convert an outgoing request to request options. */\nexport function getRequestOptions(request: HttpClientRequest): HttpRequestOptions {\n  // request.host may be 'hostname:port' when the caller passed\n  // { host: 'hostname:port' } to http.request(). Split it so that\n  // `hostname` is always port-free (matching the http.RequestOptions contract)\n  // and the port is not lost when request.port is undefined.\n  const hostWithPort = request.host || '';\n  const portInHost = /^(.*):(\\d+)$/.exec(hostWithPort);\n  const hostname = portInHost ? portInHost[1] : hostWithPort;\n  const port = request.port ?? (portInHost ? Number(portInHost[2]) : undefined);\n\n  return {\n    method: request.method,\n    port,\n    protocol: request.protocol,\n    host: request.host,\n    hostname,\n    path: request.path,\n    headers: request.getHeaders(),\n  };\n}\n\nexport function getRequestUrl(requestOptions: HttpRequestOptions): string {\n  return String(getRequestUrlObject(requestOptions));\n}\n\nexport function getRequestUrlObject(requestOptions: HttpRequestOptions): URL {\n  const protocol = requestOptions.protocol || 'http:';\n  const hostHeader = requestOptions.headers?.host && String(requestOptions.headers?.host);\n  const hostname = hostHeader || requestOptions.hostname || requestOptions.host || '';\n  // Don't log standard :80 (http) and :443 (https) ports to reduce the noise\n  // Also don't add port if the hostname already includes a port\n  const port =\n    !requestOptions.port || requestOptions.port === 80 || requestOptions.port === 443 || /^(.*):(\\d+)$/.test(hostname)\n      ? ''\n      : `:${requestOptions.port}`;\n  const path = requestOptions.path ? requestOptions.path : '/';\n  return new URL(path, `${protocol}//${hostname}${port}`);\n}\n\n/**\n * Build the full URL string from a Node.js ClientRequest.\n */\nexport function getRequestUrlFromClientRequest(request: HttpClientRequest): string {\n  return String(getRequestUrl(getRequestOptions(request)));\n}\n"],"names":[],"mappings":"AAEA;AACO,SAAS,iBAAiB,CAAC,OAAO,EAAyC;AAClF;AACA;AACA;AACA;AACA,EAAE,MAAM,YAAA,GAAe,OAAO,CAAC,IAAA,IAAQ,EAAE;AACzC,EAAE,MAAM,aAAa,cAAc,CAAC,IAAI,CAAC,YAAY,CAAC;AACtD,EAAE,MAAM,QAAA,GAAW,UAAA,GAAa,UAAU,CAAC,CAAC,CAAA,GAAI,YAAY;AAC5D,EAAE,MAAM,IAAA,GAAO,OAAO,CAAC,IAAA,KAAS,UAAA,GAAa,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,CAAA,GAAI,SAAS,CAAC;;AAE/E,EAAE,OAAO;AACT,IAAI,MAAM,EAAE,OAAO,CAAC,MAAM;AAC1B,IAAI,IAAI;AACR,IAAI,QAAQ,EAAE,OAAO,CAAC,QAAQ;AAC9B,IAAI,IAAI,EAAE,OAAO,CAAC,IAAI;AACtB,IAAI,QAAQ;AACZ,IAAI,IAAI,EAAE,OAAO,CAAC,IAAI;AACtB,IAAI,OAAO,EAAE,OAAO,CAAC,UAAU,EAAE;AACjC,GAAG;AACH;;AAEO,SAAS,aAAa,CAAC,cAAc,EAA8B;AAC1E,EAAE,OAAO,MAAM,CAAC,mBAAmB,CAAC,cAAc,CAAC,CAAC;AACpD;;AAEO,SAAS,mBAAmB,CAAC,cAAc,EAA2B;AAC7E,EAAE,MAAM,QAAA,GAAW,cAAc,CAAC,QAAA,IAAY,OAAO;AACrD,EAAE,MAAM,UAAA,GAAa,cAAc,CAAC,OAAO,EAAE,IAAA,IAAQ,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,IAAI,CAAC;AACzF,EAAE,MAAM,QAAA,GAAW,UAAA,IAAc,cAAc,CAAC,QAAA,IAAY,cAAc,CAAC,IAAA,IAAQ,EAAE;AACrF;AACA;AACA,EAAE,MAAM,IAAA;AACR,IAAI,CAAC,cAAc,CAAC,IAAA,IAAQ,cAAc,CAAC,SAAS,EAAA,IAAM,cAAc,CAAC,SAAS,GAAA,IAAO,cAAc,CAAC,IAAI,CAAC,QAAQ;AACrH,QAAQ;AACR,QAAQ,CAAC,CAAC,EAAE,cAAc,CAAC,IAAI,CAAC,CAAA;AACA,EAAA,MAAA,IAAA,GAAA,cAAA,CAAA,IAAA,GAAA,cAAA,CAAA,IAAA,GAAA,GAAA;AACA,EAAA,OAAA,IAAA,GAAA,CAAA,IAAA,EAAA,CAAA,EAAA,QAAA,CAAA,EAAA,EAAA,QAAA,CAAA,EAAA,IAAA,CAAA,CAAA,CAAA;AACA;;AAEA;AACA;AACA;AACA,SAAA,8BAAA,CAAA,OAAA,EAAA;AACA,EAAA,OAAA,MAAA,CAAA,aAAA,CAAA,iBAAA,CAAA,OAAA,CAAA,CAAA,CAAA;AACA;;;;"}

package/build/esm/integrations/http/inject-trace-propagation-headers.js

@@ -0,0 +1,79 @@
+import { getClient } from '../../currentScopes.js';
+import { DEBUG_BUILD } from '../../debug-build.js';
+import { debug } from '../../utils/debug-logger.js';
+import { isError } from '../../utils/is.js';
+import { getTraceData } from '../../utils/traceData.js';
+import { shouldPropagateTraceForUrl } from '../../utils/tracePropagationTargets.js';
+import { LOG_PREFIX } from './constants.js';
+import { getRequestUrlFromClientRequest } from './get-request-url.js';
+import { mergeBaggageHeaders } from '../../utils/baggage.js';
+
+/**
+ * Inject Sentry trace-propagation headers into an outgoing request if the
+ * target URL matches the configured `tracePropagationTargets`.
+ *
+ * Note: this must be called *before* calling `request.end()` (or firing the
+ * `http.client.request.start` diagnostics channel), because at that point,
+ * the headers have already been sent, and cannot be modified.
+ */
+function injectTracePropagationHeaders(
+  request,
+  propagationDecisionMap,
+) {
+  const url = getRequestUrlFromClientRequest(request);
+  const clientOptions = getClient()?.getOptions();
+  const { tracePropagationTargets, propagateTraceparent } = clientOptions ?? {};
+
+  if (!shouldPropagateTraceForUrl(url, tracePropagationTargets, propagationDecisionMap)) {
+    return;
+  }
+
+  const hasExistingSentryTraceHeader = !!request.getHeader('sentry-trace');
+
+  if (hasExistingSentryTraceHeader) {
+    // add nothing if there's already a sentry-trace header,
+    // or else baggage can be sent twice.
+    return;
+  }
+
+  const traceData = getTraceData({ propagateTraceparent });
+  if (!traceData) return;
+
+  const { 'sentry-trace': sentryTrace, baggage, traceparent } = traceData;
+
+  if (sentryTrace) {
+    try {
+      request.setHeader('sentry-trace', sentryTrace);
+      DEBUG_BUILD && debug.log(LOG_PREFIX, 'Added sentry-trace header');
+    } catch (e) {
+      DEBUG_BUILD &&
+        debug.error(LOG_PREFIX, 'Failed to set sentry-trace header:', isError(e) ? e.message : 'Unknown error');
+    }
+  }
+
+  if (traceparent && !request.getHeader('traceparent')) {
+    try {
+      request.setHeader('traceparent', traceparent);
+      DEBUG_BUILD && debug.log(LOG_PREFIX, 'Added traceparent header');
+    } catch (e) {
+      DEBUG_BUILD &&
+        debug.error(LOG_PREFIX, 'Failed to set traceparent header:', isError(e) ? e.message : 'Unknown error');
+    }
+  }
+
+  if (baggage) {
+    const merged = mergeBaggageHeaders(request.getHeader('baggage'), baggage);
+    if (merged) {
+      try {
+        request.setHeader('baggage', merged);
+        DEBUG_BUILD && debug.log(LOG_PREFIX, 'Added baggage header');
+      } catch (e) {
+        DEBUG_BUILD &&
+          debug.error(LOG_PREFIX, 'Failed to set baggage header:', isError(e) ? e.message : 'Unknown error');
+      }
+    }
+  }
+}
+
+export { injectTracePropagationHeaders };
+//# sourceMappingURL=inject-trace-propagation-headers.js.map

package/build/esm/integrations/http/inject-trace-propagation-headers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-trace-propagation-headers.js","sources":["../../../../src/integrations/http/inject-trace-propagation-headers.ts"],"sourcesContent":["import type { LRUMap } from '../../utils/lru';\nimport { getClient } from '../../currentScopes';\nimport { DEBUG_BUILD } from '../../debug-build';\nimport { debug } from '../../utils/debug-logger';\nimport { isError } from '../../utils/is';\nimport { getTraceData } from '../../utils/traceData';\nimport { shouldPropagateTraceForUrl } from '../../utils/tracePropagationTargets';\nimport { LOG_PREFIX } from './constants';\nimport { getRequestUrlFromClientRequest } from './get-request-url';\nimport type { HttpClientRequest } from './types';\nimport { mergeBaggageHeaders } from '../../utils/baggage';\n\n/**\n * Inject Sentry trace-propagation headers into an outgoing request if the\n * target URL matches the configured `tracePropagationTargets`.\n *\n * Note: this must be called *before* calling `request.end()` (or firing the\n * `http.client.request.start` diagnostics channel), because at that point,\n * the headers have already been sent, and cannot be modified.\n */\nexport function injectTracePropagationHeaders(\n  request: HttpClientRequest,\n  propagationDecisionMap: LRUMap<string, boolean>,\n): void {\n  const url = getRequestUrlFromClientRequest(request);\n  const clientOptions = getClient()?.getOptions();\n  const { tracePropagationTargets, propagateTraceparent } = clientOptions ?? {};\n\n  if (!shouldPropagateTraceForUrl(url, tracePropagationTargets, propagationDecisionMap)) {\n    return;\n  }\n\n  const hasExistingSentryTraceHeader = !!request.getHeader('sentry-trace');\n\n  if (hasExistingSentryTraceHeader) {\n    // add nothing if there's already a sentry-trace header,\n    // or else baggage can be sent twice.\n    return;\n  }\n\n  const traceData = getTraceData({ propagateTraceparent });\n  if (!traceData) return;\n\n  const { 'sentry-trace': sentryTrace, baggage, traceparent } = traceData;\n\n  if (sentryTrace) {\n    try {\n      request.setHeader('sentry-trace', sentryTrace);\n      DEBUG_BUILD && debug.log(LOG_PREFIX, 'Added sentry-trace header');\n    } catch (e) {\n      DEBUG_BUILD &&\n        debug.error(LOG_PREFIX, 'Failed to set sentry-trace header:', isError(e) ? e.message : 'Unknown error');\n    }\n  }\n\n  if (traceparent && !request.getHeader('traceparent')) {\n    try {\n      request.setHeader('traceparent', traceparent);\n      DEBUG_BUILD && debug.log(LOG_PREFIX, 'Added traceparent header');\n    } catch (e) {\n      DEBUG_BUILD &&\n        debug.error(LOG_PREFIX, 'Failed to set traceparent header:', isError(e) ? e.message : 'Unknown error');\n    }\n  }\n\n  if (baggage) {\n    const merged = mergeBaggageHeaders(request.getHeader('baggage'), baggage);\n    if (merged) {\n      try {\n        request.setHeader('baggage', merged);\n        DEBUG_BUILD && debug.log(LOG_PREFIX, 'Added baggage header');\n      } catch (e) {\n        DEBUG_BUILD &&\n          debug.error(LOG_PREFIX, 'Failed to set baggage header:', isError(e) ? e.message : 'Unknown error');\n      }\n    }\n  }\n}\n"],"names":[],"mappings":";;;;;;;;;;AAYA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,6BAA6B;AAC7C,EAAE,OAAO;AACT,EAAE,sBAAsB;AACxB,EAAQ;AACR,EAAE,MAAM,GAAA,GAAM,8BAA8B,CAAC,OAAO,CAAC;AACrD,EAAE,MAAM,gBAAgB,SAAS,EAAE,EAAE,UAAU,EAAE;AACjD,EAAE,MAAM,EAAE,uBAAuB,EAAE,oBAAA,KAAyB,aAAA,IAAiB,EAAE;;AAE/E,EAAE,IAAI,CAAC,0BAA0B,CAAC,GAAG,EAAE,uBAAuB,EAAE,sBAAsB,CAAC,EAAE;AACzF,IAAI;AACJ,EAAE;;AAEF,EAAE,MAAM,4BAAA,GAA+B,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,cAAc,CAAC;;AAE1E,EAAE,IAAI,4BAA4B,EAAE;AACpC;AACA;AACA,IAAI;AACJ,EAAE;;AAEF,EAAE,MAAM,YAAY,YAAY,CAAC,EAAE,oBAAA,EAAsB,CAAC;AAC1D,EAAE,IAAI,CAAC,SAAS,EAAE;;AAElB,EAAE,MAAM,EAAE,cAAc,EAAE,WAAW,EAAE,OAAO,EAAE,WAAA,EAAY,GAAI,SAAS;;AAEzE,EAAE,IAAI,WAAW,EAAE;AACnB,IAAI,IAAI;AACR,MAAM,OAAO,CAAC,SAAS,CAAC,cAAc,EAAE,WAAW,CAAC;AACpD,MAAM,WAAA,IAAe,KAAK,CAAC,GAAG,CAAC,UAAU,EAAE,2BAA2B,CAAC;AACvE,IAAI,CAAA,CAAE,OAAO,CAAC,EAAE;AAChB,MAAM,WAAA;AACN,QAAQ,KAAK,CAAC,KAAK,CAAC,UAAU,EAAE,oCAAoC,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,OAAA,GAAU,eAAe,CAAC;AAC/G,IAAI;AACJ,EAAE;;AAEF,EAAE,IAAI,WAAA,IAAe,CAAC,OAAO,CAAC,SAAS,CAAC,aAAa,CAAC,EAAE;AACxD,IAAI,IAAI;AACR,MAAM,OAAO,CAAC,SAAS,CAAC,aAAa,EAAE,WAAW,CAAC;AACnD,MAAM,WAAA,IAAe,KAAK,CAAC,GAAG,CAAC,UAAU,EAAE,0BAA0B,CAAC;AACtE,IAAI,CAAA,CAAE,OAAO,CAAC,EAAE;AAChB,MAAM,WAAA;AACN,QAAQ,KAAK,CAAC,KAAK,CAAC,UAAU,EAAE,mCAAmC,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,OAAA,GAAU,eAAe,CAAC;AAC9G,IAAI;AACJ,EAAE;;AAEF,EAAE,IAAI,OAAO,EAAE;AACf,IAAI,MAAM,MAAA,GAAS,mBAAmB,CAAC,OAAO,CAAC,SAAS,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;AAC7E,IAAI,IAAI,MAAM,EAAE;AAChB,MAAM,IAAI;AACV,QAAQ,OAAO,CAAC,SAAS,CAAC,SAAS,EAAE,MAAM,CAAC;AAC5C,QAAQ,WAAA,IAAe,KAAK,CAAC,GAAG,CAAC,UAAU,EAAE,sBAAsB,CAAC;AACpE,MAAM,CAAA,CAAE,OAAO,CAAC,EAAE;AAClB,QAAQ,WAAA;AACR,UAAU,KAAK,CAAC,KAAK,CAAC,UAAU,EAAE,+BAA+B,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,OAAA,GAAU,eAAe,CAAC;AAC5G,MAAM;AACN,IAAI;AACJ,EAAE;AACF;;;;"}

package/build/esm/integrations/mcp-server/handlers.js

@@ -168,5 +168,76 @@ function wrapAllMCPHandlers(serverInstance) {
   wrapPromptHandlers(serverInstance);
 }
 
-export { wrapAllMCPHandlers, wrapPromptHandlers, wrapResourceHandlers, wrapToolHandlers };
+/**
+ * Retroactively wraps handlers on tools, resources, and prompts that were registered
+ * before `wrapMcpServerWithSentry` was called.
+ *
+ * The MCP SDK stores registered entries in private maps and invokes them via the entry's
+ * own property at call time — `executor` for tools, `readCallback` for resources, and
+ * `handler` for prompts. Replacing those properties
+ * in-place is therefore equivalent to having wrapped the original registration call.
+ *
+ * NOTE: This intentionally accesses private MCP SDK internals (`_registeredTools` etc.).
+ * The properties and their shapes are verified against @modelcontextprotocol/sdk source:
+ * https://github.com/modelcontextprotocol/typescript-sdk/blob/2c0c481cb9dbfd15c8613f765c940a5f5bace94d/packages/server/src/server/mcp.ts#L304
+ * When upgrading the MCP SDK, re-verify that these internal maps and their callable
+ * properties still exist and are invoked directly (not captured by closure at registration).
+ * All access is defensive — if a property is absent or not a function we skip silently.
+ * @internal
+ */
+function wrapExistingHandlers(serverInstance) {
+  const server = serverInstance ;
+
+  // Tools: MCP SDK calls registeredTool.executor (generated from handler at registration time)
+  const registeredTools = server['_registeredTools'];
+  if (registeredTools && typeof registeredTools === 'object') {
+    for (const [name, tool] of Object.entries(registeredTools )) {
+      if (typeof tool['executor'] === 'function') {
+        tool['executor'] = createWrappedHandler(tool['executor'] , 'registerTool', name);
+      }
+    }
+  }
+
+  // Resources: MCP SDK calls registeredResource.readCallback
+  const registeredResources = server['_registeredResources'];
+  if (registeredResources && typeof registeredResources === 'object') {
+    for (const [name, resource] of Object.entries(registeredResources )) {
+      if (typeof resource['readCallback'] === 'function') {
+        resource['readCallback'] = createWrappedHandler(
+          resource['readCallback'] ,
+          'registerResource',
+          name,
+        );
+      }
+    }
+  }
+
+  // Resource templates: MCP SDK calls registeredResourceTemplate.readCallback
+  const registeredResourceTemplates = server['_registeredResourceTemplates'];
+  if (registeredResourceTemplates && typeof registeredResourceTemplates === 'object') {
+    for (const [name, template] of Object.entries(
+      registeredResourceTemplates ,
+    )) {
+      if (typeof template['readCallback'] === 'function') {
+        template['readCallback'] = createWrappedHandler(
+          template['readCallback'] ,
+          'registerResource',
+          name,
+        );
+      }
+    }
+  }
+
+  // Prompts: MCP SDK calls registeredPrompt.handler
+  const registeredPrompts = server['_registeredPrompts'];
+  if (registeredPrompts && typeof registeredPrompts === 'object') {
+    for (const [name, prompt] of Object.entries(registeredPrompts )) {
+      if (typeof prompt['handler'] === 'function') {
+        prompt['handler'] = createWrappedHandler(prompt['handler'] , 'registerPrompt', name);
+      }
+    }
+  }
+}
+
+export { wrapAllMCPHandlers, wrapExistingHandlers, wrapPromptHandlers, wrapResourceHandlers, wrapToolHandlers };
 //# sourceMappingURL=handlers.js.map