feat(tracing): Handle incoming tracestate data, allow for third-party data

packages/node/src/handlers.ts

@@ -1,7 +1,7 @@
 /* eslint-disable max-lines */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { captureException, getCurrentHub, startTransaction, withScope } from '@sentry/core';
-import { extractTraceparentData, Span } from '@sentry/tracing';
+import { extractSentrytraceData, extractTracestateData, Span } from '@sentry/tracing';
 import { Event, ExtractedNodeRequestData, Transaction } from '@sentry/types';
 import { forget, isPlainObject, isString, logger, normalize, stripUrlQueryAndFragment } from '@sentry/utils';
 import * as cookie from 'cookie';
@@ -55,17 +55,21 @@ export function tracingHandler(): (
     res: http.ServerResponse,
     next: (error?: any) => void,
   ): void {
-    // If there is a trace header set, we extract the data from it (parentSpanId, traceId, and sampling decision)
-    let traceparentData;
-    if (req.headers && isString(req.headers['sentry-trace'])) {
-      traceparentData = extractTraceparentData(req.headers['sentry-trace'] as string);
+    // Extract data from trace headers
+    let traceparentData, tracestateData;
+    if (req.headers?.['sentry-trace']) {
+      traceparentData = extractSentrytraceData(req.headers['sentry-trace'] as string);
+    }
+    if (req.headers?.tracestate) {
+      tracestateData = extractTracestateData(req.headers.tracestate as string);
     }
 
     const transaction = startTransaction(
       {
         name: extractExpressTransactionName(req, { path: true, method: true }),
         op: 'http.server',
         ...traceparentData,
+        ...(tracestateData && { metadata: { tracestate: tracestateData } }),
       },
       { request: extractRequestData(req) },
     );

packages/node/test/handlers.test.ts

@@ -221,8 +221,11 @@ describe('tracingHandler', () => {
     expect(startTransaction).toHaveBeenCalled();
   });
 
-  it("pulls parent's data from tracing header on the request", () => {
-    req.headers = { 'sentry-trace': '12312012123120121231201212312012-1121201211212012-0' };
+  it('pulls data from tracing headers on the request', () => {
+    req.headers = {
+      'sentry-trace': '12312012123120121231201212312012-1121201211212012-0',
+      tracestate: 'sentry=doGsaREgReaT',
+    };
 
     sentryTracingMiddleware(req, res, next);
 
@@ -232,6 +235,7 @@ describe('tracingHandler', () => {
     expect(transaction.traceId).toEqual('12312012123120121231201212312012');
     expect(transaction.parentSpanId).toEqual('1121201211212012');
     expect(transaction.sampled).toEqual(false);
+    expect(transaction.metadata?.tracestate).toEqual({ sentry: 'sentry=doGsaREgReaT' });
   });
 
   it('extracts request data for sampling context', () => {

packages/node/test/integrations/http.test.ts

@@ -1,7 +1,7 @@
 import * as sentryCore from '@sentry/core';
 import { Hub } from '@sentry/hub';
 import * as hubModule from '@sentry/hub';
-import { addExtensionMethods, Span, TRACEPARENT_REGEXP, Transaction } from '@sentry/tracing';
+import { addExtensionMethods, SENTRY_TRACE_REGEX, Span, Transaction } from '@sentry/tracing';
 import * as http from 'http';
 import * as nock from 'nock';
 
@@ -77,7 +77,7 @@ describe('tracing', () => {
 
     expect(sentryTraceHeader).toBeDefined();
     expect(tracestateHeader).toBeDefined();
-    expect(TRACEPARENT_REGEXP.test(sentryTraceHeader as string)).toBe(true);
+    expect(SENTRY_TRACE_REGEX.test(sentryTraceHeader as string)).toBe(true);
   });
 
   it("doesn't attach tracing headers to outgoing sentry requests", () => {

packages/serverless/src/awslambda.ts

@@ -9,9 +9,9 @@ import {
   withScope,
 } from '@sentry/node';
 import * as Sentry from '@sentry/node';
-import { extractTraceparentData } from '@sentry/tracing';
+import { extractSentrytraceData, extractTracestateData } from '@sentry/tracing';
 import { Integration } from '@sentry/types';
-import { isString, logger } from '@sentry/utils';
+import { logger } from '@sentry/utils';
 // NOTE: I have no idea how to fix this right now, and don't want to waste more time, as it builds just fine — Kamil
 // eslint-disable-next-line import/no-unresolved
 import { Context, Handler } from 'aws-lambda';
@@ -192,7 +192,7 @@ export function wrapHandler<TEvent, TResult>(
   };
   let timeoutWarningTimer: NodeJS.Timeout;
 
-  // AWSLambda is like Express. It makes a distinction about handlers based on it's last argument
+  // AWSLambda is like Express. It makes a distinction about handlers based on its last argument
   // async (event) => async handler
   // async (event, context) => async handler
   // (event, context, callback) => sync handler
@@ -243,16 +243,22 @@ export function wrapHandler<TEvent, TResult>(
       }, timeoutWarningDelay);
     }
 
-    // Applying `sentry-trace` to context
-    let traceparentData;
+    // Extract tracing data from headers
+    let traceparentData, tracestateData;
     const eventWithHeaders = event as { headers?: { [key: string]: string } };
-    if (eventWithHeaders.headers && isString(eventWithHeaders.headers['sentry-trace'])) {
-      traceparentData = extractTraceparentData(eventWithHeaders.headers['sentry-trace'] as string);
+
+    if (eventWithHeaders.headers?.['sentry-trace']) {
+      traceparentData = extractSentrytraceData(eventWithHeaders.headers['sentry-trace'] as string);
+    }
+    if (eventWithHeaders.headers?.tracestate) {
+      tracestateData = extractTracestateData(eventWithHeaders.headers.tracestate as string);
     }
+
     const transaction = startTransaction({
       name: context.functionName,
       op: 'awslambda.handler',
       ...traceparentData,
+      ...(tracestateData && { metadata: { tracestate: tracestateData } }),
     });
 
     const hub = getCurrentHub();

packages/serverless/src/gcpfunction/http.ts

@@ -1,6 +1,6 @@
 import { captureException, flush, getCurrentHub, Handlers, startTransaction } from '@sentry/node';
-import { extractTraceparentData } from '@sentry/tracing';
-import { isString, logger, stripUrlQueryAndFragment } from '@sentry/utils';
+import { extractSentrytraceData, extractTracestateData } from '@sentry/tracing';
+import { logger, stripUrlQueryAndFragment } from '@sentry/utils';
 
 import { domainify, getActiveDomain, proxyFunction } from './../utils';
 import { HttpFunction, WrapperOptions } from './general';
@@ -49,16 +49,22 @@ function _wrapHttpFunction(fn: HttpFunction, wrapOptions: Partial<HttpFunctionWr
     const reqMethod = (req.method || '').toUpperCase();
     const reqUrl = stripUrlQueryAndFragment(req.originalUrl || req.url || '');
 
-    // Applying `sentry-trace` to context
-    let traceparentData;
+    // Extract tracing data from headers
+    let traceparentData, tracestateData;
     const reqWithHeaders = req as { headers?: { [key: string]: string } };
-    if (reqWithHeaders.headers && isString(reqWithHeaders.headers['sentry-trace'])) {
-      traceparentData = extractTraceparentData(reqWithHeaders.headers['sentry-trace'] as string);
+
+    if (reqWithHeaders.headers?.['sentry-trace']) {
+      traceparentData = extractSentrytraceData(reqWithHeaders.headers['sentry-trace'] as string);
+    }
+    if (reqWithHeaders.headers?.tracestate) {
+      tracestateData = extractTracestateData(reqWithHeaders.headers.tracestate as string);
     }
+
     const transaction = startTransaction({
       name: `${reqMethod} ${reqUrl}`,
       op: 'gcp.function.http',
       ...traceparentData,
+      ...(tracestateData && { metadata: { tracestate: tracestateData } }),
     });
 
     // getCurrentHub() is expected to use current active domain as a carrier

packages/serverless/test/awslambda.test.ts

@@ -221,6 +221,35 @@ describe('AWSLambda', () => {
       await wrappedHandler(fakeEvent, fakeContext, fakeCallback);
     });
 
+    test('incoming trace headers are correctly parsed and used', async () => {
+      expect.assertions(1);
+
+      fakeEvent.headers = {
+        'sentry-trace': '12312012123120121231201212312012-1121201211212012-0',
+        tracestate: 'sentry=doGsaREgReaT,maisey=silly,charlie=goofy',
+      };
+
+      const handler: Handler = (_event, _context, callback) => {
+        expect(Sentry.startTransaction).toBeCalledWith(
+          expect.objectContaining({
+            traceId: '12312012123120121231201212312012',
+            parentSpanId: '1121201211212012',
+            parentSampled: false,
+            metadata: {
+              tracestate: {
+                sentry: 'sentry=doGsaREgReaT',
+                thirdparty: 'maisey=silly,charlie=goofy',
+              },
+            },
+          }),
+        );
+
+        callback(undefined, { its: 'fine' });
+      };
+      const wrappedHandler = wrapHandler(handler);
+      await wrappedHandler(fakeEvent, fakeContext, fakeCallback);
+    });
+
     test('capture error', async () => {
       expect.assertions(10);
 
@@ -278,6 +307,35 @@ describe('AWSLambda', () => {
       await wrappedHandler(fakeEvent, fakeContext, fakeCallback);
     });
 
+    test('incoming trace headers are correctly parsed and used', async () => {
+      expect.assertions(1);
+
+      fakeEvent.headers = {
+        'sentry-trace': '12312012123120121231201212312012-1121201211212012-0',
+        tracestate: 'sentry=doGsaREgReaT,maisey=silly,charlie=goofy',
+      };
+
+      const handler: Handler = async (_event, _context, callback) => {
+        expect(Sentry.startTransaction).toBeCalledWith(
+          expect.objectContaining({
+            traceId: '12312012123120121231201212312012',
+            parentSpanId: '1121201211212012',
+            parentSampled: false,
+            metadata: {
+              tracestate: {
+                sentry: 'sentry=doGsaREgReaT',
+                thirdparty: 'maisey=silly,charlie=goofy',
+              },
+            },
+          }),
+        );
+
+        callback(undefined, { its: 'fine' });
+      };
+      const wrappedHandler = wrapHandler(handler);
+      await wrappedHandler(fakeEvent, fakeContext, fakeCallback);
+    });
+
     test('capture error', async () => {
       expect.assertions(10);
 
@@ -328,6 +386,35 @@ describe('AWSLambda', () => {
       await wrappedHandler(fakeEvent, fakeContext, fakeCallback);
     });
 
+    test('incoming trace headers are correctly parsed and used', async () => {
+      expect.assertions(1);
+
+      fakeEvent.headers = {
+        'sentry-trace': '12312012123120121231201212312012-1121201211212012-0',
+        tracestate: 'sentry=doGsaREgReaT,maisey=silly,charlie=goofy',
+      };
+
+      const handler: Handler = async (_event, _context, callback) => {
+        expect(Sentry.startTransaction).toBeCalledWith(
+          expect.objectContaining({
+            traceId: '12312012123120121231201212312012',
+            parentSpanId: '1121201211212012',
+            parentSampled: false,
+            metadata: {
+              tracestate: {
+                sentry: 'sentry=doGsaREgReaT',
+                thirdparty: 'maisey=silly,charlie=goofy',
+              },
+            },
+          }),
+        );
+
+        callback(undefined, { its: 'fine' });
+      };
+      const wrappedHandler = wrapHandler(handler);
+      await wrappedHandler(fakeEvent, fakeContext, fakeCallback);
+    });
+
     test('capture error', async () => {
       expect.assertions(10);
 

packages/serverless/test/gcpfunction.test.ts

@@ -120,6 +120,35 @@ describe('GCPFunction', () => {
       expect(Sentry.flush).toBeCalledWith(2000);
     });
 
+    test('incoming trace headers are correctly parsed and used', async () => {
+      expect.assertions(1);
+
+      const handler: HttpFunction = (_req, res) => {
+        res.statusCode = 200;
+        res.end();
+      };
+      const wrappedHandler = wrapHttpFunction(handler);
+      const traceHeaders = {
+        'sentry-trace': '12312012123120121231201212312012-1121201211212012-0',
+        tracestate: 'sentry=doGsaREgReaT,maisey=silly,charlie=goofy',
+      };
+      await handleHttp(wrappedHandler, traceHeaders);
+
+      expect(Sentry.startTransaction).toBeCalledWith(
+        expect.objectContaining({
+          traceId: '12312012123120121231201212312012',
+          parentSpanId: '1121201211212012',
+          parentSampled: false,
+          metadata: {
+            tracestate: {
+              sentry: 'sentry=doGsaREgReaT',
+              thirdparty: 'maisey=silly,charlie=goofy',
+            },
+          },
+        }),
+      );
+    });
+
     test('capture error', async () => {
       expect.assertions(5);
 

packages/tracing/src/browser/browsertracing.ts

@@ -5,7 +5,7 @@ import { getGlobalObject, logger } from '@sentry/utils';
 import { startIdleTransaction } from '../hubextensions';
 import { DEFAULT_IDLE_TIMEOUT, IdleTransaction } from '../idletransaction';
 import { SpanStatus } from '../spanstatus';
-import { extractTraceparentData, secToMs } from '../utils';
+import { extractSentrytraceData, extractTracestateData, secToMs } from '../utils';
 import { registerBackgroundTabDetection } from './backgroundtab';
 import { MetricsInstrumentation } from './metrics';
 import {
@@ -191,7 +191,7 @@ export class BrowserTracing implements Integration {
     // eslint-disable-next-line @typescript-eslint/unbound-method
     const { beforeNavigate, idleTimeout, maxTransactionDuration } = this.options;
 
-    const parentContextFromHeader = context.op === 'pageload' ? getHeaderContext() : undefined;
+    const parentContextFromHeader = context.op === 'pageload' ? extractTraceDataFromMetaTags() : undefined;
 
     const expandedContext = {
       ...context,
@@ -230,14 +230,22 @@ export class BrowserTracing implements Integration {
 }
 
 /**
- * Gets transaction context from a sentry-trace meta.
+ * Gets transaction context data from `sentry-trace` and `tracestate` <meta> tags.
  *
- * @returns Transaction context data from the header or undefined if there's no header or the header is malformed
+ * @returns Transaction context data or undefined neither tag exists or has valid data
  */
-export function getHeaderContext(): Partial<TransactionContext> | undefined {
-  const header = getMetaContent('sentry-trace');
-  if (header) {
-    return extractTraceparentData(header);
+export function extractTraceDataFromMetaTags(): Partial<TransactionContext> | undefined {
+  const sentrytraceValue = getMetaContent('sentry-trace');
+  const tracestateValue = getMetaContent('tracestate');
+
+  const sentrytraceData = sentrytraceValue ? extractSentrytraceData(sentrytraceValue) : undefined;
+  const tracestateData = tracestateValue ? extractTracestateData(tracestateValue) : undefined;
+
+  if (sentrytraceData || tracestateData?.sentry || tracestateData?.thirdparty) {
+    return {
+      ...sentrytraceData,
+      ...(tracestateData && { metadata: { tracestate: tracestateData } }),
+    };
   }
 
   return undefined;

packages/tracing/src/index.ts

@@ -22,9 +22,10 @@ addExtensionMethods();
 export { addExtensionMethods };
 
 export {
-  extractTraceparentData,
+  extractSentrytraceData,
+  extractTracestateData,
   getActiveTransaction,
   hasTracingEnabled,
+  SENTRY_TRACE_REGEX,
   stripUrlQueryAndFragment,
-  TRACEPARENT_REGEXP,
 } from './utils';