feat(cloudflare): Support basic WorkerEntrypoint

Author: JPeer264

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": []
+}

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

@@ -0,0 +1,43 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig.json to read more about this file */
+
+    /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    "target": "es2021",
+    /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    "lib": ["es2021"],
+    /* Specify what JSX code is generated. */
+    "jsx": "react-jsx",
+
+    /* Specify what module code is generated. */
+    "module": "es2022",
+    /* Specify how TypeScript looks up a file from a given module specifier. */
+    "moduleResolution": "Bundler",
+    /* Enable importing .json files */
+    "resolveJsonModule": true,
+
+    /* Allow JavaScript files to be a part of your program. Use the `checkJS` option to get errors from these files. */
+    "allowJs": true,
+    /* Enable error reporting in type-checked JavaScript files. */
+    "checkJs": false,
+
+    /* Disable emitting files from a compilation. */
+    "noEmit": true,
+
+    /* Ensure that each file can be safely transpiled without relying on other imports. */
+    "isolatedModules": true,
+    /* Allow 'import x from y' when a module doesn't have a default export. */
+    "allowSyntheticDefaultImports": true,
+    /* Ensure that casing is correct in imports. */
+    "forceConsistentCasingInFileNames": true,
+
+    /* Enable all strict type-checking options. */
+    "strict": true,
+
+    /* Skip type checking all .d.ts files. */
+    "skipLibCheck": true,
+    "types": ["./worker-configuration.d.ts"]
+  },
+  "exclude": ["test"],
+  "include": ["src/**/*.ts"]
+}

dev-packages/e2e-tests/test-applications/cloudflare-workersentrypoint/vitest.config.mts

@@ -0,0 +1,11 @@
+import { defineWorkersConfig } from '@cloudflare/vitest-pool-workers/config';
+
+export default defineWorkersConfig({
+  test: {
+    poolOptions: {
+      workers: {
+        wrangler: { configPath: './wrangler.toml' },
+      },
+    },
+  },
+});