ref: Streamline sentry-trace, baggage and DSC handling

Author: mydea

packages/browser/src/tracing/request.ts

@@ -10,15 +10,11 @@ import {
   SentryNonRecordingSpan,
   getActiveSpan,
   getClient,
-  getCurrentScope,
-  getDynamicSamplingContextFromClient,
-  getDynamicSamplingContextFromSpan,
-  getIsolationScope,
+  getSentryHeaders,
   hasTracingEnabled,
   instrumentFetchRequest,
   setHttpStatus,
   spanToJSON,
-  spanToTraceHeader,
   startInactiveSpan,
 } from '@sentry/core';
 import type { Client, HandlerDataXhr, SentryWrappedXMLHttpRequest, Span } from '@sentry/types';
@@ -27,8 +23,6 @@ import {
   addFetchEndInstrumentationHandler,
   addFetchInstrumentationHandler,
   browserPerformanceTimeOrigin,
-  dynamicSamplingContextToSentryBaggageHeader,
-  generateSentryTraceHeader,
   parseUrl,
   stringMatchesSomePattern,
 } from '@sentry/utils';
@@ -419,21 +413,9 @@ export function xhrCallback(
 }
 
 function addTracingHeadersToXhrRequest(xhr: SentryWrappedXMLHttpRequest, client: Client, span?: Span): void {
-  const scope = getCurrentScope();
-  const isolationScope = getIsolationScope();
-  const { traceId, spanId, sampled, dsc } = {
-    ...isolationScope.getPropagationContext(),
-    ...scope.getPropagationContext(),
-  };
-
-  const sentryTraceHeader =
-    span && hasTracingEnabled() ? spanToTraceHeader(span) : generateSentryTraceHeader(traceId, spanId, sampled);
-
-  const sentryBaggageHeader = dynamicSamplingContextToSentryBaggageHeader(
-    dsc || (span ? getDynamicSamplingContextFromSpan(span) : getDynamicSamplingContextFromClient(traceId, client)),
-  );
+  const { sentryTrace, baggage } = getSentryHeaders({ span, client });
 
-  setHeaderOnXhr(xhr, sentryTraceHeader, sentryBaggageHeader);
+  setHeaderOnXhr(xhr, sentryTrace, baggage);
 }
 
 function setHeaderOnXhr(

packages/core/src/baseclient.ts

@@ -37,7 +37,6 @@ import {
   checkOrSetAlreadyCaught,
   createAttachmentEnvelopeItem,
   createClientReportEnvelope,
-  dropUndefinedKeys,
   dsnToString,
   isParameterizedString,
   isPlainObject,
@@ -57,9 +56,9 @@ import { createEventEnvelope, createSessionEnvelope } from './envelope';
 import type { IntegrationIndex } from './integration';
 import { afterSetupIntegrations } from './integration';
 import { setupIntegration, setupIntegrations } from './integration';
+import { getDynamicSamplingContextFromScopes, getTraceContextFromScopes } from './propagationContext';
 import type { Scope } from './scope';
 import { updateSession } from './session';
-import { getDynamicSamplingContextFromClient } from './tracing/dynamicSamplingContext';
 import { parseSampleRate } from './utils/parseSampleRate';
 import { prepareEvent } from './utils/prepareEvent';
 
@@ -689,30 +688,18 @@ export abstract class BaseClient<O extends ClientOptions> implements Client<O> {
         return evt;
       }
 
-      const propagationContext = {
-        ...isolationScope.getPropagationContext(),
-        ...(currentScope ? currentScope.getPropagationContext() : undefined),
+      evt.contexts = {
+        trace: getTraceContextFromScopes(currentScope, isolationScope),
+        ...evt.contexts,
       };
 
-      const trace = evt.contexts && evt.contexts.trace;
-      if (!trace && propagationContext) {
-        const { traceId: trace_id, spanId, parentSpanId, dsc } = propagationContext;
-        evt.contexts = {
-          trace: dropUndefinedKeys({
-            trace_id,
-            span_id: spanId,
-            parent_span_id: parentSpanId,
-          }),
-          ...evt.contexts,
-        };
+      const dynamicSamplingContext = getDynamicSamplingContextFromScopes(this, currentScope, isolationScope);
 
-        const dynamicSamplingContext = dsc ? dsc : getDynamicSamplingContextFromClient(trace_id, this);
+      evt.sdkProcessingMetadata = {
+        dynamicSamplingContext,
+        ...evt.sdkProcessingMetadata,
+      };
 
-        evt.sdkProcessingMetadata = {
-          dynamicSamplingContext,
-          ...evt.sdkProcessingMetadata,
-        };
-      }
       return evt;
     });
   }

