feat(core): Add OpenTelemetry-specific getTraceData version

packages/core/src/asyncContext/types.ts

@@ -1,4 +1,5 @@
 import type { Scope } from '@sentry/types';
+import { getTraceData } from '../utils/traceData';
 import type {
   startInactiveSpan,
   startSpan,
@@ -64,4 +65,7 @@ export interface AsyncContextStrategy {
 
   /** Suppress tracing in the given callback, ensuring no spans are generated inside of it.  */
   suppressTracing?: typeof suppressTracing;
+
+  /** get trace data as serialized string values for propagation via `sentry-trace` and `baggage` */
+  getTraceData?: typeof getTraceData;
 }

packages/core/src/index.ts

@@ -5,6 +5,7 @@ export type { OfflineStore, OfflineTransportOptions } from './transports/offline
 export type { ServerRuntimeClientOptions } from './server-runtime-client';
 export type { RequestDataIntegrationOptions } from './integrations/requestdata';
 export type { IntegrationIndex } from './integration';
+export type { TraceData } from './utils/traceData';
 
 export * from './tracing';
 export * from './semanticAttributes';

packages/core/src/utils/traceData.ts

@@ -5,11 +5,13 @@ import {
   generateSentryTraceHeader,
   logger,
 } from '@sentry/utils';
+import { getAsyncContextStrategy } from '../asyncContext';
+import { getMainCarrier } from '../carrier';
 import { getClient, getCurrentScope } from '../currentScopes';
 import { getDynamicSamplingContextFromClient, getDynamicSamplingContextFromSpan } from '../tracing';
 import { getActiveSpan, getRootSpan, spanToTraceHeader } from './spanUtils';
 
-type TraceData = {
+export type TraceData = {
   'sentry-trace'?: string;
   baggage?: string;
 };
@@ -30,6 +32,12 @@ type TraceData = {
  * or meta tag name.
  */
 export function getTraceData(span?: Span, scope?: Scope, client?: Client): TraceData {
+  const carrier = getMainCarrier();
+  const acs = getAsyncContextStrategy(carrier);
+  if (acs.getTraceData) {
+    return acs.getTraceData(span, scope, client);
+  }
+
   const clientToUse = client || getClient();
   const scopeToUse = scope || getCurrentScope();
   const spanToUse = span || getActiveSpan();

packages/opentelemetry/src/asyncContextStrategy.ts

@@ -1,6 +1,6 @@
 import * as api from '@opentelemetry/api';
 import { getDefaultCurrentScope, getDefaultIsolationScope, setAsyncContextStrategy } from '@sentry/core';
-import type { withActiveSpan as defaultWithActiveSpan } from '@sentry/core';
+import type { getTraceData as defaultGetTraceData, withActiveSpan as defaultWithActiveSpan } from '@sentry/core';
 import type { Scope } from '@sentry/types';
 
 import {
@@ -12,6 +12,7 @@ import { startInactiveSpan, startSpan, startSpanManual, withActiveSpan } from '.
 import type { CurrentScopes } from './types';
 import { getScopesFromContext } from './utils/contextData';
 import { getActiveSpan } from './utils/getActiveSpan';
+import { getTraceData } from './utils/getTraceData';
 import { suppressTracing } from './utils/suppressTracing';
 
 /**
@@ -102,9 +103,10 @@ export function setOpenTelemetryContextAsyncContextStrategy(): void {
     startSpanManual,
     startInactiveSpan,
     getActiveSpan,
+    suppressTracing,
     // The types here don't fully align, because our own `Span` type is narrower
     // than the OTEL one - but this is OK for here, as we now we'll only have OTEL spans passed around
     withActiveSpan: withActiveSpan as typeof defaultWithActiveSpan,
-    suppressTracing: suppressTracing,
+    getTraceData: getTraceData as typeof defaultGetTraceData,
   });
 }

packages/opentelemetry/src/utils/getTraceData.ts

@@ -0,0 +1,40 @@
+import * as api from '@opentelemetry/api';
+import type { Span } from '@opentelemetry/api';
+import type { TraceData } from '@sentry/core';
+import { getCurrentScope } from '@sentry/core';
+import { getPropagationContextFromSpan } from '../propagator';
+import { generateSpanContextForPropagationContext } from './generateSpanContextForPropagationContext';
+
+/**
+ * Otel-specific implementation of `getTraceData`.
+ * @see `@sentry/core` version of `getTraceData` for more information
+ */
+export function getTraceData(span?: Span): TraceData {
+  const ctx = api.context.active();
+  const spanToUse = span || api.trace.getSpan(ctx);
+
+  // This should never happen, given we always create an ambient non-recording span if there's no active span.
+  if (!spanToUse) {
+    return {};
+  }
+  const headersObject: Record<string, string> = {};
+
+  const propagationContext = spanToUse
+    ? getPropagationContextFromSpan(spanToUse)
+    : getCurrentScope().getPropagationContext();
+
+  const spanContext = generateSpanContextForPropagationContext(propagationContext);
+
+  const context = api.trace.setSpanContext(ctx, spanContext);
+
+  api.propagation.inject(context, headersObject);
+
+  if (!headersObject['sentry-trace']) {
+    return {};
+  }
+
+  return {
+    'sentry-trace': headersObject['sentry-trace'],
+    baggage: headersObject['baggage'],
+  };
+}