@openclaw/diagnostics-otel 2026.9.8 → 2026.10.1-beta.2

package/dist/.setup/{runtime-api-ButGOVne.mjs → runtime-api-C7192_s0.mjs}

@@ -15,14 +15,15 @@ import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { readFileSync } from "node:fs";
 import nodePath from "node:path";
 import { isInternalDiagnosticEventMetadata, isValidDiagnosticSpanId, isValidDiagnosticTraceFlags, isValidDiagnosticTraceId, normalizeDiagnosticLane, normalizeDiagnosticValue } from "openclaw/plugin-sdk/diagnostic-runtime";
-import { collectErrorGraphCandidates } from "openclaw/plugin-sdk/error-runtime";
+import { collectErrorGraphCandidates, readErrorName } from "openclaw/plugin-sdk/error-runtime";
 import { createNodeProxyAgent } from "openclaw/plugin-sdk/fetch-runtime";
 import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-proto";
 import { BatchLogRecordProcessor, LoggerProvider } from "@opentelemetry/sdk-logs";
 import { AsyncLocalStorageContextManager } from "@opentelemetry/context-async-hooks";
 import { B3InjectEncoding, B3Propagator } from "@opentelemetry/propagator-b3";
 import { JaegerPropagator } from "@opentelemetry/propagator-jaeger";