packages/core/src/fetch.ts

@@ -1,24 +1,11 @@
 import type { Client, HandlerDataFetch, Scope, Span, SpanOrigin } from '@sentry/types';
-import {
-  BAGGAGE_HEADER_NAME,
-  SENTRY_BAGGAGE_KEY_PREFIX,
-  dynamicSamplingContextToSentryBaggageHeader,
-  generateSentryTraceHeader,
-  isInstanceOf,
-  parseUrl,
-} from '@sentry/utils';
-import { getClient, getCurrentScope, getIsolationScope } from './currentScopes';
+import { BAGGAGE_HEADER_NAME, SENTRY_BAGGAGE_KEY_PREFIX, isInstanceOf, parseUrl } from '@sentry/utils';
+import { getClient, getCurrentScope } from './currentScopes';
 import { SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from './semanticAttributes';
-import {
-  SPAN_STATUS_ERROR,
-  getDynamicSamplingContextFromClient,
-  getDynamicSamplingContextFromSpan,
-  setHttpStatus,
-  startInactiveSpan,
-} from './tracing';
+import { SPAN_STATUS_ERROR, getSentryHeaders, setHttpStatus, startInactiveSpan } from './tracing';
 import { SentryNonRecordingSpan } from './tracing/sentryNonRecordingSpan';
 import { hasTracingEnabled } from './utils/hasTracingEnabled';
-import { getActiveSpan, spanToTraceHeader } from './utils/spanUtils';
+import { getActiveSpan } from './utils/spanUtils';
 
 type PolymorphicRequestHeaders =
   | Record<string, string | undefined>
@@ -132,44 +119,31 @@ export function addTracingHeadersToFetchRequest(
   },
   span?: Span,
 ): PolymorphicRequestHeaders | undefined {
-  const isolationScope = getIsolationScope();
-
-  const { traceId, spanId, sampled, dsc } = {
-    ...isolationScope.getPropagationContext(),
-    ...scope.getPropagationContext(),
-  };
-
-  const sentryTraceHeader = span ? spanToTraceHeader(span) : generateSentryTraceHeader(traceId, spanId, sampled);
-
-  const sentryBaggageHeader = dynamicSamplingContextToSentryBaggageHeader(
-    dsc || (span ? getDynamicSamplingContextFromSpan(span) : getDynamicSamplingContextFromClient(traceId, client)),
-  );
+  const { sentryTrace, baggage } = getSentryHeaders({ span, client, scope });
 
   const headers =
     fetchOptionsObj.headers ||
     (typeof Request !== 'undefined' && isInstanceOf(request, Request) ? (request as Request).headers : undefined);
 
   if (!headers) {
-    return { 'sentry-trace': sentryTraceHeader, baggage: sentryBaggageHeader };
+    return { 'sentry-trace': sentryTrace, baggage };
   } else if (typeof Headers !== 'undefined' && isInstanceOf(headers, Headers)) {
     const newHeaders = new Headers(headers as Headers);
 
-    newHeaders.set('sentry-trace', sentryTraceHeader);
+    newHeaders.set('sentry-trace', sentryTrace);
 
-    if (sentryBaggageHeader) {
+    if (baggage) {
       const prevBaggageHeader = newHeaders.get(BAGGAGE_HEADER_NAME);
       if (prevBaggageHeader) {
         const prevHeaderStrippedFromSentryBaggage = stripBaggageHeaderOfSentryBaggageValues(prevBaggageHeader);
         newHeaders.set(
           BAGGAGE_HEADER_NAME,
           // If there are non-sentry entries (i.e. if the stripped string is non-empty/truthy) combine the stripped header and sentry baggage header
           // otherwise just set the sentry baggage header
-          prevHeaderStrippedFromSentryBaggage
-            ? `${prevHeaderStrippedFromSentryBaggage},${sentryBaggageHeader}`
-            : sentryBaggageHeader,
+          prevHeaderStrippedFromSentryBaggage ? `${prevHeaderStrippedFromSentryBaggage},${baggage}` : baggage,
         );
       } else {
-        newHeaders.set(BAGGAGE_HEADER_NAME, sentryBaggageHeader);
+        newHeaders.set(BAGGAGE_HEADER_NAME, baggage);
       }
     }
 
@@ -191,13 +165,13 @@ export function addTracingHeadersToFetchRequest(
           }
         }),
       // Attach the new sentry-trace header
-      ['sentry-trace', sentryTraceHeader],
+      ['sentry-trace', sentryTrace],
     ];
 
