ref: Read propagation context off of scope and isolation scope when propagating

Author: Luca Forstner

packages/core/src/baseclient.ts

@@ -638,21 +638,13 @@ export abstract class BaseClient<O extends ClientOptions> implements Client<O> {
         return evt;
       }
 
-      // If a trace context is not set on the event, we use the propagationContext set on the event to
-      // generate a trace context. If the propagationContext does not have a dynamic sampling context, we
-      // also generate one for it.
-      const { propagationContext } = evt.sdkProcessingMetadata || {};
-      const trace = evt.contexts && evt.contexts.trace;
-      if (!trace && propagationContext) {
-        const { traceId: trace_id, spanId, parentSpanId, dsc } = propagationContext as PropagationContext;
-        evt.contexts = {
-          trace: {
-            trace_id,
-            span_id: spanId,
-            parent_span_id: parentSpanId,
-          },
-          ...evt.contexts,
-        };
+      const propagationContext = {
+        ...isolationScope.getPropagationContext(),
+        ...(scope ? scope.getPropagationContext() : undefined),
+      };
+
+      if (propagationContext && (!evt.sdkProcessingMetadata || !evt.sdkProcessingMetadata.dynamicSamplingContext)) {
+        const { traceId: trace_id, dsc } = propagationContext;
 
         const dynamicSamplingContext = dsc ? dsc : getDynamicSamplingContextFromClient(trace_id, this, scope);
 

packages/core/src/utils/applyScopeDataToEvent.ts

@@ -16,13 +16,16 @@ export function applyScopeDataToEvent(event: Event, data: ScopeData): void {
   // We want to set the trace context for normal events only if there isn't already
   // a trace context on the event. There is a product feature in place where we link
   // errors with transaction and it relies on that.
+  // If there is a span, we use that to apply the trace data, if not, we use the propagation context as a fallback.
   if (span) {
     applySpanToEvent(event, span);
+  } else {
+    applyPropagationContextToEvent(event, propagationContext);
   }
 
   applyFingerprintToEvent(event, fingerprint);
   applyBreadcrumbsToEvent(event, breadcrumbs);
-  applySdkMetadataToEvent(event, sdkProcessingMetadata, propagationContext);
+  applySdkMetadataToEvent(event, sdkProcessingMetadata);
 }
 
 /** Merge data of two scopes together. */
@@ -163,15 +166,10 @@ function applyBreadcrumbsToEvent(event: Event, breadcrumbs: Breadcrumb[]): void
   event.breadcrumbs = mergedBreadcrumbs.length ? mergedBreadcrumbs : undefined;
 }
 
-function applySdkMetadataToEvent(
-  event: Event,
-  sdkProcessingMetadata: ScopeData['sdkProcessingMetadata'],
-  propagationContext: PropagationContext,
-): void {
+function applySdkMetadataToEvent(event: Event, sdkProcessingMetadata: ScopeData['sdkProcessingMetadata']): void {
   event.sdkProcessingMetadata = {
     ...event.sdkProcessingMetadata,
     ...sdkProcessingMetadata,
-    propagationContext: propagationContext,
   };
 }
 
@@ -190,6 +188,16 @@ function applySpanToEvent(event: Event, span: Span): void {
   }
 }
 
+function applyPropagationContextToEvent(event: Event, propagationContext: PropagationContext): void {
+  event.contexts = {
+    trace: {
+      trace_id: propagationContext.traceId,
+      span_id: propagationContext.spanId,
+    },
+    ...event.contexts,
+  };
+}
+
 /**
  * Applies fingerprint from the scope to the event if there's one,
  * uses message if there's one instead or get rid of empty fingerprint

packages/node/src/integrations/http.ts

@@ -1,6 +1,8 @@
 import type * as http from 'http';
 import type * as https from 'https';
 import type { Hub } from '@sentry/core';
+import { getIsolationScope } from '@sentry/core';
+import { getRootSpan } from '@sentry/core';
 import {
   addBreadcrumb,
   getActiveSpan,
@@ -13,13 +15,7 @@ import {
   spanToJSON,
   spanToTraceHeader,
 } from '@sentry/core';
-import type {
-  DynamicSamplingContext,
-  EventProcessor,
-  Integration,
-  SanitizedRequestData,
-  TracePropagationTargets,
-} from '@sentry/types';
+import type { EventProcessor, Integration, SanitizedRequestData, TracePropagationTargets } from '@sentry/types';
 import {
   LRUMap,
   dynamicSamplingContextToSentryBaggageHeader,
@@ -250,13 +246,15 @@ function _createWrappedRequestMethodFactory(
       // eslint-disable-next-line deprecation/deprecation
       const rawRequestUrl = extractRawUrl(requestOptions);
       const requestUrl = extractUrl(requestOptions);
+      const client = getClient();
 
       // we don't want to record requests to Sentry as either breadcrumbs or spans, so just use the original method
-      if (isSentryRequestUrl(requestUrl, getClient())) {
+      if (isSentryRequestUrl(requestUrl, client)) {
         return originalRequestMethod.apply(httpModule, requestArgs);
       }
 
       const scope = getCurrentScope();
+      const isolationScope = getIsolationScope();
       const parentSpan = getActiveSpan();
 
       const data = getRequestSpanData(requestUrl, requestOptions);
@@ -271,19 +269,26 @@ function _createWrappedRequestMethodFactory(
           })
         : undefined;
 
-      if (shouldAttachTraceData(rawRequestUrl)) {
-        if (requestSpan) {
-          const sentryTraceHeader = spanToTraceHeader(requestSpan);
-          const dynamicSamplingContext = getDynamicSamplingContextFromSpan(requestSpan);
-          addHeadersToRequestOptions(requestOptions, requestUrl, sentryTraceHeader, dynamicSamplingContext);
-        } else {
-          const client = getClient();
-          const { traceId, sampled, dsc } = scope.getPropagationContext();
-          const sentryTraceHeader = generateSentryTraceHeader(traceId, undefined, sampled);
-          const dynamicSamplingContext =
-            dsc || (client ? getDynamicSamplingContextFromClient(traceId, client, scope) : undefined);
-          addHeadersToRequestOptions(requestOptions, requestUrl, sentryTraceHeader, dynamicSamplingContext);
-        }
+      if (client && shouldAttachTraceData(rawRequestUrl)) {
+        const transaction = requestSpan && getRootSpan(requestSpan);
+
+        const { traceId, spanId, sampled, dsc } = {
+          ...isolationScope.getPropagationContext(),
+          ...scope.getPropagationContext(),
+        };
+
+        const sentryTraceHeader = requestSpan
+          ? spanToTraceHeader(requestSpan)
+          : generateSentryTraceHeader(traceId, spanId, sampled);
+
+        const sentryBaggageHeader = dynamicSamplingContextToSentryBaggageHeader(
+          dsc ||
+            (transaction
+              ? getDynamicSamplingContextFromSpan(transaction)
+              : getDynamicSamplingContextFromClient(traceId, client, scope)),
+        );
+
+        addHeadersToRequestOptions(requestOptions, requestUrl, sentryTraceHeader, sentryBaggageHeader);
       } else {
         DEBUG_BUILD &&
           logger.log(
@@ -333,7 +338,7 @@ function addHeadersToRequestOptions(
   requestOptions: RequestOptions,
   requestUrl: string,
   sentryTraceHeader: string,
-  dynamicSamplingContext: Partial<DynamicSamplingContext> | undefined,
+  sentryBaggageHeader: string | undefined,
 ): void {
   // Don't overwrite sentry-trace and baggage header if it's already set.
   const headers = requestOptions.headers || {};
@@ -343,15 +348,13 @@ function addHeadersToRequestOptions(
 
   DEBUG_BUILD &&
     logger.log(`[Tracing] Adding sentry-trace header ${sentryTraceHeader} to outgoing request to "${requestUrl}": `);
-  const sentryBaggage = dynamicSamplingContextToSentryBaggageHeader(dynamicSamplingContext);
-  const sentryBaggageHeader =
-    sentryBaggage && sentryBaggage.length > 0 ? normalizeBaggageHeader(requestOptions, sentryBaggage) : undefined;
 
   requestOptions.headers = {
     ...requestOptions.headers,
     'sentry-trace': sentryTraceHeader,
     // Setting a header to `undefined` will crash in node so we only set the baggage header when it's defined
-    ...(sentryBaggageHeader && { baggage: sentryBaggageHeader }),
+    ...(sentryBaggageHeader &&
+      sentryBaggageHeader.length > 0 && { baggage: normalizeBaggageHeader(requestOptions, sentryBaggageHeader) }),
   };
 }
 

packages/node/src/integrations/undici/index.ts

@@ -5,6 +5,8 @@ import {
   getCurrentScope,
   getDynamicSamplingContextFromClient,
   getDynamicSamplingContextFromSpan,
+  getIsolationScope,
+  getRootSpan,
   isSentryRequestUrl,
   spanToTraceHeader,
 } from '@sentry/core';
@@ -157,6 +159,7 @@ export class Undici implements Integration {
 
     const clientOptions = client.getOptions();
     const scope = getCurrentScope();
+    const isolationScope = getIsolationScope();
     const parentSpan = getActiveSpan();
 
     const span = this._shouldCreateSpan(stringUrl) ? createRequestSpan(parentSpan, request, stringUrl) : undefined;
@@ -180,18 +183,23 @@ export class Undici implements Integration {
     };
 
     if (shouldAttachTraceData(stringUrl)) {
-      if (span) {
-        const dynamicSamplingContext = getDynamicSamplingContextFromSpan(span);
-        const sentryBaggageHeader = dynamicSamplingContextToSentryBaggageHeader(dynamicSamplingContext);
-
-        setHeadersOnRequest(request, spanToTraceHeader(span), sentryBaggageHeader);
-      } else {
-        const { traceId, sampled, dsc } = scope.getPropagationContext();
-        const sentryTrace = generateSentryTraceHeader(traceId, undefined, sampled);
-        const dynamicSamplingContext = dsc || getDynamicSamplingContextFromClient(traceId, client, scope);
-        const sentryBaggageHeader = dynamicSamplingContextToSentryBaggageHeader(dynamicSamplingContext);
-        setHeadersOnRequest(request, sentryTrace, sentryBaggageHeader);
-      }
+      const transaction = span && getRootSpan(span);
+
+      const { traceId, spanId, sampled, dsc } = {
+        ...isolationScope.getPropagationContext(),
+        ...scope.getPropagationContext(),
+      };
+
+      const sentryTraceHeader = span ? spanToTraceHeader(span) : generateSentryTraceHeader(traceId, spanId, sampled);
+
+      const sentryBaggageHeader = dynamicSamplingContextToSentryBaggageHeader(
+        dsc ||
+          (transaction
+            ? getDynamicSamplingContextFromSpan(transaction)
+            : getDynamicSamplingContextFromClient(traceId, client, scope)),
+      );
+
+      setHeadersOnRequest(request, sentryTraceHeader, sentryBaggageHeader);
     }
   };
 

packages/tracing-internal/src/browser/request.ts

@@ -5,6 +5,7 @@ import {
   getCurrentScope,
   getDynamicSamplingContextFromClient,
   getDynamicSamplingContextFromSpan,
+  getIsolationScope,
   getRootSpan,
   hasTracingEnabled,
   spanToJSON,
@@ -275,6 +276,7 @@ export function xhrCallback(
   }
 
   const scope = getCurrentScope();
+  const isolationScope = getIsolationScope();
   const parentSpan = getActiveSpan();
 
   const span =
@@ -297,21 +299,26 @@ export function xhrCallback(
     spans[xhr.__sentry_xhr_span_id__] = span;
   }
 
-  if (xhr.setRequestHeader && shouldAttachHeaders(sentryXhrData.url)) {
-    if (span) {
-      const transaction = span && getRootSpan(span);
-      const dynamicSamplingContext = transaction && getDynamicSamplingContextFromSpan(transaction);
-      const sentryBaggageHeader = dynamicSamplingContextToSentryBaggageHeader(dynamicSamplingContext);
-      setHeaderOnXhr(xhr, spanToTraceHeader(span), sentryBaggageHeader);
-    } else {
-      const client = getClient();
-      const { traceId, sampled, dsc } = scope.getPropagationContext();
-      const sentryTraceHeader = generateSentryTraceHeader(traceId, undefined, sampled);
-      const dynamicSamplingContext =
-        dsc || (client ? getDynamicSamplingContextFromClient(traceId, client, scope) : undefined);
-      const sentryBaggageHeader = dynamicSamplingContextToSentryBaggageHeader(dynamicSamplingContext);
-      setHeaderOnXhr(xhr, sentryTraceHeader, sentryBaggageHeader);
-    }
+  const client = getClient();
+
+  if (xhr.setRequestHeader && shouldAttachHeaders(sentryXhrData.url) && client) {
+    const transaction = span && getRootSpan(span);
+
+    const { traceId, spanId, sampled, dsc } = {
+      ...isolationScope.getPropagationContext(),
+      ...scope.getPropagationContext(),
+    };
+
+    const sentryTraceHeader = span ? spanToTraceHeader(span) : generateSentryTraceHeader(traceId, spanId, sampled);
+
+    const sentryBaggageHeader = dynamicSamplingContextToSentryBaggageHeader(
+      dsc ||
+        (transaction
+          ? getDynamicSamplingContextFromSpan(transaction)
+          : getDynamicSamplingContextFromClient(traceId, client, scope)),
+    );
+
+    setHeaderOnXhr(xhr, sentryTraceHeader, sentryBaggageHeader);
   }
 
   return span;

packages/tracing-internal/src/common/fetch.ts

@@ -4,6 +4,7 @@ import {
   getCurrentScope,
   getDynamicSamplingContextFromClient,
   getDynamicSamplingContextFromSpan,
+  getIsolationScope,
   getRootSpan,
   hasTracingEnabled,
   spanToTraceHeader,
@@ -137,16 +138,21 @@ export function addTracingHeadersToFetchRequest(
 
   const transaction = span && getRootSpan(span);
 
-  const { traceId, sampled, dsc } = scope.getPropagationContext();
+  const isolationScope = getIsolationScope();
 
-  const sentryTraceHeader = span ? spanToTraceHeader(span) : generateSentryTraceHeader(traceId, undefined, sampled);
-  const dynamicSamplingContext = transaction
-    ? getDynamicSamplingContextFromSpan(transaction)
-    : dsc
-      ? dsc
-      : getDynamicSamplingContextFromClient(traceId, client, scope);
+  const { traceId, spanId, sampled, dsc } = {
+    ...isolationScope.getPropagationContext(),
+    ...scope.getPropagationContext(),
+  };
 
-  const sentryBaggageHeader = dynamicSamplingContextToSentryBaggageHeader(dynamicSamplingContext);
+  const sentryTraceHeader = span ? spanToTraceHeader(span) : generateSentryTraceHeader(traceId, spanId, sampled);
+
+  const sentryBaggageHeader = dynamicSamplingContextToSentryBaggageHeader(
+    dsc ||
+      (transaction
+        ? getDynamicSamplingContextFromSpan(transaction)
+        : getDynamicSamplingContextFromClient(traceId, client, scope)),
+  );
 
   const headers =
     options.headers ||

packages/types/src/tracing.ts

@@ -2,10 +2,43 @@ import type { DynamicSamplingContext } from './envelope';
 
 export type TracePropagationTargets = (string | RegExp)[];
 
+/**
+ * `PropagationContext` represents the data from an incoming trace. It should be constructed from incoming trace data,
+ * usually represented by `sentry-trace` and `baggage` HTTP headers.
+ *
+ * There is always a propagation context present in the SDK (or rather on Scopes), holding at least a `traceId`. This is
+ * to ensure that there is always a trace we can attach events onto, even if performance monitoring is disabled. If
+ * there was no incoming `traceId`, the `traceId` will be generated by the current SDK.
+ */
 export interface PropagationContext {
+  /**
+   * Either represents the incoming `traceId` or the `traceId` generated by the current SDK, if there was no incoming trace.
+   */
   traceId: string;
+  /**
+   * Represents the execution context of the current SDK. This acts as a fallback value to associate events with a
+   * particular execution context when performance monitoring is disabled.
+   *
+   * The ID of a current span (if one exists) should have precedence over this value when propagating trace data.
+   */
   spanId: string;
+  /**
+   * Represents the sampling decision of the incoming trace.
+   *
+   * The current SDK should not modify this value!
+   */
   sampled?: boolean;
+  /**
+   * The `parentSpanId` denotes the ID of the incoming client span. If there is no `parentSpanId` on the propagation
+   * context, it means that the the incoming trace didn't come from a span.
+   *
+   * The current SDK should not modify this value!
+   */
   parentSpanId?: string;
+  /**
+   * An undefined dsc in the propagation context means that the current SDK invocation is the head of trace and still free to modify and set the DSC for outgoing requests.
+   *
+   * The current SDK should not modify this value!
+   */
   dsc?: DynamicSamplingContext;
 }