@openclaw/diagnostics-otel 2026.9.1 → 2026.9.3

package/dist/index.js

@@ -1,4 +1,4 @@
-import { t as createDiagnosticsOtelService } from "./runtime-api-DaBnxBEO.js";
+import { t as createDiagnosticsOtelService } from "./runtime-api-B9-DLHbi.js";
 import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 //#region extensions/diagnostics-otel/index.ts
 var diagnostics_otel_default = definePluginEntry({

package/dist/{runtime-api-DaBnxBEO.js → runtime-api-B9-DLHbi.js}

@@ -1,5 +1,5 @@
 import { isValidDiagnosticSpanId, isValidDiagnosticTraceFlags, isValidDiagnosticTraceId, redactSensitiveText } from "./api.js";
-import { ROOT_CONTEXT, SpanKind, SpanStatusCode, TraceFlags, context, createContextKey, diag, isSpanContextValid, metrics, propagation, trace } from "@opentelemetry/api";
+import { ROOT_CONTEXT, SpanKind, SpanStatusCode, TraceFlags, context, createContextKey, createNoopMeter, diag, isSpanContextValid, metrics, propagation, trace } from "@opentelemetry/api";
 import * as otelCore from "@opentelemetry/core";
 import { CompositePropagator, ExportResultCode, W3CBaggagePropagator, W3CTraceContextPropagator, getStringListFromEnv } from "@opentelemetry/core";
 import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-proto";
@@ -10,7 +10,7 @@ import { BasicTracerProvider, BatchSpanProcessor, ParentBasedSampler, TraceIdRat
 import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
 import { registerUnhandledRejectionHandler } from "openclaw/plugin-sdk/runtime-env";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
-import { normalizeDiagnosticLane, normalizeDiagnosticValue } from "openclaw/plugin-sdk/diagnostic-runtime";
+import { isInternalDiagnosticEventMetadata, normalizeDiagnosticLane, normalizeDiagnosticValue } from "openclaw/plugin-sdk/diagnostic-runtime";
 import { readFileSync } from "node:fs";
 import nodePath from "node:path";
 import { collectErrorGraphCandidates } from "openclaw/plugin-sdk/error-runtime";
@@ -443,10 +443,19 @@ function findOtlpExporterError(reason) {
 //#region extensions/diagnostics-otel/src/service-events.ts
 function createDiagnosticsEventHandler(params) {
 	const { logger, recorders, recordLogRecord, recordSecurityEvent } = params;
-	const { recordModelUsage, recordWebhookReceived, recordWebhookProcessed, recordWebhookError, recordMessageQueued, recordMessageReceived, recordMessageDispatchStarted, recordMessageDispatchCompleted, recordMessageProcessed, recordMessageDeliveryStarted, recordMessageDeliveryCompleted, recordMessageDeliveryError, recordTalkEvent, recordLaneEnqueue, recordLaneDequeue, recordSessionState, recordSessionTurnCreated, recordSessionStuck, recordSessionRecoveryRequested, recordSessionRecoveryCompleted, recordRunAttempt, recordHeartbeat, recordLivenessWarning, recordDiagnosticPhaseCompleted, recordRunStarted, recordRunCompleted, recordHarnessRunStarted, recordHarnessRunCompleted, recordHarnessRunError, recordContextAssembled, recordModelCallStarted, recordModelCallCompleted, recordModelCallError, recordToolExecutionStarted, recordToolExecutionCompleted, recordToolExecutionError, recordToolExecutionBlocked, recordSkillUsed, recordExecProcessCompleted, recordToolLoop, recordMemorySample, recordMemoryPressure, recordAsyncQueueDropped, recordTelemetryExporter, recordPayloadLarge, recordModelFailover } = recorders;
+	const { recordGcDuration, recordGatewayEventLoopSample, recordGatewayRpc, recordModelUsage, recordWebhookReceived, recordWebhookProcessed, recordWebhookError, recordMessageQueued, recordMessageReceived, recordMessageDispatchStarted, recordMessageDispatchCompleted, recordMessageProcessed, recordMessageDeliveryStarted, recordMessageDeliveryCompleted, recordMessageDeliveryError, recordTalkEvent, recordLaneEnqueue, recordLaneDequeue, recordSessionState, recordSessionTurnCreated, recordSessionStuck, recordSessionRecoveryRequested, recordSessionRecoveryCompleted, recordRunAttempt, recordHeartbeat, recordLivenessWarning, recordDiagnosticPhaseCompleted, recordRunStarted, recordRunCompleted, recordHarnessRunStarted, recordHarnessRunCompleted, recordHarnessRunError, recordContextAssembled, recordModelCallStarted, recordModelCallFinished, recordToolExecutionStarted, recordToolExecutionFinished, recordToolExecutionBlocked, recordSkillUsed, recordExecProcessCompleted, recordToolLoop, recordMemorySample, recordMemoryPressure, recordAsyncQueueDropped, recordTelemetryExporter, recordPayloadLarge, recordModelFailover } = recorders;
 	return (evt, metadata, privateData) => {
 		try {
 			switch (evt.type) {
+				case "diagnostic.gc":
+					recordGcDuration(evt, metadata);
+					return;
+				case "gateway.event_loop.sample":
+					recordGatewayEventLoopSample(evt, metadata);
+					return;
+				case "gateway.rpc":
+					recordGatewayRpc(evt, metadata);
+					return;
 				case "model.usage":
 					recordModelUsage(evt, metadata, privateData.hostPluginId);
 					return;
@@ -545,19 +554,15 @@ function createDiagnosticsEventHandler(params) {
 					recordModelCallStarted(evt, metadata);
 					return;
 				case "model.call.completed":
-					recordModelCallCompleted(evt, metadata, privateData.modelContent);
-					return;
 				case "model.call.error":
-					recordModelCallError(evt, metadata, privateData.modelContent);
+					recordModelCallFinished(evt, metadata, privateData.modelContent);
 					return;
 				case "tool.execution.started":
 					recordToolExecutionStarted(evt, metadata);
 					return;
 				case "tool.execution.completed":
-					recordToolExecutionCompleted(evt, metadata, privateData.toolContent);
-					return;
 				case "tool.execution.error":
-					recordToolExecutionError(evt, metadata, privateData.toolContent);
+					recordToolExecutionFinished(evt, metadata, privateData.toolContent);
 					return;
 				case "tool.execution.blocked":
 					recordToolExecutionBlocked(evt, metadata);
@@ -1056,6 +1061,48 @@ function createDiagnosticsMetrics(meter, metricNamePrefix = DEFAULT_METRIC_NAME_
 	const createCounter = (name, options) => meter.createCounter(resolveMetricName(name), options);
 	const createHistogram = (name, options) => meter.createHistogram(resolveMetricName(name), options);
 	return {
+		gcDurationHistogram: createHistogram("openclaw.gc.duration_ms", {
+			unit: "ms",
+			description: "Elapsed garbage collection duration for the hosting JavaScript isolate",
+			advice: { explicitBucketBoundaries: AGENT_DURATION_MS_BUCKETS }
+		}),
+		gatewayEventLoopDelayMaxHistogram: createHistogram("openclaw.gateway.event_loop.delay_max_ms", {
+			unit: "ms",
+			description: "Maximum event-loop delay per completed Gateway observation window",
+			advice: { explicitBucketBoundaries: AGENT_DURATION_MS_BUCKETS }
+		}),
+		gatewayEventLoopObservedCounter: createCounter("openclaw.gateway.event_loop.observed_ms", {
+			unit: "ms",
+			description: "Elapsed time covered by completed Gateway event-loop observation windows"
+		}),
+		gatewayRpcRequestsCounter: createCounter("openclaw.gateway.rpc.requests", {
+			unit: "1",
+			description: "Authenticated Gateway WebSocket requests received"
+		}),
+		gatewayRpcOutcomesCounter: createCounter("openclaw.gateway.rpc.outcomes", {
+			unit: "1",
+			description: "Gateway RPC observations by phase and outcome"
+		}),
+		gatewayRpcFirstResponseHistogram: createHistogram("openclaw.gateway.rpc.first_response_ms", {
+			unit: "ms",
+			description: "Elapsed time until the first Gateway RPC response is sent",
+			advice: { explicitBucketBoundaries: AGENT_DURATION_MS_BUCKETS }
+		}),
+		gatewayRpcHandlerHistogram: createHistogram("openclaw.gateway.rpc.handler_ms", {
+			unit: "ms",
+			description: "Gateway RPC handler duration until return or throw",
+			advice: { explicitBucketBoundaries: AGENT_DURATION_MS_BUCKETS }
+		}),
+		gatewayRpcAdmissionHistogram: createHistogram("openclaw.gateway.rpc.admission_ms", {
+			unit: "ms",
+			description: "Elapsed time from Gateway RPC receipt until handler invocation",
+			advice: { explicitBucketBoundaries: AGENT_DURATION_MS_BUCKETS }
+		}),
+		gatewayRpcQueueWaitHistogram: createHistogram("openclaw.gateway.rpc.queue_wait_ms", {
+			unit: "ms",
+			description: "Gateway operator request start queue wait",
+			advice: { explicitBucketBoundaries: AGENT_DURATION_MS_BUCKETS }
+		}),
 		tokensCounter: createCounter("openclaw.tokens", {
 			unit: "1",
 			description: "Token usage by type"
@@ -1291,7 +1338,7 @@ function createDiagnosticsMetrics(meter, metricNamePrefix = DEFAULT_METRIC_NAME_
 		}),
 		livenessCpuCoreRatioHistogram: createHistogram("openclaw.liveness.cpu_core_ratio", {
 			unit: "1",
-			description: "CPU core ratio reported by diagnostic liveness warnings"
+			description: "Whole-process CPU usage in core equivalents, including worker and native threads; can exceed 1."
 		}),
 		telemetryExporterCounter: createCounter("openclaw.telemetry.exporter.events", {
 			unit: "1",
@@ -1868,15 +1915,6 @@ function createModelRecorders(runtime) {
 		"openclaw.transport": normalizeDiagnosticValue(evt.transport),
 		"openclaw.model_call.observation_unit": modelCallObservationUnit(evt)
 	});
-	const genAiModelCallMetricAttrs = (evt, errorType) => ({
-		"gen_ai.operation.name": genAiOperationName(evt.api, evt.observationUnit),
-		"gen_ai.provider.name": normalizeDiagnosticValue(evt.provider),
-		"gen_ai.request.model": normalizeDiagnosticValue(evt.model),
-		...errorType ? { "error.type": errorType } : {}
-	});
-	const recordGenAiModelCallDuration = (evt, errorType) => {
-		genAiOperationDurationHistogram.record(evt.durationMs / 1e3, genAiModelCallMetricAttrs(evt, errorType));
-	};
 	const recordModelCallSizeTimingMetrics = (evt, attrs) => {
 		const requestPayloadBytes = positiveFiniteNumber(evt.requestPayloadBytes);
 		if (requestPayloadBytes !== void 0) modelCallRequestBytesHistogram.record(requestPayloadBytes, attrs);
@@ -1903,50 +1941,31 @@ function createModelRecorders(runtime) {
 			startTimeMs: evt.ts
 		})).spanContext();
 	};
-	const recordModelCallCompleted = (evt, metadata, modelContent) => {
-		const metricAttrs = modelCallMetricAttrs(evt);
-		modelCallDurationHistogram.record(evt.durationMs, metricAttrs);
-		recordModelCallSizeTimingMetrics(evt, metricAttrs);
-		recordGenAiModelCallDuration(evt);
-		if (!tracesEnabled) return;
-		const spanAttrs = {
-			"openclaw.provider": evt.provider,
-			"openclaw.model": evt.model
-		};
-		assignGenAiModelCallAttrs(spanAttrs, evt);
-		if (evt.api) spanAttrs["openclaw.api"] = evt.api;
-		if (evt.transport) spanAttrs["openclaw.transport"] = evt.transport;
-		assignModelCallSizeTimingAttrs(spanAttrs, evt);
-		assignModelCallPromptStatsAttrs(spanAttrs, evt);
-		assignModelCallUsageAttrs(spanAttrs, evt);
-		assignOtelModelContentAttributes(spanAttrs, modelContent, contentCapturePolicy);
-		const span = takeTrackedTrustedSpan(evt, metadata) ?? spanWithDuration(modelCallSpanName(evt), spanAttrs, evt.durationMs, {
-			kind: modelCallSpanKind(),
-			parentContext: activeTrustedParentContext(evt, metadata),
-			endTimeMs: evt.ts
-		});
-		setSpanAttrs(span, spanAttrs);
-		addUpstreamRequestIdSpanEvent(span, evt.upstreamRequestIdHash);
-		span.end(evt.ts);
-	};
-	const recordModelCallError = (evt, metadata, modelContent) => {
-		const errorType = normalizeDiagnosticValue(evt.errorCategory, "other");
+	const recordModelCallFinished = (evt, metadata, modelContent) => {
+		const errorType = evt.type === "model.call.error" ? normalizeDiagnosticValue(evt.errorCategory, "other") : void 0;
 		const metricAttrs = {
 			...modelCallMetricAttrs(evt),
-			"openclaw.errorCategory": errorType,
-			...evt.failureKind ? { "openclaw.failureKind": normalizeDiagnosticValue(evt.failureKind, "other") } : {}
+			...errorType !== void 0 ? { "openclaw.errorCategory": errorType } : {},
+			...evt.type === "model.call.error" && evt.failureKind ? { "openclaw.failureKind": normalizeDiagnosticValue(evt.failureKind, "other") } : {}
 		};
 		modelCallDurationHistogram.record(evt.durationMs, metricAttrs);
 		recordModelCallSizeTimingMetrics(evt, metricAttrs);
-		recordGenAiModelCallDuration(evt, errorType);
+		genAiOperationDurationHistogram.record(evt.durationMs / 1e3, {
+			"gen_ai.operation.name": genAiOperationName(evt.api, evt.observationUnit),
+			"gen_ai.provider.name": normalizeDiagnosticValue(evt.provider),
+			"gen_ai.request.model": normalizeDiagnosticValue(evt.model),
+			...errorType ? { "error.type": errorType } : {}
+		});
 		if (!tracesEnabled) return;
 		const spanAttrs = {
 			"openclaw.provider": evt.provider,
 			"openclaw.model": evt.model,
-			"openclaw.errorCategory": errorType,
-			"error.type": errorType
+			...errorType !== void 0 ? {
+				"openclaw.errorCategory": errorType,
+				"error.type": errorType
+			} : {}
 		};
-		if (evt.failureKind) spanAttrs["openclaw.failureKind"] = normalizeDiagnosticValue(evt.failureKind, "other");
+		if (evt.type === "model.call.error" && evt.failureKind) spanAttrs["openclaw.failureKind"] = normalizeDiagnosticValue(evt.failureKind, "other");
 		assignGenAiModelCallAttrs(spanAttrs, evt);
 		if (evt.api) spanAttrs["openclaw.api"] = evt.api;
 		if (evt.transport) spanAttrs["openclaw.transport"] = evt.transport;
@@ -1961,23 +1980,56 @@ function createModelRecorders(runtime) {
 		});
 		setSpanAttrs(span, spanAttrs);
 		addUpstreamRequestIdSpanEvent(span, evt.upstreamRequestIdHash);
-		span.setStatus({
+		if (evt.type === "model.call.error") span.setStatus({
 			code: SpanStatusCode.ERROR,
 			message: redactSensitiveText(evt.errorCategory)
 		});
 		span.end(evt.ts);
 	};
 	return {
-		recordModelCallSizeTimingMetrics,
 		recordModelCallStarted,
-		recordModelCallCompleted,
-		recordModelCallError
+		recordModelCallFinished
 	};
 }
 //#endregion
 //#region extensions/diagnostics-otel/src/service-recorders-operations.ts
 function createOperationsRecorders(runtime) {
-	const { durationHistogram, queueDepthHistogram, queueWaitHistogram, laneEnqueueCounter, laneDequeueCounter, sessionStateCounter, sessionTurnCreatedCounter, sessionStuckCounter, sessionStuckAgeHistogram, sessionRecoveryRequestedCounter, sessionRecoveryCompletedCounter, sessionRecoveryAgeHistogram, talkEventCounter, talkEventDurationHistogram, talkAudioBytesHistogram, runAttemptCounter, toolLoopCounter, memoryRssHistogram, memoryHeapUsedHistogram, memoryHeapTotalHistogram, memoryExternalHistogram, memoryArrayBuffersHistogram, memoryPressureCounter, asyncQueueDroppedCounter, tracer, activeTrustedSpans, spanWithDuration, trustedTraceContext, activeTrustedParentContext, setSpanAttrs, completeTrackedLifecycleSpan, addRunAttrs, tracesEnabled } = runtime;
+	const { durationHistogram, gatewayRpcRequestsCounter, gatewayRpcOutcomesCounter, gatewayRpcFirstResponseHistogram, gatewayRpcHandlerHistogram, gatewayRpcAdmissionHistogram, gatewayRpcQueueWaitHistogram, queueDepthHistogram, queueWaitHistogram, laneEnqueueCounter, laneDequeueCounter, sessionStateCounter, sessionTurnCreatedCounter, sessionStuckCounter, sessionStuckAgeHistogram, sessionRecoveryRequestedCounter, sessionRecoveryCompletedCounter, sessionRecoveryAgeHistogram, talkEventCounter, talkEventDurationHistogram, talkAudioBytesHistogram, runAttemptCounter, toolLoopCounter, memoryRssHistogram, memoryHeapUsedHistogram, memoryHeapTotalHistogram, memoryExternalHistogram, memoryArrayBuffersHistogram, memoryPressureCounter, asyncQueueDroppedCounter, tracer, activeTrustedSpans, spanWithDuration, trustedTraceContext, activeTrustedParentContext, internalOrTrustedExplicitParentContext, setSpanAttrs, completeTrackedLifecycleSpan, addRunAttrs, tracesEnabled } = runtime;
+	const recordGatewayRpc = (evt, metadata) => {
+		if (!metadata.trusted) return;
+		const attrs = { "openclaw.gateway.rpc.method": evt.method };
+		if (evt.phase === "received") {
+			gatewayRpcRequestsCounter.add(1, attrs);
+			return;
+		}
+		const outcomeAttrs = {
+			"openclaw.gateway.rpc.phase": evt.phase,
+			"openclaw.gateway.rpc.outcome": evt.outcome
+		};
+		gatewayRpcOutcomesCounter.add(1, outcomeAttrs);
+		switch (evt.phase) {
+			case "response":
+				if (evt.outcome === "ok" || evt.outcome === "error") gatewayRpcFirstResponseHistogram.record(evt.durationMs, attrs);
+				break;
+			case "handler":
+				gatewayRpcHandlerHistogram.record(evt.durationMs, attrs);
+				gatewayRpcAdmissionHistogram.record(evt.admissionMs, attrs);
+				break;
+			case "dispatch": if (evt.queueWaitMs !== void 0) gatewayRpcQueueWaitHistogram.record(evt.queueWaitMs, attrs);
+		}
+		if (!tracesEnabled) return;
+		const span = spanWithDuration(`openclaw.gateway.rpc.${evt.phase}`, {
+			...attrs,
+			...outcomeAttrs,
+			...evt.phase === "handler" ? { "openclaw.gateway.rpc.admission_ms": evt.admissionMs } : {},
+			...evt.phase === "dispatch" ? { "openclaw.gateway.rpc.response": evt.response } : {}
+		}, evt.durationMs, {
+			endTimeMs: evt.ts,
+			parentContext: internalOrTrustedExplicitParentContext(evt, metadata) ?? ROOT_CONTEXT
+		});
+		if (evt.outcome === "error" || evt.outcome === "threw") span.setStatus({ code: SpanStatusCode.ERROR });
+		span.end(evt.ts);
+	};
 	const recordLaneEnqueue = (evt) => {
 		const attrs = { "openclaw.lane": normalizeDiagnosticLane(evt.lane) };
 		laneEnqueueCounter.add(1, attrs);
@@ -2151,6 +2203,7 @@ function createOperationsRecorders(runtime) {
 		span.end(evt.ts);
 	};
 	return {
+		recordGatewayRpc,
 		recordLaneEnqueue,
 		recordLaneDequeue,
 		recordSessionState,
@@ -2171,7 +2224,7 @@ function createOperationsRecorders(runtime) {
 //#endregion
 //#region extensions/diagnostics-otel/src/service-recorders-tools.ts
 function createToolAndSystemRecorders(runtime) {
-	const { queueDepthHistogram, skillUsedCounter, toolExecutionDurationHistogram, toolExecutionBlockedCounter, execProcessDurationHistogram, payloadLargeCounter, payloadLargeBytesHistogram, livenessWarningCounter, livenessEventLoopDelayP99Histogram, livenessEventLoopDelayMaxHistogram, livenessEventLoopUtilizationHistogram, livenessCpuCoreRatioHistogram, telemetryExporterCounter, spanWithDuration, activeTrustedParentContext, exportedInternalOrTrustedContext, trackTrustedSpan, getTrackedInternalOrTrustedSpan, takeTrackedTrustedSpan, setSpanAttrs, addRunAttrs, paramsSummaryAttrs, contentCapturePolicy, tracesEnabled } = runtime;
+	const { gcDurationHistogram, gatewayEventLoopDelayMaxHistogram, gatewayEventLoopObservedCounter, queueDepthHistogram, skillUsedCounter, toolExecutionDurationHistogram, toolExecutionBlockedCounter, execProcessDurationHistogram, payloadLargeCounter, payloadLargeBytesHistogram, livenessWarningCounter, livenessEventLoopDelayP99Histogram, livenessEventLoopDelayMaxHistogram, livenessEventLoopUtilizationHistogram, livenessCpuCoreRatioHistogram, telemetryExporterCounter, spanWithDuration, activeTrustedParentContext, exportedInternalOrTrustedContext, trackTrustedSpan, getTrackedInternalOrTrustedSpan, takeTrackedTrustedSpan, setSpanAttrs, addRunAttrs, paramsSummaryAttrs, contentCapturePolicy, tracesEnabled } = runtime;
 	const toolExecutionBaseAttrs = (evt) => ({
 		"openclaw.toolName": evt.toolName,
 		"openclaw.tool.source": normalizeDiagnosticValue(evt.toolSource, "core"),
@@ -2212,39 +2265,22 @@ function createToolAndSystemRecorders(runtime) {
 			startTimeMs: toolTimestampMs(evt)
 		})).spanContext();
 	};
-	const recordToolExecutionCompleted = (evt, metadata, toolContent) => {
+	const recordToolExecutionFinished = (evt, metadata, toolContent) => {
 		const attrs = toolExecutionBaseAttrs(evt);
+		if (evt.type === "tool.execution.error") attrs["openclaw.errorCategory"] = normalizeDiagnosticValue(evt.errorCategory, "other");
 		toolExecutionDurationHistogram.record(evt.durationMs, attrs);
 		if (!tracesEnabled) return;
 		const spanAttrs = { ...attrs };
 		addRunAttrs(spanAttrs, evt);
 		assignOtelToolIdentityAttributes(spanAttrs, evt);
+		if (evt.type === "tool.execution.error" && evt.errorCode) spanAttrs["openclaw.errorCode"] = normalizeDiagnosticValue(evt.errorCode, "other");
 		assignOtelToolContentAttributes(spanAttrs, toolContent, contentCapturePolicy);
 		const span = takeTrackedTrustedSpan(evt, metadata) ?? spanWithDuration("openclaw.tool.execution", spanAttrs, evt.durationMs, {
 			parentContext: activeTrustedParentContext(evt, metadata),
 			endTimeMs: toolTimestampMs(evt)
 		});
 		setSpanAttrs(span, spanAttrs);
-		span.end(toolTimestampMs(evt));
-	};
-	const recordToolExecutionError = (evt, metadata, toolContent) => {
-		const attrs = {
-			...toolExecutionBaseAttrs(evt),
-			"openclaw.errorCategory": normalizeDiagnosticValue(evt.errorCategory, "other")
-		};
-		toolExecutionDurationHistogram.record(evt.durationMs, attrs);
-		if (!tracesEnabled) return;
-		const spanAttrs = { ...attrs };
-		addRunAttrs(spanAttrs, evt);
-		assignOtelToolIdentityAttributes(spanAttrs, evt);
-		if (evt.errorCode) spanAttrs["openclaw.errorCode"] = normalizeDiagnosticValue(evt.errorCode, "other");
-		assignOtelToolContentAttributes(spanAttrs, toolContent, contentCapturePolicy);
-		const span = takeTrackedTrustedSpan(evt, metadata) ?? spanWithDuration("openclaw.tool.execution", spanAttrs, evt.durationMs, {
-			parentContext: activeTrustedParentContext(evt, metadata),
-			endTimeMs: toolTimestampMs(evt)
-		});
-		setSpanAttrs(span, spanAttrs);
-		span.setStatus({
+		if (evt.type === "tool.execution.error") span.setStatus({
 			code: SpanStatusCode.ERROR,
 			message: redactSensitiveText(evt.errorCategory)
 		});
@@ -2308,6 +2344,15 @@ function createToolAndSystemRecorders(runtime) {
 		});
 		span.end(evt.ts);
 	};
+	const recordGcDuration = (evt, metadata) => {
+		if (!metadata.trusted && !isInternalDiagnosticEventMetadata(metadata)) return;
+		gcDurationHistogram.record(evt.durationMs, void 0, ROOT_CONTEXT);
+	};
+	const recordGatewayEventLoopSample = (evt, metadata) => {
+		if (!metadata.trusted && !isInternalDiagnosticEventMetadata(metadata)) return;
+		gatewayEventLoopDelayMaxHistogram.record(evt.delayMaxMs, void 0, ROOT_CONTEXT);
+		gatewayEventLoopObservedCounter.add(evt.intervalMs, void 0, ROOT_CONTEXT);
+	};
 	const recordHeartbeat = (evt) => {
 		queueDepthHistogram.record(evt.queued, { "openclaw.channel": "heartbeat" });
 	};
@@ -2365,10 +2410,11 @@ function createToolAndSystemRecorders(runtime) {
 		});
 	};
 	return {
+		recordGcDuration,
+		recordGatewayEventLoopSample,
 		recordSkillUsed,
 		recordToolExecutionStarted,
-		recordToolExecutionCompleted,
-		recordToolExecutionError,
+		recordToolExecutionFinished,
 		recordToolExecutionBlocked,
 		recordPayloadLarge,
 		recordExecProcessCompleted,
@@ -2910,56 +2956,34 @@ function diagnosticTraceContextFromSpanContext(spanContext) {
 	};
 }
 function createDiagnosticsOtelService() {
-	let traceProvider = null;
-	let meterProvider = null;
-	let logProvider = null;
-	let unsubscribe = null;
-	let unregisterTracePropagationBridge = null;
-	let stopActiveTrustedSpans = null;
-	let unregisterOwnedSdkRuntime = null;
-	let unregisterUnhandledRejectionHandler = null;
-	let retireExporterRoutes = null;
+	let state = {};
 	let preserveExporterRoutesOnNextStop = false;
 	const stopStarted = async (options) => {
-		const currentUnsubscribe = unsubscribe;
-		const currentUnregisterTracePropagationBridge = unregisterTracePropagationBridge;
-		const currentLogProvider = logProvider;
-		const currentTraceProvider = traceProvider;
-		const currentMeterProvider = meterProvider;
-		const currentStopActiveTrustedSpans = stopActiveTrustedSpans;
-		const currentUnregisterOwnedSdkRuntime = unregisterOwnedSdkRuntime;
-		const currentUnregisterUnhandledRejectionHandler = unregisterUnhandledRejectionHandler;
-		const currentRetireExporterRoutes = retireExporterRoutes;
-		unsubscribe = null;
-		unregisterTracePropagationBridge = null;
-		logProvider = null;
-		traceProvider = null;
-		meterProvider = null;
-		stopActiveTrustedSpans = null;
-		unregisterOwnedSdkRuntime = null;
-		unregisterUnhandledRejectionHandler = null;
-		retireExporterRoutes = options?.preserveExporterRoutes ? currentRetireExporterRoutes : null;
+		const current = state;
+		state = options?.preserveExporterRoutes ? { retireExporterRoutes: current.retireExporterRoutes } : {};
 		const settle = async (...stops) => (await Promise.allSettled(stops.map((stop) => Promise.resolve().then(() => stop?.())))).flatMap((result) => result.status === "rejected" ? [result.reason] : []);
-		const failures = await settle(currentUnregisterTracePropagationBridge, currentUnsubscribe, currentStopActiveTrustedSpans, currentUnregisterOwnedSdkRuntime);
-		const providerFailures = await settle(currentLogProvider ? () => currentLogProvider.shutdown() : null, currentTraceProvider ? () => currentTraceProvider.shutdown() : null, currentMeterProvider ? () => currentMeterProvider.shutdown() : null);
+		const failures = await settle(current.unregisterTracePropagationBridge, current.unsubscribe, current.stopActiveTrustedSpans, current.unregisterOwnedSdkRuntime);
+		const providerFailures = await settle(() => current.logProvider?.shutdown(), () => current.traceProvider?.shutdown(), () => current.meterProvider?.shutdown());
 		failures.push(...providerFailures);
-		if (!options?.preserveExporterRoutes) currentRetireExporterRoutes?.(providerFailures.length > 0);
-		if (providerFailures.length > 0) retireExporterRoutes = currentRetireExporterRoutes;
-		failures.push(...await settle(currentUnregisterUnhandledRejectionHandler));
+		if (!options?.preserveExporterRoutes) current.retireExporterRoutes?.(providerFailures.length > 0);
+		if (providerFailures.length > 0) state.retireExporterRoutes = current.retireExporterRoutes;
+		failures.push(...await settle(current.unregisterUnhandledRejectionHandler));
 		if (failures.length === 1) throw failures[0];
 		if (failures.length > 1) throw new AggregateError(failures, `diagnostics-otel shutdown failed: ${failures.join("; ")}`);
 	};
 	return {
 		id: "diagnostics-otel",
+		reload: { configPrefixes: ["diagnostics.otel", "diagnostics.enabled"] },
 		async start(ctx) {
 			preserveExporterRoutesOnNextStop = false;
 			await stopStarted();
+			const active = state;
 			const cfg = ctx.config.diagnostics;
 			const otel = cfg?.otel;
 			if (!cfg || cfg.enabled === false || !otel?.enabled) return;
 			const sdkDisabled = isOtelSdkDisabled(ctx.logger);
 			const sdkPreloaded = hasPreloadedOtelSdk();
-			if (!sdkPreloaded) unregisterOwnedSdkRuntime = registerOwnedSdkRuntime((message) => ctx.logger.warn(message));
+			if (!sdkPreloaded) active.unregisterOwnedSdkRuntime = registerOwnedSdkRuntime((message) => ctx.logger.warn(message));
 			if (!sdkPreloaded && sdkDisabled) return;
 			const exporterRoutes = /* @__PURE__ */ new Map();
 			const internalDiagnostics = ctx.internalDiagnostics;
@@ -3004,7 +3028,7 @@ function createDiagnosticsOtelService() {
 				ctx.logger.error("diagnostics-otel: internal diagnostics capability unavailable");
 				return;
 			}
-			retireExporterRoutes = (preserveFailures = false) => {
+			active.retireExporterRoutes = (preserveFailures = false) => {
 				for (const route of exporterRoutes.values()) {
 					if (preserveFailures && route.status === "failure") continue;
 					emitExporterEvent({
@@ -3106,7 +3130,7 @@ function createDiagnosticsOtelService() {
 					exportIntervalMillis: metricInterval,
 					exportTimeoutMillis: metricTimeout
 				}) : void 0;
-				if (metricReader) meterProvider = new MeterProvider({
+				if (metricReader) active.meterProvider = new MeterProvider({
 					resource: detectedResource,
 					readers: [metricReader],
 					sdkMetricsEnabled
@@ -3126,13 +3150,13 @@ function createDiagnosticsOtelService() {
 						maxExportBatchSize: Math.min(readPositiveOtelNumber("OTEL_BSP_MAX_EXPORT_BATCH_SIZE", 512), maxQueueSize),
 						scheduledDelayMillis: typeof otel.flushIntervalMs === "number" ? Math.max(1e3, otel.flushIntervalMs) : readPositiveOtelNumber("OTEL_BSP_SCHEDULE_DELAY", 5e3),
 						exportTimeoutMillis: readPositiveOtelNumber("OTEL_BSP_EXPORT_TIMEOUT", 3e4),
-						...sdkMetricsEnabled && meterProvider ? { selfObsMeterProvider: meterProvider } : {}
+						...sdkMetricsEnabled && active.meterProvider ? { selfObsMeterProvider: active.meterProvider } : {}
 					});
-					traceProvider = new BasicTracerProvider({
+					active.traceProvider = new BasicTracerProvider({
 						resource: detectedResource,
 						spanProcessors: [spanProcessor],
 						...sampleRate !== void 0 ? { sampler: new ParentBasedSampler({ root: new TraceIdRatioBasedSampler(sampleRate) }) } : {},
-						...sdkMetricsEnabled && meterProvider ? { meterProvider } : {}
+						...sdkMetricsEnabled && active.meterProvider ? { meterProvider: active.meterProvider } : {}
 					});
 				}
 			} catch (err) {
@@ -3156,9 +3180,9 @@ function createDiagnosticsOtelService() {
 				throw err;
 			}
 			else if (sdkPreloaded && (tracesEnabled || metricsEnabled)) ctx.logger.info("diagnostics-otel: using preloaded OpenTelemetry SDK");
-			const meter = meterProvider ? meterProvider.getMeter("openclaw") : metrics.getMeter("openclaw");
-			const diagnosticsTrace = createDiagnosticsTraceRuntime(traceProvider ? traceProvider.getTracer("openclaw") : trace.getTracer("openclaw"));
-			stopActiveTrustedSpans = diagnosticsTrace.stopActiveTrustedSpans;
+			const meter = !metricsActive ? createNoopMeter() : active.meterProvider ? active.meterProvider.getMeter("openclaw") : metrics.getMeter("openclaw");
+			const diagnosticsTrace = createDiagnosticsTraceRuntime(active.traceProvider ? active.traceProvider.getTracer("openclaw") : trace.getTracer("openclaw"));
+			active.stopActiveTrustedSpans = diagnosticsTrace.stopActiveTrustedSpans;
 			const diagnosticMetrics = createDiagnosticsMetrics(meter, otel.metricNamePrefix);
 			const diagnosticsLogs = createDiagnosticsLogExporter({
 				contentCapturePolicy,
@@ -3174,7 +3198,7 @@ function createDiagnosticsOtelService() {
 				resource,
 				serviceName
 			});
-			logProvider = diagnosticsLogs.logProvider;
+			active.logProvider = diagnosticsLogs.logProvider;
 			const { recordLogRecord, recordSecurityEvent } = diagnosticsLogs;
 			const recorderRuntime = createDiagnosticsRecorderRuntime({
 				contentCapturePolicy,
@@ -3189,13 +3213,13 @@ function createDiagnosticsOtelService() {
 				...createModelRecorders(recorderRuntime),
 				...createToolAndSystemRecorders(recorderRuntime)
 			};
-			unsubscribe = subscribe(createDiagnosticsEventHandler({
+			active.unsubscribe = subscribe(createDiagnosticsEventHandler({
 				logger: ctx.logger,
 				recorders,
 				recordLogRecord,
 				recordSecurityEvent
-			}));
-			if (tracesActive) unregisterTracePropagationBridge = ctx.internalDiagnostics?.registerTracePropagationBridge?.({
+			}), metricsActive ? void 0 : tracesActive ? { exclude: ["gateway.event_loop.sample", "diagnostic.gc"] } : { include: ["log.record", "security.event"] });
+			if (tracesActive) active.unregisterTracePropagationBridge = ctx.internalDiagnostics?.registerTracePropagationBridge?.({
 				shouldPrepareEvent(event) {
 					return event.type === "model.call.started" || event.type === "tool.execution.started";
 				},
@@ -3208,7 +3232,7 @@ function createDiagnosticsOtelService() {
 					return spanContext ? diagnosticTraceContextFromSpanContext(spanContext) : void 0;
 				}
 			}) ?? null;
-			if (hasOwnedOtlpSignal || sdkPreloaded && !sdkDisabled) unregisterUnhandledRejectionHandler = registerUnhandledRejectionHandler((reason) => {
+			if (hasOwnedOtlpSignal || sdkPreloaded && !sdkDisabled) active.unregisterUnhandledRejectionHandler = registerUnhandledRejectionHandler((reason) => {
 				const otlpError = findOtlpExporterError(reason);
 				if (!otlpError) return false;
 				const code = readErrorCode(otlpError) ?? "unknown";

package/dist/runtime-api.js

@@ -1,2 +1,2 @@
-import { t as createDiagnosticsOtelService } from "./runtime-api-DaBnxBEO.js";
+import { t as createDiagnosticsOtelService } from "./runtime-api-B9-DLHbi.js";
 export { createDiagnosticsOtelService };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/diagnostics-otel",
-  "version": "2026.9.1",
+  "version": "2026.9.3",
   "description": "OpenClaw diagnostics OpenTelemetry exporter for metrics, traces, and logs.",
   "repository": {
     "type": "git",
@@ -34,10 +34,10 @@
       "minHostVersion": ">=2026.4.25"
     },
     "compat": {
-      "pluginApi": ">=2026.9.1"
+      "pluginApi": ">=2026.9.3"
     },
     "build": {
-      "openclawVersion": "2026.9.1"
+      "openclawVersion": "2026.9.3"
     },
     "release": {
       "publishToClawHub": true,
@@ -53,7 +53,7 @@
     "README.md"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.9.1"
+    "openclaw": ">=2026.9.3"
   },
   "peerDependenciesMeta": {
     "openclaw": {