rivetkit 2.3.0-rc.8 → 2.3.0-rc.9

package/src/registry/index.ts

@@ -1,8 +1,6 @@
-import { Hono } from "hono";
 import { ENGINE_ENDPOINT } from "@/common/engine";
 import { configureServerlessPool } from "@/serverless/configure";
-import { detectRuntime, VERSION } from "@/utils";
-import { crossPlatformServe, loadRuntimeServeStatic } from "@/utils/serve";
+import { VERSION } from "@/utils";
 import {
 	type RegistryActors,
 	type RegistryConfig,
@@ -40,13 +38,15 @@ export interface ServerlessHandler {
 	fetch: FetchHandler;
 }
 
-export interface RegistryDiagnostics {
-	mode: string;
-	envoyActiveActorCount?: number | null;
+export interface RegistryRoutes {
+	health(): Promise<Response>;
+	metadata(): Promise<Response>;
+	prometheusMetrics(request?: Request): Promise<Response>;
 }
 
 export class Registry<A extends RegistryActors> {
 	#config: RegistryConfigInput<A>;
+	public readonly routes: RegistryRoutes;
 
 	get config(): RegistryConfigInput<A> {
 		return this.#config;
@@ -67,6 +67,12 @@ export class Registry<A extends RegistryActors> {
 
 	constructor(config: RegistryConfigInput<A>) {
 		this.#config = config;
+		this.routes = {
+			health: () => this.#healthRoute(),
+			metadata: () => this.#metadataRoute(),
+			prometheusMetrics: (request?: Request) =>
+				this.#prometheusMetricsRoute(request),
+		};
 	}
 
 	#ensureServerlessPoolConfigured(config: RegistryConfig): Promise<void> | undefined {
@@ -298,36 +304,91 @@ export class Registry<A extends RegistryActors> {
 	}
 
 	/**
-	 * Starts an HTTP server that dispatches every request through the
-	 * serverless handler. Uses `crossPlatformServe` to pick the right
-	 * runtime (Node, Bun, Deno).
-	 *
-	 * @param opts.port      Port to listen on. Defaults to 3000.
-	 * @param opts.publicDir If set, serves static files from this directory
-	 *                       before falling through to the registry handler.
-	 *
-	 * @example
-	 * ```ts
-	 * await registry.listen();
-	 * await registry.listen({ port: 8080, publicDir: "./public" });
-	 * ```
+	 * Returns a health response suitable for mounting in a user-owned router.
 	 */
-	public async listen(
-		opts: { port?: number; publicDir?: string } = {},
-	): Promise<void> {
-		const port = opts.port ?? 3000;
-		const config = this.parseConfig();
-		const runtime = detectRuntime();
-		const app = new Hono();
-		if (opts.publicDir) {
-			const serveStatic = await loadRuntimeServeStatic(runtime);
-			app.use("*", serveStatic({ root: opts.publicDir }));
+	async #healthRoute(): Promise<Response> {
+		const configured = await this.#activeConfiguredRegistry();
+		if (!configured) {
+			return jsonRouteResponse(503, {
+				status: "not_started",
+				runtime: "rivetkit",
+				version: VERSION,
+			});
+		}
+
+		const { runtime, registry } = configured;
+		if (!runtime.registryHealth) {
+			return jsonRouteResponse(501, {
+				status: "unsupported",
+				runtime: "rivetkit",
+				version: VERSION,
+			});
+		}
+
+		const response = await runtime.registryHealth(registry);
+		return new Response(new Uint8Array(response.body), {
+			status: response.status,
+			headers: response.headers,
+		});
+	}
+
+	/**
+	 * Returns serverless metadata suitable for mounting in a user-owned router.
+	 */
+	async #metadataRoute(): Promise<Response> {
+		const configured = await this.#activeConfiguredRegistry();
+		if (!configured) {
+			return new Response("registry not started\n", {
+				status: 503,
+				headers: { "content-type": "text/plain; charset=utf-8" },
+			});
 		}
-		app.all("*", (c) => this.handler(c.req.raw));
-		await crossPlatformServe(config, port, app, runtime);
+
+		const { runtime, registry } = configured;
+		if (!runtime.registryMetadata) {
+			return new Response("metadata is not supported by this runtime\n", {
+				status: 501,
+				headers: { "content-type": "text/plain; charset=utf-8" },
+			});
+		}
+
+		const response = await runtime.registryMetadata(registry);
+		return new Response(new Uint8Array(response.body), {
+			status: response.status,
+			headers: response.headers,
+		});
+	}
+
+	/**
+	 * Returns a Prometheus metrics response suitable for mounting in a user-owned router.
+	 */
+	async #prometheusMetricsRoute(_request?: Request): Promise<Response> {
+		const configured = await this.#activeConfiguredRegistry();
+		if (!configured) {
+			return new Response("registry not started\n", {
+				status: 503,
+				headers: { "content-type": "text/plain; charset=utf-8" },
+			});
+		}
+
+		const { runtime, registry } = configured;
+		if (!runtime.registryMetrics) {
+			return new Response("metrics are not supported by this runtime\n", {
+				status: 501,
+				headers: { "content-type": "text/plain; charset=utf-8" },
+			});
+		}
+
+		const response = await runtime.registryMetrics(registry);
+		return new Response(new Uint8Array(response.body), {
+			status: response.status,
+			headers: response.headers,
+		});
 	}
 
-	public async diagnostics(): Promise<RegistryDiagnostics> {
+	async #activeConfiguredRegistry(): Promise<
+		Awaited<ReturnType<typeof buildConfiguredRegistry>> | undefined
+	> {
 		const candidates = [
 			this.#runtimeServerlessPromise,
 			this.#runtimeServeConfiguredPromise,
@@ -335,13 +396,8 @@ export class Registry<A extends RegistryActors> {
 			candidate !== undefined
 		);
 
-		for (const candidate of candidates) {
-			const { runtime, registry } = await candidate;
-			const diagnostics = await runtime.registryDiagnostics?.(registry);
-			if (diagnostics) return diagnostics;
-		}
-
-		return { mode: "not_started", envoyActiveActorCount: null };
+		if (candidates.length === 0) return undefined;
+		return await candidates[0]!;
 	}
 
 	/**
@@ -355,12 +411,12 @@ export class Registry<A extends RegistryActors> {
 				.then(async ({ runtime, registry, serveConfig }) => {
 					await runtime.serveRegistry(registry, serveConfig);
 				})
-				.catch((error) => {
+				.catch((err) => {
 					// Always-attached catch so the stored promise never leaves a
 					// rejection unhandled. Downstream awaits (e.g. #runShutdown's
 					// Promise.race) attach their own catches and still observe
 					// resolution via the race.
-					logger().warn({ error }, "runtime registry serve errored");
+					logger().warn({ err }, "runtime registry serve errored");
 				});
 			// Install signal handlers once an envoy lifecycle has begun. Only
 			// Mode A ever reaches here. Mode B (handler(request)) intentionally
@@ -423,8 +479,8 @@ export class Registry<A extends RegistryActors> {
 			signal,
 			config,
 			configuredRegistryPromise,
-		).catch((error) => {
-			logger().warn({ error }, "shutdown error");
+		).catch((err) => {
+			logger().warn({ err }, "shutdown error");
 		});
 	}
 
@@ -451,9 +507,9 @@ export class Registry<A extends RegistryActors> {
 						const { runtime, registry } =
 							await configuredRegistryPromise;
 						await runtime.shutdownRegistry(registry);
-					} catch (error) {
+					} catch (err) {
 						logger().warn(
-							{ error },
+							{ err },
 							"runtime registry shutdown errored (mode A)",
 						);
 					}
@@ -469,7 +525,7 @@ export class Registry<A extends RegistryActors> {
 							await runtime.shutdownRegistry(registry);
 						} catch (err) {
 							logger().warn(
-								{ error: err },
+								{ err },
 								"runtime registry shutdown errored (mode B)",
 							);
 						}
@@ -598,6 +654,13 @@ function isServerlessMetadataRequest(request: Request, basePath: string): boolea
 	return parsed.pathname === `${normalizedBase}/metadata`;
 }
 
+function jsonRouteResponse(status: number, body: unknown): Response {
+	return new Response(JSON.stringify(body), {
+		status,
+		headers: { "content-type": "application/json" },
+	});
+}
+
 export function setup<A extends RegistryActors>(
 	input: RegistryConfigInput<A>,
 ): Registry<A> {

package/src/registry/napi-runtime.ts

@@ -24,7 +24,7 @@ import type {
 	RuntimeQueueTryNextBatchOptions,
 	RuntimeQueueWaitOptions,
 	RuntimeRequestSaveOpts,
-	RuntimeRegistryDiagnostics,
+	RuntimeRegistryRouteResponse,
 	RuntimeServeConfig,
 	RuntimeServerlessRequest,
 	RuntimeServerlessResponseHead,
@@ -202,16 +202,6 @@ export class NapiCoreRuntime implements CoreRuntime {
 		await asNativeRegistry(registry).shutdown();
 	}
 
-	async registryDiagnostics(
-		registry: RegistryHandle,
-	): Promise<RuntimeRegistryDiagnostics> {
-		const diagnostics = await asNativeRegistry(registry).diagnostics();
-		return {
-			mode: diagnostics.mode,
-			envoyActiveActorCount: diagnostics.envoyActiveActorCount,
-		};
-	}
-
 	async registryActorStopThresholdMs(
 		registry: RegistryHandle,
 	): Promise<number | undefined> {
@@ -221,6 +211,39 @@ export class NapiCoreRuntime implements CoreRuntime {
 		);
 	}
 
+	async registryHealth(
+		registry: RegistryHandle,
+	): Promise<RuntimeRegistryRouteResponse> {
+		const response = await asNativeRegistry(registry).health();
+		return {
+			status: response.status,
+			headers: response.headers,
+			body: response.body,
+		};
+	}
+
+	async registryMetadata(
+		registry: RegistryHandle,
+	): Promise<RuntimeRegistryRouteResponse> {
+		const response = asNativeRegistry(registry).metadata();
+		return {
+			status: response.status,
+			headers: response.headers,
+			body: response.body,
+		};
+	}
+
+	async registryMetrics(
+		registry: RegistryHandle,
+	): Promise<RuntimeRegistryRouteResponse> {
+		const response = asNativeRegistry(registry).metrics();
+		return {
+			status: response.status,
+			headers: response.headers,
+			body: response.body,
+		};
+	}
+
 	async handleServerlessRequest(
 		registry: RegistryHandle,
 		req: RuntimeServerlessRequest,