fix(test/utils/tracing): disable OTel globals before re-registering in createInMemoryTracing

The previous form (commit 133d468) skipped `provider.register()` to
avoid "Attempted duplicate registration of API: trace" when another
test in the same shard had already loaded `~/v3/tracer.server.ts`
(which calls register() via its `singleton("opentelemetry", …)`).
That fix went too far: tests like `sentryTraceContext.server.test.ts`
exercise OTel's *global* API (`trace.getActiveSpan()` via
`getActiveTraceIds`), which requires a registered global context
manager. Without register(), `trace.getActiveSpan()` returned
undefined — 6/9 assertions in that file flipped red on shard 1 of
the latest CI run.

Webapp's vitest config uses `pool: "forks"` with
`--no-file-parallelism`, so all test files in a shard share one
process. globalThis persists across files even though vitest clears
the module cache between them. OTel's `setGlobal*` no-ops (logs an
error, returns false) when a global is already set — so the second
caller's register() is a no-op, leaving the globals pointed at the
first caller's provider.

Fix: call `trace.disable(); context.disable(); propagation.disable();`
*before* `provider.register()`. The disables clear any previously-set
globals (whether from `tracer.server.ts`'s singleton or a prior
createInMemoryTracing call), so the test's provider always wins for
both span recording (via SimpleSpanProcessor) AND the global API.
Each createInMemoryTracing call rotates the globals; no leakage to
the next test file.

Verified locally: `pnpm vitest run test/sentryTraceContext.server.test.ts`
9/9 pass. Running it alongside test/engine/triggerTask.test.ts (which
loads tracer.server.ts) reaches the test-setup phase normally —
no more module-load OTel collision.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: matt-aitken

apps/webapp/test/utils/tracing.ts

@@ -1,3 +1,4 @@
+import { context, propagation, trace } from "@opentelemetry/api";
 import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
 import { InMemorySpanExporter, SimpleSpanProcessor } from "@opentelemetry/sdk-trace-base";
 import {
@@ -8,22 +9,35 @@ import {
 } from "@opentelemetry/sdk-metrics";
 
 export function createInMemoryTracing() {
-  // Initialize the tracer provider and exporter — but do NOT call
-  // `provider.register()`. Calling register() sets the OTel global APIs
-  // (trace/context/propagation), and webapp's `~/v3/tracer.server.ts`
-  // also calls register() via its singleton. Webapp's `vitest.config.ts`
-  // uses `pool: "forks"` with `--no-file-parallelism`, so all test
-  // files in a shard share one process — globals set by the first test
-  // to load tracer.server.ts conflict with subsequent createInMemoryTracing
-  // calls, throwing "Attempted duplicate registration of API: trace".
+  // Webapp's vitest config uses `pool: "forks"` with `--no-file-parallelism`,
+  // so all test files in a shard share one process. globalThis persists
+  // across files even though vitest clears the module cache between them.
   //
-  // The tracer returned from `provider.getTracer(...)` is scoped to
-  // this provider, so the InMemorySpanExporter still receives the
-  // spans the consuming test creates — no global registration needed.
+  // OTel's `provider.register()` calls trace/context/propagation
+  // `setGlobal*` — and `setGlobal` no-ops (logs an error, returns false)
+  // when a global is already set. Two patterns hit that path:
+  // 1. `~/v3/tracer.server.ts` runs `provider.register()` via its
+  //    `singleton("opentelemetry", setupTelemetry)` — first test in the
+  //    shard to import that path sets the globals to webapp's tracer.
+  // 2. A subsequent test calls `createInMemoryTracing()` to swap in its
+  //    own in-memory provider. Without disabling first, register() is
+  //    a no-op — the test's provider receives spans via its
+  //    SimpleSpanProcessor (provider-scoped), but `trace.getActiveSpan()`
+  //    (used by code under test, e.g. sentryTraceContext.server.ts)
+  //    reads from the stale global context manager from step 1.
+  //
+  // Disable first, then register, so the test's provider always wins
+  // for both span recording and the global API. After the test, the
+  // next caller's createInMemoryTracing rotates again — no leakage.
+  trace.disable();
+  context.disable();
+  propagation.disable();
+
   const exporter = new InMemorySpanExporter();
   const provider = new NodeTracerProvider({
     spanProcessors: [new SimpleSpanProcessor(exporter)],
   });
+  provider.register();
 
   const tracer = provider.getTracer("test-tracer");