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

Author: JPeer264

CHANGELOG.md

@@ -4,6 +4,8 @@
 
 - "You miss 100 percent of the chances you don't take. — Wayne Gretzky" — Michael Scott
 
+- **fix(cloudflare)**: Durable Object constructors now run in their own isolation scope. When work that the constructor starts, for example a `blockConcurrencyWhile` callback, calls a method of the instance, that call is no longer treated as an incoming RPC call, so an error the instance catches itself is no longer reported as unhandled. As a result, `Sentry.setTag()`, `setUser()` and `setContext()` in a constructor now apply only to that constructor work. They no longer reach later `fetch`, RPC or `alarm` invocations, because the scope they used to write to is shared by every Durable Object and handler in the isolate. Use `initialScope` for static data, and set per-instance data in each handler.
+
 ## 11.2.0
 
 ### Important Changes

packages/cloudflare/test/durableobject.test.ts

@@ -272,6 +272,54 @@ describe('instrumentDurableObjectWithSentry', () => {
     expect(events[1]?.user).toBeUndefined();
   });
 
+  // The only scope that all later invocations share is the default isolation scope of the isolate, so
+  // data set in the constructor stays in the constructor's own scope.
+  it('does not apply scope data set in the constructor to later invocations', async () => {
+    const events: Event[] = [];
+    const waits: Promise<unknown>[] = [];
+    const mockContext = {
+      waitUntil: vi.fn((promise: Promise<unknown>) => {
+        waits.push(promise);
+      }),
+    } as any;
+
+    const testClass = class {
+      constructor() {
+        SentryCore.setTag('constructor_tag', 'from-constructor');
+        SentryCore.setUser({ id: 'user-from-constructor' });
+      }
+
+      alarm() {
+        SentryCore.captureMessage('alarm');
+      }
+
+      rpcMethod() {
+        SentryCore.captureMessage('rpc');
+      }
+    };
+    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.alarm();
+    obj.rpcMethod();
+    await Promise.all(waits);
+
+    expect(events.map(event => event.message)).toEqual(['alarm', 'rpc']);
+    expect(events.map(event => event.tags?.constructor_tag)).toEqual([undefined, undefined]);
+    expect(events.map(event => event.user)).toEqual([undefined, undefined]);
+  });
+
   it('Built-in durable object methods are always instrumented', () => {
     const testClass = class {
       fetch() {}