fix(core): continueTrace doesn't propagate given trace ID if active span exists (#18328)

During investigation of [this
issue](#18296), we
discovered that `continueTrace` does not propagate the given trace ID if
it is called from within an already active span (in this instance this
happened because of the already active span started by the cloudflare
auto-instrumentation.

Solution: This PR resolves this behavior by setting the currently active
span to undefined when forking the propagation context in
`continueTrace`.

Tests:
- After introducing the fix one of the `@sentry/sveltekit` unit tests
started to fail. Not sure why this was triggered by this change, but I
fixed it by setting the `isSubRequest` property on the event instead of
the route, which seems correct to me.
- Added a unit test in `@sentry/core` that calls `continueTrace` inside
an active span and checks that the trace id is now propagated as we
would expect.

Author: nicohrubec

packages/core/src/tracing/trace.ts

@@ -226,6 +226,7 @@ export const continueTrace = <V>(
   return withScope(scope => {
     const propagationContext = propagationContextFromHeaders(sentryTrace, baggage);
     scope.setPropagationContext(propagationContext);
+    _setSpanForScope(scope, undefined);
     return callback();
   });
 };

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

@@ -4,6 +4,7 @@ import {
   getGlobalScope,
   getIsolationScope,
   getMainCarrier,
+  getTraceData,
   Scope,
   SEMANTIC_ATTRIBUTE_SENTRY_OP,
   SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
@@ -2021,6 +2022,74 @@ describe('continueTrace', () => {
       });
     });
   });
+
+  it('updates the propagation context when called inside an active span', () => {
+    const client = new TestClient(
+      getDefaultTestClientOptions({
+        dsn: 'https://username@domain/123',
+        tracesSampleRate: 1,
+      }),
+    );
+    setCurrentClient(client);
+    client.init();
+
+    const sentryTrace = '12312012123120121231201212312012-1121201211212012-1';
+    const sentryTraceId = '12312012123120121231201212312012';
+    const sentryBaggage = 'sentry-org_id=123';
+
+    startSpan({ name: 'outer' }, () => {
+      continueTrace(
+        {
+          sentryTrace: sentryTrace,
+          baggage: sentryBaggage,
+        },
+        () => {
+          const traceDataInContinuedTrace = getTraceData();
+          const traceIdInContinuedTrace = traceDataInContinuedTrace['sentry-trace']?.split('-')[0];
+          const traceIdInCurrentScope = getCurrentScope().getPropagationContext().traceId;
+
+          expect(getActiveSpan()).toBeUndefined();
+          expect(traceIdInContinuedTrace).toBe(sentryTraceId);
+          expect(traceIdInCurrentScope).toBe(sentryTraceId);
+        },
+      );
+    });
+  });
+
+  it('sets the correct trace and parent span ids when called inside an active span and a new span is started from within the callback', () => {
+    const client = new TestClient(
+      getDefaultTestClientOptions({
+        dsn: 'https://username@domain/123',
+        tracesSampleRate: 1,
+      }),
+    );
+    setCurrentClient(client);
+    client.init();
+
+    const sentryTrace = '12312012123120121231201212312012-1121201211212012-1';
+    const sentryTraceId = '12312012123120121231201212312012';
+    const sentrySpanId = '1121201211212012';
+    const sentryBaggage = 'sentry-org_id=123';
+
+    startSpan({ name: 'outer' }, () => {
+      continueTrace(
+        {
+          sentryTrace: sentryTrace,
+          baggage: sentryBaggage,
+        },
+        () => {
+          startSpan({ name: 'inner' }, span => {
+            const innerSpanJson = spanToJSON(span);
+            const innerTraceId = innerSpanJson.trace_id;
+            const innerParentSpanId = innerSpanJson.parent_span_id;
+
+            expect(innerTraceId).toBe(sentryTraceId);
+            expect(innerParentSpanId).toBe(sentrySpanId);
+          });
+        },
+      );
+    });
+  });
 });
 
 describe('getActiveSpan', () => {

packages/sveltekit/test/server-common/handle.test.ts

@@ -186,7 +186,7 @@ describe('sentryHandle', () => {
           resolve: async _ => {
             // simulating a nested load call:
             await sentryHandle()({
-              event: mockEvent({ route: { id: 'api/users/details/[id]', isSubRequest: true } }),
+              event: mockEvent({ route: { id: 'api/users/details/[id]' }, isSubRequest: true }),
               resolve: resolve(type, isError),
             });
             return mockResponse;