@durable-streams/benchmarks 0.1.1 → 0.1.2

package/dist/index.cjs

@@ -0,0 +1,269 @@
+"use strict";
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const node_fs = __toESM(require("node:fs"));
+const vitest = __toESM(require("vitest"));
+const __durable_streams_client = __toESM(require("@durable-streams/client"));
+
+//#region src/index.ts
+const results = new Map();
+function recordResult(name, value, unit) {
+	if (!results.has(name)) results.set(name, {
+		values: [],
+		unit
+	});
+	results.get(name).values.push(value);
+}
+function calculateStats(values) {
+	const sorted = [...values].sort((a, b) => a - b);
+	const min = sorted[0];
+	const max = sorted[sorted.length - 1];
+	const mean = values.reduce((a, b) => a + b, 0) / values.length;
+	const p50 = sorted[Math.floor(sorted.length * .5)];
+	const p75 = sorted[Math.floor(sorted.length * .75)];
+	const p99 = sorted[Math.floor(sorted.length * .99)];
+	return {
+		min,
+		max,
+		mean,
+		p50,
+		p75,
+		p99
+	};
+}
+function printResults() {
+	console.log(`\n=== RESULTS SO FAR ===`);
+	const tableData = {};
+	for (const [name, data] of results.entries()) {
+		if (data.values.length === 0) continue;
+		const stats = calculateStats(data.values);
+		tableData[name] = {
+			Min: `${stats.min.toFixed(2)} ${data.unit}`,
+			Max: `${stats.max.toFixed(2)} ${data.unit}`,
+			Mean: `${stats.mean.toFixed(2)} ${data.unit}`,
+			P50: `${stats.p50.toFixed(2)} ${data.unit}`,
+			P75: `${stats.p75.toFixed(2)} ${data.unit}`,
+			P99: `${stats.p99.toFixed(2)} ${data.unit}`,
+			Iterations: data.values.length
+		};
+	}
+	console.table(tableData);
+}
+/**
+* Run the full benchmark suite against a server
+*/
+function runBenchmarks(options) {
+	const { baseUrl, environment = `unknown` } = options;
+	(0, vitest.afterAll)(() => {
+		const statsOutput = {};
+		for (const [name, data] of results.entries()) {
+			const stats = calculateStats(data.values);
+			statsOutput[name] = {
+				...stats,
+				unit: data.unit,
+				iterations: data.values.length
+			};
+		}
+		const output = {
+			environment,
+			baseUrl,
+			timestamp: new Date().toISOString(),
+			results: statsOutput
+		};
+		(0, node_fs.writeFileSync)(`benchmark-results.json`, JSON.stringify(output, null, 2), `utf-8`);
+		console.log(`\n\n=== BENCHMARK RESULTS ===`);
+		console.log(`Environment: ${output.environment}`);
+		console.log(`Base URL: ${output.baseUrl}`);
+		console.log(``);
+		const finalTableData = {};
+		for (const [name, stats] of Object.entries(statsOutput)) finalTableData[name] = {
+			Min: `${stats.min.toFixed(2)} ${stats.unit}`,
+			Max: `${stats.max.toFixed(2)} ${stats.unit}`,
+			Mean: `${stats.mean.toFixed(2)} ${stats.unit}`,
+			P50: `${stats.p50.toFixed(2)} ${stats.unit}`,
+			P75: `${stats.p75.toFixed(2)} ${stats.unit}`,
+			P99: `${stats.p99.toFixed(2)} ${stats.unit}`,
+			Iterations: stats.iterations
+		};
+		console.table(finalTableData);
+		console.log(`\n\nResults saved to benchmark-results.json`);
+	});
+	(0, vitest.describe)(`Latency - Round-trip Time`, () => {
+		(0, vitest.bench)(`baseline ping (round-trip network latency)`, async () => {
+			const startTime = performance.now();
+			await fetch(`${baseUrl}/health`);
+			const endTime = performance.now();
+			const pingTime = endTime - startTime;
+			recordResult(`Baseline Ping`, pingTime, `ms`);
+		}, {
+			iterations: 5,
+			time: 5e3
+		});
+		(0, vitest.bench)(`append and receive via long-poll (100 bytes)`, async () => {
+			const streamPath = `/v1/stream/latency-bench-${Date.now()}-${Math.random()}`;
+			const stream = await __durable_streams_client.DurableStream.create({
+				url: `${baseUrl}${streamPath}`,
+				contentType: `application/octet-stream`
+			});
+			const message = new Uint8Array(100).fill(42);
+			let offset = (await stream.head()).offset;
+			const pingStart = performance.now();
+			await fetch(`${baseUrl}/health`);
+			const pingEnd = performance.now();
+			const pingTime = pingEnd - pingStart;
+			const warmupPromise = (async () => {
+				const res = await stream.stream({
+					offset,
+					live: `long-poll`
+				});
+				await new Promise((resolve) => {
+					const unsubscribe = res.subscribeBytes(async (chunk) => {
+						if (chunk.data.length > 0) {
+							offset = chunk.offset;
+							unsubscribe();
+							res.cancel();
+							resolve();
+						}
+					});
+				});
+			})();
+			await stream.append(message);
+			await warmupPromise;
+			const readPromise = (async () => {
+				const res = await stream.stream({
+					offset,
+					live: `long-poll`
+				});
+				await new Promise((resolve) => {
+					const unsubscribe = res.subscribeBytes(async (chunk) => {
+						if (chunk.data.length > 0) {
+							unsubscribe();
+							res.cancel();
+							resolve();
+						}
+					});
+				});
+			})();
+			const startTime = performance.now();
+			await stream.append(message);
+			await readPromise;
+			const endTime = performance.now();
+			await stream.delete();
+			const totalLatency = endTime - startTime;
+			const overhead = totalLatency - pingTime;
+			recordResult(`Latency - Total RTT`, totalLatency, `ms`);
+			recordResult(`Latency - Ping`, pingTime, `ms`);
+			recordResult(`Latency - Overhead`, overhead, `ms`);
+		}, {
+			iterations: 10,
+			time: 15e3
+		});
+		(0, vitest.afterAll)(() => {
+			printResults();
+		});
+	});
+	(0, vitest.describe)(`Message Throughput`, () => {
+		(0, vitest.bench)(`small messages (100 bytes)`, async () => {
+			const streamPath = `/v1/stream/msg-small-${Date.now()}-${Math.random()}`;
+			const stream = await __durable_streams_client.DurableStream.create({
+				url: `${baseUrl}${streamPath}`,
+				contentType: `application/octet-stream`
+			});
+			const message = new Uint8Array(100).fill(42);
+			const messageCount = 1e3;
+			const concurrency = 75;
+			const startTime = performance.now();
+			for (let batch = 0; batch < messageCount / concurrency; batch++) await Promise.all(Array.from({ length: concurrency }, () => stream.append(message)));
+			const endTime = performance.now();
+			const elapsedSeconds = (endTime - startTime) / 1e3;
+			const messagesPerSecond = messageCount / elapsedSeconds;
+			await stream.delete();
+			recordResult(`Throughput - Small Messages`, messagesPerSecond, `msg/sec`);
+		}, {
+			iterations: 3,
+			time: 1e4
+		});
+		(0, vitest.bench)(`large messages (1MB)`, async () => {
+			const streamPath = `/v1/stream/msg-large-${Date.now()}-${Math.random()}`;
+			const stream = await __durable_streams_client.DurableStream.create({
+				url: `${baseUrl}${streamPath}`,
+				contentType: `application/octet-stream`
+			});
+			const message = new Uint8Array(1024 * 1024).fill(42);
+			const messageCount = 50;
+			const concurrency = 15;
+			const startTime = performance.now();
+			for (let batch = 0; batch < messageCount / concurrency; batch++) await Promise.all(Array.from({ length: concurrency }, () => stream.append(message)));
+			const endTime = performance.now();
+			const elapsedSeconds = (endTime - startTime) / 1e3;
+			const messagesPerSecond = messageCount / elapsedSeconds;
+			await stream.delete();
+			recordResult(`Throughput - Large Messages`, messagesPerSecond, `msg/sec`);
+		}, {
+			iterations: 2,
+			time: 1e4
+		});
+		(0, vitest.afterAll)(() => {
+			printResults();
+		});
+	});
+	vitest.describe.skip(`Byte Throughput`, () => {
+		(0, vitest.bench)(`streaming throughput - appendStream`, async () => {
+			const streamPath = `/v1/stream/byte-stream-${Date.now()}-${Math.random()}`;
+			const stream = await __durable_streams_client.DurableStream.create({
+				url: `${baseUrl}${streamPath}`,
+				contentType: `application/octet-stream`
+			});
+			const chunkSize = 64 * 1024;
+			const chunk = new Uint8Array(chunkSize).fill(42);
+			const totalChunks = 100;
+			const startTime = performance.now();
+			const appends = [];
+			for (let i = 0; i < totalChunks; i++) appends.push(stream.append(chunk));
+			await Promise.all(appends);
+			const endTime = performance.now();
+			let bytesRead = 0;
+			const readRes = await stream.stream({ live: false });
+			const reader = readRes.bodyStream().getReader();
+			let result = await reader.read();
+			while (!result.done) {
+				bytesRead += result.value.length;
+				result = await reader.read();
+			}
+			const elapsedSeconds = (endTime - startTime) / 1e3;
+			const mbPerSecond = bytesRead / (1024 * 1024) / elapsedSeconds;
+			await stream.delete();
+			recordResult(`Throughput - Streaming (appendStream)`, mbPerSecond, `MB/sec`);
+		}, {
+			iterations: 3,
+			time: 1e4
+		});
+		(0, vitest.afterAll)(() => {
+			printResults();
+		});
+	});
+}
+
+//#endregion
+exports.runBenchmarks = runBenchmarks

