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

package/dist/.setup/{runtime-api-CKLGMqUx.mjs → runtime-api-DNn_S1dw.mjs}

@@ -1,4 +1,4 @@
-import { ROOT_CONTEXT, SpanKind, SpanStatusCode, TraceFlags, context, createContextKey, createNoopMeter, diag, isSpanContextValid, metrics, propagation, trace } from "@opentelemetry/api";
+import { ROOT_CONTEXT, SpanKind, SpanStatusCode, TraceFlags, context, 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";
@@ -57,12 +57,6 @@ const BLOCKED_OTEL_LOG_ATTRIBUTE_KEYS = /* @__PURE__ */ new Set([
 	"constructor"
 ]);
 const OTEL_EXPORTER_OTLP_ENDPOINT_ENV = "OTEL_EXPORTER_OTLP_ENDPOINT";
-const OTEL_EXPORTER_OTLP_TRACES_ENDPOINT_ENV = "OTEL_EXPORTER_OTLP_TRACES_ENDPOINT";
-const OTEL_EXPORTER_OTLP_METRICS_ENDPOINT_ENV = "OTEL_EXPORTER_OTLP_METRICS_ENDPOINT";
-const OTEL_EXPORTER_OTLP_LOGS_ENDPOINT_ENV = "OTEL_EXPORTER_OTLP_LOGS_ENDPOINT";
-const OTEL_EXPORTER_OTLP_TRACES_PROTOCOL_ENV = "OTEL_EXPORTER_OTLP_TRACES_PROTOCOL";
-const OTEL_EXPORTER_OTLP_METRICS_PROTOCOL_ENV = "OTEL_EXPORTER_OTLP_METRICS_PROTOCOL";
-const OTEL_EXPORTER_OTLP_LOGS_PROTOCOL_ENV = "OTEL_EXPORTER_OTLP_LOGS_PROTOCOL";
 const OTEL_EXPORTER_OTLP_CERTIFICATE_ENV = "OTEL_EXPORTER_OTLP_CERTIFICATE";
 const OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE_ENV = "OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE";
 const OTEL_EXPORTER_OTLP_CLIENT_KEY_ENV = "OTEL_EXPORTER_OTLP_CLIENT_KEY";
@@ -467,22 +461,19 @@ function createExporterHealthEventEmitter(publish) {
 		}
 		const reason = event.reason ?? "unspecified";
 		if (event.status === "failure") {
-			const route = failures.get(key) ?? { active: /* @__PURE__ */ new Map() };
-			failures.set(key, route);
-			if (route.active.has(reason)) return;
-			route.active.set(reason, event);
-			if (route.reported === void 0) {
-				route.reported = reason;
-				publish(event);
-			}
+			const active = failures.get(key) ?? /* @__PURE__ */ new Map();
+			if (active.has(reason)) return;
+			active.set(reason, event);
+			failures.set(key, active);
+			if (active.size === 1) publish(event);
 			return;
 		}
-		const route = failures.get(key);
-		if (!route?.active.delete(reason) || route.reported !== reason) return;
-		const next = route.active.entries().next().value;
+		const active = failures.get(key);
+		const reported = active?.keys().next().value;
+		if (!active?.delete(reason) || reported !== reason) return;
+		const next = active.values().next().value;
 		if (next) {
-			route.reported = next[0];
-			publish(next[1]);
+			publish(next);
 			return;
 		}
 		failures.delete(key);
@@ -855,16 +846,17 @@ function createDiagnosticsMetrics(meter, metricNamePrefix = DEFAULT_METRIC_NAME_
 		description,
 		...explicitBucketBoundaries ? { advice: { explicitBucketBoundaries } } : {}
 	});
