feat(core): Implement strictTraceContinuation

packages/core/src/tracing/trace.ts

@@ -16,6 +16,8 @@ import { hasSpansEnabled } from '../utils/hasSpansEnabled';
 import { parseSampleRate } from '../utils/parseSampleRate';
 import { _getSpanForScope, _setSpanForScope } from '../utils/spanOnScope';
 import { addChildSpanToSpan, getRootSpan, spanIsSampled, spanTimeInputToSeconds, spanToJSON } from '../utils/spanUtils';
+import { baggageHeaderToDynamicSamplingContext } from '../utils-hoist/baggage';
+import { extractOrgIdFromDsnHost } from '../utils-hoist/dsn';
 import { logger } from '../utils-hoist/logger';
 import { generateTraceId } from '../utils-hoist/propagationContext';
 import { propagationContextFromHeaders } from '../utils-hoist/tracing';
@@ -215,6 +217,47 @@ export const continueTrace = <V>(
   }
 
   const { sentryTrace, baggage } = options;
+  const client = getClient();
+
+  const clientOptions = client?.getOptions();
+  const strictTraceContinuation = clientOptions?.strictTraceContinuation || false; // default for `strictTraceContinuation` is `false` todo(v10): set default to `true`
+
+  const incomingDsc = baggageHeaderToDynamicSamplingContext(baggage);
+  const baggageOrgId = incomingDsc?.org_id;
+
+  let sdkOrgId: string | undefined;
+  const dsn = client?.getDsn();
+  if (dsn?.host) {
+    sdkOrgId = extractOrgIdFromDsnHost(dsn.host);
+  }
+
+  const shouldStartNewTrace = (): boolean => {
+    // Case: baggage org ID and SDK org ID don't match - always start new trace
+    if (baggageOrgId && sdkOrgId && baggageOrgId !== sdkOrgId) {
+      DEBUG_BUILD &&
+        logger.info(`Starting a new trace because org IDs don't match (incoming: ${baggageOrgId}, sdk: ${sdkOrgId})`);
+      return true;
+    }
+
+    if (strictTraceContinuation) {
+      // With strict continuation enabled, start new trace if:
+      // - Baggage has org ID but SDK doesn't have one
+      // - SDK has org ID but baggage doesn't have one
+      if ((baggageOrgId && !sdkOrgId) || (!baggageOrgId && sdkOrgId)) {
+        DEBUG_BUILD &&
+          logger.info(
+            `Starting a new trace because strict trace continuation is enabled and one org ID is missing (incoming: ${baggageOrgId}, sdk: ${sdkOrgId})`,
+          );
+        return true;
+      }
+    }
+
+    return false;
+  };
+
+  if (shouldStartNewTrace()) {
+    return startNewTrace(callback);
+  }
 
   return withScope(scope => {
     const propagationContext = propagationContextFromHeaders(sentryTrace, baggage);

packages/core/src/types-hoist/options.ts

@@ -320,6 +320,18 @@ export interface ClientOptions<TO extends BaseTransportOptions = BaseTransportOp
    */
   tracePropagationTargets?: TracePropagationTargets;
 
+  /**
+   * Controls whether trace continuation should be strict about matching organization IDs.
+   *
+   * When set to `true`, the SDK will only continue a trace if the organization ID in the incoming baggage
+   * matches the organization ID of the current SDK (extracted from the DSN).
+   *
+   * If there is no match, the SDK will start a new trace instead of continuing the incoming one.
+   *
+   * @default false
+   */
+  strictTraceContinuation?: boolean;
+
   /**
    * The organization ID of the current SDK. The organization ID is a string containing only numbers. This ID is used to
    * propagate traces to other Sentry services.

packages/core/test/lib/tracing/trace.test.ts

@@ -31,6 +31,7 @@ import type { Span } from '../../../src/types-hoist/span';
 import type { StartSpanOptions } from '../../../src/types-hoist/startSpanOptions';
 import { _setSpanForScope } from '../../../src/utils/spanOnScope';
 import { getActiveSpan, getRootSpan, getSpanDescendants, spanIsSampled } from '../../../src/utils/spanUtils';
+import { extractOrgIdFromDsnHost } from '../../../src/utils-hoist/dsn';
 import { getDefaultTestClientOptions, TestClient } from '../../mocks/client';
 
 const enum Type {
@@ -1733,6 +1734,151 @@ describe('continueTrace', () => {
 
     expect(result).toEqual('aha');
   });
+
+  describe('strictTraceContinuation', () => {
+    const creatOrgIdInDsn = (orgId: number) => {
+      vi.spyOn(client, 'getDsn').mockReturnValue({
+        host: `o${orgId}.ingest.sentry.io`,
+        protocol: 'https',
+        projectId: 'projId',
+      });
+    };
+
+    afterEach(() => {
+      vi.clearAllMocks();
+    });
+
+    it('continues trace when org IDs match', () => {
+      creatOrgIdInDsn(123);
+
+      const scope = continueTrace(
+        {
+          sentryTrace: '12312012123120121231201212312012-1121201211212012-1',
+          baggage: 'sentry-org_id=123',
+        },
+        () => {
+          return getCurrentScope();
+        },
+      );
+
+      expect(scope.getPropagationContext().traceId).toBe('12312012123120121231201212312012');
+      expect(scope.getPropagationContext().parentSpanId).toBe('1121201211212012');
+    });
+
+    it('starts new trace when both SDK and baggage org IDs are set and do not match', () => {
+      creatOrgIdInDsn(123);
+
+      const scope = continueTrace(
+        {
+          sentryTrace: '12312012123120121231201212312012-1121201211212012-1',
+          baggage: 'sentry-org_id=456',
+        },
+        () => {
+          return getCurrentScope();
+        },
+      );
+
+      // Should start a new trace with a different trace ID
+      expect(scope.getPropagationContext().traceId).not.toBe('12312012123120121231201212312012');
+      expect(scope.getPropagationContext().parentSpanId).toBeUndefined();
+    });
+
+    describe('when strictTraceContinuation is true', () => {
+      it('starts new trace when baggage org ID is missing', () => {
+        client.getOptions().strictTraceContinuation = true;
+
+        creatOrgIdInDsn(123);
+
+        const scope = continueTrace(
+          {
+            sentryTrace: '12312012123120121231201212312012-1121201211212012-1',
+            baggage: 'sentry-environment=production',
+          },
+          () => {
+            return getCurrentScope();
+          },
+        );
+
+        // Should start a new trace with a different trace ID
+        expect(scope.getPropagationContext().traceId).not.toBe('12312012123120121231201212312012');
+        expect(scope.getPropagationContext().parentSpanId).toBeUndefined();
+      });
+
+      it('starts new trace when SDK org ID is missing', () => {
+        client.getOptions().strictTraceContinuation = true;
+
+        const scope = continueTrace(
+          {
+            sentryTrace: '12312012123120121231201212312012-1121201211212012-1',
+            baggage: 'sentry-org_id=123',
+          },
+          () => {
+            return getCurrentScope();
+          },
+        );
+
+        // Should start a new trace with a different trace ID
+        expect(scope.getPropagationContext().traceId).not.toBe('12312012123120121231201212312012');
+        expect(scope.getPropagationContext().parentSpanId).toBeUndefined();
+      });
+
+      it('continues trace when both org IDs are missing', () => {
+        client.getOptions().strictTraceContinuation = true;
+
+        const scope = continueTrace(
+          {
+            sentryTrace: '12312012123120121231201212312012-1121201211212012-1',
+            baggage: 'sentry-environment=production',
+          },
+          () => {
+            return getCurrentScope();
+          },
+        );
+
+        // Should continue the trace
+        expect(scope.getPropagationContext().traceId).toBe('12312012123120121231201212312012');
+        expect(scope.getPropagationContext().parentSpanId).toBe('1121201211212012');
+      });
+    });
+
+    describe('when strictTraceContinuation is false', () => {
+      it('continues trace when baggage org ID is missing', () => {
+        client.getOptions().strictTraceContinuation = false;
+
+        creatOrgIdInDsn(123);
+
+        const scope = continueTrace(
+          {
+            sentryTrace: '12312012123120121231201212312012-1121201211212012-1',
+            baggage: 'sentry-environment=production',
+          },
+          () => {
+            return getCurrentScope();
+          },
+        );
+
+        expect(scope.getPropagationContext().traceId).toBe('12312012123120121231201212312012');
+        expect(scope.getPropagationContext().parentSpanId).toBe('1121201211212012');
+      });
+
+      it('SDK org ID is missing', () => {
+        client.getOptions().strictTraceContinuation = false;
+
+        const scope = continueTrace(
+          {
+            sentryTrace: '12312012123120121231201212312012-1121201211212012-1',
+            baggage: 'sentry-org_id=123',
+          },
+          () => {
+            return getCurrentScope();
+          },
+        );
+
+        expect(scope.getPropagationContext().traceId).toBe('12312012123120121231201212312012');
+        expect(scope.getPropagationContext().parentSpanId).toBe('1121201211212012');
+      });
+    });
+  });
 });
 
 describe('getActiveSpan', () => {