rewrite httpContext integration to use processSpan client hook

Lms24 · Lms24 · commit 776e302a6b8f · 2025-12-11T15:34:13.000+01:00
diff --git a/dev-packages/browser-integration-tests/suites/span-first/pageload/test.ts b/dev-packages/browser-integration-tests/suites/span-first/pageload/test.ts
@@ -106,6 +106,18 @@ sentryTest('sends a span v2 envelope for the pageload', async ({ getLocalTestUrl
         type: 'string',
         value: 'url',
       },
+      'sentry.idle_span_finish_reason': {
+        type: 'string',
+        value: 'idleTimeout',
+      },
+      'url.full': {
+        type: 'string',
+        value: 'http://sentry-test.io/index.html',
+      },
+      'http.request.header.user_agent': {
+        type: 'string',
+        value: expect.any(String),
+      },
     }),
     trace_id: expect.stringMatching(/^[a-f\d]{32}$/),
     span_id: expect.stringMatching(/^[a-f\d]{16}$/),
diff --git a/dev-packages/browser-integration-tests/suites/span-first/web-vitals/web-vitals-ttfb/init.js b/dev-packages/browser-integration-tests/suites/span-first/web-vitals/web-vitals-ttfb/init.js
@@ -0,0 +1,13 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  traceLifecycle: 'stream',
+  integrations: [Sentry.browserTracingIntegration(), Sentry.spanStreamingIntegration()],
+  tracePropagationTargets: ['http://sentry-test-site.example'],
+  tracesSampleRate: 1,
+  sendDefaultPii: true,
+  debug: true,
+});
diff --git a/dev-packages/browser-integration-tests/suites/span-first/web-vitals/web-vitals-ttfb/template.html b/dev-packages/browser-integration-tests/suites/span-first/web-vitals/web-vitals-ttfb/template.html
@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+  </head>
+  <body>
+    <div>Rendered</div>
+  </body>
+</html>
diff --git a/dev-packages/browser-integration-tests/suites/span-first/web-vitals/web-vitals-ttfb/test.ts b/dev-packages/browser-integration-tests/suites/span-first/web-vitals/web-vitals-ttfb/test.ts
@@ -0,0 +1,33 @@
+import { expect } from '@playwright/test';
+import { sentryTest } from '../../../../utils/fixtures';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { getSpanOp, waitForV2Spans } from '../../../../utils/spanFirstUtils';
+
+sentryTest('captures TTFB web vital', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
+  const pageloadSpansPromise = waitForV2Spans(page, spans => !!spans.find(span => getSpanOp(span) === 'pageload'));
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+  await page.goto(url);
+
+  const pageloadSpan = (await pageloadSpansPromise).find(span => getSpanOp(span) === 'pageload');
+
+  expect(pageloadSpan).toBeDefined();
+
+  // If responseStart === 0, ttfb is not reported
+  // This seems to happen somewhat randomly, so we just ignore this in that case
+  const responseStart = await page.evaluate("performance.getEntriesByType('navigation')[0].responseStart;");
+  if (responseStart !== 0) {
+    expect(pageloadSpan!.attributes?.['ui.web_vital.ttfb']).toEqual({
+      type: expect.stringMatching(/^double$/),
+      value: expect.any(Number),
+    });
+  }
+
+  expect(pageloadSpan!.attributes?.['ui.web_vital.ttfb.requestTime']).toEqual({
+    type: expect.stringMatching(/^integer|double$/),
+    value: expect.any(Number),
+  });
+});
diff --git a/packages/browser/src/integrations/httpcontext.ts b/packages/browser/src/integrations/httpcontext.ts
@@ -1,18 +1,47 @@
-import { defineIntegration } from '@sentry/core';
+import {
+  defineIntegration,
+  httpHeadersToSpanAttributes,
+  safeSetSpanAttributes,
+  SEMANTIC_ATTRIBUTE_URL_FULL,
+} from '@sentry/core';
 import { getHttpRequestData, WINDOW } from '../helpers';
 
 /**
  * Collects information about HTTP request headers and
  * attaches them to the event.
  */
 export const httpContextIntegration = defineIntegration(() => {
+  const inBrowserEnvironment = WINDOW.navigator || WINDOW.location || WINDOW.document;
+
   return {
     name: 'HttpContext',
-    // TODO (span-streaming): probably fine to omit this in favour of us globally
-    // already adding request context data but should double-check this
+    setup(client) {
+      if (!inBrowserEnvironment) {
+        return;
+      }
+
+      if (client.getOptions().traceLifecycle === 'stream') {
+        client.on('processSpan', (span, { readOnlySpan }) => {
+          if (readOnlySpan.is_segment) {
+            const { url, headers } = getHttpRequestData();
+
+            const attributeHeaders = httpHeadersToSpanAttributes(headers);
+
+            safeSetSpanAttributes(
+              span,
+              {
+                [SEMANTIC_ATTRIBUTE_URL_FULL]: url,
+                ...attributeHeaders,
+              },
+              readOnlySpan.attributes,
+            );
+          }
+        });
+      }
+    },
     preprocessEvent(event) {
       // if none of the information we want exists, don't bother
-      if (!WINDOW.navigator && !WINDOW.location && !WINDOW.document) {
+      if (!inBrowserEnvironment) {
         return;
       }
 
diff --git a/packages/core/src/client.ts b/packages/core/src/client.ts
@@ -31,7 +31,7 @@ import type { RequestEventData } from './types-hoist/request';
 import type { SdkMetadata } from './types-hoist/sdkmetadata';
 import type { Session, SessionAggregates } from './types-hoist/session';
 import type { SeverityLevel } from './types-hoist/severity';
-import type { Span, SpanAttributes, SpanContextData, SpanJSON } from './types-hoist/span';
+import type { Span, SpanAttributes, SpanContextData, SpanJSON, SpanV2JSON } from './types-hoist/span';
 import type { StartSpanOptions } from './types-hoist/startSpanOptions';
 import type { Transport, TransportMakeRequestResponse } from './types-hoist/transport';
 import { isV2BeforeSendSpanCallback } from './utils/beforeSendSpan';
@@ -621,6 +621,10 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
    * Register a callback for when the span is ready to be enqueued into the span buffer.
    */
   public on(hook: 'enqueueSpan', callback: (span: Span) => void): () => void;
+  /**
+   * Register a callback for when a span is processed, to add some attributes to the span.
+   */
+  public on(hook: 'processSpan', callback: (span: Span, hint: { readOnlySpan: SpanV2JSON }) => void): () => void;
 
   /**
    * Register a callback for when an idle span is allowed to auto-finish.
@@ -897,6 +901,8 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
   // Hooks reserved for Span-First span processing:
   /** Fire a hook after the `spanEnd` hook  */
   public emit(hook: 'afterSpanEnd', span: Span): void;
+  /** Fire a hook after a span is processed, to add some attributes to the span. */
+  public emit(hook: 'processSpan', span: Span, hint: { readOnlySpan: SpanV2JSON }): void;
   /** Fire a hook after the `segmentSpanEnd` hook is fired. */
   public emit(hook: 'afterSegmentSpanEnd', span: Span): void;
   /** Fire a hook after a span ready to be enqueued into the span buffer. */
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
@@ -90,6 +90,7 @@ export {
   showSpanDropWarning,
 } from './utils/spanUtils';
 export { captureSpan } from './spans/captureSpan';
+export { safeSetSpanAttributes } from './spans/spanFirstUtils';
 export { attributesFromObject } from './utils/attributes';
 export { _setSpanForScope as _INTERNAL_setSpanForScope } from './utils/spanOnScope';
 export { parseSampleRate } from './utils/parseSampleRate';
diff --git a/packages/core/src/spans/captureSpan.ts b/packages/core/src/spans/captureSpan.ts
@@ -1,4 +1,3 @@
-import { type RawAttributes, isAttributeObject } from '../attributes';
 import type { Client } from '../client';
 import { getClient, getGlobalScope } from '../currentScopes';
 import { DEBUG_BUILD } from '../debug-build';
@@ -16,10 +15,12 @@ import {
   SEMANTIC_ATTRIBUTE_USER_USERNAME,
 } from '../semanticAttributes';
 import { getCapturedScopesOnSpan } from '../tracing/utils';
+import type { SerializedAttributes } from '../types-hoist/attributes';
 import type { Span, SpanV2JSON } from '../types-hoist/span';
 import { mergeScopeData } from '../utils/applyScopeDataToEvent';
 import { debug } from '../utils/debug-logger';
 import { INTERNAL_getSegmentSpan, spanToV2JSON } from '../utils/spanUtils';
+import { safeSetSpanAttributes } from './spanFirstUtils';
 
 /**
  * Captures a span and returns it to the caller, to be enqueued for sending.
@@ -36,14 +37,19 @@ export function captureSpan(span: Span, client = getClient()): void {
   const { isolationScope: spanIsolationScope, scope: spanScope } = getCapturedScopesOnSpan(span);
   const finalScopeData = getFinalScopeData(spanIsolationScope, spanScope);
 
-  const originalAttributeKeys = Object.keys(serializedSegmentSpan.attributes ?? {});
+  const originalAttributes = serializedSegmentSpan.attributes ?? {};
 
-  applyCommonSpanAttributes(span, serializedSegmentSpan, client, finalScopeData, originalAttributeKeys);
+  applyCommonSpanAttributes(span, serializedSegmentSpan, client, finalScopeData, originalAttributes);
 
   if (span === segmentSpan) {
-    applyScopeToSegmentSpan(span, finalScopeData, originalAttributeKeys);
+    applyScopeToSegmentSpan(span, finalScopeData, originalAttributes);
   }
 
+  // Allow integrations to add additional data to span. Pass in a serialized
+  // span to avoid having to potentially serialize the span in every integration
+  // (for improved performance).
+  client.emit('processSpan', span, { readOnlySpan: spanToV2JSON(span) });
+
   // Wondering where we apply the beforeSendSpan callback?
   // We apply it directly before sending the span,
   // so whenever the buffer this span gets enqueued in is being flushed.
@@ -55,11 +61,15 @@ export function captureSpan(span: Span, client = getClient()): void {
   client.emit('enqueueSpan', span);
 }
 
-function applyScopeToSegmentSpan(segmentSpan: Span, scopeData: ScopeData, originalAttributeKeys: string[]): void {
+function applyScopeToSegmentSpan(
+  segmentSpan: Span,
+  scopeData: ScopeData,
+  originalAttributes: SerializedAttributes,
+): void {
   // TODO: Apply all scope data from auto instrumentation (contexts, request) to segment span
   const { attributes } = scopeData;
   if (attributes) {
-    setAttributesIfNotPresent(segmentSpan, originalAttributeKeys, attributes);
+    safeSetSpanAttributes(segmentSpan, attributes, originalAttributes);
   }
 }
 
@@ -68,28 +78,32 @@ function applyCommonSpanAttributes(
   serializedSegmentSpan: SpanV2JSON,
   client: Client,
   scopeData: ScopeData,
-  originalAttributeKeys: string[],
+  originalAttributes: SerializedAttributes,
 ): void {
   const sdk = client.getSdkMetadata();
   const { release, environment, sendDefaultPii } = client.getOptions();
 
   // avoid overwriting any previously set attributes (from users or potentially our SDK instrumentation)
-  setAttributesIfNotPresent(span, originalAttributeKeys, {
-    [SEMANTIC_ATTRIBUTE_SENTRY_RELEASE]: release,
-    [SEMANTIC_ATTRIBUTE_SENTRY_ENVIRONMENT]: environment,
-    [SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_NAME]: serializedSegmentSpan.name,
-    [SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_ID]: serializedSegmentSpan.span_id,
-    [SEMANTIC_ATTRIBUTE_SENTRY_SDK_NAME]: sdk?.sdk?.name,
-    [SEMANTIC_ATTRIBUTE_SENTRY_SDK_VERSION]: sdk?.sdk?.version,
-    ...(sendDefaultPii
-      ? {
-          [SEMANTIC_ATTRIBUTE_USER_ID]: scopeData.user?.id,
-          [SEMANTIC_ATTRIBUTE_USER_EMAIL]: scopeData.user?.email,
-          [SEMANTIC_ATTRIBUTE_USER_IP_ADDRESS]: scopeData.user?.ip_address ?? undefined,
-          [SEMANTIC_ATTRIBUTE_USER_USERNAME]: scopeData.user?.username,
-        }
-      : {}),
-  });
+  safeSetSpanAttributes(
+    span,
+    {
+      [SEMANTIC_ATTRIBUTE_SENTRY_RELEASE]: release,
+      [SEMANTIC_ATTRIBUTE_SENTRY_ENVIRONMENT]: environment,
+      [SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_NAME]: serializedSegmentSpan.name,
+      [SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_ID]: serializedSegmentSpan.span_id,
+      [SEMANTIC_ATTRIBUTE_SENTRY_SDK_NAME]: sdk?.sdk?.name,
+      [SEMANTIC_ATTRIBUTE_SENTRY_SDK_VERSION]: sdk?.sdk?.version,
+      ...(sendDefaultPii
+        ? {
+            [SEMANTIC_ATTRIBUTE_USER_ID]: scopeData.user?.id,
+            [SEMANTIC_ATTRIBUTE_USER_EMAIL]: scopeData.user?.email,
+            [SEMANTIC_ATTRIBUTE_USER_IP_ADDRESS]: scopeData.user?.ip_address ?? undefined,
+            [SEMANTIC_ATTRIBUTE_USER_USERNAME]: scopeData.user?.username,
+          }
+        : {}),
+    },
+    originalAttributes,
+  );
 }
 
 // TODO: Extract this to a helper in core. It's used in multiple places.
@@ -103,35 +117,3 @@ function getFinalScopeData(isolationScope: Scope | undefined, scope: Scope | und
   }
   return finalScopeData;
 }
-
-function setAttributesIfNotPresent(
-  span: Span,
-  originalAttributeKeys: string[],
-  newAttributes: RawAttributes<Record<string, unknown>>,
-): void {
-  Object.keys(newAttributes).forEach(key => {
-    if (!originalAttributeKeys.includes(key)) {
-      setAttributeOnSpanWithMaybeUnit(span, key, newAttributes[key]);
-    }
-  });
-}
-
-function setAttributeOnSpanWithMaybeUnit(span: Span, attributeKey: string, attributeValue: unknown): void {
-  if (isAttributeObject(attributeValue)) {
-    const { value, unit } = attributeValue;
-
-    if (isSupportedAttributeType(value)) {
-      span.setAttribute(attributeKey, value);
-    }
-
-    if (unit) {
-      span.setAttribute(`${attributeKey}.unit`, unit);
-    }
-  } else if (isSupportedAttributeType(attributeValue)) {
-    span.setAttribute(attributeKey, attributeValue);
-  }
-}
-
-function isSupportedAttributeType(value: unknown): value is Parameters<Span['setAttribute']>[1] {
-  return ['string', 'number', 'boolean'].includes(typeof value) || Array.isArray(value);
-}
diff --git a/packages/core/src/spans/spanFirstUtils.ts b/packages/core/src/spans/spanFirstUtils.ts
@@ -0,0 +1,39 @@
+import type { RawAttributes } from '../attributes';
+import { isAttributeObject } from '../attributes';
+import type { SerializedAttributes } from '../types-hoist/attributes';
+import type { Span } from '../types-hoist/span';
+
+/**
+ * Only set a span attribute if it is not already set.
+ */
+export function safeSetSpanAttributes(
+  span: Span,
+  newAttributes: RawAttributes<Record<string, unknown>>,
+  originalAttributeKeys: SerializedAttributes | undefined,
+): void {
+  Object.keys(newAttributes).forEach(key => {
+    if (!originalAttributeKeys?.[key]) {
+      setAttributeOnSpanWithMaybeUnit(span, key, newAttributes[key]);
+    }
+  });
+}
+
+function setAttributeOnSpanWithMaybeUnit(span: Span, attributeKey: string, attributeValue: unknown): void {
+  if (isAttributeObject(attributeValue)) {
+    const { value, unit } = attributeValue;
+
+    if (isSupportedAttributeType(value)) {
+      span.setAttribute(attributeKey, value);
+    }
+
+    if (unit) {
+      span.setAttribute(`${attributeKey}.unit`, unit);
+    }
+  } else if (isSupportedAttributeType(attributeValue)) {
+    span.setAttribute(attributeKey, attributeValue);
+  }
+}
+
+function isSupportedAttributeType(value: unknown): value is Parameters<Span['setAttribute']>[1] {
+  return ['string', 'number', 'boolean'].includes(typeof value) || Array.isArray(value);
+}
diff --git a/packages/core/src/utils/spanUtils.ts b/packages/core/src/utils/spanUtils.ts
@@ -314,11 +314,7 @@ export function getStatusMessage(status: SpanStatus | undefined): string | undef
  * Convert the various statuses to the ones expected by Sentry ('ok' is default)
  */
 export function getV2StatusMessage(status: SpanStatus | undefined): 'ok' | 'error' {
-  return !status ||
-    status.code === SPAN_STATUS_UNSET ||
-    (status.code === SPAN_STATUS_ERROR && status.message === 'unknown_error')
-    ? 'ok'
-    : 'error';
+  return !status || status.code === SPAN_STATUS_OK || status.code === SPAN_STATUS_UNSET ? 'ok' : 'error';
 }
 
 /**
