@webex/calling 3.12.0-mobius-socket.11 → 3.12.0-mobius-socket.13

package/dist/module/CallingClient/CallingClient.js

@@ -79,6 +79,11 @@ export class CallingClient extends Eventing {
         this.registerCallsClearedListener();
     }
     async init() {
+        const loggerContext = {
+            file: CALLING_CLIENT_FILE,
+            method: METHODS.INIT,
+        };
+        log.info(METHOD_START_MESSAGE, loggerContext);
         if (typeof window !== 'undefined' && window?.navigator?.userAgent) {
             const ua = window.navigator.userAgent;
             if (ua.toLowerCase().includes('windows')) {
@@ -107,10 +112,11 @@ export class CallingClient extends Eventing {
         await this.getMobiusServers();
         if (this.apiRequest.isSocketEnabled()) {
             await this.connectToMobiusSocket();
-            this.registerMobiusSocketListener();
+            this.apiRequest.registerMobiusSocketListener(this.handleMobiusAsyncEvent);
         }
         await this.createLine();
         this.setupNetworkEventListeners();
+        log.log('CallingClient initialization complete', loggerContext);
     }
     async checkNetworkReachability() {
         try {
@@ -411,34 +417,23 @@ export class CallingClient extends Eventing {
         }
         log.warn('All Mobius socket connection attempts exhausted for both primary and backup, continuing without socket', loggerContext);
     }
-    registerMobiusSocketListener() {
-        log.info(METHOD_START_MESSAGE, {
-            file: CALLING_CLIENT_FILE,
-            method: METHODS.REGISTER_MOBIUS_SOCKET_LISTENER,
-        });
-        this.apiRequest.registerMobiusSocketListener(this.handleMobiusAsyncEvent);
-        log.info('Successfully registered listener for Mobius events', {
-            file: CALLING_CLIENT_FILE,
-            method: METHODS.REGISTER_MOBIUS_SOCKET_LISTENER,
-        });
-    }
     handleMobiusAsyncEvent = async (event) => {
-        log.info(METHOD_START_MESSAGE, {
+        const loggerContext = {
             file: CALLING_CLIENT_FILE,
             method: METHODS.HANDLE_MOBIUS_ASYNC_EVENT,
-        });
+        };
         const eventType = event?.data.eventType;
+        log.trace(`Mobius async event received - eventType: ${eventType ?? 'undefined'}`, loggerContext);
         if (!eventType) {
-            log.warn('Dropping unsupported mobius socket payload', {
-                file: CALLING_CLIENT_FILE,
-                method: METHODS.HANDLE_MOBIUS_ASYNC_EVENT,
-            });
+            log.warn('Dropping unsupported mobius socket payload', loggerContext);
             return;
         }
         if (eventType === MobiusEventType.REGISTRATION_DOWN) {
+            log.warn('Received REGISTRATION_DOWN event from Mobius; teardown handling pending (TODO)', loggerContext);
             return;
         }
         this.callManager.dequeueWsEvents(event);
+        log.trace(`Mobius async event dispatched to CallManager - eventType: ${eventType}`, loggerContext);
     };
     registerCallsClearedListener() {
         log.info(METHOD_START_MESSAGE, {

package/dist/module/CallingClient/constants.js

@@ -70,6 +70,8 @@ export const CALL_MANAGER_FILE = 'callManager';
 export const METRIC_FILE = 'metric';
 export const REGISTRATION_FILE = 'register';
 export const REQUEST_FILE = 'REQUEST';
+export const MOBIUS_SOCKET_MAPPER_FILE = 'mobiusSocketMapper';
+export const WS_FEATURE_FLAG_FILE = 'wsFeatureFlag';
 export const CODEC_ID = 'codecId';
 export const MEDIA_ID = 'id';
 export const RTC_ICE_CANDIDATE_PAIR = 'RTCIceCandidatePair_';
@@ -236,4 +238,14 @@ export const METHODS = {
     UNREGISTER_MOBIUS_SOCKET_LISTENER: 'unregisterMobiusSocketListener',
     HANDLE_MOBIUS_ASYNC_EVENT: 'handleMobiusAsyncEvent',
     HANDLE_REGISTRATION_DOWN_EVENT: 'handleRegistrationDownEvent',
+    DISCONNECT_FROM_MOBIUS_SOCKET: 'disconnectFromMobiusSocket',
+    MAKE_REQUEST: 'makeRequest',
+    DERIVE_MOBIUS_SOCKET_MESSAGE_TYPE: 'deriveMobiusSocketMessageType',
+    IS_MOBIUS_WSS_ENABLED: 'isMobiusWssEnabled',
+    RESTORE_PREVIOUS_REGISTRATION: 'restorePreviousRegistration',
+    RESTART_REGISTRATION: 'restartRegistration',
+    TRIGGER_REGISTRATION: 'triggerRegistration',
+    HANDLE_404_KEEPALIVE_FAILURE: 'handle404KeepaliveFailure',
+    INITIATE_FAILBACK: 'initiateFailback',
+    EXECUTE_FAILBACK: 'executeFailback',
 };

package/dist/module/CallingClient/registration/register.js

@@ -179,7 +179,22 @@ export class Registration {
         });
     }
     async restorePreviousRegistration(caller) {
+        const loggerContext = {
+            file: REGISTRATION_FILE,
+            method: METHODS.RESTORE_PREVIOUS_REGISTRATION,
+        };
+        log.info(`${METHOD_START_MESSAGE} - caller: ${caller}, activeMobiusUrl: ${this.activeMobiusUrl}`, loggerContext);
         let abort = false;
+        if (this.apiRequest.isSocketEnabled()) {
+            log.info(`Disconnecting from Mobius socket to restore previous registration.`, {
+                file: REGISTRATION_FILE,
+                method: 'restorePreviousRegistration',
+            });
+            await this.apiRequest.disconnectFromMobiusSocket({
+                code: 3050,
+                reason: 'done (permanent)',
+            });
+        }
         if (this.activeMobiusUrl) {
             abort = await this.attemptRegistrationWithServers(caller, [this.activeMobiusUrl]);
             if (this.retryAfter) {
@@ -193,20 +208,31 @@ export class Registration {
                     abort = await this.attemptRegistrationWithServers(caller, this.backupMobiusUris);
                 }
                 else {
-                    this.restartRegistration(caller);
+                    await this.restartRegistration(caller);
                 }
                 this.retryAfter = undefined;
+                log.log(`restorePreviousRegistration completed via 429 retry-after path - caller: ${caller}`, loggerContext);
                 return true;
             }
         }
+        log.log(`restorePreviousRegistration completed - caller: ${caller}, deviceRegistered: ${this.isDeviceRegistered()}, abort: ${abort}`, loggerContext);
         return abort;
     }
     async handle404KeepaliveFailure(caller) {
+        const loggerContext = {
+            file: REGISTRATION_FILE,
+            method: METHODS.HANDLE_404_KEEPALIVE_FAILURE,
+        };
+        log.info(`${METHOD_START_MESSAGE} - caller: ${caller}`, loggerContext);
         if (caller === KEEPALIVE_UTIL) {
             const abort = await this.attemptRegistrationWithServers(caller);
             if (!abort && !this.isDeviceRegistered()) {
+                log.warn('Keepalive 404 recovery: re-registration did not complete, starting failover timer', loggerContext);
                 await this.startFailoverTimer();
             }
+            else {
+                log.log(`Keepalive 404 recovery handled - deviceRegistered: ${this.isDeviceRegistered()}, abort: ${abort}`, loggerContext);
+            }
         }
     }
     async handle429Retry(retryAfter, caller) {
@@ -287,6 +313,14 @@ export class Registration {
             log.log(`Scheduled retry with primary in ${interval} seconds, number of attempts : ${attempt}`, loggerContext);
         }
         else if (this.backupMobiusUris.length) {
+            if (this.apiRequest.isSocketEnabled()) {
+                log.info('Disconnecting from primary Mobius socket for failover to backup servers', loggerContext);
+                await this.apiRequest.disconnectFromMobiusSocket({
+                    code: 3050,
+                    reason: 'done (permanent)',
+                });
+                log.log('Mobius socket disconnect complete prior to backup failover', loggerContext);
+            }
             this.saveFailoverState({
                 attempt,
                 timeElapsed,
@@ -384,14 +418,23 @@ export class Registration {
             this.rehomingIntervalMin);
     }
     initiateFailback() {
+        const loggerContext = {
+            file: REGISTRATION_FILE,
+            method: METHODS.INITIATE_FAILBACK,
+        };
         if (this.isFailbackRequired()) {
             if (!this.failbackTimer) {
                 this.failback429RetryAttempts = 0;
                 const intervalInMinutes = this.getFailbackInterval();
+                log.info(`Scheduling failback to primary - intervalMinutes: ${intervalInMinutes}`, loggerContext);
                 this.startFailbackTimer(intervalInMinutes * MINUTES_TO_SEC_MFACTOR);
             }
+            else {
+                log.info('Failback timer already scheduled, skipping', loggerContext);
+            }
         }
         else {
+            log.info('Failback not required, clearing any pending failback timer', loggerContext);
             this.failback429RetryAttempts = 0;
             this.clearFailbackTimer();
         }
@@ -404,20 +447,24 @@ export class Registration {
         });
     }
     async executeFailback() {
+        const loggerContext = {
+            file: REGISTRATION_FILE,
+            method: METHODS.EXECUTE_FAILBACK,
+        };
+        log.info(METHOD_START_MESSAGE, loggerContext);
         await this.mutex.runExclusive(async () => {
             if (this.isFailbackRequired()) {
                 const primaryServerStatus = await this.isPrimaryActive();
                 if (Object.keys(this.callManager.getActiveCalls()).length === 0 && primaryServerStatus) {
-                    log.info(`Attempting failback to primary.`, {
-                        file: REGISTRATION_FILE,
-                        method: this.executeFailback.name,
-                    });
+                    log.info(`Attempting failback to primary.`, loggerContext);
                     await this.deregister();
                     if (this.apiRequest.isSocketEnabled()) {
+                        log.info('Disconnecting from backup Mobius socket for failback to primary', loggerContext);
                         await this.apiRequest.disconnectFromMobiusSocket({
                             code: 3050,
                             reason: 'done (permanent)',
                         });
+                        log.log('Mobius socket disconnect complete prior to primary failback', loggerContext);
                     }
                     const abort = await this.attemptRegistrationWithServers(FAILBACK_UTIL);
                     if (this.scheduled429Retry || abort || this.isDeviceRegistered()) {
@@ -429,7 +476,7 @@ export class Registration {
                         return;
                     }
                     if (!this.isDeviceRegistered()) {
-                        await this.restartRegistration(this.executeFailback.name);
+                        await this.restartRegistration(loggerContext.method);
                     }
                     else {
                         this.failbackTimer = undefined;
@@ -437,10 +484,7 @@ export class Registration {
                     }
                 }
                 else {
-                    log.info('Active calls present or primary Mobius is down, deferring failback to next cycle.', {
-                        file: REGISTRATION_FILE,
-                        method: this.executeFailback.name,
-                    });
+                    log.info('Active calls present or primary Mobius is down, deferring failback to next cycle.', loggerContext);
                     this.failbackTimer = undefined;
                     this.initiateFailback();
                 }
@@ -470,12 +514,18 @@ export class Registration {
         this.registrationStatus = value;
     }
     async restartRegistration(caller) {
+        const loggerContext = {
+            file: REGISTRATION_FILE,
+            method: METHODS.RESTART_REGISTRATION,
+        };
+        log.info(`${METHOD_START_MESSAGE} - caller: ${caller}`, loggerContext);
         this.clearFailbackTimer();
         this.failback429RetryAttempts = 0;
         const abort = await this.attemptRegistrationWithServers(caller, this.primaryMobiusUris);
         if (!abort && !this.isDeviceRegistered()) {
             await this.startFailoverTimer();
         }
+        log.log(`restartRegistration completed - caller: ${caller}, deviceRegistered: ${this.isDeviceRegistered()}, abort: ${abort}`, loggerContext);
     }
     async handleConnectionRestoration(retry) {
         log.info(METHOD_START_MESSAGE, {
@@ -528,7 +578,13 @@ export class Registration {
         };
     }
     async triggerRegistration() {
+        const loggerContext = {
+            file: REGISTRATION_FILE,
+            method: METHODS.TRIGGER_REGISTRATION,
+        };
+        log.info(METHOD_START_MESSAGE, loggerContext);
         if (await this.resumeFailover()) {
+            log.info('Registration trigger handled by resumeFailover path', loggerContext);
             return;
         }
         if (this.primaryMobiusUris.length > 0) {
@@ -536,9 +592,17 @@ export class Registration {
             if (!this.isDeviceRegistered() && !abort) {
                 await this.startFailoverTimer();
             }
+            log.log(`triggerRegistration completed - deviceRegistered: ${this.isDeviceRegistered()}, abort: ${abort}`, loggerContext);
+        }
+        else {
+            log.warn('triggerRegistration skipped: no primary Mobius URIs available', loggerContext);
         }
     }
     async attemptRegistrationWithServers(caller, servers = this.primaryMobiusUris) {
+        const loggerContext = {
+            file: REGISTRATION_FILE,
+            method: REGISTER_UTIL,
+        };
         let abort = false;
         this.retryAfter = undefined;
         let connectedWebSocketUrl;
@@ -546,10 +610,7 @@ export class Registration {
             return abort;
         }
         if (this.isDeviceRegistered()) {
-            log.info(`[${caller}] : Device already registered with : ${this.activeMobiusUrl}`, {
-                file: REGISTRATION_FILE,
-                method: REGISTER_UTIL,
-            });
+            log.info(`[${caller}] : Device already registered with : ${this.activeMobiusUrl}`, loggerContext);
             return abort;
         }
         for (const url of servers) {
@@ -560,14 +621,13 @@ export class Registration {
                 abort = false;
                 this.registrationStatus = RegistrationStatus.INACTIVE;
                 this.lineEmitter(LINE_EVENTS.CONNECTING);
-                log.info(`[${caller}] : Mobius url to contact: ${url}`, {
-                    file: REGISTRATION_FILE,
-                    method: REGISTER_UTIL,
-                });
+                log.info(`[${caller}] : Mobius url to contact: ${url}`, loggerContext);
                 if (this.apiRequest.isSocketEnabled()) {
                     const wssNormalizedUrl = url.endsWith('/') ? url.slice(0, -1) : url;
+                    log.info(`[${caller}] : Connecting to Mobius WebSocket - serverType: ${serverType}, wssUrl: ${wssNormalizedUrl}`, loggerContext);
                     connectedWebSocketUrl = await this.apiRequest.connectToMobiusSocket(wssNormalizedUrl);
                     connectedWebSocketUrl = connectedWebSocketUrl ? `${connectedWebSocketUrl}/` : undefined;
+                    log.log(`[${caller}] : Mobius WebSocket connected - serverType: ${serverType}, connectedWebSocketUrl: ${connectedWebSocketUrl}`, loggerContext);
                 }
                 const resp = await this.postRegistration(url);
                 this.clearFailoverState();
@@ -575,10 +635,7 @@ export class Registration {
                 this.registrationStatus = RegistrationStatus.ACTIVE;
                 this.setActiveMobiusUrl(connectedWebSocketUrl || url);
                 this.lineEmitter(LINE_EVENTS.REGISTERED, resp.body);
-                log.log(`Registration successful for deviceId: ${this.deviceInfo.device?.deviceId} userId: ${this.userId} responseTrackingId: ${resp.headers?.trackingid}`, {
-                    file: REGISTRATION_FILE,
-                    method: METHODS.REGISTER,
-                });
+                log.log(`Registration successful for deviceId: ${this.deviceInfo.device?.deviceId} userId: ${this.userId} responseTrackingId: ${resp.headers?.trackingid}`, loggerContext);
                 this.setIntervalValues(this.deviceInfo);
                 this.metricManager.setDeviceInfo(this.deviceInfo);
                 this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION, REG_ACTION.REGISTER, METRIC_TYPE.BEHAVIORAL, caller, serverType, resp.headers?.trackingid ?? '', undefined, undefined);
@@ -587,25 +644,30 @@ export class Registration {
                 break;
             }
             catch (err) {
-                connectedWebSocketUrl = undefined;
-                await this.apiRequest.disconnectFromMobiusSocket({ code: 3050, reason: 'done (permanent)' });
                 const body = err;
-                abort = await handleRegistrationErrors(body, (clientError, finalError) => {
-                    if (finalError) {
+                const { finalError, shouldDisconnect } = await handleRegistrationErrors(body, (clientError, isFinalError) => {
+                    if (isFinalError) {
                         this.lineEmitter(LINE_EVENTS.ERROR, undefined, clientError);
                     }
                     else {
                         this.lineEmitter(LINE_EVENTS.UNREGISTERED);
                     }
                     this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION_ERROR, REG_ACTION.REGISTER, METRIC_TYPE.BEHAVIORAL, caller, serverType, body.headers?.trackingid ?? '', undefined, clientError);
-                }, { method: caller, file: REGISTRATION_FILE }, (retryAfter, retryCaller) => this.handle429Retry(retryAfter, retryCaller), this.restoreRegistrationCallBack());
+                }, { method: caller, file: REGISTRATION_FILE }, (retryAfter, retryCaller) => this.handle429Retry(retryAfter, retryCaller), this.restoreRegistrationCallBack(), servers.length);
+                abort = finalError;
                 if (this.registrationStatus === RegistrationStatus.ACTIVE) {
-                    log.info(`[${caller}] : Device is already restored, active mobius url: ${this.activeMobiusUrl}`, {
-                        file: REGISTRATION_FILE,
-                        method: this.attemptRegistrationWithServers.name,
-                    });
+                    log.info(`[${caller}] : Device is already restored, active mobius url: ${this.activeMobiusUrl}`, loggerContext);
                     break;
                 }
+                if (shouldDisconnect && this.apiRequest.isSocketEnabled()) {
+                    connectedWebSocketUrl = undefined;
+                    log.info(`[${caller}] : Tearing down Mobius WebSocket after registration error - serverType: ${serverType}`, loggerContext);
+                    await this.apiRequest.disconnectFromMobiusSocket({
+                        code: 3050,
+                        reason: 'done (permanent)',
+                    });
+                    log.log(`[${caller}] : Mobius WebSocket disconnect complete after registration error - serverType: ${serverType}`, loggerContext);
+                }
                 if (abort) {
                     this.setStatus(RegistrationStatus.INACTIVE);
                     await uploadLogs();
@@ -666,7 +728,7 @@ export class Registration {
                         if (event.data.type === WorkerMessageType.KEEPALIVE_FAILURE) {
                             const error = event.data.err;
                             log.warn(`Keep-alive missed ${event.data.keepAliveRetryCount} times. Status -> ${error.statusCode} `, logContext);
-                            const abort = await handleRegistrationErrors(error, (clientError, finalError) => {
+                            const { finalError: abort } = await handleRegistrationErrors(error, (clientError, finalError) => {
                                 if (finalError) {
                                     this.lineEmitter(LINE_EVENTS.ERROR, undefined, clientError);
                                 }
@@ -706,18 +768,17 @@ export class Registration {
         return this.reconnectPending;
     }
     async deregister() {
+        const loggerContext = {
+            file: REGISTRATION_FILE,
+            method: METHODS.DEREGISTER,
+        };
+        log.info(METHOD_START_MESSAGE, loggerContext);
         try {
             await this.deleteRegistration(this.activeMobiusUrl, this.deviceInfo.device?.deviceId, this.deviceInfo.device?.clientDeviceUri);
-            log.log('Registration successfully deregistered', {
-                file: REGISTRATION_FILE,
-                method: METHODS.DEREGISTER,
-            });
+            log.log('Registration successfully deregistered', loggerContext);
         }
         catch (err) {
-            log.warn(`Delete failed with Mobius: ${JSON.stringify(err)}`, {
-                file: REGISTRATION_FILE,
-                method: METHODS.DEREGISTER,
-            });
+            log.warn(`Delete failed with Mobius: ${JSON.stringify(err)}`, loggerContext);
         }
         this.clearKeepaliveTimer();
         this.setStatus(RegistrationStatus.INACTIVE);

package/dist/module/CallingClient/utils/mobiusSocketMapper.js

@@ -1,7 +1,14 @@
 import { HTTP_METHODS } from '../../common/types';
+import log from '../../Logger';
+import { METHODS, MOBIUS_SOCKET_MAPPER_FILE } from '../constants';
 import { MOBIUS_SOCKET_MESSAGE_TYPE } from './constants';
 export function deriveMobiusSocketMessageType(uri, httpMethodType) {
+    const logContext = {
+        file: MOBIUS_SOCKET_MAPPER_FILE,
+        method: METHODS.DERIVE_MOBIUS_SOCKET_MESSAGE_TYPE,
+    };
     if (!uri) {
+        log.warn('Cannot derive Mobius socket message type: uri is empty', logContext);
         return MOBIUS_SOCKET_MESSAGE_TYPE.UNKNOWN;
     }
     if (uri.includes('/services')) {
@@ -14,6 +21,7 @@ export function deriveMobiusSocketMessageType(uri, httpMethodType) {
         if (uri.includes('/calltransfer/commit')) {
             return MOBIUS_SOCKET_MESSAGE_TYPE.CALL_TRANSFER;
         }
+        log.warn(`Unrecognized supplementary service uri - uri: ${uri}, httpMethod: ${httpMethodType}`, logContext);
         return MOBIUS_SOCKET_MESSAGE_TYPE.UNKNOWN;
     }
     if (uri.includes('/calls/') && uri.includes('/media')) {
@@ -29,6 +37,7 @@ export function deriveMobiusSocketMessageType(uri, httpMethodType) {
         if (httpMethodType === HTTP_METHODS.DELETE) {
             return MOBIUS_SOCKET_MESSAGE_TYPE.CALL_DELETE;
         }
+        log.warn(`Unrecognized httpMethod for calls/{callId} - uri: ${uri}, httpMethod: ${httpMethodType}`, logContext);
         return MOBIUS_SOCKET_MESSAGE_TYPE.UNKNOWN;
     }
     if (uri.endsWith('/call')) {
@@ -47,11 +56,13 @@ export function deriveMobiusSocketMessageType(uri, httpMethodType) {
         if (httpMethodType === HTTP_METHODS.GET) {
             return MOBIUS_SOCKET_MESSAGE_TYPE.DEVICE_GET;
         }
+        log.warn(`Unrecognized httpMethod for devices/{deviceId} - uri: ${uri}, httpMethod: ${httpMethodType}`, logContext);
         return MOBIUS_SOCKET_MESSAGE_TYPE.UNKNOWN;
     }
     if (uri.includes('/devices') && !uri.match(/\/devices\/[^/?]+/)) {
         return MOBIUS_SOCKET_MESSAGE_TYPE.DEVICE_LIST;
     }
+    log.warn(`Unrecognized uri pattern for Mobius socket - uri: ${uri}, httpMethod: ${httpMethodType}`, logContext);
     return MOBIUS_SOCKET_MESSAGE_TYPE.UNKNOWN;
 }
 export const isSupplementaryServiceMessageType = (type) => [

package/dist/module/CallingClient/utils/request.js

@@ -41,12 +41,18 @@ export class APIRequest {
         APIRequest.instance = undefined;
     }
     constructor(config) {
+        const logContext = {
+            file: REQUEST_FILE,
+            method: METHODS.CONSTRUCTOR,
+        };
         if (!config.webex) {
+            log.error('APIRequest instantiation failed: WebexSDK instance is required', logContext);
             throw new Error('WebexSDK instance is required');
         }
         this.webex = config.webex;
         this.isMobiusSocketEnabled = isMobiusWssEnabled(config.webex) || false;
         this.mobiusSocket = getMobiusSocketInstance(this.webex);
+        log.info(`APIRequest initialized with transport: ${this.isMobiusSocketEnabled ? 'WSS' : 'HTTP'}`, logContext);
     }
     isSocketEnabled() {
         return this.isMobiusSocketEnabled;
@@ -74,8 +80,9 @@ export class APIRequest {
     async disconnectFromMobiusSocket(options) {
         const logContext = {
             file: REQUEST_FILE,
-            method: 'disconnectFromMobiusSocket',
+            method: METHODS.DISCONNECT_FROM_MOBIUS_SOCKET,
         };
+        log.info('Disconnecting from Mobius WebSocket', logContext);
         try {
             await this.mobiusSocket.disconnect(options);
             log.log('Mobius WebSocket disconnected successfully', logContext);
@@ -85,10 +92,16 @@ export class APIRequest {
         }
     }
     async makeRequest(request) {
+        const logContext = {
+            file: REQUEST_FILE,
+            method: METHODS.MAKE_REQUEST,
+        };
+        log.info(`Dispatching request via ${this.isMobiusSocketEnabled ? 'WSS' : 'HTTP'} `, logContext);
         if (this.isMobiusSocketEnabled) {
             const trackingId = `webex-js-sdk_${uuid()}`;
             const socketType = deriveMobiusSocketMessageType(request.uri, request.method);
             if (socketType === MOBIUS_SOCKET_MESSAGE_TYPE.UNKNOWN) {
+                log.error(`Unknown Mobius Socket message type for uri: ${request.uri}, httpMethod: ${request.method}`, logContext);
                 throw new Error(`Unknown Mobius Socket message type: ${socketType}`);
             }
             const isSupplementaryService = isSupplementaryServiceMessageType(socketType);
@@ -103,21 +116,36 @@ export class APIRequest {
                     },
                     data: request.body,
                 });
+                log.log(`WSS request succeeded - socketType: ${socketType}, trackingId: ${trackingId}, statusCode: ${wsResponse.statusCode}`, logContext);
                 return normalizeWsResponse(wsResponse);
             }
             catch (err) {
+                log.error(`WSS request failed - socketType: ${socketType}, trackingId: ${trackingId}, error: ${String(err)}`, logContext);
                 throw normalizeWsError(err);
             }
         }
         return this.webex.request(request);
     }
     registerMobiusSocketListener(cb) {
+        const logContext = {
+            file: REQUEST_FILE,
+            method: METHODS.REGISTER_MOBIUS_SOCKET_LISTENER,
+        };
+        log.info('Attaching Mobius async event listener', logContext);
         this.mobiusSocket.on('event:async_event', (data) => {
+            log.trace(`Mobius async event received - eventType: ${data?.data?.eventType ?? 'unknown'}`, logContext);
             cb(data);
         });
+        log.log('Mobius async event listener attached', logContext);
     }
     unregisterMobiusSocketListener() {
+        const logContext = {
+            file: REQUEST_FILE,
+            method: METHODS.UNREGISTER_MOBIUS_SOCKET_LISTENER,
+        };
+        log.info('Detaching Mobius async event listener', logContext);
         this.mobiusSocket.off('event:async_event');
+        log.log('Mobius async event listener detached', logContext);
     }
 }
 export const createAPIRequest = (config) => APIRequest.getInstance(config);

package/dist/module/CallingClient/utils/wsFeatureFlag.js

@@ -1,5 +1,12 @@
+import log from '../../Logger';
+import { METHODS, WS_FEATURE_FLAG_FILE } from '../constants';
 export const WEBRTC_CALLING_OVER_WS_FEATURE_KEY = 'webrtc-calling-over-ws-CALL-219562';
 export function isMobiusWssEnabled(webex) {
-    return (webex.internal?.device?.features?.developer?.get(WEBRTC_CALLING_OVER_WS_FEATURE_KEY)?.value ===
-        true);
+    const enabled = webex.internal?.device?.features?.developer?.get(WEBRTC_CALLING_OVER_WS_FEATURE_KEY)?.value ===
+        true;
+    log.trace(`Mobius WSS feature flag '${WEBRTC_CALLING_OVER_WS_FEATURE_KEY}' resolved to: ${enabled}`, {
+        file: WS_FEATURE_FLAG_FILE,
+        method: METHODS.IS_MOBIUS_WSS_ENABLED,
+    });
+    return enabled;
 }

package/dist/module/common/Utils.js

@@ -106,7 +106,8 @@ export function emitFinalFailure(emitterCb, loggerContext, message) {
         'An unknown error occurred. Wait a moment and try again. Please contact the administrator if the problem persists.', RegistrationStatus.INACTIVE, clientError);
     emitterCb(clientError);
 }
-export async function handleRegistrationErrors(err, emitterCb, loggerContext, retry429Cb, restoreRegCb) {
+export async function handleRegistrationErrors(err, emitterCb, loggerContext, retry429Cb, restoreRegCb, serverCount = 1) {
+    let shouldDisconnect = false;
     const lineError = createLineError('', {}, ERROR_TYPE.DEFAULT, RegistrationStatus.INACTIVE);
     const errorCode = Number(err.statusCode);
     let finalError = false;
@@ -117,6 +118,7 @@ export async function handleRegistrationErrors(err, emitterCb, loggerContext, re
             log.warn(`400 Bad Request`, loggerContext);
             updateLineErrorContext(loggerContext, ERROR_TYPE.BAD_REQUEST, 'Invalid input. Please verify the required parameters, sign out and then sign back in with the valid data', RegistrationStatus.INACTIVE, lineError);
             emitterCb(lineError, finalError);
+            shouldDisconnect = serverCount > 1;
             break;
         }
         case ERROR_CODE.UNAUTHORIZED: {
@@ -124,6 +126,7 @@ export async function handleRegistrationErrors(err, emitterCb, loggerContext, re
             log.warn(`401 Unauthorized`, loggerContext);
             updateLineErrorContext(loggerContext, ERROR_TYPE.TOKEN_ERROR, 'User is unauthorized due to an expired token. Sign out, then sign back in.', RegistrationStatus.INACTIVE, lineError);
             emitterCb(lineError, finalError);
+            shouldDisconnect = serverCount > 1;
             break;
         }
         case ERROR_CODE.DEVICE_NOT_FOUND: {
@@ -131,6 +134,7 @@ export async function handleRegistrationErrors(err, emitterCb, loggerContext, re
             log.warn(`404 Device Not Found`, loggerContext);
             updateLineErrorContext(loggerContext, ERROR_TYPE.NOT_FOUND, 'Webex Calling is unable to find your device. Sign out, then sign back in', RegistrationStatus.INACTIVE, lineError);
             emitterCb(lineError, finalError);
+            shouldDisconnect = serverCount > 1;
             break;
         }
         case ERROR_CODE.TOO_MANY_REQUESTS: {
@@ -139,20 +143,23 @@ export async function handleRegistrationErrors(err, emitterCb, loggerContext, re
             const caller = loggerContext.method || 'handleErrors';
             if (retry429Cb && err.headers) {
                 const retryAfter = Number(err.headers['retry-after']);
-                retry429Cb(retryAfter, caller);
+                await retry429Cb(retryAfter, caller);
             }
+            shouldDisconnect = false;
             break;
         }
         case ERROR_CODE.INTERNAL_SERVER_ERROR: {
             log.warn(`500 Internal Server Error`, loggerContext);
             updateLineErrorContext(loggerContext, ERROR_TYPE.SERVER_ERROR, 'An unknown error occurred while placing the request. Wait a moment and try again.', RegistrationStatus.INACTIVE, lineError);
             emitterCb(lineError, finalError);
+            shouldDisconnect = serverCount > 1;
             break;
         }
         case ERROR_CODE.SERVICE_UNAVAILABLE: {
             log.warn(`503 Service Unavailable`, loggerContext);
             updateLineErrorContext(loggerContext, ERROR_TYPE.SERVICE_UNAVAILABLE, 'An error occurred on the server while processing the request. Wait a moment and try again.', RegistrationStatus.INACTIVE, lineError);
             emitterCb(lineError, finalError);
+            shouldDisconnect = serverCount > 1;
             break;
         }
         case ERROR_CODE.FORBIDDEN: {
@@ -162,7 +169,8 @@ export async function handleRegistrationErrors(err, emitterCb, loggerContext, re
                 log.warn('Error response has no body, throwing default error', loggerContext);
                 updateLineErrorContext(loggerContext, ERROR_TYPE.FORBIDDEN_ERROR, 'An unauthorized action has been received. This action has been blocked. Please contact the administrator if this persists.', RegistrationStatus.INACTIVE, lineError);
                 emitterCb(lineError, finalError);
-                return finalError;
+                shouldDisconnect = serverCount > 1;
+                return { finalError, shouldDisconnect };
             }
             const code = Number(errorBody.errorCode);
             log.warn(`Error code found : ${code}`, loggerContext);
@@ -174,6 +182,7 @@ export async function handleRegistrationErrors(err, emitterCb, loggerContext, re
                         const caller = loggerContext.method || 'handleErrors';
                         await restoreRegCb(errorBody, caller);
                     }
+                    shouldDisconnect = false;
                     break;
                 }
                 case DEVICE_ERROR_CODE.DEVICE_CREATION_DISABLED: {
@@ -182,6 +191,7 @@ export async function handleRegistrationErrors(err, emitterCb, loggerContext, re
                     updateLineErrorContext(loggerContext, ERROR_TYPE.FORBIDDEN_ERROR, errorMessage, RegistrationStatus.INACTIVE, lineError);
                     log.warn(errorMessage, loggerContext);
                     emitterCb(lineError, true);
+                    shouldDisconnect = true;
                     break;
                 }
                 case DEVICE_ERROR_CODE.DEVICE_CREATION_FAILED: {
@@ -189,6 +199,7 @@ export async function handleRegistrationErrors(err, emitterCb, loggerContext, re
                     updateLineErrorContext(loggerContext, ERROR_TYPE.FORBIDDEN_ERROR, errorMessage, RegistrationStatus.INACTIVE, lineError);
                     log.warn(errorMessage, loggerContext);
                     emitterCb(lineError, finalError);
+                    shouldDisconnect = serverCount > 1;
                     break;
                 }
                 default: {
@@ -196,6 +207,7 @@ export async function handleRegistrationErrors(err, emitterCb, loggerContext, re
                     updateLineErrorContext(loggerContext, ERROR_TYPE.FORBIDDEN_ERROR, errorMessage, RegistrationStatus.INACTIVE, lineError);
                     log.warn(errorMessage, loggerContext);
                     emitterCb(lineError, finalError);
+                    shouldDisconnect = serverCount > 1;
                 }
             }
             break;
@@ -204,9 +216,10 @@ export async function handleRegistrationErrors(err, emitterCb, loggerContext, re
             updateLineErrorContext(loggerContext, ERROR_TYPE.DEFAULT, 'Unknown error', RegistrationStatus.INACTIVE, lineError);
             log.warn(`Unknown Error`, loggerContext);
             emitterCb(lineError, finalError);
+            shouldDisconnect = serverCount > 1;
         }
     }
-    return finalError;
+    return { finalError, shouldDisconnect };
 }
 export async function handleCallingClientErrors(err, emitterCb, loggerContext) {
     const clientError = createClientError('', {}, ERROR_TYPE.DEFAULT, RegistrationStatus.INACTIVE);

package/dist/types/CallingClient/CallingClient.d.ts

@@ -40,7 +40,6 @@ export declare class CallingClient extends Eventing<CallingClientEventTypes> imp
     private getClientRegionInfo;
     private getMobiusServers;
     private connectToMobiusSocket;
-    private registerMobiusSocketListener;
     private handleMobiusAsyncEvent;
     private registerCallsClearedListener;
     private callsClearedHandler;