@openclaw/diagnostics-prometheus 2026.7.2-beta.5 → 2026.8.1-beta.2

package/dist/index.js

@@ -1,5 +1,7 @@
 import { isInternalDiagnosticEventMetadata, redactSensitiveText } from "./api.js";
 import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+import { normalizeDiagnosticLane, normalizeDiagnosticValue } from "openclaw/plugin-sdk/diagnostic-runtime";
+import { asNonNegativeFiniteNumber } from "openclaw/plugin-sdk/number-runtime";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 //#region extensions/diagnostics-prometheus/src/service.ts
 const DURATION_BUCKETS_SECONDS = [
@@ -61,29 +63,10 @@ const RATIO_BUCKETS = [
 	8,
 	16
 ];
-const LOW_CARDINALITY_VALUE_RE = /^[A-Za-z0-9_.:-]{1,120}$/u;
 const MAX_PROMETHEUS_SERIES = 2048;
 const DROPPED_SERIES_COUNTER_NAME = "openclaw_prometheus_series_dropped_total";
-function lowCardinalityLabel(value, fallback = "unknown") {
-	if (!value) return fallback;
-	const redacted = redactSensitiveText(value.trim());
-	const redactedLower = redacted.toLowerCase();
-	if (redactedLower.startsWith("agent:") || redactedLower.includes(":agent:")) return fallback;
-	return LOW_CARDINALITY_VALUE_RE.test(redacted) ? redacted : fallback;
-}
-function lowCardinalityQueueLaneLabel(value, fallback = "unknown") {
-	if (!value) return fallback;
-	const redacted = redactSensitiveText(value.trim());
-	if (redacted.toLowerCase().startsWith("agent:")) return fallback;
-	const scopedLaneIndex = redacted.indexOf(":");
-	const lane = scopedLaneIndex >= 0 ? redacted.slice(0, scopedLaneIndex) : redacted;
-	return LOW_CARDINALITY_VALUE_RE.test(lane) ? lane : fallback;
-}
-function numericValue(value) {
-	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
-}
 function seconds(ms) {
-	const value = numericValue(ms);
+	const value = asNonNegativeFiniteNumber(ms);
 	return value === void 0 ? void 0 : value / 1e3;
 }
 function sortedLabels(labels) {
@@ -246,126 +229,126 @@ function renderPrometheusMetrics(store) {
 }
 function runLabels(evt) {
 	return {
-		...evt.blockedBy ? { blocked_by: lowCardinalityLabel(evt.blockedBy) } : {},
-		channel: lowCardinalityLabel(evt.channel),
-		model: lowCardinalityLabel(evt.model),
-		outcome: lowCardinalityLabel(evt.outcome, "unknown"),
-		provider: lowCardinalityLabel(evt.provider),
-		trigger: lowCardinalityLabel(evt.trigger)
+		...evt.blockedBy ? { blocked_by: normalizeDiagnosticValue(evt.blockedBy) } : {},
+		channel: normalizeDiagnosticValue(evt.channel),
+		model: normalizeDiagnosticValue(evt.model),
+		outcome: normalizeDiagnosticValue(evt.outcome, "unknown"),
+		provider: normalizeDiagnosticValue(evt.provider),
+		trigger: normalizeDiagnosticValue(evt.trigger)
 	};
 }
 function modelCallLabels(evt) {
 	return {
-		api: lowCardinalityLabel(evt.api),
-		error_category: evt.type === "model.call.error" ? lowCardinalityLabel(evt.errorCategory, "other") : "none",
-		model: lowCardinalityLabel(evt.model),
+		api: normalizeDiagnosticValue(evt.api),
+		error_category: evt.type === "model.call.error" ? normalizeDiagnosticValue(evt.errorCategory, "other") : "none",
+		model: normalizeDiagnosticValue(evt.model),
 		observation_unit: evt.observationUnit === "turn" ? "turn" : "request",
 		outcome: evt.type === "model.call.error" ? "error" : "completed",
-		provider: lowCardinalityLabel(evt.provider),
-		transport: lowCardinalityLabel(evt.transport)
+		provider: normalizeDiagnosticValue(evt.provider),
+		transport: normalizeDiagnosticValue(evt.transport)
 	};
 }
 function modelFailoverLabels(evt) {
 	return {
-		from_model: lowCardinalityLabel(evt.fromModel),
-		from_provider: lowCardinalityLabel(evt.fromProvider),
-		lane: lowCardinalityQueueLaneLabel(evt.lane),
-		reason: lowCardinalityLabel(evt.reason, "other"),
+		from_model: normalizeDiagnosticValue(evt.fromModel),
+		from_provider: normalizeDiagnosticValue(evt.fromProvider),
+		lane: normalizeDiagnosticLane(evt.lane),
+		reason: normalizeDiagnosticValue(evt.reason, "other"),
 		suspended: evt.suspended === void 0 ? "unknown" : String(evt.suspended),
-		to_model: lowCardinalityLabel(evt.toModel),
-		to_provider: lowCardinalityLabel(evt.toProvider)
+		to_model: normalizeDiagnosticValue(evt.toModel),
+		to_provider: normalizeDiagnosticValue(evt.toProvider)
 	};
 }
 function toolExecutionLabels(evt) {
 	return {
-		error_category: evt.type === "tool.execution.error" ? lowCardinalityLabel(evt.errorCategory, "other") : "none",
+		error_category: evt.type === "tool.execution.error" ? normalizeDiagnosticValue(evt.errorCategory, "other") : "none",
 		outcome: evt.type === "tool.execution.error" ? "error" : "completed",
-		params_kind: lowCardinalityLabel(evt.paramsSummary?.kind),
-		tool: lowCardinalityLabel(evt.toolName, "tool"),
-		tool_owner: lowCardinalityLabel(evt.toolOwner, "none"),
-		tool_source: lowCardinalityLabel(evt.toolSource, "core")
+		params_kind: normalizeDiagnosticValue(evt.paramsSummary?.kind),
+		tool: normalizeDiagnosticValue(evt.toolName, "tool"),
+		tool_owner: normalizeDiagnosticValue(evt.toolOwner, "none"),
+		tool_source: normalizeDiagnosticValue(evt.toolSource, "core")
 	};
 }
 function toolExecutionBlockedLabels(evt) {
 	return {
-		denied_reason: lowCardinalityLabel(evt.deniedReason, "other"),
-		params_kind: lowCardinalityLabel(evt.paramsSummary?.kind),
-		tool: lowCardinalityLabel(evt.toolName, "tool"),
-		tool_owner: lowCardinalityLabel(evt.toolOwner, "none"),
-		tool_source: lowCardinalityLabel(evt.toolSource, "core")
+		denied_reason: normalizeDiagnosticValue(evt.deniedReason, "other"),
+		params_kind: normalizeDiagnosticValue(evt.paramsSummary?.kind),
+		tool: normalizeDiagnosticValue(evt.toolName, "tool"),
+		tool_owner: normalizeDiagnosticValue(evt.toolOwner, "none"),
+		tool_source: normalizeDiagnosticValue(evt.toolSource, "core")
 	};
 }
 function skillLabels(evt) {
 	return {
-		activation: lowCardinalityLabel(evt.activation, "unknown"),
-		agent: lowCardinalityLabel(evt.agentId),
-		skill: lowCardinalityLabel(evt.skillName, "skill"),
-		source: lowCardinalityLabel(evt.skillSource)
+		activation: normalizeDiagnosticValue(evt.activation, "unknown"),
+		agent: normalizeDiagnosticValue(evt.agentId),
+		skill: normalizeDiagnosticValue(evt.skillName, "skill"),
+		source: normalizeDiagnosticValue(evt.skillSource)
 	};
 }
 function harnessLabels(evt) {
 	return {
-		channel: lowCardinalityLabel(evt.channel),
-		error_category: evt.type === "harness.run.error" ? lowCardinalityLabel(evt.errorCategory, "other") : "none",
-		harness: lowCardinalityLabel(evt.harnessId),
-		model: lowCardinalityLabel(evt.model),
-		outcome: evt.type === "harness.run.error" ? "error" : lowCardinalityLabel(evt.outcome),
-		phase: evt.type === "harness.run.error" ? lowCardinalityLabel(evt.phase) : "none",
-		plugin: lowCardinalityLabel(evt.pluginId),
-		provider: lowCardinalityLabel(evt.provider)
+		channel: normalizeDiagnosticValue(evt.channel),
+		error_category: evt.type === "harness.run.error" ? normalizeDiagnosticValue(evt.errorCategory, "other") : "none",
+		harness: normalizeDiagnosticValue(evt.harnessId),
+		model: normalizeDiagnosticValue(evt.model),
+		outcome: evt.type === "harness.run.error" ? "error" : normalizeDiagnosticValue(evt.outcome),
+		phase: evt.type === "harness.run.error" ? normalizeDiagnosticValue(evt.phase) : "none",
+		plugin: normalizeDiagnosticValue(evt.pluginId),
+		provider: normalizeDiagnosticValue(evt.provider)
 	};
 }
 function webhookLabels(evt) {
 	return {
-		channel: lowCardinalityLabel(evt.channel),
-		webhook: lowCardinalityLabel(evt.updateType)
+		channel: normalizeDiagnosticValue(evt.channel),
+		webhook: normalizeDiagnosticValue(evt.updateType)
 	};
 }
 function sessionStuckLabels(evt) {
 	return {
-		reason: lowCardinalityLabel(evt.reason, "none"),
+		reason: normalizeDiagnosticValue(evt.reason, "none"),
 		state: evt.state
 	};
 }
 function sessionRecoveryLabels(evt) {
 	return {
-		action: evt.type === "session.recovery.completed" ? lowCardinalityLabel(evt.action, "unknown") : evt.allowActiveAbort ? "abort" : "recover",
-		active_work_kind: lowCardinalityLabel(evt.activeWorkKind, "none"),
+		action: evt.type === "session.recovery.completed" ? normalizeDiagnosticValue(evt.action, "unknown") : evt.allowActiveAbort ? "abort" : "recover",
+		active_work_kind: normalizeDiagnosticValue(evt.activeWorkKind, "none"),
 		state: evt.state,
 		status: evt.type === "session.recovery.completed" ? evt.status : "requested"
 	};
 }
 function livenessLabels(evt) {
-	return { reason: lowCardinalityLabel(evt.reasons.join(":"), "unknown") };
+	return { reason: normalizeDiagnosticValue(evt.reasons.join(":"), "unknown") };
 }
 function payloadLargeLabels(evt) {
 	return {
 		action: evt.action,
-		channel: lowCardinalityLabel(evt.channel, "none"),
-		plugin: lowCardinalityLabel(evt.pluginId, "none"),
-		reason: lowCardinalityLabel(evt.reason, "none"),
-		surface: lowCardinalityLabel(evt.surface, "unknown")
+		channel: normalizeDiagnosticValue(evt.channel, "none"),
+		plugin: normalizeDiagnosticValue(evt.pluginId, "none"),
+		reason: normalizeDiagnosticValue(evt.reason, "none"),
+		surface: normalizeDiagnosticValue(evt.surface, "unknown")
 	};
 }
 function talkLabels(evt) {
 	return {
-		brain: lowCardinalityLabel(evt.brain),
-		event_type: lowCardinalityLabel(evt.talkEventType),
-		mode: lowCardinalityLabel(evt.mode),
-		provider: lowCardinalityLabel(evt.provider),
-		transport: lowCardinalityLabel(evt.transport)
+		brain: normalizeDiagnosticValue(evt.brain),
+		event_type: normalizeDiagnosticValue(evt.talkEventType),
+		mode: normalizeDiagnosticValue(evt.mode),
+		provider: normalizeDiagnosticValue(evt.provider),
+		transport: normalizeDiagnosticValue(evt.transport)
 	};
 }
 function recordModelUsage(store, evt) {
 	const labels = {
-		agent: lowCardinalityLabel(evt.agentId),
-		channel: lowCardinalityLabel(evt.channel),
-		model: lowCardinalityLabel(evt.model),
-		provider: lowCardinalityLabel(evt.provider)
+		agent: normalizeDiagnosticValue(evt.agentId),
+		channel: normalizeDiagnosticValue(evt.channel),
+		model: normalizeDiagnosticValue(evt.model),
+		provider: normalizeDiagnosticValue(evt.provider)
 	};
 	const usage = evt.usage;
 	const recordTokens = (tokenType, value) => {
-		const amount = numericValue(value);
+		const amount = asNonNegativeFiniteNumber(value);
 		if (amount === void 0 || amount === 0) return;
 		store.counter("openclaw_model_tokens_total", "Model tokens reported by diagnostic usage events.", {
 			...labels,
@@ -383,7 +366,7 @@ function recordModelUsage(store, evt) {
 	recordTokens("cache_write", usage.cacheWrite);
 	recordTokens("prompt", usage.promptTokens);
 	recordTokens("total", usage.total);
-	store.counter("openclaw_model_cost_usd_total", "Estimated model cost in USD reported by diagnostic usage events.", labels, numericValue(evt.costUsd) ?? 0);
+	store.counter("openclaw_model_cost_usd_total", "Estimated model cost in USD reported by diagnostic usage events.", labels, asNonNegativeFiniteNumber(evt.costUsd) ?? 0);
 	store.histogram("openclaw_model_usage_duration_seconds", "Model usage event duration in seconds.", labels, seconds(evt.durationMs));
 }
 function recordDiagnosticEvent(store, evt, metadata) {
@@ -422,14 +405,14 @@ function recordDiagnosticEvent(store, evt, metadata) {
 			return;
 		case "message.processed":
 			store.counter("openclaw_message_processed_total", "Inbound messages processed by outcome.", {
-				channel: lowCardinalityLabel(evt.channel),
+				channel: normalizeDiagnosticValue(evt.channel),
 				outcome: evt.outcome,
-				reason: lowCardinalityLabel(evt.reason, "none")
+				reason: normalizeDiagnosticValue(evt.reason, "none")
 			});
 			store.histogram("openclaw_message_processed_duration_seconds", "Inbound message processing duration in seconds.", {
-				channel: lowCardinalityLabel(evt.channel),
+				channel: normalizeDiagnosticValue(evt.channel),
 				outcome: evt.outcome,
-				reason: lowCardinalityLabel(evt.reason, "none")
+				reason: normalizeDiagnosticValue(evt.reason, "none")
 			}, seconds(evt.durationMs));
 			return;
 		case "webhook.received":
@@ -443,55 +426,55 @@ function recordDiagnosticEvent(store, evt, metadata) {
 			return;
 		case "message.delivery.started":
 			store.counter("openclaw_message_delivery_started_total", "Outbound message delivery attempts started.", {
-				channel: lowCardinalityLabel(evt.channel),
-				delivery_kind: lowCardinalityLabel(evt.deliveryKind, "other")
+				channel: normalizeDiagnosticValue(evt.channel),
+				delivery_kind: normalizeDiagnosticValue(evt.deliveryKind, "other")
 			});
 			return;
 		case "message.received":
 			store.counter("openclaw_message_received_total", "Inbound messages received by channel.", {
-				channel: lowCardinalityLabel(evt.channel),
-				source: lowCardinalityLabel(evt.source)
+				channel: normalizeDiagnosticValue(evt.channel),
+				source: normalizeDiagnosticValue(evt.source)
 			});
 			return;
 		case "message.dispatch.started":
 			store.counter("openclaw_message_dispatch_started_total", "Inbound message dispatch attempts started by channel.", {
-				channel: lowCardinalityLabel(evt.channel),
-				source: lowCardinalityLabel(evt.source)
+				channel: normalizeDiagnosticValue(evt.channel),
+				source: normalizeDiagnosticValue(evt.source)
 			});
 			return;
 		case "message.dispatch.completed":
 			store.counter("openclaw_message_dispatch_completed_total", "Inbound message dispatch attempts completed by outcome.", {
-				channel: lowCardinalityLabel(evt.channel),
+				channel: normalizeDiagnosticValue(evt.channel),
 				outcome: evt.outcome,
-				reason: lowCardinalityLabel(evt.reason, "none"),
-				source: lowCardinalityLabel(evt.source)
+				reason: normalizeDiagnosticValue(evt.reason, "none"),
+				source: normalizeDiagnosticValue(evt.source)
 			});
 			store.histogram("openclaw_message_dispatch_duration_seconds", "Inbound message dispatch duration in seconds.", {
-				channel: lowCardinalityLabel(evt.channel),
+				channel: normalizeDiagnosticValue(evt.channel),
 				outcome: evt.outcome,
-				reason: lowCardinalityLabel(evt.reason, "none"),
-				source: lowCardinalityLabel(evt.source)
+				reason: normalizeDiagnosticValue(evt.reason, "none"),
+				source: normalizeDiagnosticValue(evt.source)
 			}, seconds(evt.durationMs));
 			return;
 		case "message.delivery.completed":
 		case "message.delivery.error":
 			store.counter("openclaw_message_delivery_total", "Outbound message delivery attempts by outcome.", {
-				channel: lowCardinalityLabel(evt.channel),
-				delivery_kind: lowCardinalityLabel(evt.deliveryKind, "other"),
-				error_category: evt.type === "message.delivery.error" ? lowCardinalityLabel(evt.errorCategory, "other") : "none",
+				channel: normalizeDiagnosticValue(evt.channel),
+				delivery_kind: normalizeDiagnosticValue(evt.deliveryKind, "other"),
+				error_category: evt.type === "message.delivery.error" ? normalizeDiagnosticValue(evt.errorCategory, "other") : "none",
 				outcome: evt.type === "message.delivery.error" ? "error" : "completed"
 			});
 			store.histogram("openclaw_message_delivery_duration_seconds", "Outbound message delivery duration in seconds.", {
-				channel: lowCardinalityLabel(evt.channel),
-				delivery_kind: lowCardinalityLabel(evt.deliveryKind, "other"),
-				error_category: evt.type === "message.delivery.error" ? lowCardinalityLabel(evt.errorCategory, "other") : "none",
+				channel: normalizeDiagnosticValue(evt.channel),
+				delivery_kind: normalizeDiagnosticValue(evt.deliveryKind, "other"),
+				error_category: evt.type === "message.delivery.error" ? normalizeDiagnosticValue(evt.errorCategory, "other") : "none",
 				outcome: evt.type === "message.delivery.error" ? "error" : "completed"
 			}, seconds(evt.durationMs));
 			return;
 		case "talk.event":
 			store.counter("openclaw_talk_event_total", "Talk events emitted by type.", talkLabels(evt));
 			store.histogram("openclaw_talk_event_duration_seconds", "Talk event duration in seconds when reported.", talkLabels(evt), seconds(evt.durationMs));
-			store.histogram("openclaw_talk_audio_bytes", "Talk audio frame byte lengths.", talkLabels(evt), numericValue(evt.byteLength), BYTE_BUCKETS);
+			store.histogram("openclaw_talk_audio_bytes", "Talk audio frame byte lengths.", talkLabels(evt), asNonNegativeFiniteNumber(evt.byteLength), BYTE_BUCKETS);
 			return;
 		case "session.recovery.requested":
 		case "session.recovery.completed":
@@ -500,15 +483,15 @@ function recordDiagnosticEvent(store, evt, metadata) {
 			return;
 		case "queue.lane.enqueue":
 		case "queue.lane.dequeue":
-			store.gauge("openclaw_queue_lane_size", "Current diagnostic queue lane size.", { lane: lowCardinalityQueueLaneLabel(evt.lane) }, numericValue(evt.queueSize));
-			if (evt.type === "queue.lane.dequeue") store.histogram("openclaw_queue_lane_wait_seconds", "Queue lane wait time in seconds.", { lane: lowCardinalityQueueLaneLabel(evt.lane) }, seconds(evt.waitMs));
+			store.gauge("openclaw_queue_lane_size", "Current diagnostic queue lane size.", { lane: normalizeDiagnosticLane(evt.lane) }, asNonNegativeFiniteNumber(evt.queueSize));
+			if (evt.type === "queue.lane.dequeue") store.histogram("openclaw_queue_lane_wait_seconds", "Queue lane wait time in seconds.", { lane: normalizeDiagnosticLane(evt.lane) }, seconds(evt.waitMs));
 			return;
 		case "session.state":
 			store.counter("openclaw_session_state_total", "Session state observations.", {
-				reason: lowCardinalityLabel(evt.reason, "none"),
+				reason: normalizeDiagnosticValue(evt.reason, "none"),
 				state: evt.state
 			});
-			if (evt.queueDepth !== void 0) store.gauge("openclaw_session_queue_depth", "Latest observed session queue depth.", { state: evt.state }, numericValue(evt.queueDepth));
+			if (evt.queueDepth !== void 0) store.gauge("openclaw_session_queue_depth", "Latest observed session queue depth.", { state: evt.state }, asNonNegativeFiniteNumber(evt.queueDepth));
 			return;
 		case "session.stuck":
 			store.counter("openclaw_session_stuck_total", "Stale session bookkeeping observations with no active work.", sessionStuckLabels(evt));
@@ -516,8 +499,8 @@ function recordDiagnosticEvent(store, evt, metadata) {
 			return;
 		case "session.turn.created":
 			store.counter("openclaw_session_turn_created_total", "Agent session turns created.", {
-				agent: lowCardinalityLabel(evt.agentId),
-				channel: lowCardinalityLabel(evt.channel),
+				agent: normalizeDiagnosticValue(evt.agentId),
+				channel: normalizeDiagnosticValue(evt.channel),
 				trigger: evt.trigger
 			});
 			return;
@@ -525,7 +508,7 @@ function recordDiagnosticEvent(store, evt, metadata) {
 			store.gauge("openclaw_memory_bytes", "Latest process memory usage by memory kind.", { kind: "rss" }, evt.memory.rssBytes);
 			store.gauge("openclaw_memory_bytes", "Latest process memory usage by memory kind.", { kind: "heap_total" }, evt.memory.heapTotalBytes);
 			store.gauge("openclaw_memory_bytes", "Latest process memory usage by memory kind.", { kind: "heap_used" }, evt.memory.heapUsedBytes);
-			store.histogram("openclaw_memory_rss_bytes", "RSS memory sample distribution in bytes.", {}, numericValue(evt.memory.rssBytes), BYTE_BUCKETS);
+			store.histogram("openclaw_memory_rss_bytes", "RSS memory sample distribution in bytes.", {}, asNonNegativeFiniteNumber(evt.memory.rssBytes), BYTE_BUCKETS);
 			return;
 		case "diagnostic.memory.pressure":
 			store.counter("openclaw_memory_pressure_total", "Memory pressure events by level and reason.", {
@@ -535,33 +518,33 @@ function recordDiagnosticEvent(store, evt, metadata) {
 			return;
 		case "diagnostic.liveness.warning":
 			store.counter("openclaw_liveness_warning_total", "Diagnostic liveness warning events.", livenessLabels(evt));
-			store.gauge("openclaw_liveness_sessions", "Latest session counts reported with diagnostic liveness warnings.", { state: "active" }, numericValue(evt.active));
-			store.gauge("openclaw_liveness_sessions", "Latest session counts reported with diagnostic liveness warnings.", { state: "waiting" }, numericValue(evt.waiting));
-			store.gauge("openclaw_liveness_sessions", "Latest session counts reported with diagnostic liveness warnings.", { state: "queued" }, numericValue(evt.queued));
+			store.gauge("openclaw_liveness_sessions", "Latest session counts reported with diagnostic liveness warnings.", { state: "active" }, asNonNegativeFiniteNumber(evt.active));
+			store.gauge("openclaw_liveness_sessions", "Latest session counts reported with diagnostic liveness warnings.", { state: "waiting" }, asNonNegativeFiniteNumber(evt.waiting));
+			store.gauge("openclaw_liveness_sessions", "Latest session counts reported with diagnostic liveness warnings.", { state: "queued" }, asNonNegativeFiniteNumber(evt.queued));
 			store.histogram("openclaw_liveness_event_loop_delay_p99_seconds", "P99 event-loop delay reported by diagnostic liveness warnings in seconds.", livenessLabels(evt), seconds(evt.eventLoopDelayP99Ms));
 			store.histogram("openclaw_liveness_event_loop_delay_max_seconds", "Maximum event-loop delay reported by diagnostic liveness warnings in seconds.", livenessLabels(evt), seconds(evt.eventLoopDelayMaxMs));
-			store.histogram("openclaw_liveness_event_loop_utilization_ratio", "Event-loop utilization reported by diagnostic liveness warnings.", livenessLabels(evt), numericValue(evt.eventLoopUtilization), RATIO_BUCKETS);
-			store.histogram("openclaw_liveness_cpu_core_ratio", "CPU core ratio reported by diagnostic liveness warnings.", livenessLabels(evt), numericValue(evt.cpuCoreRatio), RATIO_BUCKETS);
+			store.histogram("openclaw_liveness_event_loop_utilization_ratio", "Event-loop utilization reported by diagnostic liveness warnings.", livenessLabels(evt), asNonNegativeFiniteNumber(evt.eventLoopUtilization), RATIO_BUCKETS);
+			store.histogram("openclaw_liveness_cpu_core_ratio", "CPU core ratio reported by diagnostic liveness warnings.", livenessLabels(evt), asNonNegativeFiniteNumber(evt.cpuCoreRatio), RATIO_BUCKETS);
 			return;
 		case "diagnostic.async_queue.dropped":
-			store.counter("openclaw_diagnostic_async_queue_dropped_total", "Async diagnostic queue drops by dropped event class.", { drop_class: "total" }, numericValue(evt.droppedEvents));
-			if (evt.droppedTrustedEvents !== void 0) store.counter("openclaw_diagnostic_async_queue_dropped_total", "Async diagnostic queue drops by dropped event class.", { drop_class: "trusted" }, numericValue(evt.droppedTrustedEvents));
-			if (evt.droppedUntrustedEvents !== void 0) store.counter("openclaw_diagnostic_async_queue_dropped_total", "Async diagnostic queue drops by dropped event class.", { drop_class: "untrusted" }, numericValue(evt.droppedUntrustedEvents));
-			if (evt.droppedPriorityEvents !== void 0) store.counter("openclaw_diagnostic_async_queue_dropped_total", "Async diagnostic queue drops by dropped event class.", { drop_class: "priority" }, numericValue(evt.droppedPriorityEvents));
-			store.gauge("openclaw_diagnostic_async_queue_length", "Latest async diagnostic queue length after a drop summary.", {}, numericValue(evt.queueLength));
+			store.counter("openclaw_diagnostic_async_queue_dropped_total", "Async diagnostic queue drops by dropped event class.", { drop_class: "total" }, asNonNegativeFiniteNumber(evt.droppedEvents));
+			if (evt.droppedTrustedEvents !== void 0) store.counter("openclaw_diagnostic_async_queue_dropped_total", "Async diagnostic queue drops by dropped event class.", { drop_class: "trusted" }, asNonNegativeFiniteNumber(evt.droppedTrustedEvents));
+			if (evt.droppedUntrustedEvents !== void 0) store.counter("openclaw_diagnostic_async_queue_dropped_total", "Async diagnostic queue drops by dropped event class.", { drop_class: "untrusted" }, asNonNegativeFiniteNumber(evt.droppedUntrustedEvents));
+			if (evt.droppedPriorityEvents !== void 0) store.counter("openclaw_diagnostic_async_queue_dropped_total", "Async diagnostic queue drops by dropped event class.", { drop_class: "priority" }, asNonNegativeFiniteNumber(evt.droppedPriorityEvents));
+			store.gauge("openclaw_diagnostic_async_queue_length", "Latest async diagnostic queue length after a drop summary.", {}, asNonNegativeFiniteNumber(evt.queueLength));
 			break;
 		case "diagnostic.heartbeat": break;
 		case "telemetry.exporter":
 			store.counter("openclaw_telemetry_exporter_total", "Telemetry exporter lifecycle events.", {
-				exporter: lowCardinalityLabel(evt.exporter),
-				reason: lowCardinalityLabel(evt.reason, "none"),
+				exporter: normalizeDiagnosticValue(evt.exporter),
+				reason: normalizeDiagnosticValue(evt.reason, "none"),
 				signal: evt.signal,
 				status: evt.status
 			});
 			return;
 		case "payload.large":
 			store.counter("openclaw_payload_large_total", "Oversized payload diagnostics by surface and action.", payloadLargeLabels(evt));
-			store.histogram("openclaw_payload_large_bytes", "Oversized payload byte sizes by surface and action.", payloadLargeLabels(evt), numericValue(evt.bytes), BYTE_BUCKETS);
+			store.histogram("openclaw_payload_large_bytes", "Oversized payload byte sizes by surface and action.", payloadLargeLabels(evt), asNonNegativeFiniteNumber(evt.bytes), BYTE_BUCKETS);
 		default:
 	}
 }
@@ -577,6 +560,7 @@ function createMetricsHandler(store) {
 		res.statusCode = 200;
 		res.setHeader("Cache-Control", "no-store");
 		res.setHeader("Content-Type", "text/plain; version=0.0.4; charset=utf-8");
+		res.setHeader("Content-Length", String(Buffer.byteLength(body)));
 		if (req.method === "HEAD") {
 			res.end();
 			return true;
@@ -588,6 +572,12 @@ function createMetricsHandler(store) {
 function createDiagnosticsPrometheusExporter() {
 	const store = createPrometheusMetricStore();
 	let unsubscribe;
+	let internalDiagnostics;
+	const reportExporterHealth = (update) => {
+		try {
+			internalDiagnostics?.reportExporterHealth?.(update);
+		} catch {}
+	};
 	return {
 		handler: createMetricsHandler(store),
 		render: () => renderPrometheusMetrics(store),
@@ -606,7 +596,14 @@ function createDiagnosticsPrometheusExporter() {
 						ctx.logger.error(`diagnostics-prometheus: event handler failed (${event.type}): ${safeErrorMessage(err)}`);
 					}
 				});
-				ctx.internalDiagnostics?.emit({
+				internalDiagnostics = ctx.internalDiagnostics;
+				reportExporterHealth({
+					signal: "metrics",
+					transport: "prometheus-scrape",
+					status: "started",
+					reason: "configured"
+				});
+				internalDiagnostics.emit({
 					type: "telemetry.exporter",
 					exporter: "diagnostics-prometheus",
 					signal: "metrics",
@@ -617,6 +614,18 @@ function createDiagnosticsPrometheusExporter() {
 			stop() {
 				unsubscribe?.();
 				unsubscribe = void 0;
+				reportExporterHealth({
+					signal: "metrics",
+					transport: "prometheus-scrape",
+					status: "dropped"
+				});
+				internalDiagnostics?.emit({
+					type: "telemetry.exporter",
+					exporter: "diagnostics-prometheus",
+					signal: "metrics",
+					status: "dropped"
+				});
+				internalDiagnostics = void 0;
 				store.reset();
 			}
 		}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/diagnostics-prometheus",
-  "version": "2026.7.2-beta.5",
+  "version": "2026.8.1-beta.2",
   "description": "OpenClaw diagnostics Prometheus exporter for runtime metrics.",
   "repository": {
     "type": "git",
@@ -18,10 +18,10 @@
       "minHostVersion": ">=2026.4.25"
     },
     "compat": {
-      "pluginApi": ">=2026.7.2-beta.5"
+      "pluginApi": ">=2026.8.1-beta.2"
     },
     "build": {
-      "openclawVersion": "2026.7.2-beta.5"
+      "openclawVersion": "2026.8.1-beta.2"
     },
     "release": {
       "publishToClawHub": true,
@@ -37,7 +37,7 @@
     "README.md"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.7.2-beta.5"
+    "openclaw": ">=2026.8.1-beta.2"
   },
   "peerDependenciesMeta": {
     "openclaw": {