sonamu 0.9.8 → 0.9.10

package/dist/stream/ws-telemetry.js

@@ -0,0 +1,931 @@
+import { __esmMin } from "../_virtual/rolldown_runtime.js";
+import { InMemoryEventStore, InMemoryMetricStore, InMemorySpanStore, init_ws_telemetry_memory } from "./ws-telemetry-memory.js";
+import { generateSpanId, generateTraceId, init_ws_telemetry_trace, parseTraceParent } from "./ws-telemetry-trace.js";
+
+//#region src/stream/ws-telemetry.ts
+function isSensitiveKey(key) {
+	const normalized = key.replace(/[^a-zA-Z0-9]/g, "").toLowerCase();
+	return SENSITIVE_KEY_PATTERNS.some((pattern) => normalized.includes(pattern));
+}
+function redactValue(value, key) {
+	if (key !== undefined && isSensitiveKey(key)) {
+		return REDACTED_VALUE;
+	}
+	if (Array.isArray(value)) {
+		return value.map((item) => redactValue(item));
+	}
+	if (value instanceof Date) {
+		return value;
+	}
+	if (value && typeof value === "object") {
+		const redacted = {};
+		for (const [childKey, childValue] of Object.entries(value)) {
+			redacted[childKey] = redactValue(childValue, childKey);
+		}
+		return redacted;
+	}
+	return value;
+}
+/**
+* defaultSensitiveKeyRedact — sensitive key 패턴 기반 built-in redactor.
+* pipeline emit flow의 첫 단계에서 항상 적용된다.
+*/
+function defaultSensitiveKeyRedact(record) {
+	if (record.type === "event") {
+		return {
+			...record,
+			attributes: record.attributes ? redactValue(record.attributes) : undefined,
+			detail: record.detail ? redactValue(record.detail) : undefined,
+			payloadPreview: record.payloadPreview
+		};
+	}
+	if (record.type === "metric") {
+		return {
+			...record,
+			tags: record.tags ? redactValue(record.tags) : undefined,
+			snapshot: record.snapshot ? { ...record.snapshot } : undefined
+		};
+	}
+	return {
+		...record,
+		attributes: record.attributes ? redactValue(record.attributes) : undefined,
+		events: record.events?.map((event) => ({
+			...event,
+			attributes: event.attributes ? redactValue(event.attributes) : undefined
+		})),
+		links: record.links?.map((link) => ({
+			...link,
+			attributes: link.attributes ? redactValue(link.attributes) : undefined
+		}))
+	};
+}
+function truncatePayloadPreview(payload, maxBytes) {
+	try {
+		const serialized = JSON.stringify(redactValue(payload));
+		if (Buffer.byteLength(serialized, "utf-8") <= maxBytes) {
+			return serialized;
+		}
+		return truncateUtf8String(serialized, maxBytes);
+	} catch {
+		return "[unserializable]";
+	}
+}
+function truncateUtf8String(value, maxBytes) {
+	if (maxBytes <= 0) return "";
+	const suffix = maxBytes >= 3 ? "..." : "";
+	const contentBudget = maxBytes - Buffer.byteLength(suffix, "utf-8");
+	let result = "";
+	let usedBytes = 0;
+	for (const char of value) {
+		const charBytes = Buffer.byteLength(char, "utf-8");
+		if (usedBytes + charBytes > contentBudget) break;
+		result += char;
+		usedBytes += charBytes;
+	}
+	return result + suffix;
+}
+function isPromiseLike(value) {
+	return typeof value === "object" && value !== null && "then" in value && "catch" in value;
+}
+function buildController(options, runtimeMetadata) {
+	const defaults = options.defaults ?? {};
+	const eventsOpt = options.events ?? {};
+	const metricsOpt = options.metrics ?? {};
+	const spansOpt = options.spans ?? {};
+	const defaultsMaxRecordsPerSecond = defaults.maxRecordsPerSecond ?? DEFAULT_MAX_RECORDS_PER_SECOND;
+	const eventsSharedRedactor = eventsOpt.redactor === null ? undefined : defaults.redactor;
+	const eventsSignalRedactor = typeof eventsOpt.redactor === "function" ? eventsOpt.redactor : undefined;
+	const eventsSharedBeforeRecord = eventsOpt.beforeRecord === null ? undefined : defaults.beforeRecord;
+	const eventsSignalBeforeRecord = typeof eventsOpt.beforeRecord === "function" ? eventsOpt.beforeRecord : undefined;
+	const metricsSharedRedactor = metricsOpt.redactor === null ? undefined : defaults.redactor;
+	const metricsSignalRedactor = typeof metricsOpt.redactor === "function" ? metricsOpt.redactor : undefined;
+	const metricsSharedBeforeRecord = metricsOpt.beforeRecord === null ? undefined : defaults.beforeRecord;
+	const metricsSignalBeforeRecord = typeof metricsOpt.beforeRecord === "function" ? metricsOpt.beforeRecord : undefined;
+	const spansSharedRedactor = spansOpt.redactor === null ? undefined : defaults.redactor;
+	const spansSignalRedactor = typeof spansOpt.redactor === "function" ? spansOpt.redactor : undefined;
+	const spansSharedBeforeRecord = spansOpt.beforeRecord === null ? undefined : defaults.beforeRecord;
+	const spansSignalBeforeRecord = typeof spansOpt.beforeRecord === "function" ? spansOpt.beforeRecord : undefined;
+	const eventSinks = eventsOpt.sinks ? [...eventsOpt.sinks] : [];
+	let eventStore = eventsOpt.store;
+	if (eventSinks.length === 0 && eventStore === undefined) {
+		eventStore = new InMemoryEventStore({
+			maxRecords: eventsOpt.maxRecords ?? defaults.maxRecords,
+			maxBytes: eventsOpt.maxBytes ?? defaults.maxBytes
+		});
+		eventSinks.push(eventStore.sink);
+	} else if (eventStore !== undefined && !eventSinks.includes(eventStore.sink)) {
+		eventSinks.push(eventStore.sink);
+	}
+	const eventsResolved = {
+		sinks: eventSinks,
+		store: eventStore,
+		maxRecordsPerSecond: eventsOpt.sampling?.maxRecordsPerSecond ?? defaultsMaxRecordsPerSecond,
+		maxInFlightEmits: eventsOpt.maxInFlightEmits ?? DEFAULT_MAX_IN_FLIGHT_EMITS_PER_SINK,
+		sharedRedactor: eventsSharedRedactor,
+		signalRedactor: eventsSignalRedactor,
+		sharedBeforeRecord: eventsSharedBeforeRecord,
+		signalBeforeRecord: eventsSignalBeforeRecord,
+		sampling: {
+			defaultRate: eventsOpt.sampling?.defaultRate ?? DEFAULT_EVENT_SAMPLING_DEFAULT_RATE,
+			rateByEvent: eventsOpt.sampling?.rateByEvent ?? {},
+			alwaysRecordLevels: eventsOpt.sampling?.alwaysRecordLevels ?? [...DEFAULT_EVENT_ALWAYS_RECORD_LEVELS]
+		},
+		capturePayload: eventsOpt.capturePayload ?? DEFAULT_EVENT_CAPTURE_PAYLOAD,
+		maxPayloadPreviewBytes: eventsOpt.maxPayloadPreviewBytes ?? DEFAULT_EVENT_MAX_PAYLOAD_PREVIEW_BYTES
+	};
+	const metricSinks = metricsOpt.sinks ? [...metricsOpt.sinks] : [];
+	let metricStore = metricsOpt.store;
+	if (metricSinks.length === 0 && metricStore === undefined) {
+		metricStore = new InMemoryMetricStore({
+			maxRecords: metricsOpt.maxRecords ?? defaults.maxRecords,
+			maxBytes: metricsOpt.maxBytes ?? defaults.maxBytes
+		});
+		metricSinks.push(metricStore.sink);
+	} else if (metricStore !== undefined && !metricSinks.includes(metricStore.sink)) {
+		metricSinks.push(metricStore.sink);
+	}
+	const metricsResolved = {
+		sinks: metricSinks,
+		store: metricStore,
+		maxRecordsPerSecond: metricsOpt.sampling?.maxRecordsPerSecond ?? defaultsMaxRecordsPerSecond,
+		maxInFlightEmits: metricsOpt.maxInFlightEmits ?? DEFAULT_MAX_IN_FLIGHT_EMITS_PER_SINK,
+		sharedRedactor: metricsSharedRedactor,
+		signalRedactor: metricsSignalRedactor,
+		sharedBeforeRecord: metricsSharedBeforeRecord,
+		signalBeforeRecord: metricsSignalBeforeRecord,
+		collectionEnabled: metricsOpt.collectionEnabled ?? DEFAULT_METRIC_COLLECTION_ENABLED,
+		sampleIntervalMs: metricsOpt.sampleIntervalMs ?? DEFAULT_METRIC_SAMPLE_INTERVAL_MS
+	};
+	const spanSinks = spansOpt.sinks ? [...spansOpt.sinks] : [];
+	let spanStore = spansOpt.store;
+	if (spanSinks.length === 0 && spanStore === undefined) {
+		spanStore = new InMemorySpanStore({
+			maxRecords: spansOpt.maxRecords ?? defaults.maxRecords,
+			maxBytes: spansOpt.maxBytes ?? defaults.maxBytes
+		});
+		spanSinks.push(spanStore.sink);
+	} else if (spanStore !== undefined && !spanSinks.includes(spanStore.sink)) {
+		spanSinks.push(spanStore.sink);
+	}
+	const spansResolved = {
+		sinks: spanSinks,
+		store: spanStore,
+		maxRecordsPerSecond: spansOpt.sampling?.maxRecordsPerSecond ?? defaultsMaxRecordsPerSecond,
+		maxInFlightEmits: spansOpt.maxInFlightEmits ?? DEFAULT_MAX_IN_FLIGHT_EMITS_PER_SINK,
+		sharedRedactor: spansSharedRedactor,
+		signalRedactor: spansSignalRedactor,
+		sharedBeforeRecord: spansSharedBeforeRecord,
+		signalBeforeRecord: spansSignalBeforeRecord,
+		sampling: { defaultRate: spansOpt.sampling?.defaultRate ?? DEFAULT_SPAN_SAMPLING_DEFAULT_RATE }
+	};
+	const eventPipeline = new EventPipeline(eventsResolved, runtimeMetadata);
+	const metricPipeline = new MetricPipeline(metricsResolved, runtimeMetadata);
+	const spanPipeline = new SpanPipeline(spansResolved, runtimeMetadata);
+	const traceOptions = {
+		extractTraceParent: options.trace?.extractTraceParent ?? DEFAULT_TRACE_OPTIONS.extractTraceParent,
+		generateConnectionTrace: options.trace?.generateConnectionTrace ?? DEFAULT_TRACE_OPTIONS.generateConnectionTrace,
+		propagateMessageTrace: options.trace?.propagateMessageTrace ?? DEFAULT_TRACE_OPTIONS.propagateMessageTrace,
+		recordConnectionLifetimeSpan: options.trace?.recordConnectionLifetimeSpan ?? DEFAULT_TRACE_OPTIONS.recordConnectionLifetimeSpan
+	};
+	const shutdownTimeoutMs = options.shutdownTimeoutMs ?? DEFAULT_SHUTDOWN_TIMEOUT_MS;
+	return new WebSocketTelemetryControllerImpl(eventPipeline, metricPipeline, spanPipeline, traceOptions, runtimeMetadata, shutdownTimeoutMs);
+}
+function assertControllerOptionIsExclusive(options) {
+	const ignoredKeys = Object.entries(options).filter(([key, value]) => key !== "enabled" && key !== "controller" && value !== undefined).map(([key]) => key);
+	if (ignoredKeys.length === 0) return;
+	throw new Error(`WebSocket telemetry controller option cannot be combined with other telemetry options: ${ignoredKeys.join(", ")}`);
+}
+function createWebSocketTelemetryController(telemetryOption, runtimeMetadata) {
+	if (telemetryOption === undefined || telemetryOption === false) {
+		return new NoopWebSocketTelemetryController();
+	}
+	if (telemetryOption === true) {
+		return buildController({}, runtimeMetadata);
+	}
+	if (telemetryOption.enabled === false) {
+		return new NoopWebSocketTelemetryController();
+	}
+	if (telemetryOption.controller) {
+		assertControllerOptionIsExclusive(telemetryOption);
+		return telemetryOption.controller;
+	}
+	return buildController(telemetryOption, runtimeMetadata);
+}
+var EMPTY_METRICS_SNAPSHOT, DEFAULT_TRACE_OPTIONS, DEFAULT_MAX_RECORDS_PER_SECOND, DEFAULT_SHUTDOWN_TIMEOUT_MS, DEFAULT_EVENT_SAMPLING_DEFAULT_RATE, DEFAULT_EVENT_ALWAYS_RECORD_LEVELS, DEFAULT_EVENT_CAPTURE_PAYLOAD, DEFAULT_EVENT_MAX_PAYLOAD_PREVIEW_BYTES, DEFAULT_METRIC_COLLECTION_ENABLED, DEFAULT_METRIC_SAMPLE_INTERVAL_MS, DEFAULT_SPAN_SAMPLING_DEFAULT_RATE, DEFAULT_MAX_IN_FLIGHT_EMITS_PER_SINK, SENSITIVE_KEY_PATTERNS, REDACTED_VALUE, TokenBucket, noopUnsubscribe, NoopWebSocketTelemetryController, TelemetryPipeline, EventPipeline, MetricPipeline, SpanPipeline, WebSocketTelemetryControllerImpl;
+var init_ws_telemetry = __esmMin((() => {
+	init_ws_telemetry_memory();
+	init_ws_telemetry_trace();
+	EMPTY_METRICS_SNAPSHOT = {
+		timestamp: 0,
+		activeConnections: 0,
+		activeConnectionsByNamespace: {},
+		roomCount: 0,
+		pendingInboundMessages: 0,
+		pendingOutboundMessages: 0,
+		socketBufferedBytes: 0,
+		pendingFanOutJobs: 0,
+		pendingFanOutTargets: 0,
+		telemetryDroppedRecords: 0,
+		telemetrySinkFailures: 0
+	};
+	DEFAULT_TRACE_OPTIONS = {
+		extractTraceParent: true,
+		generateConnectionTrace: true,
+		propagateMessageTrace: true,
+		recordConnectionLifetimeSpan: false
+	};
+	DEFAULT_MAX_RECORDS_PER_SECOND = 1e4;
+	DEFAULT_SHUTDOWN_TIMEOUT_MS = 2e3;
+	DEFAULT_EVENT_SAMPLING_DEFAULT_RATE = 1;
+	DEFAULT_EVENT_ALWAYS_RECORD_LEVELS = ["warn", "error"];
+	DEFAULT_EVENT_CAPTURE_PAYLOAD = false;
+	DEFAULT_EVENT_MAX_PAYLOAD_PREVIEW_BYTES = 1024;
+	DEFAULT_METRIC_COLLECTION_ENABLED = true;
+	DEFAULT_METRIC_SAMPLE_INTERVAL_MS = 1e4;
+	DEFAULT_SPAN_SAMPLING_DEFAULT_RATE = 1;
+	DEFAULT_MAX_IN_FLIGHT_EMITS_PER_SINK = 100;
+	SENSITIVE_KEY_PATTERNS = [
+		"authorization",
+		"cookie",
+		"token",
+		"password",
+		"secret",
+		"apikey",
+		"session",
+		"email"
+	];
+	REDACTED_VALUE = "[redacted]";
+	TokenBucket = class {
+		tokens;
+		lastRefill;
+		constructor(maxTokens, refillRate) {
+			this.maxTokens = maxTokens;
+			this.refillRate = refillRate;
+			this.tokens = maxTokens;
+			this.lastRefill = Date.now();
+		}
+		tryConsume() {
+			this.refill();
+			if (this.tokens < 1) return false;
+			this.tokens -= 1;
+			return true;
+		}
+		refill() {
+			const now = Date.now();
+			const elapsed = (now - this.lastRefill) / 1e3;
+			this.tokens = Math.min(this.maxTokens, this.tokens + elapsed * this.refillRate);
+			this.lastRefill = now;
+		}
+	};
+	noopUnsubscribe = () => {};
+	NoopWebSocketTelemetryController = class {
+		emit(_input) {}
+		recordMetric(_input) {}
+		recordSpan(_input) {}
+		getMetricsSnapshot() {
+			return {
+				...EMPTY_METRICS_SNAPSHOT,
+				timestamp: Date.now()
+			};
+		}
+		getEventStore() {
+			return undefined;
+		}
+		getMetricStore() {
+			return undefined;
+		}
+		getSpanStore() {
+			return undefined;
+		}
+		registerMetricSource(_source) {
+			return noopUnsubscribe;
+		}
+		createConnectionContext(_request) {
+			return {};
+		}
+		getTraceOptions() {
+			return { ...DEFAULT_TRACE_OPTIONS };
+		}
+		shutdown(_options) {
+			return Promise.resolve();
+		}
+	};
+	TelemetryPipeline = class {
+		sinks;
+		_store;
+		tokenBucket;
+		maxInFlightEmits;
+		runtimeMetadata;
+		sharedRedactor;
+		sharedBeforeRecord;
+		internalEventReporter;
+		inFlightEmits = new WeakMap();
+		droppedCount = 0;
+		sinkFailureCount = 0;
+		shutdownCalled = false;
+		constructor(sinks, store, maxRecordsPerSecond, maxInFlightEmits, sharedRedactor, sharedBeforeRecord, runtimeMetadata) {
+			this.sinks = sinks;
+			this._store = store;
+			this.tokenBucket = new TokenBucket(maxRecordsPerSecond, maxRecordsPerSecond);
+			this.maxInFlightEmits = maxInFlightEmits;
+			this.sharedRedactor = sharedRedactor;
+			this.sharedBeforeRecord = sharedBeforeRecord;
+			this.runtimeMetadata = runtimeMetadata;
+		}
+		get store() {
+			return this._store;
+		}
+		setInternalEventReporter(reporter) {
+			this.internalEventReporter = reporter;
+		}
+		emitInternal(input) {
+			if (this.shutdownCalled) return;
+			let record;
+			try {
+				record = this.buildRecord(input);
+			} catch {
+				this.droppedCount += 1;
+				return;
+			}
+			const skipRateLimit = this.shouldBypassRateLimit(record);
+			if (!skipRateLimit && !this.tokenBucket.tryConsume()) {
+				this.droppedCount += 1;
+				return;
+			}
+			let prepared;
+			try {
+				const afterDefault = defaultSensitiveKeyRedact(record);
+				if (afterDefault.type !== record.type) {
+					this.droppedCount += 1;
+					return;
+				}
+				prepared = afterDefault;
+			} catch {
+				this.droppedCount += 1;
+				return;
+			}
+			if (this.sharedRedactor !== undefined) {
+				const sharedRedactor = this.sharedRedactor;
+				const result = this.applyTransform(prepared, (r) => sharedRedactor(r), "shared", "redactor");
+				if (result === null) return;
+				prepared = result;
+			}
+			const signalRedactor = this.getSignalRedactor();
+			if (signalRedactor !== undefined) {
+				const result = this.applyTransform(prepared, (r) => signalRedactor(r), "signal", "redactor");
+				if (result === null) return;
+				prepared = result;
+			}
+			if (this.sharedBeforeRecord !== undefined) {
+				const sharedBeforeRecord = this.sharedBeforeRecord;
+				const result = this.applyTransform(prepared, (r) => sharedBeforeRecord(r), "shared", "beforeRecord");
+				if (result === null) return;
+				prepared = result;
+			}
+			const signalBeforeRecord = this.getSignalBeforeRecord();
+			if (signalBeforeRecord !== undefined) {
+				const result = this.applyTransform(prepared, (r) => signalBeforeRecord(r), "signal", "beforeRecord");
+				if (result === null) return;
+				prepared = result;
+			}
+			this.dispatchToSinks(prepared);
+		}
+		applyTransform(record, runner, source, kind) {
+			let result;
+			try {
+				result = runner(record);
+			} catch {
+				this.droppedCount += 1;
+				return null;
+			}
+			if (result === null) {
+				this.droppedCount += 1;
+				return null;
+			}
+			if (result.type !== record.type) {
+				this.droppedCount += 1;
+				const eventName = kind === "redactor" ? "ws.telemetry.redactor.type_mismatch" : "ws.telemetry.beforeRecord.type_mismatch";
+				this.dispatchInternalEvent(eventName, "warn", {
+					expected: record.type,
+					actual: result.type,
+					source
+				});
+				return null;
+			}
+			return result;
+		}
+		dispatchToSinks(record, selfObserveFailures = true) {
+			const critical = this.isCriticalRecord(record);
+			let droppedForRecord = false;
+			for (const sink of this.sinks) {
+				const inFlight = this.inFlightEmits.get(sink) ?? 0;
+				if (!critical && inFlight >= this.maxInFlightEmits) {
+					if (!droppedForRecord) {
+						this.droppedCount += 1;
+						droppedForRecord = true;
+					}
+					continue;
+				}
+				try {
+					const result = sink.emit(record);
+					if (isPromiseLike(result)) {
+						this.inFlightEmits.set(sink, inFlight + 1);
+						result.then(() => {
+							this.decrementInFlightEmit(sink);
+						}, (error) => {
+							this.decrementInFlightEmit(sink);
+							this.observeSinkFailure("emit", error, selfObserveFailures);
+						});
+					}
+				} catch (error) {
+					this.observeSinkFailure("emit", error, selfObserveFailures);
+				}
+			}
+		}
+		decrementInFlightEmit(sink) {
+			const current = this.inFlightEmits.get(sink) ?? 0;
+			if (current <= 1) {
+				this.inFlightEmits.delete(sink);
+				return;
+			}
+			this.inFlightEmits.set(sink, current - 1);
+		}
+		observeSinkFailure(phase, error, selfObserveFailure) {
+			this.sinkFailureCount += 1;
+			if (!selfObserveFailure) return;
+			this.dispatchInternalEvent("ws.telemetry.sink.failed", "warn", {
+				phase,
+				signal: this.signal,
+				errorType: error instanceof Error ? error.name : typeof error
+			});
+		}
+		dispatchInternalEvent(name, level, detail) {
+			if (this.internalEventReporter === undefined) return;
+			try {
+				this.internalEventReporter(name, level, detail);
+			} catch {}
+		}
+		async shutdown(timeoutMs) {
+			if (this.shutdownCalled) return;
+			this.shutdownCalled = true;
+			const sinkShutdowns = this.sinks.map((sink) => this.shutdownSink(sink, timeoutMs));
+			if (sinkShutdowns.length > 0) {
+				await Promise.allSettled(sinkShutdowns);
+			}
+		}
+		async shutdownSink(sink, timeoutMs) {
+			if (!sink.shutdown) return;
+			try {
+				const result = sink.shutdown({ timeoutMs });
+				if (!isPromiseLike(result)) return;
+				let timeout = null;
+				const shutdownPromise = result.then(() => "completed", (error) => {
+					throw error;
+				});
+				const timeoutPromise = new Promise((resolve) => {
+					timeout = setTimeout(() => {
+						resolve("timeout");
+					}, timeoutMs);
+				});
+				const outcome = await Promise.race([shutdownPromise, timeoutPromise]);
+				if (timeout) {
+					clearTimeout(timeout);
+				}
+				if (outcome === "timeout") {
+					shutdownPromise.catch(() => {});
+					this.sinkFailureCount += 1;
+					this.dispatchInternalEvent("ws.telemetry.shutdown.timeout", "warn", {
+						timeoutMs,
+						signal: this.signal
+					});
+				}
+			} catch (error) {
+				this.observeSinkFailure("shutdown", error, true);
+			}
+		}
+	};
+	EventPipeline = class extends TelemetryPipeline {
+		signal = "event";
+		signalRedactor;
+		signalBeforeRecord;
+		sampling;
+		capturePayload;
+		maxPayloadPreviewBytes;
+		currentEmitAlwaysRecord = false;
+		constructor(options, runtimeMetadata) {
+			super(options.sinks, options.store, options.maxRecordsPerSecond, options.maxInFlightEmits, options.sharedRedactor, options.sharedBeforeRecord, runtimeMetadata);
+			this.signalRedactor = options.signalRedactor;
+			this.signalBeforeRecord = options.signalBeforeRecord;
+			this.sampling = options.sampling;
+			this.capturePayload = options.capturePayload;
+			this.maxPayloadPreviewBytes = options.maxPayloadPreviewBytes;
+		}
+		emit(input) {
+			try {
+				if (this.shutdownCalled) return;
+				const levels = this.sampling.alwaysRecordLevels;
+				const alwaysRecord = levels.includes(input.level);
+				if (!alwaysRecord) {
+					const rate = this.sampling.rateByEvent[input.name] ?? this.sampling.defaultRate;
+					if (rate <= 0) {
+						this.droppedCount += 1;
+						return;
+					}
+					if (rate < 1 && Math.random() >= rate) {
+						this.droppedCount += 1;
+						return;
+					}
+				}
+				this.currentEmitAlwaysRecord = alwaysRecord;
+				try {
+					this.emitInternal(input);
+				} finally {
+					this.currentEmitAlwaysRecord = false;
+				}
+			} catch {}
+		}
+		dispatchInternalDiagnosticEvent(name, level, detail) {
+			const record = {
+				type: "event",
+				timestamp: Date.now(),
+				monotonicTime: performance.now(),
+				runtimeId: this.runtimeMetadata.runtimeId,
+				nodeId: this.runtimeMetadata.nodeId,
+				name,
+				level,
+				detail
+			};
+			try {
+				const sanitized = defaultSensitiveKeyRedact(record);
+				if (sanitized.type !== "event") return;
+				this.dispatchToSinks(sanitized, false);
+			} catch {}
+		}
+		buildRecord(input) {
+			let record = {
+				type: "event",
+				timestamp: Date.now(),
+				monotonicTime: performance.now(),
+				runtimeId: this.runtimeMetadata.runtimeId,
+				nodeId: this.runtimeMetadata.nodeId,
+				name: input.name,
+				level: input.level,
+				namespace: input.namespace,
+				connectionId: input.connectionId,
+				userId: input.userId,
+				attributes: input.attributes,
+				detail: input.detail,
+				traceId: input.traceId,
+				spanId: input.spanId,
+				parentSpanId: input.parentSpanId,
+				sampled: input.sampled
+			};
+			if (this.capturePayload === "preview" && input.payload !== undefined) {
+				record = {
+					...record,
+					payloadPreview: truncatePayloadPreview(input.payload, this.maxPayloadPreviewBytes)
+				};
+			}
+			return record;
+		}
+		shouldBypassRateLimit(_record) {
+			return this.currentEmitAlwaysRecord;
+		}
+		isCriticalRecord(record) {
+			return record.level === "warn" || record.level === "error";
+		}
+		getSignalRedactor() {
+			return this.signalRedactor;
+		}
+		getSignalBeforeRecord() {
+			return this.signalBeforeRecord;
+		}
+	};
+	MetricPipeline = class extends TelemetryPipeline {
+		signal = "metric";
+		signalRedactor;
+		signalBeforeRecord;
+		metricSources = new Set();
+		collectionEnabled;
+		sampleIntervalMs;
+		collectionInterval = null;
+		snapshotProvider;
+		constructor(options, runtimeMetadata) {
+			super(options.sinks, options.store, options.maxRecordsPerSecond, options.maxInFlightEmits, options.sharedRedactor, options.sharedBeforeRecord, runtimeMetadata);
+			this.signalRedactor = options.signalRedactor;
+			this.signalBeforeRecord = options.signalBeforeRecord;
+			this.collectionEnabled = options.collectionEnabled;
+			this.sampleIntervalMs = options.sampleIntervalMs;
+			if (this.collectionEnabled && this.sampleIntervalMs > 0) {
+				this.collectionInterval = setInterval(() => {
+					this.collectAndEmit();
+				}, this.sampleIntervalMs);
+				if (this.collectionInterval && typeof this.collectionInterval === "object" && "unref" in this.collectionInterval) {
+					this.collectionInterval.unref();
+				}
+			}
+		}
+		emit(input) {
+			try {
+				this.emitInternal(input);
+			} catch {}
+		}
+		buildRecord(input) {
+			return {
+				type: "metric",
+				timestamp: Date.now(),
+				monotonicTime: performance.now(),
+				runtimeId: this.runtimeMetadata.runtimeId,
+				nodeId: this.runtimeMetadata.nodeId,
+				name: input.name,
+				kind: input.kind,
+				value: input.value,
+				unit: input.unit,
+				tags: input.tags,
+				namespace: input.namespace,
+				connectionId: input.connectionId,
+				userId: input.userId,
+				traceId: input.traceId,
+				spanId: input.spanId,
+				parentSpanId: input.parentSpanId,
+				sampled: input.sampled,
+				snapshot: input.snapshot
+			};
+		}
+		shouldBypassRateLimit(record) {
+			const outcome = record.tags?.outcome;
+			if (outcome === "failed" || outcome === "rejected" || outcome === "dropped") {
+				return true;
+			}
+			return record.name.endsWith(".failures") || record.name.endsWith(".failure") || record.name.endsWith(".dropped") || record.name.includes(".failures.") || record.name.includes(".dropped.");
+		}
+		isCriticalRecord(record) {
+			return this.shouldBypassRateLimit(record);
+		}
+		getSignalRedactor() {
+			return this.signalRedactor;
+		}
+		getSignalBeforeRecord() {
+			return this.signalBeforeRecord;
+		}
+		registerMetricSource(source) {
+			this.metricSources.add(source);
+			return () => {
+				this.metricSources.delete(source);
+			};
+		}
+		setSnapshotProvider(provider) {
+			this.snapshotProvider = provider;
+		}
+		getSnapshot() {
+			const now = Date.now();
+			const base = {
+				...EMPTY_METRICS_SNAPSHOT,
+				timestamp: now,
+				activeConnectionsByNamespace: {},
+				telemetryDroppedRecords: this.droppedCount,
+				telemetrySinkFailures: this.sinkFailureCount
+			};
+			for (const source of this.metricSources) {
+				try {
+					const partial = source.collect(now);
+					base.activeConnections += partial.activeConnections ?? 0;
+					base.roomCount += partial.roomCount ?? 0;
+					base.pendingInboundMessages += partial.pendingInboundMessages ?? 0;
+					base.pendingOutboundMessages += partial.pendingOutboundMessages ?? 0;
+					base.socketBufferedBytes += partial.socketBufferedBytes ?? 0;
+					base.pendingFanOutJobs += partial.pendingFanOutJobs ?? 0;
+					base.pendingFanOutTargets += partial.pendingFanOutTargets ?? 0;
+					if (partial.activeConnectionsByNamespace) {
+						for (const [ns, count] of Object.entries(partial.activeConnectionsByNamespace)) {
+							base.activeConnectionsByNamespace[ns] = (base.activeConnectionsByNamespace[ns] ?? 0) + count;
+						}
+					}
+				} catch {}
+			}
+			return base;
+		}
+		collectAndEmit() {
+			try {
+				if (this.shutdownCalled) return;
+				const snapshot = this.snapshotProvider?.() ?? this.getSnapshot();
+				const input = {
+					name: "ws.connections.active",
+					kind: "gauge",
+					value: snapshot.activeConnections,
+					unit: "1",
+					snapshot
+				};
+				this.emit(input);
+			} catch {}
+		}
+		async shutdown(timeoutMs) {
+			if (this.collectionInterval !== null) {
+				clearInterval(this.collectionInterval);
+				this.collectionInterval = null;
+			}
+			await super.shutdown(timeoutMs);
+		}
+	};
+	SpanPipeline = class extends TelemetryPipeline {
+		signal = "span";
+		signalRedactor;
+		signalBeforeRecord;
+		sampling;
+		constructor(options, runtimeMetadata) {
+			super(options.sinks, options.store, options.maxRecordsPerSecond, options.maxInFlightEmits, options.sharedRedactor, options.sharedBeforeRecord, runtimeMetadata);
+			this.signalRedactor = options.signalRedactor;
+			this.signalBeforeRecord = options.signalBeforeRecord;
+			this.sampling = { defaultRate: options.sampling.defaultRate };
+		}
+		emit(input) {
+			try {
+				if (this.shutdownCalled) return;
+				if (input.status !== "error") {
+					const rate = this.sampling.defaultRate;
+					if (rate <= 0) {
+						this.droppedCount += 1;
+						return;
+					}
+					if (rate < 1 && Math.random() >= rate) {
+						this.droppedCount += 1;
+						return;
+					}
+				}
+				this.emitInternal(input);
+			} catch {}
+		}
+		buildRecord(input) {
+			return {
+				type: "span",
+				timestamp: Date.now(),
+				monotonicTime: performance.now(),
+				runtimeId: this.runtimeMetadata.runtimeId,
+				nodeId: this.runtimeMetadata.nodeId,
+				operationName: input.operationName,
+				kind: input.kind,
+				durationMs: input.durationMs,
+				status: input.status,
+				namespace: input.namespace,
+				connectionId: input.connectionId,
+				userId: input.userId,
+				attributes: input.attributes,
+				errorType: input.errorType,
+				traceId: input.traceId,
+				spanId: input.spanId,
+				parentSpanId: input.parentSpanId,
+				sampled: input.sampled,
+				events: input.events,
+				links: input.links
+			};
+		}
+		shouldBypassRateLimit(record) {
+			return record.status === "error";
+		}
+		isCriticalRecord(record) {
+			return record.status === "error";
+		}
+		getSignalRedactor() {
+			return this.signalRedactor;
+		}
+		getSignalBeforeRecord() {
+			return this.signalBeforeRecord;
+		}
+	};
+	WebSocketTelemetryControllerImpl = class {
+		events;
+		metrics;
+		spans;
+		runtimeId;
+		nodeId;
+		traceOptions;
+		shutdownTimeoutMs;
+		shutdownCalled = false;
+		constructor(events, metrics, spans, traceOptions, runtimeMetadata, shutdownTimeoutMs) {
+			this.events = events;
+			this.metrics = metrics;
+			this.spans = spans;
+			this.traceOptions = traceOptions;
+			this.runtimeId = runtimeMetadata.runtimeId;
+			this.nodeId = runtimeMetadata.nodeId;
+			this.shutdownTimeoutMs = shutdownTimeoutMs;
+			const reporter = (name, level, detail) => {
+				this.events.dispatchInternalDiagnosticEvent(name, level, detail);
+			};
+			this.events.setInternalEventReporter(reporter);
+			this.metrics.setInternalEventReporter(reporter);
+			this.spans.setInternalEventReporter(reporter);
+			this.metrics.setSnapshotProvider(() => this.getMetricsSnapshot());
+		}
+		emit(input) {
+			try {
+				if (this.shutdownCalled) return;
+				this.events.emit(input);
+			} catch {}
+		}
+		recordMetric(input) {
+			try {
+				if (this.shutdownCalled) return;
+				this.metrics.emit(input);
+			} catch {}
+		}
+		recordSpan(input) {
+			try {
+				if (this.shutdownCalled) return;
+				this.spans.emit(input);
+			} catch {}
+		}
+		getMetricsSnapshot() {
+			try {
+				const base = this.metrics.getSnapshot();
+				base.telemetryDroppedRecords = this.events.droppedCount + this.metrics.droppedCount + this.spans.droppedCount;
+				base.telemetrySinkFailures = this.events.sinkFailureCount + this.metrics.sinkFailureCount + this.spans.sinkFailureCount;
+				return base;
+			} catch {
+				return {
+					...EMPTY_METRICS_SNAPSHOT,
+					timestamp: Date.now()
+				};
+			}
+		}
+		getEventStore() {
+			try {
+				return this.events.store;
+			} catch {
+				return undefined;
+			}
+		}
+		getMetricStore() {
+			try {
+				return this.metrics.store;
+			} catch {
+				return undefined;
+			}
+		}
+		getSpanStore() {
+			try {
+				return this.spans.store;
+			} catch {
+				return undefined;
+			}
+		}
+		registerMetricSource(source) {
+			try {
+				return this.metrics.registerMetricSource(source);
+			} catch {
+				return noopUnsubscribe;
+			}
+		}
+		createConnectionContext(request) {
+			try {
+				if (this.traceOptions.extractTraceParent && request?.headers) {
+					const traceparentHeader = request.headers["traceparent"];
+					const traceparentValue = Array.isArray(traceparentHeader) ? traceparentHeader[0] : traceparentHeader;
+					if (traceparentValue) {
+						const parsed = parseTraceParent(traceparentValue);
+						if (parsed) {
+							const context = {
+								traceId: parsed.traceId,
+								parentSpanId: parsed.parentId,
+								sampled: parsed.sampled
+							};
+							if (this.traceOptions.generateConnectionTrace) {
+								context.spanId = generateSpanId();
+							}
+							return { ...context };
+						}
+					}
+				}
+				if (!this.traceOptions.generateConnectionTrace) {
+					return {};
+				}
+				return {
+					traceId: generateTraceId(),
+					spanId: generateSpanId()
+				};
+			} catch {
+				return {};
+			}
+		}
+		getTraceOptions() {
+			return { ...this.traceOptions };
+		}
+		async shutdown(options) {
+			if (this.shutdownCalled) return;
+			this.shutdownCalled = true;
+			const timeoutMs = options?.timeoutMs ?? this.shutdownTimeoutMs;
+			try {
+				await Promise.allSettled([
+					this.events.shutdown(timeoutMs),
+					this.metrics.shutdown(timeoutMs),
+					this.spans.shutdown(timeoutMs)
+				]);
+			} catch {}
+		}
+	};
+}));
+
+//#endregion
+init_ws_telemetry();
+export { DEFAULT_TRACE_OPTIONS, EMPTY_METRICS_SNAPSHOT, NoopWebSocketTelemetryController, WebSocketTelemetryControllerImpl, createWebSocketTelemetryController, init_ws_telemetry, isPromiseLike };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ws-telemetry.js","names":["redacted: Record<string, unknown>","eventSinks: WebSocketTelemetryEventSink[]","eventStore: WebSocketTelemetryEventStore | undefined","eventsResolved: ResolvedEventPipelineOptions","metricSinks: WebSocketTelemetryMetricSink[]","metricStore: WebSocketTelemetryMetricStore | undefined","metricsResolved: ResolvedMetricPipelineOptions","spanSinks: WebSocketTelemetrySpanSink[]","spanStore: WebSocketTelemetrySpanStore | undefined","spansResolved: ResolvedSpanPipelineOptions","traceOptions: WebSocketTelemetryTraceOptions","EMPTY_METRICS_SNAPSHOT: WebSocketTelemetryMetricsSnapshot","DEFAULT_TRACE_OPTIONS: WebSocketTelemetryTraceOptions","DEFAULT_EVENT_ALWAYS_RECORD_LEVELS: ReadonlyArray<\"warn\" | \"error\">","DEFAULT_EVENT_CAPTURE_PAYLOAD: false | \"preview\"","maxTokens: number","refillRate: number","record: TRecord","prepared: TRecord","result: WebSocketTelemetryRecord | null","timeout: ReturnType<typeof setTimeout> | null","levels: ReadonlyArray<string>","record: WebSocketTelemetryEventRecord","base: WebSocketTelemetryMetricsSnapshot","input: WebSocketMetricInput","reporter: InternalEventReporter","context: WebSocketTelemetryConnectionContext"],"sources":["../../src/stream/ws-telemetry.ts"],"sourcesContent":["import { InMemoryEventStore, InMemoryMetricStore, InMemorySpanStore } from \"./ws-telemetry-memory\";\nimport { generateSpanId, generateTraceId, parseTraceParent } from \"./ws-telemetry-trace\";\n\n// -- Record types (unchanged) --\n\nexport type WebSocketTelemetryRecordBase = {\n  timestamp: number;\n  monotonicTime?: number;\n  runtimeId: string;\n  nodeId: string;\n  namespace?: string;\n  connectionId?: string;\n  // userId는 connection 소유자를 식별하기 위한 opaque identifier (보통 DB PK)\n  // pseudonymous identifier로만 사용하며, 이메일/전화번호 등 PII는 들어가지 않는다고 가정함\n  userId?: string;\n  traceId?: string;\n  spanId?: string;\n  parentSpanId?: string;\n  sampled?: boolean;\n};\n\nexport type WebSocketTelemetryEventRecord = WebSocketTelemetryRecordBase & {\n  type: \"event\";\n  name: string;\n  level: \"debug\" | \"info\" | \"warn\" | \"error\";\n  attributes?: Record<string, string | number | boolean>;\n  detail?: Record<string, unknown>;\n  payloadPreview?: string;\n};\n\nexport type WebSocketTelemetryMetricRecord = WebSocketTelemetryRecordBase & {\n  type: \"metric\";\n  name: string;\n  kind: \"counter\" | \"histogram\" | \"gauge\";\n  value: number;\n  unit?: \"1\" | \"ms\" | \"By\";\n  tags?: Record<string, string>;\n  snapshot?: WebSocketTelemetryMetricsSnapshot;\n};\n\nexport type WebSocketTelemetrySpanRecord = WebSocketTelemetryRecordBase & {\n  type: \"span\";\n  operationName: string;\n  kind: \"internal\" | \"producer\" | \"consumer\" | \"server\" | \"client\";\n  durationMs: number;\n  status: \"unset\" | \"ok\" | \"error\";\n  attributes?: Record<string, string | number | boolean>;\n  errorType?: string;\n  events?: Array<{\n    name: string;\n    timestamp: number;\n    attributes?: Record<string, unknown>;\n  }>;\n  links?: Array<{\n    traceId: string;\n    spanId: string;\n    attributes?: Record<string, unknown>;\n  }>;\n};\n\nexport type WebSocketTelemetryRecord =\n  | WebSocketTelemetryEventRecord\n  | WebSocketTelemetryMetricRecord\n  | WebSocketTelemetrySpanRecord;\n\n// -- Input types (unchanged) --\n\nexport type WebSocketTelemetryEventInput = {\n  name: string;\n  level: \"debug\" | \"info\" | \"warn\" | \"error\";\n  namespace?: string;\n  connectionId?: string;\n  userId?: string;\n  attributes?: Record<string, string | number | boolean>;\n  detail?: Record<string, unknown>;\n  payload?: unknown;\n  traceId?: string;\n  spanId?: string;\n  parentSpanId?: string;\n  sampled?: boolean;\n};\n\nexport type WebSocketMetricInput = {\n  name: string;\n  kind: \"counter\" | \"histogram\" | \"gauge\";\n  value: number;\n  unit?: \"1\" | \"ms\" | \"By\";\n  tags?: Record<string, string>;\n  namespace?: string;\n  connectionId?: string;\n  userId?: string;\n  traceId?: string;\n  spanId?: string;\n  parentSpanId?: string;\n  sampled?: boolean;\n  snapshot?: WebSocketTelemetryMetricsSnapshot;\n};\n\nexport type WebSocketSpanInput = {\n  operationName: string;\n  kind: \"internal\" | \"producer\" | \"consumer\" | \"server\" | \"client\";\n  durationMs: number;\n  status: \"unset\" | \"ok\" | \"error\";\n  namespace?: string;\n  connectionId?: string;\n  userId?: string;\n  attributes?: Record<string, string | number | boolean>;\n  errorType?: string;\n  traceId?: string;\n  spanId?: string;\n  parentSpanId?: string;\n  sampled?: boolean;\n  events?: Array<{\n    name: string;\n    timestamp: number;\n    attributes?: Record<string, unknown>;\n  }>;\n  links?: Array<{\n    traceId: string;\n    spanId: string;\n    attributes?: Record<string, unknown>;\n  }>;\n};\n\nexport type WebSocketTelemetryInput =\n  | ({ type: \"event\" } & WebSocketTelemetryEventInput)\n  | ({ type: \"metric\" } & WebSocketMetricInput)\n  | ({ type: \"span\" } & WebSocketSpanInput);\n\n// -- Metrics snapshot --\n\nexport type WebSocketTelemetryMetricsSnapshot = {\n  timestamp: number;\n  activeConnections: number;\n  activeConnectionsByNamespace: Record<string, number>;\n  roomCount: number;\n  pendingInboundMessages: number;\n  pendingOutboundMessages: number;\n  socketBufferedBytes: number;\n  pendingFanOutJobs: number;\n  pendingFanOutTargets: number;\n  telemetryDroppedRecords: number;\n  telemetrySinkFailures: number;\n};\n\n// -- Connection snapshot (TelemetryInspectableConnection) --\n\nexport type WebSocketTelemetryConnectionSnapshot = {\n  pendingInboundMessages: number;\n  pendingOutboundMessages: number;\n  socketBufferedBytes: number;\n};\n\nexport interface TelemetryInspectableConnection {\n  getTelemetrySnapshot(): WebSocketTelemetryConnectionSnapshot;\n}\n\n// -- Signal-narrowed sinks --\n\nexport interface WebSocketTelemetryEventSink {\n  emit(record: WebSocketTelemetryEventRecord): void | Promise<void>;\n  shutdown?(options?: { timeoutMs?: number }): void | Promise<void>;\n}\n\nexport interface WebSocketTelemetryMetricSink {\n  emit(record: WebSocketTelemetryMetricRecord): void | Promise<void>;\n  shutdown?(options?: { timeoutMs?: number }): void | Promise<void>;\n}\n\nexport interface WebSocketTelemetrySpanSink {\n  emit(record: WebSocketTelemetrySpanRecord): void | Promise<void>;\n  shutdown?(options?: { timeoutMs?: number }): void | Promise<void>;\n}\n\n// -- Signal-narrowed query filters --\n\nexport type WebSocketTelemetryEventQueryFilter = {\n  name?: string;\n  level?: \"debug\" | \"info\" | \"warn\" | \"error\";\n  connectionId?: string;\n  userId?: string;\n  namespace?: string;\n  traceId?: string;\n  since?: number;\n  until?: number;\n  limit?: number;\n};\n\nexport type WebSocketTelemetryMetricQueryFilter = {\n  name?: string;\n  kind?: \"counter\" | \"histogram\" | \"gauge\";\n  connectionId?: string;\n  userId?: string;\n  namespace?: string;\n  traceId?: string;\n  since?: number;\n  until?: number;\n  limit?: number;\n};\n\nexport type WebSocketTelemetrySpanQueryFilter = {\n  operationName?: string;\n  kind?: \"internal\" | \"producer\" | \"consumer\" | \"server\" | \"client\";\n  status?: \"unset\" | \"ok\" | \"error\";\n  connectionId?: string;\n  userId?: string;\n  namespace?: string;\n  traceId?: string;\n  since?: number;\n  until?: number;\n  limit?: number;\n};\n\n// -- Signal-narrowed stores --\n\nexport interface WebSocketTelemetryEventStore {\n  readonly sink: WebSocketTelemetryEventSink;\n  query(filter: WebSocketTelemetryEventQueryFilter): WebSocketTelemetryEventRecord[];\n  clear(): void;\n}\n\nexport interface WebSocketTelemetryMetricStore {\n  readonly sink: WebSocketTelemetryMetricSink;\n  query(filter: WebSocketTelemetryMetricQueryFilter): WebSocketTelemetryMetricRecord[];\n  clear(): void;\n}\n\nexport interface WebSocketTelemetrySpanStore {\n  readonly sink: WebSocketTelemetrySpanSink;\n  query(filter: WebSocketTelemetrySpanQueryFilter): WebSocketTelemetrySpanRecord[];\n  clear(): void;\n}\n\n// -- Metric source interface (unchanged) --\n\nexport interface WebSocketTelemetryMetricSource {\n  collect(now: number): Partial<WebSocketTelemetryMetricsSnapshot>;\n}\n\n// -- Redactor / beforeRecord types (signal-narrowed + shared) --\n\nexport type WebSocketTelemetryEventRedactor = (\n  record: WebSocketTelemetryEventRecord,\n) => WebSocketTelemetryEventRecord | null;\n\nexport type WebSocketTelemetryMetricRedactor = (\n  record: WebSocketTelemetryMetricRecord,\n) => WebSocketTelemetryMetricRecord | null;\n\nexport type WebSocketTelemetrySpanRedactor = (\n  record: WebSocketTelemetrySpanRecord,\n) => WebSocketTelemetrySpanRecord | null;\n\nexport type WebSocketTelemetryRedactor = (\n  record: WebSocketTelemetryRecord,\n) => WebSocketTelemetryRecord | null;\n\nexport type WebSocketTelemetryEventBeforeRecord = (\n  record: WebSocketTelemetryEventRecord,\n) => WebSocketTelemetryEventRecord | null;\n\nexport type WebSocketTelemetryMetricBeforeRecord = (\n  record: WebSocketTelemetryMetricRecord,\n) => WebSocketTelemetryMetricRecord | null;\n\nexport type WebSocketTelemetrySpanBeforeRecord = (\n  record: WebSocketTelemetrySpanRecord,\n) => WebSocketTelemetrySpanRecord | null;\n\nexport type WebSocketTelemetryBeforeRecord = (\n  record: WebSocketTelemetryRecord,\n) => WebSocketTelemetryRecord | null;\n\n// -- Trace options / connection context --\n\nexport type WebSocketTelemetryTraceOptions = {\n  extractTraceParent: boolean;\n  generateConnectionTrace: boolean;\n  propagateMessageTrace: boolean;\n  recordConnectionLifetimeSpan: boolean;\n};\n\nexport type WebSocketTelemetryConnectionContext = {\n  traceId?: string;\n  spanId?: string;\n  parentSpanId?: string;\n  sampled?: boolean;\n};\n\nexport interface TelemetryContextProvider {\n  getTelemetryContext(): WebSocketTelemetryConnectionContext;\n}\n\n// -- Options schema --\n\nexport type WebSocketTelemetryEventSamplingOptions = {\n  defaultRate?: number;\n  rateByEvent?: Record<string, number>;\n  maxRecordsPerSecond?: number;\n  alwaysRecordLevels?: Array<\"warn\" | \"error\">;\n};\n\nexport type WebSocketTelemetryMetricSamplingOptions = {\n  maxRecordsPerSecond?: number;\n};\n\nexport type WebSocketTelemetrySpanSamplingOptions = {\n  defaultRate?: number;\n  maxRecordsPerSecond?: number;\n};\n\nexport type WebSocketTelemetryDefaultsOptions = {\n  redactor?: WebSocketTelemetryRedactor;\n  beforeRecord?: WebSocketTelemetryBeforeRecord;\n  maxRecords?: number;\n  maxBytes?: number;\n  maxRecordsPerSecond?: number;\n};\n\nexport type WebSocketTelemetryEventsOptions = {\n  sinks?: WebSocketTelemetryEventSink[];\n  store?: WebSocketTelemetryEventStore;\n  maxRecords?: number;\n  maxBytes?: number;\n  maxInFlightEmits?: number;\n  redactor?: WebSocketTelemetryEventRedactor | null;\n  beforeRecord?: WebSocketTelemetryEventBeforeRecord | null;\n  sampling?: WebSocketTelemetryEventSamplingOptions;\n  capturePayload?: false | \"preview\";\n  maxPayloadPreviewBytes?: number;\n};\n\nexport type WebSocketTelemetryMetricsOptions = {\n  sinks?: WebSocketTelemetryMetricSink[];\n  store?: WebSocketTelemetryMetricStore;\n  maxRecords?: number;\n  maxBytes?: number;\n  maxInFlightEmits?: number;\n  redactor?: WebSocketTelemetryMetricRedactor | null;\n  beforeRecord?: WebSocketTelemetryMetricBeforeRecord | null;\n  sampling?: WebSocketTelemetryMetricSamplingOptions;\n  collectionEnabled?: boolean;\n  sampleIntervalMs?: number;\n};\n\nexport type WebSocketTelemetrySpansOptions = {\n  sinks?: WebSocketTelemetrySpanSink[];\n  store?: WebSocketTelemetrySpanStore;\n  maxRecords?: number;\n  maxBytes?: number;\n  maxInFlightEmits?: number;\n  redactor?: WebSocketTelemetrySpanRedactor | null;\n  beforeRecord?: WebSocketTelemetrySpanBeforeRecord | null;\n  sampling?: WebSocketTelemetrySpanSamplingOptions;\n};\n\nexport type WebSocketTelemetryOptions = {\n  enabled?: boolean;\n  controller?: WebSocketTelemetryController;\n  defaults?: WebSocketTelemetryDefaultsOptions;\n  events?: WebSocketTelemetryEventsOptions;\n  metrics?: WebSocketTelemetryMetricsOptions;\n  spans?: WebSocketTelemetrySpansOptions;\n  trace?: Partial<WebSocketTelemetryTraceOptions>;\n  shutdownTimeoutMs?: number;\n};\n\n// -- Controller interface --\n\nexport interface WebSocketTelemetryController {\n  emit(input: WebSocketTelemetryEventInput): void;\n  recordMetric(input: WebSocketMetricInput): void;\n  recordSpan(input: WebSocketSpanInput): void;\n  getMetricsSnapshot(): WebSocketTelemetryMetricsSnapshot;\n  getEventStore(): WebSocketTelemetryEventStore | undefined;\n  getMetricStore(): WebSocketTelemetryMetricStore | undefined;\n  getSpanStore(): WebSocketTelemetrySpanStore | undefined;\n  registerMetricSource(source: WebSocketTelemetryMetricSource): () => void;\n  createConnectionContext(request?: {\n    headers?: Readonly<Record<string, string | string[] | undefined>>;\n  }): WebSocketTelemetryConnectionContext;\n  getTraceOptions(): WebSocketTelemetryTraceOptions;\n  shutdown(options?: { timeoutMs?: number }): Promise<void>;\n}\n\n// -- Constants and shared helpers (preserved-behavior) --\n\nexport const EMPTY_METRICS_SNAPSHOT: WebSocketTelemetryMetricsSnapshot = {\n  timestamp: 0,\n  activeConnections: 0,\n  activeConnectionsByNamespace: {},\n  roomCount: 0,\n  pendingInboundMessages: 0,\n  pendingOutboundMessages: 0,\n  socketBufferedBytes: 0,\n  pendingFanOutJobs: 0,\n  pendingFanOutTargets: 0,\n  telemetryDroppedRecords: 0,\n  telemetrySinkFailures: 0,\n};\n\nexport const DEFAULT_TRACE_OPTIONS: WebSocketTelemetryTraceOptions = {\n  extractTraceParent: true,\n  generateConnectionTrace: true,\n  propagateMessageTrace: true,\n  recordConnectionLifetimeSpan: false,\n};\n\nconst DEFAULT_MAX_RECORDS_PER_SECOND = 10_000;\nconst DEFAULT_SHUTDOWN_TIMEOUT_MS = 2_000;\nconst DEFAULT_EVENT_SAMPLING_DEFAULT_RATE = 1.0;\nconst DEFAULT_EVENT_ALWAYS_RECORD_LEVELS: ReadonlyArray<\"warn\" | \"error\"> = [\"warn\", \"error\"];\nconst DEFAULT_EVENT_CAPTURE_PAYLOAD: false | \"preview\" = false;\nconst DEFAULT_EVENT_MAX_PAYLOAD_PREVIEW_BYTES = 1024;\nconst DEFAULT_METRIC_COLLECTION_ENABLED = true;\nconst DEFAULT_METRIC_SAMPLE_INTERVAL_MS = 10_000;\nconst DEFAULT_SPAN_SAMPLING_DEFAULT_RATE = 1.0;\nconst DEFAULT_MAX_IN_FLIGHT_EMITS_PER_SINK = 100;\n\nconst SENSITIVE_KEY_PATTERNS = [\n  \"authorization\",\n  \"cookie\",\n  \"token\",\n  \"password\",\n  \"secret\",\n  \"apikey\",\n  \"session\",\n  \"email\",\n] as const;\nconst REDACTED_VALUE = \"[redacted]\";\n\nfunction isSensitiveKey(key: string): boolean {\n  const normalized = key.replace(/[^a-zA-Z0-9]/g, \"\").toLowerCase();\n  return SENSITIVE_KEY_PATTERNS.some((pattern) => normalized.includes(pattern));\n}\n\nfunction redactValue(value: unknown, key?: string): unknown {\n  if (key !== undefined && isSensitiveKey(key)) {\n    return REDACTED_VALUE;\n  }\n\n  if (Array.isArray(value)) {\n    return value.map((item) => redactValue(item));\n  }\n\n  if (value instanceof Date) {\n    return value;\n  }\n\n  if (value && typeof value === \"object\") {\n    const redacted: Record<string, unknown> = {};\n    for (const [childKey, childValue] of Object.entries(value)) {\n      redacted[childKey] = redactValue(childValue, childKey);\n    }\n    return redacted;\n  }\n\n  return value;\n}\n\n/**\n * defaultSensitiveKeyRedact — sensitive key 패턴 기반 built-in redactor.\n * pipeline emit flow의 첫 단계에서 항상 적용된다.\n */\nfunction defaultSensitiveKeyRedact(record: WebSocketTelemetryRecord): WebSocketTelemetryRecord {\n  if (record.type === \"event\") {\n    return {\n      ...record,\n      attributes: record.attributes\n        ? (redactValue(record.attributes) as WebSocketTelemetryEventRecord[\"attributes\"])\n        : undefined,\n      detail: record.detail\n        ? (redactValue(record.detail) as WebSocketTelemetryEventRecord[\"detail\"])\n        : undefined,\n      payloadPreview: record.payloadPreview,\n    };\n  }\n\n  if (record.type === \"metric\") {\n    return {\n      ...record,\n      tags: record.tags\n        ? (redactValue(record.tags) as WebSocketTelemetryMetricRecord[\"tags\"])\n        : undefined,\n      snapshot: record.snapshot ? { ...record.snapshot } : undefined,\n    };\n  }\n\n  return {\n    ...record,\n    attributes: record.attributes\n      ? (redactValue(record.attributes) as WebSocketTelemetrySpanRecord[\"attributes\"])\n      : undefined,\n    events: record.events?.map((event) => ({\n      ...event,\n      attributes: event.attributes\n        ? (redactValue(event.attributes) as Record<string, unknown>)\n        : undefined,\n    })),\n    links: record.links?.map((link) => ({\n      ...link,\n      attributes: link.attributes\n        ? (redactValue(link.attributes) as Record<string, unknown>)\n        : undefined,\n    })),\n  };\n}\n\nfunction truncatePayloadPreview(payload: unknown, maxBytes: number): string {\n  try {\n    const serialized = JSON.stringify(redactValue(payload));\n    if (Buffer.byteLength(serialized, \"utf-8\") <= maxBytes) {\n      return serialized;\n    }\n    return truncateUtf8String(serialized, maxBytes);\n  } catch {\n    return \"[unserializable]\";\n  }\n}\n\nfunction truncateUtf8String(value: string, maxBytes: number): string {\n  if (maxBytes <= 0) return \"\";\n\n  const suffix = maxBytes >= 3 ? \"...\" : \"\";\n  const contentBudget = maxBytes - Buffer.byteLength(suffix, \"utf-8\");\n  let result = \"\";\n  let usedBytes = 0;\n\n  for (const char of value) {\n    const charBytes = Buffer.byteLength(char, \"utf-8\");\n    if (usedBytes + charBytes > contentBudget) break;\n    result += char;\n    usedBytes += charBytes;\n  }\n\n  return result + suffix;\n}\n\nexport function isPromiseLike(value: unknown): value is Promise<void> {\n  return typeof value === \"object\" && value !== null && \"then\" in value && \"catch\" in value;\n}\n\n// -- TokenBucket (unchanged) --\n\nclass TokenBucket {\n  private tokens: number;\n  private lastRefill: number;\n\n  constructor(\n    private readonly maxTokens: number,\n    private readonly refillRate: number,\n  ) {\n    this.tokens = maxTokens;\n    this.lastRefill = Date.now();\n  }\n\n  tryConsume(): boolean {\n    this.refill();\n    if (this.tokens < 1) return false;\n    this.tokens -= 1;\n    return true;\n  }\n\n  private refill(): void {\n    const now = Date.now();\n    const elapsed = (now - this.lastRefill) / 1000;\n    this.tokens = Math.min(this.maxTokens, this.tokens + elapsed * this.refillRate);\n    this.lastRefill = now;\n  }\n}\n\n// -- NoopWebSocketTelemetryController (preserved-behavior) --\n\nconst noopUnsubscribe = (): void => {};\n\nexport class NoopWebSocketTelemetryController implements WebSocketTelemetryController {\n  emit(_input: WebSocketTelemetryEventInput): void {\n    // noop\n  }\n\n  recordMetric(_input: WebSocketMetricInput): void {\n    // noop\n  }\n\n  recordSpan(_input: WebSocketSpanInput): void {\n    // noop\n  }\n\n  getMetricsSnapshot(): WebSocketTelemetryMetricsSnapshot {\n    return { ...EMPTY_METRICS_SNAPSHOT, timestamp: Date.now() };\n  }\n\n  getEventStore(): WebSocketTelemetryEventStore | undefined {\n    return undefined;\n  }\n\n  getMetricStore(): WebSocketTelemetryMetricStore | undefined {\n    return undefined;\n  }\n\n  getSpanStore(): WebSocketTelemetrySpanStore | undefined {\n    return undefined;\n  }\n\n  registerMetricSource(_source: WebSocketTelemetryMetricSource): () => void {\n    return noopUnsubscribe;\n  }\n\n  createConnectionContext(_request?: {\n    headers?: Readonly<Record<string, string | string[] | undefined>>;\n  }): WebSocketTelemetryConnectionContext {\n    return {};\n  }\n\n  getTraceOptions(): WebSocketTelemetryTraceOptions {\n    return { ...DEFAULT_TRACE_OPTIONS };\n  }\n\n  shutdown(_options?: { timeoutMs?: number }): Promise<void> {\n    return Promise.resolve();\n  }\n}\n\n// -- Resolved per-pipeline option types (internal) --\n\ntype RuntimeMetadata = {\n  runtimeId: string;\n  nodeId: string;\n};\n\ntype ResolvedEventPipelineOptions = {\n  sinks: WebSocketTelemetryEventSink[];\n  store: WebSocketTelemetryEventStore | undefined;\n  maxRecordsPerSecond: number;\n  maxInFlightEmits: number;\n  sharedRedactor: WebSocketTelemetryRedactor | undefined;\n  signalRedactor: WebSocketTelemetryEventRedactor | undefined;\n  sharedBeforeRecord: WebSocketTelemetryBeforeRecord | undefined;\n  signalBeforeRecord: WebSocketTelemetryEventBeforeRecord | undefined;\n  sampling: {\n    defaultRate: number;\n    rateByEvent: Record<string, number>;\n    alwaysRecordLevels: Array<\"warn\" | \"error\">;\n  };\n  capturePayload: false | \"preview\";\n  maxPayloadPreviewBytes: number;\n};\n\ntype ResolvedMetricPipelineOptions = {\n  sinks: WebSocketTelemetryMetricSink[];\n  store: WebSocketTelemetryMetricStore | undefined;\n  maxRecordsPerSecond: number;\n  maxInFlightEmits: number;\n  sharedRedactor: WebSocketTelemetryRedactor | undefined;\n  signalRedactor: WebSocketTelemetryMetricRedactor | undefined;\n  sharedBeforeRecord: WebSocketTelemetryBeforeRecord | undefined;\n  signalBeforeRecord: WebSocketTelemetryMetricBeforeRecord | undefined;\n  collectionEnabled: boolean;\n  sampleIntervalMs: number;\n};\n\ntype ResolvedSpanPipelineOptions = {\n  sinks: WebSocketTelemetrySpanSink[];\n  store: WebSocketTelemetrySpanStore | undefined;\n  maxRecordsPerSecond: number;\n  maxInFlightEmits: number;\n  sharedRedactor: WebSocketTelemetryRedactor | undefined;\n  signalRedactor: WebSocketTelemetrySpanRedactor | undefined;\n  sharedBeforeRecord: WebSocketTelemetryBeforeRecord | undefined;\n  signalBeforeRecord: WebSocketTelemetrySpanBeforeRecord | undefined;\n  sampling: {\n    defaultRate: number;\n  };\n};\n\n// -- Internal event reporter type --\n// EventPipeline 자신과 controller가 내부 진단 이벤트를 발행할 때 사용한다.\n// type-mismatch / shutdown.timeout / sink.failed 등을 events pipeline 경로로 보낸다.\ntype InternalEventReporter = (\n  name: string,\n  level: WebSocketTelemetryEventRecord[\"level\"],\n  detail?: Record<string, unknown>,\n) => void;\n\n// -- TelemetryPipeline (abstract) --\n\nabstract class TelemetryPipeline<\n  TRecord extends WebSocketTelemetryRecord,\n  TInput,\n  TSink extends {\n    emit(record: TRecord): void | Promise<void>;\n    shutdown?(options?: { timeoutMs?: number }): void | Promise<void>;\n  },\n  TStore extends { readonly sink: TSink; clear(): void } | undefined,\n> {\n  abstract readonly signal: \"event\" | \"metric\" | \"span\";\n  protected readonly sinks: TSink[];\n  protected readonly _store: TStore;\n  protected readonly tokenBucket: TokenBucket;\n  protected readonly maxInFlightEmits: number;\n  protected readonly runtimeMetadata: RuntimeMetadata;\n  protected readonly sharedRedactor: WebSocketTelemetryRedactor | undefined;\n  protected readonly sharedBeforeRecord: WebSocketTelemetryBeforeRecord | undefined;\n  protected internalEventReporter: InternalEventReporter | undefined;\n  private readonly inFlightEmits = new WeakMap<TSink, number>();\n  droppedCount = 0;\n  sinkFailureCount = 0;\n  shutdownCalled = false;\n\n  protected constructor(\n    sinks: TSink[],\n    store: TStore,\n    maxRecordsPerSecond: number,\n    maxInFlightEmits: number,\n    sharedRedactor: WebSocketTelemetryRedactor | undefined,\n    sharedBeforeRecord: WebSocketTelemetryBeforeRecord | undefined,\n    runtimeMetadata: RuntimeMetadata,\n  ) {\n    this.sinks = sinks;\n    this._store = store;\n    this.tokenBucket = new TokenBucket(maxRecordsPerSecond, maxRecordsPerSecond);\n    this.maxInFlightEmits = maxInFlightEmits;\n    this.sharedRedactor = sharedRedactor;\n    this.sharedBeforeRecord = sharedBeforeRecord;\n    this.runtimeMetadata = runtimeMetadata;\n  }\n\n  get store(): TStore {\n    return this._store;\n  }\n\n  setInternalEventReporter(reporter: InternalEventReporter): void {\n    this.internalEventReporter = reporter;\n  }\n\n  abstract emit(input: TInput): void;\n\n  protected abstract buildRecord(input: TInput): TRecord;\n\n  protected abstract shouldBypassRateLimit(record: TRecord): boolean;\n\n  protected abstract isCriticalRecord(record: TRecord): boolean;\n\n  protected abstract getSignalRedactor(): ((record: TRecord) => TRecord | null) | undefined;\n\n  protected abstract getSignalBeforeRecord(): ((record: TRecord) => TRecord | null) | undefined;\n\n  // 공통 emit 흐름. 모든 신호별 pipeline의 emit이 이 메서드로 위임한다.\n  protected emitInternal(input: TInput): void {\n    if (this.shutdownCalled) return;\n\n    let record: TRecord;\n    try {\n      record = this.buildRecord(input);\n    } catch {\n      this.droppedCount += 1;\n      return;\n    }\n\n    const skipRateLimit = this.shouldBypassRateLimit(record);\n    if (!skipRateLimit && !this.tokenBucket.tryConsume()) {\n      this.droppedCount += 1;\n      return;\n    }\n\n    // step 1: defaultSensitiveKeyRedact 항상 적용\n    let prepared: TRecord;\n    try {\n      const afterDefault = defaultSensitiveKeyRedact(record);\n      if (afterDefault.type !== record.type) {\n        // 방어 로직 — 본 구현에서는 발생하지 않지만 type-narrow를 위해 검증\n        this.droppedCount += 1;\n        return;\n      }\n      prepared = afterDefault as TRecord;\n    } catch {\n      this.droppedCount += 1;\n      return;\n    }\n\n    // step 2: sharedRedactor (이미 buildController에서 signalRedactor===null이면 sharedRedactor=undefined로 덮어쓴 상태)\n    if (this.sharedRedactor !== undefined) {\n      const sharedRedactor = this.sharedRedactor;\n      const result = this.applyTransform(prepared, (r) => sharedRedactor(r), \"shared\", \"redactor\");\n      if (result === null) return;\n      prepared = result;\n    }\n\n    // step 3: signalRedactor\n    const signalRedactor = this.getSignalRedactor();\n    if (signalRedactor !== undefined) {\n      const result = this.applyTransform(prepared, (r) => signalRedactor(r), \"signal\", \"redactor\");\n      if (result === null) return;\n      prepared = result;\n    }\n\n    // step 4: sharedBeforeRecord\n    if (this.sharedBeforeRecord !== undefined) {\n      const sharedBeforeRecord = this.sharedBeforeRecord;\n      const result = this.applyTransform(\n        prepared,\n        (r) => sharedBeforeRecord(r),\n        \"shared\",\n        \"beforeRecord\",\n      );\n      if (result === null) return;\n      prepared = result;\n    }\n\n    // step 5: signalBeforeRecord\n    const signalBeforeRecord = this.getSignalBeforeRecord();\n    if (signalBeforeRecord !== undefined) {\n      const result = this.applyTransform(\n        prepared,\n        (r) => signalBeforeRecord(r),\n        \"signal\",\n        \"beforeRecord\",\n      );\n      if (result === null) return;\n      prepared = result;\n    }\n\n    this.dispatchToSinks(prepared);\n  }\n\n  // redactor 또는 beforeRecord 1회 적용. 반환값이 null이면 drop, type 불일치면 drop + internal event.\n  // shared 변환은 wider record를 받아 wider record를 반환하지만, signal 변환은 narrowed TRecord끼리 변환한다.\n  // 양쪽 모두 동일한 type-mismatch defensive 검사를 거친다.\n  private applyTransform(\n    record: TRecord,\n    runner: (record: TRecord) => WebSocketTelemetryRecord | null,\n    source: \"shared\" | \"signal\",\n    kind: \"redactor\" | \"beforeRecord\",\n  ): TRecord | null {\n    let result: WebSocketTelemetryRecord | null;\n    try {\n      result = runner(record);\n    } catch {\n      this.droppedCount += 1;\n      return null;\n    }\n\n    if (result === null) {\n      this.droppedCount += 1;\n      return null;\n    }\n\n    if (result.type !== record.type) {\n      this.droppedCount += 1;\n      const eventName =\n        kind === \"redactor\"\n          ? \"ws.telemetry.redactor.type_mismatch\"\n          : \"ws.telemetry.beforeRecord.type_mismatch\";\n      this.dispatchInternalEvent(eventName, \"warn\", {\n        expected: record.type,\n        actual: result.type,\n        source,\n      });\n      return null;\n    }\n\n    // result.type === record.type === TRecord[\"type\"]이므로 narrowed TRecord로 안전하게 좁힐 수 있다.\n    return result as TRecord;\n  }\n\n  protected dispatchToSinks(record: TRecord, selfObserveFailures = true): void {\n    const critical = this.isCriticalRecord(record);\n    let droppedForRecord = false;\n\n    for (const sink of this.sinks) {\n      const inFlight = this.inFlightEmits.get(sink) ?? 0;\n      if (!critical && inFlight >= this.maxInFlightEmits) {\n        if (!droppedForRecord) {\n          this.droppedCount += 1;\n          droppedForRecord = true;\n        }\n        continue;\n      }\n\n      try {\n        const result = sink.emit(record);\n        if (isPromiseLike(result)) {\n          this.inFlightEmits.set(sink, inFlight + 1);\n          result.then(\n            () => {\n              this.decrementInFlightEmit(sink);\n            },\n            (error: unknown) => {\n              this.decrementInFlightEmit(sink);\n              this.observeSinkFailure(\"emit\", error, selfObserveFailures);\n            },\n          );\n        }\n      } catch (error) {\n        this.observeSinkFailure(\"emit\", error, selfObserveFailures);\n      }\n    }\n  }\n\n  private decrementInFlightEmit(sink: TSink): void {\n    const current = this.inFlightEmits.get(sink) ?? 0;\n    if (current <= 1) {\n      this.inFlightEmits.delete(sink);\n      return;\n    }\n    this.inFlightEmits.set(sink, current - 1);\n  }\n\n  private observeSinkFailure(\n    phase: \"emit\" | \"shutdown\",\n    error: unknown,\n    selfObserveFailure: boolean,\n  ): void {\n    this.sinkFailureCount += 1;\n    if (!selfObserveFailure) return;\n    this.dispatchInternalEvent(\"ws.telemetry.sink.failed\", \"warn\", {\n      phase,\n      signal: this.signal,\n      errorType: error instanceof Error ? error.name : typeof error,\n    });\n  }\n\n  protected dispatchInternalEvent(\n    name: string,\n    level: WebSocketTelemetryEventRecord[\"level\"],\n    detail?: Record<string, unknown>,\n  ): void {\n    if (this.internalEventReporter === undefined) return;\n    try {\n      this.internalEventReporter(name, level, detail);\n    } catch {\n      // 진단 이벤트 자체가 실패하면 swallow\n    }\n  }\n\n  async shutdown(timeoutMs: number): Promise<void> {\n    if (this.shutdownCalled) return;\n    this.shutdownCalled = true;\n\n    const sinkShutdowns = this.sinks.map((sink) => this.shutdownSink(sink, timeoutMs));\n    if (sinkShutdowns.length > 0) {\n      await Promise.allSettled(sinkShutdowns);\n    }\n  }\n\n  private async shutdownSink(sink: TSink, timeoutMs: number): Promise<void> {\n    if (!sink.shutdown) return;\n\n    try {\n      const result = sink.shutdown({ timeoutMs });\n      if (!isPromiseLike(result)) return;\n\n      let timeout: ReturnType<typeof setTimeout> | null = null;\n      const shutdownPromise = result.then(\n        () => \"completed\" as const,\n        (error: unknown) => {\n          throw error;\n        },\n      );\n      const timeoutPromise = new Promise<\"timeout\">((resolve) => {\n        timeout = setTimeout(() => {\n          resolve(\"timeout\");\n        }, timeoutMs);\n      });\n\n      const outcome = await Promise.race([shutdownPromise, timeoutPromise]);\n      if (timeout) {\n        clearTimeout(timeout);\n      }\n\n      if (outcome === \"timeout\") {\n        shutdownPromise.catch(() => {});\n        this.sinkFailureCount += 1;\n        this.dispatchInternalEvent(\"ws.telemetry.shutdown.timeout\", \"warn\", {\n          timeoutMs,\n          signal: this.signal,\n        });\n      }\n    } catch (error) {\n      this.observeSinkFailure(\"shutdown\", error, true);\n    }\n  }\n}\n\n// -- EventPipeline --\n\nclass EventPipeline extends TelemetryPipeline<\n  WebSocketTelemetryEventRecord,\n  WebSocketTelemetryEventInput,\n  WebSocketTelemetryEventSink,\n  WebSocketTelemetryEventStore | undefined\n> {\n  readonly signal = \"event\" as const;\n  protected readonly signalRedactor: WebSocketTelemetryEventRedactor | undefined;\n  protected readonly signalBeforeRecord: WebSocketTelemetryEventBeforeRecord | undefined;\n  protected readonly sampling: {\n    defaultRate: number;\n    rateByEvent: Record<string, number>;\n    alwaysRecordLevels: Array<\"warn\" | \"error\">;\n  };\n  protected readonly capturePayload: false | \"preview\";\n  protected readonly maxPayloadPreviewBytes: number;\n  // alwaysRecord level 경로에서 prepareRecord(skipRateLimit=true) 의미를 보존하기 위한 플래그.\n  private currentEmitAlwaysRecord = false;\n\n  constructor(options: ResolvedEventPipelineOptions, runtimeMetadata: RuntimeMetadata) {\n    super(\n      options.sinks,\n      options.store,\n      options.maxRecordsPerSecond,\n      options.maxInFlightEmits,\n      options.sharedRedactor,\n      options.sharedBeforeRecord,\n      runtimeMetadata,\n    );\n    this.signalRedactor = options.signalRedactor;\n    this.signalBeforeRecord = options.signalBeforeRecord;\n    this.sampling = options.sampling;\n    this.capturePayload = options.capturePayload;\n    this.maxPayloadPreviewBytes = options.maxPayloadPreviewBytes;\n  }\n\n  emit(input: WebSocketTelemetryEventInput): void {\n    try {\n      if (this.shutdownCalled) return;\n\n      // sampling: alwaysRecordLevels 우선\n      const levels: ReadonlyArray<string> = this.sampling.alwaysRecordLevels;\n      const alwaysRecord = levels.includes(input.level);\n\n      if (!alwaysRecord) {\n        const rate = this.sampling.rateByEvent[input.name] ?? this.sampling.defaultRate;\n        if (rate <= 0) {\n          this.droppedCount += 1;\n          return;\n        }\n        if (rate < 1 && Math.random() >= rate) {\n          this.droppedCount += 1;\n          return;\n        }\n      }\n\n      this.currentEmitAlwaysRecord = alwaysRecord;\n      try {\n        this.emitInternal(input);\n      } finally {\n        this.currentEmitAlwaysRecord = false;\n      }\n    } catch {\n      // pipeline emit 또한 throw-free 정책\n    }\n  }\n\n  // 내부 진단 이벤트 — sampling/rate-limit 우회. shutdown 중에도 발행해 timeout/실패 진단이 유실되지 않도록 한다.\n  // 사용자 redactor의 type-mismatch 위험을 피하기 위해 default redactor만 적용한다.\n  dispatchInternalDiagnosticEvent(\n    name: string,\n    level: WebSocketTelemetryEventRecord[\"level\"],\n    detail?: Record<string, unknown>,\n  ): void {\n    const record: WebSocketTelemetryEventRecord = {\n      type: \"event\",\n      timestamp: Date.now(),\n      monotonicTime: performance.now(),\n      runtimeId: this.runtimeMetadata.runtimeId,\n      nodeId: this.runtimeMetadata.nodeId,\n      name,\n      level,\n      detail,\n    };\n\n    // 진단 이벤트는 항상 default redactor만 적용해 sink에 직접 전달한다.\n    // (사용자 redactor가 진단 이벤트의 type을 잘못 바꿔 무한 루프를 일으키는 일을 막는다.)\n    try {\n      const sanitized = defaultSensitiveKeyRedact(record);\n      if (sanitized.type !== \"event\") return;\n      this.dispatchToSinks(sanitized, false);\n    } catch {\n      // swallow\n    }\n  }\n\n  protected buildRecord(input: WebSocketTelemetryEventInput): WebSocketTelemetryEventRecord {\n    let record: WebSocketTelemetryEventRecord = {\n      type: \"event\",\n      timestamp: Date.now(),\n      monotonicTime: performance.now(),\n      runtimeId: this.runtimeMetadata.runtimeId,\n      nodeId: this.runtimeMetadata.nodeId,\n      name: input.name,\n      level: input.level,\n      namespace: input.namespace,\n      connectionId: input.connectionId,\n      userId: input.userId,\n      attributes: input.attributes,\n      detail: input.detail,\n      traceId: input.traceId,\n      spanId: input.spanId,\n      parentSpanId: input.parentSpanId,\n      sampled: input.sampled,\n    };\n\n    if (this.capturePayload === \"preview\" && input.payload !== undefined) {\n      record = {\n        ...record,\n        payloadPreview: truncatePayloadPreview(input.payload, this.maxPayloadPreviewBytes),\n      };\n    }\n\n    return record;\n  }\n\n  protected shouldBypassRateLimit(_record: WebSocketTelemetryEventRecord): boolean {\n    // alwaysRecordLevels에 해당하는 record는 sampling을 거치지 않고 들어왔으며,\n    // 기존 controller 동작을 보존하기 위해 token bucket도 skip한다.\n    return this.currentEmitAlwaysRecord;\n  }\n\n  protected isCriticalRecord(record: WebSocketTelemetryEventRecord): boolean {\n    return record.level === \"warn\" || record.level === \"error\";\n  }\n\n  protected getSignalRedactor():\n    | ((record: WebSocketTelemetryEventRecord) => WebSocketTelemetryEventRecord | null)\n    | undefined {\n    return this.signalRedactor;\n  }\n\n  protected getSignalBeforeRecord():\n    | ((record: WebSocketTelemetryEventRecord) => WebSocketTelemetryEventRecord | null)\n    | undefined {\n    return this.signalBeforeRecord;\n  }\n}\n\n// -- MetricPipeline --\n\nclass MetricPipeline extends TelemetryPipeline<\n  WebSocketTelemetryMetricRecord,\n  WebSocketMetricInput,\n  WebSocketTelemetryMetricSink,\n  WebSocketTelemetryMetricStore | undefined\n> {\n  readonly signal = \"metric\" as const;\n  protected readonly signalRedactor: WebSocketTelemetryMetricRedactor | undefined;\n  protected readonly signalBeforeRecord: WebSocketTelemetryMetricBeforeRecord | undefined;\n  protected readonly metricSources: Set<WebSocketTelemetryMetricSource> = new Set();\n  protected readonly collectionEnabled: boolean;\n  protected readonly sampleIntervalMs: number;\n  protected collectionInterval: ReturnType<typeof setInterval> | null = null;\n  protected snapshotProvider: (() => WebSocketTelemetryMetricsSnapshot) | undefined;\n\n  constructor(options: ResolvedMetricPipelineOptions, runtimeMetadata: RuntimeMetadata) {\n    super(\n      options.sinks,\n      options.store,\n      options.maxRecordsPerSecond,\n      options.maxInFlightEmits,\n      options.sharedRedactor,\n      options.sharedBeforeRecord,\n      runtimeMetadata,\n    );\n    this.signalRedactor = options.signalRedactor;\n    this.signalBeforeRecord = options.signalBeforeRecord;\n    this.collectionEnabled = options.collectionEnabled;\n    this.sampleIntervalMs = options.sampleIntervalMs;\n\n    if (this.collectionEnabled && this.sampleIntervalMs > 0) {\n      this.collectionInterval = setInterval(() => {\n        this.collectAndEmit();\n      }, this.sampleIntervalMs);\n\n      if (\n        this.collectionInterval &&\n        typeof this.collectionInterval === \"object\" &&\n        \"unref\" in this.collectionInterval\n      ) {\n        this.collectionInterval.unref();\n      }\n    }\n  }\n\n  emit(input: WebSocketMetricInput): void {\n    try {\n      this.emitInternal(input);\n    } catch {\n      // pipeline emit throw-free 정책\n    }\n  }\n\n  protected buildRecord(input: WebSocketMetricInput): WebSocketTelemetryMetricRecord {\n    return {\n      type: \"metric\",\n      timestamp: Date.now(),\n      monotonicTime: performance.now(),\n      runtimeId: this.runtimeMetadata.runtimeId,\n      nodeId: this.runtimeMetadata.nodeId,\n      name: input.name,\n      kind: input.kind,\n      value: input.value,\n      unit: input.unit,\n      tags: input.tags,\n      namespace: input.namespace,\n      connectionId: input.connectionId,\n      userId: input.userId,\n      traceId: input.traceId,\n      spanId: input.spanId,\n      parentSpanId: input.parentSpanId,\n      sampled: input.sampled,\n      snapshot: input.snapshot,\n    };\n  }\n\n  protected shouldBypassRateLimit(record: WebSocketTelemetryMetricRecord): boolean {\n    const outcome = record.tags?.outcome;\n    if (outcome === \"failed\" || outcome === \"rejected\" || outcome === \"dropped\") {\n      return true;\n    }\n\n    return (\n      record.name.endsWith(\".failures\") ||\n      record.name.endsWith(\".failure\") ||\n      record.name.endsWith(\".dropped\") ||\n      record.name.includes(\".failures.\") ||\n      record.name.includes(\".dropped.\")\n    );\n  }\n\n  protected isCriticalRecord(record: WebSocketTelemetryMetricRecord): boolean {\n    return this.shouldBypassRateLimit(record);\n  }\n\n  protected getSignalRedactor():\n    | ((record: WebSocketTelemetryMetricRecord) => WebSocketTelemetryMetricRecord | null)\n    | undefined {\n    return this.signalRedactor;\n  }\n\n  protected getSignalBeforeRecord():\n    | ((record: WebSocketTelemetryMetricRecord) => WebSocketTelemetryMetricRecord | null)\n    | undefined {\n    return this.signalBeforeRecord;\n  }\n\n  registerMetricSource(source: WebSocketTelemetryMetricSource): () => void {\n    this.metricSources.add(source);\n    return () => {\n      this.metricSources.delete(source);\n    };\n  }\n\n  setSnapshotProvider(provider: () => WebSocketTelemetryMetricsSnapshot): void {\n    this.snapshotProvider = provider;\n  }\n\n  getSnapshot(): WebSocketTelemetryMetricsSnapshot {\n    const now = Date.now();\n    const base: WebSocketTelemetryMetricsSnapshot = {\n      ...EMPTY_METRICS_SNAPSHOT,\n      timestamp: now,\n      activeConnectionsByNamespace: {},\n      telemetryDroppedRecords: this.droppedCount,\n      telemetrySinkFailures: this.sinkFailureCount,\n    };\n\n    for (const source of this.metricSources) {\n      try {\n        const partial = source.collect(now);\n        base.activeConnections += partial.activeConnections ?? 0;\n        base.roomCount += partial.roomCount ?? 0;\n        base.pendingInboundMessages += partial.pendingInboundMessages ?? 0;\n        base.pendingOutboundMessages += partial.pendingOutboundMessages ?? 0;\n        base.socketBufferedBytes += partial.socketBufferedBytes ?? 0;\n        base.pendingFanOutJobs += partial.pendingFanOutJobs ?? 0;\n        base.pendingFanOutTargets += partial.pendingFanOutTargets ?? 0;\n        if (partial.activeConnectionsByNamespace) {\n          for (const [ns, count] of Object.entries(partial.activeConnectionsByNamespace)) {\n            base.activeConnectionsByNamespace[ns] =\n              (base.activeConnectionsByNamespace[ns] ?? 0) + count;\n          }\n        }\n      } catch {\n        // metric source 실패는 외부로 전파되어선 안 됨\n      }\n    }\n\n    return base;\n  }\n\n  collectAndEmit(): void {\n    try {\n      if (this.shutdownCalled) return;\n      const snapshot = this.snapshotProvider?.() ?? this.getSnapshot();\n      const input: WebSocketMetricInput = {\n        name: \"ws.connections.active\",\n        kind: \"gauge\",\n        value: snapshot.activeConnections,\n        unit: \"1\",\n        snapshot,\n      };\n      this.emit(input);\n    } catch {\n      // metrics 수집 실패는 외부로 전파되어선 안 됨\n    }\n  }\n\n  override async shutdown(timeoutMs: number): Promise<void> {\n    if (this.collectionInterval !== null) {\n      clearInterval(this.collectionInterval);\n      this.collectionInterval = null;\n    }\n    await super.shutdown(timeoutMs);\n  }\n}\n\n// -- SpanPipeline --\n\nclass SpanPipeline extends TelemetryPipeline<\n  WebSocketTelemetrySpanRecord,\n  WebSocketSpanInput,\n  WebSocketTelemetrySpanSink,\n  WebSocketTelemetrySpanStore | undefined\n> {\n  readonly signal = \"span\" as const;\n  protected readonly signalRedactor: WebSocketTelemetrySpanRedactor | undefined;\n  protected readonly signalBeforeRecord: WebSocketTelemetrySpanBeforeRecord | undefined;\n  protected readonly sampling: {\n    defaultRate: number;\n  };\n\n  constructor(options: ResolvedSpanPipelineOptions, runtimeMetadata: RuntimeMetadata) {\n    super(\n      options.sinks,\n      options.store,\n      options.maxRecordsPerSecond,\n      options.maxInFlightEmits,\n      options.sharedRedactor,\n      options.sharedBeforeRecord,\n      runtimeMetadata,\n    );\n    this.signalRedactor = options.signalRedactor;\n    this.signalBeforeRecord = options.signalBeforeRecord;\n    this.sampling = { defaultRate: options.sampling.defaultRate };\n  }\n\n  emit(input: WebSocketSpanInput): void {\n    try {\n      if (this.shutdownCalled) return;\n\n      // status === \"error\"는 sampling 우회\n      if (input.status !== \"error\") {\n        const rate = this.sampling.defaultRate;\n        if (rate <= 0) {\n          this.droppedCount += 1;\n          return;\n        }\n        if (rate < 1 && Math.random() >= rate) {\n          this.droppedCount += 1;\n          return;\n        }\n      }\n\n      this.emitInternal(input);\n    } catch {\n      // pipeline emit throw-free 정책\n    }\n  }\n\n  protected buildRecord(input: WebSocketSpanInput): WebSocketTelemetrySpanRecord {\n    return {\n      type: \"span\",\n      timestamp: Date.now(),\n      monotonicTime: performance.now(),\n      runtimeId: this.runtimeMetadata.runtimeId,\n      nodeId: this.runtimeMetadata.nodeId,\n      operationName: input.operationName,\n      kind: input.kind,\n      durationMs: input.durationMs,\n      status: input.status,\n      namespace: input.namespace,\n      connectionId: input.connectionId,\n      userId: input.userId,\n      attributes: input.attributes,\n      errorType: input.errorType,\n      traceId: input.traceId,\n      spanId: input.spanId,\n      parentSpanId: input.parentSpanId,\n      sampled: input.sampled,\n      events: input.events,\n      links: input.links,\n    };\n  }\n\n  protected shouldBypassRateLimit(record: WebSocketTelemetrySpanRecord): boolean {\n    return record.status === \"error\";\n  }\n\n  protected isCriticalRecord(record: WebSocketTelemetrySpanRecord): boolean {\n    return record.status === \"error\";\n  }\n\n  protected getSignalRedactor():\n    | ((record: WebSocketTelemetrySpanRecord) => WebSocketTelemetrySpanRecord | null)\n    | undefined {\n    return this.signalRedactor;\n  }\n\n  protected getSignalBeforeRecord():\n    | ((record: WebSocketTelemetrySpanRecord) => WebSocketTelemetrySpanRecord | null)\n    | undefined {\n    return this.signalBeforeRecord;\n  }\n}\n\n// -- WebSocketTelemetryControllerImpl --\n\nexport class WebSocketTelemetryControllerImpl implements WebSocketTelemetryController {\n  protected readonly events: EventPipeline;\n  protected readonly metrics: MetricPipeline;\n  protected readonly spans: SpanPipeline;\n  protected readonly runtimeId: string;\n  protected readonly nodeId: string;\n  protected readonly traceOptions: WebSocketTelemetryTraceOptions;\n  protected readonly shutdownTimeoutMs: number;\n  protected shutdownCalled = false;\n\n  constructor(\n    events: EventPipeline,\n    metrics: MetricPipeline,\n    spans: SpanPipeline,\n    traceOptions: WebSocketTelemetryTraceOptions,\n    runtimeMetadata: RuntimeMetadata,\n    shutdownTimeoutMs: number,\n  ) {\n    this.events = events;\n    this.metrics = metrics;\n    this.spans = spans;\n    this.traceOptions = traceOptions;\n    this.runtimeId = runtimeMetadata.runtimeId;\n    this.nodeId = runtimeMetadata.nodeId;\n    this.shutdownTimeoutMs = shutdownTimeoutMs;\n\n    // 모든 pipeline 진단 이벤트는 events pipeline 경로로 라우팅한다.\n    const reporter: InternalEventReporter = (name, level, detail) => {\n      this.events.dispatchInternalDiagnosticEvent(name, level, detail);\n    };\n    this.events.setInternalEventReporter(reporter);\n    this.metrics.setInternalEventReporter(reporter);\n    this.spans.setInternalEventReporter(reporter);\n    this.metrics.setSnapshotProvider(() => this.getMetricsSnapshot());\n  }\n\n  emit(input: WebSocketTelemetryEventInput): void {\n    try {\n      if (this.shutdownCalled) return;\n      this.events.emit(input);\n    } catch {\n      // controller throw-free\n    }\n  }\n\n  recordMetric(input: WebSocketMetricInput): void {\n    try {\n      if (this.shutdownCalled) return;\n      this.metrics.emit(input);\n    } catch {\n      // controller throw-free\n    }\n  }\n\n  recordSpan(input: WebSocketSpanInput): void {\n    try {\n      if (this.shutdownCalled) return;\n      this.spans.emit(input);\n    } catch {\n      // controller throw-free\n    }\n  }\n\n  getMetricsSnapshot(): WebSocketTelemetryMetricsSnapshot {\n    try {\n      const base = this.metrics.getSnapshot();\n      base.telemetryDroppedRecords =\n        this.events.droppedCount + this.metrics.droppedCount + this.spans.droppedCount;\n      base.telemetrySinkFailures =\n        this.events.sinkFailureCount + this.metrics.sinkFailureCount + this.spans.sinkFailureCount;\n      return base;\n    } catch {\n      return { ...EMPTY_METRICS_SNAPSHOT, timestamp: Date.now() };\n    }\n  }\n\n  getEventStore(): WebSocketTelemetryEventStore | undefined {\n    try {\n      return this.events.store;\n    } catch {\n      return undefined;\n    }\n  }\n\n  getMetricStore(): WebSocketTelemetryMetricStore | undefined {\n    try {\n      return this.metrics.store;\n    } catch {\n      return undefined;\n    }\n  }\n\n  getSpanStore(): WebSocketTelemetrySpanStore | undefined {\n    try {\n      return this.spans.store;\n    } catch {\n      return undefined;\n    }\n  }\n\n  registerMetricSource(source: WebSocketTelemetryMetricSource): () => void {\n    try {\n      return this.metrics.registerMetricSource(source);\n    } catch {\n      return noopUnsubscribe;\n    }\n  }\n\n  createConnectionContext(request?: {\n    headers?: Readonly<Record<string, string | string[] | undefined>>;\n  }): WebSocketTelemetryConnectionContext {\n    try {\n      if (this.traceOptions.extractTraceParent && request?.headers) {\n        const traceparentHeader = request.headers[\"traceparent\"];\n        const traceparentValue = Array.isArray(traceparentHeader)\n          ? traceparentHeader[0]\n          : traceparentHeader;\n        if (traceparentValue) {\n          const parsed = parseTraceParent(traceparentValue);\n          if (parsed) {\n            const context: WebSocketTelemetryConnectionContext = {\n              traceId: parsed.traceId,\n              parentSpanId: parsed.parentId,\n              sampled: parsed.sampled,\n            };\n            if (this.traceOptions.generateConnectionTrace) {\n              context.spanId = generateSpanId();\n            }\n            return { ...context };\n          }\n        }\n      }\n\n      if (!this.traceOptions.generateConnectionTrace) {\n        return {};\n      }\n\n      return { traceId: generateTraceId(), spanId: generateSpanId() };\n    } catch {\n      return {};\n    }\n  }\n\n  getTraceOptions(): WebSocketTelemetryTraceOptions {\n    return { ...this.traceOptions };\n  }\n\n  async shutdown(options?: { timeoutMs?: number }): Promise<void> {\n    if (this.shutdownCalled) return;\n    this.shutdownCalled = true;\n\n    const timeoutMs = options?.timeoutMs ?? this.shutdownTimeoutMs;\n    try {\n      await Promise.allSettled([\n        this.events.shutdown(timeoutMs),\n        this.metrics.shutdown(timeoutMs),\n        this.spans.shutdown(timeoutMs),\n      ]);\n    } catch {\n      // controller shutdown은 throw-free\n    }\n  }\n}\n\n// -- Factory --\n\nfunction buildController(\n  options: WebSocketTelemetryOptions,\n  runtimeMetadata: RuntimeMetadata,\n): WebSocketTelemetryController {\n  const defaults = options.defaults ?? {};\n  const eventsOpt = options.events ?? {};\n  const metricsOpt = options.metrics ?? {};\n  const spansOpt = options.spans ?? {};\n\n  const defaultsMaxRecordsPerSecond =\n    defaults.maxRecordsPerSecond ?? DEFAULT_MAX_RECORDS_PER_SECOND;\n\n  // 신호별 redactor / beforeRecord 해석.\n  // null이면 sharedRedactor를 undefined로 덮어써 step 2 자체를 skip한다.\n  const eventsSharedRedactor = eventsOpt.redactor === null ? undefined : defaults.redactor;\n  const eventsSignalRedactor =\n    typeof eventsOpt.redactor === \"function\" ? eventsOpt.redactor : undefined;\n  const eventsSharedBeforeRecord =\n    eventsOpt.beforeRecord === null ? undefined : defaults.beforeRecord;\n  const eventsSignalBeforeRecord =\n    typeof eventsOpt.beforeRecord === \"function\" ? eventsOpt.beforeRecord : undefined;\n\n  const metricsSharedRedactor = metricsOpt.redactor === null ? undefined : defaults.redactor;\n  const metricsSignalRedactor =\n    typeof metricsOpt.redactor === \"function\" ? metricsOpt.redactor : undefined;\n  const metricsSharedBeforeRecord =\n    metricsOpt.beforeRecord === null ? undefined : defaults.beforeRecord;\n  const metricsSignalBeforeRecord =\n    typeof metricsOpt.beforeRecord === \"function\" ? metricsOpt.beforeRecord : undefined;\n\n  const spansSharedRedactor = spansOpt.redactor === null ? undefined : defaults.redactor;\n  const spansSignalRedactor =\n    typeof spansOpt.redactor === \"function\" ? spansOpt.redactor : undefined;\n  const spansSharedBeforeRecord =\n    spansOpt.beforeRecord === null ? undefined : defaults.beforeRecord;\n  const spansSignalBeforeRecord =\n    typeof spansOpt.beforeRecord === \"function\" ? spansOpt.beforeRecord : undefined;\n\n  // events\n  const eventSinks: WebSocketTelemetryEventSink[] = eventsOpt.sinks ? [...eventsOpt.sinks] : [];\n  let eventStore: WebSocketTelemetryEventStore | undefined = eventsOpt.store;\n  if (eventSinks.length === 0 && eventStore === undefined) {\n    eventStore = new InMemoryEventStore({\n      maxRecords: eventsOpt.maxRecords ?? defaults.maxRecords,\n      maxBytes: eventsOpt.maxBytes ?? defaults.maxBytes,\n    });\n    eventSinks.push(eventStore.sink);\n  } else if (eventStore !== undefined && !eventSinks.includes(eventStore.sink)) {\n    eventSinks.push(eventStore.sink);\n  }\n\n  const eventsResolved: ResolvedEventPipelineOptions = {\n    sinks: eventSinks,\n    store: eventStore,\n    maxRecordsPerSecond: eventsOpt.sampling?.maxRecordsPerSecond ?? defaultsMaxRecordsPerSecond,\n    maxInFlightEmits: eventsOpt.maxInFlightEmits ?? DEFAULT_MAX_IN_FLIGHT_EMITS_PER_SINK,\n    sharedRedactor: eventsSharedRedactor,\n    signalRedactor: eventsSignalRedactor,\n    sharedBeforeRecord: eventsSharedBeforeRecord,\n    signalBeforeRecord: eventsSignalBeforeRecord,\n    sampling: {\n      defaultRate: eventsOpt.sampling?.defaultRate ?? DEFAULT_EVENT_SAMPLING_DEFAULT_RATE,\n      rateByEvent: eventsOpt.sampling?.rateByEvent ?? {},\n      alwaysRecordLevels: eventsOpt.sampling?.alwaysRecordLevels ?? [\n        ...DEFAULT_EVENT_ALWAYS_RECORD_LEVELS,\n      ],\n    },\n    capturePayload: eventsOpt.capturePayload ?? DEFAULT_EVENT_CAPTURE_PAYLOAD,\n    maxPayloadPreviewBytes:\n      eventsOpt.maxPayloadPreviewBytes ?? DEFAULT_EVENT_MAX_PAYLOAD_PREVIEW_BYTES,\n  };\n\n  // metrics\n  const metricSinks: WebSocketTelemetryMetricSink[] = metricsOpt.sinks ? [...metricsOpt.sinks] : [];\n  let metricStore: WebSocketTelemetryMetricStore | undefined = metricsOpt.store;\n  if (metricSinks.length === 0 && metricStore === undefined) {\n    metricStore = new InMemoryMetricStore({\n      maxRecords: metricsOpt.maxRecords ?? defaults.maxRecords,\n      maxBytes: metricsOpt.maxBytes ?? defaults.maxBytes,\n    });\n    metricSinks.push(metricStore.sink);\n  } else if (metricStore !== undefined && !metricSinks.includes(metricStore.sink)) {\n    metricSinks.push(metricStore.sink);\n  }\n\n  const metricsResolved: ResolvedMetricPipelineOptions = {\n    sinks: metricSinks,\n    store: metricStore,\n    maxRecordsPerSecond: metricsOpt.sampling?.maxRecordsPerSecond ?? defaultsMaxRecordsPerSecond,\n    maxInFlightEmits: metricsOpt.maxInFlightEmits ?? DEFAULT_MAX_IN_FLIGHT_EMITS_PER_SINK,\n    sharedRedactor: metricsSharedRedactor,\n    signalRedactor: metricsSignalRedactor,\n    sharedBeforeRecord: metricsSharedBeforeRecord,\n    signalBeforeRecord: metricsSignalBeforeRecord,\n    collectionEnabled: metricsOpt.collectionEnabled ?? DEFAULT_METRIC_COLLECTION_ENABLED,\n    sampleIntervalMs: metricsOpt.sampleIntervalMs ?? DEFAULT_METRIC_SAMPLE_INTERVAL_MS,\n  };\n\n  // spans\n  const spanSinks: WebSocketTelemetrySpanSink[] = spansOpt.sinks ? [...spansOpt.sinks] : [];\n  let spanStore: WebSocketTelemetrySpanStore | undefined = spansOpt.store;\n  if (spanSinks.length === 0 && spanStore === undefined) {\n    spanStore = new InMemorySpanStore({\n      maxRecords: spansOpt.maxRecords ?? defaults.maxRecords,\n      maxBytes: spansOpt.maxBytes ?? defaults.maxBytes,\n    });\n    spanSinks.push(spanStore.sink);\n  } else if (spanStore !== undefined && !spanSinks.includes(spanStore.sink)) {\n    spanSinks.push(spanStore.sink);\n  }\n\n  const spansResolved: ResolvedSpanPipelineOptions = {\n    sinks: spanSinks,\n    store: spanStore,\n    maxRecordsPerSecond: spansOpt.sampling?.maxRecordsPerSecond ?? defaultsMaxRecordsPerSecond,\n    maxInFlightEmits: spansOpt.maxInFlightEmits ?? DEFAULT_MAX_IN_FLIGHT_EMITS_PER_SINK,\n    sharedRedactor: spansSharedRedactor,\n    signalRedactor: spansSignalRedactor,\n    sharedBeforeRecord: spansSharedBeforeRecord,\n    signalBeforeRecord: spansSignalBeforeRecord,\n    sampling: {\n      defaultRate: spansOpt.sampling?.defaultRate ?? DEFAULT_SPAN_SAMPLING_DEFAULT_RATE,\n    },\n  };\n\n  const eventPipeline = new EventPipeline(eventsResolved, runtimeMetadata);\n  const metricPipeline = new MetricPipeline(metricsResolved, runtimeMetadata);\n  const spanPipeline = new SpanPipeline(spansResolved, runtimeMetadata);\n\n  const traceOptions: WebSocketTelemetryTraceOptions = {\n    extractTraceParent:\n      options.trace?.extractTraceParent ?? DEFAULT_TRACE_OPTIONS.extractTraceParent,\n    generateConnectionTrace:\n      options.trace?.generateConnectionTrace ?? DEFAULT_TRACE_OPTIONS.generateConnectionTrace,\n    propagateMessageTrace:\n      options.trace?.propagateMessageTrace ?? DEFAULT_TRACE_OPTIONS.propagateMessageTrace,\n    recordConnectionLifetimeSpan:\n      options.trace?.recordConnectionLifetimeSpan ??\n      DEFAULT_TRACE_OPTIONS.recordConnectionLifetimeSpan,\n  };\n\n  const shutdownTimeoutMs = options.shutdownTimeoutMs ?? DEFAULT_SHUTDOWN_TIMEOUT_MS;\n\n  return new WebSocketTelemetryControllerImpl(\n    eventPipeline,\n    metricPipeline,\n    spanPipeline,\n    traceOptions,\n    runtimeMetadata,\n    shutdownTimeoutMs,\n  );\n}\n\nfunction assertControllerOptionIsExclusive(options: WebSocketTelemetryOptions): void {\n  const ignoredKeys = Object.entries(options)\n    .filter(([key, value]) => key !== \"enabled\" && key !== \"controller\" && value !== undefined)\n    .map(([key]) => key);\n\n  if (ignoredKeys.length === 0) return;\n\n  throw new Error(\n    `WebSocket telemetry controller option cannot be combined with other telemetry options: ${ignoredKeys.join(\n      \", \",\n    )}`,\n  );\n}\n\nexport function createWebSocketTelemetryController(\n  telemetryOption: boolean | WebSocketTelemetryOptions | undefined,\n  runtimeMetadata: RuntimeMetadata,\n): WebSocketTelemetryController {\n  if (telemetryOption === undefined || telemetryOption === false) {\n    return new NoopWebSocketTelemetryController();\n  }\n\n  if (telemetryOption === true) {\n    return buildController({}, runtimeMetadata);\n  }\n\n  if (telemetryOption.enabled === false) {\n    return new NoopWebSocketTelemetryController();\n  }\n\n  if (telemetryOption.controller) {\n    assertControllerOptionIsExclusive(telemetryOption);\n    return telemetryOption.controller;\n  }\n\n  return buildController(telemetryOption, runtimeMetadata);\n}\n"],"mappings":"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"}