@supalive/core 1.15.0 → 1.16.0

package/dist/src/exports/server.js

@@ -1,11 +1,13 @@
 import { l as primaryOnlyConn, n as getContextRegistry } from "../../router-DP2ThAwh.js";
 import { n as stableStringify, r as supaliveStringify, t as groupByToMap } from "../../helper-zdJT5FUc.js";
-import { r as evaluateCacheFreshness } from "../../overlap-checker-Kz7B_jsp.js";
-import { i as AuthenticationError, o as ClientMessageSchema } from "../../types_client_rpc-ByGwoRCL.js";
+import { s as traceCacheCall } from "../../query-LJranz0c.js";
+import { r as evaluateCacheFreshness } from "../../overlap-checker-1TwhkAwy.js";
+import { i as AuthenticationError, o as ClientMessageSchema } from "../../types_client_rpc-CWZmlWmM.js";
 import { n as RemoteSubscriptionMessageSchema } from "../../types_server-BhC19R2a.js";
-import { n as sleep } from "../../realtime_db-CVze3gM0.js";
+import { n as sleep } from "../../realtime_db-B0Tin87E.js";
+import { C as appInstanceId, D as serializeMapValue, E as logger, S as RetentionWatermark, T as logLevelOf, _ as UnregisterSubscriptionResultSchema, a as bootstrapDbTypes, b as UpdateSubscriptionReadSetResultSchema, c as initCore, d as InvalidateWritesetParamsSchema, f as InvalidateWritesetResultSchema, g as UnregisterSubscriptionParamsSchema, h as RegisterSubscriptionResultSchema, i as DB_QUERY_TIMEOUT_MS, l as initDatabase, m as RegisterSubscriptionParamsSchema, n as SubscriptionWorker, o as createDatabase, p as RegisterSubscriptionBatchResultSchema, r as CORE_VERSION, s as initCacheLayer, t as dispatchWorkerMessage, u as CacheLayer, v as UnregisterSubscriptionsResultSchema, w as isProduction, x as RETENTION_WATERMARK_CHANNEL, y as UpdateSubscriptionReadSetParamsSchema } from "../../sub-worker-dispatch-qiSs5Xkm.js";
 import { n as resolveReadRouting, t as makeConnRouting } from "../../read-routing-BUcQAwnd.js";
-import { C as appInstanceId, D as serializeMapValue, E as logger, S as RetentionWatermark, T as logLevelOf, _ as UnregisterSubscriptionResultSchema, a as bootstrapDbTypes, b as UpdateSubscriptionReadSetResultSchema, c as initCore, d as InvalidateWritesetParamsSchema, f as InvalidateWritesetResultSchema, g as UnregisterSubscriptionParamsSchema, h as RegisterSubscriptionResultSchema, i as DB_QUERY_TIMEOUT_MS, l as initDatabase, m as RegisterSubscriptionParamsSchema, n as SubscriptionWorker, o as createDatabase, p as RegisterSubscriptionBatchResultSchema, r as CORE_VERSION, s as initCacheLayer, t as dispatchWorkerMessage, u as CacheLayer, v as UnregisterSubscriptionsResultSchema, w as isProduction, x as RETENTION_WATERMARK_CHANNEL, y as UpdateSubscriptionReadSetParamsSchema } from "../../sub-worker-dispatch-CC0w_sx0.js";
+import { ROOT_CONTEXT, SpanKind, SpanStatusCode, context, isSpanContextValid, metrics, propagation, trace } from "@opentelemetry/api";
 import { v4 } from "uuid";
 import { createServer } from "http";
 import { WebSocket, WebSocketServer } from "ws";
@@ -72,6 +74,251 @@ async function generateCacheKey(queryName, input, queryIdentity) {
 	return `ck_${await getHashOf(`${queryName}_${typeof input === "string" ? input : stableStringify(input)}_${queryIdentity}`)}`;
 }
 //#endregion
+//#region src/observability.ts
+let rootLogger = logger;
+/** Replace the process-wide root logger. Call once at startup, before creating
+* the server, to route Supalive's request/lifecycle logs through your own pino
+* instance. */
+function configureRootLogger(logger) {
+	rootLogger = logger;
+}
+/** The current root logger (defaults to the env-configured singleton). */
+function getRootLogger() {
+	return rootLogger;
+}
+const CLIENT_ERROR_CODES = /* @__PURE__ */ new Set([
+	"NOT_FOUND",
+	"BAD_REQUEST",
+	"INVALID_MESSAGE",
+	"PARSE_ERROR",
+	"UNAUTHENTICATED",
+	"RATE_LIMITED",
+	"METHOD_NOT_ALLOWED",
+	"TOO_MANY_CONCURRENT_MUTATIONS",
+	"TOO_MANY_CONCURRENT_ACTIONS",
+	"SUBSCRIBE_ERROR"
+]);
+/**
+* The bound observability surface for one server instance: an injectable logger,
+* OTel metric instruments, and the `record()` seam every operation funnels
+* through. Built once in the server constructor and shared with the HTTP RPC
+* handler.
+*/
+var Observability = class {
+	logger;
+	requestLog;
+	onEvent;
+	requestCounter;
+	durationHistogram;
+	activeConnections;
+	activeSubscriptions;
+	tracer;
+	constructor(opts = {}) {
+		const base = opts.logger ?? getRootLogger();
+		this.logger = opts.level ? base.child({}, { level: opts.level }) : base;
+		this.requestLog = opts.requestLog ?? "all";
+		this.onEvent = opts.onEvent;
+		const meterName = opts.meterName ?? "@supalive/core";
+		const meter = metrics.getMeter(meterName, opts.meterVersion);
+		this.tracer = trace.getTracer(meterName, opts.meterVersion);
+		this.requestCounter = meter.createCounter("supalive_requests_total", { description: "Total Supalive operations (WS calls, subscribes, HTTP RPC, jobs)." });
+		this.durationHistogram = meter.createHistogram("supalive_request_duration_ms", {
+			description: "Operation duration in milliseconds.",
+			unit: "ms"
+		});
+		this.activeConnections = meter.createUpDownCounter("supalive_active_connections", { description: "Currently open WebSocket connections." });
+		this.activeSubscriptions = meter.createUpDownCounter("supalive_active_subscriptions", { description: "Currently registered live-query subscriptions on this instance." });
+	}
+	/** Record one completed operation: metrics + optional onEvent + one log line,
+	*  and finalize the op's span (status/attributes/exception) when present. */
+	record(e) {
+		const traceId = this.finalizeSpan(e);
+		if (traceId) (e.extra ??= {}).traceId = traceId;
+		const attrs = {
+			transport: e.transport,
+			procedure: e.procedure ?? "",
+			kind: e.kind ?? "",
+			outcome: e.outcome,
+			code: e.code ?? ""
+		};
+		this.requestCounter.add(1, attrs);
+		this.durationHistogram.record(e.durationMs, attrs);
+		if (this.onEvent) try {
+			this.onEvent(e);
+		} catch {}
+		if (this.requestLog === "off") return;
+		if (e.outcome === "ok") {
+			if (this.requestLog !== "all") return;
+			this.logger.info(logFields(e), summary(e));
+			return;
+		}
+		const fields = logFields(e);
+		if (!e.error && e.code != null && CLIENT_ERROR_CODES.has(e.code)) this.logger.warn(fields, summary(e));
+		else this.logger.error({
+			...fields,
+			err: e.error
+		}, summary(e));
+	}
+	/**
+	* Start a SERVER span for an operation, as a child of `parent` (or the active
+	* context). No-op — returns a non-recording span — until a TracerProvider is
+	* registered by the app, so this costs nothing when tracing is disabled.
+	* Returns the span plus a context that has it active, for `context.with(...)`
+	* wrapping so nested handler work / `ctx.span` children attach correctly.
+	*/
+	startSpan(name, opts = {}) {
+		const parent = opts.parent ?? context.active();
+		const span = this.tracer.startSpan(name, {
+			kind: SpanKind.SERVER,
+			attributes: {
+				...opts.transport ? { "supalive.transport": opts.transport } : {},
+				...opts.procedure ? { "supalive.procedure": opts.procedure } : {},
+				...opts.kind ? { "supalive.kind": opts.kind } : {}
+			}
+		}, parent);
+		return {
+			span,
+			context: trace.setSpan(parent, span)
+		};
+	}
+	/**
+	* Continue a trace from an inbound carrier (HTTP headers, or a WS message's
+	* `trace` field). Returns a context to pass as `startSpan({ parent })`. When
+	* no propagator is registered / no trace context is present, returns the root
+	* context (a fresh trace).
+	*/
+	extractContext(carrier) {
+		return propagation.extract(ROOT_CONTEXT, carrier);
+	}
+	/** Set the span's final status/attributes from the event, then end it.
+	*  Returns the (valid) trace id for log correlation, or undefined. */
+	finalizeSpan(e) {
+		const span = e.span;
+		if (!span) return void 0;
+		try {
+			span.setAttribute("supalive.outcome", e.outcome);
+			if (e.code) span.setAttribute("supalive.code", e.code);
+			if (e.procedure) span.setAttribute("supalive.procedure", e.procedure);
+			if (e.kind) span.setAttribute("supalive.kind", e.kind);
+			if (e.outcome === "error") {
+				if (e.error instanceof Error) span.recordException(e.error);
+				span.setStatus({
+					code: SpanStatusCode.ERROR,
+					message: e.code
+				});
+			} else span.setStatus({ code: SpanStatusCode.OK });
+		} finally {
+			span.end();
+		}
+		const sc = span.spanContext();
+		return isSpanContextValid(sc) ? sc.traceId : void 0;
+	}
+	/** A request-scoped child logger for `ctx.log`, bound with the given fields
+	*  (reqId, procedure, and trace id when tracing is on). */
+	childLogger(fields) {
+		return this.logger.child(fields);
+	}
+	/**
+	* A LAZY request-scoped `ctx.log`. Most handlers never log, and pino's
+	* `.child()` (bindings merge + serialization) isn't free — so this defers the
+	* child creation until the first `debug/info/warn/error` call and reuses it
+	* after. When a handler logs nothing, no child logger is ever allocated; the
+	* only per-request cost is this small delegator object. Returns the narrow
+	* {@link HandlerLogger} surface the handler context exposes.
+	*/
+	lazyChildLogger(fields) {
+		const base = this.logger;
+		let child;
+		const get = () => child ??= base.child(fields);
+		return {
+			debug: (...args) => get().debug(...args),
+			info: (...args) => get().info(...args),
+			warn: (...args) => get().warn(...args),
+			error: (...args) => get().error(...args)
+		};
+	}
+	/** The span's trace id, or undefined when tracing is off / the span is
+	*  non-recording. For binding onto `ctx.log`. */
+	traceIdOf(span) {
+		if (!span) return void 0;
+		const sc = span.spanContext();
+		return isSpanContextValid(sc) ? sc.traceId : void 0;
+	}
+	connectionOpened() {
+		this.activeConnections.add(1);
+	}
+	connectionClosed() {
+		this.activeConnections.add(-1);
+	}
+	subscriptionAdded(n = 1) {
+		this.activeSubscriptions.add(n);
+	}
+	subscriptionRemoved(n = 1) {
+		this.activeSubscriptions.add(-n);
+	}
+};
+/** Start marker for an operation; pass to {@link elapsedMs} to get its duration. */
+function startTimer() {
+	return performance.now();
+}
+function elapsedMs(startedAt) {
+	return Math.round((performance.now() - startedAt) * 1e3) / 1e3;
+}
+const coreTracer = trace.getTracer("@supalive/core");
+/**
+* Run a query handler inside a `query <procedureName>` span, nested under
+* `parentContext` (the operation span) or the active context. The span is handed
+* to `run` so it becomes the query handler's `ctx.span` and the parent of any DB
+* spans. Cache HITs never call this (no execution), so a span appearing means a
+* real recompute — including the otherwise-invisible background reactive path,
+* where `parentContext` is omitted and the span is a root.
+*
+* No-op-cheap when tracing is off: the started span is non-recording, so we skip
+* the `context.with` and just run.
+*/
+function traceQueryExecution(procedureName, trigger, parentContext, run) {
+	const parent = parentContext ?? context.active();
+	const span = coreTracer.startSpan(`query ${procedureName}`, { attributes: {
+		"supalive.kind": "query",
+		"supalive.procedure": procedureName,
+		"supalive.trigger": trigger
+	} }, parent);
+	const exec = async () => {
+		try {
+			const r = await run(span);
+			span.setStatus({ code: SpanStatusCode.OK });
+			return r;
+		} catch (err) {
+			if (err instanceof Error) span.recordException(err);
+			span.setStatus({ code: SpanStatusCode.ERROR });
+			throw err;
+		} finally {
+			span.end();
+		}
+	};
+	return span.isRecording() ? context.with(trace.setSpan(parent, span), exec) : exec();
+}
+function logFields(e) {
+	const f = {
+		op: e.op,
+		transport: e.transport,
+		outcome: e.outcome,
+		durMs: e.durationMs
+	};
+	if (e.procedure) f.procedure = e.procedure;
+	if (e.kind) f.kind = e.kind;
+	if (e.code) f.code = e.code;
+	if (e.reqId) f.reqId = e.reqId;
+	if (e.sessionId) f.sessionId = e.sessionId;
+	if (e.userId != null) f.userId = e.userId;
+	if (e.extra) Object.assign(f, e.extra);
+	return f;
+}
+function summary(e) {
+	const label = e.procedure ? `${e.kind ?? e.op} ${e.procedure}` : e.op;
+	return `${e.transport} ${label} ${e.outcome}`;
+}
+//#endregion
 //#region src/server/one-shot-query.ts
 /**
 * Execute a one-shot query (WS `call` or HTTP RPC) with the same caching model
@@ -108,14 +355,24 @@ async function generateCacheKey(queryName, input, queryIdentity) {
 * `ts` the result reflects, which the caller echoes so the client can advance
 * its high-water.
 */
