Merge pull request #84 from MatthewWid/session-benchmarks

Benchmark suite for pushing events to individual clients

Author: MatthewWid

examples/benchmarks/benchmark.ts

@@ -1,6 +1,7 @@
-import {suite as suiteChannelPushManySessions} from "./suites/channel-push-many-sessions";
+import {suite as suiteChannelBroadcast} from "./suites/channel-broadcast";
+import {suite as suiteSessionPush} from "./suites/session-push";
 
-Promise.all([suiteChannelPushManySessions.setup()]).then((suites) => {
+Promise.all([suiteSessionPush.setup()]).then((suites) => {
 	for (const suite of suites) {
 		suite.run();
 	}

examples/benchmarks/lib/createClientPool.ts

@@ -1,28 +1,19 @@
-import EventSource from "eventsource";
+import type {EventSource} from "eventsource";
+import {createEventSource} from "./createEventSource";
 
-export interface ClientPoolOptions {
-	port: number;
-	numberOfClients?: number;
-}
+export type CleanupClientPool = () => void;
 
-export const createClientPool = async ({
-	port,
-	numberOfClients = 1,
-}: ClientPoolOptions): Promise<() => void> => {
-	const sources = new Set<EventSource>();
-	const listeners = new Set<Promise<unknown>>();
+export const createClientPool = async (
+	port: number,
+	numberOfClients = 1
+): Promise<CleanupClientPool> => {
+	const listeners = new Set<Promise<EventSource>>();
 
 	for (let index = 0; index < numberOfClients; ++index) {
-		const eventsource = new EventSource(`http://localhost:${port}`);
-		const listener = new Promise((resolve) =>
-			eventsource.addEventListener("open", resolve)
-		);
-
-		sources.add(eventsource);
-		listeners.add(listener);
+		listeners.add(createEventSource(port));
 	}
 
-	await Promise.all(listeners);
+	const sources = await Promise.all(listeners);
 
 	return () => {
 		for (const eventsource of sources) {

examples/benchmarks/lib/createEventSource.ts

@@ -0,0 +1,13 @@
+import {EventSource} from "eventsource";
+
+const createEventSource = (port: number, path = "/sse") => {
+	const url = `http://localhost:${port}${path}`;
+	const eventSource = new EventSource(url);
+
+	return new Promise<EventSource>((resolve, reject) => {
+		eventSource.addEventListener("open", () => resolve(eventSource));
+		eventSource.addEventListener("error", (error) => reject(error.message));
+	});
+};
+
+export {createEventSource};

examples/benchmarks/suites/channel-push-many-sessions.ts renamed to examples/benchmarks/suites/channel-broadcast.ts

@@ -1,5 +1,3 @@
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-
 import {createChannel, createSession} from "better-sse";
 // @ts-ignore
 import EasySse from "easy-server-sent-events";
@@ -8,25 +6,25 @@ import SseChannel from "sse-channel";
 import {createClientPool} from "../lib/createClientPool";
 import {Suite} from "./Suite";
 
-export const suite = new Suite("Push events with channels", async () => {
+export const suite = new Suite("Broadcast events with channels", async () => {
 	const numberOfClients = 10;
 
 	await suite.addBenchmark("better-sse", async (server, port, listen) => {
-		let count = 0;
-
 		const channel = createChannel();
 
-		server.get("/", async (req, res) => {
+		server.get("/sse", async (req, res) => {
 			channel.register(await createSession(req, res));
 		});
 
 		await listen();
 
+		let count = 0;
+
 		return {
 			run: () => {
 				channel.broadcast(++count);
 			},
-			teardown: await createClientPool({port, numberOfClients}),
+			teardown: await createClientPool(port, numberOfClients),
 		};
 	});
 
@@ -35,7 +33,7 @@ export const suite = new Suite("Push events with channels", async () => {
 
 		const channel = new SseChannel({jsonEncode: true});
 
-		server.get("/", (req, res) => {
+		server.get("/sse", (req, res) => {
 			channel.addClient(req, res);
 		});
 
@@ -51,29 +49,29 @@ export const suite = new Suite("Push events with channels", async () => {
 					id: count,
 				});
 			},
-			teardown: await createClientPool({port, numberOfClients}),
+			teardown: await createClientPool(port, numberOfClients),
 		};
 	});
 
 	await suite.addBenchmark(
 		"easy-server-sent-events",
 		async (server, port, listen) => {
-			let count = 0;
-
-			const {SSE, send} = EasySse({endpoint: "/"});
+			const {SSE, send} = EasySse({endpoint: "/sse"});
 
-			server.get("/", (req, res, next) => {
+			server.get("/sse", (req, res, next) => {
 				SSE(req, res, next);
 				res.flushHeaders();
 			});
 
 			await listen();
 
+			let count = 0;
+
 			return {
 				run: () => {
 					send("all", "message", ++count);
 				},
-				teardown: await createClientPool({port, numberOfClients}),
+				teardown: await createClientPool(port, numberOfClients),
 			};
 		}
 	);

examples/benchmarks/suites/session-push.ts

@@ -0,0 +1,98 @@
+import {createServer as createRawHttpServer} from "node:http";
+import {type Session, createSession} from "better-sse";
+import type {Response as ExpressResponse} from "express";
+import SSE, {type Client} from "sse";
+// @ts-ignore
+import SseChannel from "sse-channel";
+import {createEventSource} from "../lib/createEventSource";
+import {Suite} from "./Suite";
+
+export const suite = new Suite("Push events with sessions", async () => {
+	await suite.addBenchmark("better-sse", async (server, port, listen) => {
+		let session: Session;
+
+		server.get("/sse", async (req, res) => {
+			session = await createSession(req, res);
+		});
+
+		await listen();
+
+		const eventSource = await createEventSource(port);
+
+		let count = 0;
+
+		return {
+			run: () => {
+				session.push(++count);
+			},
+			teardown: () => eventSource.close(),
+		};
+	});
+
+	await suite.addBenchmark("sse-channel", async (server, port, listen) => {
+		const channel = new SseChannel({jsonEncode: true});
+
+		let res: ExpressResponse;
+
+		server.get("/sse", (req, _res) => {
+			res = _res;
+			channel.addClient(req, res);
+		});
+
+		await listen();
+
+		const eventSource = await createEventSource(port);
+
+		let count = 0;
+
+		return {
+			run: () => {
+				++count;
+
+				channel.send(
+					{
+						event: "message",
+						data: count,
+						id: count,
+					},
+					[res]
+				);
+			},
+			teardown: () => eventSource.close(),
+		};
+	});
+
+	await suite.addBenchmark("sse", async (server) => {
+		const port = ++Suite.port;
+
+		// `sse` package cannot attach to an Express instance directly, so wrap with a raw Node HTTP server
+		const wrapper = createRawHttpServer(server);
+
+		const sse = new SSE(wrapper);
+
+		let client: Client;
+
+		sse.on("connection", (_client) => {
+			client = _client;
+		});
+
+		await new Promise<void>((resolve) => wrapper.listen(port, () => resolve()));
+
+		const eventSource = await createEventSource(port);
+
+		let count = 0;
+
+		return {
+			run: () => {
+				const stringified = (count++).toString();
+
+				client.send({
+					event: "message",
+					data: stringified,
+					id: stringified,
+				});
+			},
+			teardown: () => eventSource.close(),
+		};
+	});
+});

examples/package-lock.json

@@ -15,6 +15,7 @@
 		"express": "^4.21.1",
 		"node-os-utils": "^1.3.7",
 		"pem": "^1.14.8",
+		"sse": "^0.0.8",
 		"sse-channel": "^4.0.0",
 		"ts-node": "^10.9.2",
 		"ts-node-dev": "^2.0.0"
@@ -24,6 +25,7 @@
 		"@types/express": "^5.0.0",
 		"@types/node": "^20.16.12",
 		"@types/node-os-utils": "^1.3.4",
-		"@types/pem": "^1.14.4"
+		"@types/pem": "^1.14.4",
+		"@types/sse": "^0.0.0"
 	}
 }