getsentry · Lms24 · Aug 2, 2024 · Jul 31, 2024 · Jul 31, 2024 · Jul 31, 2024
diff --git a/packages/astro/src/index.server.ts b/packages/astro/src/index.server.ts
@@ -55,6 +55,7 @@ export {
   getSentryRelease,
   getSpanDescendants,
   getSpanStatusFromHttpCode,
+  getTraceData,
   graphqlIntegration,
   hapiIntegration,
   httpIntegration,

diff --git a/packages/astro/src/server/meta.ts b/packages/astro/src/server/meta.ts
diff --git a/packages/astro/src/server/middleware.ts b/packages/astro/src/server/middleware.ts
@@ -14,7 +14,7 @@ import type { Client, Scope, Span, SpanAttributes } from '@sentry/types';
 import { addNonEnumerableProperty, objectify, stripUrlQueryAndFragment } from '@sentry/utils';
 import type { APIContext, MiddlewareResponseHandler } from 'astro';
 
-import { getTracingMetaTags } from './meta';
+import { getTraceData } from '@sentry/node';
 
 type MiddlewareOptions = {
   /**
@@ -189,9 +189,13 @@ function addMetaTagToHead(htmlChunk: string, scope: Scope, client: Client, span?
   if (typeof htmlChunk !== 'string') {
     return htmlChunk;
   }
+  const { 'sentry-trace': sentryTrace, baggage } = getTraceData(span, scope, client);
+
+  const sentryTraceMeta = `<meta name="sentry-trace" content="${sentryTrace}"/>`;
+  const baggageMeta = baggage && `<meta name="baggage" content="${baggage}"/>`;
+
+  const content = `<head>\n${sentryTraceMeta}`.concat(baggageMeta ? `\n${baggageMeta}` : '', '\n');
 
-  const { sentryTrace, baggage } = getTracingMetaTags(span, scope, client);
-  const content = `<head>\n${sentryTrace}\n${baggage}\n`;
   return htmlChunk.replace('<head>', content);
 }
 

diff --git a/packages/astro/test/integration/middleware/index.test.ts b/packages/astro/test/integration/middleware/index.test.ts
@@ -3,7 +3,7 @@ import { describe, expect, it, vi } from 'vitest';
 import { onRequest } from '../../../src/integration/middleware';
 
 vi.mock('../../../src/server/meta', () => ({
-  getTracingMetaTags: () => ({
+  getTracingMetaTagValues: () => ({
     sentryTrace: '<meta name="sentry-trace" content="123">',
     baggage: '<meta name="baggage" content="abc">',
   }),

diff --git a/packages/astro/test/server/middleware.test.ts b/packages/astro/test/server/middleware.test.ts
@@ -1,12 +1,13 @@
 import { SEMANTIC_ATTRIBUTE_SENTRY_SOURCE } from '@sentry/core';
+import * as SentryCore from '@sentry/core';
 import * as SentryNode from '@sentry/node';
 import type { Client, Span } from '@sentry/types';
-import { vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { handleRequest, interpolateRouteFromUrlAndParams } from '../../src/server/middleware';
 
 vi.mock('../../src/server/meta', () => ({
-  getTracingMetaTags: () => ({
+  getTracingMetaTagValues: () => ({
     sentryTrace: '<meta name="sentry-trace" content="123">',
     baggage: '<meta name="baggage" content="abc">',
   }),
@@ -28,10 +29,18 @@ describe('sentryMiddleware', () => {
         setPropagationContext: vi.fn(),
         getSpan: getSpanMock,
         setSDKProcessingMetadata: setSDKProcessingMetadataMock,
+        getPropagationContext: () => ({}),
       } as any;
     });
     vi.spyOn(SentryNode, 'getActiveSpan').mockImplementation(getSpanMock);
     vi.spyOn(SentryNode, 'getClient').mockImplementation(() => ({}) as Client);
+    vi.spyOn(SentryNode, 'getTraceData').mockImplementation(() => ({
+      'sentry-trace': '123',
+      baggage: 'abc',
+    }));
+    vi.spyOn(SentryCore, 'getDynamicSamplingContextFromSpan').mockImplementation(() => ({
+      transaction: 'test',
+    }));
   });
 
   const nextResult = Promise.resolve(new Response(null, { status: 200, headers: new Headers() }));

diff --git a/packages/aws-serverless/src/index.ts b/packages/aws-serverless/src/index.ts
@@ -20,6 +20,7 @@ export {
   getCurrentScope,
   getGlobalScope,
   getIsolationScope,
+  getTraceData,
   setCurrentClient,
   Scope,
   SDK_VERSION,

diff --git a/packages/bun/src/index.ts b/packages/bun/src/index.ts
@@ -40,6 +40,7 @@ export {
   getCurrentScope,
   getGlobalScope,
   getIsolationScope,
+  getTraceData,
   setCurrentClient,
   Scope,
   SDK_VERSION,

diff --git a/packages/cloudflare/src/index.ts b/packages/cloudflare/src/index.ts
@@ -55,6 +55,7 @@ export {
   setMeasurement,
   getActiveSpan,
   getRootSpan,
+  getTraceData,
   startSpan,
   startInactiveSpan,
   startSpanManual,

diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
@@ -82,6 +82,7 @@ export {
 } from './utils/spanUtils';
 export { parseSampleRate } from './utils/parseSampleRate';
 export { applySdkMetadata } from './utils/sdkMetadata';
+export { getTraceData } from './utils/traceData';
 export { DEFAULT_ENVIRONMENT } from './constants';
 export { addBreadcrumb } from './breadcrumbs';
 export { functionToStringIntegration } from './integrations/functiontostring';

diff --git a/packages/core/src/utils/traceData.ts b/packages/core/src/utils/traceData.ts
@@ -0,0 +1,87 @@
+import type { Client, Scope, Span } from '@sentry/types';
+import {
+  TRACEPARENT_REGEXP,
+  dynamicSamplingContextToSentryBaggageHeader,
+  generateSentryTraceHeader,
+  logger,
+} from '@sentry/utils';
+import { getClient, getCurrentScope } from '../currentScopes';
+import { getDynamicSamplingContextFromClient, getDynamicSamplingContextFromSpan } from '../tracing';
+import { getActiveSpan, getRootSpan, spanToTraceHeader } from './spanUtils';
+
+/**
+ * Extracts trace propagation data from the current span or from the client's scope (via transaction or propagation
+ * context) and serializes it to `sentry-trace` and `baggage` values to strings. These values can be used to propagate
+ * a trace via our tracing Http headers or Html `<meta>` tags.
+ *
+ * This function also applies some validation to the generated sentry-trace and baggage values to ensure that
+ * only valid strings are returned.
+ *
+ * @param span a span to take the trace data from. By default, the currently active span is used.
+ * @param scope the scope to take trace data from By default, the active current scope is used.
+ * @param client the SDK's client to take trace data from. By default, the current client is used.
+ *
+ * @returns an object with the tracing data values. The object keys are the name of the tracing key to be used as header
+ * or meta tag name.
+ */
+export function getTraceData(
+  span?: Span,
+  scope?: Scope,
+  client?: Client,
+): { 'sentry-trace': string; baggage?: string } {
+  const clientToUse = client || getClient();
+  const scopeToUse = scope || getCurrentScope();
+  const spanToUse = span || getActiveSpan();
+
+  const { dsc, sampled, traceId } = scopeToUse.getPropagationContext();
+  const rootSpan = spanToUse && getRootSpan(spanToUse);
+
+  const sentryTrace = spanToUse ? spanToTraceHeader(spanToUse) : generateSentryTraceHeader(traceId, undefined, sampled);
+
+  const dynamicSamplingContext = rootSpan
+    ? getDynamicSamplingContextFromSpan(rootSpan)
+    : dsc
+      ? dsc
+      : clientToUse
+        ? getDynamicSamplingContextFromClient(traceId, clientToUse)
+        : undefined;
+
+  const baggage = dynamicSamplingContextToSentryBaggageHeader(dynamicSamplingContext);
+
+  const isValidSentryTraceHeader = TRACEPARENT_REGEXP.test(sentryTrace);
+  if (!isValidSentryTraceHeader) {
+    logger.warn('Invalid sentry-trace data. Returning empty "sentry-trace" value');
+  }
+
+  const validBaggage = isValidBaggageString(baggage);
+  if (!validBaggage) {
+    logger.warn('Invalid baggage data. Not returning "baggage" value');
+  }
+
+  return {
+    'sentry-trace': isValidSentryTraceHeader ? sentryTrace : '',
+    ...(validBaggage && { baggage }),
+  };
+}
+
+/**
+ * Tests string against baggage spec as defined in:
+ *
+ * - W3C Baggage grammar: https://www.w3.org/TR/baggage/#definition
+ * - RFC7230 token definition: https://datatracker.ietf.org/doc/html/rfc7230#section-3.2.6
+ *
+ * exported for testing
+ */
+export function isValidBaggageString(baggage?: string): boolean {
+  if (!baggage || !baggage.length) {
+    return false;
+  }
+  const keyRegex = "[-!#$%&'*+.^_`|~A-Za-z0-9]+";
+  const valueRegex = '[!#-+-./0-9:<=>?@A-Z\\[\\]a-z{-}]+';
+  const spaces = '\\s*';
+  // eslint-disable-next-line @sentry-internal/sdk/no-regexp-constructor -- RegExp for readability, no user input
+  const baggageRegex = new RegExp(
+    `^${keyRegex}${spaces}=${spaces}${valueRegex}(${spaces},${spaces}${keyRegex}${spaces}=${spaces}${valueRegex})*$`,
+  );
+  return baggageRegex.test(baggage);
+}