fix(cloudflare): Make sure enableRpcTracePropagation is ranked higher

Author: JPeer264

packages/cloudflare/src/durableobject.ts

@@ -133,7 +133,7 @@ export function instrumentDurableObjectWithSentry<
 
       // When using the deprecated `instrumentPrototypeMethods` option, always create spans.
       // When using the new `enableRpcTracePropagation`, only create spans when RPC metadata is present.
-      const alwaysTrace = options.instrumentPrototypeMethods !== undefined;
+      const alwaysTrace = options.enableRpcTracePropagation === undefined;
 
       // Return a Proxy that binds all methods to the original object and creates spans
       // for RPC calls that have Sentry trace context propagated.

packages/cloudflare/src/wrapMethodWithSentry.ts

@@ -1,5 +1,5 @@
 import type { DurableObjectStorage } from '@cloudflare/workers-types';
-import type { SerializedTraceData, Span } from '@sentry/core';
+import type { SerializedTraceData } from '@sentry/core';
 import {
   captureException,
   continueTrace,
@@ -18,11 +18,7 @@ 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 {

packages/cloudflare/test/durableobject.test.ts

@@ -81,6 +81,69 @@ describe('instrumentDurableObjectWithSentry', () => {
     expect(initCore).nthCalledWith(2, expect.any(Function), expect.objectContaining({ orgId: 2 }));
   });
 
+  it('does not create RPC spans without metadata when both RPC options are set', () => {
+    const startSpanSpy = vi.spyOn(SentryCore, 'startSpan');
+    vi.spyOn(SentryCore, 'getClient').mockReturnValue(undefined);
+
+    const testClass = class {
+      rpcMethod() {
+        return 'result';
+      }
+    };
+    const instrumented = instrumentDurableObjectWithSentry(
+      vi.fn().mockReturnValue({
+        enableRpcTracePropagation: true,
+        instrumentPrototypeMethods: true,
+      }),
+      testClass as any,
+    );
+    const obj = Reflect.construct(instrumented, []);
+
+    expect(obj.rpcMethod()).toBe('result');
+    expect(startSpanSpy).not.toHaveBeenCalled();
+  });
+
+  it('does not create RPC spans without metadata when enableRpcTracePropagation is true', () => {
+    const startSpanSpy = vi.spyOn(SentryCore, 'startSpan');
+    vi.spyOn(SentryCore, 'getClient').mockReturnValue(undefined);
+
+    const testClass = class {
+      rpcMethod() {
+        return 'result';
+      }
+    };
+    const instrumented = instrumentDurableObjectWithSentry(
+      vi.fn().mockReturnValue({
+        enableRpcTracePropagation: true,
+        instrumentPrototypeMethods: false,
+      }),
+      testClass as any,
+    );
+    const obj = Reflect.construct(instrumented, []);
+
+    expect(obj.rpcMethod()).toBe('result');
+    expect(startSpanSpy).not.toHaveBeenCalled();
+  });
+
+  it('creates RPC spans without metadata when using deprecated instrumentPrototypeMethods', () => {
+    const startSpanSpy = vi.spyOn(SentryCore, 'startSpan').mockImplementation((_, callback) => callback({} as any));
+    vi.spyOn(SentryCore, 'getClient').mockReturnValue(undefined);
+
+    const testClass = class {
+      rpcMethod() {
+        return 'result';
+      }
+    };
+    const instrumented = instrumentDurableObjectWithSentry(
+      vi.fn().mockReturnValue({ instrumentPrototypeMethods: true }),
+      testClass as any,
+    );
+    const obj = Reflect.construct(instrumented, []);
+
+    expect(obj.rpcMethod()).toBe('result');
+    expect(startSpanSpy).toHaveBeenCalled();
+  });
+
   it('Binds prototype methods to original object when enableRpcTracePropagation is true', () => {
     const testClass = class {
       method() {