fix check

Author: mydea

packages/node/src/integrations/node-fetch.ts

@@ -1,9 +1,9 @@
 import type { UndiciRequest, UndiciResponse } from '@opentelemetry/instrumentation-undici';
 import { UndiciInstrumentation } from '@opentelemetry/instrumentation-undici';
-import { getTraceData } from '@sentry/core';
+import { getClient, getTraceData, LRUMap } from '@sentry/core';
 import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, addBreadcrumb, defineIntegration, hasTracingEnabled } from '@sentry/core';
 import { getBreadcrumbLogLevelFromHttpStatusCode, getSanitizedUrlString, parseUrl } from '@sentry/core';
-import { addOpenTelemetryInstrumentation } from '@sentry/opentelemetry';
+import { addOpenTelemetryInstrumentation, shouldPropagateTraceForUrl } from '@sentry/opentelemetry';
 import type { IntegrationFn, SanitizedRequestData } from '@sentry/types';
 
 interface NodeFetchOptions {
@@ -27,6 +27,8 @@ const _nativeNodeFetchIntegration = ((options: NodeFetchOptions = {}) => {
   return {
     name: 'NodeFetch',
     setupOnce() {
+      const propagationDecisionMap = new LRUMap<string, boolean>(100);
+
       const instrumentation = new UndiciInstrumentation({
         requireParentforSpans: false,
         ignoreRequestHook: request => {
@@ -40,7 +42,11 @@ const _nativeNodeFetchIntegration = ((options: NodeFetchOptions = {}) => {
           // If tracing is disabled, we still want to propagate traces
           // So we do that manually here, matching what the instrumentation does otherwise
           if (!hasTracingEnabled()) {
-            const addedHeaders = getTraceData();
+            const tracePropagationTargets = getClient()?.getOptions().tracePropagationTargets;
+            const addedHeaders = shouldPropagateTraceForUrl(url, tracePropagationTargets, propagationDecisionMap)
+              ? getTraceData()
+              : {};
+
             const requestHeaders = request.headers;
             if (Array.isArray(requestHeaders)) {
               Object.entries(addedHeaders).forEach(headers => requestHeaders.push(...headers));

packages/opentelemetry/src/index.ts

@@ -45,7 +45,11 @@ export { setupEventContextTrace } from './setupEventContextTrace';
 
 export { setOpenTelemetryContextAsyncContextStrategy } from './asyncContextStrategy';
 export { wrapContextManagerClass } from './contextManager';
-export { SentryPropagator, getPropagationContextFromSpan } from './propagator';
+export {
+  SentryPropagator,
+  getPropagationContextFromSpan,
+  shouldPropagateTraceForUrl,
+} from './propagator';
 export { SentrySpanProcessor } from './spanProcessor';
 export {
   SentrySampler,

packages/opentelemetry/src/propagator.ts

@@ -89,11 +89,7 @@ export class SentryPropagator extends W3CBaggagePropagator {
     const url = activeSpan && getCurrentURL(activeSpan);
 
     const tracePropagationTargets = getClient()?.getOptions()?.tracePropagationTargets;
-    if (
-      typeof url === 'string' &&
-      tracePropagationTargets &&
-      !this._shouldInjectTraceData(tracePropagationTargets, url)
-    ) {
+    if (!shouldPropagateTraceForUrl(url, tracePropagationTargets, this._urlMatchesTargetsMap)) {
       DEBUG_BUILD &&
         logger.log(
           '[Tracing] Not injecting trace data for url because it does not match tracePropagationTargets:',
@@ -169,22 +165,36 @@ export class SentryPropagator extends W3CBaggagePropagator {
   public fields(): string[] {
     return [SENTRY_TRACE_HEADER, SENTRY_BAGGAGE_HEADER];
   }
+}
 
-  /** If we want to inject trace data for a given URL. */
-  private _shouldInjectTraceData(tracePropagationTargets: Options['tracePropagationTargets'], url: string): boolean {
-    if (tracePropagationTargets === undefined) {
-      return true;
-    }
+const NOT_PROPAGATED_MESSAGE =
+  '[Tracing] Not injecting trace data for url because it does not match tracePropagationTargets:';
 
-    const cachedDecision = this._urlMatchesTargetsMap.get(url);
-    if (cachedDecision !== undefined) {
-      return cachedDecision;
-    }
+/**
+ * Check if a given URL should be propagated to or not.
+ * If no url is defined, or no trace propagation targets are defined, this will always return `true`.
+ * You can also optionally provide a decision map, to cache decisions and avoid repeated regex lookups.
+ */
+export function shouldPropagateTraceForUrl(
+  url: string | undefined,
+  tracePropagationTargets: Options['tracePropagationTargets'],
+  decisionMap?: LRUMap<string, boolean>,
+): boolean {
+  if (typeof url !== 'string' || !tracePropagationTargets) {
+    return true;
+  }
 
-    const decision = stringMatchesSomePattern(url, tracePropagationTargets);
-    this._urlMatchesTargetsMap.set(url, decision);
-    return decision;
+  const cachedDecision = decisionMap?.get(url);
+  if (cachedDecision !== undefined) {
+    DEBUG_BUILD && !cachedDecision && logger.log(NOT_PROPAGATED_MESSAGE, url);
+    return cachedDecision;
   }
+
+  const decision = stringMatchesSomePattern(url, tracePropagationTargets);
+  decisionMap?.set(url, decision);
+
+  DEBUG_BUILD && !decision && logger.log(NOT_PROPAGATED_MESSAGE, url);
+  return decision;
 }
 
 /**