implement

Author: nicohrubec

packages/core/src/semanticAttributes.ts

@@ -52,6 +52,10 @@ 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 list of SDK packages loaded by the application (e.g., ["npm:@sentry/browser@9.0.0"]) */
+export const SEMANTIC_ATTRIBUTE_SENTRY_SDK_PACKAGES = 'sentry.sdk.packages';
 
 /** The user ID (gated by sendDefaultPii) */
 export const SEMANTIC_ATTRIBUTE_USER_ID = 'user.id';

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

@@ -4,7 +4,9 @@ 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_PACKAGES,
   SEMANTIC_ATTRIBUTE_SENTRY_SDK_VERSION,
   SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_ID,
   SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_NAME,
@@ -53,6 +55,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 +93,18 @@ 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);
+  const packages = client.getSdkMetadata()?.sdk?.packages?.map(p => `${p.name}@${p.version}`);
+
+  safeSetSpanJSONAttributes(segmentSpanJSON, {
+    [SEMANTIC_ATTRIBUTE_SENTRY_SDK_INTEGRATIONS]: integrationNames.length
+      ? JSON.stringify(integrationNames)
+      : undefined,
+    [SEMANTIC_ATTRIBUTE_SENTRY_SDK_PACKAGES]: packages?.length ? JSON.stringify(packages) : undefined,
+  });
+}
+
 function applyCommonSpanAttributes(
   spanJSON: StreamedSpanJSON,
   serializedSegmentSpan: StreamedSpanJSON,

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

@@ -7,7 +7,9 @@ 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_PACKAGES,
   SEMANTIC_ATTRIBUTE_SENTRY_SDK_VERSION,
   SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_ID,
   SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_NAME,
@@ -291,6 +293,102 @@ describe('captureSpan', () => {
     });
   });
 
+  it('adds sentry.sdk.integrations and sentry.sdk.packages to segment spans as JSON-stringified strings', () => {
+    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',
+            packages: [
+              { name: 'npm:@sentry/browser', version: '9.0.0' },
+              { name: 'npm:@sentry/core', 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: 'string',
+          value: '["InboundFilters","BrowserTracing"]',
+        },
+        [SEMANTIC_ATTRIBUTE_SENTRY_SDK_PACKAGES]: {
+          type: 'string',
+          value: '["npm:@sentry/browser@9.0.0","npm:@sentry/core@9.0.0"]',
+        },
+      },
+      _segmentSpan: span,
+    });
+  });
+
+  it('does not add sentry.sdk.integrations or sentry.sdk.packages to non-segment child spans', () => {
+    const client = new TestClient(
+      getDefaultTestClientOptions({
+        dsn: 'https://dsn@ingest.f00.f00/1',
+        tracesSampleRate: 1,
+        integrations: [{ name: 'InboundFilters', setupOnce: () => {} }],
+        _metadata: {
+          sdk: {
+            name: 'sentry.javascript.browser',
+            version: '9.0.0',
+            packages: [{ name: 'npm:@sentry/browser', version: '9.0.0' }],
+          },
+        },
+      }),
+    );
+
+    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();
+    expect(serializedChild.attributes?.[SEMANTIC_ATTRIBUTE_SENTRY_SDK_PACKAGES]).toBeUndefined();
+  });
+
   describe('client hooks', () => {
     it('calls processSpan and processSegmentSpan hooks for a segment span', () => {
       const client = new TestClient(