feat(core): Emit sentry.sdk.integrations on segment spans in span streaming

In the classic (non-streaming) pipeline, SDK integrations ride on the
transaction event wrapper via `event.sdk.integrations`. The span
streaming pipeline emits segment spans directly as span envelope items
with no transaction wrapper, so that metadata never reaches ingest.

Add `sentry.sdk.integrations` as a native array attribute on segment
spans (matching the wire contract Relay expects: `type: 'array'`).
Relies on the homogeneous-primitive-array serializer support.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: nicohrubec

packages/core/src/semanticAttributes.ts

@@ -52,6 +52,8 @@ export const SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_ID = 'sentry.segment.id';
 export const SEMANTIC_ATTRIBUTE_SENTRY_SDK_NAME = 'sentry.sdk.name';
 /** The version of the Sentry SDK */
 export const SEMANTIC_ATTRIBUTE_SENTRY_SDK_VERSION = 'sentry.sdk.version';
+/** The list of integrations enabled in the Sentry SDK (e.g., ["InboundFilters", "BrowserTracing"]) */
+export const SEMANTIC_ATTRIBUTE_SENTRY_SDK_INTEGRATIONS = 'sentry.sdk.integrations';
 
 /** The user ID (gated by sendDefaultPii) */
 export const SEMANTIC_ATTRIBUTE_USER_ID = 'user.id';

packages/core/src/tracing/spans/captureSpan.ts

@@ -4,6 +4,7 @@ import type { ScopeData } from '../../scope';
 import {
   SEMANTIC_ATTRIBUTE_SENTRY_ENVIRONMENT,
   SEMANTIC_ATTRIBUTE_SENTRY_RELEASE,
+  SEMANTIC_ATTRIBUTE_SENTRY_SDK_INTEGRATIONS,
   SEMANTIC_ATTRIBUTE_SENTRY_SDK_NAME,
   SEMANTIC_ATTRIBUTE_SENTRY_SDK_VERSION,
   SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_ID,
@@ -53,6 +54,7 @@ export function captureSpan(span: Span, client: Client): SerializedStreamedSpanW
 
   if (spanJSON.is_segment) {
     applyScopeToSegmentSpan(spanJSON, finalScopeData);
+    applySdkMetadataToSegmentSpan(spanJSON, client);
     // Allow hook subscribers to mutate the segment span JSON
     // This also invokes the `processSegmentSpan` hook of all integrations
     client.emit('processSegmentSpan', spanJSON);
@@ -90,6 +92,15 @@ function applyScopeToSegmentSpan(_segmentSpanJSON: StreamedSpanJSON, _scopeData:
   // This will follow in a separate PR
 }
 
+function applySdkMetadataToSegmentSpan(segmentSpanJSON: StreamedSpanJSON, client: Client): void {
+  const integrationNames = client.getOptions().integrations.map(i => i.name);
+  if (!integrationNames.length) return;
+
+  safeSetSpanJSONAttributes(segmentSpanJSON, {
+    [SEMANTIC_ATTRIBUTE_SENTRY_SDK_INTEGRATIONS]: integrationNames,
+  });
+}
+
 function applyCommonSpanAttributes(
   spanJSON: StreamedSpanJSON,
   serializedSegmentSpan: StreamedSpanJSON,

packages/core/test/lib/tracing/spans/captureSpan.test.ts

@@ -7,6 +7,7 @@ import {
   SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
   SEMANTIC_ATTRIBUTE_SENTRY_RELEASE,
   SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE,
+  SEMANTIC_ATTRIBUTE_SENTRY_SDK_INTEGRATIONS,
   SEMANTIC_ATTRIBUTE_SENTRY_SDK_NAME,
   SEMANTIC_ATTRIBUTE_SENTRY_SDK_VERSION,
   SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_ID,
@@ -291,6 +292,86 @@ describe('captureSpan', () => {
     });
   });
 
+  it('adds sentry.sdk.integrations to segment spans as an array attribute', () => {
+    const client = new TestClient(
+      getDefaultTestClientOptions({
+        dsn: 'https://dsn@ingest.f00.f00/1',
+        tracesSampleRate: 1,
+        release: '1.0.0',
+        environment: 'staging',
+        integrations: [
+          { name: 'InboundFilters', setupOnce: () => {} },
+          { name: 'BrowserTracing', setupOnce: () => {} },
+        ],
+        _metadata: {
+          sdk: {
+            name: 'sentry.javascript.browser',
+            version: '9.0.0',
+          },
+        },
+      }),
+    );
+
+    const span = withScope(scope => {
+      scope.setClient(client);
+      const span = startInactiveSpan({ name: 'my-span', attributes: { 'sentry.op': 'http.client' } });
+      span.end();
+      return span;
+    });
+
+    expect(captureSpan(span, client)).toStrictEqual({
+      span_id: expect.stringMatching(/^[\da-f]{16}$/),
+      trace_id: expect.stringMatching(/^[\da-f]{32}$/),
+      parent_span_id: undefined,
+      links: undefined,
+      start_timestamp: expect.any(Number),
+      name: 'my-span',
+      end_timestamp: expect.any(Number),
+      status: 'ok',
+      is_segment: true,
+      attributes: {
+        [SEMANTIC_ATTRIBUTE_SENTRY_OP]: { type: 'string', value: 'http.client' },
+        [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: { type: 'string', value: 'manual' },
+        [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: { type: 'integer', value: 1 },
+        [SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_NAME]: { value: 'my-span', type: 'string' },
+        [SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_ID]: { value: span.spanContext().spanId, type: 'string' },
+        'sentry.span.source': { value: 'custom', type: 'string' },
+        [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: { value: 'custom', type: 'string' },
+        [SEMANTIC_ATTRIBUTE_SENTRY_RELEASE]: { value: '1.0.0', type: 'string' },
+        [SEMANTIC_ATTRIBUTE_SENTRY_ENVIRONMENT]: { value: 'staging', type: 'string' },
+        [SEMANTIC_ATTRIBUTE_SENTRY_SDK_NAME]: { value: 'sentry.javascript.browser', type: 'string' },
+        [SEMANTIC_ATTRIBUTE_SENTRY_SDK_VERSION]: { value: '9.0.0', type: 'string' },
+        [SEMANTIC_ATTRIBUTE_SENTRY_SDK_INTEGRATIONS]: {
+          type: 'array',
+          value: ['InboundFilters', 'BrowserTracing'],
+        },
+      },
+      _segmentSpan: span,
+    });
+  });
+
+  it('does not add sentry.sdk.integrations to non-segment child spans', () => {
+    const client = new TestClient(
+      getDefaultTestClientOptions({
+        dsn: 'https://dsn@ingest.f00.f00/1',
+        tracesSampleRate: 1,
+        integrations: [{ name: 'InboundFilters', setupOnce: () => {} }],
+      }),
+    );
+
+    const serializedChild = withScope(scope => {
+      scope.setClient(client);
+      return startSpan({ name: 'segment' }, () => {
+        const childSpan = startInactiveSpan({ name: 'child' });
+        childSpan.end();
+        return captureSpan(childSpan, client);
+      });
+    });
+
+    expect(serializedChild.is_segment).toBe(false);
+    expect(serializedChild.attributes?.[SEMANTIC_ATTRIBUTE_SENTRY_SDK_INTEGRATIONS]).toBeUndefined();
+  });
+
   describe('client hooks', () => {
     it('calls processSpan and processSegmentSpan hooks for a segment span', () => {
       const client = new TestClient(