add trace envelope header

Author: Lms24

dev-packages/browser-integration-tests/suites/public-api/startSpan/standalone/segment-false/subject.js

@@ -1 +1,4 @@
-Sentry.startSpan({ name: 'standalone_segment_span', experimental: { standalone: true, segment: false } }, () => {});
+Sentry.startSpan(
+  { name: 'standalone_none_segment_span', experimental: { standalone: true, segment: false } },
+  () => {},
+);

dev-packages/browser-integration-tests/suites/public-api/startSpan/standalone/segment-false/test.ts

@@ -16,14 +16,22 @@ sentryTest('sends a span envelope with is_segment: false', async ({ getLocalTest
   const url = await getLocalTestPath({ testDir: __dirname });
   const spanEnvelope = await getFirstSentryEnvelopeRequest<SpanEnvelope>(page, url, properFullEnvelopeRequestParser);
 
-  const headers = spanEnvelope[0];
+  const envelopeHeaders = spanEnvelope[0];
   const item = spanEnvelope[1][0];
 
   const itemHeader = item[0];
   const spanJson = item[1];
 
-  expect(headers).toEqual({
+  expect(envelopeHeaders).toEqual({
     sent_at: expect.any(String),
+    trace: {
+      environment: 'production',
+      public_key: 'public',
+      sample_rate: '1',
+      sampled: 'true',
+      trace_id: spanJson.trace_id,
+      transaction: 'standalone_none_segment_span',
+    },
   });
 
   expect(itemHeader).toEqual({
@@ -36,7 +44,7 @@ sentryTest('sends a span envelope with is_segment: false', async ({ getLocalTest
       'sentry.sample_rate': 1,
       'sentry.source': 'custom',
     },
-    description: 'standalone_segment_span',
+    description: 'standalone_none_segment_span',
     origin: 'manual',
     span_id: expect.stringMatching(/^[0-9a-f]{16}$/),
     start_timestamp: expect.any(Number),

dev-packages/browser-integration-tests/suites/public-api/startSpan/standalone/segment-true/test.ts

@@ -16,14 +16,22 @@ sentryTest('sends a segment span envelope', async ({ getLocalTestPath, page }) =
   const url = await getLocalTestPath({ testDir: __dirname });
   const spanEnvelope = await getFirstSentryEnvelopeRequest<SpanEnvelope>(page, url, properFullEnvelopeRequestParser);
 
-  const headers = spanEnvelope[0];
+  const envelopeHeaders = spanEnvelope[0];
   const item = spanEnvelope[1][0];
 
   const itemHeader = item[0];
   const spanJson = item[1];
 
-  expect(headers).toEqual({
+  expect(envelopeHeaders).toEqual({
     sent_at: expect.any(String),
+    trace: {
+      environment: 'production',
+      public_key: 'public',
+      sample_rate: '1',
+      sampled: 'true',
+      trace_id: spanJson.trace_id,
+      transaction: 'standalone_segment_span',
+    },
   });
 
   expect(itemHeader).toEqual({

dev-packages/browser-integration-tests/suites/public-api/startSpan/standalone/segment-undefined/subject.js

@@ -1 +1 @@
-Sentry.startSpan({ name: 'standalone_segment_span', experimental: { standalone: true } }, () => {});
+Sentry.startSpan({ name: 'standalone_span', experimental: { standalone: true } }, () => {});

dev-packages/browser-integration-tests/suites/public-api/startSpan/standalone/segment-undefined/test.ts

@@ -16,14 +16,22 @@ sentryTest('sends a segment-less span envelope', async ({ getLocalTestPath, page
   const url = await getLocalTestPath({ testDir: __dirname });
   const spanEnvelope = await getFirstSentryEnvelopeRequest<SpanEnvelope>(page, url, properFullEnvelopeRequestParser);
 
-  const headers = spanEnvelope[0];
+  const envelopeHeaders = spanEnvelope[0];
   const item = spanEnvelope[1][0];
 
   const itemHeader = item[0];
   const spanJson = item[1];
 
-  expect(headers).toEqual({
+  expect(envelopeHeaders).toEqual({
     sent_at: expect.any(String),
+    trace: {
+      environment: 'production',
+      public_key: 'public',
+      sample_rate: '1',
+      sampled: 'true',
+      trace_id: spanJson.trace_id,
+      transaction: 'standalone_span',
+    },
   });
 
   expect(itemHeader).toEqual({
@@ -36,7 +44,7 @@ sentryTest('sends a segment-less span envelope', async ({ getLocalTestPath, page
       'sentry.sample_rate': 1,
       'sentry.source': 'custom',
     },
-    description: 'standalone_segment_span',
+    description: 'standalone_span',
     origin: 'manual',
     span_id: expect.stringMatching(/^[0-9a-f]{16}$/),
     start_timestamp: expect.any(Number),

packages/core/src/envelope.ts

@@ -2,6 +2,7 @@ import type {
   Attachment,
   AttachmentItem,
   DsnComponents,
+  DynamicSamplingContext,
   Event,
   EventEnvelope,
   EventItem,
@@ -21,7 +22,7 @@ import {
   getSdkMetadataForEnvelopeHeader,
 } from '@sentry/utils';
 import { createSpanEnvelopeItem } from '@sentry/utils';
-import type { SentrySpan } from './tracing';
+import { type SentrySpan, getDynamicSamplingContextFromSpan } from './tracing';
 import { spanToJSON } from './utils/spanUtils';
 
 /**
@@ -126,8 +127,18 @@ export function createAttachmentEnvelope(
  * Create envelope from Span item.
  */
 export function createSpanEnvelope(spans: SentrySpan[]): SpanEnvelope {
+  function dscHasRequiredProps(dsc: Partial<DynamicSamplingContext>): dsc is DynamicSamplingContext {
+    return !!dsc.trace_id && !!dsc.public_key;
+  }
+
+  // For the moment we'll obtain the DSC from the first span in the array
+  // This might need to be changed if we permit sending multiple spans from
+  // different segments in one envelope
+  const dsc = getDynamicSamplingContextFromSpan(spans[0]);
+
   const headers: SpanEnvelope[0] = {
     sent_at: new Date().toISOString(),
+    ...(dscHasRequiredProps(dsc) && { trace: dsc }),
   };
 
   const items = spans.map(span => createSpanEnvelopeItem(spanToJSON(span)));

packages/core/test/lib/envelope.test.ts

@@ -1,6 +1,15 @@
-import type { DsnComponents, DynamicSamplingContext, Event } from '@sentry/types';
+import type { Client, DsnComponents, DynamicSamplingContext, Event } from '@sentry/types';
 
-import { createEventEnvelope } from '../../src/envelope';
+import {
+  SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
+  SentrySpan,
+  getCurrentScope,
+  getIsolationScope,
+  setAsyncContextStrategy,
+  setCurrentClient,
+} from '../../src';
+import { createEventEnvelope, createSpanEnvelope } from '../../src/envelope';
+import { TestClient, getDefaultTestClientOptions } from '../mocks/client';
 
 const testDsn: DsnComponents = { protocol: 'https', projectId: 'abc', host: 'testry.io', publicKey: 'pubKey123' };
 
@@ -75,3 +84,78 @@ describe('createEventEnvelope', () => {
     });
   });
 });
+
+describe('createSpanEnvelope', () => {
+  let client: Client | undefined;
+  beforeEach(() => {
+    getCurrentScope().clear();
+    getIsolationScope().clear();
+    setAsyncContextStrategy(undefined);
+    const options = getDefaultTestClientOptions({ tracesSampleRate: 1, dsn: 'https://username@domain/123' });
+    client = new TestClient(options);
+    setCurrentClient(client);
+    client.init();
+  });
+
+  it('creates a span envelope', () => {
+    const span = new SentrySpan({
+      name: 'test',
+      isStandalone: true,
+      isSegment: true,
+      startTimestamp: 1,
+      endTimestamp: 2,
+      sampled: true,
+      attributes: { [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'custom' },
+    });
+
+    const spanEnvelope = createSpanEnvelope([span]);
+
+    const spanItem = spanEnvelope[1][0][1];
+    expect(spanItem).toEqual({
+      data: {
+        'sentry.origin': 'manual',
+        'sentry.source': 'custom',
+      },
+      description: 'test',
+      is_segment: true,
+      origin: 'manual',
+      span_id: expect.stringMatching(/^[0-9a-f]{16}$/),
+      segment_id: spanItem.segment_id,
+      start_timestamp: 1,
+      timestamp: 2,
+      trace_id: expect.stringMatching(/^[0-9a-f]{32}$/),
+    });
+  });
+
+  it('adds `trace` and `sent_at` envelope headers', () => {
+    const spanEnvelope = createSpanEnvelope([
+      new SentrySpan({ name: 'test', attributes: { [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'custom' } }),
+    ]);
+
+    const spanEnvelopeHeaders = spanEnvelope[0];
+    expect(spanEnvelopeHeaders).toEqual({
+      sent_at: expect.any(String),
+      trace: {
+        environment: 'production',
+        public_key: 'username',
+        sampled: 'false',
+        trace_id: expect.stringMatching(/^[0-9a-f]{32}$/),
+        transaction: 'test',
+      },
+    });
+  });
+
+  it("doesn't add a `trace` envelope header if there's no public key", () => {
+    const options = getDefaultTestClientOptions({ tracesSampleRate: 1, dsn: 'https://domain/123' });
+    client = new TestClient(options);
+    setCurrentClient(client);
+    client.init();
+
+    const spanEnvelope = createSpanEnvelope([new SentrySpan()]);
+
+    const spanEnvelopeHeaders = spanEnvelope[0];
+    expect(spanEnvelopeHeaders).toEqual({
+      sent_at: expect.any(String),
+    });
+  });
+});

packages/types/src/envelope.ts

@@ -106,7 +106,7 @@ type CheckInEnvelopeHeaders = { trace?: DynamicSamplingContext };
 type ClientReportEnvelopeHeaders = BaseEnvelopeHeaders;
 type ReplayEnvelopeHeaders = BaseEnvelopeHeaders;
 type StatsdEnvelopeHeaders = BaseEnvelopeHeaders;
-type SpanEnvelopeHeaders = BaseEnvelopeHeaders;
+type SpanEnvelopeHeaders = BaseEnvelopeHeaders & { trace?: DynamicSamplingContext };
 
 export type EventEnvelope = BaseEnvelope<
   EventEnvelopeHeaders,