fix(cloudflare): Instrument custom WorkerEntrypoint RPC methods

Author: akshitsinha

CHANGELOG.md

@@ -6,6 +6,8 @@
 
 Work in this release was contributed by @dobladov and @PeterWadie. Thank you for your contributions!
 
+- feat(cloudflare): Instrument custom WorkerEntrypoint RPC receiver methods
+
 ## 10.65.0
 
 - feat(angular): Set `url` attributes on pageload and navigation spans ([#21985](https://github.com/getsentry/sentry-javascript/pull/21985))

dev-packages/cloudflare-integration-tests/suites/tracing/propagation/worker-workerentrypoint-rpc/index-sub-worker.ts

@@ -5,7 +5,17 @@ interface Env {
   SENTRY_DSN: string;
 }
 
-class MySubWorkerEntrypointBase extends WorkerEntrypoint {
+interface Props {
+  accountId: string;
+}
+
+class BaseEntrypoint extends WorkerEntrypoint<Env, Props> {
+  inherited(value: string): string {
+    return value;
+  }
+}
+
+class MySubWorkerEntrypointBase extends BaseEntrypoint {
   async fetch(request: Request): Promise<Response> {
     const url = new URL(request.url);
 
@@ -20,13 +30,30 @@ class MySubWorkerEntrypointBase extends WorkerEntrypoint {
 
     return new Response('Not found', { status: 404 });
   }
+
+  get(key: string): { argumentCount: number; key: string } {
+    Sentry.setTag('key', key);
+    return { argumentCount: arguments.length, key };
+  }
+
+  throwError(): never {
+    throw new Error('custom RPC receiver failed');
+  }
 }
 
-export default Sentry.withSentry(
+export const BindingEntrypoint = Sentry.withSentry(
   (env: Env) => ({
     dsn: env.SENTRY_DSN,
     tracesSampleRate: 1.0,
     enableRpcTracePropagation: true,
+    initialScope: { tags: { initial_scope: 'applied' } },
+    beforeSend(event) {
+      event.tags = { ...event.tags, before_send: 'applied' };
+      return event;
+    },
+    transportOptions: { fetch: fetch.bind(globalThis) },
   }),
   MySubWorkerEntrypointBase,
 );
+
+export default BindingEntrypoint;

dev-packages/cloudflare-integration-tests/suites/tracing/propagation/worker-workerentrypoint-rpc/index.ts

@@ -1,10 +1,26 @@
 import * as Sentry from '@sentry/cloudflare';
+import { WorkerEntrypoint, exports as workerExports } from 'cloudflare:workers';
 
 interface Env {
   SENTRY_DSN: string;
-  SUB_WORKER: Fetcher;
+  SUB_WORKER: Fetcher & {
+    get(key: string): Promise<{ argumentCount: number; key: string }>;
+    inherited(value: string): Promise<string>;
+    throwError(): Promise<never>;
+  };
 }
 
+class LoopbackEntrypointBase extends WorkerEntrypoint<Env> {
+  throwError(): never {
+    throw new Error('loopback RPC receiver failed');
+  }
+}
+
+export const LoopbackEntrypoint = Sentry.withSentry(
+  (env: Env) => ({ dsn: env.SENTRY_DSN, tracesSampleRate: 0 }),
+  LoopbackEntrypointBase,
+);
+
 export default Sentry.withSentry(
   (env: Env) => ({
     dsn: env.SENTRY_DSN,
@@ -27,6 +43,30 @@ export default Sentry.withSentry(
         return new Response(text);
       }
 
+      if (url.pathname === '/call-entrypoint-rpc') {
+        const result = await env.SUB_WORKER.get('feature-key');
+        const inherited = await env.SUB_WORKER.inherited('base-value');
+        return Response.json({ inherited, ...result });
+      }
+
+      if (url.pathname === '/call-entrypoint-rpc-error') {
+        try {
+          await env.SUB_WORKER.throwError();
+        } catch {
+          return new Response('fallback');
+        }
+      }
+
+      if (url.pathname === '/call-loopback-rpc-error') {
+        try {
+          await (
+            workerExports as unknown as { LoopbackEntrypoint: { throwError(): Promise<never> } }
+          ).LoopbackEntrypoint.throwError();
+        } catch {
+          return new Response('fallback');
+        }
+      }
+
       return new Response('Not found', { status: 404 });
     },
   } satisfies ExportedHandler<Env>,

dev-packages/cloudflare-integration-tests/suites/tracing/propagation/worker-workerentrypoint-rpc/test.ts

@@ -127,3 +127,89 @@ it('propagates trace for request with query params from Worker to WorkerEntrypoi
   expect(entrypointParentSpanId).toBeDefined();
   expect(entrypointParentSpanId).toBe(workerSpanId);
 });
+
+it('instruments inherited custom WorkerEntrypoint RPC methods and strips metadata', async ({ signal }) => {
+  let callerTraceId: string | undefined;
+  let receiverTraceId: string | undefined;
+
+  const runner = createRunner(__dirname)
+    .expect(envelope => {
+      const event = envelope[1]?.[0]?.[1] as Event;
+      expect(event.transaction).toBe('GET /call-entrypoint-rpc');
+      callerTraceId = event.contexts?.trace?.trace_id;
+    })
+    .expect(envelope => {
+      const event = envelope[1]?.[0]?.[1] as Event;
+      expect(event.transaction).toBe('get');
+      expect(event.contexts?.trace?.op).toBe('rpc');
+      receiverTraceId = event.contexts?.trace?.trace_id;
+    })
+    .expect(envelope => {
+      const event = envelope[1]?.[0]?.[1] as Event;
+      expect(event.transaction).toBe('inherited');
+      expect(event.contexts?.trace?.op).toBe('rpc');
+    })
+    .unordered()
+    .start(signal);
+
+  const response = await runner.makeRequest<{ argumentCount: number; inherited: string; key: string }>(
+    'get',
+    '/call-entrypoint-rpc',
+  );
+  expect(response).toEqual({ argumentCount: 1, inherited: 'base-value', key: 'feature-key' });
+
+  await runner.completed();
+  expect(receiverTraceId).toBe(callerTraceId);
+});
+
+it('captures errors thrown by custom WorkerEntrypoint RPC methods', async ({ signal }) => {
+  const runner = createRunner(__dirname)
+    .expect(envelope => {
+      const event = envelope[1]?.[0]?.[1] as Event;
+      expect(event.exception?.values?.[0]?.value).toBe('custom RPC receiver failed');
+      expect(event.exception?.values?.[0]?.mechanism).toEqual({
+        handled: false,
+        type: 'auto.faas.cloudflare.worker_entrypoint',
+      });
+      expect(event.tags?.initial_scope).toBe('applied');
+      expect(event.tags?.before_send).toBe('applied');
+    })
+    .expect(envelope => {
+      const event = envelope[1]?.[0]?.[1] as Event;
+      expect(event.transaction).toBe('throwError');
+    })
+    .expect(envelope => {
+      const event = envelope[1]?.[0]?.[1] as Event;
+      expect(event.transaction).toBe('GET /call-entrypoint-rpc-error');
+    })
+    .unordered()
+    .start(signal);
+
+  const response = await runner.makeRequest<string>('get', '/call-entrypoint-rpc-error');
+  expect(response).toBe('fallback');
+
+  await runner.completed();
+});
+
+it('captures errors from loopback WorkerEntrypoint RPC without trace propagation', async ({ signal }) => {
+  const runner = createRunner(__dirname)
+    .expect(envelope => {
+      const event = envelope[1]?.[0]?.[1] as Event;
+      expect(event.exception?.values?.[0]?.value).toBe('loopback RPC receiver failed');
+      expect(event.exception?.values?.[0]?.mechanism).toEqual({
+        handled: false,
+        type: 'auto.faas.cloudflare.worker_entrypoint',
+      });
+    })
+    .expect(envelope => {
+      const event = envelope[1]?.[0]?.[1] as Event;
+      expect(event.transaction).toBe('GET /call-loopback-rpc-error');
+    })
+    .unordered()
+    .start(signal);
+
+  const response = await runner.makeRequest<string>('get', '/call-loopback-rpc-error');
+  expect(response).toBe('fallback');
+
+  await runner.completed();
+});

dev-packages/cloudflare-integration-tests/suites/tracing/propagation/worker-workerentrypoint-rpc/wrangler.jsonc

@@ -7,6 +7,7 @@
     {
       "binding": "SUB_WORKER",
       "service": "cloudflare-worker-workerentrypoint-rpc-sub",
+      "entrypoint": "BindingEntrypoint",
     },
   ],
 }

packages/cloudflare/src/client.ts

@@ -177,9 +177,9 @@ interface BaseCloudflareOptions {
    * When enabled, trace context (sentry-trace + baggage) is propagated across:
    * - `stub.fetch()` calls to Durable Objects (via HTTP headers)
    * - Service binding `fetch()` calls (via HTTP headers)
-   * - RPC method calls to Durable Objects (via trailing argument)
+   * - RPC method calls to Durable Objects and WorkerEntrypoints (via trailing argument)
    *
-   * When enabled on the **receiver side** (DurableObject), the SDK will also:
+   * When enabled on the **receiver side** (DurableObject or WorkerEntrypoint), the SDK will also:
    * - Extract and continue traces from incoming RPC calls
    * - Create spans for each RPC method invocation
    * - Capture errors thrown by RPC methods
@@ -206,6 +206,12 @@ interface BaseCloudflareOptions {
    *   }),
    *   MyDOBase,
    * );
+   *
+   * // WorkerEntrypoint side (receiver)
+   * export const MyEntrypoint = Sentry.withSentry(
+   *   env => ({ dsn: env.SENTRY_DSN, enableRpcTracePropagation: true }),
+   *   MyEntrypointBase,
+   * );
    * ```
    */
   enableRpcTracePropagation?: boolean;