message-nexus 1.0.1 → 1.1.0

package/dist/index.d.ts

@@ -1,15 +1,34 @@
 import { Emitter } from 'mitt';
 
-interface Message {
-    id: string;
-    type: string;
-    payload?: unknown;
+type JsonRpcId = string | number | null;
+interface JsonRpcRequest {
+    jsonrpc: '2.0';
+    method: string;
+    params?: unknown;
+    id: JsonRpcId;
+}
+interface JsonRpcNotification {
+    jsonrpc: '2.0';
+    method: string;
+    params?: unknown;
+}
+interface JsonRpcResponse {
+    jsonrpc: '2.0';
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+    id: JsonRpcId;
+}
+interface NexusEnvelope<T = JsonRpcRequest | JsonRpcResponse | JsonRpcNotification> {
     from: string;
     to?: string;
     metadata?: Record<string, unknown>;
-    isResponse?: boolean;
-    error?: unknown;
+    payload: T;
 }
+type Message = NexusEnvelope;
 declare class BaseDriver {
     onMessage: ((data: Message) => void) | null;
     constructor();
@@ -59,11 +78,26 @@ interface LogEntry {
     context?: string;
 }
 type LogHandler = (entry: LogEntry) => void;
-declare class Logger {
+interface LoggerInterface {
+    addHandler(handler: LogHandler): void;
+    setMinLevel(level: LogLevel): void;
+    enable(): void;
+    disable(): void;
+    isEnabled(): boolean;
+    debug(message: string, metadata?: Record<string, unknown>): void;
+    info(message: string, metadata?: Record<string, unknown>): void;
+    warn(message: string, metadata?: Record<string, unknown>): void;
+    error(message: string, metadata?: Record<string, unknown>): void;
+}
+declare class Logger implements LoggerInterface {
     private handlers;
     private context;
     private minLevel;
-    constructor(context: string, minLevel?: LogLevel);
+    private enabled;
+    constructor(context: string, minLevel?: LogLevel, enabled?: boolean);
+    enable(): void;
+    disable(): void;
+    isEnabled(): boolean;
     addHandler(handler: LogHandler): void;
     setMinLevel(level: LogLevel): void;
     private shouldLog;
@@ -83,6 +117,7 @@ interface WebSocketDriverOptions {
     url: string;
     reconnect?: boolean | ReconnectOptions;
     logger?: Logger;
+    onStatusChange?: (status: 'connecting' | 'connected' | 'disconnected' | 'error') => void;
 }
 declare class WebSocketDriver extends BaseDriver {
     private url;
@@ -94,6 +129,7 @@ declare class WebSocketDriver extends BaseDriver {
     private reconnectTimer;
     private isManuallyClosed;
     private logger;
+    private onStatusChange?;
     constructor(options: WebSocketDriverOptions);
     private connect;
     private scheduleReconnect;
@@ -107,21 +143,32 @@ declare function createEmitter(): Emitter<Record<string, Message>>;
 interface MessageNexusOptions {
     instanceId?: string;
     timeout?: number;
-    logger?: Logger;
+    logger?: LoggerInterface;
+    loggerEnabled?: boolean;
 }
-interface RequestOptions {
-    type: string;
-    payload?: unknown;
+interface InvokeOptions {
+    method: string;
+    params?: unknown;
     to?: string;
     metadata?: Record<string, unknown>;
     timeout?: number;
     retryCount?: number;
     retryDelay?: number;
 }
-interface CommandMessage extends Message {
-    type: string;
-    payload?: unknown;
+interface NotificationOptions {
+    method: string;
+    params?: unknown;
+    to?: string;
+    metadata?: Record<string, unknown>;
+}
+interface InvokeContext {
+    messageId?: string;
+    from: string;
+    to?: string;
+    metadata?: Record<string, unknown>;
 }
+type InvokeHandler<Params = any, Result = any> = (params: Params, context: InvokeContext) => Result | Promise<Result>;
+type NotificationHandler<Params = any> = (params: Params, context: InvokeContext) => void;
 type ErrorHandler = (error: Error, context?: Record<string, unknown>) => void;
 interface Metrics {
     messagesSent: number;
@@ -133,21 +180,17 @@ interface Metrics {
     averageLatency: number;
 }
 type MetricsCallback = (metrics: Metrics) => void;
-declare class MessageNexus<RequestPayload = unknown, ResponsePayload = unknown> {
+declare class MessageNexus<GlobalRequestPayload = unknown, GlobalResponsePayload = unknown> {
     driver: BaseDriver;
     pendingTasks: Map<string, {
-        resolve: (value: ResponsePayload) => void;
+        resolve: (value: any) => void;
         reject: (reason?: unknown) => void;
         timer: ReturnType<typeof setTimeout>;
         to?: string;
         timestamp: number;
     }>;
-    incomingMessages: Map<string, {
-        from?: string;
-        type: string;
-        timestamp: number;
-    }>;
-    messageHandlers: Set<(data: CommandMessage) => void>;
+    invokeHandlers: Map<string, InvokeHandler>;
+    notificationHandlers: Map<string, Set<NotificationHandler>>;
     timeout: number;
     instanceId: string;
     private cleanupInterval;
@@ -158,18 +201,23 @@ declare class MessageNexus<RequestPayload = unknown, ResponsePayload = unknown>
     private metrics;
     private metricsCallbacks;
     constructor(driver: BaseDriver, options?: MessageNexusOptions);
-    request(typeOrOptions: string | RequestOptions): Promise<ResponsePayload>;
+    invoke<T = GlobalResponsePayload>(methodOrOptions: string | InvokeOptions): Promise<T>;
     private _sendMessage;
     onError(handler: ErrorHandler): () => void;
     flushQueue(): void;
+    notify(methodOrOptions: string | NotificationOptions): void;
     private _validateMessage;
-    _handleIncoming(data: unknown): void;
+    _handleIncoming(data: unknown): Promise<void>;
     getMetrics(): Metrics;
     onMetrics(callback: MetricsCallback): () => boolean;
     private _notifyMetrics;
-    onCommand(handler: (data: CommandMessage) => void): () => boolean;
-    reply(messageId: string, payload: unknown, error?: unknown): void;
+    handle<Params = any, Result = any>(method: string, handler: InvokeHandler<Params, Result>): () => boolean;
+    removeHandler(method: string): void;
+    onNotification<Params = any>(method: string, handler: NotificationHandler<Params>): () => void;
+    offNotification(method: string, handler: NotificationHandler<any>): void;
+    private _reply;
+    private _replyError;
     destroy(): void;
 }
 
-export { BaseDriver, BroadcastDriver, type CommandMessage, type ErrorHandler, type Message, type MessageNexusOptions, type Metrics, type MetricsCallback, MittDriver, PostMessageDriver, type RequestOptions, WebSocketDriver, createEmitter, MessageNexus as default };
+export { BaseDriver, BroadcastDriver, type ErrorHandler, type InvokeContext, type InvokeHandler, type InvokeOptions, type LoggerInterface, type Message, type MessageNexusOptions, type Metrics, type MetricsCallback, MittDriver, type NotificationHandler, type NotificationOptions, PostMessageDriver, WebSocketDriver, createEmitter, MessageNexus as default };

package/dist/index.js

@@ -52,7 +52,7 @@ var BroadcastDriver = class extends BaseDriver {
 };
 
 // src/drivers/MittDriver.ts
-var eventIndicator = "message_bridge_message_event";
+var eventIndicator = "message_nexus_message_event";
 var MittDriver = class extends BaseDriver {
   constructor(emitter) {
     super();
@@ -121,11 +121,26 @@ var PostMessageDriver = class extends BaseDriver {
 };
 
 // src/utils/logger.ts
+function isLogger(value) {
+  if (value == null || typeof value !== "object") return false;
+  const logger = value;
+  return typeof logger.addHandler === "function" && typeof logger.setMinLevel === "function" && typeof logger.enable === "function" && typeof logger.disable === "function" && typeof logger.isEnabled === "function" && typeof logger.debug === "function" && typeof logger.info === "function" && typeof logger.warn === "function" && typeof logger.error === "function";
+}
 var Logger = class {
-  constructor(context, minLevel = "info" /* INFO */) {
+  constructor(context, minLevel = "info" /* INFO */, enabled = false) {
     this.handlers = [];
     this.context = context;
     this.minLevel = minLevel;
+    this.enabled = enabled;
+  }
+  enable() {
+    this.enabled = true;
+  }
+  disable() {
+    this.enabled = false;
+  }
+  isEnabled() {
+    return this.enabled;
   }
   addHandler(handler) {
     this.handlers.push(handler);
@@ -138,7 +153,7 @@ var Logger = class {
     return levels.indexOf(level) >= levels.indexOf(this.minLevel);
   }
   log(level, message, metadata) {
-    if (!this.shouldLog(level)) return;
+    if (!this.enabled || !this.shouldLog(level)) return;
     const entry = {
       level,
       timestamp: Date.now(),
@@ -161,9 +176,19 @@ var Logger = class {
     this.log("error" /* ERROR */, message, metadata);
   }
 };
+function genTimestamp() {
+  const now = /* @__PURE__ */ new Date();
+  return now.toLocaleTimeString("zh-CN", {
+    hour12: false,
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    fractionalSecondDigits: 3
+  });
+}
 var createConsoleHandler = () => {
   return (entry) => {
-    const timestamp = new Date(entry.timestamp).toISOString();
+    const timestamp = genTimestamp();
     const prefix = `[${timestamp}] [${entry.level.toUpperCase()}] [${entry.context || "app"}]`;
     const logFn = entry.level === "debug" /* DEBUG */ ? console.debug : entry.level === "info" /* INFO */ ? console.info : entry.level === "warn" /* WARN */ ? console.warn : console.error;
     if (entry.metadata) {
@@ -189,13 +214,16 @@ var WebSocketDriver = class extends BaseDriver {
     this.retryInterval = (typeof options.reconnect === "object" ? options.reconnect.retryInterval : void 0) ?? 5e3;
     this.logger = options.logger || new Logger("WebSocketDriver");
     this.logger.addHandler(createConsoleHandler());
+    this.onStatusChange = options.onStatusChange;
     this.connect();
   }
   connect() {
+    this.onStatusChange?.("connecting");
     this.ws = new WebSocket(this.url);
     this.ws.addEventListener("open", () => {
       this.logger.info("WebSocket connected", { url: this.url });
       this.retryCount = 0;
+      this.onStatusChange?.("connected");
     });
     this.ws.addEventListener("message", (event) => {
       try {
@@ -213,6 +241,7 @@ var WebSocketDriver = class extends BaseDriver {
     });
     this.ws.addEventListener("error", (event) => {
       this.logger.error("WebSocket error", { event });
+      this.onStatusChange?.("error");
     });
     this.ws.addEventListener("close", () => {
       this.logger.info("WebSocket connection closed", {
@@ -222,6 +251,8 @@ var WebSocketDriver = class extends BaseDriver {
       });
       if (!this.isManuallyClosed && this.reconnectEnabled && this.retryCount < this.maxRetries) {
         this.scheduleReconnect();
+      } else {
+        this.onStatusChange?.("disconnected");
       }
     });
   }
@@ -234,6 +265,7 @@ var WebSocketDriver = class extends BaseDriver {
       maxRetries: this.maxRetries,
       url: this.url
     });
+    this.onStatusChange?.("connecting");
     this.reconnectTimer = window.setTimeout(() => {
       this.connect();
     }, delay);
@@ -264,6 +296,7 @@ var WebSocketDriver = class extends BaseDriver {
       this.ws.close();
       this.ws = null;
     }
+    this.onStatusChange?.("disconnected");
   }
   destroy() {
     this.close();
@@ -297,45 +330,45 @@ var MessageNexus = class {
     this.driver = driver;
     this.instanceId = options?.instanceId || crypto.randomUUID();
     this.timeout = options?.timeout ?? 1e4;
-    this.logger = options?.logger || new Logger("MessageNexus");
-    this.logger.addHandler(createConsoleHandler());
+    if (options?.logger && isLogger(options.logger)) {
+      this.logger = options.logger;
+    } else {
+      this.logger = new Logger("MessageNexus");
+    }
+    const loggerEnabled = options?.loggerEnabled ?? false;
+    if (loggerEnabled) {
+      this.logger.enable();
+      this.logger.addHandler(createConsoleHandler());
+      this.logger.info("MessageNexus initialized", {
+        instanceId: this.instanceId,
+        timeout: this.timeout
+      });
+    }
     this.pendingTasks = /* @__PURE__ */ new Map();
-    this.incomingMessages = /* @__PURE__ */ new Map();
-    this.messageHandlers = /* @__PURE__ */ new Set();
+    this.invokeHandlers = /* @__PURE__ */ new Map();
+    this.notificationHandlers = /* @__PURE__ */ new Map();
     this.cleanupInterval = null;
     this.driver.onMessage = (data) => this._handleIncoming(data);
-    this.logger.info("MessageNexus initialized", {
-      instanceId: this.instanceId,
-      timeout: this.timeout
-    });
-    this.cleanupInterval = window.setInterval(() => {
-      const now = Date.now();
-      for (const [id, msg] of this.incomingMessages.entries()) {
-        if (now - msg.timestamp > this.timeout * 2) {
-          this.incomingMessages.delete(id);
-        }
-      }
-    }, 6e4);
   }
-  async request(typeOrOptions) {
+  async invoke(methodOrOptions) {
     const id = crypto.randomUUID();
-    let type;
-    let payload;
+    let method;
+    let params;
     let to;
     let metadata;
     let timeout;
     let retryCount = 0;
     let retryDelay = 1e3;
-    if (typeof typeOrOptions === "string") {
-      type = typeOrOptions;
-      payload = void 0;
+    if (typeof methodOrOptions === "string") {
+      method = methodOrOptions;
+      params = void 0;
       to = void 0;
       metadata = {};
       timeout = this.timeout;
     } else {
-      const opts = typeOrOptions;
-      type = opts.type;
-      payload = opts.payload;
+      const opts = methodOrOptions;
+      method = opts.method;
+      params = opts.params;
       to = opts.to;
       metadata = opts.metadata || {};
       timeout = opts.timeout ?? this.timeout;
@@ -348,16 +381,20 @@ var MessageNexus = class {
           this.pendingTasks.delete(id);
           this.metrics.messagesFailed++;
           this.metrics.pendingMessages--;
-          reject(new Error(`Message timeout: ${type} (${id})`));
+          reject(new Error(`Message timeout: ${method} (${id})`));
         }, timeout);
         this.pendingTasks.set(id, { resolve, reject, timer, timestamp: Date.now() });
+        const rpcRequest = {
+          jsonrpc: "2.0",
+          method,
+          params,
+          id
+        };
         const message = {
-          id,
-          type,
-          payload,
           from: this.instanceId,
           to,
-          metadata: { ...metadata, timestamp: Date.now() }
+          metadata: { ...metadata, timestamp: Date.now() },
+          payload: rpcRequest
         };
         this._sendMessage(message);
       }).catch((error) => {
@@ -374,20 +411,26 @@ var MessageNexus = class {
     return attempt(0);
   }
   _sendMessage(message) {
+    const payload = message.payload;
+    const isRequest = "method" in payload;
+    const messageId = "id" in payload ? String(payload.id) : void 0;
+    const typeOrMethod = isRequest ? payload.method : "RESPONSE";
     try {
       this.driver.send(message);
       this.metrics.messagesSent++;
-      this.metrics.pendingMessages++;
-      this.logger.debug("Message sent", { messageId: message.id, type: message.type });
+      if (isRequest && messageId !== void 0) {
+        this.metrics.pendingMessages++;
+      }
+      this.logger.debug("Message sent", { messageId, type: typeOrMethod });
     } catch (error) {
       const err = error instanceof Error ? error : new Error(String(error));
       this.metrics.messagesFailed++;
-      this.logger.error("Failed to send message", { error: err.message, messageId: message.id });
+      this.logger.error("Failed to send message", { error: err.message, messageId });
       this.errorHandler?.(err, { message });
       if (this.messageQueue.length < this.maxQueueSize) {
         this.messageQueue.push(message);
         this.logger.debug("Message queued", {
-          messageId: message.id,
+          messageId,
           queueSize: this.messageQueue.length + 1
         });
       } else {
@@ -420,55 +463,145 @@ var MessageNexus = class {
       }
     }
   }
+  notify(methodOrOptions) {
+    let method;
+    let params;
+    let to;
+    let metadata;
+    if (typeof methodOrOptions === "string") {
+      method = methodOrOptions;
+      params = void 0;
+      to = void 0;
+      metadata = {};
+    } else {
+      const opts = methodOrOptions;
+      method = opts.method;
+      params = opts.params;
+      to = opts.to;
+      metadata = opts.metadata || {};
+    }
+    const rpcNotification = {
+      jsonrpc: "2.0",
+      method,
+      params
+    };
+    const message = {
+      from: this.instanceId,
+      to,
+      metadata: { ...metadata, timestamp: Date.now() },
+      payload: rpcNotification
+    };
+    this._sendMessage(message);
+  }
   _validateMessage(data) {
     if (!data || typeof data !== "object") return false;
-    const msg = data;
-    if (typeof msg.id !== "string") return false;
-    if (typeof msg.type !== "string") return false;
-    if (msg.from && typeof msg.from !== "string") return false;
-    if (msg.to && typeof msg.to !== "string") return false;
-    if (msg.metadata && typeof msg.metadata !== "object") return false;
-    if (msg.isResponse !== void 0 && typeof msg.isResponse !== "boolean") return false;
+    const env = data;
+    if (typeof env.from !== "string") return false;
+    if (env.to !== void 0 && typeof env.to !== "string") return false;
+    if (env.metadata !== void 0 && typeof env.metadata !== "object") return false;
+    const payload = env.payload;
+    if (!payload || typeof payload !== "object") return false;
+    if (payload.jsonrpc !== "2.0") return false;
+    const isRequest = "method" in payload;
+    const isResponse = "result" in payload || "error" in payload;
+    if (!isRequest && !isResponse) return false;
     return true;
   }
-  _handleIncoming(data) {
+  async _handleIncoming(data) {
     if (!this._validateMessage(data)) {
       this.logger.error("Invalid message format received", { data });
       this.errorHandler?.(new Error("Invalid message format received"), { data });
       this.metrics.messagesFailed++;
       return;
     }
-    const { id, to, type, payload, isResponse, error, from } = data;
-    if (to && to !== this.instanceId) {
+    const envelope = data;
+    const payload = envelope.payload;
+    if (envelope.to && envelope.to !== this.instanceId) {
       this.logger.debug("Message filtered: not for this instance", {
-        messageId: id,
-        to,
+        messageId: "id" in payload ? payload.id : void 0,
+        to: envelope.to,
         instanceId: this.instanceId
       });
       return;
     }
-    if (isResponse && this.pendingTasks.has(id)) {
-      const { resolve, reject, timer, timestamp } = this.pendingTasks.get(id);
-      clearTimeout(timer);
-      this.pendingTasks.delete(id);
-      const latency = Date.now() - timestamp;
-      this.metrics.messagesReceived++;
-      this.metrics.pendingMessages--;
-      this.metrics.totalLatency += latency;
-      this.metrics.averageLatency = this.metrics.totalLatency / this.metrics.messagesReceived;
-      this.logger.debug("Response received", { messageId: id, latency });
-      if (error) reject(error);
-      else resolve(payload);
-      this._notifyMetrics();
+    if ("result" in payload || "error" in payload) {
+      const response = payload;
+      const id = String(response.id);
+      if (this.pendingTasks.has(id)) {
+        const { resolve, reject, timer, timestamp } = this.pendingTasks.get(id);
+        clearTimeout(timer);
+        this.pendingTasks.delete(id);
+        const latency = Date.now() - timestamp;
+        this.metrics.messagesReceived++;
+        this.metrics.pendingMessages--;
+        this.metrics.totalLatency += latency;
+        this.metrics.averageLatency = this.metrics.totalLatency / this.metrics.messagesReceived;
+        this.logger.debug("Response received", { messageId: id, latency });
+        if (response.error) {
+          const err = new Error(response.error.message);
+          err.code = response.error.code;
+          err.data = response.error.data;
+          reject(err);
+        } else {
+          resolve(response.result);
+        }
+        this._notifyMetrics();
+      } else {
+        this.logger.warn("Orphaned response received", { messageId: id });
+      }
       return;
     }
-    if (isResponse) {
-      this.logger.warn("Orphaned response received", { messageId: id });
-      return;
+    if ("method" in payload) {
+      if ("id" in payload) {
+        const request = payload;
+        const id = String(request.id);
+        this.logger.debug("Invoke message received", {
+          messageId: id,
+          type: request.method,
+          from: envelope.from
+        });
+        const context = {
+          messageId: id,
+          from: envelope.from,
+          to: envelope.to,
+          metadata: envelope.metadata
+        };
+        const handler = this.invokeHandlers.get(request.method);
+        if (handler) {
+          try {
+            const result = await handler(request.params, context);
+            this._reply(id, envelope.from, result);
+          } catch (error) {
+            this._replyError(id, envelope.from, error);
+          }
+        } else {
+          const err = new Error(`Method not found: ${request.method}`);
+          err.code = -32601;
+          this._replyError(id, envelope.from, err);
+        }
+      } else {
+        const notification = payload;
+        this.logger.debug("Notification message received", {
+          type: notification.method,
+          from: envelope.from
+        });
+        const context = {
+          from: envelope.from,
+          to: envelope.to,
+          metadata: envelope.metadata
+        };
+        const handlers = this.notificationHandlers.get(notification.method);
+        if (handlers) {
+          handlers.forEach((handler) => {
+            try {
+              handler(notification.params, context);
+            } catch (error) {
+              this.logger.error("Error in notification handler", { error: String(error) });
+            }
+          });
+        }
+      }
     }
-    this.logger.debug("Command message received", { messageId: id, type, from });
-    this.incomingMessages.set(id, { from, type, timestamp: Date.now() });
-    this.messageHandlers.forEach((handler) => handler(data));
   }
   getMetrics() {
     return { ...this.metrics, pendingMessages: this.pendingTasks.size };
@@ -481,27 +614,62 @@ var MessageNexus = class {
     const metrics = this.getMetrics();
     this.metricsCallbacks.forEach((callback) => callback(metrics));
   }
-  onCommand(handler) {
-    this.messageHandlers.add(handler);
-    return () => this.messageHandlers.delete(handler);
+  handle(method, handler) {
+    if (this.invokeHandlers.has(method)) {
+      this.logger.warn(`Overriding existing handler for method: ${method}`);
+    }
+    this.invokeHandlers.set(method, handler);
+    return () => this.invokeHandlers.delete(method);
+  }
+  removeHandler(method) {
+    this.invokeHandlers.delete(method);
   }
-  reply(messageId, payload, error) {
-    const incoming = this.incomingMessages.get(messageId);
-    if (!incoming) {
-      throw new Error(`Message not found: ${messageId}`);
+  onNotification(method, handler) {
+    if (!this.notificationHandlers.has(method)) {
+      this.notificationHandlers.set(method, /* @__PURE__ */ new Set());
+    }
+    this.notificationHandlers.get(method).add(handler);
+    return () => this.offNotification(method, handler);
+  }
+  offNotification(method, handler) {
+    const handlers = this.notificationHandlers.get(method);
+    if (handlers) {
+      handlers.delete(handler);
+      if (handlers.size === 0) {
+        this.notificationHandlers.delete(method);
+      }
     }
-    const responsePayload = payload;
-    const responseError = error;
-    this.driver.send({
+  }
+  _reply(messageId, to, payload) {
+    const rpcResponse = {
+      jsonrpc: "2.0",
       id: messageId,
-      type: `${incoming.type}_RESPONSE`,
-      payload: responsePayload,
-      error: responseError,
-      isResponse: true,
+      result: payload
+    };
+    const message = {
       from: this.instanceId,
-      to: incoming.from
-    });
-    this.incomingMessages.delete(messageId);
+      to,
+      payload: rpcResponse
+    };
+    this.driver.send(message);
+  }
+  _replyError(messageId, to, error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    const rpcResponse = {
+      jsonrpc: "2.0",
+      id: messageId,
+      error: {
+        code: err.code || -32e3,
+        message: err.message,
+        data: err.data
+      }
+    };
+    const message = {
+      from: this.instanceId,
+      to,
+      payload: rpcResponse
+    };
+    this.driver.send(message);
   }
   destroy() {
     this.logger.info("MessageNexus destroying", {
@@ -515,7 +683,8 @@ var MessageNexus = class {
       clearInterval(this.cleanupInterval);
       this.cleanupInterval = null;
     }
-    this.messageHandlers.clear();
+    this.invokeHandlers.clear();
+    this.notificationHandlers.clear();
     this.metricsCallbacks.clear();
   }
 };