feat(tracing): add propagation of environment and release values in baggage headers

Author: Lms24

packages/tracing/src/browser/request.ts

@@ -1,4 +1,5 @@
 /* eslint-disable max-lines */
+import type { Span } from '@sentry/types';
 import {
   addInstrumentationHandler,
   BAGGAGE_HEADER_NAME,
@@ -7,7 +8,6 @@ import {
   mergeAndSerializeBaggage,
 } from '@sentry/utils';
 
-import { Span } from '../span';
 import { getActiveTransaction, hasTracingEnabled } from '../utils';
 
 export const DEFAULT_TRACING_ORIGINS = ['localhost', /^\//];

packages/tracing/src/span.ts

@@ -1,6 +1,15 @@
 /* eslint-disable max-lines */
-import { Baggage, Primitive, Span as SpanInterface, SpanContext, Transaction } from '@sentry/types';
-import { dropUndefinedKeys, timestampWithMs, uuid4 } from '@sentry/utils';
+import { getCurrentHub } from '@sentry/hub';
+import { Baggage, Hub, Primitive, Span as SpanInterface, SpanContext, Transaction } from '@sentry/types';
+import {
+  createBaggage,
+  dropUndefinedKeys,
+  isBaggageEmpty,
+  isSentryBaggageEmpty,
+  setBaggageValue,
+  timestampWithMs,
+  uuid4,
+} from '@sentry/utils';
 
 /**
  * Keeps track of finished spans for a given transaction
@@ -302,7 +311,14 @@ export class Span implements SpanInterface {
    * @inheritdoc
    */
   public getBaggage(): Baggage | undefined {
-    return this.transaction && this.transaction.metadata.baggage;
+    const existingBaggage = this.transaction && this.transaction.metadata.baggage;
+
+    const finalBaggage =
+      !existingBaggage || isSentryBaggageEmpty(existingBaggage)
+        ? this._getBaggageWithSentryValues(existingBaggage)
+        : existingBaggage;
+
+    return isBaggageEmpty(finalBaggage) ? undefined : finalBaggage;
   }
 
   /**
@@ -334,6 +350,24 @@ export class Span implements SpanInterface {
       trace_id: this.traceId,
     });
   }
+
+  /**
+   *
+   * @param baggage
+   * @returns
+   */
+  private _getBaggageWithSentryValues(baggage: Baggage = createBaggage({})): Baggage {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
+    const hub: Hub = ((this.transaction as any) && (this.transaction as any)._hub) || getCurrentHub();
+    const client = hub.getClient();
+
+    const { environment, release } = (client && client.getOptions()) || {};
+
+    environment && setBaggageValue(baggage, 'environment', environment);
+    release && setBaggageValue(baggage, 'release', release);
+
+    return baggage;
+  }
 }
 
 export type SpanStatusType =

packages/tracing/src/transaction.ts

@@ -17,12 +17,12 @@ export class Transaction extends SpanClass implements TransactionInterface {
 
   public metadata: TransactionMetadata;
 
-  private _measurements: Measurements = {};
-
   /**
    * The reference to the current hub.
    */
-  private readonly _hub: Hub;
+  protected readonly _hub: Hub;
+
+  private _measurements: Measurements = {};
 
   private _trimEnd?: boolean;
 

packages/tracing/test/span.test.ts

@@ -1,9 +1,11 @@
 import { BrowserClient } from '@sentry/browser';
 import { Hub, makeMain, Scope } from '@sentry/hub';
+import { createBaggage, getSentryBaggageItems, getThirdPartyBaggage, isSentryBaggageEmpty } from '@sentry/utils';
 
 import { Span, Transaction } from '../src';
 import { TRACEPARENT_REGEXP } from '../src/utils';
 import { getDefaultBrowserClientOptions } from './testutils';
+import { BaseTransportOptions, ClientOptions } from '@sentry/types';
 
 describe('Span', () => {
   let hub: Hub;
@@ -390,4 +392,57 @@ describe('Span', () => {
       expect(span.data).toStrictEqual({ data0: 'foo', data1: 'bar' });
     });
   });
+
+  describe('getBaggage and _getBaggageWithSentryValues', () => {
+    beforeEach(() => {
+      hub.getClient()!!.getOptions = () => {
+        return {
+          release: '1.0.1',
+          environment: 'production',
+        } as ClientOptions<BaseTransportOptions>;
+      };
+    });
+
+    test('leave baggage content untouched and just return baggage if there already is Sentry content in it', () => {
+      const transaction = new Transaction(
+        {
+          name: 'tx',
+          metadata: { baggage: createBaggage({ environment: 'myEnv' }, '') },
+        },
+        hub,
+      );
+
+      const hubSpy = jest.spyOn(hub.getClient()!!, 'getOptions');
+
+      const span = transaction.startChild();
+
+      const baggage = span.getBaggage();
+
+      expect(hubSpy).toHaveBeenCalledTimes(0);
+      expect(baggage && isSentryBaggageEmpty(baggage)).toBeFalsy();
+      expect(baggage && getSentryBaggageItems(baggage)).toStrictEqual({ environment: 'myEnv' });
+      expect(baggage && getThirdPartyBaggage(baggage)).toStrictEqual('');
+    });
+
+    test('add Sentry baggage data to baggage if Sentry content is empty', () => {
+      const transaction = new Transaction(
+        {
+          name: 'tx',
+          metadata: { baggage: createBaggage({}, '') },
+        },
+        hub,
+      );
+
+      const hubSpy = jest.spyOn(hub.getClient()!!, 'getOptions');
+
+      const span = transaction.startChild();
+
+      const baggage = span.getBaggage();
+
+      expect(hubSpy).toHaveBeenCalledTimes(1);
+      expect(baggage && isSentryBaggageEmpty(baggage)).toBeFalsy();
+      expect(baggage && getSentryBaggageItems(baggage)).toStrictEqual({ release: '1.0.1', environment: 'production' });
+      expect(baggage && getThirdPartyBaggage(baggage)).toStrictEqual('');
+    });
+  });
 });

