@webex/calling 3.12.0-mobius-socket.17 → 3.12.0-mobius-socket.19

package/dist/module/mobius-socket/mobius-socket.js

@@ -2,18 +2,13 @@
  * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file
  */
 import { EventEmitter } from 'events';
-import { camelCase, set } from 'lodash';
 import backoff from 'backoff';
 import Socket from './socket';
-import { BadRequest, Forbidden, NotAuthorized, UnknownResponse, } from './errors';
+import { BadRequest, Forbidden, NotAuthorized, UnknownResponse } from './errors';
 const normalReconnectReasons = ['idle', 'done (forced)'];
-const DEFAULT_MOBIUS_WEBSOCKET_SESSION = 'mobius-websocket-session';
 const MOBIUS_SOCKET_NAMESPACE = 'MobiusSocket';
 const TOKEN_REFRESH_INTERVAL_MS = 1 * 60 * 60 * 1000;
 function normalizeMobiusAuthToken(token) {
-    if (typeof token !== 'string') {
-        return token;
-    }
     return token.replace(/^Bearer\s+/i, '');
 }
 class MobiusSocket extends EventEmitter {
@@ -25,20 +20,16 @@ class MobiusSocket extends EventEmitter {
         this.webex = webex;
         this.config = config;
         this.logger = webex.logger || console;
-        this.defaultSessionId = DEFAULT_MOBIUS_WEBSOCKET_SESSION;
         this.connected = false;
         this.connecting = false;
         this.hasEverConnected = false;
         this.socket = undefined;
-        this.sockets = new Map();
-        this.backoffCalls = new Map();
-        this._shutdownSwitchoverBackoffCalls = new Map();
-        this._seenAsyncEventIdsBySession = new Map();
-        this._connectPromises = new Map();
-        this.mercuryTimeOffset = undefined;
-        this._tokenRefreshTimer = undefined;
-        this._tokenRefreshInFlight = undefined;
-        this._bindInternalEvents();
+        this.backoffCall = undefined;
+        this.shutdownSwitchoverBackoffCall = undefined;
+        this.seenAsyncEventIds = new Map();
+        this.connectPromise = undefined;
+        this.tokenRefreshTimer = undefined;
+        this.tokenRefreshInFlight = undefined;
     }
     off(eventName, listener) {
         if (listener) {
@@ -47,88 +38,49 @@ class MobiusSocket extends EventEmitter {
         this.removeAllListeners(eventName);
         return this;
     }
-    _bindInternalEvents() {
-        this.on('event:featureToggle_update', (envelope) => {
-            if (envelope && envelope.data) {
-                this.webex.internal.feature.updateFeature(envelope.data.featureToggle);
-            }
-        });
-        this.on('event:ActiveClusterStatusEvent', (envelope) => {
-            if (typeof this.webex.internal.services?.switchActiveClusterIds === 'function' &&
-                envelope &&
-                envelope.data) {
-                this.webex.internal.services.switchActiveClusterIds(envelope.data?.activeClusters);
-            }
-        });
-        this.on('event:u2c.cache-invalidation', (envelope) => {
-            if (typeof this.webex.internal.services?.invalidateCache === 'function' &&
-                envelope &&
-                envelope.data) {
-                this.webex.internal.services.invalidateCache(envelope.data?.timestamp);
-            }
-        });
-    }
-    _attachSocketEventListeners(socket, sessionId) {
-        socket.on('close', (event) => this._onclose(sessionId, event, socket));
-        socket.on('message', (...args) => this._onmessage(sessionId, ...args));
-        socket.on('pong', (...args) => this._setTimeOffset(sessionId, ...args));
-        socket.on('sequence-mismatch', (...args) => this._emit(sessionId, 'sequence-mismatch', ...args));
-        socket.on('ping-pong-latency', (...args) => this._emit(sessionId, 'ping-pong-latency', ...args));
+    attachSocketEventListeners(socket) {
+        socket.on('close', (event) => this.onclose(event, socket));
+        socket.on('message', (...args) => this.onmessage(...args));
     }
-    _getSeenAsyncEventIds(sessionId) {
-        let seenAsyncEventIds = this._seenAsyncEventIdsBySession.get(sessionId);
-        if (!seenAsyncEventIds) {
-            seenAsyncEventIds = new Map();
-            this._seenAsyncEventIdsBySession.set(sessionId, seenAsyncEventIds);
-        }
-        return seenAsyncEventIds;
-    }
-    _clearSeenAsyncEventIds(sessionId) {
-        if (sessionId) {
-            this._seenAsyncEventIdsBySession.delete(sessionId);
-            return;
-        }
-        this._seenAsyncEventIdsBySession.clear();
-    }
-    _trackAsyncEventAndShouldSuppressDuplicate(sessionId, envelope) {
+    trackAsyncEventAndShouldSuppressDuplicate(envelope) {
         if (envelope?.type !== 'async_event' || !envelope.eventId) {
             return false;
         }
-        const seenAsyncEventIds = this._getSeenAsyncEventIds(sessionId);
-        if (seenAsyncEventIds.has(envelope.eventId)) {
-            const previousValue = seenAsyncEventIds.get(envelope.eventId);
-            seenAsyncEventIds.delete(envelope.eventId);
-            seenAsyncEventIds.set(envelope.eventId, previousValue);
-            this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: duplicate async_event suppressed for ${sessionId}, eventId=${envelope.eventId}`);
+        if (this.seenAsyncEventIds.has(envelope.eventId)) {
+            const previousValue = this.seenAsyncEventIds.get(envelope.eventId);
+            this.seenAsyncEventIds.delete(envelope.eventId);
+            this.seenAsyncEventIds.set(envelope.eventId, previousValue);
+            this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: duplicate async_event suppressed, eventId=${envelope.eventId}`);
             return true;
         }
-        this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: tracking async_event for ${sessionId}, eventId=${envelope.eventId}`);
-        seenAsyncEventIds.set(envelope.eventId, true);
-        if (seenAsyncEventIds.size > this.config.dedupCacheMaxSize) {
-            const oldestEventId = seenAsyncEventIds.keys().next().value;
-            seenAsyncEventIds.delete(oldestEventId);
-            this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: evicted oldest async_event from dedup cache for ${sessionId}, eventId=${oldestEventId}`);
+        this.logger.log(`${MOBIUS_SOCKET_NAMESPACE}: tracking async_event, eventId=${envelope.eventId}`);
+        this.seenAsyncEventIds.set(envelope.eventId, true);
+        if (this.seenAsyncEventIds.size > this.config.dedupCacheMaxSize) {
+            const oldestEventId = this.seenAsyncEventIds.keys().next().value;
+            this.seenAsyncEventIds.delete(oldestEventId);
+            this.logger.log(`${MOBIUS_SOCKET_NAMESPACE}: evicted oldest async_event from dedup cache, eventId=${oldestEventId}`);
         }
         return false;
     }
-    _handleImminentShutdown(sessionId) {
-        const oldSocket = this.sockets.get(sessionId);
+    handleImminentShutdown() {
+        const oldSocket = this.socket;
         try {
-            if (this._shutdownSwitchoverBackoffCalls.get(sessionId)) {
-                this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: [shutdown] switchover already in progress for ${sessionId}`);
+            if (this.shutdownSwitchoverBackoffCall) {
+                this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: [shutdown] switchover already in progress`);
                 return;
             }
-            const switchoverId = `${Date.now()}`;
-            this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: [shutdown] switchover start, id=${switchoverId} for ${sessionId}`);
-            this._connectWithBackoff(undefined, sessionId, {
+            this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: [shutdown] switchover start`);
+            this.connectWithBackoff(undefined, {
                 isShutdownSwitchover: true,
                 attemptOptions: {
                     isShutdownSwitchover: true,
                     onSuccess: (newSocket, webSocketUrl) => {
-                        this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: [shutdown] switchover connected, url: ${webSocketUrl} for ${sessionId}`);
-                        this.socket = this.sockets.get(this.defaultSessionId);
-                        this.connected = this.hasConnectedSockets();
-                        this._emit(sessionId, 'event:mercury_shutdown_switchover_complete', {
+                        this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: [shutdown] switchover connected, url: ${webSocketUrl}`);
+                        newSocket.connecting = false;
+                        newSocket.connected = true;
+                        this.socket = newSocket;
+                        this.connected = true;
+                        this.emitEvent('event:mobius_shutdown_switchover_complete', {
                             url: webSocketUrl,
                         });
                         if (oldSocket) {
@@ -138,185 +90,111 @@ class MobiusSocket extends EventEmitter {
                 },
             })
                 .then(() => {
-                this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: [shutdown] switchover completed successfully for ${sessionId}`);
+                this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: [shutdown] switchover completed successfully`);
             })
                 .catch((err) => {
-                this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: [shutdown] switchover exhausted retries; will fall back to normal reconnection for ${sessionId}: `, err);
-                this._emit(sessionId, 'event:mercury_shutdown_switchover_failed', { reason: err });
+                this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: [shutdown] switchover exhausted retries; will fall back to normal reconnection: `, err);
+                this.emitEvent('event:mobius_shutdown_switchover_failed', { reason: err });
             });
         }
         catch (e) {
-            this.logger.error(`${MOBIUS_SOCKET_NAMESPACE}: [shutdown] error during switchover for ${sessionId}`, e);
-            this._shutdownSwitchoverBackoffCalls.delete(sessionId);
-            this._emit(sessionId, 'event:mercury_shutdown_switchover_failed', { reason: e });
+            this.logger.error(`${MOBIUS_SOCKET_NAMESPACE}: [shutdown] error during switchover`, e);
+            this.shutdownSwitchoverBackoffCall = undefined;
+            this.emitEvent('event:mobius_shutdown_switchover_failed', { reason: e });
         }
     }
-    getLastError() {
-        return this.lastError;
-    }
-    getSockets() {
-        return this.sockets;
-    }
-    getSocket(sessionId = this.defaultSessionId) {
-        return this.sockets.get(sessionId);
-    }
-    getConnectedWebSocketUrl(sessionId = this.defaultSessionId) {
-        const socket = this.getSocket(sessionId);
-        if (!socket?.connected) {
+    getConnectedWebSocketUrl() {
+        if (!this.socket?.connected) {
             return undefined;
         }
-        return socket.url;
-    }
-    send(payload, sessionId = this.defaultSessionId) {
-        const socket = this.getSocket(sessionId);
-        if (!socket || !socket.connected) {
-            return Promise.reject(new Error(`Mobius socket is not connected for session ${sessionId}`));
-        }
-        return socket.send(payload);
+        return this.socket.url;
     }
-    sendWssRequest(payload, sessionIdOrOptions = this.defaultSessionId, options = {}) {
+    sendWssRequest(payload, options = {}) {
         if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
             return Promise.reject(new Error('`payload` is required'));
         }
-        let sessionId = this.defaultSessionId;
-        let requestOptions = options;
-        if (typeof sessionIdOrOptions === 'string') {
-            sessionId = sessionIdOrOptions;
-        }
-        else if (sessionIdOrOptions && typeof sessionIdOrOptions === 'object') {
-            requestOptions = sessionIdOrOptions;
+        if (!this.socket || !this.socket.connected) {
+            return Promise.reject(new Error('Mobius socket is not connected'));
         }
-        const socket = this.getSocket(sessionId);
-        if (!socket || !socket.connected) {
-            return Promise.reject(new Error(`Mobius socket is not connected for session ${sessionId}`));
-        }
-        return socket.sendRequest(payload, {
-            timeout: requestOptions.timeout,
+        const requestConfigOptions = {
+            timeout: options.timeout,
             matchesResponse: (response, request) => response?.type === 'response_event' &&
                 response?.subtype === request.type &&
                 response?.trackingId === request.trackingId,
             getStatusCode: (response) => response?.statusCode,
             getStatusMessage: (response) => response?.statusMessage,
-            createError: (response, statusCode, statusMessage) => this._createWssResponseError(response, statusCode, statusMessage),
-            createTimeoutError: (request) => this._createWssResponseError({
+            createError: (response, statusCode, statusMessage) => this.createWssResponseError(response, statusCode, statusMessage),
+            createTimeoutError: (request) => this.createWssResponseError({
                 type: 'response_event',
                 subtype: request.type,
                 trackingId: request.trackingId,
             }, 408, 'Mobius websocket response timed out'),
-        });
+        };
+        return this.socket.sendRequest(payload, requestConfigOptions);
     }
     isConnected() {
         return this.connected;
     }
-    hasConnectedSockets(sessionId) {
-        if (sessionId) {
-            return Boolean(this.sockets.get(sessionId)?.connected);
-        }
-        for (const socket of this.sockets.values()) {
-            if (socket?.connected) {
-                return true;
-            }
+    connect(webSocketUrl) {
+        if (this.connectPromise) {
+            this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: connection already in progress, returning existing promise`);
+            return this.connectPromise;
         }
-        return false;
-    }
-    hasConnectingSockets(sessionId = this.defaultSessionId) {
-        const socket = this.sockets.get(sessionId || this.defaultSessionId);
-        return Boolean(socket?.connecting);
-    }
-    connect(webSocketUrl, sessionId = this.defaultSessionId) {
-        if (this._connectPromises.has(sessionId)) {
-            this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: connection ${sessionId} already in progress, returning existing promise`);
-            return this._connectPromises.get(sessionId);
-        }
-        const sessionSocket = this.sockets.get(sessionId);
-        if (sessionSocket?.connected || sessionSocket?.connecting) {
-            this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: connection ${sessionId} already connected, will not connect again`);
+        if (this.socket?.connected || this.socket?.connecting) {
+            this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: already connected, will not connect again`);
             return Promise.resolve();
         }
         if (webSocketUrl && this.socketUrl && webSocketUrl !== this.socketUrl) {
             this.hasEverConnected = false;
         }
-        const resolvedUrl = webSocketUrl || this.socketUrl;
         if (webSocketUrl) {
             this.socketUrl = webSocketUrl;
         }
         this.connecting = true;
-        this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: starting connection attempt for ${sessionId}${Number(this.config.initialConnectionMaxRetries) === 0 && !this.hasEverConnected
+        this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: starting connection attempt${Number(this.config.initialConnectionMaxRetries) === 0 && !this.hasEverConnected
             ? ' (initial retries disabled)'
             : ''}`);
         const connectPromise = Promise.resolve(this.webex.internal.device.registered || this.webex.internal.device.register())
             .then(() => {
-            this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: connecting ${sessionId}`);
-            return this._connectWithBackoff(resolvedUrl, sessionId);
+            this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: connecting`);
+            return this.connectWithBackoff(this.socketUrl);
         })
             .finally(() => {
-            this._connectPromises.delete(sessionId);
+            this.connectPromise = undefined;
         });
-        this._connectPromises.set(sessionId, connectPromise);
+        this.connectPromise = connectPromise;
         return connectPromise;
     }
-    logout() {
-        this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: logout() called`);
-        return this.disconnectAll(this.config.beforeLogoutOptionsCloseReason &&
-            !normalReconnectReasons.includes(this.config.beforeLogoutOptionsCloseReason)
-            ? { code: 3050, reason: this.config.beforeLogoutOptionsCloseReason }
-            : undefined);
-    }
-    disconnect(options, sessionId = this.defaultSessionId) {
-        this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}#disconnect: connecting state: ${this.connecting}, connected state: ${this.connected}, socket exists: ${!!this
-            .socket}, options: ${JSON.stringify(options)}`);
-        const backoffCall = this.backoffCalls.get(sessionId);
-        if (backoffCall) {
-            this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: aborting connection ${sessionId}`);
-            backoffCall.abort();
-            this.backoffCalls.delete(sessionId);
-        }
-        const shutdownSwitchoverBackoffCall = this._shutdownSwitchoverBackoffCalls.get(sessionId);
-        if (shutdownSwitchoverBackoffCall) {
-            this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: aborting shutdown switchover connection ${sessionId}`);
-            shutdownSwitchoverBackoffCall.abort();
-            this._shutdownSwitchoverBackoffCalls.delete(sessionId);
-        }
-        this._connectPromises.delete(sessionId);
-        const sessionSocket = this.sockets.get(sessionId);
-        this._clearSeenAsyncEventIds(sessionId);
-        if (!sessionSocket) {
-            this.connected = this.hasConnectedSockets();
-            if (!this.hasConnectedSockets()) {
-                this._stopTokenRefreshTimer();
-            }
+    disconnect(options) {
+        this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}#disconnect: connecting state: ${this.connecting},
+       connected state: ${this.connected}, socket exists: ${!!this.socket},
+       options: ${JSON.stringify(options)}`);
+        if (this.backoffCall) {
+            this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: aborting connection`);
+            this.backoffCall.abort();
+            this.backoffCall = undefined;
+        }
+        if (this.shutdownSwitchoverBackoffCall) {
+            this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: aborting shutdown switchover connection`);
+            this.shutdownSwitchoverBackoffCall.abort();
+            this.shutdownSwitchoverBackoffCall = undefined;
+        }
+        this.connectPromise = undefined;
+        this.seenAsyncEventIds.clear();
+        if (!this.socket) {
+            this.connected = false;
+            this.stopTokenRefreshTimer();
             return Promise.resolve();
         }
-        sessionSocket.removeAllListeners('message');
-        sessionSocket.connecting = false;
-        sessionSocket.connected = false;
-        return Promise.resolve(sessionSocket.close(options || undefined)).finally(() => {
-            this.connected = this.hasConnectedSockets();
-            if (!this.hasConnectedSockets()) {
-                this._stopTokenRefreshTimer();
-            }
-        });
-    }
-    disconnectAll(options) {
-        const disconnectPromises = [];
-        for (const sessionId of this.sockets.keys()) {
-            disconnectPromises.push(this.disconnect(options, sessionId));
-        }
-        return Promise.all(disconnectPromises).then(() => {
+        this.socket.removeAllListeners('message');
+        this.socket.connecting = false;
+        this.socket.connected = false;
+        return Promise.resolve(this.socket.close(options || undefined)).finally(() => {
             this.connected = false;
-            this.socket = undefined;
-            this.sockets.clear();
-            this.backoffCalls.clear();
-            this._shutdownSwitchoverBackoffCalls.clear();
-            this._clearSeenAsyncEventIds();
-            this._stopTokenRefreshTimer();
-            this._connectPromises.clear();
+            this.stopTokenRefreshTimer();
         });
     }
-    processRegistrationStatusEvent(message) {
-        this.localClusterServiceUrls = message.localClusterServiceUrls;
-    }
-    _createWssResponseError(response, statusCode, statusMessage) {
+    createWssResponseError(response, statusCode, statusMessage) {
         const error = new Error(statusMessage || `Mobius websocket request failed with status ${statusCode || 'unknown'}`);
         error.name = 'MobiusSocketResponseError';
         error.statusCode = statusCode;
@@ -325,45 +203,36 @@ class MobiusSocket extends EventEmitter {
         error.trackingId = response?.trackingId;
         return error;
     }
-    _applyOverrides(event) {
-        if (!event || !event.headers) {
-            return;
-        }
-        const headerKeys = Object.keys(event.headers);
-        headerKeys.forEach((keyPath) => {
-            set(event, keyPath, event.headers[keyPath]);
-        });
-    }
-    _prepareUrl(webSocketUrl) {
+    prepareUrl(webSocketUrl) {
         if (!webSocketUrl) {
             webSocketUrl = this.webex.internal.device.webSocketUrl;
         }
         return Promise.resolve(webSocketUrl);
     }
-    _attemptConnection(socketUrl, sessionId, callback, options = {}) {
+    attemptConnection(socketUrl, callback, options = {}) {
         const { isShutdownSwitchover = false, onSuccess = null } = options;
         const socket = new Socket();
         socket.connecting = true;
         let newWSUrl;
-        this._attachSocketEventListeners(socket, sessionId);
+        this.attachSocketEventListeners(socket);
         const backoffCall = isShutdownSwitchover
-            ? this._shutdownSwitchoverBackoffCalls.get(sessionId)
-            : this.backoffCalls.get(sessionId);
+            ? this.shutdownSwitchoverBackoffCall
+            : this.backoffCall;
         if (!backoffCall) {
             const mode = isShutdownSwitchover ? 'switchover backoff call' : 'backoffCall';
-            const msg = `${MOBIUS_SOCKET_NAMESPACE}: prevent socket open when ${mode} no longer defined for ${sessionId}`;
+            const msg = `${MOBIUS_SOCKET_NAMESPACE}: prevent socket open when ${mode} no longer defined`;
             const err = new Error(msg);
             this.logger.info(msg);
             callback(err);
             return Promise.reject(err);
         }
         if (!isShutdownSwitchover) {
-            this.sockets.set(sessionId, socket);
+            this.socket = socket;
         }
-        return this._prepareAndOpenSocket(socket, socketUrl, sessionId, isShutdownSwitchover)
+        return this.prepareAndOpenSocket(socket, socketUrl, isShutdownSwitchover)
             .then((webSocketUrl) => {
             newWSUrl = webSocketUrl;
-            this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: ${isShutdownSwitchover ? '[shutdown] switchover' : ''} connected to mobius socket, success, action: connected for ${sessionId}, url: ${newWSUrl}`);
+            this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: ${isShutdownSwitchover ? '[shutdown] switchover' : ''} connected to mobius socket, success, url: ${newWSUrl}`);
             if (onSuccess) {
                 onSuccess(socket, webSocketUrl);
                 callback();
@@ -374,48 +243,44 @@ class MobiusSocket extends EventEmitter {
         })
             .catch((reason) => {
             if (isShutdownSwitchover) {
-                this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: [shutdown] switchover attempt failed for ${sessionId}`, reason);
+                this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: [shutdown] switchover attempt failed`, reason);
                 return callback(reason);
             }
-            this.lastError = reason;
-            const backoffCallNormal = this.backoffCalls.get(sessionId);
+            const backoffCallNormal = this.backoffCall;
             if (reason.code !== 1006 && backoffCallNormal && backoffCallNormal?.getNumRetries() > 0) {
-                this._emit(sessionId, 'connection_failed', reason, {
-                    sessionId,
+                this.emitEvent('connection_failed', reason, {
                     retries: backoffCallNormal?.getNumRetries(),
                 });
             }
-            this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: connection attempt failed for ${sessionId}`, reason, backoffCallNormal?.getNumRetries() === 0 ? reason.stack : '');
+            this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: connection attempt failed`, reason, backoffCallNormal?.getNumRetries() === 0 ? reason.stack : '');
             if (reason instanceof UnknownResponse) {
-                this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: received unknown response code for ${sessionId}, refreshing device registration`);
+                this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: received unknown response code, refreshing device registration`);
                 return this.webex.internal.device.refresh().then(() => callback(reason));
             }
             if (reason instanceof NotAuthorized) {
-                this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: received authorization error for ${sessionId}, reauthorizing`);
+                this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: received authorization error, reauthorizing`);
                 return this.webex.credentials.refresh({ force: true }).then(() => callback(reason));
             }
             if (reason instanceof BadRequest || reason instanceof Forbidden) {
-                this.logger.warn(`${MOBIUS_SOCKET_NAMESPACE}: received unrecoverable response from ${MOBIUS_SOCKET_NAMESPACE} for ${sessionId}`);
+                this.logger.warn(`${MOBIUS_SOCKET_NAMESPACE}: received unrecoverable response from ${MOBIUS_SOCKET_NAMESPACE}`);
                 backoffCallNormal?.abort();
                 return callback(reason);
             }
             return callback(reason);
         })
             .catch((reason) => {
-            this.logger.error(`${MOBIUS_SOCKET_NAMESPACE}: failed to handle connection failure for ${sessionId}`, reason);
+            this.logger.error(`${MOBIUS_SOCKET_NAMESPACE}: failed to handle connection failure`, reason);
             callback(reason);
         });
     }
-    _prepareAndOpenSocket(socket, socketUrl, sessionId, isShutdownSwitchover = false) {
+    prepareAndOpenSocket(socket, socketUrl, isShutdownSwitchover = false) {
         const logPrefix = isShutdownSwitchover ? '[shutdown] switchover' : 'connection';
-        return Promise.all([this._prepareUrl(socketUrl), this.webex.credentials.getUserToken()]).then(([webSocketUrl, token]) => {
+        return Promise.all([this.prepareUrl(socketUrl), this.webex.credentials.getUserToken()]).then(([webSocketUrl, token]) => {
             let options = {
                 forceCloseDelay: this.config.forceCloseDelay,
                 wssResponseTimeout: this.config.wssResponseTimeout,
-                skipAckEventId: this.config.skipAckEventId,
-                skipAckEventType: this.config.skipAckEventType,
                 token: normalizeMobiusAuthToken(token.toString()),
-                refreshToken: () => this._refreshToken(),
+                refreshToken: () => this.refreshToken(),
                 trackingId: `${this.webex.sessionId}_${Date.now()}`,
                 logger: this.logger,
             };
@@ -426,13 +291,14 @@ class MobiusSocket extends EventEmitter {
                 this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: ${customOptionsMsg}`);
                 options = { ...options, ...this.webex.config.defaultMobiusSocketOptions };
             }
-            this.sockets.set(sessionId, socket);
-            this.socket = this.sockets.get(this.defaultSessionId);
-            this.logger.info(`${MOBIUS_SOCKET_NAMESPACE} ${logPrefix} url for ${sessionId}: ${webSocketUrl}`);
+            if (!isShutdownSwitchover) {
+                this.socket = socket;
+            }
+            this.logger.info(`${MOBIUS_SOCKET_NAMESPACE} ${logPrefix} url: ${webSocketUrl}`);
             return socket.open(webSocketUrl, options).then(() => webSocketUrl);
         });
     }
-    _connectWithBackoff(webSocketUrl, sessionId, context = {}) {
+    connectWithBackoff(webSocketUrl, context = {}) {
         const { isShutdownSwitchover = false, attemptOptions = {} } = context;
         return new Promise((resolve, reject) => {
             let call;
@@ -441,44 +307,43 @@ class MobiusSocket extends EventEmitter {
                 ? null
                 : Number(this.config.initialConnectionMaxRetries);
             const isInitialConnectWithoutRetries = isInitialConnect && initialRetryLimit === 0;
-            const onComplete = (err, sid = sessionId) => {
+            const onComplete = (err) => {
                 if (isShutdownSwitchover) {
-                    this._shutdownSwitchoverBackoffCalls.delete(sid);
+                    this.shutdownSwitchoverBackoffCall = undefined;
                 }
                 else {
-                    this.backoffCalls.delete(sid);
+                    this.backoffCall = undefined;
                 }
-                const sessionSocket = this.sockets.get(sid);
                 if (err) {
                     const msg = isShutdownSwitchover
                         ? `[shutdown] switchover failed after ${call.getNumRetries()} retries`
                         : `failed to connect after ${call.getNumRetries()} retries`;
-                    this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: ${msg}; log statement about next retry was inaccurate; ${err}`);
-                    if (sessionSocket) {
-                        sessionSocket.connecting = false;
-                        sessionSocket.connected = false;
+                    this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: ${msg}; ${err}`);
+                    if (!isShutdownSwitchover && this.socket) {
+                        this.socket.connecting = false;
+                        this.socket.connected = false;
                     }
                     return reject(err);
                 }
-                if (sessionSocket) {
-                    sessionSocket.connecting = false;
-                    sessionSocket.connected = true;
+                if (!isShutdownSwitchover && this.socket) {
+                    this.socket.connecting = false;
+                    this.socket.connected = true;
                 }
                 if (!isShutdownSwitchover) {
-                    this.connecting = this.hasConnectingSockets();
-                    this.connected = this.hasConnectedSockets();
+                    this.connecting = false;
+                    this.connected = true;
                     this.hasEverConnected = true;
-                    this._startTokenRefreshTimer();
-                    this._emit(sid, 'online');
+                    this.startTokenRefreshTimer();
+                    this.emitEvent('online');
                 }
                 return resolve();
             };
             call = backoff.call((callback) => {
                 const attemptNum = call.getNumRetries();
                 const attemptLogPrefix = isShutdownSwitchover ? '[shutdown] switchover' : 'connection';
-                this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: executing ${attemptLogPrefix} attempt ${attemptNum} for ${sessionId}`);
-                this._attemptConnection(webSocketUrl, sessionId, callback, attemptOptions);
-            }, (err) => onComplete(err, sessionId));
+                this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: executing ${attemptLogPrefix} attempt ${attemptNum}`);
+                this.attemptConnection(webSocketUrl, callback, attemptOptions);
+            }, (err) => onComplete(err));
             call.setStrategy(new backoff.ExponentialStrategy({
                 initialDelay: this.config.backoffTimeReset,
                 maxDelay: this.config.backoffTimeMax,
@@ -493,94 +358,70 @@ class MobiusSocket extends EventEmitter {
                 call.failAfter(this.config.maxRetries);
             }
             if (isShutdownSwitchover) {
-                this._shutdownSwitchoverBackoffCalls.set(sessionId, call);
+                this.shutdownSwitchoverBackoffCall = call;
             }
             else {
-                this.backoffCalls.set(sessionId, call);
+                this.backoffCall = call;
             }
             call.on('abort', () => {
                 const msg = isShutdownSwitchover ? 'Shutdown Switchover' : 'Connection';
-                this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: ${msg} aborted for ${sessionId}`);
-                reject(new Error(`MobiusSocket ${msg} Aborted for ${sessionId}`));
+                this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: ${msg} aborted`);
+                reject(new Error(`MobiusSocket ${msg} Aborted`));
             });
             call.on('callback', (err) => {
                 if (err) {
                     if (isInitialConnectWithoutRetries) {
-                        this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: initial connect failed for ${sessionId}; retries already disabled`);
+                        this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: initial connect failed; retries already disabled`);
                         return;
                     }
                     const number = call.getNumRetries();
                     const delay = Math.min(call.strategy_.nextBackoffDelay_, this.config.backoffTimeMax);
                     const callbackLogPrefix = isShutdownSwitchover ? '[shutdown] switchover' : '';
-                    this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: ${callbackLogPrefix} failed to connect; attempting retry ${number + 1} in ${delay} ms for ${sessionId}`);
+                    this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: ${callbackLogPrefix} failed to connect; attempting retry ${number + 1} in ${delay} ms`);
                     if (process.env.NODE_ENV === 'development') {
                         this.logger.debug(`${MOBIUS_SOCKET_NAMESPACE}: `, err, err.stack);
                     }
                     return;
                 }
-                this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: connected ${sessionId}`);
+                this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: connected`);
             });
             call.start();
         });
     }
-    _emit(sessionId, eventName, ...args) {
+    emitEvent(eventName, ...args) {
         try {
-            if (!sessionId || !eventName) {
+            if (!eventName) {
                 return;
             }
-            const suffix = sessionId === this.defaultSessionId ? '' : `:${sessionId}`;
-            this.emit(`${eventName}${suffix}`, ...args);
+            this.emit(eventName, ...args);
         }
         catch (error) {
-            try {
-                this.logger.error(`${MOBIUS_SOCKET_NAMESPACE}: error occurred in event handler:`, error, ' with args: ', [sessionId, eventName, ...args]);
-            }
-            catch (logError) {
-                console.error('MobiusSocket _emit error handling failed:', logError);
-            }
+            this.logger.error(`${MOBIUS_SOCKET_NAMESPACE}: error occurred in event handler:`, error, ' with args: ', [eventName, ...args]);
         }
     }
-    _getEventHandlers(eventType) {
-        if (!eventType) {
-            return [];
-        }
-        const [namespace, name] = eventType.split('.');
-        const handlers = [];
-        if (!this.webex[namespace] && !this.webex.internal[namespace]) {
-            return handlers;
-        }
-        const handlerName = camelCase(`process_${name}_event`);
-        if ((this.webex[namespace] || this.webex.internal[namespace])[handlerName]) {
-            handlers.push({
-                name: handlerName,
-                namespace,
-            });
-        }
-        return handlers;
-    }
-    _startTokenRefreshTimer() {
-        if (this._tokenRefreshTimer || !this.hasConnectedSockets()) {
+    startTokenRefreshTimer() {
+        if (this.tokenRefreshTimer || !this.connected) {
             return;
         }
-        this._tokenRefreshTimer = setInterval(() => {
-            this._refreshToken().catch((error) => {
+        this.tokenRefreshTimer = setInterval(() => {
+            this.refreshToken().catch((error) => {
                 this.logger.error(`${MOBIUS_SOCKET_NAMESPACE}: periodic token refresh failed`, error);
             });
         }, TOKEN_REFRESH_INTERVAL_MS);
     }
-    _stopTokenRefreshTimer() {
-        if (!this._tokenRefreshTimer) {
+    stopTokenRefreshTimer() {
+        if (!this.tokenRefreshTimer) {
             return;
         }
-        clearInterval(this._tokenRefreshTimer);
-        this._tokenRefreshTimer = undefined;
+        clearInterval(this.tokenRefreshTimer);
+        this.tokenRefreshTimer = undefined;
     }
-    _refreshToken() {
-        if (this._tokenRefreshInFlight) {
-            return this._tokenRefreshInFlight;
+    refreshToken() {
+        if (this.tokenRefreshInFlight) {
+            return this.tokenRefreshInFlight;
         }
-        if (!this.hasConnectedSockets()) {
-            this._stopTokenRefreshTimer();
+        if (!this.connected) {
+            this.stopTokenRefreshTimer();
             return Promise.resolve();
         }
         const tokenPromise = this.webex.credentials.canRefresh
@@ -588,176 +429,145 @@ class MobiusSocket extends EventEmitter {
                 .refresh({ force: true })
                 .then(() => this.webex.credentials.getUserToken())
             : this.webex.credentials.getUserToken();
-        this._tokenRefreshInFlight = tokenPromise
+        this.tokenRefreshInFlight = tokenPromise
             .then((token) => {
             if (!token) {
                 throw new Error('Mobius token refresh did not return a token');
             }
             const refreshedToken = normalizeMobiusAuthToken(token.toString());
-            const authPayloadPromises = [];
-            for (const socket of this.sockets.values()) {
-                if (socket?.connected) {
-                    authPayloadPromises.push(socket.refresh(refreshedToken));
-                }
+            if (this.socket?.connected) {
+                return this.socket.refresh(refreshedToken);
             }
-            return Promise.all(authPayloadPromises);
+            return undefined;
         })
             .catch((error) => {
-            this.logger.error(`${MOBIUS_SOCKET_NAMESPACE}: failed to refresh/re-auth Mobius sockets`, error);
+            this.logger.error(`${MOBIUS_SOCKET_NAMESPACE}: failed to refresh/re-auth Mobius socket`, error);
             throw error;
         })
             .finally(() => {
-            this._tokenRefreshInFlight = undefined;
+            this.tokenRefreshInFlight = undefined;
         });
-        return this._tokenRefreshInFlight;
+        return this.tokenRefreshInFlight;
     }
-    _onclose(sessionId, event, sourceSocket) {
+    onclose(event, sourceSocket) {
         try {
             const reason = event.reason && event.reason.toLowerCase();
-            const sessionSocket = this.sockets.get(sessionId);
             let socketUrl;
-            event.sessionId = sessionId;
-            const isActiveSocket = sourceSocket === sessionSocket;
+            const isActiveSocket = sourceSocket === this.socket;
             if (sourceSocket) {
                 socketUrl = sourceSocket.url;
             }
-            this.sockets.delete(sessionId);
             if (isActiveSocket) {
-                if (sessionSocket) {
-                    sessionSocket.removeAllListeners();
-                    if (sessionId === this.defaultSessionId) {
-                        this.socket = undefined;
-                    }
-                    this._emit(sessionId, 'offline', event);
-                }
-                this.connecting = this.hasConnectingSockets();
-                this.connected = this.hasConnectedSockets();
-                if (!this.hasConnectedSockets()) {
-                    this._stopTokenRefreshTimer();
+                if (this.socket) {
+                    this.socket.removeAllListeners();
+                    this.socket = undefined;
+                    this.emitEvent('offline', event);
                 }
+                this.connecting = false;
+                this.connected = false;
+                this.stopTokenRefreshTimer();
             }
             else {
-                this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: [shutdown] non-active socket closed, code=${event.code} for ${sessionId}`);
+                this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: [shutdown] non-active socket closed, code=${event.code}`);
                 if (sourceSocket) {
                     sourceSocket.removeAllListeners();
                 }
             }
             switch (event.code) {
                 case 1003:
-                    this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: service rejected last message for ${sessionId}; will not reconnect: ${event.reason}`);
+                    this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: service rejected last message; will not reconnect: ${event.reason}`);
                     if (isActiveSocket)
-                        this._emit(sessionId, 'offline.permanent', event);
+                        this.emitEvent('offline.permanent', event);
                     break;
                 case 4000:
-                    this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: socket ${sessionId} replaced; will not reconnect`);
+                    this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: socket replaced; will not reconnect`);
                     if (isActiveSocket)
-                        this._emit(sessionId, 'offline.replaced', event);
+                        this.emitEvent('offline.replaced', event);
                     break;
                 case 4001:
                     if (isActiveSocket) {
-                        this.logger.warn(`${MOBIUS_SOCKET_NAMESPACE}: active socket closed with 4001; shutdown switchover failed for ${sessionId}`);
-                        this._emit(sessionId, 'offline.permanent', event);
+                        this.logger.warn(`${MOBIUS_SOCKET_NAMESPACE}: active socket closed with 4001; shutdown switchover failed`);
+                        this.emitEvent('offline.permanent', event);
                     }
                     else {
-                        this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: old socket closed with 4001 (replaced during shutdown); no reconnect needed for ${sessionId}`);
-                        this._emit(sessionId, 'offline.replaced', event);
+                        this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: old socket closed with 4001 (replaced during shutdown); no reconnect needed`);
+                        this.emitEvent('offline.replaced', event);
                     }
                     break;
                 case 1001:
                 case 1005:
                 case 1006:
                 case 1011:
-                    this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: socket ${sessionId} disconnected; reconnecting`);
+                    this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: socket disconnected; reconnecting`);
                     if (isActiveSocket) {
-                        this._emit(sessionId, 'offline.transient', event);
-                        this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: [shutdown] reconnecting active socket to recover for ${sessionId}`);
-                        this._reconnect(socketUrl, sessionId);
+                        this.emitEvent('offline.transient', event);
+                        this.reconnect(socketUrl);
                     }
                     break;
                 case 1000:
                 case 3050:
                     if (normalReconnectReasons.includes(reason)) {
-                        this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: socket ${sessionId} disconnected; reconnecting`);
+                        this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: socket disconnected; reconnecting`);
                         if (isActiveSocket) {
-                            this._emit(sessionId, 'offline.transient', event);
-                            this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: [shutdown] reconnecting due to normal close for ${sessionId}`);
-                            this._reconnect(socketUrl, sessionId);
+                            this.emitEvent('offline.transient', event);
+                            this.reconnect(socketUrl);
                         }
                     }
                     else {
-                        this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: socket ${sessionId} disconnected; will not reconnect: ${event.reason}`);
+                        this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: socket disconnected; will not reconnect: ${event.reason}`);
                         if (isActiveSocket)
-                            this._emit(sessionId, 'offline.permanent', event);
+                            this.emitEvent('offline.permanent', event);
                     }
                     break;
                 default:
-                    this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: socket ${sessionId} disconnected unexpectedly; will not reconnect`);
+                    this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: socket disconnected unexpectedly; will not reconnect`);
                     if (isActiveSocket)
-                        this._emit(sessionId, 'offline.permanent', event);
+                        this.emitEvent('offline.permanent', event);
             }
         }
         catch (error) {
-            this.logger.error(`${MOBIUS_SOCKET_NAMESPACE}: error occurred in close handler for ${sessionId}`, error);
+            this.logger.error(`${MOBIUS_SOCKET_NAMESPACE}: error occurred in close handler`, error);
         }
     }
-    _onmessage(sessionId, event) {
-        this._setTimeOffset(sessionId, event);
+    onmessage(event) {
         const envelope = event.data;
-        if (process.env.ENABLE_MERCURY_LOGGING) {
-            this.logger.debug(`${MOBIUS_SOCKET_NAMESPACE}: message envelope from ${sessionId}: `, envelope);
+        if (process.env.ENABLE_MOBIUS_LOGGING) {
+            this.logger.debug(`${MOBIUS_SOCKET_NAMESPACE}: message envelope: `, envelope);
         }
-        envelope.sessionId = sessionId;
         if (envelope && envelope.type === 'shutdown') {
-            this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: [shutdown] imminent shutdown message received for ${sessionId}`);
-            this._emit(sessionId, 'event:mercury_shutdown_imminent', envelope);
-            this._handleImminentShutdown(sessionId);
+            this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: [shutdown] imminent shutdown message received`);
+            this.emitEvent('event:mobius_shutdown_imminent', envelope);
+            this.handleImminentShutdown();
             return Promise.resolve();
         }
-        if (this._trackAsyncEventAndShouldSuppressDuplicate(sessionId, envelope)) {
+        if (this.trackAsyncEventAndShouldSuppressDuplicate(envelope)) {
             return Promise.resolve();
         }
         if (envelope.type) {
-            this._emit(sessionId, `event:${envelope.type}`, envelope);
+            this.emitEvent(`event:${envelope.type}`, envelope);
         }
-        envelope.sessionId = sessionId;
         const data = envelope.data || envelope;
-        this._applyOverrides(data);
         const eventType = data?.eventType || envelope.eventType;
         if (!eventType) {
-            this._emit(sessionId, 'event', envelope);
+            this.emitEvent('event', envelope);
             return Promise.resolve();
         }
-        return this._getEventHandlers(eventType)
-            .reduce((promise, handler) => promise.then(() => {
-            const { namespace, name } = handler;
-            return new Promise((resolve) => {
-                resolve((this.webex[namespace] || this.webex.internal[namespace])[name](data));
-            }).catch((reason) => this.logger.error(`${MOBIUS_SOCKET_NAMESPACE}: error occurred in autowired event handler for ${eventType} from ${sessionId}`, reason));
-        }), Promise.resolve())
-            .then(() => {
-            this._emit(sessionId, 'event', envelope);
+        try {
+            this.emitEvent('event', envelope);
             const [namespace] = eventType.split('.');
-            if (namespace === eventType) {
-                this._emit(sessionId, `event:${namespace}`, envelope);
+            this.emitEvent(`event:${namespace}`, envelope);
+            if (namespace !== eventType) {
+                this.emitEvent(`event:${eventType}`, envelope);
             }
-            else {
-                this._emit(sessionId, `event:${namespace}`, envelope);
-                this._emit(sessionId, `event:${eventType}`, envelope);
-            }
-        })
-            .catch((reason) => {
-            this.logger.error(`${MOBIUS_SOCKET_NAMESPACE}: error occurred processing socket message from ${sessionId}`, reason);
-        });
-    }
-    _setTimeOffset(sessionId, event) {
-        const { wsWriteTimestamp } = event.data;
-        if (typeof wsWriteTimestamp === 'number' && wsWriteTimestamp > 0) {
-            this.mercuryTimeOffset = Date.now() - wsWriteTimestamp;
         }
+        catch (reason) {
+            this.logger.error(`${MOBIUS_SOCKET_NAMESPACE}: error occurred processing socket message`, reason);
+        }
+        return Promise.resolve();
     }
-    _reconnect(webSocketUrl, sessionId = this.defaultSessionId) {
-        this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: reconnecting ${sessionId}`);
-        return this.connect(webSocketUrl || this.socketUrl, sessionId);
+    reconnect(webSocketUrl) {
+        this.logger.info(`${MOBIUS_SOCKET_NAMESPACE}: reconnecting`);
+        return this.connect(webSocketUrl || this.socketUrl);
     }
 }
 export default MobiusSocket;