iii-sdk 0.0.2-alpha

package/dist/otel-worker-gauges-ELciXZRg.mjs

@@ -0,0 +1,908 @@
+import { SpanKind, SpanStatusCode, context, metrics, propagation, trace } from "@opentelemetry/api";
+import { WebSocket } from "ws";
+import { SeverityNumber as SeverityNumber$1 } from "@opentelemetry/api-logs";
+import { Resource } from "@opentelemetry/resources";
+import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
+import { randomUUID } from "crypto";
+import { SimpleSpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { MeterProvider, PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
+import { CompositePropagator, ExportResultCode, W3CBaggagePropagator, W3CTraceContextPropagator } from "@opentelemetry/core";
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+import { registerInstrumentations } from "@opentelemetry/instrumentation";
+import { LoggerProvider, SimpleLogRecordProcessor } from "@opentelemetry/sdk-logs";
+import { JsonLogsSerializer, JsonMetricsSerializer, JsonTraceSerializer } from "@opentelemetry/otlp-transformer";
+import { monitorEventLoopDelay, performance } from "node:perf_hooks";
+
+//#region src/iii-constants.ts
+/**
+* Constants for the III module.
+*/
+/** Engine function paths for internal operations */
+const EngineFunctions = {
+	LIST_FUNCTIONS: "engine.functions.list",
+	LIST_WORKERS: "engine.workers.list",
+	REGISTER_WORKER: "engine.workers.register"
+};
+/** Engine trigger types */
+const EngineTriggers = {
+	FUNCTIONS_AVAILABLE: "engine::functions-available",
+	LOG: "log"
+};
+/** Log function paths */
+const LogFunctions = {
+	INFO: "log.info",
+	WARN: "log.warn",
+	ERROR: "log.error",
+	DEBUG: "log.debug"
+};
+/** Default reconnection configuration */
+const DEFAULT_BRIDGE_RECONNECTION_CONFIG = {
+	initialDelayMs: 1e3,
+	maxDelayMs: 3e4,
+	backoffMultiplier: 2,
+	jitterFactor: .3,
+	maxRetries: -1
+};
+/** Default invocation timeout in milliseconds */
+const DEFAULT_INVOCATION_TIMEOUT_MS = 3e4;
+
+//#endregion
+//#region src/telemetry-system/types.ts
+const ATTR_SERVICE_VERSION = "service.version";
+const ATTR_SERVICE_NAMESPACE = "service.namespace";
+const ATTR_SERVICE_INSTANCE_ID = "service.instance.id";
+/** Magic prefixes for binary frames over WebSocket */
+const PREFIX_TRACES = "OTLP";
+const PREFIX_METRICS = "MTRC";
+const PREFIX_LOGS = "LOGS";
+/** Default reconnection configuration */
+const DEFAULT_RECONNECTION_CONFIG = {
+	initialDelayMs: 1e3,
+	maxDelayMs: 3e4,
+	backoffMultiplier: 2,
+	jitterFactor: .3,
+	maxRetries: -1
+};
+
+//#endregion
+//#region src/telemetry-system/connection.ts
+/**
+* Shared WebSocket connection for OpenTelemetry exporters.
+*/
+/**
+* Shared WebSocket connection for all OTEL exporters (traces, metrics, logs).
+* Uses a single connection with message prefixes to identify signal type.
+*/
+var SharedEngineConnection = class SharedEngineConnection {
+	static {
+		this.MAX_PENDING_MESSAGES = 1e3;
+	}
+	constructor(wsUrl, config = {}) {
+		this.ws = null;
+		this.connecting = false;
+		this.shuttingDown = false;
+		this.pendingMessages = [];
+		this.reconnectAttempt = 0;
+		this.reconnectTimeout = null;
+		this.state = "disconnected";
+		this.onConnectedCallbacks = [];
+		this.wsUrl = wsUrl;
+		this.config = {
+			...DEFAULT_RECONNECTION_CONFIG,
+			...config
+		};
+		this.connect();
+	}
+	connect() {
+		if (this.connecting || this.ws && this.ws.readyState === WebSocket.OPEN) return;
+		this.connecting = true;
+		this.state = "connecting";
+		try {
+			this.ws = new WebSocket(this.wsUrl);
+			this.ws.on("open", () => {
+				this.connecting = false;
+				this.state = "connected";
+				console.log(`[OTel] Connected to engine at ${this.wsUrl}`);
+				if (this.reconnectAttempt > 0) console.log("[OTel] Successfully reconnected");
+				this.reconnectAttempt = 0;
+				if (this.reconnectTimeout) {
+					clearTimeout(this.reconnectTimeout);
+					this.reconnectTimeout = null;
+				}
+				const pending = this.pendingMessages.splice(0, this.pendingMessages.length);
+				for (const { frame, callback } of pending) this.ws?.send(frame, (err) => callback?.(err));
+				for (const cb of this.onConnectedCallbacks) cb();
+			});
+			this.ws.on("close", () => {
+				this.connecting = false;
+				this.ws = null;
+				if (this.shuttingDown) {
+					this.state = "disconnected";
+					console.log("[OTel] Connection closed during shutdown");
+					return;
+				}
+				this.state = "disconnected";
+				console.log("[OTel] Disconnected from engine, will reconnect...");
+				this.scheduleReconnect();
+			});
+			this.ws.on("error", (err) => {
+				this.connecting = false;
+				if (this.shuttingDown) return;
+				console.error("[OTel] WebSocket error:", err.message);
+			});
+		} catch (err) {
+			this.connecting = false;
+			console.error("[OTel] Connection failed:", err);
+			this.scheduleReconnect();
+		}
+	}
+	scheduleReconnect() {
+		if (this.config.maxRetries !== -1 && this.reconnectAttempt >= this.config.maxRetries) {
+			this.state = "failed";
+			console.error(`[OTel] Max retries (${this.config.maxRetries}) reached, giving up`);
+			const pending = this.pendingMessages.splice(0, this.pendingMessages.length);
+			const failedError = /* @__PURE__ */ new Error("Connection failed after max retries");
+			for (const { callback } of pending) callback?.(failedError);
+			return;
+		}
+		if (this.reconnectTimeout) return;
+		const exponentialDelay = this.config.initialDelayMs * this.config.backoffMultiplier ** this.reconnectAttempt;
+		const cappedDelay = Math.min(exponentialDelay, this.config.maxDelayMs);
+		const jitter = cappedDelay * this.config.jitterFactor * (2 * Math.random() - 1);
+		const delay = Math.max(0, Math.floor(cappedDelay + jitter));
+		this.state = "reconnecting";
+		console.log(`[OTel] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempt + 1})...`);
+		this.reconnectTimeout = setTimeout(() => {
+			this.reconnectTimeout = null;
+			this.reconnectAttempt++;
+			this.connect();
+		}, delay);
+	}
+	/**
+	* Send a message with a signal prefix.
+	*/
+	send(prefix, data, callback) {
+		const prefixBytes = Buffer.from(prefix, "utf-8");
+		const frame = Buffer.concat([prefixBytes, Buffer.from(data)]);
+		if (this.ws && this.ws.readyState === WebSocket.OPEN) this.ws.send(frame, callback);
+		else {
+			if (this.pendingMessages.length >= SharedEngineConnection.MAX_PENDING_MESSAGES) {
+				console.warn("[OTel] Pending message queue full, dropping oldest message");
+				this.pendingMessages.shift()?.callback?.(/* @__PURE__ */ new Error("Message dropped due to queue overflow"));
+			}
+			this.pendingMessages.push({
+				frame,
+				callback
+			});
+			this.connect();
+		}
+	}
+	/**
+	* Register a callback to be called when connected.
+	*/
+	onConnected(callback) {
+		this.onConnectedCallbacks.push(callback);
+		if (this.state === "connected") callback();
+	}
+	/**
+	* Get the current connection state.
+	*/
+	getState() {
+		return this.state;
+	}
+	/**
+	* Shutdown the connection.
+	*/
+	async shutdown() {
+		this.shuttingDown = true;
+		if (this.reconnectTimeout) {
+			clearTimeout(this.reconnectTimeout);
+			this.reconnectTimeout = null;
+		}
+		if (this.ws) {
+			this.ws.close();
+			this.ws = null;
+		}
+		const pending = this.pendingMessages.splice(0, this.pendingMessages.length);
+		const shutdownError = /* @__PURE__ */ new Error("Connection shutdown before message could be sent");
+		for (const { callback } of pending) callback?.(shutdownError);
+		this.onConnectedCallbacks = [];
+		this.state = "disconnected";
+	}
+};
+
+//#endregion
+//#region src/telemetry-system/span-exporter.ts
+/**
+* Span exporter for the III Engine.
+*/
+/**
+* Span exporter using the shared WebSocket connection.
+*/
+var EngineSpanExporter = class EngineSpanExporter {
+	static {
+		this.MAX_PENDING_EXPORTS = 100;
+	}
+	constructor(connection) {
+		this.pendingExports = [];
+		this.connection = connection;
+		this.connection.onConnected(() => this.flushPending());
+	}
+	flushPending() {
+		const pending = this.pendingExports.splice(0, this.pendingExports.length);
+		for (const { spans, resultCallback } of pending) this.sendExport(spans, resultCallback);
+	}
+	sendExport(spans, resultCallback) {
+		try {
+			const serialized = JsonTraceSerializer.serializeRequest(spans);
+			if (!serialized) {
+				resultCallback?.({ code: ExportResultCode.SUCCESS });
+				return;
+			}
+			this.connection.send(PREFIX_TRACES, serialized, (err) => {
+				if (err) {
+					console.error("[OTel] Failed to send spans:", err.message);
+					resultCallback?.({
+						code: ExportResultCode.FAILED,
+						error: err
+					});
+				} else resultCallback?.({ code: ExportResultCode.SUCCESS });
+			});
+		} catch (err) {
+			console.error("[OTel] Error exporting spans:", err);
+			resultCallback?.({
+				code: ExportResultCode.FAILED,
+				error: err
+			});
+		}
+	}
+	doExport(spans, resultCallback) {
+		if (this.connection.getState() !== "connected") {
+			if (this.pendingExports.length >= EngineSpanExporter.MAX_PENDING_EXPORTS) {
+				this.pendingExports.shift()?.resultCallback?.({
+					code: ExportResultCode.FAILED,
+					error: /* @__PURE__ */ new Error("Queue overflow")
+				});
+				console.warn("[OTel] Spans export queue full, dropped oldest entry");
+			}
+			this.pendingExports.push({
+				spans,
+				resultCallback
+			});
+			return;
+		}
+		this.sendExport(spans, resultCallback);
+	}
+	export(spans, resultCallback) {
+		this.doExport(spans, resultCallback);
+	}
+	async shutdown() {
+		const pending = this.pendingExports.splice(0, this.pendingExports.length);
+		const shutdownError = /* @__PURE__ */ new Error("Exporter shutdown before export completed");
+		for (const { resultCallback } of pending) resultCallback?.({
+			code: ExportResultCode.FAILED,
+			error: shutdownError
+		});
+	}
+	async forceFlush() {}
+};
+
+//#endregion
+//#region src/telemetry-system/metrics-exporter.ts
+/**
+* Metrics exporter for the III Engine.
+*/
+/**
+* Metrics exporter using the shared WebSocket connection.
+*/
+var EngineMetricsExporter = class EngineMetricsExporter {
+	static {
+		this.MAX_PENDING_EXPORTS = 100;
+	}
+	constructor(connection) {
+		this.pendingExports = [];
+		this.connection = connection;
+		this.connection.onConnected(() => this.flushPending());
+	}
+	flushPending() {
+		const pending = this.pendingExports.splice(0, this.pendingExports.length);
+		for (const { metrics: metrics$1, resultCallback } of pending) this.sendExport(metrics$1, resultCallback);
+	}
+	sendExport(metricsData, resultCallback) {
+		try {
+			const serialized = JsonMetricsSerializer.serializeRequest(metricsData);
+			if (!serialized) {
+				resultCallback?.({ code: ExportResultCode.SUCCESS });
+				return;
+			}
+			this.connection.send(PREFIX_METRICS, serialized, (err) => {
+				if (err) {
+					console.error("[OTel] Failed to send metrics:", err.message);
+					resultCallback?.({
+						code: ExportResultCode.FAILED,
+						error: err
+					});
+				} else resultCallback?.({ code: ExportResultCode.SUCCESS });
+			});
+		} catch (err) {
+			console.error("[OTel] Error exporting metrics:", err);
+			resultCallback?.({
+				code: ExportResultCode.FAILED,
+				error: err
+			});
+		}
+	}
+	doExport(metricsData, resultCallback) {
+		if (this.connection.getState() !== "connected") {
+			if (this.pendingExports.length >= EngineMetricsExporter.MAX_PENDING_EXPORTS) {
+				this.pendingExports.shift()?.resultCallback?.({
+					code: ExportResultCode.FAILED,
+					error: /* @__PURE__ */ new Error("Queue overflow")
+				});
+				console.warn("[OTel] Metrics export queue full, dropped oldest entry");
+			}
+			this.pendingExports.push({
+				metrics: metricsData,
+				resultCallback
+			});
+			return;
+		}
+		this.sendExport(metricsData, resultCallback);
+	}
+	export(metrics$1, resultCallback) {
+		this.doExport(metrics$1, resultCallback);
+	}
+	async shutdown() {
+		const pending = this.pendingExports.splice(0, this.pendingExports.length);
+		const shutdownError = /* @__PURE__ */ new Error("Exporter shutdown before export completed");
+		for (const { resultCallback } of pending) resultCallback?.({
+			code: ExportResultCode.FAILED,
+			error: shutdownError
+		});
+	}
+	async forceFlush() {}
+};
+
+//#endregion
+//#region src/telemetry-system/log-exporter.ts
+/**
+* Log exporter for the III Engine.
+*/
+/**
+* Log exporter using the shared WebSocket connection.
+*/
+var EngineLogExporter = class {
+	constructor(connection) {
+		this.pendingExports = [];
+		this.connection = connection;
+		this.connection.onConnected(() => this.flushPending());
+	}
+	flushPending() {
+		const pending = this.pendingExports.splice(0, this.pendingExports.length);
+		for (const { logs, callback } of pending) this.doExport(logs, callback);
+	}
+	doExport(logs, resultCallback) {
+		if (this.connection.getState() !== "connected") {
+			this.pendingExports.push({
+				logs,
+				callback: resultCallback
+			});
+			return;
+		}
+		try {
+			const serialized = JsonLogsSerializer.serializeRequest(logs);
+			if (!serialized) {
+				resultCallback({ code: ExportResultCode.SUCCESS });
+				return;
+			}
+			this.connection.send(PREFIX_LOGS, serialized, (err) => {
+				if (err) {
+					console.error("[OTel] Failed to send logs:", err.message);
+					resultCallback({
+						code: ExportResultCode.FAILED,
+						error: err
+					});
+				} else resultCallback({ code: ExportResultCode.SUCCESS });
+			});
+		} catch (err) {
+			console.error("[OTel] Error exporting logs:", err);
+			resultCallback({
+				code: ExportResultCode.FAILED,
+				error: err
+			});
+		}
+	}
+	export(logs, resultCallback) {
+		this.doExport(logs, resultCallback);
+	}
+	async shutdown() {
+		for (const { callback } of this.pendingExports) callback({
+			code: ExportResultCode.FAILED,
+			error: /* @__PURE__ */ new Error("Exporter shutdown")
+		});
+		this.pendingExports = [];
+	}
+};
+
+//#endregion
+//#region src/telemetry-system/context.ts
+/**
+* Trace context and baggage propagation utilities.
+*/
+/**
+* Extract the current trace ID from the active span context.
+*/
+function currentTraceId() {
+	const span = trace.getActiveSpan();
+	if (span) {
+		const spanContext = span.spanContext();
+		if (spanContext.traceId && spanContext.traceId !== "00000000000000000000000000000000") return spanContext.traceId;
+	}
+}
+/**
+* Extract the current span ID from the active span context.
+*/
+function currentSpanId() {
+	const span = trace.getActiveSpan();
+	if (span) {
+		const spanContext = span.spanContext();
+		if (spanContext.spanId && spanContext.spanId !== "0000000000000000") return spanContext.spanId;
+	}
+}
+/**
+* Inject the current trace context into a W3C traceparent header string.
+*/
+function injectTraceparent() {
+	const carrier = {};
+	propagation.inject(context.active(), carrier);
+	return carrier["traceparent"];
+}
+/**
+* Extract a trace context from a W3C traceparent header string.
+*/
+function extractTraceparent(traceparent) {
+	const carrier = { traceparent };
+	return propagation.extract(context.active(), carrier);
+}
+/**
+* Inject the current baggage into a W3C baggage header string.
+*/
+function injectBaggage() {
+	const carrier = {};
+	propagation.inject(context.active(), carrier);
+	return carrier["baggage"];
+}
+/**
+* Extract baggage from a W3C baggage header string.
+*/
+function extractBaggage(baggage) {
+	const carrier = { baggage };
+	return propagation.extract(context.active(), carrier);
+}
+/**
+* Extract both trace context and baggage from their respective headers.
+*/
+function extractContext(traceparent, baggage) {
+	const carrier = {};
+	if (traceparent) carrier["traceparent"] = traceparent;
+	if (baggage) carrier["baggage"] = baggage;
+	return propagation.extract(context.active(), carrier);
+}
+/**
+* Get a baggage entry from the current context.
+*/
+function getBaggageEntry(key) {
+	return propagation.getBaggage(context.active())?.getEntry(key)?.value;
+}
+/**
+* Set a baggage entry in the current context.
+*/
+function setBaggageEntry(key, value) {
+	let bag = propagation.getBaggage(context.active()) ?? propagation.createBaggage();
+	bag = bag.setEntry(key, { value });
+	return propagation.setBaggage(context.active(), bag);
+}
+/**
+* Remove a baggage entry from the current context.
+*/
+function removeBaggageEntry(key) {
+	const bag = propagation.getBaggage(context.active());
+	if (!bag) return context.active();
+	const newBag = bag.removeEntry(key);
+	return propagation.setBaggage(context.active(), newBag);
+}
+/**
+* Get all baggage entries from the current context.
+*/
+function getAllBaggage() {
+	const bag = propagation.getBaggage(context.active());
+	if (!bag) return {};
+	const entries = {};
+	for (const [key, entry] of bag.getAllEntries()) entries[key] = entry.value;
+	return entries;
+}
+
+//#endregion
+//#region src/telemetry-system/index.ts
+/**
+* OpenTelemetry initialization for the III Node SDK.
+*
+* This module provides trace, metrics, and log export to the III Engine
+* via a shared WebSocket connection using OTLP JSON format.
+*/
+let sharedConnection = null;
+let tracerProvider = null;
+let meterProvider = null;
+let loggerProvider = null;
+let tracer = null;
+let meter = null;
+let logger = null;
+let serviceName = "iii-node-iii";
+/**
+* Initialize OpenTelemetry with the given configuration.
+* This should be called once at application startup.
+*/
+function initOtel(config = {}) {
+	if (!(config.enabled ?? (process.env.OTEL_ENABLED === "true" || process.env.OTEL_ENABLED === "1"))) {
+		console.log("[OTel] OpenTelemetry is disabled");
+		return;
+	}
+	if (config.instrumentations?.length) registerInstrumentations({ instrumentations: config.instrumentations });
+	serviceName = config.serviceName ?? process.env.OTEL_SERVICE_NAME ?? "iii-node-iii";
+	const serviceVersion = config.serviceVersion ?? process.env.SERVICE_VERSION ?? "unknown";
+	const serviceNamespace = config.serviceNamespace ?? process.env.SERVICE_NAMESPACE;
+	const serviceInstanceId = config.serviceInstanceId ?? process.env.SERVICE_INSTANCE_ID ?? randomUUID();
+	const engineWsUrl = config.engineWsUrl ?? process.env.III_BRIDGE_URL ?? "ws://localhost:49134";
+	const resourceAttributes = {
+		[ATTR_SERVICE_NAME]: serviceName,
+		[ATTR_SERVICE_VERSION]: serviceVersion,
+		[ATTR_SERVICE_INSTANCE_ID]: serviceInstanceId
+	};
+	if (serviceNamespace) resourceAttributes[ATTR_SERVICE_NAMESPACE] = serviceNamespace;
+	const resource = new Resource(resourceAttributes);
+	sharedConnection = new SharedEngineConnection(engineWsUrl, config.reconnectionConfig);
+	tracerProvider = new NodeTracerProvider({
+		resource,
+		spanProcessors: [new SimpleSpanProcessor(new EngineSpanExporter(sharedConnection))]
+	});
+	propagation.setGlobalPropagator(new CompositePropagator({ propagators: [new W3CTraceContextPropagator(), new W3CBaggagePropagator()] }));
+	tracerProvider.register();
+	tracer = trace.getTracer(serviceName);
+	console.log(`[OTel] Traces initialized: engine=${engineWsUrl}, service=${serviceName}`);
+	if (config.metricsEnabled ?? (process.env.OTEL_METRICS_ENABLED === "true" || process.env.OTEL_METRICS_ENABLED === "1")) {
+		const metricsExporter = new EngineMetricsExporter(sharedConnection);
+		const exportIntervalMs = config.metricsExportIntervalMs ?? 6e4;
+		meterProvider = new MeterProvider({
+			resource,
+			readers: [new PeriodicExportingMetricReader({
+				exporter: metricsExporter,
+				exportIntervalMillis: exportIntervalMs
+			})]
+		});
+		metrics.setGlobalMeterProvider(meterProvider);
+		meter = meterProvider.getMeter(serviceName);
+		console.log(`[OTel] Metrics initialized: interval=${exportIntervalMs}ms`);
+	}
+	const logExporter = new EngineLogExporter(sharedConnection);
+	loggerProvider = new LoggerProvider({ resource });
+	loggerProvider.addLogRecordProcessor(new SimpleLogRecordProcessor(logExporter));
+	logger = loggerProvider.getLogger(serviceName);
+	console.log("[OTel] Logs initialized");
+}
+/**
+* Shutdown OpenTelemetry, flushing any pending data.
+*/
+async function shutdownOtel() {
+	if (tracerProvider) {
+		await tracerProvider.shutdown();
+		tracerProvider = null;
+	}
+	if (meterProvider) {
+		await meterProvider.shutdown();
+		meterProvider = null;
+	}
+	if (loggerProvider) {
+		await loggerProvider.shutdown();
+		loggerProvider = null;
+	}
+	if (sharedConnection) {
+		await sharedConnection.shutdown();
+		sharedConnection = null;
+	}
+	tracer = null;
+	meter = null;
+	logger = null;
+}
+/**
+* Get the OpenTelemetry tracer instance.
+*/
+function getTracer() {
+	return tracer;
+}
+/**
+* Get the OpenTelemetry meter instance.
+*/
+function getMeter() {
+	return meter;
+}
+/**
+* Get the OpenTelemetry logger instance.
+*/
+function getLogger() {
+	return logger;
+}
+/**
+* Start a new span with the given name and run the callback within it.
+*/
+async function withSpan(name, options, fn) {
+	if (!tracer) {
+		const noopSpan = {
+			spanContext: () => ({
+				traceId: "",
+				spanId: "",
+				traceFlags: 0
+			}),
+			setAttribute: () => noopSpan,
+			setAttributes: () => noopSpan,
+			addEvent: () => noopSpan,
+			addLink: () => noopSpan,
+			setStatus: () => noopSpan,
+			updateName: () => noopSpan,
+			end: () => {},
+			isRecording: () => false,
+			recordException: () => {},
+			addLinks: () => noopSpan
+		};
+		return fn(noopSpan);
+	}
+	const parentContext = options.traceparent ? extractTraceparent(options.traceparent) : context.active();
+	return tracer.startActiveSpan(name, { kind: options.kind ?? SpanKind.INTERNAL }, parentContext, async (span) => {
+		try {
+			const result = await fn(span);
+			span.setStatus({ code: SpanStatusCode.OK });
+			return result;
+		} catch (error) {
+			span.setStatus({
+				code: SpanStatusCode.ERROR,
+				message: error.message
+			});
+			span.recordException(error);
+			throw error;
+		} finally {
+			span.end();
+		}
+	});
+}
+
+//#endregion
+//#region src/utils.ts
+/**
+* Safely stringify a value, handling circular references, BigInt, and other edge cases.
+* Returns "[unserializable]" if serialization fails for any reason.
+*/
+function safeStringify(value) {
+	const seen = /* @__PURE__ */ new WeakSet();
+	try {
+		return JSON.stringify(value, (_key, val) => {
+			if (typeof val === "bigint") return val.toString();
+			if (val !== null && typeof val === "object") {
+				if (seen.has(val)) return "[Circular]";
+				seen.add(val);
+			}
+			return val;
+		});
+	} catch {
+		return "[unserializable]";
+	}
+}
+
+//#endregion
+//#region src/worker-metrics.ts
+/**
+* Worker metrics collection for the III Node SDK.
+*
+* Collects CPU, memory, and event loop metrics for worker health monitoring.
+* Uses the Node.js built-in `monitorEventLoopDelay` API for accurate
+* event loop lag measurements.
+*/
+/**
+* Collects worker resource metrics including CPU, memory, and event loop lag.
+*
+* Uses the Node.js `monitorEventLoopDelay` API for high-precision event loop
+* delay measurements instead of manual `setImmediate` timing.
+*
+* @example
+* ```typescript
+* const collector = new WorkerMetricsCollector()
+*
+* // Collect metrics periodically
+* setInterval(() => {
+*   const metrics = collector.collect()
+*   console.log('CPU:', metrics.cpu_percent, '%')
+*   console.log('Event Loop Lag:', metrics.event_loop_lag_ms, 'ms')
+* }, 5000)
+*
+* // Clean up when done
+* collector.stopMonitoring()
+* ```
+*/
+var WorkerMetricsCollector = class {
+	/**
+	* Creates a new WorkerMetricsCollector instance.
+	*
+	* @param options - Configuration options
+	*/
+	constructor(options = {}) {
+		this.eventLoopHistogram = null;
+		this.startTime = Date.now();
+		this.lastCpuUsage = process.cpuUsage();
+		this.lastCpuTime = performance.now();
+		this.startEventLoopMonitoring(options.eventLoopResolutionMs ?? 20);
+	}
+	/**
+	* Starts the event loop delay histogram monitoring.
+	*
+	* @param resolutionMs - Histogram resolution in milliseconds
+	*/
+	startEventLoopMonitoring(resolutionMs) {
+		this.eventLoopHistogram = monitorEventLoopDelay({ resolution: Number.isFinite(resolutionMs) && resolutionMs > 0 ? Math.max(1, Math.floor(resolutionMs)) : 20 });
+		this.eventLoopHistogram.enable();
+	}
+	/**
+	* Stops the event loop monitoring and releases resources.
+	* Should be called when the collector is no longer needed.
+	*/
+	stopMonitoring() {
+		if (this.eventLoopHistogram) {
+			this.eventLoopHistogram.disable();
+			this.eventLoopHistogram = null;
+		}
+	}
+	/**
+	* Collects current worker metrics.
+	*
+	* This method calculates CPU usage since the last collection,
+	* reads memory usage, and gets event loop delay statistics.
+	* The event loop histogram is reset after each collection for
+	* accurate per-interval measurements.
+	*
+	* @returns Current worker metrics snapshot
+	*/
+	collect() {
+		const memoryUsage = process.memoryUsage();
+		const cpuUsage = process.cpuUsage();
+		const now = performance.now();
+		const cpuDelta = {
+			user: cpuUsage.user - this.lastCpuUsage.user,
+			system: cpuUsage.system - this.lastCpuUsage.system
+		};
+		const timeDelta = (now - this.lastCpuTime) * 1e3;
+		const cpuPercent = timeDelta > 0 ? (cpuDelta.user + cpuDelta.system) / timeDelta * 100 : 0;
+		this.lastCpuUsage = cpuUsage;
+		this.lastCpuTime = now;
+		let eventLoopLagMs = 0;
+		if (this.eventLoopHistogram) {
+			eventLoopLagMs = this.eventLoopHistogram.mean / 1e6;
+			this.eventLoopHistogram.reset();
+		}
+		return {
+			memory_heap_used: memoryUsage.heapUsed,
+			memory_heap_total: memoryUsage.heapTotal,
+			memory_rss: memoryUsage.rss,
+			memory_external: memoryUsage.external,
+			cpu_user_micros: cpuUsage.user,
+			cpu_system_micros: cpuUsage.system,
+			cpu_percent: Math.min(cpuPercent, 100),
+			event_loop_lag_ms: eventLoopLagMs,
+			uptime_seconds: Math.floor((Date.now() - this.startTime) / 1e3),
+			timestamp_ms: Date.now(),
+			runtime: "node"
+		};
+	}
+};
+
+//#endregion
+//#region src/otel-worker-gauges.ts
+let registeredGauges = false;
+let metricsCollector = null;
+let registeredMeter = null;
+let registeredBatchCallback = null;
+let registeredObservables = [];
+function registerWorkerGauges(meter$1, options) {
+	if (registeredGauges) return;
+	const { workerId, workerName } = options;
+	const baseAttributes = {
+		"worker.id": workerId,
+		...workerName && { "worker.name": workerName }
+	};
+	metricsCollector = new WorkerMetricsCollector();
+	const memoryHeapUsed = meter$1.createObservableGauge("iii.worker.memory.heap_used", {
+		description: "Worker heap memory used in bytes",
+		unit: "bytes"
+	});
+	const memoryHeapTotal = meter$1.createObservableGauge("iii.worker.memory.heap_total", {
+		description: "Worker total heap memory in bytes",
+		unit: "bytes"
+	});
+	const memoryRss = meter$1.createObservableGauge("iii.worker.memory.rss", {
+		description: "Worker resident set size in bytes",
+		unit: "bytes"
+	});
+	const memoryExternal = meter$1.createObservableGauge("iii.worker.memory.external", {
+		description: "Worker external memory in bytes",
+		unit: "bytes"
+	});
+	const cpuPercent = meter$1.createObservableGauge("iii.worker.cpu.percent", {
+		description: "Worker CPU usage percentage",
+		unit: "%"
+	});
+	const cpuUserMicros = meter$1.createObservableGauge("iii.worker.cpu.user_micros", {
+		description: "Worker CPU user time in microseconds",
+		unit: "us"
+	});
+	const cpuSystemMicros = meter$1.createObservableGauge("iii.worker.cpu.system_micros", {
+		description: "Worker CPU system time in microseconds",
+		unit: "us"
+	});
+	const eventLoopLag = meter$1.createObservableGauge("iii.worker.event_loop.lag_ms", {
+		description: "Worker event loop lag in milliseconds",
+		unit: "ms"
+	});
+	const uptimeSeconds = meter$1.createObservableGauge("iii.worker.uptime_seconds", {
+		description: "Worker uptime in seconds",
+		unit: "s"
+	});
+	const batchCallback = (observableResult) => {
+		if (!metricsCollector) return;
+		const metrics$1 = metricsCollector.collect();
+		if (metrics$1.memory_heap_used !== void 0) observableResult.observe(memoryHeapUsed, metrics$1.memory_heap_used, baseAttributes);
+		if (metrics$1.memory_heap_total !== void 0) observableResult.observe(memoryHeapTotal, metrics$1.memory_heap_total, baseAttributes);
+		if (metrics$1.memory_rss !== void 0) observableResult.observe(memoryRss, metrics$1.memory_rss, baseAttributes);
+		if (metrics$1.memory_external !== void 0) observableResult.observe(memoryExternal, metrics$1.memory_external, baseAttributes);
+		if (metrics$1.cpu_percent !== void 0) observableResult.observe(cpuPercent, metrics$1.cpu_percent, baseAttributes);
+		if (metrics$1.cpu_user_micros !== void 0) observableResult.observe(cpuUserMicros, metrics$1.cpu_user_micros, baseAttributes);
+		if (metrics$1.cpu_system_micros !== void 0) observableResult.observe(cpuSystemMicros, metrics$1.cpu_system_micros, baseAttributes);
+		if (metrics$1.event_loop_lag_ms !== void 0) observableResult.observe(eventLoopLag, metrics$1.event_loop_lag_ms, baseAttributes);
+		if (metrics$1.uptime_seconds !== void 0) observableResult.observe(uptimeSeconds, metrics$1.uptime_seconds, baseAttributes);
+	};
+	meter$1.addBatchObservableCallback(batchCallback, [
+		memoryHeapUsed,
+		memoryHeapTotal,
+		memoryRss,
+		memoryExternal,
+		cpuPercent,
+		cpuUserMicros,
+		cpuSystemMicros,
+		eventLoopLag,
+		uptimeSeconds
+	]);
+	registeredMeter = meter$1;
+	registeredBatchCallback = batchCallback;
+	registeredObservables = [
+		memoryHeapUsed,
+		memoryHeapTotal,
+		memoryRss,
+		memoryExternal,
+		cpuPercent,
+		cpuUserMicros,
+		cpuSystemMicros,
+		eventLoopLag,
+		uptimeSeconds
+	];
+	registeredGauges = true;
+}
+function stopWorkerGauges() {
+	if (registeredMeter && registeredBatchCallback) registeredMeter.removeBatchObservableCallback(registeredBatchCallback, registeredObservables);
+	if (metricsCollector) {
+		metricsCollector.stopMonitoring();
+		metricsCollector = null;
+	}
+	registeredMeter = null;
+	registeredBatchCallback = null;
+	registeredObservables = [];
+	registeredGauges = false;
+}
+
+//#endregion
+export { removeBaggageEntry as C, EngineFunctions as D, DEFAULT_INVOCATION_TIMEOUT_MS as E, EngineTriggers as O, injectTraceparent as S, DEFAULT_BRIDGE_RECONNECTION_CONFIG as T, extractContext as _, SeverityNumber$1 as a, getBaggageEntry as b, getLogger as c, initOtel as d, shutdownOtel as f, extractBaggage as g, currentTraceId as h, safeStringify as i, LogFunctions as k, getMeter as l, currentSpanId as m, stopWorkerGauges as n, SpanKind as o, withSpan as p, WorkerMetricsCollector as r, SpanStatusCode as s, registerWorkerGauges as t, getTracer as u, extractTraceparent as v, setBaggageEntry as w, injectBaggage as x, getAllBaggage as y };
+//# sourceMappingURL=otel-worker-gauges-ELciXZRg.mjs.map