package/dist/index.d.cts

@@ -0,0 +1,12 @@
+//#region src/index.d.ts
+interface BenchmarkOptions {
+  /** Base URL of the server to benchmark */
+  baseUrl: string;
+  /** Environment name (e.g., "production", "local") */
+  environment?: string;
+}
+/**
+* Run the full benchmark suite against a server
+*/
+declare function runBenchmarks(options: BenchmarkOptions): void; //#endregion
+export { BenchmarkOptions, runBenchmarks };

package/package.json

@@ -1,48 +1,57 @@
 {
   "name": "@durable-streams/benchmarks",
-  "version": "0.1.1",
   "description": "Performance benchmark suite for Durable Streams server implementations",
+  "version": "0.1.2",
   "author": "Durable Stream contributors",
-  "license": "Apache-2.0",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/durable-streams/durable-streams.git",
-    "directory": "packages/benchmarks"
-  },
   "bugs": {
     "url": "https://github.com/durable-streams/durable-streams/issues"
   },
-  "keywords": [
-    "durable-streams",
-    "benchmarks",
-    "performance",
-    "typescript"
-  ],
-  "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    }
-  },
   "dependencies": {
     "vitest": "^3.2.4",
-    "@durable-streams/client": "0.1.1"
+    "@durable-streams/client": "0.1.2"
   },
   "devDependencies": {
     "@types/node": "^22.15.21",
     "tsdown": "^0.9.0",
     "typescript": "^5.0.0"
   },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
   "files": [
     "dist",
     "src"
   ],
-  "engines": {
-    "node": ">=18.0.0"
+  "keywords": [
+    "benchmarks",
+    "durable-streams",
+    "performance",
+    "typescript"
+  ],
+  "license": "Apache-2.0",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/durable-streams/durable-streams.git",
+    "directory": "packages/benchmarks"
   },
+  "sideEffects": false,
+  "type": "module",
+  "types": "./dist/index.d.ts",
   "scripts": {
     "build": "tsdown",
     "dev": "tsdown --watch",