feat(cloudflare): Support basic WorkerEntrypoint (#19884)

part of #15942 

This is a basic instrumentation for `WorkerEntrypoint`. There is no
extra `instrumentWorkerEntrypoint` exported, and should work directly
with `withSentry` OOTB:

```js
class MyWorker extends WorkerEntrypoint {}

export default Sentry.withSentry(() => ({}), MyWorker)
```

To support the full `WorkerEntrypoint` there is the need to instrument
[RPC
methods](#16898).
Without that we can't fully support `WorkerEntrypoint`s but just the
basics of it. This can be added once #19991 lands (it is safe to review
now and instrument the env in a separate PR)

--- 

If you look at the instrumentations themselves, there is no
`isInstrumented` or `markAsInstrumented`. The reason is that on the one
hand this is not required, as every request is spawning a new instance
of the `WorkerEntrypoint` and on the other hand it wouldn't work as it
would mark it as instrumented, but on the request the `fetch` is
overridden and not instrumented.

Author: JPeer264

CHANGELOG.md

@@ -4,6 +4,23 @@
 
 - "You miss 100 percent of the chances you don't take. — Wayne Gretzky" — Michael Scott
 
+- **feat(cloudflare): Support basic WorkerEntrypoint ([#19884](https://github.com/getsentry/sentry-javascript/pull/19884))**
+
+  `withSentry` now supports instrumenting classes extending Cloudflare's `WorkerEntrypoint`. This instruments `fetch`, `scheduled`, `queue`, and `tail` handlers.
+
+  ```ts
+  import * as Sentry from '@sentry/cloudflare';
+  import { WorkerEntrypoint } from 'cloudflare:workers';
+
+  class MyWorker extends WorkerEntrypoint {
+    async fetch(request: Request): Promise<Response> {
+      return new Response('Hello World!');
+    }
+  }
+
+  export default Sentry.withSentry(env => ({ dsn: env.SENTRY_DSN, tracesSampleRate: 1.0 }), MyWorker);
+  ```
+
 - **ref(core): Unify .do\* span ops to `gen_ai.generate_content` ([#20074](https://github.com/getsentry/sentry-javascript/pull/20074))**
 
   All Vercel AI `do*` spans (`ai.generateText.doGenerate`, `ai.streamText.doStream`, `ai.generateObject.doGenerate`, `ai.streamObject.doStream`) now use a single unified span op `gen_ai.generate_content` instead of separate ops like `gen_ai.generate_text`, `gen_ai.stream_text`, `gen_ai.generate_object`, and `gen_ai.stream_object`.

dev-packages/e2e-tests/test-applications/cloudflare-mcp/src/env.d.ts

@@ -1,7 +1,9 @@
 // Generated by Wrangler on Mon Jul 29 2024 21:44:31 GMT-0400 (Eastern Daylight Time)
 // by running `wrangler types`
-
-interface Env {
-  E2E_TEST_DSN: '';
-  MY_DURABLE_OBJECT: DurableObjectNamespace;
+declare namespace Cloudflare {
+  interface Env {
+    E2E_TEST_DSN: '';
+    MY_DURABLE_OBJECT: DurableObjectNamespace;
+  }
 }
+interface Env extends Cloudflare.Env {}

dev-packages/e2e-tests/test-applications/cloudflare-workersentrypoint/.gitignore

@@ -0,0 +1 @@
+.wrangler

dev-packages/e2e-tests/test-applications/cloudflare-workersentrypoint/.npmrc

@@ -0,0 +1,2 @@
+@sentry:registry=http://127.0.0.1:4873
+@sentry-internal:registry=http://127.0.0.1:4873

dev-packages/e2e-tests/test-applications/cloudflare-workersentrypoint/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "cloudflare-workersentrypoint",
+  "version": "0.0.0",
+  "private": true,
+  "scripts": {
+    "deploy": "wrangler deploy",
+    "dev": "wrangler dev --var \"E2E_TEST_DSN:$E2E_TEST_DSN\" --log-level=$(test $CI && echo 'none' || echo 'log')",
+    "build": "wrangler deploy --dry-run",
+    "test": "vitest --run",
+    "typecheck": "tsc --noEmit",
+    "cf-typegen": "wrangler types --strict-vars false",
+    "test:build": "pnpm install && pnpm build",
+    "test:assert": "pnpm typecheck && pnpm test:dev && pnpm test:prod",
+    "test:prod": "TEST_ENV=production playwright test",
+    "test:dev": "TEST_ENV=development playwright test"
+  },
+  "dependencies": {
+    "@sentry/cloudflare": "latest || *"
+  },
+  "devDependencies": {
+    "@playwright/test": "~1.56.0",
+    "@cloudflare/vitest-pool-workers": "^0.8.19",
+    "@cloudflare/workers-types": "^4.20240725.0",
+    "@sentry-internal/test-utils": "link:../../../test-utils",
+    "typescript": "^5.5.2",
+    "vitest": "~3.2.0",
+    "wrangler": "^4.61.0",
+    "ws": "^8.18.3"
+  },
+  "volta": {
+    "extends": "../../package.json"
+  },
+  "pnpm": {
+    "overrides": {
+      "strip-literal": "~2.0.0"
+    }
+  }
+}

dev-packages/e2e-tests/test-applications/cloudflare-workersentrypoint/playwright.config.ts

@@ -0,0 +1,22 @@
+import { getPlaywrightConfig } from '@sentry-internal/test-utils';
+const testEnv = process.env.TEST_ENV;
+
+if (!testEnv) {
+  throw new Error('No test env defined');
+}
+
+const APP_PORT = 38787;
+
+const config = getPlaywrightConfig(
+  {
+    startCommand: `pnpm dev --port ${APP_PORT}`,
+    port: APP_PORT,
+  },
+  {
+    // This comes with the risk of tests leaking into each other but the tests run quite slow so we should parallelize
+    workers: '100%',
+    retries: 0,
+  },
+);
+
+export default config;

dev-packages/e2e-tests/test-applications/cloudflare-workersentrypoint/src/index.ts

@@ -0,0 +1,123 @@
+/**
+ * Welcome to Cloudflare Workers! This is your first worker.
+ *
+ * - Run `npm run dev` in your terminal to start a development server
+ * - Open a browser tab at http://localhost:8787/ to see your worker in action
+ * - Run `npm run deploy` to publish your worker
+ *
+ * Bind resources to your worker in `wrangler.toml`. After adding bindings, a type definition for the
+ * `Env` object can be regenerated with `npm run cf-typegen`.
+ *
+ * Learn more at https://developers.cloudflare.com/workers/
+ */
+import * as Sentry from '@sentry/cloudflare';
+import { DurableObject, WorkerEntrypoint } from 'cloudflare:workers';
+
+class MyDurableObjectBase extends DurableObject<Env> {
+  private throwOnExit = new WeakMap<WebSocket, Error>();
+  async throwException(): Promise<void> {
+    throw new Error('Should be recorded in Sentry.');
+  }
+
+  async fetch(request: Request) {
+    const url = new URL(request.url);
+    switch (url.pathname) {
+      case '/throwException': {
+        await this.throwException();
+        break;
+      }
+      case '/ws': {
+        const webSocketPair = new WebSocketPair();
+        const [client, server] = Object.values(webSocketPair);
+        this.ctx.acceptWebSocket(server);
+        return new Response(null, { status: 101, webSocket: client });
+      }
+      case '/storage/put': {
+        await this.ctx.storage.put('test-key', 'test-value');
+        return new Response('Stored');
+      }
+      case '/storage/get': {
+        const value = await this.ctx.storage.get('test-key');
+        return new Response(`Got: ${value}`);
+      }
+    }
+    return new Response('DO is fine');
+  }
+
+  webSocketMessage(ws: WebSocket, message: string | ArrayBuffer): void | Promise<void> {
+    if (message === 'throwException') {
+      throw new Error('Should be recorded in Sentry: webSocketMessage');
+    } else if (message === 'throwOnExit') {
+      this.throwOnExit.set(ws, new Error('Should be recorded in Sentry: webSocketClose'));
+    }
+  }
+
+  webSocketClose(ws: WebSocket): void | Promise<void> {
+    if (this.throwOnExit.has(ws)) {
+      const error = this.throwOnExit.get(ws)!;
+      this.throwOnExit.delete(ws);
+      throw error;
+    }
+  }
+}
+
+export const MyDurableObject = Sentry.instrumentDurableObjectWithSentry(
+  (env: Env) => ({
+    dsn: env.E2E_TEST_DSN,
+    environment: 'qa', // dynamic sampling bias to keep transactions
+    tunnel: `http://localhost:3031/`, // proxy server
+    tracesSampleRate: 1.0,
+    sendDefaultPii: true,
+    transportOptions: {
+      // We are doing a lot of events at once in this test
+      bufferSize: 1000,
+    },
+    instrumentPrototypeMethods: true,
+  }),
+  MyDurableObjectBase,
+);
+
+class MyWorker extends WorkerEntrypoint {
+  async fetch(request: Request) {
+    const url = new URL(request.url);
+    switch (url.pathname) {
+      case '/rpc/throwException':
+        {
+          const id = this.env.MY_DURABLE_OBJECT.idFromName('foo');
+          const stub = this.env.MY_DURABLE_OBJECT.get(id) as DurableObjectStub<MyDurableObjectBase>;
+          try {
+            await stub.throwException();
+          } catch (e) {
+            //We will catch this to be sure not to log inside withSentry
+            return new Response(null, { status: 500 });
+          }
+        }
+        break;
+      case '/throwException':
+        throw new Error('To be recorded in Sentry.');
+      default:
+        if (url.pathname.startsWith('/pass-to-object/')) {
+          const id = this.env.MY_DURABLE_OBJECT.idFromName('foo');
+          const stub = this.env.MY_DURABLE_OBJECT.get(id) as DurableObjectStub<MyDurableObjectBase>;
+          url.pathname = url.pathname.replace('/pass-to-object/', '');
+          return stub.fetch(new Request(url, request));
+        }
+    }
+    return new Response('Hello World!');
+  }
+}
+
+export default Sentry.withSentry(
+  env => ({
+    dsn: env.E2E_TEST_DSN,
+    environment: 'qa', // dynamic sampling bias to keep transactions
+    tunnel: `http://localhost:3031/`, // proxy server
+    tracesSampleRate: 1.0,
+    sendDefaultPii: true,
+    transportOptions: {
+      // We are doing a lot of events at once in this test
+      bufferSize: 1000,
+    },
+  }),
+  MyWorker,
+);

dev-packages/e2e-tests/test-applications/cloudflare-workersentrypoint/start-event-proxy.mjs

@@ -0,0 +1,6 @@
+import { startEventProxyServer } from '@sentry-internal/test-utils';
+
+startEventProxyServer({
+  port: 3031,
+  proxyServerName: 'cloudflare-workersentrypoint',
+});

dev-packages/e2e-tests/test-applications/cloudflare-workersentrypoint/tests/index.test.ts

@@ -0,0 +1,101 @@
+import { expect, test } from '@playwright/test';
+import { waitForError, waitForRequest, waitForTransaction } from '@sentry-internal/test-utils';
+import { SDK_VERSION } from '@sentry/cloudflare';
+import { WebSocket } from 'ws';
+
+test('Index page', async ({ baseURL }) => {
+  const result = await fetch(baseURL!);
+  expect(result.status).toBe(200);
+  await expect(result.text()).resolves.toBe('Hello World!');
+});
+
+test("worker's withSentry", async ({ baseURL }) => {
+  const eventWaiter = waitForError('cloudflare-workersentrypoint', event => {
+    return event.exception?.values?.[0]?.mechanism?.type === 'auto.http.cloudflare';
+  });
+  const response = await fetch(`${baseURL}/throwException`);
+  expect(response.status).toBe(500);
+  const event = await eventWaiter;
+  expect(event.exception?.values?.[0]?.value).toBe('To be recorded in Sentry.');
+});
+
+test('RPC method which throws an exception to be logged to sentry', async ({ baseURL }) => {
+  const eventWaiter = waitForError('cloudflare-workersentrypoint', event => {
+    return event.exception?.values?.[0]?.mechanism?.type === 'auto.faas.cloudflare.durable_object';
+  });
+  const response = await fetch(`${baseURL}/rpc/throwException`);
+  expect(response.status).toBe(500);
+  const event = await eventWaiter;
+  expect(event.exception?.values?.[0]?.value).toBe('Should be recorded in Sentry.');
+});
+
+test("Request processed by DurableObject's fetch is recorded", async ({ baseURL }) => {
+  const eventWaiter = waitForError('cloudflare-workersentrypoint', event => {
+    return event.exception?.values?.[0]?.mechanism?.type === 'auto.faas.cloudflare.durable_object';
+  });
+  const response = await fetch(`${baseURL}/pass-to-object/throwException`);
+  expect(response.status).toBe(500);
+  const event = await eventWaiter;
+  expect(event.exception?.values?.[0]?.value).toBe('Should be recorded in Sentry.');
+});
+
+test('Websocket.webSocketMessage', async ({ baseURL }) => {
+  const eventWaiter = waitForError('cloudflare-workersentrypoint', event => {
+    return !!event.exception?.values?.[0];
+  });
+  const url = new URL('/pass-to-object/ws', baseURL);
+  url.protocol = url.protocol.replace('http', 'ws');
+  const socket = new WebSocket(url.toString());
+  socket.addEventListener('open', () => {
+    socket.send('throwException');
+  });
+  const event = await eventWaiter;
+  socket.close();
+  expect(event.exception?.values?.[0]?.value).toBe('Should be recorded in Sentry: webSocketMessage');
+  expect(event.exception?.values?.[0]?.mechanism?.type).toBe('auto.faas.cloudflare.durable_object');
+});
+
+test('Websocket.webSocketClose', async ({ baseURL }) => {
+  const eventWaiter = waitForError('cloudflare-workersentrypoint', event => {
+    return !!event.exception?.values?.[0];
+  });
+  const url = new URL('/pass-to-object/ws', baseURL);
+  url.protocol = url.protocol.replace('http', 'ws');
+  const socket = new WebSocket(url.toString());
+  socket.addEventListener('open', () => {
+    socket.send('throwOnExit');
+    socket.close();
+  });
+  const event = await eventWaiter;
+  expect(event.exception?.values?.[0]?.value).toBe('Should be recorded in Sentry: webSocketClose');
+  expect(event.exception?.values?.[0]?.mechanism?.type).toBe('auto.faas.cloudflare.durable_object');
+});
+
+test('sends user-agent header with SDK name and version in envelope requests', async ({ baseURL }) => {
+  const requestPromise = waitForRequest('cloudflare-workersentrypoint', () => true);
+
+  await fetch(`${baseURL}/throwException`);
+
+  const request = await requestPromise;
+
+  expect(request.rawProxyRequestHeaders).toMatchObject({
+    'user-agent': `sentry.javascript.cloudflare/${SDK_VERSION}`,
+  });
+});
+
+test('Storage operations create spans in Durable Object transactions', async ({ baseURL }) => {
+  const transactionWaiter = waitForTransaction('cloudflare-workersentrypoint', event => {
+    return event.spans?.some(span => span.op === 'db' && span.description === 'durable_object_storage_put') ?? false;
+  });
+
+  const response = await fetch(`${baseURL}/pass-to-object/storage/put`);
+  expect(response.status).toBe(200);
+
+  const transaction = await transactionWaiter;
+  const putSpan = transaction.spans?.find(span => span.description === 'durable_object_storage_put');
+
+  expect(putSpan).toBeDefined();
+  expect(putSpan?.op).toBe('db');
+  expect(putSpan?.data?.['db.system.name']).toBe('cloudflare.durable_object.storage');
+  expect(putSpan?.data?.['db.operation.name']).toBe('put');
+});

dev-packages/e2e-tests/test-applications/cloudflare-workersentrypoint/tests/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "types": ["@cloudflare/vitest-pool-workers"]
+  },
+  "include": ["./**/*.ts"],
+  "exclude": []
+}