use trace json object

Author: AbhiPrasad

packages/core/src/envelope.ts

@@ -12,13 +12,12 @@ import {
   SessionItem,
 } from '@sentry/types';
 import {
-  BaggageObj,
   createBaggage,
   createEnvelope,
   dropUndefinedKeys,
   dsnToString,
+  getSentryBaggageItems,
   isBaggageEmpty,
-  serializeBaggage,
 } from '@sentry/utils';
 
 /** Extract sdk info from from the API metadata */
@@ -138,14 +137,14 @@ function createEventEnvelopeHeaders(
         userid: event.user && event.user.id,
         // user.segment currently doesn't exist explicitly in interface User (just as a record key)
         usersegment: event.user && event.user.segment,
-      } as BaggageObj),
+      }),
     );
 
   return {
     event_id: event.event_id as string,
     sent_at: new Date().toISOString(),
     ...(sdkInfo && { sdk: sdkInfo }),
     ...(!!tunnel && { dsn: dsnToString(dsn) }),
-    ...(baggage && !isBaggageEmpty(baggage) && { trace: serializeBaggage(baggage) }),
+    ...(baggage && !isBaggageEmpty(baggage) && { trace: getSentryBaggageItems(baggage) }),
   };
 }

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

@@ -5,31 +5,31 @@ import { createEventEnvelope } from '../../src/envelope';
 const testDsn: DsnComponents = { protocol: 'https', projectId: 'abc', host: 'testry.io' };
 
 describe('createEventEnvelope', () => {
-  describe('baggage header', () => {
-    it("doesn't add baggage header if event is not a transaction", () => {
+  describe('trace header', () => {
+    it("doesn't add trace header if event is not a transaction", () => {
       const event: Event = {};
       const envelopeHeaders = createEventEnvelope(event, testDsn)[0];
 
       expect(envelopeHeaders).toBeDefined();
-      expect(envelopeHeaders.baggage).toBeUndefined();
+      expect(envelopeHeaders.trace).toBeUndefined();
     });
 
-    it("doesn't add baggage header if no baggage data is available", () => {
+    it("doesn't add trace header if no baggage data is available", () => {
       const event: Event = {
         type: 'transaction',
       };
       const envelopeHeaders = createEventEnvelope(event, testDsn)[0];
 
       expect(envelopeHeaders).toBeDefined();
-      expect(envelopeHeaders.baggage).toBeUndefined();
+      expect(envelopeHeaders.trace).toBeUndefined();
     });
 
-    const testTable: Array<[string, Event, string]> = [
-      ['adds only baggage item', { type: 'transaction', release: '1.0.0' }, 'sentry-release=1.0.0'],
+    const testTable: Array<[string, Event, Event]> = [
+      ['adds only baggage item', { type: 'transaction', release: '1.0.0' }, { release: '1.0.0' }],
       [
         'adds two baggage items',
         { type: 'transaction', release: '1.0.0', environment: 'prod' },
-        'sentry-environment=prod,sentry-release=1.0.0',
+        { release: '1.0.0', environment: 'prod' },
       ],
       [
         'adds all baggageitems',
@@ -40,15 +40,20 @@ describe('createEventEnvelope', () => {
           user: { id: 'bob', segment: 'segmentA' },
           transaction: 'TX',
         },
-        'sentry-environment=prod,sentry-release=1.0.0,sentry-transaction=TX,sentry-userid=bob,sentry-usersegment=segmentA',
+        {
+          release: '1.0.0',
+          environment: 'prod',
+          user: { id: 'bob', segment: 'segmentA' },
+          transaction: 'TX',
+        },
       ],
     ];
-    it.each(testTable)('%s', (_: string, event, serializedBaggage) => {
+    it.each(testTable)('%s', (_: string, event, trace) => {
       const envelopeHeaders = createEventEnvelope(event, testDsn)[0];
 
       expect(envelopeHeaders).toBeDefined();
-      expect(envelopeHeaders.baggage).toBeDefined();
-      expect(envelopeHeaders.baggage).toEqual(serializedBaggage);
+      expect(envelopeHeaders.trace).toBeDefined();
+      expect(envelopeHeaders.trace).toEqual(trace);
     });
   });
 });

packages/integration-tests/suites/tracing/baggage/test.ts

@@ -10,7 +10,10 @@ sentryTest('should send baggage data in transaction envelope header', async ({ g
   const envHeader = await getFirstSentryEnvelopeRequest<EventEnvelopeHeaders>(page, url, envelopeHeaderRequestParser);
 
   expect(envHeader.trace).toBeDefined();
-  expect(envHeader.trace).toEqual(
-    'sentry-environment=production,sentry-transaction=testTransactionBaggage,sentry-userid=user123,sentry-usersegment=segmentB',
-  );
+  expect(envHeader.trace).toEqual({
+    environment: 'production',
+    transaction: 'testTransactionBaggage',
+    userid: 'user123',
+    usersegment: 'segmentB',
+  });
 });

packages/types/src/envelope.ts

@@ -56,7 +56,7 @@ export type SessionItem =
   | BaseEnvelopeItem<SessionAggregatesItemHeaders, SessionAggregates>;
 export type ClientReportItem = BaseEnvelopeItem<ClientReportItemHeaders, ClientReport>;
 
-export type EventEnvelopeHeaders = { event_id: string; sent_at: string; trace?: string };
+export type EventEnvelopeHeaders = { event_id: string; sent_at: string; trace?: Record<string, unknown> };
 type SessionEnvelopeHeaders = { sent_at: string };
 type ClientReportEnvelopeHeaders = BaseEnvelopeHeaders;
 

packages/utils/src/baggage.ts

@@ -52,6 +52,11 @@ export function isBaggageEmpty(baggage: Baggage): boolean {
   return Object.keys(baggage[0]).length === 0;
 }
 
+/** Returns Sentry specific baggage values */
+export function getSentryBaggageItems(baggage: Baggage): BaggageObj {
+  return baggage[0];
+}
+
 /** Serialize a baggage object */
 export function serializeBaggage(baggage: Baggage): string {
   return Object.keys(baggage[0]).reduce((prev, key: keyof BaggageObj) => {