fix(cloudflare): Don't treat DO constructor work as incoming RPC calls

The RPC prototype wrapper treats a call without trace data on the default
isolation scope as an incoming RPC call, starts a new trace for it and
captures its errors as unhandled. The SDK ran Durable Object constructors
on the default isolation scope, so async work the constructor started,
such as a blockConcurrencyWhile callback, reached the wrappers with that
scope. Its calls to the instance's own methods were captured as untraced
RPC entries, including errors the instance caught itself.

Run the constructor on a forked construction scope, which that async work
inherits. Instrumented handlers called from it still fork their own scope,
and the construction scope carries no invocation state, so captures made
directly in that work are delivered as before.

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

Author: JPeer264

dev-packages/cloudflare-integration-tests/suites/durableobject/constructor-async-work/index.ts

@@ -0,0 +1,87 @@
+import * as Sentry from '@sentry/cloudflare';
+import { DurableObject } from 'cloudflare:workers';
+
+interface Env {
+  SENTRY_DSN: string;
+  BLOCK_CONCURRENCY_DURABLE_OBJECT: DurableObjectNamespace<BlockConcurrencyDurableObject>;
+  ASYNC_METHOD_DURABLE_OBJECT: DurableObjectNamespace<AsyncMethodDurableObject>;
+}
+
+export class BlockConcurrencyDurableObject extends DurableObject<Env> {
+  private failure?: Error;
+
+  constructor(ctx: DurableObjectState, env: Env) {
+    super(ctx, env);
+
+    // The callback runs after the constructor has returned, so after the SDK has wrapped `init`.
+    void ctx.blockConcurrencyWhile(async () => {
+      try {
+        this.init();
+      } catch (error) {
+        this.failure = error as Error;
+      }
+    });
+  }
+
+  init(): void {
+    throw new Error('Init failed');
+  }
+
+  ping(): string {
+    const status = this.failure ? 'degraded' : 'ok';
+    Sentry.captureMessage(`block-concurrency-while ping: ${status}`);
+    return status;
+  }
+}
+
+export class AsyncMethodDurableObject extends DurableObject<Env> {
+  private failure?: Error;
+  private readonly loaded: Promise<void>;
+
+  constructor(ctx: DurableObjectState, env: Env) {
+    super(ctx, env);
+
+    this.loaded = this.load();
+  }
+
+  async load(): Promise<void> {
+    // Everything after the first `await` runs after the constructor has returned, so after the SDK
+    // has wrapped `init`.
+    await this.ctx.storage.get('config');
+
+    try {
+      this.init();
+    } catch (error) {
+      this.failure = error as Error;
+    }
+  }
+
+  init(): void {
+    throw new Error('Init failed');
+  }
+
+  async ping(): Promise<string> {
+    await this.loaded;
+    const status = this.failure ? 'degraded' : 'ok';
+    Sentry.captureMessage(`async-method ping: ${status}`);
+    return status;
+  }
+}
+
+export default {
+  async fetch(request: Request, env: Env): Promise<Response> {
+    const url = new URL(request.url);
+
+    if (url.pathname === '/block-concurrency-while') {
+      const namespace = env.BLOCK_CONCURRENCY_DURABLE_OBJECT;
+      return new Response(await namespace.get(namespace.idFromName('test')).ping());
+    }
+
+    if (url.pathname === '/async-method') {
+      const namespace = env.ASYNC_METHOD_DURABLE_OBJECT;
+      return new Response(await namespace.get(namespace.idFromName('test')).ping());
+    }
+
+    return new Response('Not found', { status: 404 });
+  },
+} satisfies ExportedHandler<Env>;

dev-packages/cloudflare-integration-tests/suites/durableobject/constructor-async-work/instrument.server.ts

@@ -0,0 +1,6 @@
+import { defineCloudflareOptions } from '@sentry/cloudflare';
+
+export default defineCloudflareOptions((env: { SENTRY_DSN: string }) => ({
+  dsn: env.SENTRY_DSN,
+  tracesSampleRate: 1.0,
+}));

dev-packages/cloudflare-integration-tests/suites/durableobject/constructor-async-work/test.ts

