spooder 3.2.2 → 3.2.4

package/README.md

@@ -623,6 +623,22 @@ The `stop` function allows you to stop the server. `method` is one of `ServerSto
 
 ---
 
+#### `ErrorWithMetadata(message: string, metadata: object)`
+
+The `ErrorWithMetadata` class is a thin wrapper around the built-in `Error` class that allows you to attach metadata to the error.
+
+Providing additional information to errors can be used for debugging purposes when errors are dispatched to the canary.
+
+```ts
+throw new ErrorWithMetadata('Something went wrong', { foo: 'bar' });
+```
+
+For convinience, if any of the values in the `metadata` are functions, they will be called and the return value will be used instead.
+
+Additionally, promises will be resolved and readable streams will be converted to strings.
+
+---
+
 #### `route_location(redirect_url: string)`
 
 The `route_location` is a built-in request handler that redirects the client to a specified URL with the status code `301 Moved Permanently`.

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "spooder",
 	"type": "module",
-	"version": "3.2.2",
+	"version": "3.2.4",
 	"exports": {
 		".": {
 			"bun": "./src/api.ts",

package/src/api.d.ts

@@ -1,5 +1,10 @@
 /// <reference types="bun-types" />
 /// <reference types="node" />
+export declare class ErrorWithMetadata extends Error {
+    metadata: Record<string, unknown>;
+    constructor(message: string, metadata: Record<string, unknown>);
+    resolve_metadata(): Promise<object>;
+}
 export declare function panic(err_message_or_obj: string | object, ...err: object[]): Promise<void>;
 export declare function caution(err_message_or_obj: string | object, ...err: object[]): Promise<void>;
 type HandlerReturnType = any;

package/src/api.ts

@@ -3,6 +3,26 @@ import http from 'node:http';
 import path from 'node:path';
 import fs from 'node:fs/promises';
 
+export class ErrorWithMetadata extends Error {
+	constructor(message: string, public metadata: Record<string, unknown>) {
+		super(message);
+	}
+
+	async resolve_metadata(): Promise<object> {
+		const metadata = Object.assign({}, this.metadata);
+		for (const [key, value] of Object.entries(metadata)) {
+			if (value instanceof Promise)
+				metadata[key] = await value;
+			else if (typeof value === 'function')
+				metadata[key] = value();
+			else if (value instanceof ReadableStream)
+				metadata[key] = await new Response(value).text();
+		}
+
+		return metadata;
+	}
+}
+
 async function handle_error(prefix: string, err_message_or_obj: string | object, ...err: unknown[]): Promise<void> {
 	let error_message = 'unknown error';
 
@@ -16,20 +36,25 @@ async function handle_error(prefix: string, err_message_or_obj: string | object,
 		err.push(err_message_or_obj);
 	}
 
-	// Serialize error objects.
-	err = err.map(e => {
+	const final_err = Array(err.length);
+	for (let i = 0; i < err.length; i++) {
+		const e = err[i];
+
 		if (e instanceof Error) {
-			return {
+			const report = {
 				name: e.name,
 				message: e.message,
 				stack: e.stack?.split('\n') ?? []
-			}
-		}
+			} as Record<string, unknown>;
 
-		return e;
-	})
+			if (e instanceof ErrorWithMetadata)
+				report.metadata = await e.resolve_metadata();
+
+			final_err[i] = report;
+		}
+	}
 
-	await dispatch_report(prefix + error_message, err);
+	await dispatch_report(prefix + error_message, final_err);
 }
 
 export async function panic(err_message_or_obj: string | object, ...err: object[]): Promise<void> {

package/src/cli.ts

@@ -36,38 +36,39 @@ async function start_server() {
 		}
 	}
 
-	Bun.spawn(parse_command_line(config.run), {
+	const proc = Bun.spawn(parse_command_line(config.run), {
 		cwd: process.cwd(),
 		stdout: 'inherit',
-		stderr: 'pipe',
-
-		onExit: (proc, exitCode, signal) => {
-			log('server exited with code %d', exitCode);
-
-			if (exitCode !== null && exitCode > 0) {
-				if (proc.stderr !== undefined) {
-					const res = new Response(proc.stderr as ReadableStream);
-
-					res.text().then(async stderr => {
-						await dispatch_report('crash: server exited unexpectedly', [{
-							exitCode,
-							stderr: strip_color_codes(stderr).split(/\r?\n/)
-						}]);
-					});
-				} else {
-					dispatch_report('crash: service exited unexpectedly', [{
-						exitCode
-					}]);
-				}
-			}
+		stderr: 'pipe'
+	});
 
-			const auto_restart_ms = config.autoRestart;
-			if (auto_restart_ms > -1) {
-				log('restarting server in %dms', auto_restart_ms);
-				setTimeout(start_server, auto_restart_ms);
-			}
+	await proc.exited;
+
+	const proc_exit_code = proc.exitCode;
+	log('server exited with code %s', proc_exit_code);
+
+	if (proc_exit_code !== 0) {
+		if (proc.stderr !== undefined) {
+			const res = new Response(proc.stderr as ReadableStream);
+
+			res.text().then(async stderr => {
+				await dispatch_report('crash: server exited unexpectedly', [{
+					proc_exit_code,
+					stderr: strip_color_codes(stderr).split(/\r?\n/)
+				}]);
+			});
+		} else {
+			dispatch_report('crash: service exited unexpectedly', [{
+				proc_exit_code
+			}]);
 		}
-	});
+	}
+
+	const auto_restart_ms = config.autoRestart;
+	if (auto_restart_ms > -1) {
+		log('restarting server in %dms', auto_restart_ms);
+		setTimeout(start_server, auto_restart_ms);
+	}
 }
 
 await start_server();