-async function runCachedQuery(deps, procedure, procedureName, input, serverCtx, lastSnapshotTs, clientMinTs) {
+async function runCachedQuery(deps, procedure, procedureName, input, serverCtx, lastSnapshotTs, clientMinTs, handlerObs) {
 	const queryIdentity = resolveQueryIdentity(procedure, serverCtx, input, deps.getUserId);
 	const cacheKey = await generateCacheKey(procedureName, stableStringify(input), queryIdentity);
 	const routing = await resolveReadRouting(deps.db, lastSnapshotTs, clientMinTs ?? 0n);
 	const readTs = routing.readTs;
-	const metadata = await deps.cache.getQueryCacheMetaData(cacheKey);
-	if ((await evaluateCacheFreshness(routing.readImpl, metadata, readTs, deps.getMinRetainedTs())).fresh) {
-		const cached = await deps.cache.getQueryCacheFor(cacheKey);
+	const { metadata, freshness } = await traceCacheCall("freshness", async () => {
+		const metadata = await deps.cache.getQueryCacheMetaData(cacheKey);
+		return {
+			metadata,
+			freshness: await evaluateCacheFreshness(routing.readImpl, metadata, readTs, deps.getMinRetainedTs())
+		};
+	});
+	if (freshness.fresh) {
+		const cached = await traceCacheCall("get", async (setHit) => {
+			const c = await deps.cache.getQueryCacheFor(cacheKey);
+			setHit(!!(c && metadata && c.version === metadata.version));
+			return c;
+		});
 		if (cached && metadata && cached.version === metadata.version) {
 			if (readTs > metadata.lastSnapshotTs) deps.cache.advanceQueryCacheMetadata(cacheKey, {
 				lastSnapshotTs: readTs,
@@ -134,11 +391,16 @@ async function runCachedQuery(deps, procedure, procedureName, input, serverCtx,
 		beginTs: readTs
 	}, async (ctx) => {
 		const fn = procedure.fn;
-		return fn({
-			db: ctx,
-			serverCtx,
-			...makeConnRouting(ctx, routing)
-		}, input);
+		return traceQueryExecution(procedureName, "request", void 0, (querySpan) => {
+			const qctx = {
+				db: ctx,
+				serverCtx,
+				...makeConnRouting(ctx, routing),
+				log: handlerObs?.log,
+				span: querySpan
+			};
+			return fn(qctx, input);
+		});
 	});
 	await deps.cache.setQueryCacheAndMetadataFor(cacheKey, result.data, {
 		lastSnapshotTs: result.ts,
@@ -152,7 +414,7 @@ async function runCachedQuery(deps, procedure, procedureName, input, serverCtx,
 }
 //#endregion
 //#region src/server/sub-manager-client.ts
-const logger$5 = logger.child({ name: "SUBS_MGR_CLIENT" }, { level: logLevelOf("SUB_MANAGER_CLIENT_LOG_LEVEL") });
+const logger$3 = logger.child({ name: "SUBS_MGR_CLIENT" }, { level: logLevelOf("SUB_MANAGER_CLIENT_LOG_LEVEL") });
 const subscriptionManagerDataPack = {
 	encode: (data) => supaliveStringify(data),
 	decode: (data) => JSON.parse(data)
@@ -209,7 +471,7 @@ var SubManagerClient = class {
 		this.client.dataPack = subscriptionManagerDataPack;
 		this.client.on("open", this.handleOpen.bind(this));
 		this.client.on("close", this.handleClose.bind(this));
-		this.client.on("error", (err) => logger$5.warn(err, "sub-manager client socket error"));
+		this.client.on("error", (err) => logger$3.warn(err, "sub-manager client socket error"));
 	}
 	/**
 	* Wire up the app-server-driven recovery. Must be called before any
@@ -270,7 +532,7 @@ var SubManagerClient = class {
 	appendToBuffer(writeSet) {
 		if (this.bufferedWriteSets.length + writeSet.length > this.bufferLimit) {
 			if (!this.bufferDroppedDuringOutage) {
-				logger$5.warn(`Invalidate buffer would exceed ${this.bufferLimit}; dropping buffered entries. Subscriptions will be caught up via commit-log replay on re-register.`);
+				logger$3.warn(`Invalidate buffer would exceed ${this.bufferLimit}; dropping buffered entries. Subscriptions will be caught up via commit-log replay on re-register.`);
 				this.bufferDroppedDuringOutage = true;
 			}
 			this.bufferedWriteSets = [];
@@ -287,7 +549,7 @@ var SubManagerClient = class {
 			const result = await this.call("invalidateWriteset", { writeSet }, InvalidateWritesetResultSchema);
 			if (this.affectedHandler && result.affected.length > 0) await this.affectedHandler(result.affected);
 		} catch (err) {
-			logger$5.error(err, "Failed to flush invalidate buffer after recovery");
+			logger$3.error(err, "Failed to flush invalidate buffer after recovery");
 		}
 	}
 	markBusy() {
@@ -303,28 +565,28 @@ var SubManagerClient = class {
 		this.resolveReady();
 	}
 	handleClose() {
-		logger$5.info("sub-manager client: socket closed");
+		logger$3.info("sub-manager client: socket closed");
 		this.markBusy();
 	}
 	handleOpen() {
 		if (!this.hasConnectedOnce) {
 			this.hasConnectedOnce = true;
-			logger$5.info("sub-manager client: initial connect");
+			logger$3.info("sub-manager client: initial connect");
 			this.markReady();
 			return;
 		}
-		logger$5.info("sub-manager client: reconnected — starting recovery");
+		logger$3.info("sub-manager client: reconnected — starting recovery");
 		this.runRecovery();
 	}
 	async runRecovery() {
 		try {
 			if (this.recoveryDriver) await this.recoveryDriver();
-			else logger$5.warn("sub-manager client: no recoveryDriver configured — skipping recovery step");
+			else logger$3.warn("sub-manager client: no recoveryDriver configured — skipping recovery step");
 			await this.flushBuffer();
 		} catch (err) {
-			logger$5.error(err, "Recovery failed; state will be marked ready anyway");
+			logger$3.error(err, "Recovery failed; state will be marked ready anyway");
 		} finally {
-			logger$5.info("sub-manager client: recovery complete");
+			logger$3.info("sub-manager client: recovery complete");
 			this.markReady();
 		}
 	}
@@ -342,7 +604,7 @@ var SubManagerClient = class {
 };
 //#endregion
 //#region src/jobs/scheduler.ts
-const logger$4 = logger.child({ name: "SCHEDULER" }, { level: logLevelOf("SCHEDULER_LOG_LEVEL") });
+const logger$2 = logger.child({ name: "SCHEDULER" }, { level: logLevelOf("SCHEDULER_LOG_LEVEL") });
 function delayMsFrom(opts) {
 	if (opts?.runAt) return Math.max(0, opts.runAt.getTime() - Date.now());
 	if (opts?.delaySeconds && opts.delaySeconds > 0) return opts.delaySeconds * 1e3;
@@ -372,18 +634,18 @@ var DevScheduler = class {
 		for (const job of jobs) {
 			const endpoint = endpointFor(job.name);
 			const timer = setInterval(() => {
-				this.post(endpoint, {}).catch((err) => logger$4.error(err, `dev recurring job "${job.name}" failed`));
+				this.post(endpoint, {}).catch((err) => logger$2.error(err, `dev recurring job "${job.name}" failed`));
 			}, this.intervalMs);
 			timer.unref?.();
 			this.intervals.set(job.name, timer);
-			logger$4.info(`dev schedule "${job.name}" (cron "${job.cron}") → firing every ${this.intervalMs}ms`);
+			logger$2.info(`dev schedule "${job.name}" (cron "${job.cron}") → firing every ${this.intervalMs}ms`);
 		}
 	}
 	async enqueue(name, body, endpoint, opts) {
 		const id = crypto.randomUUID();
 		const timer = setTimeout(() => {
 			this.timeouts.delete(id);
-			this.post(endpoint, body).catch((err) => logger$4.error(err, `dev one-shot job "${name}" failed`));
+			this.post(endpoint, body).catch((err) => logger$2.error(err, `dev one-shot job "${name}" failed`));
 		}, delayMsFrom(opts));
 		timer.unref?.();
 		this.timeouts.set(id, timer);
@@ -441,7 +703,7 @@ var QStashScheduler = class {
 				url: req.url
 			});
 		} catch (err) {
-			logger$4.warn(err, `signature verification failed for job "${req.name}"`);
+			logger$2.warn(err, `signature verification failed for job "${req.name}"`);
 			return false;
 		}
 	}
@@ -451,15 +713,15 @@ var QStashScheduler = class {
 		try {
 			existing = await this.client.schedules.list();
 		} catch (err) {
-			logger$4.error(err, "failed to list QStash schedules; skipping reconcile of stale schedules");
+			logger$2.error(err, "failed to list QStash schedules; skipping reconcile of stale schedules");
 		}
 		for (const schedule of existing) {
 			const id = schedule.scheduleId;
 			if (id?.startsWith(SCHEDULE_ID_PREFIX) && !desired.has(id)) try {
 				await this.client.schedules.delete(id);
-				logger$4.info(`removed stale QStash schedule ${id}`);
+				logger$2.info(`removed stale QStash schedule ${id}`);
 			} catch (err) {
-				logger$4.error(err, `failed to remove stale schedule ${id}`);
+				logger$2.error(err, `failed to remove stale schedule ${id}`);
 			}
 		}
 		for (const [scheduleId, job] of desired) try {
@@ -468,9 +730,9 @@ var QStashScheduler = class {
 				destination: endpointFor(job.name),
 				cron: job.cron
 			});
-			logger$4.info(`synced QStash schedule "${job.name}" (${job.cron})`);
+			logger$2.info(`synced QStash schedule "${job.name}" (${job.cron})`);
 		} catch (err) {
-			logger$4.error(err, `failed to sync schedule for job "${job.name}"`);
+			logger$2.error(err, `failed to sync schedule for job "${job.name}"`);
 			throw err;
 		}
 	}
@@ -557,7 +819,6 @@ var FixedWindowRateLimiter = class {
 };
 //#endregion
 //#region src/server/http-rpc.ts
-const logger$3 = logger.child({ name: "HTTP_RPC" }, { level: logLevelOf("SERVER_LOG_LEVEL") });
 /**
 * Handles the one-shot HTTP RPC transport: a single `POST {path}` endpoint for
 * `query`/`mutation`/`action`. The procedure name travels in the request body
@@ -573,44 +834,87 @@ const logger$3 = logger.child({ name: "HTTP_RPC" }, { level: logLevelOf("SERVER_
 */
 var HttpRpcHandler = class {
 	deps;
+	/** The RPC endpoint path (always set; claimed even when disabled so a call is
+	* explicitly rejected rather than silently falling through). */
 	path;
 	rpc;
+	rpcEnabled;
 	rateLimiter;
+	/** Job webhook prefix (`{jobPath}/`) — a job POST is `{jobPath}/<jobName>`. */
+	jobPrefix;
 	constructor(deps) {
 		this.deps = deps;
 		this.rpc = deps.rpc;
+		this.rpcEnabled = deps.rpcEnabled;
 		this.path = normalizeRpcPath(deps.rpc.path ?? "/_rpc");
-		if (deps.rpc.rateLimit !== false) {
+		if (this.rpcEnabled && deps.rpc.rateLimit !== false) {
 			const rl = deps.rpc.rateLimit ?? {};
 			this.rateLimiter = new FixedWindowRateLimiter(rl.windowMs ?? 6e4, rl.max ?? 120);
 		}
+		this.jobPrefix = `${deps.jobPath}/`;
 	}
-	/** True when this handler owns the given request path. The procedure name is
-	* carried in the body now, so a single exact path is the whole surface. */
+	/** True when this handler owns the given request path as an RPC call. The
+	* procedure name is carried in the body now, so a single exact path is the
+	* whole RPC surface. Claims the path even when disabled so {@link handle}
+	* rejects the call explicitly. */
 	handlesPath(path) {
 		return path === this.path;
 	}
+	/** True when the path is a job webhook (`{jobPath}/<name>`). */
+	handlesJobPath(path) {
+		return path.startsWith(this.jobPrefix);
+	}
 	stop() {
 		this.rateLimiter?.stop();
 	}
 	async handle(req, res, path) {
+		if (!this.rpcEnabled) return this.send(res, 404, {
+			success: false,
+			error: "not found",
+			code: "NOT_FOUND"
+		});
 		this.applyCors(req, res);
 		if (req.method === "OPTIONS") {
 			res.writeHead(204);
 			res.end();
 			return;
 		}
-		if (req.method !== "POST") return this.send(res, 405, {
-			success: false,
-			error: "method not allowed",
-			code: "METHOD_NOT_ALLOWED"
-		});
+		const startedAt = startTimer();
+		const reqId = crypto.randomUUID().slice(0, 8);
+		let procName;
+		let kind;
+		let userId;
+		let span;
+		const record = (outcome, opts) => {
+			this.deps.obs.record({
+				op: "rpc",
+				transport: "http",
+				procedure: procName,
+				kind,
+				outcome,
+				durationMs: elapsedMs(startedAt),
+				code: opts?.code,
+				error: opts?.error,
+				reqId,
+				userId: userId ?? void 0,
+				span
+			});
+		};
+		if (req.method !== "POST") {
+			record("error", { code: "METHOD_NOT_ALLOWED" });
+			return this.send(res, 405, {
+				success: false,
+				error: "method not allowed",
+				code: "METHOD_NOT_ALLOWED"
+			});
+		}
 		if (this.rateLimiter) {
 			const keyBy = this.rpc.rateLimit ? this.rpc.rateLimit.keyBy : void 0;
 			const key = keyBy ? keyBy(req) : clientIp(req);
 			const rl = this.rateLimiter.check(key);
 			if (!rl.allowed) {
 				res.setHeader("retry-after", String(Math.ceil(rl.retryAfterMs / 1e3)));
+				record("error", { code: "RATE_LIMITED" });
 				return this.send(res, 429, {
 					success: false,
 					error: "rate limit exceeded",
@@ -629,44 +933,88 @@ var HttpRpcHandler = class {
 			rawInput = envelope.input ?? {};
 			minTs = typeof envelope.minTs === "string" ? parseMinTs$1(envelope.minTs) : void 0;
 		} catch {
+			record("error", { code: "BAD_REQUEST" });
 			return this.send(res, 400, {
 				success: false,
 				error: "invalid request",
 				code: "BAD_REQUEST"
 			});
 		}
+		procName = name;
 		const procedure = this.deps.getRegistry()?.getProcedure(name);
-		if (!procedure || procedure.internal || procedure.type === "job") return this.send(res, 404, {
-			success: false,
-			error: "not found",
-			code: "NOT_FOUND"
-		});
+		if (!procedure || procedure.internal || procedure.type === "job") {
+			record("error", { code: "NOT_FOUND" });
+			return this.send(res, 404, {
+				success: false,
+				error: "not found",
+				code: "NOT_FOUND"
+			});
+		}
+		kind = procedure.type;
 		const auth = await this.resolveAuth(req);
-		if (!auth.ok) return this.send(res, 401, {
-			success: false,
-			error: auth.message,
-			code: "UNAUTHENTICATED"
-		});
+		if (!auth.ok) {
+			record("error", { code: "UNAUTHENTICATED" });
+			return this.send(res, 401, {
+				success: false,
+				error: auth.message,
+				code: "UNAUTHENTICATED"
+			});
+		}
+		userId = this.deps.getUserId?.(auth.ctx);
 		let input;
 		try {
-			input = procedure.inputSchema.parse(rawInput);
+			const parseRes = procedure.inputSchema.safeParse(rawInput);
+			if (!parseRes.success) {
+				record("error", { code: "BAD_REQUEST" });
+				return this.send(res, 400, {
+					success: false,
+					error: `Invalid input: ${parseRes.error.issues[0]?.message ?? "Unknow error"}`,
+					code: "BAD_REQUEST"
+				});
+			}
+			input = parseRes.data;
 		} catch (err) {
-			logger$3.warn(err, `RPC "${name}" received invalid input`);
+			record("error", {
+				code: "BAD_REQUEST",
+				error: err
+			});
 			return this.send(res, 400, {
 				success: false,
 				error: "invalid input",
 				code: "BAD_REQUEST"
 			});
 		}
+		const started = this.deps.obs.startSpan(`rpc.${kind} ${name}`, {
+			transport: "http",
+			procedure: name,
+			kind,
+			parent: this.deps.obs.extractContext(req.headers)
+		});
+		span = started.span;
+		const traceId = this.deps.obs.traceIdOf(span);
+		const handlerObs = {
+			log: this.deps.obs.lazyChildLogger({
+				reqId,
+				procedure: name,
+				kind,
+				...userId != null ? { userId } : {},
+				...traceId ? { traceId } : {}
+			}),
+			span
+		};
 		try {
-			const { data, ts } = await this.runProcedure(procedure, input, auth.ctx, minTs);
+			const { data, ts } = await context.with(started.context, () => this.runProcedure(procedure, input, auth.ctx, minTs, handlerObs));
+			record("ok");
 			return this.send(res, 200, {
 				success: true,
 				data,
 				ts: ts?.toString()
 			});
 		} catch (err) {
-			logger$3.error(err, `RPC "${name}" failed`);
+			record("error", {
+				code: "EXECUTION_ERROR",
+				error: err
+			});
 			return this.send(res, 500, {
 				success: false,
 				error: err instanceof Error ? err.message : "execution failed",
@@ -674,10 +1022,97 @@ var HttpRpcHandler = class {
 			});
 		}
 	}
-	async runProcedure(procedure, input, serverCtx, minTs) {
+	/**
+	* Handles a job webhook: `POST {jobPath}/<jobName>`. Kept alongside {@link handle}
+	* so the whole HTTP surface (RPC + jobs) lives in one class. Every job POST is
+	* authenticated by the configured scheduler BEFORE any lookup or work — a forged
+	* POST must not even learn whether a job name exists. Returns 500 on handler
+	* failure so the scheduler retries (jobs must be idempotent).
+	*/
+	async handleJob(req, res, path) {
+		if (req.method !== "POST") return this.send(res, 405, { error: "method not allowed" });
+		const name = decodeURIComponent(path.slice(this.jobPrefix.length));
+		if (!name || name.includes("/")) return this.send(res, 404, { error: "unknown job" });
+		if (!this.deps.jobScheduler) return this.send(res, 503, { error: "jobs not enabled" });
+		const startedAt = startTimer();
+		const rawBody = await readBody(req);
+		let verified = false;
+		try {
+			verified = await this.deps.jobScheduler.verify({
+				name,
+				rawBody,
+				headers: lowercaseHeaders(req.headers),
+				url: this.deps.endpointFor(name)
+			});
+		} catch (err) {
+			this.deps.obs.logger.warn(err, `job "${name}" verification threw`);
+		}
+		if (!verified) return this.send(res, 401, { error: "invalid signature" });
+		const procedure = this.deps.getRegistry()?.getProcedure(name);
+		if (!procedure || procedure.type !== "job") return this.send(res, 404, { error: "unknown job" });
+		let input;
+		try {
+			const parsed = rawBody.trim().length > 0 ? JSON.parse(rawBody) : {};
+			input = procedure.inputSchema.parse(parsed);
+		} catch (err) {
+			this.deps.obs.logger.warn(err, `job "${name}" received an invalid payload`);
+			return this.send(res, 400, { error: "invalid payload" });
+		}
+		const started = this.deps.obs.startSpan(`job ${name}`, {
+			transport: "http",
+			procedure: name,
+			kind: "job",
+			parent: this.deps.obs.extractContext(req.headers)
+		});
+		const span = started.span;
+		const traceId = this.deps.obs.traceIdOf(span);
+		const jobLog = this.deps.obs.lazyChildLogger({
+			reqId: span && traceId ? traceId : name,
+			procedure: name,
+			kind: "job",
+			...traceId ? { traceId } : {}
+		});
+		try {
+			const serverCtx = this.deps.jobContext ? await this.deps.jobContext() : void 0;
+			const fn = procedure.fn;
+			const result = await context.with(started.context, () => fn({
+				db: this.deps.db,
+				serverCtx,
+				log: jobLog,
+				span
+			}, input));
+			this.deps.obs.record({
+				op: "job",
+				transport: "http",
+				procedure: name,
+				kind: "job",
+				outcome: "ok",
+				durationMs: elapsedMs(startedAt),
+				span
+			});
+			return this.send(res, 200, {
+				ok: true,
+				result
+			});
+		} catch (err) {
+			this.deps.obs.record({
+				op: "job",
+				transport: "http",
+				procedure: name,
+				kind: "job",
+				outcome: "error",
+				durationMs: elapsedMs(startedAt),
+				code: "JOB_FAILED",
+				error: err,
+				span
+			});
+			return this.send(res, 500, { error: "job failed" });
+		}
+	}
+	async runProcedure(procedure, input, serverCtx, minTs, handlerObs) {
 		if (procedure.type === "query") {
 			const lastSnapshotTs = await this.deps.db.impl.getLatestSnapshotTimestamp();
-			return runCachedQuery(this.deps.oneShotDeps, procedure, procedure.name, input, serverCtx, lastSnapshotTs, minTs);
+			return runCachedQuery(this.deps.oneShotDeps, procedure, procedure.name, input, serverCtx, lastSnapshotTs, minTs, handlerObs);
 		}
 		if (procedure.type === "mutation") {
 			const res = await this.deps.db.mutation(async (ctx) => {
@@ -685,7 +1120,9 @@ var HttpRpcHandler = class {
 				return fn({
 					db: ctx,
 					serverCtx,
-					...primaryOnlyConn
+					...primaryOnlyConn,
+					log: handlerObs?.log,
+					span: handlerObs?.span
 				}, input);
 			});
 			return {
@@ -698,7 +1135,9 @@ var HttpRpcHandler = class {
 			db: this.deps.db,
 			serverCtx,
 			storage: this.deps.storage,
-			scheduler: this.deps.scheduler
+			scheduler: this.deps.scheduler,
+			log: handlerObs?.log,
+			span: handlerObs?.span
 		}, input) };
 	}
 	async resolveAuth(req) {
@@ -769,6 +1208,11 @@ function defaultHttpAuth(req) {
 	const match = /^Bearer\s+(.+)$/i.exec(value);
 	return match ? { token: match[1] } : void 0;
 }
+function lowercaseHeaders(headers) {
+	const out = {};
+	for (const [k, v] of Object.entries(headers)) out[k.toLowerCase()] = Array.isArray(v) ? v.join(",") : v;
+	return out;
+}
 function clientIp(req) {
 	const xff = req.headers["x-forwarded-for"];
 	if (xff) {
@@ -840,7 +1284,6 @@ const CLIENT_TIMEOUT_MS = 12e4;
 * mutation triggers a new race.
 */
 const RECOMPUTE_LOCK_TTL_SECONDS = Number(process.env.SUPALIVE_RECOMPUTE_LOCK_TTL_SECONDS ?? 10);
-const logger$2 = logger.child({ "name": "SUPALIVE" }, { level: logLevelOf("SERVER_LOG_LEVEL") });
 /**
 * Supalive WebSocket Server
 */
@@ -861,6 +1304,8 @@ var SupaliveWebSocketServer = class {
 	scheduler;
 	jobPath;
 	jobClient;
+	/** Owns the HTTP surface: one-shot RPC (when `config.rpc` is set) AND the job
+	* webhook. Always constructed — jobs work even without RPC enabled. */
 	rpcHandler;
 	/** Optional object storage exposed to every procedure as `ctx.storage`. */
 	storage;
@@ -872,6 +1317,10 @@ var SupaliveWebSocketServer = class {
 		totalConnections: 0,
 		activeSubscriptions: 0
 	};
+	/** Structured logs + OTel metrics + the per-operation `onEvent` seam. */
+	obs;
+	/** The request/lifecycle logger (injectable via `config.observability.logger`). */
+	log;
 	constructor(config) {
 		this.config = {
 			port: 3e3,
@@ -881,6 +1330,15 @@ var SupaliveWebSocketServer = class {
 			...config
 		};
 		this.instanceId = appInstanceId;
+		this.obs = new Observability({
+			logger: (config.observability?.logger ?? logger).child({ name: "SUPALIVE" }, { level: config.observability?.level ?? logLevelOf("SERVER_LOG_LEVEL") }),
+			level: void 0,
+			requestLog: config.observability?.requestLog,
+			onEvent: config.observability?.onEvent,
+			meterName: config.observability?.meterName,
+			meterVersion: config.observability?.meterVersion
+		});
+		this.log = this.obs.logger;
 		if (config.subManager) this.subManagerClient = config.subManager;
 		else if (config.subManagerUrl) this.subManagerClient = new SubManagerClient(config.subManagerUrl);
 		else throw new Error("either `subManager` (in-process link) or `subManagerUrl` (WebSocket URL) is required");
@@ -890,7 +1348,7 @@ var SupaliveWebSocketServer = class {
 		this.db = config.database;
 		this.storage = config.storage;
 		this.db.setOnAfterCommit((writeSet, commitTs) => {
-			this.handleMutationCommit(writeSet, commitTs).catch((err) => logger$2.error(err, "post-commit invalidation failed"));
+			this.handleMutationCommit(writeSet, commitTs).catch((err) => this.log.error(err, "post-commit invalidation failed"));
 		});
 		this.scheduler = config.scheduler;
 		this.jobPath = normalizeJobPath(config.jobPath ?? "/_jobs");
@@ -901,20 +1359,27 @@ var SupaliveWebSocketServer = class {
 			getUserId: config.getUserId,
 			getMinRetainedTs: () => this.retentionWatermark.get()
 		};
-		if (config.rpc) this.rpcHandler = new HttpRpcHandler({
+		this.rpcHandler = new HttpRpcHandler({
 			getRegistry: () => this.contextRegistry,
 			db: this.db,
 			oneShotDeps: this.oneShotDeps,
 			verifyAuth: config.verifyAuth,
-			rpc: config.rpc,
+			rpc: config.rpc ?? {},
+			rpcEnabled: config.rpc !== void 0,
 			storage: this.storage,
-			scheduler: this.jobClient
+			scheduler: this.jobClient,
+			obs: this.obs,
+			getUserId: config.getUserId,
+			jobScheduler: this.scheduler,
+			jobContext: config.jobContext,
+			jobPath: this.jobPath,
+			endpointFor: (name) => this.endpointFor(name)
 		});
 		this.subManagerClient.setRecoveryDriver(this.runSubManagerRecovery.bind(this));
 		this.subManagerClient.setAffectedHandler(this.runAffectedHandler.bind(this));
 		this.httpServer = createServer((req, res) => {
 			this.handleHttpRequest(req, res).catch((err) => {
-				logger$2.error(err, "HTTP request handler error");
+				this.log.error(err, "HTTP request handler error");
 				if (!res.headersSent) {
 					res.writeHead(500, { "content-type": "application/json" });
 					res.end(JSON.stringify({ error: "internal error" }));
@@ -944,7 +1409,7 @@ var SupaliveWebSocketServer = class {
 	startSessionHeartbeat(session) {
 		session.heartbeatTimer = setInterval(() => {
 			if (Date.now() - session.lastReceivedAt > CLIENT_TIMEOUT_MS) {
-				logger$2.info(`ws inactivity → terminate session ${session.id}`);
+				this.log.info(`ws inactivity → terminate session ${session.id}`);
 				try {
 					session.ws.terminate();
 				} catch {}
@@ -970,11 +1435,11 @@ var SupaliveWebSocketServer = class {
 		try {
 			await this.retentionWatermark.loadFrom(this.db.impl);
 		} catch (err) {
-			logger$2.error(err, "failed to load initial retention watermark");
+			this.log.error(err, "failed to load initial retention watermark");
 		}
 		await new Promise((resolve) => {
 			this.httpServer.listen(this.config.port, this.config.host, () => {
-				logger$2.info(`Server: ${this.instanceId} listening on ${this.config.host}:${this.config.port}`);
+				this.log.info(`Server: ${this.instanceId} listening on ${this.config.host}:${this.config.port}`);
 				resolve();
 			});
 		});
@@ -995,9 +1460,9 @@ var SupaliveWebSocketServer = class {
 		if (jobs.length === 0) return;
 		try {
 			await this.scheduler.syncSchedules(jobs, (name) => this.endpointFor(name));
-			logger$2.info(`Synced ${jobs.length} recurring job schedule(s)`);
+			this.log.info(`Synced ${jobs.length} recurring job schedule(s)`);
 		} catch (err) {
-			logger$2.error(err, "Failed to sync job schedules");
+			this.log.error(err, "Failed to sync job schedules");
 		}
 	}
 	/** Absolute URL the scheduler POSTs to for a given job name. */
@@ -1028,9 +1493,9 @@ var SupaliveWebSocketServer = class {
 	async stop() {
 		this.wss.close();
 		for (const [ws] of this.sessions) ws.close(1001, "Server shutting down");
-		this.rpcHandler?.stop();
+		this.rpcHandler.stop();
 		this.httpServer.close();
-		logger$2.info("Server stopped");
+		this.log.info("Server stopped");
 	}
 	getStats() {
 		return {
@@ -1054,63 +1519,25 @@ var SupaliveWebSocketServer = class {
 			status: "ok",
 			instanceId: this.instanceId
 		});
-		if (this.rpcHandler && this.rpcHandler.handlesPath(path)) return this.rpcHandler.handle(req, res, path);
-		const jobPrefix = `${this.jobPath}/`;
-		if (!path.startsWith(jobPrefix)) return sendJson(res, 404, { error: "not found" });
-		if (req.method !== "POST") return sendJson(res, 405, { error: "method not allowed" });
-		const name = decodeURIComponent(path.slice(jobPrefix.length));
-		if (!name || name.includes("/")) return sendJson(res, 404, { error: "unknown job" });
-		if (!this.scheduler) return sendJson(res, 503, { error: "jobs not enabled" });
-		const rawBody = await readRequestBody(req);
-		let verified = false;
-		try {
-			verified = await this.scheduler.verify({
-				name,
-				rawBody,
-				headers: lowercaseHeaders(req.headers),
-				url: this.endpointFor(name)
-			});
-		} catch (err) {
-			logger$2.warn(err, `job "${name}" verification threw`);
-		}
-		if (!verified) return sendJson(res, 401, { error: "invalid signature" });
-		const procedure = this.contextRegistry?.getProcedure(name);
-		if (!procedure || procedure.type !== "job") return sendJson(res, 404, { error: "unknown job" });
-		let input;
-		try {
-			const parsed = rawBody.trim().length > 0 ? JSON.parse(rawBody) : {};
-			input = procedure.inputSchema.parse(parsed);
-		} catch (err) {
-			logger$2.warn(err, `job "${name}" received an invalid payload`);
-			return sendJson(res, 400, { error: "invalid payload" });
-		}
-		try {
-			const serverCtx = this.config.jobContext ? await this.config.jobContext() : void 0;
-			const fn = procedure.fn;
-			const result = await fn({
-				db: this.db,
-				serverCtx
-			}, input);
-			logger$2.info(`job "${name}" completed`);
-			return sendJson(res, 200, {
-				ok: true,
-				result
-			});
-		} catch (err) {
-			logger$2.error(err, `job "${name}" failed`);
-			return sendJson(res, 500, { error: "job failed" });
+		if (this.rpcHandler.handlesPath(path)) return this.rpcHandler.handle(req, res, path);
+		if (this.rpcHandler.handlesJobPath(path)) return this.rpcHandler.handleJob(req, res, path);
+		if (this.config.onHttpRequest) {
+			if (await this.config.onHttpRequest(req, res)) return;
 		}
+		return sendJson(res, 404, { error: "not found" });
 	}
 	setupWebSocketHandlers() {
 		this.wss.on("connection", (ws, req) => {
 			this.handleConnection(ws, req).catch((err) => {
-				logger$2.error(err, "Connection handler error");
+				this.log.error(err, "Connection handler error");
 			});
 		});
 	}
 	async handleConnection(ws, req) {
 		this.stats.totalConnections++;
 		this.stats.activeConnections++;
+		this.obs.connectionOpened();
+		const connectedAt = startTimer();
 		const session = {
 			id: v4(),
 			ws,
@@ -1123,7 +1550,10 @@ var SupaliveWebSocketServer = class {
 			lastSentAt: Date.now(),
 			heartbeatTimer: null
 		};
-		logger$2.info(`New session: ${session.id}`);
+		this.log.info({
+			sessionId: session.id,
+			activeConnections: this.stats.activeConnections
+		}, `New session: ${session.id}`);
 		this.sessions.set(ws, session);
 		this.sendMessage(session, {
 			type: "connected",
@@ -1132,7 +1562,7 @@ var SupaliveWebSocketServer = class {
 		ws.on("message", (data) => {
 			session.lastReceivedAt = Date.now();
 			this.handleMessage(session, data.toString()).catch((err) => {
-				logger$2.error(err, "Message handler error");
+				this.log.error(err, "Message handler error");
 			});
 		});
 		ws.on("ping", () => {
@@ -1143,17 +1573,24 @@ var SupaliveWebSocketServer = class {
 		});
 		this.startSessionHeartbeat(session);
 		ws.on("close", (code) => {
-			logger$2.info(`Connection closed: ${session.id}, code: ${code}`);
 			this.clearSessionTimers(session);
 			this.handleDisconnect(session);
 			this.sessions.delete(ws);
 			this.stats.activeConnections--;
+			this.obs.connectionClosed();
+			this.log.info({
+				sessionId: session.id,
+				code,
+				durMs: elapsedMs(connectedAt),
+				activeConnections: this.stats.activeConnections
+			}, `Connection closed: ${session.id}, code: ${code}`);
 		});
 		ws.on("error", (err) => {
-			logger$2.error(err, "Websocket error");
+			this.log.error(err, "Websocket error");
 		});
 	}
 	async handleMessage(session, message) {
+		const startedAt = startTimer();
 		try {
 			const rawMsg = JSON.parse(message);
 			const parseResult = ClientMessageSchema.safeParse(rawMsg);
@@ -1161,22 +1598,22 @@ var SupaliveWebSocketServer = class {
 				this.sendError(session, "", "Invalid message format", "INVALID_MESSAGE");
 				return;
 			}
-			await this.processMessage(session, parseResult.data);
+			await this.processMessage(session, parseResult.data, startedAt);
 		} catch (err) {
-			logger$2.error(err, "Message handling error");
+			this.log.error(err, "Message handling error");
 			this.sendError(session, "", "Parse error", "PARSE_ERROR");
 		}
 	}
-	async processMessage(session, msg) {
+	async processMessage(session, msg, startedAt) {
 		switch (msg.type) {
 			case "auth":
 				await this.handleAuth(session, msg.data);
 				break;
 			case "call":
-				await this.handleCall(session, msg.id, msg.procedure, msg.input, parseMinTs(msg.minTs));
+				await this.handleCall(session, msg.id, msg.procedure, msg.input, startedAt, parseMinTs(msg.minTs), msg.trace);
 				break;
 			case "subscribe":
-				await this.handleSubscribe(session, msg.id, msg.procedure, msg.input);
+				await this.handleSubscribe(session, msg.id, msg.procedure, msg.input, startedAt, msg.trace);
 				break;
 			case "unsubscribe":
 				await this.handleUnsubscribe(session, msg.subId);
@@ -1224,16 +1661,17 @@ var SupaliveWebSocketServer = class {
 	* session. Callers (handleCall) own the response/error for their own
 	* op via the returned promise.
 	*/
-	enqueueMutation(session, procedure, validatedInput) {
+	enqueueMutation(session, procedure, validatedInput, handlerObs) {
 		return new Promise((resolve, reject) => {
 			const pending = {
 				procedure,
 				validatedInput,
 				resolve,
-				reject
+				reject,
+				handlerObs
 			};
 			session.mutationQueue.push(pending);
-			this.drainMutationQueue(session).catch((err) => logger$2.error(err, "drainMutationQueue crashed"));
+			this.drainMutationQueue(session).catch((err) => this.log.error(err, "drainMutationQueue crashed"));
 		});
 	}
 	/**
@@ -1249,13 +1687,17 @@ var SupaliveWebSocketServer = class {
 				const op = session.mutationQueue.shift();
 				try {
 					const fn = op.procedure.fn;
-					const result = await this.db.mutation(async (ctx) => {
+					const runMutation = () => this.db.mutation(async (ctx) => {
 						return fn({
 							db: ctx,
 							serverCtx: session.serverCtx,
-							...primaryOnlyConn
+							...primaryOnlyConn,
+							log: op.handlerObs?.log,
+							span: op.handlerObs?.span
 						}, op.validatedInput);
 					});
+					const parentSpan = op.handlerObs?.span;
+					const result = parentSpan?.isRecording() ? await context.with(trace.setSpan(context.active(), parentSpan), runMutation) : await runMutation();
 					op.resolve(result);
 				} catch (err) {
 					op.reject(err);
@@ -1265,81 +1707,181 @@ var SupaliveWebSocketServer = class {
 			session.mutationInFlight = false;
 		}
 	}
-	async handleCall(session, id, procedureName, input, minTs) {
+	async handleCall(session, id, procedureName, input, startedAt, minTs, trace) {
+		const userId = this.config.getUserId?.(session.serverCtx) ?? void 0;
+		let span;
+		const record = (outcome, opts) => {
+			this.obs.record({
+				op: "rpc",
+				transport: "ws",
+				procedure: procedureName,
+				kind: opts?.kind,
+				outcome,
+				durationMs: elapsedMs(startedAt),
+				code: opts?.code,
+				error: opts?.error,
+				sessionId: session.id,
+				reqId: id,
+				userId,
+				span
+			});
+		};
 		if (!this.router) {
 			this.sendError(session, id, "Router not registered", "SERVER_ERROR");
+			record("error", { code: "SERVER_ERROR" });
 			return;
 		}
 		const procedure = this.contextRegistry.getProcedure(procedureName);
 		if (!procedure || procedure.type === "job") {
 			this.sendError(session, id, `Procedure "${procedureName}" not found`, "NOT_FOUND");
+			record("error", { code: "NOT_FOUND" });
 			return;
 		}
-		try {
-			const validatedInput = procedure.inputSchema.parse(input);
-			if (procedure.type === "query") {
-				const lastSnapshotTs = await this.db.impl.getLatestSnapshotTimestamp();
-				const { data, ts } = await runCachedQuery(this.oneShotDeps, procedure, procedureName, validatedInput, session.serverCtx, lastSnapshotTs, minTs);
-				this.sendMessage(session, {
-					type: "response",
-					id,
-					success: true,
-					data,
-					ts: ts.toString()
-				});
-			} else if (procedure.type === "mutation") {
-				if (session.mutationQueue.length >= MAX_MUTATION_QUEUE_BUFFER) {
-					this.sendError(session, id, `Too many concurrent mutations on this connection (max ${MAX_MUTATION_QUEUE_BUFFER})`, "TOO_MANY_CONCURRENT_MUTATIONS");
-					return;
-				}
-				const mutationResult = await this.enqueueMutation(session, procedure, validatedInput);
-				this.sendMessage(session, {
-					type: "response",
-					id,
-					success: true,
-					data: mutationResult.result,
-					ts: mutationResult.commitTs.toString()
-				});
-			} else if (procedure.type === "action") {
-				if (session.actionInFlight >= MAX_ACTION_CONCURRENCY) {
-					this.sendError(session, id, `Too many concurrent actions on this connection (max ${MAX_ACTION_CONCURRENCY})`, "TOO_MANY_CONCURRENT_ACTIONS");
-					return;
-				}
-				session.actionInFlight++;
-				let result;
-				try {
-					const fn = procedure.fn;
-					result = await fn({
-						db: this.db,
-						serverCtx: session.serverCtx,
-						storage: this.storage,
-						scheduler: this.jobClient
-					}, validatedInput);
-				} finally {
-					session.actionInFlight--;
+		const kind = procedure.type;
+		const parent = trace ? this.obs.extractContext({ traceparent: trace }) : void 0;
+		const started = this.obs.startSpan(`rpc.${kind} ${procedureName}`, {
+			transport: "ws",
+			procedure: procedureName,
+			kind,
+			parent
+		});
+		span = started.span;
+		const traceId = this.obs.traceIdOf(span);
+		const handlerObs = {
+			log: this.obs.lazyChildLogger({
+				reqId: id,
+				sessionId: session.id,
+				procedure: procedureName,
+				kind,
+				...userId != null ? { userId } : {},
+				...traceId ? { traceId } : {}
+			}),
+			span
+		};
+		await context.with(started.context, async () => {
+			try {
+				const validatedInput = procedure.inputSchema.parse(input);
+				if (procedure.type === "query") {
+					const lastSnapshotTs = await this.db.impl.getLatestSnapshotTimestamp();
+					const { data, ts } = await runCachedQuery(this.oneShotDeps, procedure, procedureName, validatedInput, session.serverCtx, lastSnapshotTs, minTs, handlerObs);
+					this.sendMessage(session, {
+						type: "response",
+						id,
+						success: true,
+						data,
+						ts: ts.toString()
+					});
+					record("ok", { kind });
+				} else if (procedure.type === "mutation") {
+					if (session.mutationQueue.length >= MAX_MUTATION_QUEUE_BUFFER) {
+						this.sendError(session, id, `Too many concurrent mutations on this connection (max ${MAX_MUTATION_QUEUE_BUFFER})`, "TOO_MANY_CONCURRENT_MUTATIONS");
+						record("error", {
+							kind,
+							code: "TOO_MANY_CONCURRENT_MUTATIONS"
+						});
+						return;
+					}
+					const mutationResult = await this.enqueueMutation(session, procedure, validatedInput, handlerObs);
+					this.sendMessage(session, {
+						type: "response",
+						id,
+						success: true,
+						data: mutationResult.result,
+						ts: mutationResult.commitTs.toString()
+					});
+					record("ok", { kind });
+				} else if (procedure.type === "action") {
+					if (session.actionInFlight >= MAX_ACTION_CONCURRENCY) {
+						this.sendError(session, id, `Too many concurrent actions on this connection (max ${MAX_ACTION_CONCURRENCY})`, "TOO_MANY_CONCURRENT_ACTIONS");
+						record("error", {
+							kind,
+							code: "TOO_MANY_CONCURRENT_ACTIONS"
+						});
+						return;
+					}
+					session.actionInFlight++;
+					let result;
+					try {
+						const fn = procedure.fn;
+						result = await fn({
+							db: this.db,
+							serverCtx: session.serverCtx,
+							storage: this.storage,
+							scheduler: this.jobClient,
+							log: handlerObs.log,
+							span: handlerObs.span
+						}, validatedInput);
+					} finally {
+						session.actionInFlight--;
+					}
+					this.sendMessage(session, {
+						type: "response",
+						id,
+						success: true,
+						data: result
+					});
+					record("ok", { kind });
 				}
-				this.sendMessage(session, {
-					type: "response",
-					id,
-					success: true,
-					data: result
+			} catch (err) {
+				this.sendError(session, id, err instanceof Error ? err.message : "Execution failed", "EXECUTION_ERROR");
+				record("error", {
+					kind,
+					code: "EXECUTION_ERROR",
+					error: err
 				});
 			}
-		} catch (err) {
-			logger$2.error(err, `Error executing "${procedureName}"`);
-			this.sendError(session, id, err instanceof Error ? err.message : "Execution failed", "EXECUTION_ERROR");
-		}
+		});
 	}
-	async handleSubscribe(session, id, procedureName, input) {
+	async handleSubscribe(session, id, procedureName, input, startedAt, trace) {
+		const userId = this.config.getUserId?.(session.serverCtx) ?? void 0;
+		let span;
+		const record = (outcome, opts) => {
+			this.obs.record({
+				op: "subscribe",
+				transport: "ws",
+				procedure: procedureName,
+				kind: "subscribe",
+				outcome,
+				durationMs: elapsedMs(startedAt),
+				code: opts?.code,
+				error: opts?.error,
+				sessionId: session.id,
+				reqId: id,
+				userId,
+				span
+			});
+		};
 		if (!this.router) {
 			this.sendError(session, id, "Router not registered", "SERVER_ERROR");
+			record("error", { code: "SERVER_ERROR" });
 			return;
 		}
 		const procedure = this.contextRegistry.getProcedure(procedureName);
 		if (!procedure || procedure.type !== "query") {
 			this.sendError(session, id, `Procedure "${procedureName}" not found or not a query`, "NOT_FOUND");
+			record("error", { code: "NOT_FOUND" });
 			return;
 		}
+		const parent = trace ? this.obs.extractContext({ traceparent: trace }) : void 0;
+		const started = this.obs.startSpan(`subscribe ${procedureName}`, {
+			transport: "ws",
+			procedure: procedureName,
+			kind: "subscribe",
+			parent
+		});
+		span = started.span;
+		const traceId = this.obs.traceIdOf(span);
+		const handlerObs = {
+			log: this.obs.lazyChildLogger({
+				reqId: id,
+				sessionId: session.id,
+				procedure: procedureName,
+				kind: "subscribe",
+				...userId != null ? { userId } : {},
+				...traceId ? { traceId } : {}
+			}),
+			span
+		};
 		try {
 			const validatedInput = procedure.inputSchema.parse(input);
 			const queryIdentity = resolveQueryIdentity(procedure, session.serverCtx, validatedInput, this.config.getUserId);
@@ -1359,7 +1901,11 @@ var SupaliveWebSocketServer = class {
 					data = cached.data;
 					servedTs = cached.lastSnapshotTs;
 				} else {
-					liveResult = await this.executeLiveQuery(procedureName, validatedInput, session.serverCtx);
+					liveResult = await this.executeLiveQuery(procedureName, validatedInput, session.serverCtx, {
+						log: handlerObs.log,
+						parentContext: started.context,
+						trigger: "subscribe"
+					});
 					data = liveResult.data;
 					servedTs = liveResult.ts;
 				}
@@ -1384,7 +1930,11 @@ var SupaliveWebSocketServer = class {
 					}
 				}
 				if (rebuild) {
-					liveResult = await this.executeLiveQuery(procedureName, validatedInput, session.serverCtx);
+					liveResult = await this.executeLiveQuery(procedureName, validatedInput, session.serverCtx, {
+						log: handlerObs.log,
+						parentContext: started.context,
+						trigger: "subscribe"
+					});
 					data = liveResult.data;
 					servedTs = liveResult.ts;
 				}
@@ -1394,6 +1944,7 @@ var SupaliveWebSocketServer = class {
 					subscribedTimes: 1
 				});
 				this.stats.activeSubscriptions++;
+				this.obs.subscriptionAdded();
 			}
 			if (liveResult) {
 				const [updateResult] = await Promise.all([this.subManagerClient.updateSubscriptionReadSet({
@@ -1403,7 +1954,7 @@ var SupaliveWebSocketServer = class {
 					readSet: liveResult.readSet,
 					instanceName: this.instanceId
 				}), this.cache.setQueryCacheFor(cacheKey, data, liveResult.ts)]);
-				if (!updateResult.tracked) logger$2.warn(`updateSubscriptionReadSet returned tracked:false immediately after register for ${subId} — possible sub-manager restart mid-subscribe`);
+				if (!updateResult.tracked) this.log.warn(`updateSubscriptionReadSet returned tracked:false immediately after register for ${subId} — possible sub-manager restart mid-subscribe`);
 			}
 			dataHash = await getHashOf(data);
 			this.sendMessage(session, {
@@ -1419,10 +1970,13 @@ var SupaliveWebSocketServer = class {
 				dataHash,
 				ts: servedTs.toString()
 			});
-			logger$2.info(`Subscribed: ${subId} for session ${session.id}`);
+			record("ok", { code: void 0 });
 		} catch (err) {
-			logger$2.error(err, `Error subscribing to "${procedureName}"`);
 			this.sendError(session, id, err instanceof Error ? err.message : "Subscribe failed", "SUBSCRIBE_ERROR");
+			record("error", {
+				code: "SUBSCRIBE_ERROR",
+				error: err
+			});
 		}
 	}
 	async handleUnsubscribe(session, subId) {
@@ -1436,19 +1990,24 @@ var SupaliveWebSocketServer = class {
 			session.subIds.delete(subId);
 			this.serverSubscriptions.delete(subId);
 			this.stats.activeSubscriptions--;
+			this.obs.subscriptionRemoved();
 			try {
 				await this.subManagerClient.unregisterSubscription({
 					subId,
 					instanceName: this.instanceId
 				});
 			} catch (err) {
-				logger$2.error(err, "Failed to unregister from sub-manager:");
+				this.log.error(err, "Failed to unregister from sub-manager:");
 			}
 		}
-		logger$2.info(`Unsubscribed: ${subId} for session ${session.id}, remaining server subs: ${serverSub.subscribedTimes}`);
+		this.log.debug({
+			sessionId: session.id,
+			subId,
+			remaining: serverSub.subscribedTimes
+		}, `Unsubscribed: ${subId} for session ${session.id}`);
 	}
 	async handleDisconnect(session) {
-		logger$2.info(`Session disconnected: ${session.id}`);
+		this.log.info(`Session disconnected: ${session.id}`);
 		let unregisterSubs = void 0;
 		for (const subId of session.subIds) {
 			const sub = this.serverSubscriptions.get(subId);
@@ -1466,13 +2025,14 @@ var SupaliveWebSocketServer = class {
 				instanceName: this.instanceId
 			})));
 		} catch (err) {
-			logger$2.error(err, "Failed to unregister from sub-manager:");
+			this.log.error(err, "Failed to unregister from sub-manager:");
 		}
 		for (const sub of unregisterSubs) if (sub.subscribedTimes <= 0) {
 			this.serverSubscriptions.delete(sub.subId);
 			this.stats.activeSubscriptions--;
+			this.obs.subscriptionRemoved();
 		}
-		logger$2.info(`All Subscription sessions is disconnected: ${session.id}, subs: ${unregisterSubs.length}`);
+		this.log.info(`All Subscription sessions is disconnected: ${session.id}, subs: ${unregisterSubs.length}`);
 	}
 	/**
 	* Drives recovery on a sub-manager reconnect. Iterates this app server's
@@ -1491,10 +2051,10 @@ var SupaliveWebSocketServer = class {
 	async runSubManagerRecovery() {
 		const snapshot = Array.from(this.serverSubscriptions.values());
 		if (snapshot.length === 0) {
-			logger$2.info("Sub-manager recovery: no subscriptions to restore");
+			this.log.info("Sub-manager recovery: no subscriptions to restore");
 			return;
 		}
-		logger$2.info(`Sub-manager recovery: restoring ${snapshot.length} subscription(s)`);
+		this.log.info(`Sub-manager recovery: restoring ${snapshot.length} subscription(s)`);
 		const lastSnapshotTs = await this.db.impl.getLatestSnapshotTimestamp();
 		const subIds = snapshot.map((e) => e.subId);
 		const recordsMap = await this.cache.fetchRegistrationRecordsBatch(subIds);
@@ -1536,11 +2096,11 @@ var SupaliveWebSocketServer = class {
 					});
 				}
 			} catch (err) {
-				logger$2.error(err, `Sub-manager recovery: failed to batch register ${i}-${i + batch.length}`);
+				this.log.error(err, `Sub-manager recovery: failed to batch register ${i}-${i + batch.length}`);
 			}
 		}
-		await Promise.allSettled(recompute.map((a) => this.reexecuteAffectedQuery(a)));
-		logger$2.info(`Sub-manager recovery: done (${recompute.length} reexec'd)`);
+		await Promise.allSettled(recompute.map((a) => this.reexecuteAffectedQuery(a, "recovery")));
+		this.log.info(`Sub-manager recovery: done (${recompute.length} reexec'd)`);
 	}
 	async runAffectedHandler(affected) {
 		await Promise.allSettled(affected.map((a) => this.reexecuteAffectedQuery(a)));
@@ -1557,6 +2117,7 @@ var SupaliveWebSocketServer = class {
 		if (serverSub) {
 			this.serverSubscriptions.delete(subId);
 			this.stats.activeSubscriptions = Math.max(0, this.stats.activeSubscriptions - 1);
+			this.obs.subscriptionRemoved();
 			for (const [, session] of this.sessions) if (session.subIds.has(subId)) {
 				notified++;
 				session.subIds.delete(subId);
@@ -1567,18 +2128,18 @@ var SupaliveWebSocketServer = class {
 				});
 			}
 		}
-		logger$2.warn(`Dropped subscription ${subId} locally (${reason}); notified ${notified} session(s)`);
+		this.log.warn(`Dropped subscription ${subId} locally (${reason}); notified ${notified} session(s)`);
 	}
 	async handleMutationCommit(writeSet, commitTs) {
 		if (writeSet.length === 0) return;
 		const tables = [...new Set(writeSet.map((w) => w.table))];
-		logger$2.debug(`Mutation committed for tables: [${tables.join(", ")}]`);
+		this.log.debug(`Mutation committed for tables: [${tables.join(", ")}]`);
 		try {
 			const result = await this.subManagerClient.invalidateWriteset({ writeSet });
-			logger$2.debug({ affected: result }, "Sub-managers invalidation result");
+			this.log.debug({ affected: result }, "Sub-managers invalidation result");
 			if (result?.affected?.length > 0) await Promise.allSettled(result.affected.map((affected) => this.dispatchAffected(affected, commitTs)));
 		} catch (err) {
-			logger$2.error(err, "Failed to notify sub-managers");
+			this.log.error(err, "Failed to notify sub-managers");
 		}
 	}
 	/**
@@ -1600,7 +2161,7 @@ var SupaliveWebSocketServer = class {
 			return;
 		}
 		if (affected.notifyInstances.length === 0) {
-			logger$2.debug(`dispatchAffected: no live instances hold ${affected.subId} — dropping`);
+			this.log.debug(`dispatchAffected: no live instances hold ${affected.subId} — dropping`);
 			return;
 		}
 		await this.publishRecomputeRace(affected, commitTs);
@@ -1626,23 +2187,23 @@ var SupaliveWebSocketServer = class {
 			try {
 				await redisRetryPolicy.execute(() => this.cache.redis.publish(channel, payload));
 			} catch (err) {
-				logger$2.error(err, `Failed to publish recompute-race to ${channel} after many retries`);
+				this.log.error(err, `Failed to publish recompute-race to ${channel} after many retries`);
 			}
 		});
 		await Promise.all(publishPromises);
 	}
-	async reexecuteAffectedQuery(affected) {
+	async reexecuteAffectedQuery(affected, trigger = "recompute") {
 		let foundSession = null;
 		for (const [, session] of this.sessions) if (session.subIds.has(affected.subId)) {
 			foundSession = session;
 			break;
 		}
 		if (!foundSession) {
-			logger$2.debug(`Session not found for subId: ${affected.subId}`);
+			this.log.debug(`Session not found for subId: ${affected.subId}`);
 			return;
 		}
 		try {
-			const liveResult = await this.executeLiveQuery(affected.queryName, affected.args, foundSession.serverCtx);
+			const liveResult = await this.executeLiveQuery(affected.queryName, affected.args, foundSession.serverCtx, { trigger });
 			const dataHash = await getHashOf(liveResult.data);
 			const [updateResult] = await Promise.all([this.subManagerClient.updateSubscriptionReadSet({
 				cacheKey: affected.cacheKey,
@@ -1664,21 +2225,23 @@ var SupaliveWebSocketServer = class {
 				ts
 			});
 			if (affected.notifyInstances.length > 0) await this.publishSubscriptionUpdate(affected.subId, liveResult.data, dataHash, affected.notifyInstances, ts);
-			logger$2.debug(`Re-executed affected query for subId: ${affected.subId}`);
+			this.log.debug(`Re-executed affected query for subId: ${affected.subId}`);
 		} catch (err) {
-			logger$2.error(err, `Failed to re-execute query for subId ${affected.subId}`);
+			this.log.error(err, `Failed to re-execute query for subId ${affected.subId}`);
 		}
 	}
-	async executeLiveQuery(procedureName, input, serverCtx) {
+	async executeLiveQuery(procedureName, input, serverCtx, opts) {
 		const procedure = this.contextRegistry.getProcedure(procedureName);
 		if (!procedure || procedure.type !== "query") throw new Error(`Procedure not defined: ${procedureName}`);
 		return this.db.liveQuery(async (ctx) => {
 			const fn = procedure.fn;
-			return fn({
+			return traceQueryExecution(procedureName, opts?.trigger ?? "recompute", opts?.parentContext, (querySpan) => fn({
 				db: ctx,
 				serverCtx,
-				...primaryOnlyConn
-			}, input);
+				...primaryOnlyConn,
+				log: opts?.log,
+				span: querySpan
+			}, input));
 		});
 	}
 	sendMessage(session, message) {
@@ -1705,7 +2268,7 @@ var SupaliveWebSocketServer = class {
 		const appChannels = [...this.appPubSubChannels];
 		await this.redisSub.subscribe(instanceChannel, schemaChannel, watermarkChannel, ...appChannels);
 		this.redisSub.on("connect", () => {
-			logger$2.info(`Subscribed to Redis channels: ${[
+			this.log.info(`Subscribed to Redis channels: ${[
 				instanceChannel,
 				schemaChannel,
 				watermarkChannel,
@@ -1714,20 +2277,20 @@ var SupaliveWebSocketServer = class {
 		});
 		this.redisSub.on("message", (channel, message) => {
 			if (channel === instanceChannel) this.handleRemoteInstanceMessage(message).catch((err) => {
-				logger$2.error(err, "Error handling remote instance message");
+				this.log.error(err, "Error handling remote instance message");
 			});
 			else if (channel === schemaChannel) this.handleSchemaReload().catch((err) => {
-				logger$2.error(err, "Error handling schema reload");
+				this.log.error(err, "Error handling schema reload");
 			});
 			else if (channel === watermarkChannel) try {
 				this.retentionWatermark.set(BigInt(message));
 			} catch (err) {
-				logger$2.error(err, `Bad retention watermark message: ${message}`);
+				this.log.error(err, `Bad retention watermark message: ${message}`);
 			}
-			else if (this.appPubSubChannels.has(channel)) Promise.resolve(this.config.appPubSub?.onMessage(channel, message)).catch((err) => logger$2.error(err, `Error in appPubSub handler for channel ${channel}`));
+			else if (this.appPubSubChannels.has(channel)) Promise.resolve(this.config.appPubSub?.onMessage(channel, message)).catch((err) => this.log.error(err, `Error in appPubSub handler for channel ${channel}`));
 		});
 		this.redisSub.on("error", (err) => {
-			logger$2.error(err, `Subscriber error for channels: ${instanceChannel}, ${schemaChannel}`);
+			this.log.error(err, `Subscriber error for channels: ${instanceChannel}, ${schemaChannel}`);
 		});
 	}
 	/**
@@ -1737,13 +2300,13 @@ var SupaliveWebSocketServer = class {
 	* messages published by this instance (we already have the new types).
 	*/
 	async handleSchemaReload() {
-		logger$2.info(`Schema reload request received in instance ${this.instanceId} — reloading schema...`);
+		this.log.info(`Schema reload request received in instance ${this.instanceId} — reloading schema...`);
 		try {
 			await sleep(1e3 + Math.random() * 5e3);
 			await bootstrapDbTypes(this.db, this.cache, true);
-			logger$2.info(`Schema reload applied in instance ${this.instanceId}`);
+			this.log.info(`Schema reload applied in instance ${this.instanceId}`);
 		} catch (err) {
-			logger$2.error(err, "Failed to reload schema");
+			this.log.error(err, "Failed to reload schema");
 			return;
 		}
 	}
@@ -1777,7 +2340,7 @@ var SupaliveWebSocketServer = class {
 		try {
 			parsed = RemoteSubscriptionMessageSchema.parse(JSON.parse(message));
 		} catch (err) {
-			logger$2.error(err, "Failed to parse remote instance message");
+			this.log.error(err, "Failed to parse remote instance message");
 			return;
 		}
 		if (parsed.originInstance === this.instanceId) return;
@@ -1800,7 +2363,7 @@ var SupaliveWebSocketServer = class {
 	async handleRemoteRecomputeRace(req) {
 		if (!this.hasLocalSessionFor(req.subId)) return;
 		if (!await this.cache.tryAcquireRecomputeLock(this.instanceId, req.subId, req.commitTs, RECOMPUTE_LOCK_TTL_SECONDS)) {
-			logger$2.debug(`recompute-race: lost lock for ${req.subId}@${req.commitTs}, waiting for winner's update`);
+			this.log.debug(`recompute-race: lost lock for ${req.subId}@${req.commitTs}, waiting for winner's update`);
 			return;
 		}
 		await this.reexecuteAffectedQuery({
@@ -1826,7 +2389,7 @@ var SupaliveWebSocketServer = class {
 			try {
 				await redisRetryPolicy.execute(() => this.cache.redis.publish(channel, payload));
 			} catch (err) {
-				logger$2.error(err, `Failed to publish to ${channel} after many retries`);
+				this.log.error(err, `Failed to publish to ${channel} after many retries`);
 			}
 		});
 		await Promise.all(publishPromises);
@@ -1853,29 +2416,6 @@ function sendJson(res, status, body) {
 	res.writeHead(status, { "content-type": "application/json" });
 	res.end(payload);
 }
-function lowercaseHeaders(headers) {
-	const out = {};
-	for (const [k, v] of Object.entries(headers)) out[k.toLowerCase()] = Array.isArray(v) ? v.join(",") : v;
-	return out;
-}
-/** Buffer an incoming request body to a string, capped to guard against abuse. */
-function readRequestBody(req, maxBytes = 1024 * 1024) {
-	return new Promise((resolve, reject) => {
-		const chunks = [];
-		let size = 0;
-		req.on("data", (chunk) => {
-			size += chunk.length;
-			if (size > maxBytes) {
-				reject(/* @__PURE__ */ new Error("request body too large"));
-				req.destroy();
-				return;
-			}
-			chunks.push(chunk);
-		});
-		req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
-		req.on("error", reject);
-	});
-}
 //#endregion
 //#region src/server/hash.ts
 /**
@@ -2223,6 +2763,6 @@ function resolveMaxConnectionsPerWorker(config, workers) {
 	return Math.max(1, Math.floor(total / workers));
 }
 //#endregion
-export { ANONYMOUS_IDENTITY, CORE_VERSION, CacheLayer, DB_QUERY_TIMEOUT_MS, DevScheduler, InvalidateWritesetParamsSchema, JobClient, QStashScheduler, RegisterSubscriptionParamsSchema, SubManagerClient, SubscriptionManager, SupaliveWebSocketServer, UnregisterSubscriptionParamsSchema, UpdateSubscriptionReadSetParamsSchema, appInstanceId, bootstrapDbTypes, createDatabase, generateCacheKey, generateSubscriptionId, getHashOf, initCacheLayer, initCore, initDatabase, isProduction, logLevelOf, logger, serializeMapValue };
+export { ANONYMOUS_IDENTITY, CORE_VERSION, CacheLayer, DB_QUERY_TIMEOUT_MS, DevScheduler, InvalidateWritesetParamsSchema, JobClient, Observability, QStashScheduler, RegisterSubscriptionParamsSchema, SubManagerClient, SubscriptionManager, SupaliveWebSocketServer, UnregisterSubscriptionParamsSchema, UpdateSubscriptionReadSetParamsSchema, appInstanceId, bootstrapDbTypes, configureRootLogger, createDatabase, elapsedMs, generateCacheKey, generateSubscriptionId, getHashOf, getRootLogger, initCacheLayer, initCore, initDatabase, isProduction, logLevelOf, logger, serializeMapValue, startTimer, traceQueryExecution };
 
 //# sourceMappingURL=server.js.map