@@ -0,0 +1,48 @@
+import type { Event, SerializedStreamedSpanContainer } from '@sentry/core';
+import { SENTRY_OP, SENTRY_ORIGIN, URL_PATH } from '@sentry/conventions/attributes';
+import { expect, it } from 'vitest';
+import { createRunner } from '../../../runner';
+
+// Every envelope of both requests is expected, and `failOnUnexpected` fails the test on any other one.
+// All of them are sent after the constructor work ran, so an error or span from that work would arrive
+// before the runner completes.
+it('does not capture errors a Durable Object catches in work its constructor started', async ({ signal }) => {
+  const runner = createRunner(__dirname)
+    .unordered()
+    .failOnUnexpected()
+    .expect(envelope => {
+      expect(envelope[1][0][0].type).toBe('event');
+      expect((envelope[1][0][1] as Event).message).toBe('block-concurrency-while ping: degraded');
+    })
+    .expect(envelope => {
+      expect(envelope[1][0][0].type).toBe('event');
+      expect((envelope[1][0][1] as Event).message).toBe('async-method ping: degraded');
+    })
+    .expectN(2, envelope => {
+      expect(envelope[1][0][0].type).toBe('span');
+      const container = envelope[1][0][1] as SerializedStreamedSpanContainer;
+      expect(container.items.map(item => item.name)).toEqual(['ping']);
+      expect(container.items[0]?.attributes[SENTRY_OP]?.value).toBe('rpc');
+      expect(container.items[0]?.attributes[SENTRY_ORIGIN]?.value).toBe('auto.faas.cloudflare.durable_object');
+    })
+    .expect(envelope => {
+      expect(envelope[1][0][0].type).toBe('span');
+      const container = envelope[1][0][1] as SerializedStreamedSpanContainer;
+      expect(container.items.map(item => item.attributes[URL_PATH]?.value)).toEqual(['/block-concurrency-while']);
+      expect(container.items[0]?.attributes[SENTRY_OP]?.value).toBe('http.server');
+    })
+    .expect(envelope => {
+      expect(envelope[1][0][0].type).toBe('span');
+      const container = envelope[1][0][1] as SerializedStreamedSpanContainer;
+      expect(container.items.map(item => item.attributes[URL_PATH]?.value)).toEqual(['/async-method']);
+      expect(container.items[0]?.attributes[SENTRY_OP]?.value).toBe('http.server');
+    })
+    .start(signal);
+
+  const blockConcurrencyResponse = await runner.makeRequest<string>('get', '/block-concurrency-while');
+  const asyncMethodResponse = await runner.makeRequest<string>('get', '/async-method');
+
+  expect(blockConcurrencyResponse).toBe('degraded');
+  expect(asyncMethodResponse).toBe('degraded');
+  await runner.completed();
+});

dev-packages/cloudflare-integration-tests/suites/durableobject/constructor-async-work/vite.config.mts

@@ -0,0 +1,7 @@
+import { cloudflare } from '@cloudflare/vite-plugin';
+import { sentryCloudflareVitePlugin } from '@sentry/cloudflare/vite';
+import { defineConfig } from 'vite';
+
+export default defineConfig({
+  plugins: [cloudflare(), sentryCloudflareVitePlugin()],
+});

dev-packages/cloudflare-integration-tests/suites/durableobject/constructor-async-work/wrangler.jsonc

@@ -0,0 +1,14 @@
+{
+  "$schema": "../../../node_modules/wrangler/config-schema.json",
+  "name": "durableobject-constructor-async-work-worker",
+  "main": "index.ts",
+  "compatibility_date": "2025-06-17",
+  "compatibility_flags": ["nodejs_compat"],
+  "durable_objects": {
+    "bindings": [
+      { "name": "BLOCK_CONCURRENCY_DURABLE_OBJECT", "class_name": "BlockConcurrencyDurableObject" },
+      { "name": "ASYNC_METHOD_DURABLE_OBJECT", "class_name": "AsyncMethodDurableObject" },
+    ],
+  },
+  "migrations": [{ "tag": "v1", "new_sqlite_classes": ["BlockConcurrencyDurableObject", "AsyncMethodDurableObject"] }],
+}

packages/cloudflare/src/durableobject.ts

@@ -10,6 +10,7 @@ import { instrumentDurableObjectHandlers } from './instrumentations/instrumentDu
 import { instrumentEnv } from './instrumentations/worker/instrumentEnv';
 import { getFinalOptions } from './options';
 import { instrumentContext } from './utils/instrumentContext';
+import { withConstructionIsolationScope } from './utils/invocationScope';
 import { hasRpcMeta } from './utils/rpcMeta';
 import { instrumentCloudflareAgent } from './instrumentations/agents';
 import type { DefaultEnv, ResolveEnv, StrictCloudflareOptions } from './types';
