@webex/calling 3.10.0 → 3.11.0

package/dist/module/CallingClient/calling/call.js

@@ -7,7 +7,7 @@ import { ERROR_LAYER, ERROR_TYPE } from '../../Errors/types';
 import { handleCallErrors, modifySdpForIPv4, parseMediaQualityStatistics, serviceErrorCodeHandler, uploadLogs, } from '../../common/Utils';
 import { ALLOWED_SERVICES, CallDirection, HTTP_METHODS, } from '../../common/types';
 import { createCallError } from '../../Errors/catalog/CallError';
-import { CALL_ENDPOINT_RESOURCE, CALL_FILE, CALL_HOLD_SERVICE, CALL_STATUS_RESOURCE, CALL_TRANSFER_SERVICE, CALLING_USER_AGENT, CALLS_ENDPOINT_RESOURCE, CISCO_DEVICE_URL, DEFAULT_LOCAL_CALL_ID, DEFAULT_SESSION_TIMER, DEVICES_ENDPOINT_RESOURCE, HOLD_ENDPOINT, ICE_CANDIDATES_TIMEOUT, INITIAL_SEQ_NUMBER, MEDIA_ENDPOINT_RESOURCE, METHODS, NOISE_REDUCTION_EFFECT, RESUME_ENDPOINT, SPARK_USER_AGENT, SUPPLEMENTARY_SERVICES_TIMEOUT, TRANSFER_ENDPOINT, } from '../constants';
+import { CALL_ENDPOINT_RESOURCE, CALL_FILE, CALL_HOLD_SERVICE, CALL_STATUS_RESOURCE, CALL_TRANSFER_SERVICE, CALLING_USER_AGENT, CALLS_ENDPOINT_RESOURCE, CISCO_DEVICE_URL, DEFAULT_LOCAL_CALL_ID, DEFAULT_SESSION_TIMER, DEVICES_ENDPOINT_RESOURCE, HOLD_ENDPOINT, ICE_CANDIDATES_TIMEOUT, INITIAL_SEQ_NUMBER, MAX_CALL_KEEPALIVE_RETRY_COUNT, MEDIA_ENDPOINT_RESOURCE, METHODS, NOISE_REDUCTION_EFFECT, RESUME_ENDPOINT, SPARK_USER_AGENT, SUPPLEMENTARY_SERVICES_TIMEOUT, TRANSFER_ENDPOINT, } from '../constants';
 import SDKConnector from '../../SDKConnector';
 import { Eventing } from '../../Events/impl';
 import { CALL_EVENT_KEYS, MEDIA_CONNECTION_EVENT_KEYS, MOBIUS_MIDCALL_STATE, SUPPLEMENTARY_SERVICES, } from '../../Events/types';
