fixup! fix(cloudflare): Fix instrumentDurableObjectWithSentry breaking Cloudflare Agents

Author: JPeer264

packages/cloudflare/src/request.ts

@@ -19,6 +19,11 @@ import { addCloudResourceContext, addCultureContext, addRequest } from './scope-
 import { init } from './sdk';
 import { classifyResponseStreaming } from './utils/streaming';
 
+function getRequestErrorMechanismType(context: ExecutionContext | undefined): string {
+  // Durable Object fetch handlers use DO state as context (see instrumentDurableObjectWithSentry)
+  return context && 'storage' in context ? 'auto.faas.cloudflare.durable_object' : 'auto.http.cloudflare';
+}
+
 interface RequestHandlerWrapperOptions {
   options: CloudflareOptions;
   request: Request<unknown, IncomingRequestCfProperties<unknown> | CfProperties<unknown>>;
@@ -53,6 +58,7 @@ export function wrapRequestHandler(
     // it acquires the lock, then flushAndDispose tries to wait for the same lock,
     // creating a deadlock.
     const waitUntil = context ? getOriginalWaitUntil(context)?.bind(context) : undefined;
+    const errorMechanismType = getRequestErrorMechanismType(context);
 
     const client = init({ ...options, ctx: context });
     isolationScope.setClient(client);
@@ -96,7 +102,7 @@ export function wrapRequestHandler(
         return await handler();
       } catch (e) {
         if (captureErrors) {
-          captureException(e, { mechanism: { handled: false, type: 'auto.http.cloudflare' } });
+          captureException(e, { mechanism: { handled: false, type: errorMechanismType } });
         }
         throw e;
       } finally {
@@ -129,7 +135,7 @@ export function wrapRequestHandler(
           } catch (e) {
             span.end();
             if (captureErrors) {
-              captureException(e, { mechanism: { handled: false, type: 'auto.http.cloudflare' } });
+              captureException(e, { mechanism: { handled: false, type: errorMechanismType } });
             }
             waitUntil?.(flushAndDispose(client));
             throw e;

packages/cloudflare/src/wrapMethodWithSentry.ts

@@ -1,5 +1,5 @@
 import type { DurableObjectStorage } from '@cloudflare/workers-types';
-import type { SerializedTraceData } from '@sentry/core';
+import type { SerializedTraceData, Span } from '@sentry/core';
 import {
   captureException,
   continueTrace,
@@ -18,13 +18,40 @@ import { flushAndDispose } from './flush';
 import { ensureInstrumented } from './instrument';
 import { init } from './sdk';
 import { extractRpcMeta } from './utils/rpcMeta';
-import { buildSpanLinks, getStoredSpanContext, storeSpanContext } from './utils/traceLinks';
+import {
+  buildSpanLinks,
+  getStoredSpanContext,
+  storeSpanContext,
+} from './utils/traceLinks';
 
 /** Extended DurableObjectState with originalStorage exposed by instrumentContext */
 interface InstrumentedDurableObjectState extends DurableObjectState {
   originalStorage?: DurableObjectStorage;
 }
 
+/**
+ * Resolves uninstrumented DO storage for the current invocation.
+ * Prefer `thisArg.ctx` (the live Durable Object instance) over the context captured at
+ * construction time to avoid cross-DO I/O errors in the same isolate.
+ */
+function resolveOriginalStorage(
+  context: ExecutionContext | InstrumentedDurableObjectState | undefined,
+  thisArg: unknown,
+): DurableObjectStorage | undefined {
+  if (thisArg && typeof thisArg === 'object' && 'ctx' in thisArg) {
+    const doCtx = (thisArg as { ctx: InstrumentedDurableObjectState }).ctx;
+    if (doCtx?.originalStorage) {
+      return doCtx.originalStorage;
+    }
+  }
+
+  if (context && 'originalStorage' in context && context.originalStorage) {
+    return context.originalStorage;
+  }
+
+  return undefined;
+}
+
 type MethodWrapperOptions = {
   spanName?: string;
   spanOp?: string;
@@ -94,7 +121,7 @@ export function wrapMethodWithSentry<T extends OriginalMethod>(
             const context: typeof wrapperOptions.context | undefined = wrapperOptions.context;
 
             const waitUntil = context?.waitUntil?.bind?.(context);
-            const storage = context && 'originalStorage' in context ? context.originalStorage : undefined;
+            const storage = resolveOriginalStorage(context, thisArg);
 
             let scopeClient = scope.getClient();
             // Check if client exists AND is still usable (transport not disposed)

packages/cloudflare/test/traceLinks.test.ts

@@ -82,6 +82,17 @@ describe('traceLinks', () => {
       expect(mockStorage.kv.put).not.toHaveBeenCalled();
     });
 
+    it('silently ignores sync read errors', () => {
+      const mockStorage = createMockStorage();
+      mockStorage.kv.get = vi.fn().mockImplementation(() => {
+        throw new Error('Cannot perform I/O on behalf of a different Durable Object');
+      });
+
+      const result = getStoredSpanContext(mockStorage, 'alarm');
+
+      expect(result).toBeUndefined();
+    });
+
     it('silently ignores storage errors', () => {
       const mockSpanContext = {
         traceId: 'abc123def456789012345678901234ab',