@openclaw/diagnostics-prometheus 2026.10.5-beta.4 → 2026.10.10-beta.1

package/dist/index.js

@@ -166,7 +166,7 @@ function createPrometheusMetricStore() {
 }
 //#endregion
 //#region extensions/diagnostics-prometheus/src/service-child-process.ts
-/** Git launches carry a bounded owner label; every other executable family reports `none`. */
+/** Git owners and SQLite session transports carry bounded operation labels. */
 function recordChildProcessSpawn(store, evt) {
 	store.counter("openclaw_child_process_spawn_total", "Successful child launches through the shared spawn and exec owners.", {
 		family: normalizeDiagnosticValue(evt.family),
@@ -176,6 +176,15 @@ function recordChildProcessSpawn(store, evt) {
 //#endregion
 //#region extensions/diagnostics-prometheus/src/service-memory.ts
 function recordMemorySample(store, memory, byteBuckets) {
+	for (const message of memory.workerMessages ?? []) {
+		const labels = {
+			kind: message.kind,
+			direction: message.direction
+		};
+		store.counterValue("openclaw_worker_messages_total", "Messages crossing the Gateway main-thread worker boundary.", labels, message.messages);
+		store.counterValue("openclaw_worker_message_payload_bytes_total", "Known worker payload bytes, excluding transport framing and unmeasured object graphs.", labels, message.payloadBytes);
+		store.counterValue("openclaw_worker_message_unmeasured_total", "Worker messages without a known payload size; these do not contribute to payload bytes.", labels, message.unmeasuredMessages);
+	}
 	for (const worker of memory.workerLifecycle ?? []) {
 		store.counterValue("openclaw_worker_started_total", "Worker isolates created by bounded script basename.", { script: worker.script }, worker.started);
 		for (const { reason, count } of worker.retired) store.counterValue("openclaw_worker_retired_total", "Worker isolates confirmed exited by owner retirement reason.", {
@@ -192,7 +201,10 @@ function recordMemorySample(store, memory, byteBuckets) {
 		["worker_heap_total", "workerHeapTotalBytes"],
 		["worker_heap_used", "workerHeapUsedBytes"]
 	]) store.gauge("openclaw_memory_bytes", "Latest process memory usage by memory kind.", { kind }, asNonNegativeFiniteNumber(memory[field]));
-	for (const [name, field] of [["openclaw_worker_count", "workerCount"], ["openclaw_worker_heap_sampled_count", "workerHeapSampledCount"]]) store.gauge(name, "Worker isolate counts.", {}, asNonNegativeFiniteNumber(memory[field]));
+	for (const [name, field] of [["openclaw_worker_count", "workerCount"], ["openclaw_worker_heap_sampled_count", "workerHeapSampledCount"]]) {
+		store.clearGauges(name);
+		store.gauge(name, "Worker isolate counts.", {}, asNonNegativeFiniteNumber(memory[field]));
+	}
 	store.clearGauges("openclaw_heap_space_bytes");
 	for (const space of memory.heapSpaces ?? []) for (const [stat, field] of [
 		["used", "space_used_size"],
@@ -203,13 +215,39 @@ function recordMemorySample(store, memory, byteBuckets) {
 		space: space.space_name,
 		stat
 	}, space[field]);
-	const workerHeaps = /* @__PURE__ */ new Map();
+	const workers = /* @__PURE__ */ new Map();
+	store.clearGauges("openclaw_code_mode_worker_heap_bytes");
 	for (const worker of memory.workerHeaps ?? []) {
+		if (worker.workerSlot !== void 0) for (const [kind, value] of [["used", worker.heapUsed], ["limit", worker.heapSizeLimitBytes]]) store.gauge("openclaw_code_mode_worker_heap_bytes", "Latest live Code Mode isolate heap usage and limit by reusable worker slot.", {
+			slot: String(worker.workerSlot),
+			kind
+		}, value);
+		const totals = workers.get(worker.script) ?? {
+			count: 0,
+			sampled: 0,
+			heapUsed: void 0
+		};
+		totals.count++;
+		totals.sampled++;
 		const heapUsed = asNonNegativeFiniteNumber(worker.heapUsed);
-		if (heapUsed !== void 0) workerHeaps.set(worker.script, (workerHeaps.get(worker.script) ?? 0) + heapUsed);
+		if (heapUsed !== void 0) totals.heapUsed = (totals.heapUsed ?? 0) + heapUsed;
+		workers.set(worker.script, totals);
+	}
+	for (const worker of memory.workerMemoryMissing ?? []) {
+		const totals = workers.get(worker.script) ?? {
+			count: 0,
+			sampled: 0,
+			heapUsed: void 0
+		};
+		totals.count++;
+		workers.set(worker.script, totals);
 	}
 	store.clearGauges("openclaw_worker_heap_used_bytes");
-	for (const [script, heapUsed] of workerHeaps) store.gauge("openclaw_worker_heap_used_bytes", "Latest live Worker heap usage by bounded script basename.", { script }, heapUsed);
+	for (const [script, totals] of workers) {
+		store.gauge("openclaw_worker_count", "Worker isolate counts.", { script }, totals.count);
+		store.gauge("openclaw_worker_heap_sampled_count", "Worker isolate counts.", { script }, totals.sampled);
+		store.gauge("openclaw_worker_heap_used_bytes", "Latest live Worker heap usage by bounded script basename.", { script }, totals.heapUsed);
+	}
 	store.histogram("openclaw_memory_rss_bytes", "RSS memory sample distribution in bytes.", {}, asNonNegativeFiniteNumber(memory.rssBytes), byteBuckets);
 }
 //#endregion
@@ -259,6 +297,49 @@ function recordModelUsage(store, evt) {
 }
 //#endregion
 //#region extensions/diagnostics-prometheus/src/service-operation-timing.ts
+const RPC_DURATION_BUCKETS_SECONDS = [
+	.005,
+	.01,
+	.0125,
+	.015,
+	.02,
+	.025,
+	.03,
+	.04,
+	.05,
+	.06,
+	.08,
+	.1,
+	.125,
+	.15,
+	.2,
+	.25,
+	.3,
+	.4,
+	.5,
+	.6,
+	.8,
+	1,
+	1.25,
+	1.5,
+	2,
+	2.5,
+	3,
+	4,
+	5,
+	6,
+	8,
+	10,
+	12.5,
+	15,
+	20,
+	25,
+	30,
+	60,
+	120,
+	300,
+	600
+];
 const RESPONSE_BYTE_BUCKETS = Array.from({ length: 17 }, (_, index) => 1024 * 2 ** index);
 const HEAP_DELTA_BYTE_BUCKETS = [
 	...RESPONSE_BYTE_BUCKETS.toReversed().map((bytes) => -bytes),
@@ -278,11 +359,30 @@ const CATALOG_LIST_PHASES = /* @__PURE__ */ new Set([
 const CHAT_SEND_PHASE = /^chat\.send\.(authority|admission|preparation|attachments|replyContext|authoring|persist|runAdmission|replyInitialization|snapshot|worktree|effects|response|dispatch)$/;
 function recordOperationTimingEvent(store, evt, metadata) {
 	switch (evt.type) {
+		case "secret.egress":
+			store.counter("openclaw_secret_egress_requests_total", "Secret egress proxy requests by outcome and credential substitution.", {
+				outcome: evt.outcome,
+				substituted: String(evt.substituted)
+			});
+			return;
+		case "tool.catalog": {
+			const labels = {
+				source: evt.source,
+				mode: evt.mode
+			};
+			store.counter("openclaw_tool_catalog_total", "Tool catalogs prepared.", labels);
+			store.counter("openclaw_tool_catalog_tools_total", "Tools cataloged during preparation.", labels, evt.toolCount);
+			return;
+		}
 		case "gateway.http.cancelled":
 			store.counter("openclaw_gateway_http_cancelled_total", "Gateway HTTP requests cancelled before completion.", { source: evt.source });
 			return;
 		case "diagnostic.gc":
-			store.histogram("openclaw_gc_duration_seconds", "Elapsed garbage collection duration in seconds for the hosting JavaScript isolate.", {}, seconds(evt.durationMs));
+			store.histogram("openclaw_gc_duration_seconds", "Elapsed garbage collection duration in seconds by collection kind and isolate role.", {
+				kind: evt.kind ?? "unknown",
+				thread: evt.thread ?? "main",
+				...evt.workerSlot === void 0 ? {} : { slot: String(evt.workerSlot) }
+			}, seconds(evt.durationMs));
 			return;
 		case "gateway.event_loop.sample":
 			store.histogram("openclaw_gateway_event_loop_delay_max_seconds", "Maximum event-loop delay per completed Gateway observation window in seconds.", {}, seconds(evt.delayMaxMs));
@@ -297,7 +397,7 @@ function recordOperationTimingEvent(store, evt, metadata) {
 			const sendPhase = CHAT_SEND_PHASE.exec(evt.name)?.[1];
 			if (sendPhase) {
 				const stage = evt.details?.stage;
-				if (stage === "request" || stage === "startup") store.histogram("openclaw_chat_send_phase_seconds", "Elapsed chat.send owner phases before acknowledgement and during run startup.", {
+				if (stage === "request" || stage === "startup" || stage === "steer" || stage === "queued") store.histogram("openclaw_chat_send_phase_seconds", "Elapsed chat.send owner phases before acknowledgement, during startup, or awaiting steering and queued follow-up delivery.", {
 					phase: sendPhase,
 					stage
 				}, seconds(evt.durationMs));
@@ -320,6 +420,17 @@ function recordOperationTimingEvent(store, evt, metadata) {
 			const labels = { method: evt.method };
 			if (evt.phase === "received") {
 				store.counter("openclaw_gateway_rpc_requests_total", "Authenticated Gateway WebSocket requests received.", labels);
+				if (evt.method === "models.list" && evt.modelsList) {
+					const catalog = evt.modelsList;
+					store.counter("openclaw_models_list_requests_total", "Model catalog requests by client kind and bounded request shape.", {
+						client_kind: catalog.clientKind,
+						source: catalog.source,
+						view: catalog.view,
+						scope: catalog.scope,
+						refresh: String(catalog.refresh),
+						prepared_only: String(catalog.preparedOnly)
+					});
+				}
 				return;
 			}
 			if (evt.phase === "response" && (evt.outcome === "ok" || evt.outcome === "error")) {
@@ -330,13 +441,13 @@ function recordOperationTimingEvent(store, evt, metadata) {
 				phase: evt.phase,
 				outcome: evt.outcome
 			});
-			if (evt.phase === "response" && (evt.outcome === "ok" || evt.outcome === "error")) store.histogram("openclaw_gateway_rpc_first_response_seconds", "Elapsed time until the first Gateway RPC response is sent.", labels, seconds(evt.durationMs));
+			if (evt.phase === "response" && (evt.outcome === "ok" || evt.outcome === "error")) store.histogram("openclaw_gateway_rpc_first_response_seconds", "Elapsed time until the first Gateway RPC response is sent.", labels, seconds(evt.durationMs), RPC_DURATION_BUCKETS_SECONDS);
 			else if (evt.phase === "handler") {
 				if (evt.heapDeltaBytes !== void 0) store.counter("openclaw_gateway_rpc_handler_heap_delta_exclusive_total", "Gateway RPC handlers with an exclusive main-thread heap-change sample.", labels);
 				store.histogram("openclaw_gateway_rpc_handler_heap_delta_bytes", "Exclusive RPC handler heap change; background work and GC can affect signed samples.", labels, evt.heapDeltaBytes, HEAP_DELTA_BYTE_BUCKETS);
-				store.histogram("openclaw_gateway_rpc_handler_seconds", "Gateway RPC handler duration until return or throw.", labels, seconds(evt.durationMs));
-				store.histogram("openclaw_gateway_rpc_admission_seconds", "Elapsed time from Gateway RPC receipt until handler invocation.", labels, seconds(evt.admissionMs));
-			} else if (evt.phase === "dispatch") store.histogram("openclaw_gateway_rpc_queue_wait_seconds", "Gateway operator request start queue wait.", labels, seconds(evt.queueWaitMs));
+				store.histogram("openclaw_gateway_rpc_handler_seconds", "Gateway RPC handler duration until return or throw.", labels, seconds(evt.durationMs), RPC_DURATION_BUCKETS_SECONDS);
+				store.histogram("openclaw_gateway_rpc_admission_seconds", "Elapsed time from Gateway RPC receipt until handler invocation.", labels, seconds(evt.admissionMs), RPC_DURATION_BUCKETS_SECONDS);
+			} else if (evt.phase === "dispatch") store.histogram("openclaw_gateway_rpc_queue_wait_seconds", "Gateway operator request start queue wait.", labels, seconds(evt.queueWaitMs), RPC_DURATION_BUCKETS_SECONDS);
 		}
 	}
 }
@@ -434,6 +545,52 @@ function recordWorkerRequest(store, event) {
 	};
 	store.histogram("openclaw_worker_queue_wait_seconds", "Elapsed time from worker request enqueue to dispatch.", labels, seconds(event.queueWaitMs));
 	store.histogram("openclaw_worker_request_seconds", "Elapsed time from worker dispatch to reply or failure, including preparation and transport.", labels, seconds(event.durationMs));
+	if (event.phase !== "completed" || !event.timing) return;
+	for (const [phase, start, end] of [
+		[
+			"dispatch",
+			"dispatched",
+			"posted"
+		],
+		[
+			"delivery",
+			"posted",
+			"received"
+		],
+		[
+			"input",
+			"received",
+			"inputReady"
+		],
+		[
+			"prepare",
+			"inputReady",
+			"executeStarted"
+		],
+		[
+			"execute",
+			"executeStarted",
+			"executeFinished"
+		],
+		[
+			"result",
+			"executeFinished",
+			"replied"
+		],
+		[
+			"reply",
+			"replied",
+			"replyReceived"
+		]
+	]) {
+		const started = event.timing[start];
+		const finished = event.timing[end];
+		if (started === void 0 || finished === void 0) continue;
+		store.histogram("openclaw_worker_request_phase_seconds", "Elapsed time within an observed SQLite worker request phase, including transport.", {
+			...labels,
+			phase
+		}, seconds(finished - started));
+	}
 }
 //#endregion
 //#region extensions/diagnostics-prometheus/src/service.ts
@@ -512,6 +669,8 @@ function recordDiagnosticEvent(store, evt, metadata) {
 			if (metadata.trusted) recordWorkerRequest(store, evt);
 			return;
 		case "diagnostic.phase.completed":
+		case "secret.egress":
+		case "tool.catalog":
 		case "gateway.rpc":
 		case "gateway.http.cancelled":
 		case "diagnostic.gc":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/diagnostics-prometheus",
-  "version": "2026.10.5-beta.4",
+  "version": "2026.10.10-beta.1",
   "description": "OpenClaw diagnostics Prometheus exporter for runtime metrics.",
   "repository": {
     "type": "git",
@@ -18,10 +18,10 @@
       "minHostVersion": ">=2026.4.25"
     },
     "compat": {
-      "pluginApi": ">=2026.10.5-beta.4"
+      "pluginApi": ">=2026.10.10-beta.1"
     },
     "build": {
-      "openclawVersion": "2026.10.5-beta.4"
+      "openclawVersion": "2026.10.10-beta.1"
     },
     "release": {
       "publishToClawHub": true,
@@ -39,7 +39,7 @@
     "assets/activity.svg"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.10.5-beta.4"
+    "openclaw": ">=2026.10.10-beta.1"
   },
   "peerDependenciesMeta": {
     "openclaw": {