-    if (sentryBaggageHeader) {
+    if (baggage) {
       // If there are multiple entries with the same key, the browser will merge the values into a single request header.
       // Its therefore safe to simply push a "baggage" entry, even though there might already be another baggage header.
-      newHeaders.push([BAGGAGE_HEADER_NAME, sentryBaggageHeader]);
+      newHeaders.push([BAGGAGE_HEADER_NAME, baggage]);
     }
 
     return newHeaders as PolymorphicRequestHeaders;
@@ -215,13 +189,13 @@ export function addTracingHeadersToFetchRequest(
       newBaggageHeaders.push(stripBaggageHeaderOfSentryBaggageValues(existingBaggageHeader));
     }
 
-    if (sentryBaggageHeader) {
-      newBaggageHeaders.push(sentryBaggageHeader);
+    if (baggage) {
+      newBaggageHeaders.push(baggage);
     }
 
     return {
       ...(headers as Exclude<typeof headers, Headers>),
-      'sentry-trace': sentryTraceHeader,
+      'sentry-trace': sentryTrace,
       baggage: newBaggageHeaders.length > 0 ? newBaggageHeaders.join(',') : undefined,
     };
   }

packages/core/src/index.ts

@@ -43,6 +43,10 @@ export {
   getDefaultCurrentScope,
   getDefaultIsolationScope,
 } from './defaultScopes';
+export {
+  getDynamicSamplingContextFromScopes,
+  getTraceContextFromScopes,
+} from './propagationContext';
 export { setAsyncContextStrategy } from './asyncContext';
 export { getMainCarrier } from './carrier';
 export { makeSession, closeSession, updateSession } from './session';

packages/core/src/propagationContext.ts

@@ -0,0 +1,62 @@
+import type { Client, DynamicSamplingContext, PropagationContext, TraceContext } from '@sentry/types';
+import { dropUndefinedKeys, generateSentryTraceHeader } from '@sentry/utils';
+import { getCurrentScope, getGlobalScope, getIsolationScope } from './currentScopes';
+import { getDynamicSamplingContextFromClient } from './tracing';
+
+/**
+ * Get a trace context for the currently active scopes.
+ */
+export function getTraceContextFromScopes(
+  scope = getCurrentScope(),
+  isolationScope = getIsolationScope(),
+  globalScope = getGlobalScope(),
+): TraceContext {
+  const propagationContext = mergePropagationContexts(scope, isolationScope, globalScope);
+
+  const { traceId, spanId, parentSpanId } = propagationContext;
+
+  const traceContext: TraceContext = dropUndefinedKeys({
+    trace_id: traceId,
+    span_id: spanId,
+    parent_span_id: parentSpanId,
+  });
+
+  return traceContext;
+}
+
+/**
+ * Get a sentry-trace header value for the currently active scopes.
+ */
+export function scopesToTraceHeader(
+  scope = getCurrentScope(),
+  isolationScope = getIsolationScope(),
+  globalScope = getGlobalScope(),
+): string {
+  const { traceId, sampled, spanId } = mergePropagationContexts(scope, isolationScope, globalScope);
+  return generateSentryTraceHeader(traceId, spanId, sampled);
+}
+
+/**
+ * Get the dynamic sampling context for the currently active scopes.
+ */
+export function getDynamicSamplingContextFromScopes(
+  client: Client,
+  scope = getCurrentScope(),
+  isolationScope = getIsolationScope(),
+  globalScope = getGlobalScope(),
+): Partial<DynamicSamplingContext> {
+  const propagationContext = mergePropagationContexts(scope, isolationScope, globalScope);
+  return propagationContext.dsc || getDynamicSamplingContextFromClient(propagationContext.traceId, client);
+}
+
+function mergePropagationContexts(
+  scope = getCurrentScope(),
+  isolationScope = getIsolationScope(),
+  globalScope = getGlobalScope(),
+): PropagationContext {
+  return {
+    ...globalScope.getPropagationContext(),
+    ...isolationScope.getPropagationContext(),
+    ...scope.getPropagationContext(),
+  };
+}

packages/core/src/server-runtime-client.ts

@@ -17,15 +17,12 @@ import { BaseClient } from './baseclient';
 import { createCheckInEnvelope } from './checkin';
 import { getIsolationScope } from './currentScopes';
 import { DEBUG_BUILD } from './debug-build';
+import { getDynamicSamplingContextFromScopes, getTraceContextFromScopes } from './propagationContext';
 import type { Scope } from './scope';
 import { SessionFlusher } from './sessionflusher';
-import {
-  getDynamicSamplingContextFromClient,
-  getDynamicSamplingContextFromSpan,
-  registerSpanErrorInstrumentation,
-} from './tracing';
+import { getDynamicSamplingContextFromSpan, registerSpanErrorInstrumentation } from './tracing';
 import { _getSpanForScope } from './utils/spanOnScope';
-import { getRootSpan, spanToTraceContext } from './utils/spanUtils';
+import { spanToTraceContext } from './utils/spanUtils';
 
 export interface ServerRuntimeClientOptions extends ClientOptions<BaseTransportOptions> {
   platform?: string;
@@ -248,30 +245,19 @@ export class ServerRuntimeClient<
   }
 
   /** Extract trace information from scope */
-  private _getTraceInfoFromScope(
+  protected _getTraceInfoFromScope(
     scope: Scope | undefined,
   ): [dynamicSamplingContext: Partial<DynamicSamplingContext> | undefined, traceContext: TraceContext | undefined] {
     if (!scope) {
       return [undefined, undefined];
     }
 
     const span = _getSpanForScope(scope);
-    if (span) {
-      const rootSpan = getRootSpan(span);
-      const samplingContext = getDynamicSamplingContextFromSpan(rootSpan);
-      return [samplingContext, spanToTraceContext(rootSpan)];
-    }
-
-    const { traceId, spanId, parentSpanId, dsc } = scope.getPropagationContext();
-    const traceContext: TraceContext = {
-      trace_id: traceId,
-      span_id: spanId,
-      parent_span_id: parentSpanId,
-    };
-    if (dsc) {
-      return [dsc, traceContext];
-    }
 
-    return [getDynamicSamplingContextFromClient(traceId, this), traceContext];
+    const traceContext = span ? spanToTraceContext(span) : getTraceContextFromScopes(scope);
+    const dynamicSamplingContext = span
+      ? getDynamicSamplingContextFromSpan(span)
+      : getDynamicSamplingContextFromScopes(this, scope);
+    return [dynamicSamplingContext, traceContext];
   }
 }

packages/core/src/tracing/dynamicSamplingContext.ts

@@ -65,8 +65,6 @@ export function getDynamicSamplingContextFromSpan(span: Span): Readonly<Partial<
     return {};
   }
 