-import { ATTR_GEN_AI_INPUT_MESSAGES, ATTR_GEN_AI_OUTPUT_MESSAGES, ATTR_GEN_AI_SYSTEM_INSTRUCTIONS, ATTR_GEN_AI_TOOL_CALL_ARGUMENTS, ATTR_GEN_AI_TOOL_CALL_ID, ATTR_GEN_AI_TOOL_CALL_RESULT, ATTR_GEN_AI_TOOL_DEFINITIONS, GEN_AI_OPERATION_NAME_VALUE_EXECUTE_TOOL, GEN_AI_OPERATION_NAME_VALUE_INVOKE_AGENT } from "@opentelemetry/semantic-conventions/incubating";
+import { ATTR_GEN_AI_INPUT_MESSAGES, ATTR_GEN_AI_OUTPUT_MESSAGES, ATTR_GEN_AI_TOOL_CALL_ARGUMENTS, ATTR_GEN_AI_TOOL_CALL_ID, ATTR_GEN_AI_TOOL_CALL_RESULT, ATTR_GEN_AI_TOOL_DEFINITIONS, GEN_AI_OPERATION_NAME_VALUE_EXECUTE_TOOL, GEN_AI_OPERATION_NAME_VALUE_INVOKE_AGENT } from "@opentelemetry/semantic-conventions/incubating";
+import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
 const DROPPED_OTEL_ATTRIBUTE_KEYS = /* @__PURE__ */ new Set([
 	"openclaw.callId",
 	"openclaw.call_id",
@@ -65,8 +66,6 @@ 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";
-const OTEL_SEMCONV_STABILITY_OPT_IN_ENV = "OTEL_SEMCONV_STABILITY_OPT_IN";
-const GEN_AI_LATEST_EXPERIMENTAL_OPT_IN = "gen_ai_latest_experimental";
 const GEN_AI_TOKEN_USAGE_BUCKETS = [
 	1,
 	4,
@@ -149,44 +148,21 @@ const MAX_RETAINED_TRUSTED_SPAN_CONTEXTS = 1024;
 const MAX_OTEL_CONTENT_ATTRIBUTE_CHARS = 131072;
 const MAX_OTEL_ERROR_MESSAGE_CHARS = 4096;
 const PRELOADED_OTEL_SDK_ENV = "OPENCLAW_OTEL_PRELOADED";
-const NO_CONTENT_CAPTURE = {
-	inputMessages: false,
-	outputMessages: false,
-	toolInputs: false,
-	toolOutputs: false,
-	systemPrompt: false,
-	toolDefinitions: false,
-	logBodies: false
-};
-function clampOtelLogText(value, maxChars) {
-	return value.length > maxChars ? `${truncateUtf16Safe(value, maxChars)}...(truncated)` : value;
-}
 function normalizeOtelLogString(value, maxChars) {
-	return clampOtelLogText(redactSensitiveText(value), maxChars);
+	const redacted = redactSensitiveText(value);
+	return redacted.length > maxChars ? `${truncateUtf16Safe(redacted, maxChars)}...(truncated)` : redacted;
 }
 function normalizeOtelErrorMessage(value) {
 	if (!value) return;
 	return normalizeOtelLogString(value.trim(), MAX_OTEL_ERROR_MESSAGE_CHARS) || void 0;
 }
-function resolveContentCapturePolicy(value) {
-	return value === true ? {
-		inputMessages: true,
-		outputMessages: true,
-		toolInputs: true,
-		toolOutputs: true,
-		systemPrompt: false,
-		toolDefinitions: true,
-		logBodies: true
-	} : NO_CONTENT_CAPTURE;
-}
 function hasPreloadedOtelSdk() {
 	return process.env[PRELOADED_OTEL_SDK_ENV] === "1";
 }
 function normalizeOtelContentValue(value) {
 	if (typeof value === "string") return normalizeOtelLogString(value, MAX_OTEL_CONTENT_ATTRIBUTE_CHARS);
 	if (Array.isArray(value)) {
-		const items = [];
-		for (const item of value.slice(0, 200)) if (typeof item === "string") items.push(item);
+		const items = value.slice(0, 200).filter((item) => typeof item === "string");
 		if (items.length > 0) return normalizeOtelLogString(items.join("\n"), MAX_OTEL_CONTENT_ATTRIBUTE_CHARS);
 	}
 	const json = safeJsonString(value, MAX_OTEL_CONTENT_ATTRIBUTE_CHARS);
@@ -410,11 +386,6 @@ function errorCategory(err) {
 		return "unknown";
 	}
 }
-function readErrorName(err) {
-	if (!err || typeof err !== "object") return;
-	const name = err.name;
-	return typeof name === "string" && name.trim() ? name : void 0;
-}
 function readErrorCode(err) {
 	if (!err || typeof err !== "object") return;
 	const code = err.code;
@@ -432,7 +403,7 @@ function findOtlpExporterError(reason) {
 //#endregion
 //#region extensions/diagnostics-otel/src/service-events.ts
 function createDiagnosticsEventHandler(params) {
-	const { logger, recorders, recordLogRecord, recordSecurityEvent } = params;
+	const { logger, recorders, recordLogEvent } = params;
 	return (evt, metadata, privateData) => {
 		try {
 			switch (evt.type) {
@@ -450,8 +421,8 @@ function createDiagnosticsEventHandler(params) {
 				case "message.dispatch.completed": return recorders.recordMessageDispatchCompleted(evt);
 				case "message.processed": return recorders.recordMessageProcessed(evt, metadata);
 				case "message.delivery.started": return recorders.recordMessageDeliveryStarted(evt);
-				case "message.delivery.completed": return recorders.recordMessageDeliveryCompleted(evt, metadata);
-				case "message.delivery.error": return recorders.recordMessageDeliveryError(evt, metadata);
+				case "message.delivery.completed":
+				case "message.delivery.error": return recorders.recordMessageDeliveryFinished(evt, metadata);
 				case "talk.event": return recorders.recordTalkEvent(evt, metadata);
 				case "queue.lane.enqueue": return recorders.recordLaneEnqueue(evt);
 				case "queue.lane.dequeue": return recorders.recordLaneDequeue(evt);
@@ -489,8 +460,8 @@ function createDiagnosticsEventHandler(params) {
 				case "skill.used": return recorders.recordSkillUsed(evt, metadata);
 				case "exec.process.completed": return recorders.recordExecProcessCompleted(evt, metadata);
 				case "exec.approval.followup_suppressed": break;
-				case "log.record": return recordLogRecord?.(evt, metadata);
-				case "security.event": return recordSecurityEvent?.(evt, metadata);
+				case "log.record":
+				case "security.event": return recordLogEvent?.(evt, metadata);
 				case "tool.loop": return recorders.recordToolLoop(evt);
 				case "diagnostic.memory.sample": return recorders.recordMemoryUsageMetrics(evt);
 				case "diagnostic.memory.pressure": return recorders.recordMemoryPressure(evt);
@@ -707,9 +678,6 @@ function assignOtelEventAttributes(attributes, eventAttributes, keyPrefix, norma
 function assignOtelLogEventAttributes(attributes, eventAttributes) {
 	assignOtelEventAttributes(attributes, eventAttributes, "openclaw.");
 }
-function assignOtelSecurityEventAttributes(attributes, eventAttributes) {
-	assignOtelEventAttributes(attributes, eventAttributes, "openclaw.security.attribute.", normalizeDiagnosticValue);
-}
 function securitySeverityText(severity) {
 	switch (severity) {
 		case "critical": return "FATAL";
@@ -721,36 +689,39 @@ function securitySeverityText(severity) {
 	return severity;
 }
 function assignOtelSecurityAttributes(attributes, evt) {
+	const assignOptionalNormalized = (key, value) => {
+		if (value) assignOtelLogAttribute(attributes, key, normalizeDiagnosticValue(value));
+	};
 	assignOtelLogAttribute(attributes, "openclaw.security.event_id", evt.eventId);
 	assignOtelLogAttribute(attributes, "openclaw.security.category", evt.category);
 	assignOtelLogAttribute(attributes, "openclaw.security.action", normalizeDiagnosticValue(evt.action));
 	assignOtelLogAttribute(attributes, "openclaw.security.outcome", evt.outcome);
 	assignOtelLogAttribute(attributes, "openclaw.security.severity", evt.severity);
-	if (evt.reason) assignOtelLogAttribute(attributes, "openclaw.security.reason", normalizeDiagnosticValue(evt.reason));
+	assignOptionalNormalized("openclaw.security.reason", evt.reason);
 	if (evt.actor) {
 		assignOtelLogAttribute(attributes, "openclaw.security.actor.kind", evt.actor.kind);
-		if (evt.actor.idHash) assignOtelLogAttribute(attributes, "openclaw.security.actor.id_hash", normalizeDiagnosticValue(evt.actor.idHash));
-		if (evt.actor.deviceIdHash) assignOtelLogAttribute(attributes, "openclaw.security.actor.device_id_hash", normalizeDiagnosticValue(evt.actor.deviceIdHash));
-		if (evt.actor.channel) assignOtelLogAttribute(attributes, "openclaw.security.actor.channel", normalizeDiagnosticValue(evt.actor.channel));
-		if (evt.actor.role) assignOtelLogAttribute(attributes, "openclaw.security.actor.role", normalizeDiagnosticValue(evt.actor.role));
+		assignOptionalNormalized("openclaw.security.actor.id_hash", evt.actor.idHash);
+		assignOptionalNormalized("openclaw.security.actor.device_id_hash", evt.actor.deviceIdHash);
+		assignOptionalNormalized("openclaw.security.actor.channel", evt.actor.channel);
+		assignOptionalNormalized("openclaw.security.actor.role", evt.actor.role);
 		if (evt.actor.scopes?.length) assignOtelLogAttribute(attributes, "openclaw.security.actor.scopes", evt.actor.scopes.map((scope) => normalizeDiagnosticValue(scope)).join(","));
 	}
 	if (evt.target) {
 		assignOtelLogAttribute(attributes, "openclaw.security.target.kind", evt.target.kind);
-		if (evt.target.idHash) assignOtelLogAttribute(attributes, "openclaw.security.target.id_hash", normalizeDiagnosticValue(evt.target.idHash));
+		assignOptionalNormalized("openclaw.security.target.id_hash", evt.target.idHash);
 		if (evt.target.name) assignOtelLogAttribute(attributes, "openclaw.security.target.name", securityTargetNameAttr(evt.target.name));
-		if (evt.target.owner) assignOtelLogAttribute(attributes, "openclaw.security.target.owner", normalizeDiagnosticValue(evt.target.owner));
+		assignOptionalNormalized("openclaw.security.target.owner", evt.target.owner);
 	}
 	if (evt.policy) {
-		if (evt.policy.id) assignOtelLogAttribute(attributes, "openclaw.security.policy.id", normalizeDiagnosticValue(evt.policy.id));
+		assignOptionalNormalized("openclaw.security.policy.id", evt.policy.id);
 		if (evt.policy.decision) assignOtelLogAttribute(attributes, "openclaw.security.policy.decision", evt.policy.decision);
-		if (evt.policy.reason) assignOtelLogAttribute(attributes, "openclaw.security.policy.reason", normalizeDiagnosticValue(evt.policy.reason));
+		assignOptionalNormalized("openclaw.security.policy.reason", evt.policy.reason);
 	}
 	if (evt.control) {
-		if (evt.control.id) assignOtelLogAttribute(attributes, "openclaw.security.control.id", normalizeDiagnosticValue(evt.control.id));
+		assignOptionalNormalized("openclaw.security.control.id", evt.control.id);
 		if (evt.control.family) assignOtelLogAttribute(attributes, "openclaw.security.control.family", evt.control.family);
 	}
-	assignOtelSecurityEventAttributes(attributes, evt.attributes);
+	assignOtelEventAttributes(attributes, evt.attributes, "openclaw.security.attribute.", normalizeDiagnosticValue);
 }
 //#endregion
 //#region extensions/diagnostics-otel/src/service-trace-context.ts
@@ -772,29 +743,17 @@ function traceFlagsToOtel(traceFlags) {
 	return (Number.parseInt(traceFlags ?? "00", 16) & TraceFlags.SAMPLED) !== 0 ? TraceFlags.SAMPLED : TraceFlags.NONE;
 }
 function contextForTraceContext(traceContext) {
-	const normalized = normalizeTraceContext(traceContext);
-	if (!normalized?.spanId) return;
+	if (!traceContext?.spanId) return;
 	return trace.setSpanContext(context.active(), {
-		traceId: normalized.traceId,
-		spanId: normalized.spanId,
-		traceFlags: traceFlagsToOtel(normalized.traceFlags),
+		traceId: traceContext.traceId,
+		spanId: traceContext.spanId,
+		traceFlags: traceFlagsToOtel(traceContext.traceFlags),
 		isRemote: true
 	});
 }
-function contextForTrustedTraceContext(evt, metadata) {
-	return metadata.trusted || metadata.trustedTraceContext === true ? contextForTraceContext(evt.trace) : void 0;
-}
 function normalizedTrustedTraceContext(evt, metadata) {
 	return metadata.trusted || metadata.trustedTraceContext === true ? normalizeTraceContext(evt.trace) : void 0;
 }
-function addTraceAttributes(attributes, traceContext) {
-	const normalized = normalizeTraceContext(traceContext);
-	if (!normalized) return;
-	attributes["openclaw.traceId"] = normalized.traceId;
-	if (normalized.spanId) attributes["openclaw.spanId"] = normalized.spanId;
-	if (normalized.parentSpanId) attributes["openclaw.parentSpanId"] = normalized.parentSpanId;
-	if (normalized.traceFlags) attributes["openclaw.traceFlags"] = normalized.traceFlags;
-}
 //#endregion
 //#region extensions/diagnostics-otel/src/service-logs.ts
 const LOG_SEVERITY_MAP = {
@@ -806,202 +765,131 @@ const LOG_SEVERITY_MAP = {
 	FATAL: 21
 };
 function createDiagnosticsLogExporter(params) {
-	const { contentCapturePolicy, emitExporterEvent, flushIntervalMs, headers, logger, logsEnabled, logsToOtlp, logsToStdout, logHttpAgentOptions, logUrl, resource, serviceName } = params;
+	const { captureContent, emitExporterEvent, flushIntervalMs, headers, logger, logsToOtlp, logsToStdout, logHttpAgentOptions, logUrl, resource, serviceName } = params;
 	let logProvider = null;
-	let recordLogRecord;
-	let recordSecurityEvent;
-	if (logsEnabled) {
-		let logRecordExportFailureLastReportedAt = Number.NEGATIVE_INFINITY;
-		let otelLogger;
-		const activeTransports = [...logsToOtlp ? ["otlp-http-protobuf"] : [], ...logsToStdout ? ["stdout"] : []];
-		if (logsToOtlp) {
-			const logExporter = observeOtlpExporterHealth(new OTLPLogExporter({
-				...logUrl ? { url: logUrl } : {},
-				...headers ? { headers } : {},
-				...logHttpAgentOptions ? { httpAgentOptions: logHttpAgentOptions } : {}
-			}), {
-				emitExporterEvent,
-				signal: "logs"
-			});
-			const logProcessor = new BatchLogRecordProcessor({
-				exporter: logExporter,
-				...typeof flushIntervalMs === "number" ? { scheduledDelayMillis: Math.max(1e3, flushIntervalMs) } : {}
-			});
-			logProvider = new LoggerProvider({
-				resource,
-				processors: [logProcessor]
-			});
-			otelLogger = logProvider.getLogger("openclaw");
+	if (!logsToOtlp && !logsToStdout) return {
+		logProvider,
+		recordLogEvent: void 0
+	};
+	let logRecordExportFailureLastReportedAt = Number.NEGATIVE_INFINITY;
+	let otelLogger;
+	const activeTransports = [...logsToOtlp ? ["otlp-http-protobuf"] : [], ...logsToStdout ? ["stdout"] : []];
+	if (logsToOtlp) {
+		const logExporter = observeOtlpExporterHealth(new OTLPLogExporter({
+			...logUrl ? { url: logUrl } : {},
+			...headers ? { headers } : {},
+			...logHttpAgentOptions ? { httpAgentOptions: logHttpAgentOptions } : {}
+		}), {
+			emitExporterEvent,
+			signal: "logs"
+		});
+		const logProcessor = new BatchLogRecordProcessor({
+			exporter: logExporter,
+			...typeof flushIntervalMs === "number" ? { scheduledDelayMillis: Math.max(1e3, flushIntervalMs) } : {}
+		});
+		logProvider = new LoggerProvider({
+			resource,
+			processors: [logProcessor]
+		});
+		otelLogger = logProvider.getLogger("openclaw");
+	}
+	const reportLogExportFailure = (err, label, transport) => {
+		emitExporterEvent({
+			exporter: "diagnostics-otel",
+			signal: "logs",
+			transport,
+			status: "failure",
+			reason: "emit_failed",
+			errorCategory: errorCategory(err)
+		});
+		const now = Date.now();
+		if (now - logRecordExportFailureLastReportedAt >= 6e4) {
+			logRecordExportFailureLastReportedAt = now;
+			logger.error(`diagnostics-otel: ${label} export failed: ${formatError(err)}`);
 		}
-		const reportLogExportFailure = (err, label, transport) => {
-			emitExporterEvent({
-				exporter: "diagnostics-otel",
-				signal: "logs",
-				transport,
-				status: "failure",
-				reason: "emit_failed",
-				errorCategory: errorCategory(err)
-			});
-			const now = Date.now();
-			if (now - logRecordExportFailureLastReportedAt >= 6e4) {
-				logRecordExportFailureLastReportedAt = now;
-				logger.error(`diagnostics-otel: ${label} export failed: ${formatError(err)}`);
-			}
-		};
-		const reportLogExportRecovery = (transport) => {
-			emitExporterEvent({
-				exporter: "diagnostics-otel",
-				signal: "logs",
-				transport,
-				status: "recovered",
-				reason: "emit_failed"
-			});
-		};
-		const reportLogPreparationFailure = (err, label) => {
-			for (const transport of activeTransports) reportLogExportFailure(err, label, transport);
-		};
-		const emitLogRecord = ({ logRecord, traceContext }, label) => {
-			if (logsToOtlp) try {
-				otelLogger?.emit(logRecord);
-				reportLogExportRecovery("otlp-http-protobuf");
-			} catch (error) {
-				reportLogExportFailure(error, label, "otlp-http-protobuf");
-			}
-			if (logsToStdout) try {
-				writeStdoutDiagnosticLogRecord({
-					logRecord,
-					serviceName,
-					...traceContext ? { traceContext } : {}
-				});
-				reportLogExportRecovery("stdout");
-			} catch (error) {
-				reportLogExportFailure(error, label, "stdout");
-			}
-		};
-		const buildDiagnosticLogRecord = (evt, metadata) => {
-			const logLevelName = evt.level || "INFO";
-			const severityNumber = LOG_SEVERITY_MAP[logLevelName] ?? 9;
-			const body = contentCapturePolicy.logBodies ? normalizeOtelLogString(evt.message || "log", MAX_OTEL_LOG_BODY_CHARS) : "log";
+	};
+	const recordLogEvent = (evt, metadata) => {
+		if (evt.type === "security.event" && !metadata.trusted) return;
+		const label = evt.type === "log.record" ? "log record" : "security event";
+		try {
 			const attributes = Object.create(null);
-			assignOtelLogAttribute(attributes, "openclaw.log.level", logLevelName);
-			if (evt.loggerName) assignOtelLogAttribute(attributes, "openclaw.logger", evt.loggerName);
-			if (evt.loggerParents?.length) assignOtelLogAttribute(attributes, "openclaw.logger.parents", evt.loggerParents.join("."));
-			assignOtelLogEventAttributes(attributes, evt.attributes);
-			if (evt.code?.line) assignOtelLogAttribute(attributes, "code.lineno", evt.code.line);
-			if (evt.code?.functionName) assignOtelLogAttribute(attributes, "code.function", evt.code.functionName);
+			let severityText;
+			let body;
+			if (evt.type === "log.record") {
+				severityText = evt.level || "INFO";
+				body = captureContent ? normalizeOtelLogString(evt.message || "log", MAX_OTEL_LOG_BODY_CHARS) : "log";
+				assignOtelLogAttribute(attributes, "openclaw.log.level", severityText);
+				if (evt.loggerName) assignOtelLogAttribute(attributes, "openclaw.logger", evt.loggerName);
+				if (evt.loggerParents?.length) assignOtelLogAttribute(attributes, "openclaw.logger.parents", evt.loggerParents.join("."));
+				assignOtelLogEventAttributes(attributes, evt.attributes);
+				if (evt.code?.line) assignOtelLogAttribute(attributes, "code.lineno", evt.code.line);
+				if (evt.code?.functionName) assignOtelLogAttribute(attributes, "code.function", evt.code.functionName);
+			} else {
+				severityText = securitySeverityText(evt.severity);
+				body = "openclaw.security.event";
+				assignOtelSecurityAttributes(attributes, evt);
+			}
 			const traceContext = normalizedTrustedTraceContext(evt, metadata);
-			addTraceAttributes(attributes, traceContext);
+			if (evt.type === "log.record" && traceContext?.traceFlags) attributes["openclaw.traceFlags"] = traceContext.traceFlags;
 			const logRecord = {
 				body,
-				severityText: logLevelName,
-				severityNumber,
-				attributes: redactOtelAttributes(attributes),
-				timestamp: evt.ts
-			};
-			const logContext = contextForTrustedTraceContext(evt, metadata);
-			if (logContext) logRecord.context = logContext;
-			return {
-				logRecord,
-				...traceContext ? { traceContext } : {}
-			};
-		};
-		const buildSecurityLogRecord = (evt, metadata) => {
-			const severityText = securitySeverityText(evt.severity);
-			const attributes = Object.create(null);
-			assignOtelSecurityAttributes(attributes, evt);
-			const traceContext = normalizedTrustedTraceContext(evt, metadata);
-			const logRecord = {
-				body: "openclaw.security.event",
 				severityText,
 				severityNumber: LOG_SEVERITY_MAP[severityText] ?? 9,
 				attributes: redactOtelAttributes(attributes),
 				timestamp: evt.ts
 			};
-			const logContext = contextForTrustedTraceContext(evt, metadata);
+			const logContext = contextForTraceContext(traceContext);
 			if (logContext) logRecord.context = logContext;
-			return {
-				logRecord,
-				...traceContext ? { traceContext } : {}
-			};
-		};
-		recordLogRecord = (evt, metadata) => {
-			try {
-				const record = buildDiagnosticLogRecord(evt, metadata);
-				emitLogRecord(record, "log record");
-			} catch (err) {
-				reportLogPreparationFailure(err, "log record");
-			}
-		};
-		recordSecurityEvent = (evt, metadata) => {
-			if (!metadata.trusted) return;
-			try {
-				const record = buildSecurityLogRecord(evt, metadata);
-				emitLogRecord(record, "security event");
-			} catch (err) {
-				reportLogPreparationFailure(err, "security event");
+			for (const transport of activeTransports) try {
+				if (transport === "otlp-http-protobuf") otelLogger?.emit(logRecord);
+				else writeStdoutDiagnosticLogRecord({
+					logRecord,
+					serviceName,
+					...traceContext ? { traceContext } : {}
+				});
+				emitExporterEvent({
+					exporter: "diagnostics-otel",
+					signal: "logs",
+					transport,
+					status: "recovered",
+					reason: "emit_failed"
+				});
+			} catch (error) {
+				reportLogExportFailure(error, label, transport);
 			}
-		};
-	}
+		} catch (err) {
+			for (const transport of activeTransports) reportLogExportFailure(err, label, transport);
+		}
+	};
 	return {
 		logProvider,
-		recordLogRecord,
-		recordSecurityEvent
+		recordLogEvent
 	};
 }
 //#endregion
 //#region extensions/diagnostics-otel/src/service-metrics.ts
 const DEFAULT_METRIC_NAME_PREFIX = "openclaw.";
 function createDiagnosticsMetrics(meter, metricNamePrefix = DEFAULT_METRIC_NAME_PREFIX) {
-	const resolveMetricName = (name) => `${metricNamePrefix}${name.slice(9)}`;
-	const createCounter = (name, options) => meter.createCounter(resolveMetricName(name), options);
-	const createHistogram = (name, options) => meter.createHistogram(resolveMetricName(name), options);
+	const createCounter = (name, description, unit = "1") => meter.createCounter(`${metricNamePrefix}${name}`, {
+		unit,
+		description
+	});
+	const createHistogram = (name, description, unit = "ms", explicitBucketBoundaries) => meter.createHistogram(`${metricNamePrefix}${name}`, {
+		unit,
+		description,
+		...explicitBucketBoundaries ? { advice: { explicitBucketBoundaries } } : {}
+	});
 	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 start queue or worker frame queue wait",
-			advice: { explicitBucketBoundaries: AGENT_DURATION_MS_BUCKETS }
-		}),
-		tokensCounter: createCounter("openclaw.tokens", {
-			unit: "1",
-			description: "Token usage by type"
-		}),
+		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),
+		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),
+		tokensCounter: createCounter("tokens", "Token usage by type"),
 		genAiTokenUsageHistogram: meter.createHistogram("gen_ai.client.token.usage", {
 			unit: "{token}",
 			description: "Number of input and output tokens used by GenAI client operations",
@@ -1012,233 +900,62 @@ function createDiagnosticsMetrics(meter, metricNamePrefix = DEFAULT_METRIC_NAME_
 			description: "GenAI client operation duration",
 			advice: { explicitBucketBoundaries: GEN_AI_OPERATION_DURATION_BUCKETS }
 		}),
-		costCounter: createCounter("openclaw.cost.usd", {
-			unit: "1",
-			description: "Estimated model cost (USD)"
-		}),
-		durationHistogram: createHistogram("openclaw.run.duration_ms", {
-			unit: "ms",
-			description: "Agent run duration",
-			advice: { explicitBucketBoundaries: AGENT_DURATION_MS_BUCKETS }
-		}),
-		harnessDurationHistogram: createHistogram("openclaw.harness.duration_ms", {
-			unit: "ms",
-			description: "Agent harness lifecycle duration",
-			advice: { explicitBucketBoundaries: AGENT_DURATION_MS_BUCKETS }
-		}),
-		contextHistogram: createHistogram("openclaw.context.tokens", {
-			unit: "1",
-			description: "Context window size and usage",
-			advice: { explicitBucketBoundaries: CONTEXT_TOKENS_BUCKETS }
-		}),
-		webhookReceivedCounter: createCounter("openclaw.webhook.received", {
-			unit: "1",
-			description: "Webhook requests received"
-		}),
-		webhookErrorCounter: createCounter("openclaw.webhook.error", {
-			unit: "1",
-			description: "Webhook processing errors"
-		}),
-		webhookDurationHistogram: createHistogram("openclaw.webhook.duration_ms", {
-			unit: "ms",
-			description: "Webhook processing duration"
-		}),
-		messageQueuedCounter: createCounter("openclaw.message.queued", {
-			unit: "1",
-			description: "Messages queued for processing"
-		}),
-		messageReceivedCounter: createCounter("openclaw.message.received", {
-			unit: "1",
-			description: "Inbound messages received"
-		}),
-		messageDispatchStartedCounter: createCounter("openclaw.message.dispatch.started", {
-			unit: "1",
-			description: "Inbound message dispatch attempts started"
-		}),
-		messageDispatchCompletedCounter: createCounter("openclaw.message.dispatch.completed", {
-			unit: "1",
-			description: "Inbound message dispatch attempts completed"
-		}),
-		messageDispatchDurationHistogram: createHistogram("openclaw.message.dispatch.duration_ms", {
-			unit: "ms",
-			description: "Inbound message dispatch duration"
-		}),
-		messageProcessedCounter: createCounter("openclaw.message.processed", {
-			unit: "1",
-			description: "Messages processed by outcome"
-		}),
-		messageDurationHistogram: createHistogram("openclaw.message.duration_ms", {
-			unit: "ms",
-			description: "Message processing duration"
-		}),
-		messageDeliveryStartedCounter: createCounter("openclaw.message.delivery.started", {
-			unit: "1",
-			description: "Outbound message delivery attempts started"
-		}),
-		messageDeliveryDurationHistogram: createHistogram("openclaw.message.delivery.duration_ms", {
-			unit: "ms",
-			description: "Outbound message delivery duration"
-		}),
-		queueDepthHistogram: createHistogram("openclaw.queue.depth", {
-			unit: "1",
-			description: "Queue depth on enqueue/dequeue"
-		}),
-		queueWaitHistogram: createHistogram("openclaw.queue.wait_ms", {
-			unit: "ms",
-			description: "Queue wait time before execution"
-		}),
-		laneEnqueueCounter: createCounter("openclaw.queue.lane.enqueue", {
-			unit: "1",
-			description: "Command queue lane enqueue events"
-		}),
-		laneDequeueCounter: createCounter("openclaw.queue.lane.dequeue", {
-			unit: "1",
-			description: "Command queue lane dequeue events"
-		}),
-		sessionStateCounter: createCounter("openclaw.session.state", {
-			unit: "1",
-			description: "Session state transitions"
-		}),
-		sessionTurnCreatedCounter: createCounter("openclaw.session.turn.created", {
-			unit: "1",
-			description: "Agent session turns created"
-		}),
-		sessionStuckCounter: createCounter("openclaw.session.stuck", {
-			unit: "1",
-			description: "Sessions stuck in processing"
-		}),
-		sessionStuckAgeHistogram: createHistogram("openclaw.session.stuck_age_ms", {
-			unit: "ms",
-			description: "Age of stuck sessions"
-		}),
-		sessionRecoveryRequestedCounter: createCounter("openclaw.session.recovery.requested", {
-			unit: "1",
-			description: "Session recovery attempts requested"
-		}),
-		sessionRecoveryCompletedCounter: createCounter("openclaw.session.recovery.completed", {
-			unit: "1",
-			description: "Session recovery attempts completed"
-		}),
-		sessionRecoveryAgeHistogram: createHistogram("openclaw.session.recovery.age_ms", {
-			unit: "ms",
-			description: "Age of sessions selected for recovery"
-		}),
-		talkEventCounter: createCounter("openclaw.talk.event", {
-			unit: "1",
-			description: "Talk events emitted by type"
-		}),
-		talkEventDurationHistogram: createHistogram("openclaw.talk.event.duration_ms", {
-			unit: "ms",
-			description: "Talk event duration when reported"
-		}),
-		talkAudioBytesHistogram: createHistogram("openclaw.talk.audio.bytes", {
-			unit: "By",
-			description: "Talk audio frame byte lengths"
-		}),
-		runAttemptCounter: createCounter("openclaw.run.attempt", {
-			unit: "1",
-			description: "Run attempts"
-		}),
-		toolLoopCounter: createCounter("openclaw.tool.loop", {
-			unit: "1",
-			description: "Detected repetitive tool-call loop events"
-		}),
-		skillUsedCounter: createCounter("openclaw.skill.used", {
-			unit: "1",
-			description: "Skills used by agent runs"
-		}),
-		modelCallDurationHistogram: createHistogram("openclaw.model_call.duration_ms", {
-			unit: "ms",
-			description: "Model call duration"
-		}),
-		modelCallRequestBytesHistogram: createHistogram("openclaw.model_call.request_bytes", {
-			unit: "By",
-			description: "UTF-8 byte size of sanitized model request payloads"
-		}),
-		modelCallResponseBytesHistogram: createHistogram("openclaw.model_call.response_bytes", {
-			unit: "By",
-			description: "UTF-8 byte size of bounded streamed model response payloads"
-		}),
-		modelCallTimeToFirstByteHistogram: createHistogram("openclaw.model_call.time_to_first_byte_ms", {
-			unit: "ms",
-			description: "Elapsed time before the first streamed model response event"
-		}),
-		modelFailoverCounter: createCounter("openclaw.model.failover", {
-			unit: "1",
-			description: "Model failovers by source, destination, lane, and reason"
-		}),
-		toolExecutionDurationHistogram: createHistogram("openclaw.tool.execution.duration_ms", {
-			unit: "ms",
-			description: "Tool execution duration"
-		}),
-		toolExecutionBlockedCounter: createCounter("openclaw.tool.execution.blocked", {
-			unit: "1",
-			description: "Tool executions blocked by policy or sandbox diagnostics"
-		}),
-		execProcessDurationHistogram: createHistogram("openclaw.exec.duration_ms", {
-			unit: "ms",
-			description: "Exec process duration"
-		}),
-		memoryRssHistogram: createHistogram("openclaw.memory.rss_bytes", {
-			unit: "By",
-			description: "Resident set size reported by diagnostic memory samples"
-		}),
-		memoryHeapUsedHistogram: createHistogram("openclaw.memory.heap_used_bytes", {
-			unit: "By",
-			description: "Heap used bytes reported by diagnostic memory samples"
-		}),
-		memoryHeapTotalHistogram: createHistogram("openclaw.memory.heap_total_bytes", {
-			unit: "By",
-			description: "Heap total bytes reported by diagnostic memory samples"
-		}),
-		memoryExternalHistogram: createHistogram("openclaw.memory.external_bytes", {
-			unit: "By",
-			description: "External memory bytes reported by diagnostic memory samples"
-		}),
-		memoryArrayBuffersHistogram: createHistogram("openclaw.memory.array_buffers_bytes", {
-			unit: "By",
-			description: "ArrayBuffer bytes reported by diagnostic memory samples"
-		}),
-		memoryPressureCounter: createCounter("openclaw.memory.pressure", {
-			unit: "1",
-			description: "Diagnostic memory pressure events"
-		}),
-		asyncQueueDroppedCounter: createCounter("openclaw.diagnostic.async_queue.dropped", {
-			unit: "1",
-			description: "Async diagnostic queue drops by dropped event class"
-		}),
-		payloadLargeCounter: createCounter("openclaw.payload.large", {
-			unit: "1",
-			description: "Oversized payload diagnostics by surface and action"
-		}),
-		payloadLargeBytesHistogram: createHistogram("openclaw.payload.large_bytes", {
-			unit: "By",
-			description: "Oversized payload byte sizes by surface and action"
-		}),
-		livenessWarningCounter: createCounter("openclaw.liveness.warning", {
-			unit: "1",
-			description: "Diagnostic liveness warning events"
-		}),
-		livenessEventLoopDelayP99Histogram: createHistogram("openclaw.liveness.event_loop_delay_p99_ms", {
-			unit: "ms",
-			description: "P99 event-loop delay reported by diagnostic liveness warnings"
-		}),
-		livenessEventLoopDelayMaxHistogram: createHistogram("openclaw.liveness.event_loop_delay_max_ms", {
-			unit: "ms",
-			description: "Maximum event-loop delay reported by diagnostic liveness warnings"
-		}),
-		livenessEventLoopUtilizationHistogram: createHistogram("openclaw.liveness.event_loop_utilization", {
-			unit: "1",
-			description: "Event-loop utilization reported by diagnostic liveness warnings"
-		}),
-		livenessCpuCoreRatioHistogram: createHistogram("openclaw.liveness.cpu_core_ratio", {
-			unit: "1",
-			description: "Whole-process CPU usage in core equivalents, including worker and native threads; can exceed 1."
-		}),
-		telemetryExporterCounter: createCounter("openclaw.telemetry.exporter.events", {
-			unit: "1",
-			description: "Diagnostic telemetry exporter lifecycle and failure events"
-		})
+		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),
+		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"),
+		webhookDurationHistogram: createHistogram("webhook.duration_ms", "Webhook processing duration"),
+		messageQueuedCounter: createCounter("message.queued", "Messages queued for processing"),
+		messageReceivedCounter: createCounter("message.received", "Inbound messages received"),
+		messageDispatchStartedCounter: createCounter("message.dispatch.started", "Inbound message dispatch attempts started"),
+		messageDispatchCompletedCounter: createCounter("message.dispatch.completed", "Inbound message dispatch attempts completed"),
+		messageDispatchDurationHistogram: createHistogram("message.dispatch.duration_ms", "Inbound message dispatch duration"),
+		messageProcessedCounter: createCounter("message.processed", "Messages processed by outcome"),
+		messageDurationHistogram: createHistogram("message.duration_ms", "Message processing duration"),
+		messageDeliveryStartedCounter: createCounter("message.delivery.started", "Outbound message delivery attempts started"),
+		messageDeliveryDurationHistogram: createHistogram("message.delivery.duration_ms", "Outbound message delivery duration"),
+		queueDepthHistogram: createHistogram("queue.depth", "Queue depth on enqueue/dequeue", "1"),
+		queueWaitHistogram: createHistogram("queue.wait_ms", "Queue wait time before execution"),
+		laneEnqueueCounter: createCounter("queue.lane.enqueue", "Command queue lane enqueue events"),
+		laneDequeueCounter: createCounter("queue.lane.dequeue", "Command queue lane dequeue events"),
+		sessionStateCounter: createCounter("session.state", "Session state transitions"),
+		sessionTurnCreatedCounter: createCounter("session.turn.created", "Agent session turns created"),
+		sessionStuckCounter: createCounter("session.stuck", "Sessions stuck in processing"),
+		sessionStuckAgeHistogram: createHistogram("session.stuck_age_ms", "Age of stuck sessions"),
+		sessionRecoveryRequestedCounter: createCounter("session.recovery.requested", "Session recovery attempts requested"),
+		sessionRecoveryCompletedCounter: createCounter("session.recovery.completed", "Session recovery attempts completed"),
+		sessionRecoveryAgeHistogram: createHistogram("session.recovery.age_ms", "Age of sessions selected for recovery"),
+		talkEventCounter: createCounter("talk.event", "Talk events emitted by type"),
+		talkEventDurationHistogram: createHistogram("talk.event.duration_ms", "Talk event duration when reported"),
+		talkAudioBytesHistogram: createHistogram("talk.audio.bytes", "Talk audio frame byte lengths", "By"),
+		runAttemptCounter: createCounter("run.attempt", "Run attempts"),
+		toolLoopCounter: createCounter("tool.loop", "Detected repetitive tool-call loop events"),
+		skillUsedCounter: createCounter("skill.used", "Skills used by agent runs"),
+		modelCallDurationHistogram: createHistogram("model_call.duration_ms", "Model call duration"),
+		modelCallRequestBytesHistogram: createHistogram("model_call.request_bytes", "UTF-8 byte size of sanitized model request payloads", "By"),
+		modelCallResponseBytesHistogram: createHistogram("model_call.response_bytes", "UTF-8 byte size of bounded streamed model response payloads", "By"),
+		modelCallTimeToFirstByteHistogram: createHistogram("model_call.time_to_first_byte_ms", "Elapsed time before the first streamed model response event"),
+		modelFailoverCounter: createCounter("model.failover", "Model failovers by source, destination, lane, and reason"),
+		toolExecutionDurationHistogram: createHistogram("tool.execution.duration_ms", "Tool execution duration"),
+		toolExecutionBlockedCounter: createCounter("tool.execution.blocked", "Tool executions blocked by policy or sandbox diagnostics"),
+		execProcessDurationHistogram: createHistogram("exec.duration_ms", "Exec process duration"),
+		memoryRssHistogram: createHistogram("memory.rss_bytes", "Resident set size reported by diagnostic memory samples", "By"),
+		memoryHeapUsedHistogram: createHistogram("memory.heap_used_bytes", "Heap used bytes reported by diagnostic memory samples", "By"),
+		memoryHeapTotalHistogram: createHistogram("memory.heap_total_bytes", "Heap total bytes reported by diagnostic memory samples", "By"),
+		memoryExternalHistogram: createHistogram("memory.external_bytes", "External memory bytes reported by diagnostic memory samples", "By"),
+		memoryArrayBuffersHistogram: createHistogram("memory.array_buffers_bytes", "ArrayBuffer bytes reported by diagnostic memory samples", "By"),
+		memoryPressureCounter: createCounter("memory.pressure", "Diagnostic memory pressure events"),
+		asyncQueueDroppedCounter: createCounter("diagnostic.async_queue.dropped", "Async diagnostic queue drops by dropped event class"),
+		payloadLargeCounter: createCounter("payload.large", "Oversized payload diagnostics by surface and action"),
+		payloadLargeBytesHistogram: createHistogram("payload.large_bytes", "Oversized payload byte sizes by surface and action", "By"),
+		livenessWarningCounter: createCounter("liveness.warning", "Diagnostic liveness warning events"),
+		livenessEventLoopDelayP99Histogram: createHistogram("liveness.event_loop_delay_p99_ms", "P99 event-loop delay reported by diagnostic liveness warnings"),
+		livenessEventLoopDelayMaxHistogram: createHistogram("liveness.event_loop_delay_max_ms", "Maximum event-loop delay reported by diagnostic liveness warnings"),
+		livenessEventLoopUtilizationHistogram: createHistogram("liveness.event_loop_utilization", "Event-loop utilization reported by diagnostic liveness warnings", "1"),
+		livenessCpuCoreRatioHistogram: createHistogram("liveness.cpu_core_ratio", "Whole-process CPU usage in core equivalents, including worker and native threads; can exceed 1.", "1"),
+		telemetryExporterCounter: createCounter("telemetry.exporter.events", "Diagnostic telemetry exporter lifecycle and failure events")
 	};
 }
 //#endregion
@@ -1322,16 +1039,6 @@ function registerOwnedSdkRuntime(warn) {
 	};
 }
 //#endregion
-//#region extensions/diagnostics-otel/src/service-recorder-runtime.ts
-function createDiagnosticsRecorderRuntime(params) {
-	return {
-		...params.metrics,
-		...params.traces,
-		contentCapturePolicy: params.contentCapturePolicy,
-		tracesEnabled: params.tracesEnabled
-	};
-}
-//#endregion
 //#region extensions/diagnostics-otel/src/service-genai-content.ts
 function textPart(content) {
 	return {
@@ -1495,32 +1202,6 @@ function assignJsonAttribute(attributes, key, value) {
 	const json = safeJsonString(value, MAX_OTEL_CONTENT_ATTRIBUTE_CHARS);
 	if (json) attributes[key] = json;
 }
-function assignGenAiModelContentAttributes(attributes, content, policy) {
-	if (policy.systemPrompt && typeof content?.systemPrompt === "string") {
-		const systemInstructions = [textPart(content.systemPrompt)];
-		assignJsonAttribute(attributes, ATTR_GEN_AI_SYSTEM_INSTRUCTIONS, systemInstructions);
-	}
-	if (policy.inputMessages) {
-		const inputMessages = normalizeGenAiMessages(content?.inputMessages, "user");
-		if (inputMessages.length > 0) {
-			assignJsonAttribute(attributes, ATTR_GEN_AI_INPUT_MESSAGES, inputMessages);
-			assignJsonAttribute(attributes, "input.value", inputMessages);
-			attributes["input.mime_type"] = "application/json";
-		}
-	}
-	if (policy.toolDefinitions) {
-		const toolDefinitions = normalizeGenAiToolDefinitions(content?.toolDefinitions);
-		if (toolDefinitions.length > 0) assignJsonAttribute(attributes, ATTR_GEN_AI_TOOL_DEFINITIONS, toolDefinitions);
-	}
-	if (policy.outputMessages) {
-		const outputMessages = normalizeGenAiMessages(content?.outputMessages, "assistant");
-		if (outputMessages.length > 0) {
-			assignJsonAttribute(attributes, ATTR_GEN_AI_OUTPUT_MESSAGES, outputMessages);
-			assignJsonAttribute(attributes, "output.value", outputMessages);
-			attributes["output.mime_type"] = "application/json";
-		}
-	}
-}
 function assignOtelContentAttribute(attributes, key, value) {
 	const normalized = normalizeOtelContentValue(value);
 	if (normalized) attributes[key] = normalized;
@@ -1530,38 +1211,45 @@ function assignOtelToolIdentityAttributes(attributes, evt) {
 	const toolCallId = evt.toolCallId?.trim();
 	if (toolCallId) attributes[ATTR_GEN_AI_TOOL_CALL_ID] = toolCallId;
 }
-function assignOtelModelContentAttributes(attributes, content, policy) {
-	const redactedContent = content ? {
-		...content,
-		inputMessages: redactInternalReasoningFromMessages(content.inputMessages),
-		outputMessages: redactInternalReasoningFromMessages(content.outputMessages)
-	} : void 0;
-	assignGenAiModelContentAttributes(attributes, redactedContent, policy);
-	if (policy.inputMessages) assignOtelContentAttribute(attributes, "openclaw.content.input_messages", redactedContent?.inputMessages);
-	if (policy.toolDefinitions) assignOtelContentAttribute(attributes, "openclaw.content.tool_definitions", content?.toolDefinitions);
-	if (policy.outputMessages) assignOtelContentAttribute(attributes, "openclaw.content.output_messages", redactedContent?.outputMessages);
-	if (policy.systemPrompt) assignOtelContentAttribute(attributes, "openclaw.content.system_prompt", content?.systemPrompt);
-}
-function assignOtelToolContentAttributes(attributes, content, policy) {
-	if (policy.toolInputs) {
-		const toolInput = normalizeOtelContentValue(content?.toolInput);
-		if (toolInput) {
-			attributes[ATTR_GEN_AI_TOOL_CALL_ARGUMENTS] = toolInput;
-			attributes["openclaw.content.tool_input"] = toolInput;
-		}
+function assignOtelModelContentAttributes(attributes, content, captureContent) {
+	if (!captureContent) return;
+	const redactedInput = redactInternalReasoningFromMessages(content?.inputMessages);
+	const redactedOutput = redactInternalReasoningFromMessages(content?.outputMessages);
+	const inputMessages = normalizeGenAiMessages(redactedInput, "user");
+	if (inputMessages.length > 0) {
+		assignJsonAttribute(attributes, ATTR_GEN_AI_INPUT_MESSAGES, inputMessages);
+		assignJsonAttribute(attributes, "input.value", inputMessages);
+		attributes["input.mime_type"] = "application/json";
 	}
-	if (policy.toolOutputs) {
-		const toolOutput = normalizeOtelContentValue(content?.toolOutput);
-		if (toolOutput) {
-			attributes[ATTR_GEN_AI_TOOL_CALL_RESULT] = toolOutput;
-			attributes["openclaw.content.tool_output"] = toolOutput;
-		}
+	const toolDefinitions = normalizeGenAiToolDefinitions(content?.toolDefinitions);
+	if (toolDefinitions.length > 0) assignJsonAttribute(attributes, ATTR_GEN_AI_TOOL_DEFINITIONS, toolDefinitions);
+	const outputMessages = normalizeGenAiMessages(redactedOutput, "assistant");
+	if (outputMessages.length > 0) {
+		assignJsonAttribute(attributes, ATTR_GEN_AI_OUTPUT_MESSAGES, outputMessages);
+		assignJsonAttribute(attributes, "output.value", outputMessages);
+		attributes["output.mime_type"] = "application/json";
+	}
+	assignOtelContentAttribute(attributes, "openclaw.content.input_messages", redactedInput);
+	assignOtelContentAttribute(attributes, "openclaw.content.tool_definitions", content?.toolDefinitions);
+	assignOtelContentAttribute(attributes, "openclaw.content.output_messages", redactedOutput);
+}
+function assignOtelToolContentAttributes(attributes, content, captureContent) {
+	if (!captureContent) return;
+	const toolInput = normalizeOtelContentValue(content?.toolInput);
+	if (toolInput) {
+		attributes[ATTR_GEN_AI_TOOL_CALL_ARGUMENTS] = toolInput;
+		attributes["openclaw.content.tool_input"] = toolInput;
+	}
+	const toolOutput = normalizeOtelContentValue(content?.toolOutput);
+	if (toolOutput) {
+		attributes[ATTR_GEN_AI_TOOL_CALL_RESULT] = toolOutput;
+		attributes["openclaw.content.tool_output"] = toolOutput;
 	}
 }
 //#endregion
 //#region extensions/diagnostics-otel/src/service-recorders-harness.ts
 function createHarnessRecorders(runtime) {
-	const { harnessDurationHistogram, modelFailoverCounter, activeTrustedSpans, spanWithDuration, trustedTraceContext, activeTrustedParentContext, trackTrustedSpan, setSpanAttrs, completeTrackedLifecycleSpan, addRunAttrs, tracesEnabled, getTrackedInternalOrTrustedSpan, contentCapturePolicy } = runtime;
+	const { harnessDurationHistogram, modelFailoverCounter, activeTrustedSpans, spanWithDuration, trustedTraceContext, activeTrustedParentContext, trackTrustedSpan, setSpanAttrs, completeTrackedLifecycleSpan, addRunAttrs, tracesEnabled, getTrackedInternalOrTrustedSpan, captureContent } = runtime;
 	const recordAgentCommentary = (evt, metadata, privateData) => {
 		if (!tracesEnabled || !metadata.trusted) return;
 		const span = getTrackedInternalOrTrustedSpan(evt, metadata);
@@ -1572,7 +1260,7 @@ function createHarnessRecorders(runtime) {
 			"openclaw.commentary.text_length": evt.textLength,
 			"openclaw.commentary.content_truncated": evt.contentTruncated
 		};
-		assignOtelModelContentAttributes(attrs, privateData.modelContent, contentCapturePolicy);
+		assignOtelModelContentAttributes(attrs, privateData.modelContent, captureContent);
 		span.addEvent("openclaw.agent.commentary", redactOtelAttributes(attrs), evt.sourceTimestampMs);
 	};
 	const harnessRunMetricAttrs = (evt) => ({
@@ -1630,11 +1318,7 @@ function createHarnessRecorders(runtime) {
 			code: SpanStatusCode.ERROR,
 			message: redactedError ?? errorType
 		});
-		if (trackedSpan && trustedTrace?.spanId) {
-			completeTrackedLifecycleSpan(trustedTrace, trackedSpan, evt.ts);
-			return;
-		}
-		span.end(evt.ts);
+		completeTrackedLifecycleSpan(trackedSpan ? trustedTrace : void 0, span, evt.ts);
 	};
 	const recordContextAssembled = (evt, metadata) => {
 		if (!tracesEnabled) return;
@@ -1690,11 +1374,8 @@ function createHarnessRecorders(runtime) {
 }
 //#endregion
 //#region extensions/diagnostics-otel/src/service-genai-attributes.ts
-function hasOtelSemconvOptIn(value, optIn) {
-	return value?.split(",").map((part) => part.trim()).includes(optIn) ?? false;
-}
 function emitLatestGenAiSemconv() {
-	return hasOtelSemconvOptIn(process.env[OTEL_SEMCONV_STABILITY_OPT_IN_ENV], GEN_AI_LATEST_EXPERIMENTAL_OPT_IN);
+	return process.env["OTEL_SEMCONV_STABILITY_OPT_IN"]?.split(",").map((part) => part.trim()).includes("gen_ai_latest_experimental") ?? false;
 }
 function genAiOperationName(api, observationUnit) {
 	if (observationUnit === "turn") return GEN_AI_OPERATION_NAME_VALUE_INVOKE_AGENT;
@@ -1786,7 +1467,7 @@ function addUpstreamRequestIdSpanEvent(span, upstreamRequestIdHash) {
 //#endregion
 //#region extensions/diagnostics-otel/src/service-recorders-model.ts
 function createModelRecorders(runtime) {
-	const { genAiOperationDurationHistogram, modelCallDurationHistogram, modelCallRequestBytesHistogram, modelCallResponseBytesHistogram, modelCallTimeToFirstByteHistogram, spanWithDuration, activeTrustedParentContext, trackTrustedSpan, getTrackedInternalOrTrustedSpan, takeTrackedTrustedSpan, setSpanAttrs, addRunAttrs, contentCapturePolicy, tracesEnabled } = runtime;
+	const { genAiOperationDurationHistogram, modelCallDurationHistogram, modelCallRequestBytesHistogram, modelCallResponseBytesHistogram, modelCallTimeToFirstByteHistogram, spanWithDuration, activeTrustedParentContext, trackTrustedSpan, getTrackedInternalOrTrustedSpan, takeTrackedTrustedSpan, setSpanAttrs, addRunAttrs, captureContent, tracesEnabled } = runtime;
 	const modelCallMetricAttrs = (evt) => ({
 		"openclaw.provider": evt.provider,
 		"openclaw.model": evt.model,
@@ -1853,7 +1534,7 @@ function createModelRecorders(runtime) {
 		assignModelCallSizeTimingAttrs(spanAttrs, evt);
 		assignModelCallPromptStatsAttrs(spanAttrs, evt);
 		assignModelCallUsageAttrs(spanAttrs, evt);
-		assignOtelModelContentAttributes(spanAttrs, modelContent, contentCapturePolicy);
+		assignOtelModelContentAttributes(spanAttrs, modelContent, captureContent);
 		const span = takeTrackedTrustedSpan(evt, metadata) ?? spanWithDuration(modelCallSpanName(evt), spanAttrs, evt.durationMs, {
 			kind: SpanKind.CLIENT,
 			parentContext: activeTrustedParentContext(evt, metadata),
@@ -1877,7 +1558,7 @@ function createModelRecorders(runtime) {
 function createOperationsRecorders(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;
+		if (!metadata.trusted || evt.phase === "response" && evt.firstResponse === false) return;
 		const attrs = { "openclaw.gateway.rpc.method": evt.method };
 		if (evt.phase === "received") {
 			gatewayRpcRequestsCounter.add(1, attrs);
@@ -2078,11 +1759,7 @@ function createOperationsRecorders(runtime) {
 				...message ? { message } : {}
 			});
 		}
-		if (trackedSpan && trustedTrace?.spanId) {
-			completeTrackedLifecycleSpan(trustedTrace, trackedSpan, evt.ts);
-			return;
-		}
-		span.end(evt.ts);
+		completeTrackedLifecycleSpan(trackedSpan ? trustedTrace : void 0, span, evt.ts);
 	};
 	return {
 		recordGatewayRpc,
@@ -2105,7 +1782,7 @@ function createOperationsRecorders(runtime) {
 //#endregion
 //#region extensions/diagnostics-otel/src/service-recorders-tools.ts
 function createToolAndSystemRecorders(runtime) {
-	const { gcDurationHistogram, gatewayEventLoopDelayMaxHistogram, gatewayEventLoopObservedCounter, queueDepthHistogram, skillUsedCounter, toolExecutionDurationHistogram, toolExecutionBlockedCounter, execProcessDurationHistogram, payloadLargeCounter, payloadLargeBytesHistogram, livenessWarningCounter, livenessEventLoopDelayP99Histogram, livenessEventLoopDelayMaxHistogram, livenessEventLoopUtilizationHistogram, livenessCpuCoreRatioHistogram, telemetryExporterCounter, spanWithDuration, activeTrustedParentContext, internalOrTrustedExplicitParentContext, 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, internalOrTrustedExplicitParentContext, exportedInternalOrTrustedContext, trackTrustedSpan, getTrackedInternalOrTrustedSpan, takeTrackedTrustedSpan, setSpanAttrs, addRunAttrs, paramsSummaryAttrs, captureContent, tracesEnabled } = runtime;
 	const toolExecutionBaseAttrs = (evt) => ({
 		"openclaw.toolName": evt.toolName,
 		"openclaw.tool.source": normalizeDiagnosticValue(evt.toolSource, "core"),
@@ -2155,7 +1832,7 @@ function createToolAndSystemRecorders(runtime) {
 		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);
+		assignOtelToolContentAttributes(spanAttrs, toolContent, captureContent);
 		const span = takeTrackedTrustedSpan(evt, metadata) ?? spanWithDuration("openclaw.tool.execution", spanAttrs, evt.durationMs, {
 			parentContext: activeTrustedParentContext(evt, metadata),
 			endTimeMs: toolTimestampMs(evt)
@@ -2471,11 +2148,7 @@ function createUsageRecorders(runtime) {
 			message: redactSensitiveText(evt.error)
 		});
 		const traceContext = internalOrTrustedTraceContext(evt, metadata);
-		if (trackedSpan && traceContext?.spanId) {
-			completeTrackedLifecycleSpan(traceContext, trackedSpan, evt.ts);
-			return;
-		}
-		span.end(evt.ts);
+		completeTrackedLifecycleSpan(trackedSpan ? traceContext : void 0, span, evt.ts);
 	};
 	const messageDeliveryAttrs = (evt) => ({
 		"openclaw.channel": normalizeDiagnosticValue(evt.channel),
@@ -2484,34 +2157,22 @@ function createUsageRecorders(runtime) {
 	const recordMessageDeliveryStarted = (evt) => {
 		messageDeliveryStartedCounter.add(1, messageDeliveryAttrs(evt));
 	};
-	const recordMessageDeliveryCompleted = (evt, metadata) => {
+	const recordMessageDeliveryFinished = (evt, metadata) => {
 		const attrs = {
 			...messageDeliveryAttrs(evt),
-			"openclaw.outcome": "completed"
+			"openclaw.outcome": evt.type === "message.delivery.error" ? "error" : "completed",
+			...evt.type === "message.delivery.error" ? { "openclaw.errorCategory": normalizeDiagnosticValue(evt.errorCategory, "other") } : {}
 		};
 		messageDeliveryDurationHistogram.record(evt.durationMs, attrs);
 		if (!tracesEnabled) return;
-		spanWithDuration("openclaw.message.delivery", {
+		const span = spanWithDuration("openclaw.message.delivery", {
 			...attrs,
-			"openclaw.delivery.result_count": evt.resultCount
+			...evt.type === "message.delivery.completed" ? { "openclaw.delivery.result_count": evt.resultCount } : {}
 		}, evt.durationMs, {
 			parentContext: activeInternalOrTrustedContext(evt, metadata),
 			endTimeMs: evt.ts
-		}).end(evt.ts);
-	};
-	const recordMessageDeliveryError = (evt, metadata) => {
-		const attrs = {
-			...messageDeliveryAttrs(evt),
-			"openclaw.outcome": "error",
-			"openclaw.errorCategory": normalizeDiagnosticValue(evt.errorCategory, "other")
-		};
-		messageDeliveryDurationHistogram.record(evt.durationMs, attrs);
-		if (!tracesEnabled) return;
-		const span = spanWithDuration("openclaw.message.delivery", attrs, evt.durationMs, {
-			parentContext: activeInternalOrTrustedContext(evt, metadata),
-			endTimeMs: evt.ts
 		});
-		span.setStatus({
+		if (evt.type === "message.delivery.error") span.setStatus({
 			code: SpanStatusCode.ERROR,
 			message: redactSensitiveText(evt.errorCategory)
 		});
@@ -2549,8 +2210,7 @@ function createUsageRecorders(runtime) {
 		recordMessageDispatchCompleted,
 		recordMessageProcessed,
 		recordMessageDeliveryStarted,
-		recordMessageDeliveryCompleted,
-		recordMessageDeliveryError,
+		recordMessageDeliveryFinished,
 		recordRunStarted
 	};
 }
@@ -2671,30 +2331,24 @@ function createDiagnosticsTraceRuntime(tracer) {
 			spanContext,
 			...owner ? { owner } : {}
 		});
-		while (retainedTrustedSpanContexts.size > MAX_RETAINED_TRUSTED_SPAN_CONTEXTS) {
-			const oldestKey = retainedTrustedSpanContexts.keys().next().value;
-			if (!oldestKey) break;
-			retainedTrustedSpanContexts.delete(oldestKey);
-		}
+		pruneMapToMaxSize(retainedTrustedSpanContexts, MAX_RETAINED_TRUSTED_SPAN_CONTEXTS);
 	};
 	const completeTrackedLifecycleSpan = (traceContext, span, endTimeMs) => {
-		const spanId = traceContext.spanId;
-		if (!spanId) {
+		if (!traceContext?.spanId) {
 			span.end(endTimeMs);
 			return;
 		}
+		const spanId = traceContext.spanId;
 		const spanContext = span.spanContext();
 		const retainedKeys = [{ spanId }];
-		const retainedAliasKeys = [];
 		for (const [aliasKey, alias] of activeTrustedSpanAliases) if (alias.span === span) {
 			retainedKeys.push({
 				spanId: alias.spanId,
 				owner: alias.owner
 			});
-			retainedAliasKeys.push(aliasKey);
+			activeTrustedSpanAliases.delete(aliasKey);
 		}
 		if (activeTrustedSpans.get(spanId) === span) activeTrustedSpans.delete(spanId);
-		for (const aliasKey of retainedAliasKeys) if (activeTrustedSpanAliases.get(aliasKey)?.span === span) activeTrustedSpanAliases.delete(aliasKey);
 		span.end(endTimeMs);
 		for (const retainedKey of retainedKeys) retainTrustedSpanContext(traceContext.traceId, retainedKey.spanId, spanContext, retainedKey.owner);
 	};
@@ -2717,11 +2371,9 @@ function createDiagnosticsTraceRuntime(tracer) {
 		activeTrustedSpans,
 		activeTrustedSpanAliases,
 		trustedSpanAliasKey,
-		trustedSpanAliasOwner,
 		spanWithDuration,
 		trustedTraceContext,
 		internalOrTrustedTraceContext,
-		internalOrTrustedParentContext,
 		internalOrTrustedExplicitParentContext,
 		activeTrustedParentContext,
 		activeInternalOrTrustedContext,
@@ -2783,9 +2435,6 @@ function resolveResourceDetectors() {
 		return detector ? [detector] : [];
 	});
 }
-function resolveSignalProtocol(signal, configuredProtocol) {
-	return configuredProtocol ?? readNonBlankString(process.env[OTEL_SIGNAL_PROTOCOL_ENV[signal]]) ?? readNonBlankString(process.env["OTEL_EXPORTER_OTLP_PROTOCOL"]) ?? OTLP_HTTP_PROTOBUF_PROTOCOL;
-}
 function createStartupRollbackError(startupError, cleanupError) {
 	return new AggregateError([startupError, cleanupError], "diagnostics-otel startup failed and rollback cleanup failed", { cause: startupError });
 }
@@ -2794,7 +2443,6 @@ function publicExporterEventForHealth(event) {
 		exporter: event.exporter,
 		signal: event.signal
 	};
-	if (event.status === "recovered") return;
 	if (event.status === "started") return {
 		...base,
 		status: "started",
@@ -2812,13 +2460,6 @@ function publicExporterEventForHealth(event) {
 		...event.errorCategory ? { errorCategory: event.errorCategory } : {}
 	};
 }
-function diagnosticTraceContextFromSpanContext(spanContext) {
-	return {
-		traceId: spanContext.traceId,
-		spanId: spanContext.spanId,
-		traceFlags: spanContext.traceFlags.toString(16).padStart(2, "0")
-	};
-}
 function createDiagnosticsOtelService() {
 	let state = {};
 	let preserveExporterRoutesOnNextStop = false;
@@ -2854,7 +2495,6 @@ function createDiagnosticsOtelService() {
 			const exporterHealthReporter = internalDiagnostics;
 			const emitPublicExporterEvent = createPublicExporterHealthEventEmitter((event) => {
 				const publicEvent = publicExporterEventForHealth(event);
-				if (!publicEvent) return;
 				try {
 					internalDiagnostics?.emit({
 						type: "telemetry.exporter",
@@ -2910,7 +2550,7 @@ function createDiagnosticsOtelService() {
 			];
 			const supportedOtlpSignals = /* @__PURE__ */ new Set();
 			for (const signal of ownedOtlpSignals) {
-				const protocol = resolveSignalProtocol(signal, otel.protocol);
+				const protocol = otel.protocol ?? readNonBlankString(process.env[OTEL_SIGNAL_PROTOCOL_ENV[signal]]) ?? readNonBlankString(process.env["OTEL_EXPORTER_OTLP_PROTOCOL"]) ?? OTLP_HTTP_PROTOBUF_PROTOCOL;
 				if (protocol === OTLP_HTTP_PROTOBUF_PROTOCOL) {
 					supportedOtlpSignals.add(signal);
 					continue;
@@ -2940,7 +2580,7 @@ function createDiagnosticsOtelService() {
 				min: 0,
 				max: 1
 			});
-			const contentCapturePolicy = resolveContentCapturePolicy(otel.captureContent);
+			const captureContent = otel.captureContent === true;
 			const resource = resources.resourceFromAttributes({ [ATTR_SERVICE_NAME]: serviceName });
 			const logUrl = logsToOtlp ? resolveSignalOtelUrl({
 				signalEndpoint: otel.logsEndpoint,
@@ -3052,12 +2692,11 @@ function createDiagnosticsOtelService() {
 			active.stopActiveTrustedSpans = diagnosticsTrace.stopActiveTrustedSpans;
 			const diagnosticMetrics = createDiagnosticsMetrics(meter, otel.metricNamePrefix);
 			const diagnosticsLogs = createDiagnosticsLogExporter({
-				contentCapturePolicy,
+				captureContent,
 				emitExporterEvent,
 				flushIntervalMs: otel.flushIntervalMs,
 				headers,
 				logger: ctx.logger,
-				logsEnabled: logsActive,
 				logsToOtlp,
 				logsToStdout,
 				logHttpAgentOptions,
@@ -3066,13 +2705,12 @@ function createDiagnosticsOtelService() {
 				serviceName
 			});
 			active.logProvider = diagnosticsLogs.logProvider;
-			const { recordLogRecord, recordSecurityEvent } = diagnosticsLogs;
-			const recorderRuntime = createDiagnosticsRecorderRuntime({
-				contentCapturePolicy,
-				metrics: diagnosticMetrics,
-				traces: diagnosticsTrace,
+			const recorderRuntime = {
+				...diagnosticMetrics,
+				...diagnosticsTrace,
+				captureContent,
 				tracesEnabled: tracesActive
-			});
+			};
 			const recorders = {
 				...createUsageRecorders(recorderRuntime),
 				...createOperationsRecorders(recorderRuntime),
@@ -3083,8 +2721,7 @@ function createDiagnosticsOtelService() {
 			active.unsubscribe = subscribe(createDiagnosticsEventHandler({
 				logger: ctx.logger,
 				recorders,
-				recordLogRecord,
-				recordSecurityEvent
+				recordLogEvent: diagnosticsLogs.recordLogEvent
 			}), metricsActive ? tracesActive ? void 0 : { exclude: ["diagnostic.phase.completed"] } : tracesActive ? { exclude: ["gateway.event_loop.sample", "diagnostic.gc"] } : { include: ["log.record", "security.event"] });
 			if (tracesActive) active.unregisterTracePropagationBridge = ctx.internalDiagnostics?.registerTracePropagationBridge?.({
 				shouldPrepareEvent(event) {
@@ -3096,7 +2733,11 @@ function createDiagnosticsOtelService() {
 				},
 				resolveTraceContext(traceContext) {
 					const spanContext = diagnosticsTrace.exportedSpanContextForDiagnosticTraceContext(traceContext);
-					return spanContext ? diagnosticTraceContextFromSpanContext(spanContext) : void 0;
+					return spanContext ? {
+						traceId: spanContext.traceId,
+						spanId: spanContext.spanId,
+						traceFlags: spanContext.traceFlags.toString(16).padStart(2, "0")
+					} : void 0;
 				}
 			}) ?? null;
 			if (hasOwnedOtlpSignal || sdkPreloaded && !sdkDisabled) active.unregisterUnhandledRejectionHandler = registerUnhandledRejectionHandler((reason) => {

package/dist/index.js

@@ -1,4 +1,4 @@
-import { t as createDiagnosticsOtelService } from "./.setup/runtime-api-ButGOVne.mjs";
+import { t as createDiagnosticsOtelService } from "./.setup/runtime-api-C7192_s0.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,2 @@
-import { t as createDiagnosticsOtelService } from "./.setup/runtime-api-ButGOVne.mjs";
+import { t as createDiagnosticsOtelService } from "./.setup/runtime-api-C7192_s0.mjs";
 export { createDiagnosticsOtelService };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/diagnostics-otel",
-  "version": "2026.9.8",
+  "version": "2026.10.1-beta.2",
   "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.8"
+      "pluginApi": ">=2026.10.1-beta.2"
     },
     "build": {
-      "openclawVersion": "2026.9.8"
+      "openclawVersion": "2026.10.1-beta.2"
     },
     "release": {
       "publishToClawHub": true,
@@ -55,7 +55,7 @@
     "assets/activity.svg"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.9.8"
+    "openclaw": ">=2026.10.1-beta.2"
   },
   "peerDependenciesMeta": {
     "openclaw": {