packages/types/src/span.ts

@@ -178,4 +178,6 @@ export interface Span extends SpanContext {
 
   /** return the baggage for dynamic sampling and trace propagation */
   getBaggage(): Baggage | undefined;
+
+  //_getBaggageWithSentryValues(baggage: Baggage): Baggage;
 }

packages/utils/src/baggage.ts

@@ -31,11 +31,17 @@ export function setBaggageValue(baggage: Baggage, key: keyof BaggageObj, value:
   baggage[0][key] = value;
 }
 
-/** Check if the baggage object (i.e. the first element in the tuple) is empty */
-export function isBaggageEmpty(baggage: Baggage): boolean {
+/** Check if the Sentry part of the passed baggage (i.e. the first element in the tuple) is empty */
+export function isSentryBaggageEmpty(baggage: Baggage): boolean {
   return Object.keys(baggage[0]).length === 0;
 }
 
+/** Check if the Sentry part of the passed baggage (i.e. the first element in the tuple) is empty */
+export function isBaggageEmpty(baggage: Baggage): boolean {
+  const thirdPartyBaggage = getThirdPartyBaggage(baggage);
+  return isSentryBaggageEmpty(baggage) && (thirdPartyBaggage == undefined || thirdPartyBaggage.length === 0);
+}
+
 /** Returns Sentry specific baggage values */
 export function getSentryBaggageItems(baggage: Baggage): BaggageObj {
   return baggage[0];

packages/utils/test/baggage.test.ts

@@ -1,7 +1,7 @@
 import {
   createBaggage,
   getBaggageValue,
-  isBaggageEmpty,
+  isSentryBaggageEmpty,
   mergeAndSerializeBaggage,
   parseBaggageString,
   serializeBaggage,
@@ -98,12 +98,12 @@ describe('Baggage', () => {
     });
   });
 
-  describe('isBaggageEmpty', () => {
+  describe('isSentryBaggageEmpty', () => {
     it.each([
       ['returns true if the modifyable part of baggage is empty', createBaggage({}), true],
       ['returns false if the modifyable part of baggage is not empty', createBaggage({ release: '10.0.2' }), false],
     ])('%s', (_: string, baggage, outcome) => {
-      expect(isBaggageEmpty(baggage)).toEqual(outcome);
+      expect(isSentryBaggageEmpty(baggage)).toEqual(outcome);
     });
   });