fix(cloudflare): Keep an installed OpenTelemetry async context strategy

`withSentry`, Durable Objects, Workflows and `WorkerEntrypoint` install the
AsyncLocalStorage async context strategy. When an OpenTelemetry strategy
already uses the same storage, replacing it while a request runs makes the
OpenTelemetry context manager read a Sentry scope store as a context, and
every later request fails with `context.getValue is not a function`.

The AsyncLocalStorage strategy is now only installed when no OpenTelemetry
strategy is installed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: JPeer264

packages/cloudflare/src/durableobject.ts

@@ -3,7 +3,7 @@
 import { RPC } from '@sentry/conventions/op';
 import { getDefaultIsolationScope, getIsolationScope, isObjectLike, startNewTrace } from '@sentry/core';
 import type { DurableObject } from 'cloudflare:workers';
-import { setAsyncLocalStorageAsyncContextStrategy } from '@sentry/server-utils/no-diagnostic-channels';
+import { setAsyncLocalStorageAsyncContextStrategyForWorker } from './utils/asyncContextStrategy';
 import type { CloudflareOptions } from './client';
 import { getInstrumented, markAsInstrumented } from './instrument';
 import { instrumentDurableObjectHandlers } from './instrumentations/instrumentDurableObjectHandlers';
@@ -53,7 +53,7 @@ export function constructInstrumentedDurableObject<E, T extends DurableObject<E>
   context: InstrumentedDurableObjectContext;
   frameworkManagedMethods: ReadonlySet<string>;
 } {
-  setAsyncLocalStorageAsyncContextStrategy();
+  setAsyncLocalStorageAsyncContextStrategyForWorker();
   const options = getFinalOptions(optionsCallback(env), env);
   // See InstrumentedDurableObjectContext — `ctx` is widened to `any` so the concrete
   // `DurableObjectState` type never enters the checker's relation graph in this module.

packages/cloudflare/src/instrumentations/instrumentWorkerEntrypoint.ts

@@ -1,6 +1,6 @@
 import type { RpcStub, WorkerEntrypoint } from 'cloudflare:workers';
 import { RPC } from '@sentry/conventions/op';
-import { setAsyncLocalStorageAsyncContextStrategy } from '@sentry/server-utils/no-diagnostic-channels';
+import { setAsyncLocalStorageAsyncContextStrategyForWorker } from '../utils/asyncContextStrategy';
 import type { CloudflareOptions } from '../client';
 import { markAsInstrumented } from '../instrument';
 import { getFinalOptions } from '../options';
@@ -151,7 +151,7 @@ export function instrumentWorkerEntrypoint<
   // Set up AsyncLocalStorage strategy ONCE at instrumentation time, not per-request
   // This is critical - calling this per-request would create a new AsyncLocalStorage
   // each time, breaking scope isolation for concurrent requests
-  setAsyncLocalStorageAsyncContextStrategy();
+  setAsyncLocalStorageAsyncContextStrategyForWorker();
 
   const InstrumentedClass = new Proxy(WorkerEntrypointClass, {
     construct(target, [ctx, env]) {

packages/cloudflare/src/utils/asyncContextStrategy.ts

@@ -0,0 +1,12 @@
+import { getAsyncContextStrategy, getMainCarrier } from '@sentry/core';
+import { setAsyncLocalStorageAsyncContextStrategy } from '@sentry/server-utils/no-diagnostic-channels';
+
+/**
+ * Installs the AsyncLocalStorage strategy unless an OpenTelemetry strategy is installed. Both use the same storage,
+ * so a switch during a request breaks it (#24603).
+ */
+export function setAsyncLocalStorageAsyncContextStrategyForWorker(): void {
+  if (!getAsyncContextStrategy(getMainCarrier()).withActiveSpan) {
+    setAsyncLocalStorageAsyncContextStrategy();
+  }
+}

packages/cloudflare/src/withSentry.ts

@@ -1,4 +1,4 @@
-import { setAsyncLocalStorageAsyncContextStrategy } from '@sentry/server-utils/no-diagnostic-channels';
+import { setAsyncLocalStorageAsyncContextStrategyForWorker } from './utils/asyncContextStrategy';
 import { instrumentExportedHandlerEmail } from './instrumentations/worker/instrumentEmail';
 import { instrumentExportedHandlerFetch } from './instrumentations/worker/instrumentFetch';
 import { instrumentExportedHandlerQueue } from './instrumentations/worker/instrumentQueue';
@@ -37,7 +37,7 @@ export function withSentry<
     return instrumentWorkerEntrypoint(optionsCallback as any, handler);
   }
 
-  setAsyncLocalStorageAsyncContextStrategy();
+  setAsyncLocalStorageAsyncContextStrategyForWorker();
 
   try {
     // oxlint-disable-next-line typescript/no-explicit-any

packages/cloudflare/src/workflows.ts

@@ -22,7 +22,7 @@ import type {
   WorkflowStepRollbackOptions,
   WorkflowTimeoutDuration,
 } from 'cloudflare:workers';
-import { setAsyncLocalStorageAsyncContextStrategy } from '@sentry/server-utils/no-diagnostic-channels';
+import { setAsyncLocalStorageAsyncContextStrategyForWorker } from './utils/asyncContextStrategy';
 import type { CloudflareOptions } from './client';
 import { flushAndDispose, getOriginalWaitUntil } from './flush';
 import { markAsInstrumented } from './instrument';
@@ -254,7 +254,7 @@ export function instrumentWorkflowWithSentry<
         get(obj, prop, receiver) {
           if (prop === 'run') {
             return async function (event: WorkflowEvent<P>, step: WorkflowStep): Promise<unknown> {
-              setAsyncLocalStorageAsyncContextStrategy();
+              setAsyncLocalStorageAsyncContextStrategyForWorker();
 
               return withInvocationIsolationScope(async isolationScope => {
                 const waitUntil = getOriginalWaitUntil(context).bind(context);

packages/cloudflare/test/utils/asyncContextStrategy.test.ts

@@ -0,0 +1,28 @@
+import { getAsyncContextStrategy, getMainCarrier } from '@sentry/core';
+import { setOpenTelemetryContextAsyncContextStrategy } from '@sentry/opentelemetry';
+import { afterEach, describe, expect, it } from 'vitest';
+import { setAsyncLocalStorageAsyncContextStrategyForWorker } from '../../src/utils/asyncContextStrategy';
+import { resetSdk } from '../testUtils';
+
+describe('setAsyncLocalStorageAsyncContextStrategyForWorker', () => {
+  afterEach(() => {
+    resetSdk();
+  });
+
+  it('installs the AsyncLocalStorage strategy', () => {
+    setAsyncLocalStorageAsyncContextStrategyForWorker();
+
+    const strategy = getAsyncContextStrategy(getMainCarrier());
+    expect(strategy.getTracingChannelBinding).toBeDefined();
+    expect(strategy.withActiveSpan).toBeUndefined();
+  });
+
+  it('keeps an installed OpenTelemetry strategy', () => {
+    setOpenTelemetryContextAsyncContextStrategy();
+    const openTelemetryStrategy = getAsyncContextStrategy(getMainCarrier());
+
+    setAsyncLocalStorageAsyncContextStrategyForWorker();
+
+    expect(getAsyncContextStrategy(getMainCarrier())).toBe(openTelemetryStrategy);
+  });
+});