@@ -51,6 +51,7 @@ export class Call extends Eventing {
     receivedRoapOKSeq;
     localAudioStream;
     rtcMetrics;
+    callKeepaliveRetryCount = 0;
     isMuted() {
         return this.muted;
     }
@@ -639,8 +640,7 @@ export class Call extends Eventing {
             });
         }
         catch (e) {
-            const extendedError = new Error(`Failed to setup the call: ${e}`);
-            log.error(extendedError, {
+            log.error(`Failed to setup the call: ${JSON.stringify(e)}`, {
                 file: CALL_FILE,
                 method: METHODS.HANDLE_OUTGOING_CALL_SETUP,
             });
@@ -682,8 +682,7 @@ export class Call extends Eventing {
             }
         }
         catch (e) {
-            const extendedError = new Error(`Failed to put the call on hold: ${e}`);
-            log.error(extendedError, {
+            log.error(`Failed to put the call on hold: ${JSON.stringify(e)}`, {
                 file: CALL_FILE,
                 method: METHODS.HANDLE_CALL_HOLD,
             });
@@ -725,8 +724,7 @@ export class Call extends Eventing {
             }
         }
         catch (e) {
-            const extendedError = new Error(`Failed to resume the call: ${e}`);
-            log.error(extendedError, {
+            log.error(`Failed to resume the call: ${JSON.stringify(e)}`, {
                 file: CALL_FILE,
                 method: METHODS.HANDLE_CALL_RESUME,
             });
@@ -814,13 +812,12 @@ export class Call extends Eventing {
                 method: METHODS.HANDLE_OUTGOING_CALL_ALERTING,
             });
         }
-        catch (err) {
-            const extendedError = new Error(`Failed to signal call progression: ${err}`);
-            log.error(extendedError, {
+        catch (e) {
+            log.error(`Failed to signal call progression: ${JSON.stringify(e)}`, {
                 file: CALL_FILE,
                 method: METHODS.HANDLE_OUTGOING_CALL_ALERTING,
             });
-            const errData = err;
+            const errData = e;
             handleCallErrors((error) => {
                 this.emit(CALL_EVENT_KEYS.CALL_ERROR, error);
                 this.submitCallErrorMetric(error);
@@ -864,13 +861,12 @@ export class Call extends Eventing {
                 method: METHODS.HANDLE_OUTGOING_CALL_CONNECT,
             });
         }
-        catch (err) {
-            const extendedError = new Error(`Failed to connect the call: ${err}`);
-            log.error(extendedError, {
+        catch (e) {
+            log.error(`Failed to connect the call: ${JSON.stringify(e)}`, {
                 file: CALL_FILE,
                 method: METHODS.HANDLE_OUTGOING_CALL_CONNECT,
             });
-            const errData = err;
+            const errData = e;
             handleCallErrors((error) => {
                 this.emit(CALL_EVENT_KEYS.CALL_ERROR, error);
                 this.submitCallErrorMetric(error);
@@ -886,20 +882,21 @@ export class Call extends Eventing {
     async handleIncomingCallDisconnect(event) {
         log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, {
             file: CALL_FILE,
-            method: METHODS.HANDLE_OUTGOING_CALL_DISCONNECT,
+            method: METHODS.HANDLE_INCOMING_CALL_DISCONNECT,
         });
+        this.emit(CALL_EVENT_KEYS.DISCONNECT, this.correlationId);
         this.setDisconnectReason();
         try {
             const response = await this.delete();
             log.log(`Response code: ${response.statusCode}`, {
                 file: CALL_FILE,
-                method: METHODS.HANDLE_OUTGOING_CALL_DISCONNECT,
+                method: METHODS.HANDLE_INCOMING_CALL_DISCONNECT,
             });
         }
         catch (e) {
-            log.warn('Failed to delete the call', {
+            log.warn(`Failed to delete the call: ${JSON.stringify(e)}`, {
                 file: CALL_FILE,
-                method: METHODS.HANDLE_OUTGOING_CALL_DISCONNECT,
+                method: METHODS.HANDLE_INCOMING_CALL_DISCONNECT,
             });
             uploadLogs({
                 correlationId: this.correlationId,
@@ -921,7 +918,6 @@ export class Call extends Eventing {
         }
         this.sendMediaStateMachineEvt({ type: 'E_ROAP_TEARDOWN' });
         this.sendCallStateMachineEvt({ type: 'E_CALL_CLEARED' });
-        this.emit(CALL_EVENT_KEYS.DISCONNECT, this.correlationId);
     }
     async handleOutgoingCallDisconnect(event) {
         log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, {
@@ -966,50 +962,70 @@ export class Call extends Eventing {
         this.sendMediaStateMachineEvt({ type: 'E_ROAP_TEARDOWN' });
         this.sendCallStateMachineEvt({ type: 'E_CALL_CLEARED' });
     }
-    handleCallEstablished(event) {
-        log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, {
-            file: CALL_FILE,
-            method: METHODS.HANDLE_CALL_ESTABLISHED,
-        });
-        this.emit(CALL_EVENT_KEYS.ESTABLISHED, this.correlationId);
-        this.earlyMedia = false;
-        this.connected = true;
-        if (this.sessionTimer) {
-            log.log('Resetting session timer', {
+    callKeepaliveRetryCallback = (interval) => {
+        if (this.callKeepaliveRetryCount === MAX_CALL_KEEPALIVE_RETRY_COUNT) {
+            log.warn(`Max keepalive retry attempts reached. Aborting call keepalive for callId: ${this.callId}`, {
                 file: CALL_FILE,
-                method: METHODS.HANDLE_CALL_ESTABLISHED,
+                method: 'keepaliveRetryCallback',
             });
+            return;
+        }
+        this.callKeepaliveRetryCount += 1;
+        setTimeout(async () => {
+            try {
+                await this.postStatus();
+                this.scheduleCallKeepaliveInterval();
+            }
+            catch (err) {
+                await this.handleCallKeepaliveError(err);
+            }
+        }, interval * 1000);
+    };
+    handleCallKeepaliveError = async (err) => {
+        const error = err;
+        if (this.sessionTimer) {
             clearInterval(this.sessionTimer);
         }
+        const abort = await handleCallErrors((callError) => {
+            this.emit(CALL_EVENT_KEYS.CALL_ERROR, callError);
+            this.submitCallErrorMetric(callError);
+        }, ERROR_LAYER.CALL_CONTROL, this.callKeepaliveRetryCallback, this.getCorrelationId(), error, 'handleCallEstablished', CALL_FILE);
+        if (abort) {
+            this.sendCallStateMachineEvt({ type: 'E_SEND_CALL_DISCONNECT' });
+            this.emit(CALL_EVENT_KEYS.DISCONNECT, this.getCorrelationId());
+            this.callKeepaliveRetryCount = 0;
+        }
+        await uploadLogs({
+            correlationId: this.correlationId,
+            callId: this.callId,
+            broadworksCorrelationInfo: this.broadworksCorrelationInfo,
+        });
+    };
+    scheduleCallKeepaliveInterval = () => {
+        const loggerContext = {
+            file: CALL_FILE,
+            method: 'scheduleCallKeepaliveInterval',
+        };
         this.sessionTimer = setInterval(async () => {
             try {
                 const res = await this.postStatus();
-                log.info(`Session refresh successful`, {
-                    file: CALL_FILE,
-                    method: METHODS.HANDLE_CALL_ESTABLISHED,
-                });
+                log.info(`Session refresh successful`, loggerContext);
             }
             catch (err) {
-                const error = err;
-                if (this.sessionTimer) {
-                    clearInterval(this.sessionTimer);
-                }
-                handleCallErrors((callError) => {
-                    this.emit(CALL_EVENT_KEYS.CALL_ERROR, callError);
-                    this.submitCallErrorMetric(callError);
-                }, ERROR_LAYER.CALL_CONTROL, (interval) => {
-                    setTimeout(() => {
-                        this.postStatus();
-                        this.sendCallStateMachineEvt({ type: 'E_CALL_ESTABLISHED' });
-                    }, interval * 1000);
-                }, this.getCorrelationId(), error, this.handleCallEstablished.name, CALL_FILE);
-                await uploadLogs({
-                    correlationId: this.correlationId,
-                    callId: this.callId,
-                    broadworksCorrelationInfo: this.broadworksCorrelationInfo,
-                });
+                await this.handleCallKeepaliveError(err);
             }
         }, DEFAULT_SESSION_TIMER);
+    };
+    handleCallEstablished(event) {
+        const loggerContext = {
+            file: CALL_FILE,
+            method: METHODS.HANDLE_CALL_ESTABLISHED,
+        };
+        log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, loggerContext);
+        this.emit(CALL_EVENT_KEYS.ESTABLISHED, this.correlationId);
+        this.earlyMedia = false;
+        this.connected = true;
+        this.scheduleCallKeepaliveInterval();
     }
     async handleUnknownState(event) {
         log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, {
@@ -1164,7 +1180,7 @@ export class Call extends Eventing {
             method: METHODS.HANDLE_ROAP_ERROR,
         });
         const message = event.data;
-        if (message) {
+        if (message && message.messageType === 'ERROR') {
             try {
                 const res = await this.postMedia(message);
                 log.info(`Response code: ${res.statusCode}`, {
@@ -1219,7 +1235,7 @@ export class Call extends Eventing {
             });
         }
         catch (err) {
-            log.warn('Failed to process MediaOk request', {
+            log.warn('Failed to send MediaOffer request', {
                 file: CALL_FILE,
                 method: METHODS.HANDLE_OUTGOING_ROAP_OFFER,
             });
@@ -1332,9 +1348,8 @@ export class Call extends Eventing {
         }
         catch (error) {
             const errorInfo = error;
-            const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
-            const errorLog = new Error(`Failed to upload webrtc telemetry statistics. ${errorStatus}`);
-            log.error(errorLog, loggerContext);
+            const errorStatus = await serviceErrorCodeHandler(errorInfo, loggerContext);
+            log.error(`Failed to upload webrtc telemetry statistics. ${JSON.stringify(errorStatus)}`, loggerContext);
             await uploadLogs({
                 correlationId: this.correlationId,
                 callId: this.callId,

package/dist/module/CallingClient/calling/callManager.js

@@ -137,6 +137,13 @@ export class CallManager extends Eventing {
                     method: METHODS.DEQUEUE_WS_EVENTS,
                 });
                 const call = this.getCall(correlationId);
+                if (mobiusEvent.data.callerId) {
+                    log.info('Processing Caller-Id data', {
+                        file: CALL_MANAGER_FILE,
+                        method: METHODS.DEQUEUE_WS_EVENTS,
+                    });
+                    call.startCallerIdResolution(mobiusEvent.data.callerId);
+                }
                 call.sendCallStateMachineEvt({ type: 'E_RECV_CALL_PROGRESS', data: mobiusEvent.data });
                 break;
             }

package/dist/module/CallingClient/constants.js

@@ -12,6 +12,7 @@ export const DEFAULT_LOCAL_CALL_ID = 'DefaultLocalId';
 export const DEFAULT_REHOMING_INTERVAL_MAX = 120;
 export const DEFAULT_REHOMING_INTERVAL_MIN = 60;
 export const DEFAULT_SESSION_TIMER = 1000 * 60 * 10;
+export const MAX_CALL_KEEPALIVE_RETRY_COUNT = 4;
 export const DEVICES_ENDPOINT_RESOURCE = 'devices';
 export const DISCOVERY_URL = 'https://ds.ciscospark.com/v1/region';
 export const DUMMY_METRICS = {
@@ -112,6 +113,7 @@ export const REGISTRATION_UTIL = 'triggerRegistration';
 export const REGISTER_UTIL = 'attemptRegistrationWithServers';
 export const GET_MOBIUS_SERVERS_UTIL = 'getMobiusServers';
 export const KEEPALIVE_UTIL = 'startKeepaliveTimer';
+export const RECONNECT_ON_FAILURE_UTIL = 'reconnectOnFailure';
 export const FAILBACK_UTIL = 'executeFailback';
 export const REG_429_RETRY_UTIL = 'handle429Retry';
 export const FAILOVER_UTIL = 'startFailoverTimer';
@@ -122,6 +124,7 @@ export const MOBIUS_US_PROD = 'mobius-us-east-1.prod.infra.webex.com';
 export const MOBIUS_EU_PROD = 'mobius-eu-central-1.prod.infra.webex.com';
 export const MOBIUS_US_INT = 'mobius-us-east-1.int.infra.webex.com';
 export const MOBIUS_EU_INT = 'mobius-eu-central-1.int.infra.webex.com';
+export const FAILOVER_CACHE_PREFIX = 'wxc-failover-state';
 export const ICE_CANDIDATES_TIMEOUT = 3000;
 export const METHODS = {
     CONSTRUCTOR: 'constructor',

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

@@ -8,7 +8,7 @@ import { getCallManager } from '../calling';
 import log from '../../Logger';
 import SDKConnector from '../../SDKConnector';
 import { ALLOWED_SERVICES, HTTP_METHODS, RegistrationStatus, ServiceIndicator, WorkerMessageType, } from '../../common/types';
-import { CALLING_USER_AGENT, CISCO_DEVICE_URL, DEVICES_ENDPOINT_RESOURCE, SPARK_USER_AGENT, WEBEX_WEB_CLIENT, BASE_REG_RETRY_TIMER_VAL_IN_SEC, BASE_REG_TIMER_MFACTOR, SEC_TO_MSEC_MFACTOR, REG_RANDOM_T_FACTOR_UPPER_LIMIT, REG_TRY_BACKUP_TIMER_VAL_IN_SEC, MINUTES_TO_SEC_MFACTOR, REG_429_RETRY_UTIL, REG_FAILBACK_429_MAX_RETRIES, FAILBACK_UTIL, REGISTRATION_FILE, DEFAULT_REHOMING_INTERVAL_MIN, DEFAULT_REHOMING_INTERVAL_MAX, DEFAULT_KEEPALIVE_INTERVAL, FAILOVER_UTIL, REGISTER_UTIL, RETRY_TIMER_UPPER_LIMIT, KEEPALIVE_UTIL, REGISTRATION_UTIL, METHODS, URL_ENDPOINT, } from '../constants';
+import { CALLING_USER_AGENT, CISCO_DEVICE_URL, DEVICES_ENDPOINT_RESOURCE, SPARK_USER_AGENT, WEBEX_WEB_CLIENT, BASE_REG_RETRY_TIMER_VAL_IN_SEC, BASE_REG_TIMER_MFACTOR, SEC_TO_MSEC_MFACTOR, REG_RANDOM_T_FACTOR_UPPER_LIMIT, REG_TRY_BACKUP_TIMER_VAL_IN_SEC, MINUTES_TO_SEC_MFACTOR, REG_429_RETRY_UTIL, REG_FAILBACK_429_MAX_RETRIES, FAILBACK_UTIL, REGISTRATION_FILE, DEFAULT_REHOMING_INTERVAL_MIN, DEFAULT_REHOMING_INTERVAL_MAX, DEFAULT_KEEPALIVE_INTERVAL, FAILOVER_UTIL, REGISTER_UTIL, RETRY_TIMER_UPPER_LIMIT, KEEPALIVE_UTIL, REGISTRATION_UTIL, METHODS, URL_ENDPOINT, RECONNECT_ON_FAILURE_UTIL, FAILOVER_CACHE_PREFIX, } from '../constants';
 import { LINE_EVENTS } from '../line/types';
 export class Registration {
     sdkConnector;
@@ -58,6 +58,53 @@ export class Registration {
         this.primaryMobiusUris = [];
         this.backupMobiusUris = [];
     }
+    getFailoverCacheKey() {
+        return `${FAILOVER_CACHE_PREFIX}.${this.userId || 'unknown'}`;
+    }
+    saveFailoverState(failoverState) {
+        try {
+            localStorage.setItem(this.getFailoverCacheKey(), JSON.stringify(failoverState));
+        }
+        catch (error) {
+            log.warn(`Storing failover state in cache failed with error: ${String(error)}`, {
+                file: REGISTRATION_FILE,
+                method: 'saveFailoverState',
+            });
+        }
+    }
+    clearFailoverState() {
+        try {
+            localStorage.removeItem(this.getFailoverCacheKey());
+        }
+        catch {
+            log.warn('Clearing failover state from localStorage failed', {
+                file: REGISTRATION_FILE,
+                method: 'clearFailoverState',
+            });
+        }
+    }
+    async resumeFailover() {
+        try {
+            const cachedState = localStorage.getItem(this.getFailoverCacheKey());
+            const failoverState = cachedState
+                ? JSON.parse(cachedState)
+                : undefined;
+            if (failoverState && !this.isDeviceRegistered()) {
+                const currentTime = Math.floor(Date.now() / 1000);
+                const newElapsed = failoverState.timeElapsed + (currentTime - failoverState.retryScheduledTime);
+                this.clearFailoverState();
+                await this.startFailoverTimer(failoverState.attempt, newElapsed);
+                return true;
+            }
+        }
+        catch (error) {
+            log.warn(`No failover state found in cache`, {
+                file: REGISTRATION_FILE,
+                method: 'triggerRegistration',
+            });
+        }
+        return false;
+    }
     getActiveMobiusUrl() {
         return this.activeMobiusUrl;
     }
@@ -88,7 +135,7 @@ export class Registration {
             });
         }
         catch (error) {
-            log.warn(`Delete failed with Mobius ${error}`, {
+            log.warn(`Delete failed with Mobius: ${JSON.stringify(error)}`, {
                 file: REGISTRATION_FILE,
                 method: METHODS.DELETE_REGISTRATION,
             });
@@ -119,6 +166,22 @@ export class Registration {
         let abort = false;
         if (this.activeMobiusUrl) {
             abort = await this.attemptRegistrationWithServers(caller, [this.activeMobiusUrl]);
+            if (this.retryAfter) {
+                if (this.retryAfter < RETRY_TIMER_UPPER_LIMIT) {
+                    setTimeout(async () => {
+                        await this.restartRegistration(caller);
+                    }, this.retryAfter * 1000);
+                }
+                else if (this.primaryMobiusUris.includes(this.activeMobiusUrl) &&
+                    this.backupMobiusUris.length > 0) {
+                    abort = await this.attemptRegistrationWithServers(caller, this.backupMobiusUris);
+                }
+                else {
+                    this.restartRegistration(caller);
+                }
+                this.retryAfter = undefined;
+                return true;
+            }
         }
         return abort;
     }
@@ -190,6 +253,12 @@ export class Registration {
             if (this.retryAfter != null) {
                 interval = Math.max(interval, this.retryAfter);
             }
+            this.saveFailoverState({
+                attempt,
+                timeElapsed,
+                retryScheduledTime: scheduledTime,
+                serverType: 'primary',
+            });
             setTimeout(async () => {
                 await this.mutex.runExclusive(async () => {
                     abort = await this.attemptRegistrationWithServers(FAILOVER_UTIL);
@@ -202,6 +271,12 @@ export class Registration {
             log.log(`Scheduled retry with primary in ${interval} seconds, number of attempts : ${attempt}`, loggerContext);
         }
         else if (this.backupMobiusUris.length) {
+            this.saveFailoverState({
+                attempt,
+                timeElapsed,
+                retryScheduledTime: Math.floor(Date.now() / 1000),
+                serverType: 'backup',
+            });
             log.info('Failing over to backup servers.', loggerContext);
             this.failoverImmediately = false;
             abort = await this.attemptRegistrationWithServers(FAILOVER_UTIL, this.backupMobiusUris);
@@ -262,7 +337,7 @@ export class Registration {
                 }
             }
             catch (error) {
-                log.warn(`Ping failed for primary Mobius: ${mobiusUrl} with error: ${error}`, {
+                log.warn(`Ping failed for primary Mobius: ${mobiusUrl} with error: ${JSON.stringify(error)}`, {
                     file: REGISTRATION_FILE,
                     method: FAILBACK_UTIL,
                 });
@@ -417,6 +492,9 @@ export class Registration {
         };
     }
     async triggerRegistration() {
+        if (await this.resumeFailover()) {
+            return;
+        }
         if (this.primaryMobiusUris.length > 0) {
             const abort = await this.attemptRegistrationWithServers(REGISTRATION_UTIL, this.primaryMobiusUris);
             if (!this.isDeviceRegistered() && !abort) {
@@ -450,6 +528,7 @@ export class Registration {
                     method: REGISTER_UTIL,
                 });
                 const resp = await this.postRegistration(url);
+                this.clearFailoverState();
                 this.deviceInfo = resp.body;
                 this.registrationStatus = RegistrationStatus.ACTIVE;
                 this.setActiveMobiusUrl(url);
@@ -537,7 +616,7 @@ export class Registration {
                                 this.lineEmitter(LINE_EVENTS.UNREGISTERED);
                                 await uploadLogs();
                                 if (!abort) {
-                                    await this.reconnectOnFailure(KEEPALIVE_UTIL);
+                                    await this.reconnectOnFailure(RECONNECT_ON_FAILURE_UTIL);
                                 }
                                 else if (error.statusCode === 404) {
                                     this.handle404KeepaliveFailure(KEEPALIVE_UTIL);
@@ -571,13 +650,14 @@ export class Registration {
             });
         }
         catch (err) {
-            log.warn(`Delete failed with Mobius: ${err}`, {
+            log.warn(`Delete failed with Mobius: ${JSON.stringify(err)}`, {
                 file: REGISTRATION_FILE,
                 method: METHODS.DEREGISTER,
             });
         }
         this.clearKeepaliveTimer();
         this.setStatus(RegistrationStatus.INACTIVE);
+        this.clearFailoverState();
     }
     isRegRetry() {
         return this.registerRetry;

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

@@ -40,10 +40,10 @@ const messageHandler = (event) => {
                 }
                 catch (err) {
                     const headers = {};
-                    if (err.headers.has('Retry-After')) {
+                    if (err.headers?.has('Retry-After')) {
                         headers['retry-after'] = err.headers.get('Retry-After');
                     }
-                    if (err.headers.has('Trackingid')) {
+                    if (err.headers?.has('Trackingid')) {
                         headers['trackingid'] = err.headers.get('Trackingid');
                     }
                     const error = {

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

@@ -70,11 +70,11 @@ const messageHandler = (event) => {
           keepAliveRetryCount = 0;
         } catch (err) {
           let headers = {};
-          if(err.headers.has('Retry-After')) {
+          if(err.headers?.has('Retry-After')) {
             headers['retry-after'] = err.headers.get('Retry-After');
           } 
 
-          if(err.headers.has('Trackingid')) {
+          if(err.headers?.has('Trackingid')) {
             headers['trackingid'] = err.headers.get('Trackingid');
           }   
 

package/dist/module/Contacts/ContactsClient.js

@@ -12,6 +12,7 @@ export class ContactsClient {
     groups;
     contacts;
     defaultGroupId;
+    contactsServiceUrl;
     constructor(webex, logger) {
         this.sdkConnector = SDKConnector;
         if (!this.sdkConnector.getWebex()) {
@@ -22,6 +23,9 @@ export class ContactsClient {
         this.groups = undefined;
         this.contacts = undefined;
         this.defaultGroupId = '';
+        this.contactsServiceUrl =
+            this.webex.internal.services._serviceUrls?.contactsService ||
+                this.webex.internal.services.get(this.webex.internal.services._activeServices.contactsService);
         log.setLogger(logger.level, CONTACTS_CLIENT);
     }
     async decryptContactDetail(encryptionKeyUrl, contactDetails) {
@@ -195,7 +199,7 @@ export class ContactsClient {
         const cloudContactsMap = {};
         try {
             const response = await this.webex.request({
-                uri: `${this.webex.internal.services._serviceUrls.contactsService}/${ENCRYPT_FILTER}/${USERS}/${CONTACT_FILTER}`,
+                uri: `${this.contactsServiceUrl}/${ENCRYPT_FILTER}/${USERS}/${CONTACT_FILTER}`,
                 method: HTTP_METHODS.GET,
             });
             log.log(`Response code: ${response.statusCode} and Response trackingId: ${response?.headers?.trackingid}`, loggerContext);
@@ -250,10 +254,8 @@ export class ContactsClient {
             return contactResponse;
         }
         catch (err) {
-            const errorInfo = err;
-            const extendedError = new Error(`Error fetching contacts: ${err}`);
-            log.error(extendedError, loggerContext);
-            const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
+            log.error(`Error fetching contacts: ${JSON.stringify(err)}`, loggerContext);
+            const errorStatus = serviceErrorCodeHandler(err, loggerContext);
             await uploadLogs();
             return errorStatus;
         }
@@ -374,7 +376,7 @@ export class ContactsClient {
         };
         try {
             const response = await this.webex.request({
-                uri: `${this.webex.internal.services._serviceUrls.contactsService}/${ENCRYPT_FILTER}/${USERS}/${GROUP_FILTER}`,
+                uri: `${this.contactsServiceUrl}/${ENCRYPT_FILTER}/${USERS}/${GROUP_FILTER}`,
                 method: HTTP_METHODS.POST,
                 body: groupInfo,
             });
@@ -394,10 +396,8 @@ export class ContactsClient {
             return contactResponse;
         }
         catch (err) {
-            const errorInfo = err;
-            const extendedError = new Error(`Unable to create contact group: ${err}`);
-            log.error(extendedError, loggerContext);
-            const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
+            log.error(`Unable to create contact group: ${JSON.stringify(err)}`, loggerContext);
+            const errorStatus = serviceErrorCodeHandler(err, loggerContext);
             await uploadLogs();
             return errorStatus;
         }
@@ -411,7 +411,7 @@ export class ContactsClient {
         try {
             log.info(`Deleting contact group: ${groupId}`, loggerContext);
             const response = await this.webex.request({
-                uri: `${this.webex.internal.services._serviceUrls.contactsService}/${ENCRYPT_FILTER}/${USERS}/${GROUP_FILTER}/${groupId}`,
+                uri: `${this.contactsServiceUrl}/${ENCRYPT_FILTER}/${USERS}/${GROUP_FILTER}/${groupId}`,
                 method: HTTP_METHODS.DELETE,
             });
             log.log(`Response trackingId: ${response?.headers?.trackingid}`, loggerContext);
@@ -431,10 +431,8 @@ export class ContactsClient {
             return contactResponse;
         }
         catch (err) {
-            const errorInfo = err;
-            const extendedError = new Error(`Unable to delete contact group ${groupId}: ${err}`);
-            log.error(extendedError, loggerContext);
-            const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
+            log.error(`Unable to delete contact group ${groupId}: ${JSON.stringify(err)}`, loggerContext);
+            const errorStatus = serviceErrorCodeHandler(err, loggerContext);
             await uploadLogs();
             return errorStatus;
         }
@@ -487,7 +485,7 @@ export class ContactsClient {
                 }
             }
             const response = await this.webex.request({
-                uri: `${this.webex.internal.services._serviceUrls.contactsService}/${ENCRYPT_FILTER}/${USERS}/${CONTACT_FILTER}`,
+                uri: `${this.contactsServiceUrl}/${ENCRYPT_FILTER}/${USERS}/${CONTACT_FILTER}`,
                 method: HTTP_METHODS.POST,
                 body: requestBody,
             });
@@ -517,10 +515,8 @@ export class ContactsClient {
             return contactResponse;
         }
         catch (err) {
-            const errorInfo = err;
-            const extendedError = new Error(`Failed to create contact: ${err}`);
-            log.error(extendedError, loggerContext);
-            const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
+            log.error(`Failed to create contact: ${JSON.stringify(err)}`, loggerContext);
+            const errorStatus = serviceErrorCodeHandler(err, loggerContext);
             await uploadLogs();
             return errorStatus;
         }
@@ -534,7 +530,7 @@ export class ContactsClient {
         try {
             log.info(`Deleting contact : ${contactId}`, loggerContext);
             const response = await this.webex.request({
-                uri: `${this.webex.internal.services._serviceUrls.contactsService}/${ENCRYPT_FILTER}/${USERS}/${CONTACT_FILTER}/${contactId}`,
+                uri: `${this.contactsServiceUrl}/${ENCRYPT_FILTER}/${USERS}/${CONTACT_FILTER}/${contactId}`,
                 method: HTTP_METHODS.DELETE,
             });
             const contactResponse = {
@@ -550,10 +546,8 @@ export class ContactsClient {
             return contactResponse;
         }
         catch (err) {
-            const errorInfo = err;
-            const extendedError = new Error(`Unable to delete contact ${contactId}: ${err}`);
-            log.error(extendedError, loggerContext);
-            const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
+            log.error(`Unable to delete contact ${contactId}: ${JSON.stringify(err)}`, loggerContext);
+            const errorStatus = serviceErrorCodeHandler(err, loggerContext);
             await uploadLogs();
             return errorStatus;
         }

package/dist/module/Events/impl/index.js

@@ -4,7 +4,7 @@ import { LOG_PREFIX } from '../../Logger/types';
 export class Eventing extends EventEmitter {
     emit(event, ...args) {
         const timestamp = new Date().toUTCString();
-        Logger.info(`${timestamp} ${LOG_PREFIX.EVENT}: ${event.toString()} - event emitted with parameters -> ${args} = `, {
+        Logger.info(`${timestamp} ${LOG_PREFIX.EVENT}: ${event.toString()} - event emitted with parameters -> ${args}`, {
             file: 'Events/impl/index.ts',
             method: 'emit',
         });

package/dist/module/Logger/index.js

@@ -101,9 +101,9 @@ const logTrace = (message, context) => {
         writeToLogger(`${format(context, '[TRACE]')} - ${LOG_PREFIX.MESSAGE}:${message}`, LOGGER.TRACE);
     }
 };
-const logError = (error, context) => {
+const logError = (errorMsg, context) => {
     if (currentLogLevel >= LOGGING_LEVEL.error) {
-        writeToLogger(`${format(context, '[ERROR]')} - !${LOG_PREFIX.ERROR}!${LOG_PREFIX.MESSAGE}:${error.message}`, LOGGER.ERROR);
+        writeToLogger(`${format(context, '[ERROR]')} - !${LOG_PREFIX.ERROR}!${LOG_PREFIX.MESSAGE}:${errorMsg}`, LOGGER.ERROR);
     }
 };
 const setWebexLogger = (logger) => {