propagate incoming tracestate headers

packages/nextjs/src/utils/instrumentServer.ts

@@ -1,6 +1,11 @@
 import { captureException, deepReadDirSync, getCurrentHub, Handlers, startTransaction } from '@sentry/node';
-import { extractSentrytraceData, getActiveTransaction, hasTracingEnabled } from '@sentry/tracing';
-import { fill, isString, logger, stripUrlQueryAndFragment } from '@sentry/utils';
+import {
+  extractSentrytraceData,
+  extractTracestateData,
+  getActiveTransaction,
+  hasTracingEnabled,
+} from '@sentry/tracing';
+import { fill, logger, stripUrlQueryAndFragment } from '@sentry/utils';
 import * as domain from 'domain';
 import * as http from 'http';
 import { default as createNextServer } from 'next';
@@ -199,10 +204,14 @@ function makeWrappedReqHandler(origReqHandler: ReqHandler): WrappedReqHandler {
         // We only want to record page and API requests
         if (hasTracingEnabled() && shouldTraceRequest(req.url, publicDirFiles)) {
           // If there is a trace header set, extract the data from it (parentSpanId, traceId, and sampling decision)
-          let traceparentData;
-          if (req.headers && isString(req.headers['sentry-trace'])) {
-            traceparentData = extractSentrytraceData(req.headers['sentry-trace'] as string);
-            logger.log(`[Tracing] Continuing trace ${traceparentData?.traceId}.`);
+          // Extract data from trace headers
+          let sentrytraceData, tracestateData;
+          if (req.headers?.['sentry-trace']) {
+            sentrytraceData = extractSentrytraceData(req.headers['sentry-trace'] as string);
+            logger.log(`[Tracing] Continuing trace ${sentrytraceData?.traceId}.`);
+          }
+          if (req.headers?.tracestate) {
+            tracestateData = extractTracestateData(req.headers.tracestate as string);
           }
 
           // pull off query string, if any
@@ -217,7 +226,8 @@ function makeWrappedReqHandler(origReqHandler: ReqHandler): WrappedReqHandler {
               name: `${namePrefix}${reqPath}`,
               op: 'http.server',
               metadata: { requestPath: reqPath },
-              ...traceparentData,
+              ...sentrytraceData,
+              ...(tracestateData && { metadata: { tracestate: tracestateData } }),
             },
             // extra context passed to the `tracesSampler`
             { request: req },

packages/nextjs/src/utils/withSentry.ts

@@ -1,7 +1,7 @@
 import { captureException, flush, getCurrentHub, Handlers, startTransaction } from '@sentry/node';
-import { extractSentrytraceData, hasTracingEnabled } from '@sentry/tracing';
+import { extractSentrytraceData, extractTracestateData, hasTracingEnabled } from '@sentry/tracing';
 import { Transaction } from '@sentry/types';
-import { addExceptionMechanism, isString, logger, stripUrlQueryAndFragment } from '@sentry/utils';
+import { addExceptionMechanism, logger, stripUrlQueryAndFragment } from '@sentry/utils';
 import * as domain from 'domain';
 import { NextApiHandler, NextApiResponse } from 'next';
 
@@ -36,11 +36,14 @@ export const withSentry = (handler: NextApiHandler): WrappedNextApiHandler => {
         currentScope.addEventProcessor(event => parseRequest(event, req));
 
         if (hasTracingEnabled()) {
-          // If there is a trace header set, extract the data from it (parentSpanId, traceId, and sampling decision)
-          let traceparentData;
-          if (req.headers && isString(req.headers['sentry-trace'])) {
-            traceparentData = extractSentrytraceData(req.headers['sentry-trace'] as string);
-            logger.log(`[Tracing] Continuing trace ${traceparentData?.traceId}.`);
+          // Extract data from trace headers
+          let sentrytraceData, tracestateData;
+          if (req.headers?.['sentry-trace']) {
+            sentrytraceData = extractSentrytraceData(req.headers['sentry-trace'] as string);
+            logger.log(`[Tracing] Continuing trace ${sentrytraceData?.traceId}.`);
+          }
+          if (req.headers?.tracestate) {
+            tracestateData = extractTracestateData(req.headers.tracestate as string);
           }
 
           const url = `${req.url}`;
@@ -60,7 +63,8 @@ export const withSentry = (handler: NextApiHandler): WrappedNextApiHandler => {
             {
               name: `${reqMethod}${reqPath}`,
               op: 'http.server',
-              ...traceparentData,
+              ...sentrytraceData,
+              ...(tracestateData && { metadata: { tracestate: tracestateData } }),
             },
             // extra context passed to the `tracesSampler`
             { request: req },

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 { extractSentrytraceData, Span } from '@sentry/tracing';
+import { extractSentrytraceData, extractTracestateData, Span } from '@sentry/tracing';
 import { Event, ExtractedNodeRequestData, RequestSessionStatus, Transaction } from '@sentry/types';
 import { isPlainObject, isString, logger, normalize, stripUrlQueryAndFragment } from '@sentry/utils';
 import * as cookie from 'cookie';
@@ -53,17 +53,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 sentrytraceData;
-    if (req.headers && isString(req.headers['sentry-trace'])) {
+    // Extract data from trace headers
+    let sentrytraceData, tracestateData;
+    if (req.headers?.['sentry-trace']) {
       sentrytraceData = 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',
         ...sentrytraceData,
+        ...(tracestateData && { metadata: { tracestate: tracestateData } }),
       },
       // extra context passed to the tracesSampler
       { request: extractRequestData(req) },

packages/node/test/handlers.test.ts

@@ -325,8 +325,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);
 
@@ -336,6 +339,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/serverless/src/awslambda.ts

@@ -9,9 +9,9 @@ import {
   withScope,
 } from '@sentry/node';
 import * as Sentry from '@sentry/node';
-import { extractSentrytraceData } 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';
@@ -201,7 +201,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
@@ -252,16 +252,22 @@ export function wrapHandler<TEvent, TResult>(
       }, timeoutWarningDelay);
     }
 
-    // Applying `sentry-trace` to context
-    let sentrytraceData;
+    // Extract tracing data from headers
+    let sentrytraceData, tracestateData;
     const eventWithHeaders = event as { headers?: { [key: string]: string } };
-    if (eventWithHeaders.headers && isString(eventWithHeaders.headers['sentry-trace'])) {
+
+    if (eventWithHeaders.headers?.['sentry-trace']) {
       sentrytraceData = 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',
       ...sentrytraceData,
+      ...(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 { extractSentrytraceData } 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 sentrytraceData;
+    // Extract tracing data from headers
+    let sentrytraceData, tracestateData;
     const reqWithHeaders = req as { headers?: { [key: string]: string } };
-    if (reqWithHeaders.headers && isString(reqWithHeaders.headers['sentry-trace'])) {
+
+    if (reqWithHeaders.headers?.['sentry-trace']) {
       sentrytraceData = 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',
       ...sentrytraceData,
+      ...(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);