Add WebSocket support and Sentry tracking in Cloudflare Workers

Implemented WebSocket handling with message reception and connection closure logic, including error recording in Sentry. Updated tests to verify WebSocket behaviors and added the "ws" package for WebSocket functionality.

Author: cod1k

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

@@ -24,7 +24,8 @@
     "@sentry-internal/test-utils": "link:../../../test-utils",
     "typescript": "^5.5.2",
     "vitest": "~3.2.0",
-    "wrangler": "^4.23.0"
+    "wrangler": "^4.23.0",
+    "ws": "^8.18.3"
   },
   "volta": {
     "extends": "../../package.json"

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

@@ -14,17 +14,42 @@ import * as Sentry from '@sentry/cloudflare';
 import { DurableObject } from "cloudflare:workers";
 
 class MyDurableObjectBase extends DurableObject<Env> {
-  async throwException(): Promise<string> {
-    throw new Error("Should be recorded in Sentry.")
-  }
+	private throwOnExit = new WeakMap<WebSocket, Error>();
+	async throwException(): Promise<void> {
+		throw new Error('Should be recorded in Sentry.');
+	}
 
-  async fetch(request: Request){
-    const {pathname} = new URL(request.url)
-    if(pathname === '/throwException'){
-      await this.throwException()
-    }
-    return new Response('DO is fine')
-  }
+	async fetch(request: Request) {
+		const { pathname } = new URL(request.url);
+		switch (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 });
+		}
+		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(

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

@@ -1,5 +1,6 @@
 import { expect, test } from '@playwright/test';
 import { waitForError } from '@sentry-internal/test-utils';
+import {WebSocket} from 'ws'
 
 test('Index page', async ({ baseURL }) => {
   const result = await fetch(baseURL!);
@@ -35,3 +36,47 @@ test('Request processed by DurableObject\'s fetch is recorded', async ({baseURL}
   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-workers', (event) => {
+    return event.exception?.values?.[0]?.mechanism?.type === 'cloudflare_durableobject';
+  });
+  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');
+})
+
+test('Websocket.webSocketClose', async ({baseURL}) => {
+  const eventWaiter = waitForError('cloudflare-workers', (event) => {
+    return event.exception?.values?.[0]?.mechanism?.type === 'cloudflare_durableobject';
+  });
+  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');
+})
+
+test('Websocket.webSocketClose', async ({baseURL}) => {
+  const eventWaiter = waitForError('cloudflare-workers', (event) => {
+    return event.exception?.values?.[0]?.mechanism?.type === 'cloudflare_durableobject';
+  });
+  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');
+})