+	const createDurationHistogram = (name, description) => createHistogram(name, description, "ms", AGENT_DURATION_MS_BUCKETS);
 	return {
-		gcDurationHistogram: createHistogram("gc.duration_ms", "Elapsed garbage collection duration for the hosting JavaScript isolate", "ms", AGENT_DURATION_MS_BUCKETS),
-		gatewayEventLoopDelayMaxHistogram: createHistogram("gateway.event_loop.delay_max_ms", "Maximum event-loop delay per completed Gateway observation window", "ms", AGENT_DURATION_MS_BUCKETS),
+		gcDurationHistogram: createDurationHistogram("gc.duration_ms", "Elapsed garbage collection duration for the hosting JavaScript isolate"),
+		gatewayEventLoopDelayMaxHistogram: createDurationHistogram("gateway.event_loop.delay_max_ms", "Maximum event-loop delay per completed Gateway observation window"),
 		gatewayEventLoopObservedCounter: createCounter("gateway.event_loop.observed_ms", "Elapsed time covered by completed Gateway event-loop observation windows", "ms"),
 		gatewayRpcRequestsCounter: createCounter("gateway.rpc.requests", "Authenticated Gateway WebSocket requests received"),
 		gatewayRpcOutcomesCounter: createCounter("gateway.rpc.outcomes", "Gateway RPC observations by phase and outcome"),
-		gatewayRpcFirstResponseHistogram: createHistogram("gateway.rpc.first_response_ms", "Elapsed time until the first Gateway RPC response is sent", "ms", AGENT_DURATION_MS_BUCKETS),
-		gatewayRpcHandlerHistogram: createHistogram("gateway.rpc.handler_ms", "Gateway RPC handler duration until return or throw", "ms", AGENT_DURATION_MS_BUCKETS),
-		gatewayRpcAdmissionHistogram: createHistogram("gateway.rpc.admission_ms", "Elapsed time from Gateway RPC receipt until handler invocation", "ms", AGENT_DURATION_MS_BUCKETS),
-		gatewayRpcQueueWaitHistogram: createHistogram("gateway.rpc.queue_wait_ms", "Gateway operator start queue or worker frame queue wait", "ms", AGENT_DURATION_MS_BUCKETS),
+		gatewayRpcFirstResponseHistogram: createDurationHistogram("gateway.rpc.first_response_ms", "Elapsed time until the first Gateway RPC response is sent"),
+		gatewayRpcHandlerHistogram: createDurationHistogram("gateway.rpc.handler_ms", "Gateway RPC handler duration until return or throw"),
+		gatewayRpcAdmissionHistogram: createDurationHistogram("gateway.rpc.admission_ms", "Elapsed time from Gateway RPC receipt until handler invocation"),
+		gatewayRpcQueueWaitHistogram: createDurationHistogram("gateway.rpc.queue_wait_ms", "Gateway operator start queue or worker frame queue wait"),
 		tokensCounter: createCounter("tokens", "Token usage by type"),
 		genAiTokenUsageHistogram: meter.createHistogram("gen_ai.client.token.usage", {
 			unit: "{token}",
@@ -877,8 +869,8 @@ function createDiagnosticsMetrics(meter, metricNamePrefix = DEFAULT_METRIC_NAME_
 			advice: { explicitBucketBoundaries: GEN_AI_OPERATION_DURATION_BUCKETS }
 		}),
 		costCounter: createCounter("cost.usd", "Estimated model cost (USD)"),
-		durationHistogram: createHistogram("run.duration_ms", "Agent run duration", "ms", AGENT_DURATION_MS_BUCKETS),
-		harnessDurationHistogram: createHistogram("harness.duration_ms", "Agent harness lifecycle duration", "ms", AGENT_DURATION_MS_BUCKETS),
+		durationHistogram: createDurationHistogram("run.duration_ms", "Agent run duration"),
+		harnessDurationHistogram: createDurationHistogram("harness.duration_ms", "Agent harness lifecycle duration"),
 		contextHistogram: createHistogram("context.tokens", "Context window size and usage", "1", CONTEXT_TOKENS_BUCKETS),
 		webhookReceivedCounter: createCounter("webhook.received", "Webhook requests received"),
 		webhookErrorCounter: createCounter("webhook.error", "Webhook processing errors"),
@@ -937,49 +929,6 @@ function createDiagnosticsMetrics(meter, metricNamePrefix = DEFAULT_METRIC_NAME_
 //#endregion
 //#region extensions/diagnostics-otel/src/service-propagation.ts
 const DEFAULT_PROPAGATORS = ["tracecontext", "baggage"];
-const CONTEXT_OWNER_KEY = createContextKey("openclaw.owned-sdk.context-owner");
-const PROPAGATOR_OWNER_KEY = createContextKey("openclaw.owned-sdk.propagator-owner");
-var OwnedContextManager = class extends AsyncLocalStorageContextManager {
-	constructor(owner) {
-		super();
-		this.owner = owner;
-	}
-	with(activeContext, fn, thisArg, ...args) {
-		const probe = activeContext.getValue(CONTEXT_OWNER_KEY);
-		if (probe && typeof probe === "object") probe.owner = this.owner;
-		return super.with(activeContext, fn, thisArg, ...args);
-	}
-};
-var OwnedPropagator = class {
-	constructor(delegate, owner) {
-		this.delegate = delegate;
-		this.owner = owner;
-	}
-	inject(carrierContext, carrier, setter) {
-		const probe = carrierContext.getValue(PROPAGATOR_OWNER_KEY);
-		if (probe && typeof probe === "object") {
-			probe.owner = this.owner;
-			return;
-		}
-		this.delegate.inject(carrierContext, carrier, setter);
-	}
-	extract(carrierContext, carrier, getter) {
-		return this.delegate.extract(carrierContext, carrier, getter);
-	}
-	fields() {
-		return this.delegate.fields();
-	}
-};
-function ownsGlobalPropagator(owner) {
-	const probe = {};
-	propagation.inject(ROOT_CONTEXT.setValue(PROPAGATOR_OWNER_KEY, probe), {}, { set() {} });
-	return probe.owner === owner;
-}
-function ownsGlobalContextManager(owner) {
-	const probe = {};
-	context.with(ROOT_CONTEXT.setValue(CONTEXT_OWNER_KEY, probe), () => {});
-	return probe.owner === owner;
-}
 function createConfiguredPropagator(warn) {
 	const names = (getStringListFromEnv("OTEL_PROPAGATORS") ?? DEFAULT_PROPAGATORS).map((name) => name.toLowerCase());
 	if (names.includes("none")) return null;
@@ -1001,17 +950,15 @@ function createConfiguredPropagator(warn) {
 	return propagators.length === 1 ? propagators[0] : new CompositePropagator({ propagators });
 }
 function registerOwnedSdkRuntime(warn) {
-	const owner = {};
-	const contextManager = new OwnedContextManager(owner).enable();
+	const contextManager = new AsyncLocalStorageContextManager().enable();
 	const ownsContext = context.setGlobalContextManager(contextManager);
 	if (!ownsContext) contextManager.disable();
 	const propagator = createConfiguredPropagator(warn);
-	const ownsPropagation = propagator ? propagation.setGlobalPropagator(new OwnedPropagator(propagator, owner)) : false;
+	const ownsPropagation = propagator ? propagation.setGlobalPropagator(propagator) : false;
 	if (!ownsContext && !ownsPropagation) return null;
 	return () => {
-		if (ownsPropagation && ownsGlobalPropagator(owner)) propagation.disable();
-		if (ownsContext && ownsGlobalContextManager(owner)) context.disable();
-		else if (ownsContext) contextManager.disable();
+		if (ownsPropagation) propagation.disable();
+		if (ownsContext) context.disable();
 	};
 }
 //#endregion
@@ -1247,10 +1194,12 @@ function createHarnessRecorders(runtime) {
 			assignOtelModelContentAttributes(attrs, privateData.modelContent, runtime.captureContent);
 			span.addEvent("openclaw.agent.commentary", redactOtelAttributes(attrs), evt.sourceTimestampMs);
 		},
-		recordHarnessRunStarted(evt, metadata) {
+		recordHarnessRunStarted(evt, metadata, privateData) {
 			if (!runtime.tracesEnabled || !metadata.trusted) return;
 			const spanAttrs = { ...harnessRunMetricAttrs(evt) };
 			runtime.addRunAttrs(spanAttrs, evt);
+			const inputValue = runtime.captureContent ? normalizeOtelContentValue(privateData.harnessContent?.userPrompt) : void 0;
+			if (inputValue) spanAttrs["input.value"] = inputValue;
 			runtime.trackTrustedSpan(evt, metadata, runtime.spanWithDuration("openclaw.harness.run", spanAttrs, void 0, {
 				parentContext: runtime.activeTrustedParentContext(evt, metadata),
 				startTimeMs: evt.ts
@@ -1283,6 +1232,10 @@ function createHarnessRecorders(runtime) {
 			}
 			const redactedError = normalizeOtelErrorMessage(privateData.errorMessage);
 			if (redactedError) spanAttrs["openclaw.error"] = redactedError;
+			const inputValue = runtime.captureContent ? normalizeOtelContentValue(privateData.harnessContent?.userPrompt) : void 0;
+			if (inputValue) spanAttrs["input.value"] = inputValue;
+			const outputValue = runtime.captureContent ? normalizeOtelContentValue(privateData.harnessContent?.finalResponse) : void 0;
+			if (outputValue) spanAttrs["output.value"] = outputValue;
 			const trustedTrace = runtime.trustedTraceContext(evt, metadata);
 			const trackedSpan = trustedTrace?.spanId ? runtime.activeTrustedSpans.get(trustedTrace.spanId) : void 0;
 			const span = trackedSpan ?? runtime.spanWithDuration("openclaw.harness.run", spanAttrs, evt.durationMs, {
@@ -1704,6 +1657,10 @@ function createOperationsRecorders(runtime) {
 			if (evt.errorCategory) spanAttrs["openclaw.errorCategory"] = normalizeDiagnosticValue(evt.errorCategory, "other");
 			const redactedError = normalizeOtelErrorMessage(privateData.errorMessage);
 			if (redactedError) spanAttrs["openclaw.error"] = redactedError;
+			const inputValue = runtime.captureContent ? normalizeOtelContentValue(privateData.messageContent?.userPrompt) : void 0;
+			if (inputValue) spanAttrs["input.value"] = inputValue;
+			const outputValue = runtime.captureContent ? normalizeOtelContentValue(privateData.messageContent?.finalResponse) : void 0;
+			if (outputValue) spanAttrs["output.value"] = outputValue;
 			const trustedTrace = runtime.trustedTraceContext(evt, metadata);
 			const trackedSpan = trustedTrace?.spanId ? runtime.activeTrustedSpans.get(trustedTrace.spanId) : void 0;
 			const span = trackedSpan ?? runtime.spanWithDuration("openclaw.run", spanAttrs, evt.durationMs, {
@@ -1730,13 +1687,17 @@ function createToolAndSystemRecorders(runtime) {
 		"openclaw.tool.source": normalizeDiagnosticValue(evt.toolSource, "core"),
 		"gen_ai.tool.name": evt.toolName,
 		...evt.toolOwner ? { "openclaw.tool.owner": normalizeDiagnosticValue(evt.toolOwner) } : {},
-		...runtime.paramsSummaryAttrs(evt.paramsSummary)
+		...evt.paramsSummary ? { "openclaw.tool.params.kind": evt.paramsSummary.kind } : {}
 	});
 	const toolTimestampMs = (evt) => evt.sourceTimestampMs ?? evt.ts;
 	return {
 		recordGcDuration(evt, metadata) {
 			if (!metadata.trusted && !isInternalDiagnosticEventMetadata(metadata)) return;
-			runtime.gcDurationHistogram.record(evt.durationMs, void 0, ROOT_CONTEXT);
+			runtime.gcDurationHistogram.record(evt.durationMs, {
+				"openclaw.gc.kind": evt.kind ?? "unknown",
+				"openclaw.gc.thread": evt.thread ?? "main",
+				...evt.workerSlot === void 0 ? {} : { "openclaw.gc.worker_slot": evt.workerSlot }
+			}, ROOT_CONTEXT);
 		},
 		recordGatewayEventLoopSample(evt, metadata) {
 			if (!metadata.trusted && !isInternalDiagnosticEventMetadata(metadata)) return;
@@ -1767,7 +1728,10 @@ function createToolAndSystemRecorders(runtime) {
 			if (!runtime.tracesEnabled || !metadata.trusted) return;
 			const trackedSpan = runtime.getTrackedInternalOrTrustedSpan(evt, metadata);
 			if (trackedSpan) return trackedSpan.spanContext();
-			const spanAttrs = toolExecutionBaseAttrs(evt);
+			const spanAttrs = {
+				...toolExecutionBaseAttrs(evt),
+				...runtime.paramsSummaryAttrs(evt.paramsSummary)
+			};
 			assignOtelToolIdentityAttributes(spanAttrs, evt);
 			return runtime.trackTrustedSpan(evt, metadata, runtime.spanWithDuration("openclaw.tool.execution", spanAttrs, void 0, {
 				parentContext: runtime.activeTrustedParentContext(evt, metadata),
@@ -1779,7 +1743,10 @@ function createToolAndSystemRecorders(runtime) {
 			if (evt.type === "tool.execution.error") attrs["openclaw.errorCategory"] = normalizeDiagnosticValue(evt.errorCategory, "other");
 			runtime.toolExecutionDurationHistogram.record(evt.durationMs, attrs);
 			if (!runtime.tracesEnabled) return;
-			const spanAttrs = { ...attrs };
+			const spanAttrs = {
+				...attrs,
+				...runtime.paramsSummaryAttrs(evt.paramsSummary)
+			};
 			runtime.addRunAttrs(spanAttrs, evt);
 			assignOtelToolIdentityAttributes(spanAttrs, evt);
 			if (evt.type === "tool.execution.error" && evt.errorCode) spanAttrs["openclaw.errorCode"] = normalizeDiagnosticValue(evt.errorCode, "other");
@@ -1803,6 +1770,7 @@ function createToolAndSystemRecorders(runtime) {
 			if (!runtime.tracesEnabled) return;
 			const spanAttrs = {
 				...toolExecutionBaseAttrs(evt),
+				...runtime.paramsSummaryAttrs(evt.paramsSummary),
 				"openclaw.outcome": "blocked",
 				"openclaw.deniedReason": normalizeDiagnosticValue(evt.deniedReason, "other")
 			};
@@ -2063,7 +2031,7 @@ function createUsageRecorders(runtime) {
 			runtime.messageDispatchCompletedCounter.add(1, attrs);
 			runtime.messageDispatchDurationHistogram.record(evt.durationMs, attrs);
 		},
-		recordMessageProcessed(evt, metadata) {
+		recordMessageProcessed(evt, metadata, privateData) {
 			const attrs = {
 				"openclaw.channel": normalizeDiagnosticValue(evt.channel),
 				"openclaw.outcome": evt.outcome ?? "unknown"
@@ -2074,6 +2042,10 @@ function createUsageRecorders(runtime) {
 			const spanAttrs = { ...attrs };
 			runtime.addRunAttrs(spanAttrs, evt);
 			if (evt.reason) spanAttrs["openclaw.reason"] = normalizeDiagnosticValue(evt.reason, "unknown");
+			const inputValue = runtime.captureContent ? normalizeOtelContentValue(privateData.messageContent?.userPrompt) : void 0;
+			if (inputValue) spanAttrs["input.value"] = inputValue;
+			const outputValue = runtime.captureContent ? normalizeOtelContentValue(privateData.messageContent?.finalResponse) : void 0;
+			if (outputValue) spanAttrs["output.value"] = outputValue;
 			const trackedSpan = runtime.getTrackedInternalOrTrustedSpan(evt, metadata);
 			const span = trackedSpan ?? runtime.spanWithDuration("openclaw.message.processed", spanAttrs, evt.durationMs, {
 				parentContext: runtime.internalOrTrustedExplicitParentContext(evt, metadata),
@@ -2121,10 +2093,7 @@ function createUsageRecorders(runtime) {
 			}));
 			const parentSpanId = runtime.trustedTraceContext(evt, metadata)?.parentSpanId;
 			if (parentSpanId && !runtime.activeTrustedSpans.has(parentSpanId)) {
-				const owner = {
-					kind: "run",
-					id: evt.runId
-				};
+				const owner = evt.runId;
 				runtime.activeTrustedSpanAliases.set(runtime.trustedSpanAliasKey(parentSpanId, owner), {
 					span,
 					spanId: parentSpanId,
@@ -2158,27 +2127,16 @@ function createDiagnosticsTraceRuntime(tracer) {
 	};
 	const trustedTraceContext = (evt, metadata) => metadata.trusted ? normalizeTraceContext(evt.trace) : void 0;
 	const internalOrTrustedTraceContext = (evt, metadata) => metadata.internal ? normalizeTraceContext(evt.trace) : normalizedTrustedTraceContext(evt, metadata);
-	const trustedSpanAliasOwner = (evt) => {
-		if ("runId" in evt && evt.runId) return {
-			kind: "run",
-			id: evt.runId
-		};
-	};
-	const sameTrustedSpanAliasOwner = (left, right) => Boolean(left && right && left.kind === right.kind && left.id === right.id);
-	const trustedSpanAliasKey = (spanId, owner) => `${spanId}:${owner.kind}:${owner.id}`;
+	const trustedSpanAliasOwner = (evt) => "runId" in evt ? evt.runId || void 0 : void 0;
+	const trustedSpanAliasKey = (spanId, owner) => `${spanId}:run:${owner}`;
 	const retainedTrustedSpanContextKey = (traceId, spanId, owner) => `${traceId}:${owner ? trustedSpanAliasKey(spanId, owner) : spanId}`;
 	const retainedTrustedSpanContext = (traceContext, spanId, owner) => {
 		if (!traceContext?.traceId || !spanId) return;
-		const retained = (owner ? retainedTrustedSpanContexts.get(retainedTrustedSpanContextKey(traceContext.traceId, spanId, owner)) : void 0) ?? retainedTrustedSpanContexts.get(retainedTrustedSpanContextKey(traceContext.traceId, spanId));
-		if (!retained) return;
-		if (retained.owner && !sameTrustedSpanAliasOwner(retained.owner, owner)) return;
-		return retained.spanContext;
+		return (owner ? retainedTrustedSpanContexts.get(retainedTrustedSpanContextKey(traceContext.traceId, spanId, owner)) : void 0) ?? retainedTrustedSpanContexts.get(retainedTrustedSpanContextKey(traceContext.traceId, spanId));
 	};
 	const activeTrustedSpanAlias = (spanId, owner) => {
 		if (!owner) return;
-		const alias = activeTrustedSpanAliases.get(trustedSpanAliasKey(spanId, owner));
-		if (!alias || !sameTrustedSpanAliasOwner(alias.owner, owner)) return;
-		return alias.span;
+		return activeTrustedSpanAliases.get(trustedSpanAliasKey(spanId, owner))?.span;
 	};
 	const internalOrTrustedParentContext = (evt, metadata) => {
 		const traceContext = internalOrTrustedTraceContext(evt, metadata);
@@ -2247,10 +2205,7 @@ function createDiagnosticsTraceRuntime(tracer) {
 		span.setAttributes?.(redactOtelAttributes(attributes));
 	};
 	const retainTrustedSpanContext = (traceId, spanId, spanContext, owner) => {
-		retainedTrustedSpanContexts.set(retainedTrustedSpanContextKey(traceId, spanId, owner), {
-			spanContext,
-			...owner ? { owner } : {}
-		});
+		retainedTrustedSpanContexts.set(retainedTrustedSpanContextKey(traceId, spanId, owner), spanContext);
 		pruneMapToMaxSize(retainedTrustedSpanContexts, MAX_RETAINED_TRUSTED_SPAN_CONTEXTS);
 	};
 	const completeTrackedLifecycleSpan = (traceContext, span, endTimeMs) => {
@@ -2320,11 +2275,6 @@ const RESOURCE_DETECTORS = [
 	["process", resources.processDetector],
 	["env", resources.envDetector]
 ];
-const OTEL_SIGNAL_PROTOCOL_ENV = {
-	traces: OTEL_EXPORTER_OTLP_TRACES_PROTOCOL_ENV,
-	metrics: OTEL_EXPORTER_OTLP_METRICS_PROTOCOL_ENV,
-	logs: OTEL_EXPORTER_OTLP_LOGS_PROTOCOL_ENV
-};
 function isOtelSdkDisabled(logger) {
 	const value = process.env.OTEL_SDK_DISABLED?.trim().toLowerCase();
 	if (!value || value === "false") return false;
@@ -2470,7 +2420,7 @@ function createDiagnosticsOtelService() {
 			];
 			const supportedOtlpSignals = /* @__PURE__ */ new Set();
 			for (const signal of ownedOtlpSignals) {
-				const protocol = otel.protocol ?? readNonBlankString(process.env[OTEL_SIGNAL_PROTOCOL_ENV[signal]]) ?? readNonBlankString(process.env["OTEL_EXPORTER_OTLP_PROTOCOL"]) ?? OTLP_HTTP_PROTOBUF_PROTOCOL;
+				const protocol = otel.protocol ?? readNonBlankString(process.env[`OTEL_EXPORTER_OTLP_${signal.toUpperCase()}_PROTOCOL`]) ?? readNonBlankString(process.env["OTEL_EXPORTER_OTLP_PROTOCOL"]) ?? OTLP_HTTP_PROTOBUF_PROTOCOL;
 				if (protocol === OTLP_HTTP_PROTOBUF_PROTOCOL) {
 					supportedOtlpSignals.add(signal);
 					continue;
@@ -2502,39 +2452,31 @@ function createDiagnosticsOtelService() {
 			});
 			const captureContent = otel.captureContent === true;
 			const resource = resources.resourceFromAttributes({ [ATTR_SERVICE_NAME]: serviceName });
-			const logUrl = logsToOtlp ? resolveSignalOtelUrl({
-				signalEndpoint: otel.logsEndpoint,
-				signalEnvEndpoint: process.env[OTEL_EXPORTER_OTLP_LOGS_ENDPOINT_ENV],
-				sharedEnvEndpoint,
-				endpoint,
-				path: "v1/logs"
-			}) : void 0;
-			const traceUrl = tracesToOtlp ? resolveSignalOtelUrl({
-				signalEndpoint: otel.tracesEndpoint,
-				signalEnvEndpoint: process.env[OTEL_EXPORTER_OTLP_TRACES_ENDPOINT_ENV],
-				sharedEnvEndpoint,
-				endpoint,
-				path: "v1/traces"
-			}) : void 0;
-			const metricUrl = metricsToOtlp ? resolveSignalOtelUrl({
-				signalEndpoint: otel.metricsEndpoint,
-				signalEnvEndpoint: process.env[OTEL_EXPORTER_OTLP_METRICS_ENDPOINT_ENV],
-				sharedEnvEndpoint,
-				endpoint,
-				path: "v1/metrics"
-			}) : void 0;
-			const logHttpAgentOptions = logsToOtlp ? resolveOtelHttpAgentOptions({
-				url: logUrl,
-				signalIdentifier: "LOGS"
-			}) : void 0;
-			const traceHttpAgentOptions = tracesToOtlp ? resolveOtelHttpAgentOptions({
-				url: traceUrl,
-				signalIdentifier: "TRACES"
-			}) : void 0;
-			const metricHttpAgentOptions = metricsToOtlp ? resolveOtelHttpAgentOptions({
-				url: metricUrl,
-				signalIdentifier: "METRICS"
-			}) : void 0;
+			const resolveSignal = (signal, enabled) => {
+				if (!enabled) return {};
+				const signalIdentifier = {
+					logs: "LOGS",
+					traces: "TRACES",
+					metrics: "METRICS"
+				}[signal];
+				const url = resolveSignalOtelUrl({
+					signalEndpoint: otel[`${signal}Endpoint`],
+					signalEnvEndpoint: process.env[`OTEL_EXPORTER_OTLP_${signalIdentifier}_ENDPOINT`],
+					sharedEnvEndpoint,
+					endpoint,
+					path: `v1/${signal}`
+				});
+				return {
+					url,
+					httpAgentOptions: resolveOtelHttpAgentOptions({
+						url,
+						signalIdentifier
+					})
+				};
+			};
+			const { url: logUrl, httpAgentOptions: logHttpAgentOptions } = resolveSignal("logs", logsToOtlp);
+			const { url: traceUrl, httpAgentOptions: traceHttpAgentOptions } = resolveSignal("traces", tracesToOtlp);
+			const { url: metricUrl, httpAgentOptions: metricHttpAgentOptions } = resolveSignal("metrics", metricsToOtlp);
 			if (tracesToOtlp || metricsToOtlp) try {
 				const detectedResource = resources.detectResources({ detectors: resolveResourceDetectors() }).merge(resource);
 				const sdkMetricsEnabled = otelCore.getBooleanFromEnv("OTEL_NODE_EXPERIMENTAL_SDK_METRICS");

package/dist/index.js

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

package/dist/runtime-api.js

@@ -1,2 +1 @@
-import { t as createDiagnosticsOtelService } from "./.setup/runtime-api-CKLGMqUx.mjs";
-export { createDiagnosticsOtelService };
+export { t as createDiagnosticsOtelService } from "./.setup/runtime-api-DNn_S1dw.mjs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/diagnostics-otel",
-  "version": "2026.10.5-beta.4",
+  "version": "2026.10.10-beta.1",
   "description": "OpenClaw diagnostics OpenTelemetry exporter for metrics, traces, and logs.",
   "repository": {
     "type": "git",
@@ -34,10 +34,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,
@@ -55,7 +55,7 @@
     "assets/activity.svg"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.10.5-beta.4"
+    "openclaw": ">=2026.10.10-beta.1"
   },
   "peerDependenciesMeta": {
     "openclaw": {