add headers in nextjs and node-core

s1gr1d · s1gr1d · commit 1db7f939b125 · 2025-09-01T12:14:54.000+02:00
diff --git a/packages/nextjs/src/common/pages-router-instrumentation/wrapApiHandlerWithSentry.ts b/packages/nextjs/src/common/pages-router-instrumentation/wrapApiHandlerWithSentry.ts
@@ -15,6 +15,7 @@ import {
 } from '@sentry/core';
 import type { NextApiRequest } from 'next';
 import type { AugmentedNextApiResponse, NextApiHandler } from '../types';
+import { addHeadersAsAttributes } from '../utils/headersToAttributes';
 import { flushSafelyWithTimeout } from '../utils/responseEnd';
 import { dropNextjsRootContext, escapeNextjsTracing } from '../utils/tracingUtils';
 
@@ -87,6 +88,7 @@ export function wrapApiHandlerWithSentry(apiHandler: NextApiHandler, parameteriz
                   attributes: {
                     [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'route',
                     [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.http.nextjs',
+                    ...addHeadersAsAttributes(normalizedRequest.headers || {}),
                   },
                 },
                 async span => {
diff --git a/packages/nextjs/src/common/utils/headersToAttributes.ts b/packages/nextjs/src/common/utils/headersToAttributes.ts
@@ -0,0 +1,30 @@
+import type { Span, WebFetchHeaders } from '@sentry/core';
+import { getClient, httpHeadersToSpanAttributes, winterCGHeadersToDict } from '@sentry/core';
+
+/**
+ * Extracts HTTP request headers as span attributes and optionally applies them to a span.
+ */
+export function addHeadersAsAttributes(
+  headers: WebFetchHeaders | Headers | Record<string, string | string[] | undefined> | undefined,
+  span?: Span,
+): Record<string, string[]> {
+  if (!headers) {
+    return {};
+  }
+
+  const client = getClient();
+  const sendDefaultPii = client?.getOptions().sendDefaultPii ?? false;
+
+  const headersDict: Record<string, string | string[] | undefined> =
+    headers instanceof Headers || (typeof headers === 'object' && 'get' in headers)
+      ? winterCGHeadersToDict(headers as Headers)
+      : headers;
+
+  const headerAttributes = httpHeadersToSpanAttributes(headersDict, sendDefaultPii);
+
+  if (span) {
+    span.setAttributes(headerAttributes);
+  }
+
+  return headerAttributes;
+}
diff --git a/packages/nextjs/src/common/wrapGenerationFunctionWithSentry.ts b/packages/nextjs/src/common/wrapGenerationFunctionWithSentry.ts
@@ -22,6 +22,7 @@ import {
 import type { GenerationFunctionContext } from '../common/types';
 import { isNotFoundNavigationError, isRedirectNavigationError } from './nextNavigationErrorUtils';
 import { TRANSACTION_ATTR_SENTRY_TRACE_BACKFILL } from './span-attributes-with-logic-attached';
+import { addHeadersAsAttributes } from './utils/headersToAttributes';
 import { commonObjectToIsolationScope, commonObjectToPropagationContext } from './utils/tracingUtils';
 import { getSanitizedRequestUrl } from './utils/urls';
 import { maybeExtractSynchronousParamsAndSearchParams } from './utils/wrapperUtils';
@@ -63,6 +64,11 @@ export function wrapGenerationFunctionWithSentry<F extends (...args: any[]) => a
 
       const headersDict = headers ? winterCGHeadersToDict(headers) : undefined;
 
+      if (activeSpan) {
+        const rootSpan = getRootSpan(activeSpan);
+        addHeadersAsAttributes(headers, rootSpan);
+      }
+
       let data: Record<string, unknown> | undefined = undefined;
       if (getClient()?.getOptions().sendDefaultPii) {
         const props: unknown = args[0];
diff --git a/packages/nextjs/src/common/wrapMiddlewareWithSentry.ts b/packages/nextjs/src/common/wrapMiddlewareWithSentry.ts
@@ -13,6 +13,7 @@ import {
   winterCGRequestToRequestData,
   withIsolationScope,
 } from '@sentry/core';
+import { addHeadersAsAttributes } from '../common/utils/headersToAttributes';
 import { flushSafelyWithTimeout } from '../common/utils/responseEnd';
 import type { EdgeRouteHandler } from '../edge/types';
 
@@ -59,13 +60,16 @@ export function wrapMiddlewareWithSentry<H extends EdgeRouteHandler>(
 
         let spanName: string;
         let spanSource: TransactionSource;
+        let headerAttributes: Record<string, string[]> = {};
 
         if (req instanceof Request) {
           isolationScope.setSDKProcessingMetadata({
             normalizedRequest: winterCGRequestToRequestData(req),
           });
           spanName = `middleware ${req.method} ${new URL(req.url).pathname}`;
           spanSource = 'url';
+
+          headerAttributes = addHeadersAsAttributes(req.headers);
         } else {
           spanName = 'middleware';
           spanSource = 'component';
@@ -84,6 +88,7 @@ export function wrapMiddlewareWithSentry<H extends EdgeRouteHandler>(
           const rootSpan = getRootSpan(activeSpan);
           if (rootSpan) {
             setCapturedScopesOnSpan(rootSpan, currentScope, isolationScope);
+            rootSpan.setAttributes(headerAttributes);
           }
         }
 
@@ -94,6 +99,7 @@ export function wrapMiddlewareWithSentry<H extends EdgeRouteHandler>(
             attributes: {
               [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: spanSource,
               [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.function.nextjs.wrapMiddlewareWithSentry',
+              ...headerAttributes,
             },
           },
           () => {
diff --git a/packages/nextjs/src/common/wrapRouteHandlerWithSentry.ts b/packages/nextjs/src/common/wrapRouteHandlerWithSentry.ts
@@ -19,6 +19,7 @@ import {
 } from '@sentry/core';
 import { isNotFoundNavigationError, isRedirectNavigationError } from './nextNavigationErrorUtils';
 import type { RouteHandlerContext } from './types';
+import { addHeadersAsAttributes } from './utils/headersToAttributes';
 import { flushSafelyWithTimeout } from './utils/responseEnd';
 import { commonObjectToIsolationScope } from './utils/tracingUtils';
 
@@ -39,6 +40,10 @@ export function wrapRouteHandlerWithSentry<F extends (...args: any[]) => any>(
       const activeSpan = getActiveSpan();
       const rootSpan = activeSpan ? getRootSpan(activeSpan) : undefined;
 
+      if (rootSpan && process.env.NEXT_RUNTIME !== 'edge') {
+        addHeadersAsAttributes(headers, rootSpan);
+      }
+
       let edgeRuntimeIsolationScopeOverride: Scope | undefined;
       if (rootSpan && process.env.NEXT_RUNTIME === 'edge') {
         const isolationScope = commonObjectToIsolationScope(headers);
@@ -50,6 +55,7 @@ export function wrapRouteHandlerWithSentry<F extends (...args: any[]) => any>(
         rootSpan.updateName(`${method} ${parameterizedRoute}`);
         rootSpan.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, 'route');
         rootSpan.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_OP, 'http.server');
+        addHeadersAsAttributes(headers, rootSpan);
       }
 
       return withIsolationScope(
diff --git a/packages/nextjs/src/common/wrapServerComponentWithSentry.ts b/packages/nextjs/src/common/wrapServerComponentWithSentry.ts
@@ -24,6 +24,7 @@ import { isNotFoundNavigationError, isRedirectNavigationError } from '../common/
 import type { ServerComponentContext } from '../common/types';
 import { flushSafelyWithTimeout } from '../common/utils/responseEnd';
 import { TRANSACTION_ATTR_SENTRY_TRACE_BACKFILL } from './span-attributes-with-logic-attached';
+import { addHeadersAsAttributes } from './utils/headersToAttributes';
 import { commonObjectToIsolationScope, commonObjectToPropagationContext } from './utils/tracingUtils';
 import { getSanitizedRequestUrl } from './utils/urls';
 import { maybeExtractSynchronousParamsAndSearchParams } from './utils/wrapperUtils';
@@ -61,6 +62,11 @@ export function wrapServerComponentWithSentry<F extends (...args: any[]) => any>
 
       const headersDict = context.headers ? winterCGHeadersToDict(context.headers) : undefined;
 
+      if (activeSpan) {
+        const rootSpan = getRootSpan(activeSpan);
+        addHeadersAsAttributes(context.headers, rootSpan);
+      }
+
       let params: Record<string, string> | undefined = undefined;
 
       if (getClient()?.getOptions().sendDefaultPii) {
diff --git a/packages/nextjs/src/edge/wrapApiHandlerWithSentry.ts b/packages/nextjs/src/edge/wrapApiHandlerWithSentry.ts
@@ -13,6 +13,7 @@ import {
   winterCGRequestToRequestData,
   withIsolationScope,
 } from '@sentry/core';
+import { addHeadersAsAttributes } from '../common/utils/headersToAttributes';
 import { flushSafelyWithTimeout } from '../common/utils/responseEnd';
 import type { EdgeRouteHandler } from './types';
 
@@ -31,11 +32,15 @@ export function wrapApiHandlerWithSentry<H extends EdgeRouteHandler>(
         const req: unknown = args[0];
         const currentScope = getCurrentScope();
 
+        let headerAttributes: Record<string, string[]> = {};
+
         if (req instanceof Request) {
           isolationScope.setSDKProcessingMetadata({
             normalizedRequest: winterCGRequestToRequestData(req),
           });
           currentScope.setTransactionName(`${req.method} ${parameterizedRoute}`);
+
+          headerAttributes = addHeadersAsAttributes(req.headers);
         } else {
           currentScope.setTransactionName(`handler (${parameterizedRoute})`);
         }
@@ -58,6 +63,7 @@ export function wrapApiHandlerWithSentry<H extends EdgeRouteHandler>(
             rootSpan.setAttributes({
               [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'http.server',
               [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'route',
+              ...headerAttributes,
             });
             setCapturedScopesOnSpan(rootSpan, currentScope, isolationScope);
           }
@@ -74,6 +80,7 @@ export function wrapApiHandlerWithSentry<H extends EdgeRouteHandler>(
             attributes: {
               [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'route',
               [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.function.nextjs.wrapApiHandlerWithSentry',
+              ...headerAttributes,
             },
           },
           () => {
diff --git a/packages/nextjs/src/server/index.ts b/packages/nextjs/src/server/index.ts
@@ -201,15 +201,6 @@ export function init(options: NodeOptions): NodeClient | undefined {
       }
 
       setCapturedScopesOnSpan(span, scope, isolationScope);
-
-      const sendDefaultPii = opts.sendDefaultPii ?? false;
-      const sdkProcessingMetadata = isolationScope.getScopeData().sdkProcessingMetadata;
-      const normalizedRequest = sdkProcessingMetadata?.normalizedRequest;
-
-      if (normalizedRequest?.headers) {
-        const headerAttributes = httpHeadersToSpanAttributes(normalizedRequest.headers, sendDefaultPii);
-        span.setAttributes(headerAttributes);
-      }
     }
   });
 
diff --git a/packages/node-core/src/integrations/http/incoming-requests.ts b/packages/node-core/src/integrations/http/incoming-requests.ts
@@ -7,6 +7,7 @@ import {
   getClient,
   getCurrentScope,
   getIsolationScope,
+  httpHeadersToSpanAttributes,
   httpRequestToRequestData,
   stripUrlQueryAndFragment,
   withIsolationScope,
@@ -70,8 +71,13 @@ export function instrumentServer(
         patchRequestToCaptureBody(request, isolationScope, maxIncomingRequestBodySize);
       }
 
+      // Extract HTTP request headers as span attributes
+      const client = getClient();
+      const sendDefaultPii = client?.getOptions().sendDefaultPii ?? false;
+      const httpHeaderAttributes = httpHeadersToSpanAttributes(normalizedRequest.headers || {}, sendDefaultPii);
+
       // Update the isolation scope, isolate this request
-      isolationScope.setSDKProcessingMetadata({ normalizedRequest, ipAddress });
+      isolationScope.setSDKProcessingMetadata({ normalizedRequest, ipAddress, httpHeaderAttributes });
 
       // attempt to update the scope's `transactionName` based on the request URL
       // Ideally, framework instrumentations coming after the HttpInstrumentation
diff --git a/packages/opentelemetry/src/spanProcessor.ts b/packages/opentelemetry/src/spanProcessor.ts
@@ -9,6 +9,7 @@ import {
   logSpanEnd,
   logSpanStart,
   setCapturedScopesOnSpan,
+  spanToJSON,
 } from '@sentry/core';
 import { SEMANTIC_ATTRIBUTE_SENTRY_PARENT_IS_REMOTE } from './semanticAttributes';
 import { SentrySpanExporter } from './spanExporter';
@@ -47,6 +48,20 @@ function onSpanStart(span: Span, parentContext: Context): void {
 
   logSpanStart(span);
 
+  // Add HTTP request headers as span attributes for HTTP server spans
+  if (scopes?.isolationScope) {
+    const spanData = spanToJSON(span);
+    // Check if this is an HTTP server span
+    if (spanData.op === 'http.server' || (spanData.data && 'http.method' in spanData.data)) {
+      const sdkProcessingMetadata = scopes.isolationScope.getScopeData().sdkProcessingMetadata;
+      const httpHeaderAttributes = sdkProcessingMetadata?.httpHeaderAttributes as Record<string, string[]>;
+
+      if (httpHeaderAttributes && typeof httpHeaderAttributes === 'object') {
+        span.setAttributes(httpHeaderAttributes);
+      }
+    }
+  }
+
   const client = getClient();
   client?.emit('spanStart', span);
 }

Original file line number	Diff line number	Diff line change
`@@ -201,15 +201,6 @@ export function init(options: NodeOptions): NodeClient \| undefined {`
`201`	`201`	`}`
`202`	`202`
`203`	`203`	`setCapturedScopesOnSpan(span, scope, isolationScope);`
`204`		`-`
`205`		`- const sendDefaultPii = opts.sendDefaultPii ?? false;`
`206`		`- const sdkProcessingMetadata = isolationScope.getScopeData().sdkProcessingMetadata;`
`207`		`- const normalizedRequest = sdkProcessingMetadata?.normalizedRequest;`
`208`		`-`
`209`		`- if (normalizedRequest?.headers) {`
`210`		`- const headerAttributes = httpHeadersToSpanAttributes(normalizedRequest.headers, sendDefaultPii);`
`211`		`- span.setAttributes(headerAttributes);`
`212`		`- }`
`213`	`204`	`}`
`214`	`205`	`});`
`215`	`206`