-  const dsc = getDynamicSamplingContextFromClient(spanToJSON(span).trace_id || '', client);
-
   const rootSpan = getRootSpan(span);
 
   // For core implementation, we freeze the DSC onto the span as a non-enumerable property
@@ -87,6 +85,7 @@ export function getDynamicSamplingContextFromSpan(span: Span): Readonly<Partial<
   }
 
   // Else, we generate it from the span
+  const dsc = getDynamicSamplingContextFromClient(span.spanContext().traceId, client);
   const jsonSpan = spanToJSON(rootSpan);
   const attributes = jsonSpan.data || {};
   const maybeSampleRate = attributes[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE];

packages/core/src/tracing/index.ts

@@ -27,3 +27,4 @@ export {
 export { setMeasurement, timedEventsToMeasurements } from './measurement';
 export { sampleSpan } from './sampling';
 export { logSpanEnd, logSpanStart } from './logSpans';
+export { getSentryHeaders } from './sentryHeaders';

packages/core/src/tracing/sentryHeaders.ts

@@ -0,0 +1,23 @@
+import type { Client, Scope, Span } from '@sentry/types';
+import { dynamicSamplingContextToSentryBaggageHeader } from '@sentry/utils';
+import { getDynamicSamplingContextFromScopes, scopesToTraceHeader } from '../propagationContext';
+import { spanToTraceHeader } from '../utils/spanUtils';
+import { getDynamicSamplingContextFromSpan } from './dynamicSamplingContext';
+
+/**
+ * Get the sentry-trace and baggage headers for a given span or scope.
+ * If no scope is defined, it will use the current scope.
+ */
+export function getSentryHeaders({ span, client, scope }: { span?: Span; client: Client; scope?: Scope }): {
+  sentryTrace: string;
+  baggage: string | undefined;
+} {
+  const sentryTrace = span ? spanToTraceHeader(span) : scopesToTraceHeader(scope);
+  const dsc = span ? getDynamicSamplingContextFromSpan(span) : getDynamicSamplingContextFromScopes(client, scope);
+  const baggage = dynamicSamplingContextToSentryBaggageHeader(dsc);
+
+  return {
+    sentryTrace,
+    baggage,
+  };
+}