sonamu 0.9.8 → 0.9.10

package/dist/stream/ws-registry.js

@@ -2,11 +2,24 @@ import { __esmMin } from "../_virtual/rolldown_runtime.js";
 import { WebSocketAudience, init_ws_audience } from "./ws-audience.js";
 import { WebSocketAudienceResolver, init_ws_audience_resolver } from "./ws-audience-resolver.js";
 import { NoopWebSocketClusterBus, init_ws_cluster_bus } from "./ws-cluster-bus.js";
+import { NoopWebSocketTelemetryController, init_ws_telemetry } from "./ws-telemetry.js";
 import { WebSocketDeliveryEngine, init_ws_delivery } from "./ws-delivery.js";
 import { WebSocketLocalConnectionStore, init_ws_local_connection_store } from "./ws-local-connection-store.js";
 import { InMemoryWebSocketPresenceStore, init_ws_presence_store } from "./ws-presence-store.js";
 
 //#region src/stream/ws-registry.ts
+function getConnectionTelemetryContext(connection) {
+	if (!connection || !isTelemetryContextProvider(connection)) {
+		return {};
+	}
+	return connection.getTelemetryContext();
+}
+function formatUserId(userId) {
+	return userId === undefined ? undefined : String(userId);
+}
+function isTelemetryContextProvider(connection) {
+	return "getTelemetryContext" in connection && typeof connection.getTelemetryContext === "function";
+}
 var WebSocketRegistry;
 var init_ws_registry = __esmMin((() => {
 	init_ws_audience();
@@ -15,6 +28,7 @@ var init_ws_registry = __esmMin((() => {
 	init_ws_delivery();
 	init_ws_local_connection_store();
 	init_ws_presence_store();
+	init_ws_telemetry();
 	WebSocketRegistry = class {
 		nodeId;
 		localConnections = new WebSocketLocalConnectionStore();
@@ -22,10 +36,12 @@ var init_ws_registry = __esmMin((() => {
 		clusterBus;
 		audienceResolver;
 		deliveryEngine;
-		constructor(options = {}) {
-			this.nodeId = options.nodeId ?? "local";
+		telemetryController;
+		constructor(options) {
+			this.nodeId = options.nodeId;
 			this.presenceStore = options.presenceStore ?? new InMemoryWebSocketPresenceStore();
 			this.clusterBus = options.clusterBus ?? new NoopWebSocketClusterBus();
+			this.telemetryController = options.telemetryController ?? new NoopWebSocketTelemetryController();
 			this.audienceResolver = new WebSocketAudienceResolver({
 				nodeId: this.nodeId,
 				presenceStore: this.presenceStore
@@ -34,39 +50,187 @@ var init_ws_registry = __esmMin((() => {
 				nodeId: this.nodeId,
 				localConnections: this.localConnections,
 				audienceResolver: this.audienceResolver,
-				clusterBus: this.clusterBus
+				clusterBus: this.clusterBus,
+				telemetryController: this.telemetryController
 			});
+			this.telemetryController.registerMetricSource({ collect: (_now) => {
+				const stats = this.presenceStore.getStats();
+				const localSnapshot = this.localConnections.getTelemetrySnapshot();
+				return {
+					activeConnections: stats.totalConnections,
+					activeConnectionsByNamespace: stats.byNamespace,
+					roomCount: stats.totalRooms,
+					pendingInboundMessages: localSnapshot.pendingInboundMessages,
+					pendingOutboundMessages: localSnapshot.pendingOutboundMessages,
+					socketBufferedBytes: localSnapshot.socketBufferedBytes
+				};
+			} });
 		}
 		register(connection, active = true) {
 			this.localConnections.register(connection);
-			return this.presenceStore.register({
+			const meta = this.presenceStore.register({
 				sessionId: connection.id,
 				nodeId: this.nodeId,
 				namespace: connection.namespace,
 				active
 			});
+			this.telemetryController.emit({
+				name: "ws.connection.registered",
+				level: "info",
+				connectionId: connection.id,
+				namespace: connection.namespace,
+				userId: connection.userId,
+				...getConnectionTelemetryContext(connection)
+			});
+			this.telemetryController.recordMetric({
+				name: "sonamu.ws.connections",
+				kind: "counter",
+				value: 1,
+				unit: "1",
+				tags: {
+					outcome: "registered",
+					namespace: connection.namespace
+				},
+				userId: connection.userId
+			});
+			return meta;
 		}
 		activate(connectionId) {
+			if (!this.presenceStore.getConnection(connectionId)) {
+				this.emitMutationSkipped(connectionId, { operation: "activate" });
+				return;
+			}
 			this.presenceStore.activate(connectionId);
+			const connection = this.localConnections.getConnection(connectionId);
+			this.telemetryController.emit({
+				name: "ws.connection.activated",
+				level: "info",
+				connectionId,
+				userId: connection?.userId,
+				...getConnectionTelemetryContext(connection)
+			});
 		}
 		unregister(connectionId) {
-			this.presenceStore.unregister(connectionId);
+			const connection = this.localConnections.getConnection(connectionId);
+			const telemetryContext = getConnectionTelemetryContext(connection);
+			const userId = connection?.userId ?? formatUserId(this.presenceStore.getConnection(connectionId)?.userId);
+			const meta = this.presenceStore.unregister(connectionId);
 			this.localConnections.unregister(connectionId);
+			this.telemetryController.emit({
+				name: "ws.connection.unregistered",
+				level: "debug",
+				connectionId,
+				namespace: meta?.namespace,
+				userId,
+				...telemetryContext
+			});
+			if (meta) {
+				this.telemetryController.recordMetric({
+					name: "sonamu.ws.connections",
+					kind: "counter",
+					value: 1,
+					unit: "1",
+					tags: {
+						outcome: "unregistered",
+						namespace: meta.namespace
+					},
+					userId
+				});
+			}
 		}
 		touch(connectionId) {
 			this.presenceStore.touch(connectionId);
 		}
 		setUserId(connectionId, userId) {
+			if (!this.presenceStore.getConnection(connectionId)) {
+				this.emitMutationSkipped(connectionId, {
+					operation: "setUserId",
+					userId
+				});
+				return;
+			}
 			this.presenceStore.setUserId(connectionId, userId);
+			const meta = this.presenceStore.getConnection(connectionId);
+			this.telemetryController.emit({
+				name: "ws.user.bound",
+				level: "debug",
+				connectionId,
+				namespace: meta?.namespace,
+				userId: String(userId),
+				detail: { userId },
+				...getConnectionTelemetryContext(this.localConnections.getConnection(connectionId))
+			});
 		}
 		clearUserId(connectionId) {
+			const meta = this.presenceStore.getConnection(connectionId);
+			if (!meta) {
+				this.emitMutationSkipped(connectionId, { operation: "clearUserId" });
+				return;
+			}
+			const userId = meta.userId;
 			this.presenceStore.clearUserId(connectionId);
+			this.telemetryController.emit({
+				name: "ws.user.cleared",
+				level: "debug",
+				connectionId,
+				namespace: meta.namespace,
+				userId: formatUserId(userId),
+				detail: userId !== undefined ? { userId } : undefined,
+				...getConnectionTelemetryContext(this.localConnections.getConnection(connectionId))
+			});
 		}
 		join(connectionId, roomId) {
+			if (!this.presenceStore.getConnection(connectionId)) {
+				this.emitMutationSkipped(connectionId, {
+					operation: "join",
+					roomId
+				});
+				return;
+			}
 			this.presenceStore.join(connectionId, roomId);
+			const meta = this.presenceStore.getConnection(connectionId);
+			const connection = this.localConnections.getConnection(connectionId);
+			this.telemetryController.emit({
+				name: "ws.room.joined",
+				level: "debug",
+				connectionId,
+				namespace: meta?.namespace,
+				userId: connection?.userId ?? formatUserId(meta?.userId),
+				detail: { roomId },
+				...getConnectionTelemetryContext(connection)
+			});
 		}
 		leave(connectionId, roomId) {
+			const meta = this.presenceStore.getConnection(connectionId);
+			if (!meta) {
+				this.emitMutationSkipped(connectionId, {
+					operation: "leave",
+					roomId
+				});
+				return;
+			}
 			this.presenceStore.leave(connectionId, roomId);
+			const connection = this.localConnections.getConnection(connectionId);
+			this.telemetryController.emit({
+				name: "ws.room.left",
+				level: "debug",
+				connectionId,
+				namespace: meta.namespace,
+				userId: connection?.userId ?? formatUserId(meta.userId),
+				detail: { roomId },
+				...getConnectionTelemetryContext(connection)
+			});
+		}
+		emitMutationSkipped(connectionId, detail) {
+			this.telemetryController.emit({
+				name: "ws.registry.mutation.skipped",
+				level: "debug",
+				connectionId,
+				detail: {
+					...detail,
+					reason: "connectionMissing"
+				}
+			});
 		}
 		broadcast(event, data, namespace) {
 			this.publishToAudience(WebSocketAudience.all(namespace), event, data);
@@ -105,4 +269,4 @@ var init_ws_registry = __esmMin((() => {
 //#endregion
 init_ws_registry();
 export { WebSocketRegistry, init_ws_registry };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ws-registry.js","names":[],"sources":["../../src/stream/ws-registry.ts"],"sourcesContent":["import { WebSocketAudience, type WebSocketAudience as WebSocketAudienceSpec } from \"./ws-audience\";\nimport { WebSocketAudienceResolver } from \"./ws-audience-resolver\";\nimport { NoopWebSocketClusterBus, type WebSocketClusterBus } from \"./ws-cluster-bus\";\nimport {\n  type ManagedWebSocketConnection,\n  type WebSocketRegistryStats,\n  type WebSocketRoomId,\n  type WebSocketUserId,\n} from \"./ws-core\";\nimport { WebSocketDeliveryEngine } from \"./ws-delivery\";\nimport { WebSocketLocalConnectionStore } from \"./ws-local-connection-store\";\nimport {\n  InMemoryWebSocketPresenceStore,\n  type WebSocketPresenceStore,\n  type WebSocketSessionPresence,\n} from \"./ws-presence-store\";\n\nexport type {\n  ManagedWebSocketConnection,\n  WebSocketRegistryStats,\n  WebSocketRoomId,\n  WebSocketUserId,\n};\nexport type WebSocketConnectionMeta = WebSocketSessionPresence;\n\nexport type WebSocketRegistryOptions = {\n  nodeId?: string;\n  presenceStore?: WebSocketPresenceStore;\n  clusterBus?: WebSocketClusterBus;\n};\n\nexport class WebSocketRegistry {\n  readonly nodeId: string;\n  readonly localConnections = new WebSocketLocalConnectionStore();\n  readonly presenceStore: WebSocketPresenceStore;\n  readonly clusterBus: WebSocketClusterBus;\n  readonly audienceResolver: WebSocketAudienceResolver;\n  readonly deliveryEngine: WebSocketDeliveryEngine;\n\n  constructor(options: WebSocketRegistryOptions = {}) {\n    this.nodeId = options.nodeId ?? \"local\";\n    this.presenceStore = options.presenceStore ?? new InMemoryWebSocketPresenceStore();\n    this.clusterBus = options.clusterBus ?? new NoopWebSocketClusterBus();\n    this.audienceResolver = new WebSocketAudienceResolver({\n      nodeId: this.nodeId,\n      presenceStore: this.presenceStore,\n    });\n    this.deliveryEngine = new WebSocketDeliveryEngine({\n      nodeId: this.nodeId,\n      localConnections: this.localConnections,\n      audienceResolver: this.audienceResolver,\n      clusterBus: this.clusterBus,\n    });\n  }\n\n  register(\n    connection: ManagedWebSocketConnection,\n    active: boolean = true,\n  ): WebSocketConnectionMeta {\n    this.localConnections.register(connection);\n    return this.presenceStore.register({\n      sessionId: connection.id,\n      nodeId: this.nodeId,\n      namespace: connection.namespace,\n      active,\n    });\n  }\n\n  activate(connectionId: string): void {\n    this.presenceStore.activate(connectionId);\n  }\n\n  unregister(connectionId: string): void {\n    this.presenceStore.unregister(connectionId);\n    this.localConnections.unregister(connectionId);\n  }\n\n  touch(connectionId: string): void {\n    this.presenceStore.touch(connectionId);\n  }\n\n  setUserId(connectionId: string, userId: WebSocketUserId): void {\n    this.presenceStore.setUserId(connectionId, userId);\n  }\n\n  clearUserId(connectionId: string): void {\n    this.presenceStore.clearUserId(connectionId);\n  }\n\n  join(connectionId: string, roomId: WebSocketRoomId): void {\n    this.presenceStore.join(connectionId, roomId);\n  }\n\n  leave(connectionId: string, roomId: WebSocketRoomId): void {\n    this.presenceStore.leave(connectionId, roomId);\n  }\n\n  broadcast(event: string, data: unknown, namespace?: string): void {\n    this.publishToAudience(WebSocketAudience.all(namespace), event, data);\n  }\n\n  publishToRoom(roomId: WebSocketRoomId, event: string, data: unknown, namespace?: string): void {\n    this.publishToAudience(WebSocketAudience.room(roomId, namespace), event, data);\n  }\n\n  publishToUser(userId: WebSocketUserId, event: string, data: unknown, namespace?: string): void {\n    this.publishToAudience(WebSocketAudience.user(userId, namespace), event, data);\n  }\n\n  publishToAudience(audience: WebSocketAudienceSpec, event: string, data: unknown): void {\n    this.deliveryEngine.publishToAudience(audience, event, data);\n  }\n\n  getConnection(connectionId: string): WebSocketConnectionMeta | undefined {\n    return this.presenceStore.getConnection(connectionId);\n  }\n\n  getConnectionCount(namespace?: string): number {\n    return this.presenceStore.getConnectionCount(namespace);\n  }\n\n  getRoomMembers(roomId: WebSocketRoomId, namespace?: string): WebSocketConnectionMeta[] {\n    return this.presenceStore.getRoomMembers(roomId, namespace);\n  }\n\n  getStats(): WebSocketRegistryStats {\n    return this.presenceStore.getStats();\n  }\n\n  closeAll(code?: number, reason?: string): void {\n    this.localConnections.closeAll(code, reason);\n  }\n\n  async shutdown(code?: number, reason?: string): Promise<void> {\n    this.closeAll(code, reason);\n    await this.deliveryEngine.shutdown();\n  }\n}\n"],"mappings":";;;;;;;;;;;mBAAmG;4BAChC;sBACkB;mBAO7B;iCACoB;yBAK/C;CAgBhB,oBAAb,MAA+B;EAC7B,AAAS;EACT,AAAS,mBAAmB,IAAI,+BAA+B;EAC/D,AAAS;EACT,AAAS;EACT,AAAS;EACT,AAAS;EAET,YAAY,UAAoC,EAAE,EAAE;AAClD,QAAK,SAAS,QAAQ,UAAU;AAChC,QAAK,gBAAgB,QAAQ,iBAAiB,IAAI,gCAAgC;AAClF,QAAK,aAAa,QAAQ,cAAc,IAAI,yBAAyB;AACrE,QAAK,mBAAmB,IAAI,0BAA0B;IACpD,QAAQ,KAAK;IACb,eAAe,KAAK;IACrB,CAAC;AACF,QAAK,iBAAiB,IAAI,wBAAwB;IAChD,QAAQ,KAAK;IACb,kBAAkB,KAAK;IACvB,kBAAkB,KAAK;IACvB,YAAY,KAAK;IAClB,CAAC;;EAGJ,SACE,YACA,SAAkB,MACO;AACzB,QAAK,iBAAiB,SAAS,WAAW;AAC1C,UAAO,KAAK,cAAc,SAAS;IACjC,WAAW,WAAW;IACtB,QAAQ,KAAK;IACb,WAAW,WAAW;IACtB;IACD,CAAC;;EAGJ,SAAS,cAA4B;AACnC,QAAK,cAAc,SAAS,aAAa;;EAG3C,WAAW,cAA4B;AACrC,QAAK,cAAc,WAAW,aAAa;AAC3C,QAAK,iBAAiB,WAAW,aAAa;;EAGhD,MAAM,cAA4B;AAChC,QAAK,cAAc,MAAM,aAAa;;EAGxC,UAAU,cAAsB,QAA+B;AAC7D,QAAK,cAAc,UAAU,cAAc,OAAO;;EAGpD,YAAY,cAA4B;AACtC,QAAK,cAAc,YAAY,aAAa;;EAG9C,KAAK,cAAsB,QAA+B;AACxD,QAAK,cAAc,KAAK,cAAc,OAAO;;EAG/C,MAAM,cAAsB,QAA+B;AACzD,QAAK,cAAc,MAAM,cAAc,OAAO;;EAGhD,UAAU,OAAe,MAAe,WAA0B;AAChE,QAAK,kBAAkB,kBAAkB,IAAI,UAAU,EAAE,OAAO,KAAK;;EAGvE,cAAc,QAAyB,OAAe,MAAe,WAA0B;AAC7F,QAAK,kBAAkB,kBAAkB,KAAK,QAAQ,UAAU,EAAE,OAAO,KAAK;;EAGhF,cAAc,QAAyB,OAAe,MAAe,WAA0B;AAC7F,QAAK,kBAAkB,kBAAkB,KAAK,QAAQ,UAAU,EAAE,OAAO,KAAK;;EAGhF,kBAAkB,UAAiC,OAAe,MAAqB;AACrF,QAAK,eAAe,kBAAkB,UAAU,OAAO,KAAK;;EAG9D,cAAc,cAA2D;AACvE,UAAO,KAAK,cAAc,cAAc,aAAa;;EAGvD,mBAAmB,WAA4B;AAC7C,UAAO,KAAK,cAAc,mBAAmB,UAAU;;EAGzD,eAAe,QAAyB,WAA+C;AACrF,UAAO,KAAK,cAAc,eAAe,QAAQ,UAAU;;EAG7D,WAAmC;AACjC,UAAO,KAAK,cAAc,UAAU;;EAGtC,SAAS,MAAe,QAAuB;AAC7C,QAAK,iBAAiB,SAAS,MAAM,OAAO;;EAG9C,MAAM,SAAS,MAAe,QAAgC;AAC5D,QAAK,SAAS,MAAM,OAAO;AAC3B,SAAM,KAAK,eAAe,UAAU"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ws-registry.js","names":[],"sources":["../../src/stream/ws-registry.ts"],"sourcesContent":["import { WebSocketAudience, type WebSocketAudience as WebSocketAudienceSpec } from \"./ws-audience\";\nimport { WebSocketAudienceResolver } from \"./ws-audience-resolver\";\nimport { NoopWebSocketClusterBus, type WebSocketClusterBus } from \"./ws-cluster-bus\";\nimport {\n  type ManagedWebSocketConnection,\n  type WebSocketRegistryStats,\n  type WebSocketRoomId,\n  type WebSocketUserId,\n} from \"./ws-core\";\nimport { WebSocketDeliveryEngine } from \"./ws-delivery\";\nimport { WebSocketLocalConnectionStore } from \"./ws-local-connection-store\";\nimport {\n  InMemoryWebSocketPresenceStore,\n  type WebSocketPresenceStore,\n  type WebSocketSessionPresence,\n} from \"./ws-presence-store\";\nimport {\n  type TelemetryContextProvider,\n  NoopWebSocketTelemetryController,\n  type WebSocketTelemetryConnectionContext,\n  type WebSocketTelemetryController,\n} from \"./ws-telemetry\";\n\nexport type {\n  ManagedWebSocketConnection,\n  WebSocketRegistryStats,\n  WebSocketRoomId,\n  WebSocketUserId,\n};\nexport type WebSocketConnectionMeta = WebSocketSessionPresence;\n\nexport type WebSocketRegistryOptions = {\n  // 분산 환경에서 노드 간 라우팅 식별자로 쓰이므로 반드시 호출 측(WebSocketRuntime)에서 결정해 넘긴다\n  nodeId: string;\n  presenceStore?: WebSocketPresenceStore;\n  clusterBus?: WebSocketClusterBus;\n  telemetryController?: WebSocketTelemetryController;\n};\n\nexport class WebSocketRegistry {\n  readonly nodeId: string;\n  readonly localConnections = new WebSocketLocalConnectionStore();\n  readonly presenceStore: WebSocketPresenceStore;\n  readonly clusterBus: WebSocketClusterBus;\n  readonly audienceResolver: WebSocketAudienceResolver;\n  readonly deliveryEngine: WebSocketDeliveryEngine;\n  readonly telemetryController: WebSocketTelemetryController;\n\n  constructor(options: WebSocketRegistryOptions) {\n    this.nodeId = options.nodeId;\n    this.presenceStore = options.presenceStore ?? new InMemoryWebSocketPresenceStore();\n    this.clusterBus = options.clusterBus ?? new NoopWebSocketClusterBus();\n    this.telemetryController =\n      options.telemetryController ?? new NoopWebSocketTelemetryController();\n    this.audienceResolver = new WebSocketAudienceResolver({\n      nodeId: this.nodeId,\n      presenceStore: this.presenceStore,\n    });\n    this.deliveryEngine = new WebSocketDeliveryEngine({\n      nodeId: this.nodeId,\n      localConnections: this.localConnections,\n      audienceResolver: this.audienceResolver,\n      clusterBus: this.clusterBus,\n      telemetryController: this.telemetryController,\n    });\n\n    this.telemetryController.registerMetricSource({\n      collect: (_now) => {\n        const stats = this.presenceStore.getStats();\n        const localSnapshot = this.localConnections.getTelemetrySnapshot();\n        return {\n          activeConnections: stats.totalConnections,\n          activeConnectionsByNamespace: stats.byNamespace,\n          roomCount: stats.totalRooms,\n          pendingInboundMessages: localSnapshot.pendingInboundMessages,\n          pendingOutboundMessages: localSnapshot.pendingOutboundMessages,\n          socketBufferedBytes: localSnapshot.socketBufferedBytes,\n        };\n      },\n    });\n  }\n\n  register(\n    connection: ManagedWebSocketConnection,\n    active: boolean = true,\n  ): WebSocketConnectionMeta {\n    this.localConnections.register(connection);\n    const meta = this.presenceStore.register({\n      sessionId: connection.id,\n      nodeId: this.nodeId,\n      namespace: connection.namespace,\n      active,\n    });\n    this.telemetryController.emit({\n      name: \"ws.connection.registered\",\n      level: \"info\",\n      connectionId: connection.id,\n      namespace: connection.namespace,\n      userId: connection.userId,\n      ...getConnectionTelemetryContext(connection),\n    });\n    this.telemetryController.recordMetric({\n      name: \"sonamu.ws.connections\",\n      kind: \"counter\",\n      value: 1,\n      unit: \"1\",\n      tags: { outcome: \"registered\", namespace: connection.namespace },\n      userId: connection.userId,\n    });\n    return meta;\n  }\n\n  activate(connectionId: string): void {\n    if (!this.presenceStore.getConnection(connectionId)) {\n      this.emitMutationSkipped(connectionId, { operation: \"activate\" });\n      return;\n    }\n\n    this.presenceStore.activate(connectionId);\n    const connection = this.localConnections.getConnection(connectionId);\n    this.telemetryController.emit({\n      name: \"ws.connection.activated\",\n      level: \"info\",\n      connectionId,\n      userId: connection?.userId,\n      ...getConnectionTelemetryContext(connection),\n    });\n  }\n\n  unregister(connectionId: string): void {\n    const connection = this.localConnections.getConnection(connectionId);\n    const telemetryContext = getConnectionTelemetryContext(connection);\n    const userId =\n      connection?.userId ?? formatUserId(this.presenceStore.getConnection(connectionId)?.userId);\n    const meta = this.presenceStore.unregister(connectionId);\n    this.localConnections.unregister(connectionId);\n    this.telemetryController.emit({\n      name: \"ws.connection.unregistered\",\n      level: \"debug\",\n      connectionId,\n      namespace: meta?.namespace,\n      userId,\n      ...telemetryContext,\n    });\n    if (meta) {\n      this.telemetryController.recordMetric({\n        name: \"sonamu.ws.connections\",\n        kind: \"counter\",\n        value: 1,\n        unit: \"1\",\n        tags: { outcome: \"unregistered\", namespace: meta.namespace },\n        userId,\n      });\n    }\n  }\n\n  touch(connectionId: string): void {\n    this.presenceStore.touch(connectionId);\n  }\n\n  setUserId(connectionId: string, userId: WebSocketUserId): void {\n    if (!this.presenceStore.getConnection(connectionId)) {\n      this.emitMutationSkipped(connectionId, { operation: \"setUserId\", userId });\n      return;\n    }\n\n    this.presenceStore.setUserId(connectionId, userId);\n    const meta = this.presenceStore.getConnection(connectionId);\n    this.telemetryController.emit({\n      name: \"ws.user.bound\",\n      level: \"debug\",\n      connectionId,\n      namespace: meta?.namespace,\n      userId: String(userId),\n      detail: { userId },\n      ...getConnectionTelemetryContext(this.localConnections.getConnection(connectionId)),\n    });\n  }\n\n  clearUserId(connectionId: string): void {\n    const meta = this.presenceStore.getConnection(connectionId);\n    if (!meta) {\n      this.emitMutationSkipped(connectionId, { operation: \"clearUserId\" });\n      return;\n    }\n\n    const userId = meta.userId;\n    this.presenceStore.clearUserId(connectionId);\n    this.telemetryController.emit({\n      name: \"ws.user.cleared\",\n      level: \"debug\",\n      connectionId,\n      namespace: meta.namespace,\n      userId: formatUserId(userId),\n      detail: userId !== undefined ? { userId } : undefined,\n      ...getConnectionTelemetryContext(this.localConnections.getConnection(connectionId)),\n    });\n  }\n\n  join(connectionId: string, roomId: WebSocketRoomId): void {\n    if (!this.presenceStore.getConnection(connectionId)) {\n      this.emitMutationSkipped(connectionId, { operation: \"join\", roomId });\n      return;\n    }\n\n    this.presenceStore.join(connectionId, roomId);\n    const meta = this.presenceStore.getConnection(connectionId);\n    const connection = this.localConnections.getConnection(connectionId);\n    this.telemetryController.emit({\n      name: \"ws.room.joined\",\n      level: \"debug\",\n      connectionId,\n      namespace: meta?.namespace,\n      userId: connection?.userId ?? formatUserId(meta?.userId),\n      detail: { roomId },\n      ...getConnectionTelemetryContext(connection),\n    });\n  }\n\n  leave(connectionId: string, roomId: WebSocketRoomId): void {\n    const meta = this.presenceStore.getConnection(connectionId);\n    if (!meta) {\n      this.emitMutationSkipped(connectionId, { operation: \"leave\", roomId });\n      return;\n    }\n\n    this.presenceStore.leave(connectionId, roomId);\n    const connection = this.localConnections.getConnection(connectionId);\n    this.telemetryController.emit({\n      name: \"ws.room.left\",\n      level: \"debug\",\n      connectionId,\n      namespace: meta.namespace,\n      userId: connection?.userId ?? formatUserId(meta.userId),\n      detail: { roomId },\n      ...getConnectionTelemetryContext(connection),\n    });\n  }\n\n  private emitMutationSkipped(\n    connectionId: string,\n    detail: {\n      operation: \"activate\" | \"setUserId\" | \"clearUserId\" | \"join\" | \"leave\";\n      roomId?: WebSocketRoomId;\n      userId?: WebSocketUserId;\n    },\n  ): void {\n    this.telemetryController.emit({\n      name: \"ws.registry.mutation.skipped\",\n      level: \"debug\",\n      connectionId,\n      detail: { ...detail, reason: \"connectionMissing\" },\n    });\n  }\n\n  broadcast(event: string, data: unknown, namespace?: string): void {\n    this.publishToAudience(WebSocketAudience.all(namespace), event, data);\n  }\n\n  publishToRoom(roomId: WebSocketRoomId, event: string, data: unknown, namespace?: string): void {\n    this.publishToAudience(WebSocketAudience.room(roomId, namespace), event, data);\n  }\n\n  publishToUser(userId: WebSocketUserId, event: string, data: unknown, namespace?: string): void {\n    this.publishToAudience(WebSocketAudience.user(userId, namespace), event, data);\n  }\n\n  publishToAudience(audience: WebSocketAudienceSpec, event: string, data: unknown): void {\n    this.deliveryEngine.publishToAudience(audience, event, data);\n  }\n\n  getConnection(connectionId: string): WebSocketConnectionMeta | undefined {\n    return this.presenceStore.getConnection(connectionId);\n  }\n\n  getConnectionCount(namespace?: string): number {\n    return this.presenceStore.getConnectionCount(namespace);\n  }\n\n  getRoomMembers(roomId: WebSocketRoomId, namespace?: string): WebSocketConnectionMeta[] {\n    return this.presenceStore.getRoomMembers(roomId, namespace);\n  }\n\n  getStats(): WebSocketRegistryStats {\n    return this.presenceStore.getStats();\n  }\n\n  closeAll(code?: number, reason?: string): void {\n    this.localConnections.closeAll(code, reason);\n  }\n\n  async shutdown(code?: number, reason?: string): Promise<void> {\n    this.closeAll(code, reason);\n    await this.deliveryEngine.shutdown();\n  }\n}\n\nfunction getConnectionTelemetryContext(\n  connection: ManagedWebSocketConnection | undefined,\n): WebSocketTelemetryConnectionContext {\n  if (!connection || !isTelemetryContextProvider(connection)) {\n    return {};\n  }\n\n  return connection.getTelemetryContext();\n}\n\n// telemetry record의 userId는 string 정규화 — presence store는 number | string 그대로 보관함\nfunction formatUserId(userId: WebSocketUserId | undefined): string | undefined {\n  return userId === undefined ? undefined : String(userId);\n}\n\nfunction isTelemetryContextProvider(\n  connection: ManagedWebSocketConnection,\n): connection is ManagedWebSocketConnection & TelemetryContextProvider {\n  return (\n    \"getTelemetryContext\" in connection && typeof connection.getTelemetryContext === \"function\"\n  );\n}\n"],"mappings":"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"}

package/dist/stream/ws-telemetry-memory.d.ts

@@ -0,0 +1,28 @@
+import { type WebSocketTelemetryEventQueryFilter, type WebSocketTelemetryEventRecord, type WebSocketTelemetryEventSink, type WebSocketTelemetryEventStore, type WebSocketTelemetryMetricQueryFilter, type WebSocketTelemetryMetricRecord, type WebSocketTelemetryMetricSink, type WebSocketTelemetryMetricStore, type WebSocketTelemetrySpanQueryFilter, type WebSocketTelemetrySpanRecord, type WebSocketTelemetrySpanSink, type WebSocketTelemetrySpanStore } from "./ws-telemetry";
+type InMemoryStoreOptions = {
+    maxRecords?: number;
+    maxBytes?: number;
+};
+export declare class InMemoryEventStore implements WebSocketTelemetryEventStore {
+    readonly sink: WebSocketTelemetryEventSink;
+    private readonly buffer;
+    constructor(options?: InMemoryStoreOptions);
+    query(filter: WebSocketTelemetryEventQueryFilter): WebSocketTelemetryEventRecord[];
+    clear(): void;
+}
+export declare class InMemoryMetricStore implements WebSocketTelemetryMetricStore {
+    readonly sink: WebSocketTelemetryMetricSink;
+    private readonly buffer;
+    constructor(options?: InMemoryStoreOptions);
+    query(filter: WebSocketTelemetryMetricQueryFilter): WebSocketTelemetryMetricRecord[];
+    clear(): void;
+}
+export declare class InMemorySpanStore implements WebSocketTelemetrySpanStore {
+    readonly sink: WebSocketTelemetrySpanSink;
+    private readonly buffer;
+    constructor(options?: InMemoryStoreOptions);
+    query(filter: WebSocketTelemetrySpanQueryFilter): WebSocketTelemetrySpanRecord[];
+    clear(): void;
+}
+export {};
+//# sourceMappingURL=ws-telemetry-memory.d.ts.map

package/dist/stream/ws-telemetry-memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ws-telemetry-memory.d.ts","sourceRoot":"","sources":["../../src/stream/ws-telemetry-memory.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,kCAAkC,EACvC,KAAK,6BAA6B,EAClC,KAAK,2BAA2B,EAChC,KAAK,4BAA4B,EACjC,KAAK,mCAAmC,EACxC,KAAK,8BAA8B,EACnC,KAAK,4BAA4B,EACjC,KAAK,6BAA6B,EAClC,KAAK,iCAAiC,EACtC,KAAK,4BAA4B,EACjC,KAAK,0BAA0B,EAC/B,KAAK,2BAA2B,EACjC,MAAM,gBAAgB,CAAC;AAExB,KAAK,oBAAoB,GAAG;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAuHF,qBAAa,kBAAmB,YAAW,4BAA4B;IACrE,QAAQ,CAAC,IAAI,EAAE,2BAA2B,CAAC;IAE3C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAoD;gBAE/D,OAAO,GAAE,oBAAyB;IAa9C,KAAK,CAAC,MAAM,EAAE,kCAAkC,GAAG,6BAA6B,EAAE;IAclF,KAAK,IAAI,IAAI;CAGd;AAED,qBAAa,mBAAoB,YAAW,6BAA6B;IACvE,QAAQ,CAAC,IAAI,EAAE,4BAA4B,CAAC;IAE5C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqD;gBAEhE,OAAO,GAAE,oBAAyB;IAa9C,KAAK,CAAC,MAAM,EAAE,mCAAmC,GAAG,8BAA8B,EAAE;IAcpF,KAAK,IAAI,IAAI;CAGd;AAED,qBAAa,iBAAkB,YAAW,2BAA2B;IACnE,QAAQ,CAAC,IAAI,EAAE,0BAA0B,CAAC;IAE1C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAmD;gBAE9D,OAAO,GAAE,oBAAyB;IAU9C,KAAK,CAAC,MAAM,EAAE,iCAAiC,GAAG,4BAA4B,EAAE;IAgBhF,KAAK,IAAI,IAAI;CAGd"}

package/dist/stream/ws-telemetry-memory.js

@@ -0,0 +1,180 @@
+import { __esmMin } from "../_virtual/rolldown_runtime.js";
+
+//#region src/stream/ws-telemetry-memory.ts
+function applyTimeWindow(record, since, until) {
+	if (since !== undefined && record.timestamp < since) return false;
+	if (until !== undefined && record.timestamp > until) return false;
+	return true;
+}
+function estimateEventBytes(record) {
+	let size = 200;
+	if (record.payloadPreview !== undefined) {
+		try {
+			size += Buffer.byteLength(JSON.stringify(record.payloadPreview), "utf-8");
+		} catch {
+			size += 100;
+		}
+	}
+	if (record.detail) {
+		try {
+			size += Buffer.byteLength(JSON.stringify(record.detail), "utf-8");
+		} catch {
+			size += 100;
+		}
+	}
+	return size;
+}
+function estimateMetricBytes(_record) {
+	return 200;
+}
+function estimateSpanBytes(_record) {
+	return 200;
+}
+var DEFAULT_MAX_RECORDS, DEFAULT_MAX_BYTES, InMemoryRingBuffer, InMemoryEventStore, InMemoryMetricStore, InMemorySpanStore;
+var init_ws_telemetry_memory = __esmMin((() => {
+	DEFAULT_MAX_RECORDS = 1e4;
+	DEFAULT_MAX_BYTES = 10 * 1024 * 1024;
+	InMemoryRingBuffer = class {
+		slots;
+		slotBytes;
+		capacity;
+		maxBytes;
+		estimateBytes;
+		head = 0;
+		count = 0;
+		currentBytes = 0;
+		constructor(options, estimateBytes) {
+			this.capacity = options.maxRecords ?? DEFAULT_MAX_RECORDS;
+			this.maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+			this.estimateBytes = estimateBytes;
+			this.slots = new Array(this.capacity);
+			this.slotBytes = new Array(this.capacity).fill(0);
+		}
+		push(record) {
+			if (this.capacity <= 0) return;
+			const recordSize = this.estimateBytes(record);
+			if (recordSize > this.maxBytes) return;
+			if (this.count === this.capacity) {
+				this.currentBytes -= this.slotBytes[this.head];
+				this.slots[this.head] = record;
+				this.slotBytes[this.head] = recordSize;
+				this.currentBytes += recordSize;
+				this.head = (this.head + 1) % this.capacity;
+			} else {
+				const tail = (this.head + this.count) % this.capacity;
+				this.slots[tail] = record;
+				this.slotBytes[tail] = recordSize;
+				this.currentBytes += recordSize;
+				this.count += 1;
+			}
+			while (this.currentBytes > this.maxBytes && this.count > 1) {
+				this.currentBytes -= this.slotBytes[this.head];
+				this.slots[this.head] = undefined;
+				this.slotBytes[this.head] = 0;
+				this.head = (this.head + 1) % this.capacity;
+				this.count -= 1;
+			}
+		}
+		filter(predicate, limit) {
+			const matched = [];
+			for (let i = 0; i < this.count; i++) {
+				const record = this.slots[(this.head + i) % this.capacity];
+				if (record !== undefined && predicate(record)) matched.push(record);
+			}
+			if (limit !== undefined && limit > 0 && matched.length > limit) {
+				return matched.slice(-limit);
+			}
+			return matched;
+		}
+		clear() {
+			for (let i = 0; i < this.capacity; i++) {
+				this.slots[i] = undefined;
+				this.slotBytes[i] = 0;
+			}
+			this.head = 0;
+			this.count = 0;
+			this.currentBytes = 0;
+		}
+	};
+	InMemoryEventStore = class {
+		sink;
+		buffer;
+		constructor(options = {}) {
+			this.buffer = new InMemoryRingBuffer(options, estimateEventBytes);
+			this.sink = { emit: (record) => {
+				this.buffer.push(record);
+			} };
+		}
+		query(filter) {
+			return this.buffer.filter((record) => {
+				if (filter.name !== undefined && record.name !== filter.name) return false;
+				if (filter.level !== undefined && record.level !== filter.level) return false;
+				if (filter.connectionId !== undefined && record.connectionId !== filter.connectionId) return false;
+				if (filter.userId !== undefined && record.userId !== filter.userId) return false;
+				if (filter.namespace !== undefined && record.namespace !== filter.namespace) return false;
+				if (filter.traceId !== undefined && record.traceId !== filter.traceId) return false;
+				if (!applyTimeWindow(record, filter.since, filter.until)) return false;
+				return true;
+			}, filter.limit);
+		}
+		clear() {
+			this.buffer.clear();
+		}
+	};
+	InMemoryMetricStore = class {
+		sink;
+		buffer;
+		constructor(options = {}) {
+			this.buffer = new InMemoryRingBuffer(options, estimateMetricBytes);
+			this.sink = { emit: (record) => {
+				this.buffer.push(record);
+			} };
+		}
+		query(filter) {
+			return this.buffer.filter((record) => {
+				if (filter.name !== undefined && record.name !== filter.name) return false;
+				if (filter.kind !== undefined && record.kind !== filter.kind) return false;
+				if (filter.connectionId !== undefined && record.connectionId !== filter.connectionId) return false;
+				if (filter.userId !== undefined && record.userId !== filter.userId) return false;
+				if (filter.namespace !== undefined && record.namespace !== filter.namespace) return false;
+				if (filter.traceId !== undefined && record.traceId !== filter.traceId) return false;
+				if (!applyTimeWindow(record, filter.since, filter.until)) return false;
+				return true;
+			}, filter.limit);
+		}
+		clear() {
+			this.buffer.clear();
+		}
+	};
+	InMemorySpanStore = class {
+		sink;
+		buffer;
+		constructor(options = {}) {
+			this.buffer = new InMemoryRingBuffer(options, estimateSpanBytes);
+			this.sink = { emit: (record) => {
+				this.buffer.push(record);
+			} };
+		}
+		query(filter) {
+			return this.buffer.filter((record) => {
+				if (filter.operationName !== undefined && record.operationName !== filter.operationName) return false;
+				if (filter.kind !== undefined && record.kind !== filter.kind) return false;
+				if (filter.status !== undefined && record.status !== filter.status) return false;
+				if (filter.connectionId !== undefined && record.connectionId !== filter.connectionId) return false;
+				if (filter.userId !== undefined && record.userId !== filter.userId) return false;
+				if (filter.namespace !== undefined && record.namespace !== filter.namespace) return false;
+				if (filter.traceId !== undefined && record.traceId !== filter.traceId) return false;
+				if (!applyTimeWindow(record, filter.since, filter.until)) return false;
+				return true;
+			}, filter.limit);
+		}
+		clear() {
+			this.buffer.clear();
+		}
+	};
+}));
+
+//#endregion
+init_ws_telemetry_memory();
+export { InMemoryEventStore, InMemoryMetricStore, InMemorySpanStore, init_ws_telemetry_memory };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ws-telemetry-memory.js","names":["matched: TRecord[]"],"sources":["../../src/stream/ws-telemetry-memory.ts"],"sourcesContent":["import {\n  type WebSocketTelemetryEventQueryFilter,\n  type WebSocketTelemetryEventRecord,\n  type WebSocketTelemetryEventSink,\n  type WebSocketTelemetryEventStore,\n  type WebSocketTelemetryMetricQueryFilter,\n  type WebSocketTelemetryMetricRecord,\n  type WebSocketTelemetryMetricSink,\n  type WebSocketTelemetryMetricStore,\n  type WebSocketTelemetrySpanQueryFilter,\n  type WebSocketTelemetrySpanRecord,\n  type WebSocketTelemetrySpanSink,\n  type WebSocketTelemetrySpanStore,\n} from \"./ws-telemetry\";\n\ntype InMemoryStoreOptions = {\n  maxRecords?: number;\n  maxBytes?: number;\n};\n\nconst DEFAULT_MAX_RECORDS = 10_000;\nconst DEFAULT_MAX_BYTES = 10 * 1024 * 1024; // 10 MiB\n\ntype EstimateBytes<TRecord> = (record: TRecord) => number;\n\n// 단일 FIFO ring buffer. critical/non-critical 우선순위는 두지 않는다 —\n// 인메모리 store는 휘발성 디버깅 용도이므로 critical 보존이 필요하면\n// 별도의 영속 sink를 등록해서 처리한다.\nclass InMemoryRingBuffer<TRecord extends { timestamp: number }> {\n  private readonly slots: Array<TRecord | undefined>;\n  private readonly slotBytes: number[];\n  private readonly capacity: number;\n  private readonly maxBytes: number;\n  private readonly estimateBytes: EstimateBytes<TRecord>;\n  private head = 0;\n  private count = 0;\n  private currentBytes = 0;\n\n  constructor(options: InMemoryStoreOptions, estimateBytes: EstimateBytes<TRecord>) {\n    this.capacity = options.maxRecords ?? DEFAULT_MAX_RECORDS;\n    this.maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;\n    this.estimateBytes = estimateBytes;\n    this.slots = new Array(this.capacity);\n    this.slotBytes = new Array(this.capacity).fill(0);\n  }\n\n  push(record: TRecord): void {\n    if (this.capacity <= 0) return;\n\n    const recordSize = this.estimateBytes(record);\n    // 단일 record가 maxBytes를 넘으면 받아들이지 않는다.\n    if (recordSize > this.maxBytes) return;\n\n    if (this.count === this.capacity) {\n      // 가장 오래된 슬롯을 덮어쓴다.\n      this.currentBytes -= this.slotBytes[this.head];\n      this.slots[this.head] = record;\n      this.slotBytes[this.head] = recordSize;\n      this.currentBytes += recordSize;\n      this.head = (this.head + 1) % this.capacity;\n    } else {\n      const tail = (this.head + this.count) % this.capacity;\n      this.slots[tail] = record;\n      this.slotBytes[tail] = recordSize;\n      this.currentBytes += recordSize;\n      this.count += 1;\n    }\n\n    while (this.currentBytes > this.maxBytes && this.count > 1) {\n      this.currentBytes -= this.slotBytes[this.head];\n      this.slots[this.head] = undefined;\n      this.slotBytes[this.head] = 0;\n      this.head = (this.head + 1) % this.capacity;\n      this.count -= 1;\n    }\n  }\n\n  filter(predicate: (record: TRecord) => boolean, limit?: number): TRecord[] {\n    const matched: TRecord[] = [];\n    for (let i = 0; i < this.count; i++) {\n      const record = this.slots[(this.head + i) % this.capacity];\n      if (record !== undefined && predicate(record)) matched.push(record);\n    }\n    if (limit !== undefined && limit > 0 && matched.length > limit) {\n      return matched.slice(-limit);\n    }\n    return matched;\n  }\n\n  clear(): void {\n    for (let i = 0; i < this.capacity; i++) {\n      this.slots[i] = undefined;\n      this.slotBytes[i] = 0;\n    }\n    this.head = 0;\n    this.count = 0;\n    this.currentBytes = 0;\n  }\n}\n\nfunction applyTimeWindow<TRecord extends { timestamp: number }>(\n  record: TRecord,\n  since: number | undefined,\n  until: number | undefined,\n): boolean {\n  if (since !== undefined && record.timestamp < since) return false;\n  if (until !== undefined && record.timestamp > until) return false;\n  return true;\n}\n\nfunction estimateEventBytes(record: WebSocketTelemetryEventRecord): number {\n  let size = 200;\n  if (record.payloadPreview !== undefined) {\n    try {\n      size += Buffer.byteLength(JSON.stringify(record.payloadPreview), \"utf-8\");\n    } catch {\n      size += 100;\n    }\n  }\n  if (record.detail) {\n    try {\n      size += Buffer.byteLength(JSON.stringify(record.detail), \"utf-8\");\n    } catch {\n      size += 100;\n    }\n  }\n  return size;\n}\n\nfunction estimateMetricBytes(_record: WebSocketTelemetryMetricRecord): number {\n  return 200;\n}\n\nfunction estimateSpanBytes(_record: WebSocketTelemetrySpanRecord): number {\n  return 200;\n}\n\nexport class InMemoryEventStore implements WebSocketTelemetryEventStore {\n  readonly sink: WebSocketTelemetryEventSink;\n\n  private readonly buffer: InMemoryRingBuffer<WebSocketTelemetryEventRecord>;\n\n  constructor(options: InMemoryStoreOptions = {}) {\n    this.buffer = new InMemoryRingBuffer<WebSocketTelemetryEventRecord>(\n      options,\n      estimateEventBytes,\n    );\n\n    this.sink = {\n      emit: (record: WebSocketTelemetryEventRecord): void => {\n        this.buffer.push(record);\n      },\n    };\n  }\n\n  query(filter: WebSocketTelemetryEventQueryFilter): WebSocketTelemetryEventRecord[] {\n    return this.buffer.filter((record) => {\n      if (filter.name !== undefined && record.name !== filter.name) return false;\n      if (filter.level !== undefined && record.level !== filter.level) return false;\n      if (filter.connectionId !== undefined && record.connectionId !== filter.connectionId)\n        return false;\n      if (filter.userId !== undefined && record.userId !== filter.userId) return false;\n      if (filter.namespace !== undefined && record.namespace !== filter.namespace) return false;\n      if (filter.traceId !== undefined && record.traceId !== filter.traceId) return false;\n      if (!applyTimeWindow(record, filter.since, filter.until)) return false;\n      return true;\n    }, filter.limit);\n  }\n\n  clear(): void {\n    this.buffer.clear();\n  }\n}\n\nexport class InMemoryMetricStore implements WebSocketTelemetryMetricStore {\n  readonly sink: WebSocketTelemetryMetricSink;\n\n  private readonly buffer: InMemoryRingBuffer<WebSocketTelemetryMetricRecord>;\n\n  constructor(options: InMemoryStoreOptions = {}) {\n    this.buffer = new InMemoryRingBuffer<WebSocketTelemetryMetricRecord>(\n      options,\n      estimateMetricBytes,\n    );\n\n    this.sink = {\n      emit: (record: WebSocketTelemetryMetricRecord): void => {\n        this.buffer.push(record);\n      },\n    };\n  }\n\n  query(filter: WebSocketTelemetryMetricQueryFilter): WebSocketTelemetryMetricRecord[] {\n    return this.buffer.filter((record) => {\n      if (filter.name !== undefined && record.name !== filter.name) return false;\n      if (filter.kind !== undefined && record.kind !== filter.kind) return false;\n      if (filter.connectionId !== undefined && record.connectionId !== filter.connectionId)\n        return false;\n      if (filter.userId !== undefined && record.userId !== filter.userId) return false;\n      if (filter.namespace !== undefined && record.namespace !== filter.namespace) return false;\n      if (filter.traceId !== undefined && record.traceId !== filter.traceId) return false;\n      if (!applyTimeWindow(record, filter.since, filter.until)) return false;\n      return true;\n    }, filter.limit);\n  }\n\n  clear(): void {\n    this.buffer.clear();\n  }\n}\n\nexport class InMemorySpanStore implements WebSocketTelemetrySpanStore {\n  readonly sink: WebSocketTelemetrySpanSink;\n\n  private readonly buffer: InMemoryRingBuffer<WebSocketTelemetrySpanRecord>;\n\n  constructor(options: InMemoryStoreOptions = {}) {\n    this.buffer = new InMemoryRingBuffer<WebSocketTelemetrySpanRecord>(options, estimateSpanBytes);\n\n    this.sink = {\n      emit: (record: WebSocketTelemetrySpanRecord): void => {\n        this.buffer.push(record);\n      },\n    };\n  }\n\n  query(filter: WebSocketTelemetrySpanQueryFilter): WebSocketTelemetrySpanRecord[] {\n    return this.buffer.filter((record) => {\n      if (filter.operationName !== undefined && record.operationName !== filter.operationName)\n        return false;\n      if (filter.kind !== undefined && record.kind !== filter.kind) return false;\n      if (filter.status !== undefined && record.status !== filter.status) return false;\n      if (filter.connectionId !== undefined && record.connectionId !== filter.connectionId)\n        return false;\n      if (filter.userId !== undefined && record.userId !== filter.userId) return false;\n      if (filter.namespace !== undefined && record.namespace !== filter.namespace) return false;\n      if (filter.traceId !== undefined && record.traceId !== filter.traceId) return false;\n      if (!applyTimeWindow(record, filter.since, filter.until)) return false;\n      return true;\n    }, filter.limit);\n  }\n\n  clear(): void {\n    this.buffer.clear();\n  }\n}\n"],"mappings":"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"}

package/dist/stream/ws-telemetry-trace.d.ts

@@ -0,0 +1,12 @@
+export type ParsedTraceParent = {
+    version: string;
+    traceId: string;
+    parentId: string;
+    traceFlags: number;
+    sampled: boolean;
+};
+export declare function parseTraceParent(header: string): ParsedTraceParent | null;
+export declare function generateTraceId(): string;
+export declare function generateSpanId(): string;
+export declare function formatTraceParent(traceId: string, spanId: string, sampled: boolean): string;
+//# sourceMappingURL=ws-telemetry-trace.d.ts.map

package/dist/stream/ws-telemetry-trace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ws-telemetry-trace.d.ts","sourceRoot":"","sources":["../../src/stream/ws-telemetry-trace.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAQF,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI,CAsBzE;AAED,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAED,wBAAgB,cAAc,IAAI,MAAM,CAEvC;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAG3F"}

package/dist/stream/ws-telemetry-trace.js

@@ -0,0 +1,41 @@
+import { __esmMin } from "../_virtual/rolldown_runtime.js";
+import { randomBytes } from "node:crypto";
+
+//#region src/stream/ws-telemetry-trace.ts
+function parseTraceParent(header) {
+	const trimmed = header.trim().toLowerCase();
+	const match = TRACEPARENT_REGEX.exec(trimmed);
+	if (!match) return null;
+	const [, version, traceId, parentId, flagsHex] = match;
+	if (version === "ff") return null;
+	if (traceId === ALL_ZERO_TRACE_ID || parentId === ALL_ZERO_SPAN_ID) return null;
+	const traceFlags = parseInt(flagsHex, 16);
+	return {
+		version,
+		traceId,
+		parentId,
+		traceFlags,
+		sampled: (traceFlags & 1) === 1
+	};
+}
+function generateTraceId() {
+	return randomBytes(16).toString("hex");
+}
+function generateSpanId() {
+	return randomBytes(8).toString("hex");
+}
+function formatTraceParent(traceId, spanId, sampled) {
+	const flags = sampled ? "01" : "00";
+	return `00-${traceId}-${spanId}-${flags}`;
+}
+var TRACEPARENT_REGEX, ALL_ZERO_TRACE_ID, ALL_ZERO_SPAN_ID;
+var init_ws_telemetry_trace = __esmMin((() => {
+	TRACEPARENT_REGEX = /^([0-9a-f]{2})-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})$/;
+	ALL_ZERO_TRACE_ID = "00000000000000000000000000000000";
+	ALL_ZERO_SPAN_ID = "0000000000000000";
+}));
+
+//#endregion
+init_ws_telemetry_trace();
+export { formatTraceParent, generateSpanId, generateTraceId, init_ws_telemetry_trace, parseTraceParent };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid3MtdGVsZW1ldHJ5LXRyYWNlLmpzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zdHJlYW0vd3MtdGVsZW1ldHJ5LXRyYWNlLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IHJhbmRvbUJ5dGVzIH0gZnJvbSBcIm5vZGU6Y3J5cHRvXCI7XG5cbmV4cG9ydCB0eXBlIFBhcnNlZFRyYWNlUGFyZW50ID0ge1xuICB2ZXJzaW9uOiBzdHJpbmc7XG4gIHRyYWNlSWQ6IHN0cmluZztcbiAgcGFyZW50SWQ6IHN0cmluZztcbiAgdHJhY2VGbGFnczogbnVtYmVyO1xuICBzYW1wbGVkOiBib29sZWFuO1xufTtcblxuLy8gdHJhY2VwYXJlbnQg7Y+s66e3OiAwMC08MzIgaGV4IHRyYWNlSWQ+LTwxNiBoZXggc3BhbklkPi08MiBoZXggZmxhZ3M+XG4vLyDsmIjsi5w6IDAwLTRiZjkyZjM1NzdiMTZkOGEyZTNlMjRmZjAyZTZjOTk4LTAwZjA2N2FhMGJhOTAyYjctMDFcbmNvbnN0IFRSQUNFUEFSRU5UX1JFR0VYID0gL14oWzAtOWEtZl17Mn0pLShbMC05YS1mXXszMn0pLShbMC05YS1mXXsxNn0pLShbMC05YS1mXXsyfSkkLztcbmNvbnN0IEFMTF9aRVJPX1RSQUNFX0lEID0gXCIwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMFwiO1xuY29uc3QgQUxMX1pFUk9fU1BBTl9JRCA9IFwiMDAwMDAwMDAwMDAwMDAwMFwiO1xuXG5leHBvcnQgZnVuY3Rpb24gcGFyc2VUcmFjZVBhcmVudChoZWFkZXI6IHN0cmluZyk6IFBhcnNlZFRyYWNlUGFyZW50IHwgbnVsbCB7XG4gIGNvbnN0IHRyaW1tZWQgPSBoZWFkZXIudHJpbSgpLnRvTG93ZXJDYXNlKCk7XG4gIGNvbnN0IG1hdGNoID0gVFJBQ0VQQVJFTlRfUkVHRVguZXhlYyh0cmltbWVkKTtcbiAgaWYgKCFtYXRjaCkgcmV0dXJuIG51bGw7XG5cbiAgY29uc3QgWywgdmVyc2lvbiwgdHJhY2VJZCwgcGFyZW50SWQsIGZsYWdzSGV4XSA9IG1hdGNoO1xuXG4gIC8vIGZm64qUIFczQyBUcmFjZSBDb250ZXh0IOyKpO2OmeyXkOyEnCBpbnZhbGlkIHZlcnNpb24gbWFya2Vy66GcIOyYiOyVveuQmOyWtCDsnojsnYxcbiAgaWYgKHZlcnNpb24gPT09IFwiZmZcIikgcmV0dXJuIG51bGw7XG5cbiAgLy8gVzNDIOyKpO2OmeyXkCDrlLDrnbwg66qo65GQIDDsnbggdHJhY2UgaWQgLyBzcGFuIGlk64qUIOycoO2aqO2VmOyngCDslYrsnYxcbiAgaWYgKHRyYWNlSWQgPT09IEFMTF9aRVJPX1RSQUNFX0lEIHx8IHBhcmVudElkID09PSBBTExfWkVST19TUEFOX0lEKSByZXR1cm4gbnVsbDtcblxuICBjb25zdCB0cmFjZUZsYWdzID0gcGFyc2VJbnQoZmxhZ3NIZXgsIDE2KTtcblxuICByZXR1cm4ge1xuICAgIHZlcnNpb24sXG4gICAgdHJhY2VJZCxcbiAgICBwYXJlbnRJZCxcbiAgICB0cmFjZUZsYWdzLFxuICAgIHNhbXBsZWQ6ICh0cmFjZUZsYWdzICYgMHgwMSkgPT09IDEsXG4gIH07XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBnZW5lcmF0ZVRyYWNlSWQoKTogc3RyaW5nIHtcbiAgcmV0dXJuIHJhbmRvbUJ5dGVzKDE2KS50b1N0cmluZyhcImhleFwiKTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGdlbmVyYXRlU3BhbklkKCk6IHN0cmluZyB7XG4gIHJldHVybiByYW5kb21CeXRlcyg4KS50b1N0cmluZyhcImhleFwiKTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGZvcm1hdFRyYWNlUGFyZW50KHRyYWNlSWQ6IHN0cmluZywgc3BhbklkOiBzdHJpbmcsIHNhbXBsZWQ6IGJvb2xlYW4pOiBzdHJpbmcge1xuICBjb25zdCBmbGFncyA9IHNhbXBsZWQgPyBcIjAxXCIgOiBcIjAwXCI7XG4gIHJldHVybiBgMDAtJHt0cmFjZUlkfS0ke3NwYW5JZH0tJHtmbGFnc31gO1xufVxuIl0sIm1hcHBpbmdzIjoiOzs7O0FBZ0JBLFNBQWdCLGlCQUFpQixRQUEwQztDQUN6RSxNQUFNLFVBQVUsT0FBTyxNQUFNLENBQUMsYUFBYTtDQUMzQyxNQUFNLFFBQVEsa0JBQWtCLEtBQUssUUFBUTtBQUM3QyxLQUFJLENBQUMsTUFBTyxRQUFPO0NBRW5CLE1BQU0sR0FBRyxTQUFTLFNBQVMsVUFBVSxZQUFZO0FBR2pELEtBQUksWUFBWSxLQUFNLFFBQU87QUFHN0IsS0FBSSxZQUFZLHFCQUFxQixhQUFhLGlCQUFrQixRQUFPO0NBRTNFLE1BQU0sYUFBYSxTQUFTLFVBQVUsR0FBRztBQUV6QyxRQUFPO0VBQ0w7RUFDQTtFQUNBO0VBQ0E7RUFDQSxVQUFVLGFBQWEsT0FBVTtFQUNsQzs7QUFHSCxTQUFnQixrQkFBMEI7QUFDeEMsUUFBTyxZQUFZLEdBQUcsQ0FBQyxTQUFTLE1BQU07O0FBR3hDLFNBQWdCLGlCQUF5QjtBQUN2QyxRQUFPLFlBQVksRUFBRSxDQUFDLFNBQVMsTUFBTTs7QUFHdkMsU0FBZ0Isa0JBQWtCLFNBQWlCLFFBQWdCLFNBQTBCO0NBQzNGLE1BQU0sUUFBUSxVQUFVLE9BQU87QUFDL0IsUUFBTyxNQUFNLFFBQVEsR0FBRyxPQUFPLEdBQUc7Ozs7Q0F0QzlCLG9CQUFvQjtDQUNwQixvQkFBb0I7Q0FDcEIsbUJBQW1CIn0=