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-tracemeta.
+ * 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';