@@ -67,7 +68,9 @@ export function constructInstrumentedDurableObject<E, T extends DurableObject<E>
   // Pass `newTarget` so that subclasses of the instrumented class (e.g. the wrapper classes
   // created by wrangler's local dev tooling or `@cloudflare/vitest-pool-workers`) keep their
   // own prototype — otherwise subclass methods disappear and `instanceof` checks break.
-  const obj = Reflect.construct(target, [context, instrumentedEnv], newTarget) as T;
+  const obj = withConstructionIsolationScope(
+    () => Reflect.construct(target, [context, instrumentedEnv], newTarget) as T,
+  );
 
   const frameworkManagedMethods = resolveFrameworkManagedMethods(
     prototype,
@@ -298,9 +301,10 @@ function createRpcPrototypeWrapper(methodName: string, originalMethod: Unchecked
   const wrapper = function (this: unknown, ...args: unknown[]): unknown {
     const traced = hasRpcMeta(args);
 
-    // workerd dispatches an incoming RPC call outside any async context, so a call made while an
-    // invocation is already in flight comes from the instance itself (`this.helper()` inside
-    // `fetch`, `alarm` or another RPC method). Check that before touching per-instance state.
+    // workerd dispatches an incoming RPC call outside any async context, so a call made on any other
+    // isolation scope comes from the instance itself (`this.helper()` inside `fetch`, `alarm`,
+    // another RPC method or async work the constructor started). Check that before touching
+    // per-instance state.
     if (!traced && getIsolationScope() !== getDefaultIsolationScope()) {
       return Reflect.apply(originalMethod, this, args);
     }

packages/cloudflare/src/utils/invocationScope.ts

@@ -2,6 +2,27 @@ import { getDefaultIsolationScope, getIsolationScope, type Scope, withIsolationS
 import type { ExecutionContextCompat } from '../executionContext';
 import { setInvocationState } from './invocationContext';
 
+const constructionScopes = new WeakSet<Scope>();
+
+/**
+ * Runs a Durable Object constructor on a forked isolation scope.
+ *
+ * Async work the constructor starts, such as a `blockConcurrencyWhile` callback, runs after the RPC
+ * wrappers are installed and inherits this scope, so the calls it makes to the instance's own methods
+ * are not treated as incoming RPC calls. The scope is not an invocation: it has no invocation state,
+ * and an instrumented handler that this work calls still forks a scope of its own.
+ */
+export function withConstructionIsolationScope<T>(callback: () => T): T {
+  if (getIsolationScope() !== getDefaultIsolationScope()) {
+    return callback();
+  }
+
+  return withIsolationScope(scope => {
+    constructionScopes.add(scope);
+    return callback();
+  });
+}
+
 /**
  * Runs `callback` on the isolation scope for the current invocation.
  *
@@ -19,14 +40,15 @@ import { setInvocationState } from './invocationContext';
  *
  * The AsyncLocalStorage strategy hands the default isolation scope back whenever no invocation is in
  * flight, and a forked one while inside `withIsolationScope`. Reference-comparing against the default
- * is therefore enough to tell the two cases apart. The stack fallback does not fork, so it reports the
- * default scope even inside an invocation; there the fork degrades to a no-op, which the stack strategy
- * tolerates. This matches the approach used by `patchEventHandler` in Nuxt.
+ * and the construction scopes (see {@link withConstructionIsolationScope}) is therefore enough to tell
+ * the two cases apart. The stack fallback does not fork, so it reports the default scope even inside an
+ * invocation; there the fork degrades to a no-op, which the stack strategy tolerates. This matches the
+ * approach used by `patchEventHandler` in Nuxt.
  */
 export function withInvocationIsolationScope<T>(callback: (scope: Scope) => T, context?: ExecutionContextCompat): T {
   const isolationScope = getIsolationScope();
 
-  const isEntryPoint = isolationScope === getDefaultIsolationScope();
+  const isEntryPoint = isolationScope === getDefaultIsolationScope() || constructionScopes.has(isolationScope);
   const newIsolationScope = isEntryPoint ? isolationScope.clone() : isolationScope;
 
   if (isEntryPoint) {

packages/cloudflare/test/durableobject.test.ts

@@ -216,6 +216,62 @@ describe('instrumentDurableObjectWithSentry', () => {
     expect(events[2]?.user).toBeUndefined();
   });
 
+  // Work the constructor starts shares one scope, so a handler it calls must not reuse that scope.
+  it('Built-in handlers called from work the constructor started each get their own isolation scope', async () => {
+    const events: Event[] = [];
+    const waits: Promise<unknown>[] = [];
+    const mockContext = {
+      waitUntil: vi.fn((promise: Promise<unknown>) => {
+        waits.push(promise);
+      }),
+      blockConcurrencyWhile: (callback: () => Promise<unknown>) => Promise.resolve().then(callback),
+    } as any;
+
+    const testClass = class {
+      initialized: Promise<void>;
+
+      constructor(ctx: { blockConcurrencyWhile(callback: () => Promise<void>): Promise<void> }) {
+        this.initialized = ctx.blockConcurrencyWhile(async () => {
+          await this.webSocketMessage({}, 'seed');
+          await this.webSocketMessage({}, 'probe');
+        });
+      }
+
+      webSocketMessage(_ws: unknown, message: string) {
+        if (message === 'seed') {
+          SentryCore.setTag('seeded_tag', 'from-seeding-message');
+          SentryCore.setUser({ id: 'user-from-seeding-message' });
+        }
+
+        SentryCore.captureMessage(message);
+      }
+    };
+    const obj = Reflect.construct(
+      instrumentDurableObjectWithSentry(
+        () => ({
+          dsn: 'https://public@dsn.ingest.sentry.io/1337',
+          beforeSend(event: Event) {
+            events.push(event);
+            return null;
+          },
+        }),
+        testClass as any,
+      ),
+      [mockContext, {} as any],
+    );
+
+    await obj.initialized;
+    await Promise.all(waits);
+
+    expect(events.map(event => event.message)).toEqual(['seed', 'probe']);
+    // Guards the assertions below against passing vacuously.
+    expect(events[0]?.tags?.seeded_tag).toBe('from-seeding-message');
+    expect(events[0]?.user).toEqual({ id: 'user-from-seeding-message' });
+
+    expect(events[1]?.tags?.seeded_tag).toBeUndefined();
+    expect(events[1]?.user).toBeUndefined();
+  });
+
   it('Built-in durable object methods are always instrumented', () => {
     const testClass = class {
       fetch() {}
@@ -654,6 +710,9 @@ describe('instrumentDurableObjectWithSentry', () => {
       const waitUntil = vi.fn((promise: Promise<unknown>) => {
         waits.push(promise);
       });
+      // Like workerd, runs the callback after the constructor returns, in the async context of the caller.
+      const blockConcurrencyWhile = (callback: () => Promise<unknown>): Promise<unknown> =>
+        Promise.resolve().then(callback);
 
       const instrumented = instrumentDurableObjectWithSentry(
         () => ({
@@ -675,7 +734,7 @@ describe('instrumentDurableObjectWithSentry', () => {
         }),
         testClass as any,
       );
-      const obj = Reflect.construct(instrumented, [{ waitUntil }, {}]) as InstanceType<C>;
+      const obj = Reflect.construct(instrumented, [{ waitUntil, blockConcurrencyWhile }, {}]) as InstanceType<C>;
       const settle = async (): Promise<void> => {
         while (waits.length) {
           await Promise.all(waits.splice(0));
@@ -769,6 +828,42 @@ describe('instrumentDurableObjectWithSentry', () => {
       expect(waitUntil).toHaveBeenCalledOnce();
     });
 
+    it('does not instrument calls from a blockConcurrencyWhile callback the constructor started', async () => {
+      const { obj, events, waitUntil, settle } = setup(
+        class {
+          failure?: Error;
+          initialized: Promise<void>;
+
+          constructor(ctx: { blockConcurrencyWhile(callback: () => Promise<void>): Promise<void> }) {
+            this.initialized = ctx.blockConcurrencyWhile(async () => {
+              try {
+                this.init();
+              } catch (error) {
+                this.failure = error as Error;
+              }
+            });
+          }
+
+          init(): void {
+            throw new Error('Init failed');
+          }
+
+          async ping(): Promise<string> {
+            const status = this.failure ? 'degraded' : 'ok';
+            SentryCore.captureMessage(`ping: ${status}`);
+            return status;
+          }
+        },
+      );
+
+      await obj.initialized;
+      await expect(obj.ping()).resolves.toBe('degraded');
+      await settle();
+
+      expect(events.map(event => event.message)).toEqual(['ping: degraded']);
+      expect(waitUntil).toHaveBeenCalledOnce();
+    });
+
     it('continues the caller trace when the call carries trace metadata', async () => {
       const { obj, events, transactions, settle } = setup(
         class {