@webex/calling 3.9.0-multipleLLM.2 → 3.9.0-next.10

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

@@ -709,14 +709,14 @@ export class Call extends Eventing {
             const response = await this.postSSRequest(undefined, SUPPLEMENTARY_SERVICES.RESUME);
             log.log(`Response code: ${response.statusCode}`, {
                 file: CALL_FILE,
-                method: this.handleCallResume.name,
+                method: METHODS.HANDLE_CALL_RESUME,
             });
             if (this.isHeld() === true) {
                 this.supplementaryServicesTimer = setTimeout(async () => {
-                    const errorContext = { file: CALL_FILE, method: this.handleCallResume.name };
+                    const errorContext = { file: CALL_FILE, method: METHODS.HANDLE_CALL_RESUME };
                     log.warn('Resume response timed out', {
                         file: CALL_FILE,
-                        method: this.handleCallResume.name,
+                        method: METHODS.HANDLE_CALL_RESUME,
                     });
                     const callError = createCallError('An error occurred while resuming the call. Wait a moment and try again.', errorContext, ERROR_TYPE.TIMEOUT, this.getCorrelationId(), ERROR_LAYER.CALL_CONTROL);
                     this.emit(CALL_EVENT_KEYS.RESUME_ERROR, callError);
@@ -728,14 +728,14 @@ export class Call extends Eventing {
             const extendedError = new Error(`Failed to resume the call: ${e}`);
             log.error(extendedError, {
                 file: CALL_FILE,
-                method: this.handleCallResume.name,
+                method: METHODS.HANDLE_CALL_RESUME,
             });
             const errData = e;
             handleCallErrors((error) => {
                 this.emit(CALL_EVENT_KEYS.RESUME_ERROR, error);
                 this.submitCallErrorMetric(error);
                 this.sendCallStateMachineEvt({ type: 'E_CALL_ESTABLISHED', data: errData });
-            }, ERROR_LAYER.CALL_CONTROL, (interval) => undefined, this.getCorrelationId(), errData, this.handleOutgoingCallSetup.name, CALL_FILE);
+            }, ERROR_LAYER.CALL_CONTROL, (interval) => undefined, this.getCorrelationId(), errData, METHODS.HANDLE_CALL_RESUME, CALL_FILE);
             await uploadLogs({
                 correlationId: this.correlationId,
                 callId: this.callId,
@@ -752,20 +752,20 @@ export class Call extends Eventing {
         if (data?.callProgressData?.inbandMedia) {
             log.log('Inband media present. Setting Early Media flag', {
                 file: CALL_FILE,
-                method: this.handleIncomingCallProgress.name,
+                method: METHODS.HANDLE_INCOMING_CALL_PROGRESS,
             });
             this.earlyMedia = true;
         }
         else {
             log.log('Inband media not present.', {
                 file: CALL_FILE,
-                method: this.handleIncomingCallProgress.name,
+                method: METHODS.HANDLE_INCOMING_CALL_PROGRESS,
             });
         }
         if (data?.callerId) {
             log.info('Processing Caller-Id data', {
                 file: CALL_FILE,
-                method: this.handleIncomingCallProgress.name,
+                method: METHODS.HANDLE_INCOMING_CALL_PROGRESS,
             });
             this.startCallerIdResolution(data.callerId);
         }
@@ -780,19 +780,19 @@ export class Call extends Eventing {
         if (!this.mediaConnection) {
             log.info('Media connection is not up, buffer the remote Offer Request for later handling', {
                 file: CALL_FILE,
-                method: this.handleIncomingRoapOfferRequest.name,
+                method: METHODS.HANDLE_INCOMING_ROAP_OFFER_REQUEST,
             });
             this.seq = message.seq;
             log.info(`Setting Sequence No: ${this.seq}`, {
                 file: CALL_FILE,
-                method: this.handleIncomingRoapOfferRequest.name,
+                method: METHODS.HANDLE_INCOMING_ROAP_OFFER_REQUEST,
             });
             this.remoteRoapMessage = message;
         }
         else if (this.receivedRoapOKSeq === message.seq - 2) {
             log.info('Waiting for Roap OK, buffer the remote Offer Request for later handling', {
                 file: CALL_FILE,
-                method: this.handleIncomingRoapOfferRequest.name,
+                method: METHODS.HANDLE_INCOMING_ROAP_OFFER_REQUEST,
             });
             this.remoteRoapMessage = message;
         }
@@ -811,21 +811,21 @@ export class Call extends Eventing {
             const res = await this.patch(MobiusCallState.ALERTING);
             log.log(`PATCH response: ${res.statusCode}`, {
                 file: CALL_FILE,
-                method: this.handleOutgoingCallAlerting.name,
+                method: METHODS.HANDLE_OUTGOING_CALL_ALERTING,
             });
         }
         catch (err) {
             const extendedError = new Error(`Failed to signal call progression: ${err}`);
             log.error(extendedError, {
                 file: CALL_FILE,
-                method: this.handleOutgoingCallAlerting.name,
+                method: METHODS.HANDLE_OUTGOING_CALL_ALERTING,
             });
             const errData = err;
             handleCallErrors((error) => {
                 this.emit(CALL_EVENT_KEYS.CALL_ERROR, error);
                 this.submitCallErrorMetric(error);
                 this.sendCallStateMachineEvt({ type: 'E_UNKNOWN', data: errData });
-            }, ERROR_LAYER.CALL_CONTROL, (interval) => undefined, this.getCorrelationId(), errData, this.handleOutgoingCallAlerting.name, CALL_FILE);
+            }, ERROR_LAYER.CALL_CONTROL, (interval) => undefined, this.getCorrelationId(), errData, METHODS.HANDLE_OUTGOING_CALL_ALERTING, CALL_FILE);
             await uploadLogs({
                 correlationId: this.correlationId,
                 callId: this.callId,
@@ -852,7 +852,7 @@ export class Call extends Eventing {
         if (!this.remoteRoapMessage) {
             log.warn('Offer not yet received from remote end... Exiting', {
                 file: CALL_FILE,
-                method: this.handleOutgoingCallConnect.name,
+                method: METHODS.HANDLE_OUTGOING_CALL_CONNECT,
             });
             return;
         }
@@ -861,21 +861,21 @@ export class Call extends Eventing {
             const res = await this.patch(MobiusCallState.CONNECTED);
             log.log(`PATCH response: ${res.statusCode}`, {
                 file: CALL_FILE,
-                method: this.handleOutgoingCallConnect.name,
+                method: METHODS.HANDLE_OUTGOING_CALL_CONNECT,
             });
         }
         catch (err) {
             const extendedError = new Error(`Failed to connect the call: ${err}`);
             log.error(extendedError, {
                 file: CALL_FILE,
-                method: this.handleOutgoingCallConnect.name,
+                method: METHODS.HANDLE_OUTGOING_CALL_CONNECT,
             });
             const errData = err;
             handleCallErrors((error) => {
                 this.emit(CALL_EVENT_KEYS.CALL_ERROR, error);
                 this.submitCallErrorMetric(error);
                 this.sendCallStateMachineEvt({ type: 'E_UNKNOWN', data: errData });
-            }, ERROR_LAYER.CALL_CONTROL, (interval) => undefined, this.getCorrelationId(), errData, this.handleOutgoingCallConnect.name, CALL_FILE);
+            }, ERROR_LAYER.CALL_CONTROL, (interval) => undefined, this.getCorrelationId(), errData, METHODS.HANDLE_OUTGOING_CALL_CONNECT, CALL_FILE);
             await uploadLogs({
                 correlationId: this.correlationId,
                 callId: this.callId,
@@ -901,6 +901,11 @@ export class Call extends Eventing {
                 file: CALL_FILE,
                 method: METHODS.HANDLE_OUTGOING_CALL_DISCONNECT,
             });
+            uploadLogs({
+                correlationId: this.correlationId,
+                callId: this.callId,
+                broadworksCorrelationInfo: this.broadworksCorrelationInfo,
+            });
         }
         this.deleteCb(this.correlationId);
         this.unregisterListeners();
@@ -940,6 +945,11 @@ export class Call extends Eventing {
                 file: CALL_FILE,
                 method: METHODS.HANDLE_OUTGOING_CALL_DISCONNECT,
             });
+            uploadLogs({
+                correlationId: this.correlationId,
+                callId: this.callId,
+                broadworksCorrelationInfo: this.broadworksCorrelationInfo,
+            });
         }
         this.deleteCb(this.correlationId);
         this.unregisterListeners();
@@ -1016,7 +1026,7 @@ export class Call extends Eventing {
         try {
             this.setDisconnectReason();
             const response = await this.delete();
-            log.log(`handleOutgoingCallDisconnect: Response code: ${response.statusCode}`, {
+            log.log(`Response code: ${response.statusCode}`, {
                 file: CALL_FILE,
                 method: METHODS.HANDLE_UNKNOWN_STATE,
             });
@@ -1026,6 +1036,11 @@ export class Call extends Eventing {
                 file: CALL_FILE,
                 method: METHODS.HANDLE_UNKNOWN_STATE,
             });
+            uploadLogs({
+                correlationId: this.correlationId,
+                callId: this.callId,
+                broadworksCorrelationInfo: this.broadworksCorrelationInfo,
+            });
         }
         this.deleteCb(this.correlationId);
         if (this.sessionTimer) {
@@ -1191,22 +1206,22 @@ export class Call extends Eventing {
         if (!message?.sdp) {
             log.info('Initializing Offer...', {
                 file: CALL_FILE,
-                method: this.handleOutgoingRoapOffer.name,
+                method: METHODS.HANDLE_OUTGOING_ROAP_OFFER,
             });
             this.mediaConnection.initiateOffer();
             return;
         }
         try {
             const res = await this.postMedia(message);
-            log.log(`handleOutgoingRoapOffer: Response code: ${res.statusCode}`, {
+            log.log(`Response code: ${res.statusCode}`, {
                 file: CALL_FILE,
-                method: this.handleOutgoingRoapOffer.name,
+                method: METHODS.HANDLE_OUTGOING_ROAP_OFFER,
             });
         }
         catch (err) {
             log.warn('Failed to process MediaOk request', {
                 file: CALL_FILE,
-                method: this.handleOutgoingRoapOffer.name,
+                method: METHODS.HANDLE_OUTGOING_ROAP_OFFER,
             });
             const errData = err;
             handleCallErrors(this.getEmitterCallback(errData), ERROR_LAYER.MEDIA, (interval) => {
@@ -1215,7 +1230,7 @@ export class Call extends Eventing {
                         this.sendMediaStateMachineEvt({ type: 'E_SEND_ROAP_OFFER', data: event.data });
                     }, interval * 1000);
                 }
-            }, this.getCorrelationId(), errData, this.handleOutgoingRoapOffer.name, CALL_FILE);
+            }, this.getCorrelationId(), errData, METHODS.HANDLE_OUTGOING_ROAP_OFFER, CALL_FILE);
             await uploadLogs({
                 correlationId: this.correlationId,
                 callId: this.callId,
@@ -1232,15 +1247,15 @@ export class Call extends Eventing {
         try {
             message.seq = this.seq;
             const res = await this.postMedia(message);
-            log.log(`handleOutgoingRoapAnswer: Response code: ${res.statusCode}`, {
+            log.log(`Response code: ${res.statusCode}`, {
                 file: CALL_FILE,
-                method: this.handleOutgoingRoapAnswer.name,
+                method: METHODS.HANDLE_OUTGOING_ROAP_ANSWER,
             });
         }
         catch (err) {
             log.warn('Failed to send MediaAnswer request', {
                 file: CALL_FILE,
-                method: this.handleOutgoingRoapAnswer.name,
+                method: METHODS.HANDLE_OUTGOING_ROAP_ANSWER,
             });
             const errData = err;
             handleCallErrors(this.getEmitterCallback(errData), ERROR_LAYER.MEDIA, (interval) => {
@@ -1249,7 +1264,7 @@ export class Call extends Eventing {
                         this.sendMediaStateMachineEvt({ type: 'E_SEND_ROAP_ANSWER', data: event.data });
                     }, interval * 1000);
                 }
-            }, this.getCorrelationId(), errData, this.handleOutgoingRoapAnswer.name, CALL_FILE);
+            }, this.getCorrelationId(), errData, METHODS.HANDLE_OUTGOING_ROAP_ANSWER, CALL_FILE);
             await uploadLogs({
                 correlationId: this.correlationId,
                 callId: this.callId,
@@ -1267,25 +1282,25 @@ export class Call extends Eventing {
         if (!this.mediaConnection) {
             log.info('Media connection is not up, buffer the remote offer for later handling', {
                 file: CALL_FILE,
-                method: this.handleIncomingRoapOffer.name,
+                method: METHODS.HANDLE_INCOMING_ROAP_OFFER,
             });
             this.seq = message.seq;
             log.info(`Setting Sequence No: ${this.seq}`, {
                 file: CALL_FILE,
-                method: this.handleIncomingRoapOffer.name,
+                method: METHODS.HANDLE_INCOMING_ROAP_OFFER,
             });
         }
         else if (this.receivedRoapOKSeq === message.seq - 2) {
             log.info('Waiting for Roap OK, buffer the remote offer for later handling', {
                 file: CALL_FILE,
-                method: this.handleIncomingRoapOffer.name,
+                method: METHODS.HANDLE_INCOMING_ROAP_OFFER,
             });
             this.remoteRoapMessage = message;
         }
         else {
             log.info('Handling new offer...', {
                 file: CALL_FILE,
-                method: this.handleIncomingRoapOffer.name,
+                method: METHODS.HANDLE_INCOMING_ROAP_OFFER,
             });
             this.seq = message.seq;
             if (this.mediaConnection) {
@@ -1476,7 +1491,7 @@ export class Call extends Eventing {
     async patch(state) {
         log.info(`Send a PATCH for ${state} to Webex Calling`, {
             file: CALL_FILE,
-            method: this.patch.name,
+            method: 'patch',
         });
         return this.webex.request({
             uri: `${this.mobiusUrl}${DEVICES_ENDPOINT_RESOURCE}/${this.deviceId}/${CALLS_ENDPOINT_RESOURCE}/${this.callId}`,
@@ -1539,7 +1554,7 @@ export class Call extends Eventing {
             default: {
                 log.warn(`Unknown type for PUT request: ${type}`, {
                     file: CALL_FILE,
-                    method: this.postSSRequest.name,
+                    method: METHODS.POST_SS_REQUEST,
                 });
             }
         }
@@ -1567,7 +1582,7 @@ export class Call extends Eventing {
         if (transferType === TransferType.BLIND && transferTarget) {
             log.info(`Initiating Blind transfer with : ${transferTarget}`, {
                 file: CALL_FILE,
-                method: this.completeTransfer.name,
+                method: METHODS.COMPLETE_TRANSFER,
             });
             const context = {
                 transferorCallId: this.getCallId(),
@@ -1575,18 +1590,22 @@ export class Call extends Eventing {
             };
             try {
                 await this.postSSRequest(context, SUPPLEMENTARY_SERVICES.TRANSFER);
+                log.info(`Blind Transfer completed for correlationId ${this.getCorrelationId()}`, {
+                    file: CALL_FILE,
+                    method: METHODS.COMPLETE_TRANSFER,
+                });
                 this.metricManager.submitCallMetric(METRIC_EVENT.CALL, TRANSFER_ACTION.BLIND, METRIC_TYPE.BEHAVIORAL, this.getCallId(), this.getCorrelationId(), undefined);
             }
             catch (e) {
                 log.warn(`Blind Transfer failed for correlationId ${this.getCorrelationId()}`, {
                     file: CALL_FILE,
-                    method: this.completeTransfer.name,
+                    method: METHODS.COMPLETE_TRANSFER,
                 });
                 const errData = e;
                 handleCallErrors((error) => {
                     this.emit(CALL_EVENT_KEYS.TRANSFER_ERROR, error);
                     this.submitCallErrorMetric(error, TRANSFER_ACTION.BLIND);
-                }, ERROR_LAYER.CALL_CONTROL, (interval) => undefined, this.getCorrelationId(), errData, this.completeTransfer.name, CALL_FILE);
+                }, ERROR_LAYER.CALL_CONTROL, (interval) => undefined, this.getCorrelationId(), errData, METHODS.COMPLETE_TRANSFER, CALL_FILE);
                 await uploadLogs({
                     correlationId: this.correlationId,
                     callId: this.callId,
@@ -1597,7 +1616,7 @@ export class Call extends Eventing {
         else if (transferType === TransferType.CONSULT && transferCallId) {
             log.info(`Initiating Consult transfer between : ${this.callId} and ${transferCallId}`, {
                 file: CALL_FILE,
-                method: this.completeTransfer.name,
+                method: METHODS.COMPLETE_TRANSFER,
             });
             const context = {
                 transferorCallId: this.getCallId(),
@@ -1605,18 +1624,22 @@ export class Call extends Eventing {
             };
             try {
                 await this.postSSRequest(context, SUPPLEMENTARY_SERVICES.TRANSFER);
+                log.info(`Consult Transfer completed for correlationId ${this.getCorrelationId()}`, {
+                    file: CALL_FILE,
+                    method: METHODS.COMPLETE_TRANSFER,
+                });
                 this.metricManager.submitCallMetric(METRIC_EVENT.CALL, TRANSFER_ACTION.CONSULT, METRIC_TYPE.BEHAVIORAL, this.getCallId(), this.getCorrelationId(), undefined);
             }
             catch (e) {
                 log.warn(`Consult Transfer failed for correlationId ${this.getCorrelationId()}`, {
                     file: CALL_FILE,
-                    method: this.completeTransfer.name,
+                    method: METHODS.COMPLETE_TRANSFER,
                 });
                 const errData = e;
                 handleCallErrors((error) => {
                     this.emit(CALL_EVENT_KEYS.TRANSFER_ERROR, error);
                     this.submitCallErrorMetric(error, TRANSFER_ACTION.CONSULT);
-                }, ERROR_LAYER.CALL_CONTROL, (interval) => undefined, this.getCorrelationId(), errData, this.completeTransfer.name, CALL_FILE);
+                }, ERROR_LAYER.CALL_CONTROL, (interval) => undefined, this.getCorrelationId(), errData, METHODS.COMPLETE_TRANSFER, CALL_FILE);
                 await uploadLogs({
                     correlationId: this.correlationId,
                     callId: this.callId,
@@ -1627,7 +1650,7 @@ export class Call extends Eventing {
         else {
             log.warn(`Invalid information received, transfer failed for correlationId: ${this.getCorrelationId()}`, {
                 file: CALL_FILE,
-                method: this.completeTransfer.name,
+                method: METHODS.COMPLETE_TRANSFER,
             });
         }
     }
@@ -1690,13 +1713,13 @@ export class Call extends Eventing {
                 case RoapScenario.OFFER: {
                     log.info(`before modifying sdp: ${event.roapMessage.sdp}`, {
                         file: CALL_FILE,
-                        method: this.mediaRoapEventsListener.name,
+                        method: METHODS.MEDIA_ROAP_EVENTS_LISTENER,
                     });
                     event.roapMessage.sdp = modifySdpForIPv4(event.roapMessage.sdp);
                     const sdpVideoPortZero = event.roapMessage.sdp.replace(/^m=(video) (?:\d+) /gim, 'm=$1 0 ');
                     log.info(`after modification sdp: ${sdpVideoPortZero}`, {
                         file: CALL_FILE,
-                        method: this.mediaRoapEventsListener.name,
+                        method: METHODS.MEDIA_ROAP_EVENTS_LISTENER,
                     });
                     event.roapMessage.sdp = sdpVideoPortZero;
                     this.localRoapMessage = event.roapMessage;

package/dist/module/CallingClient/constants.js

@@ -45,7 +45,7 @@ export const DUMMY_MOBIUS_URL = 'https://mobius.aintgen-a-1.int.infra.webex.com/
 export const IP_ENDPOINT = 'myip';
 export const INITIAL_SEQ_NUMBER = 1;
 export const MEDIA_ENDPOINT_RESOURCE = 'media';
-export const NETWORK_FLAP_TIMEOUT = 2000;
+export const NETWORK_FLAP_TIMEOUT = 5000;
 export const CALL_HOLD_SERVICE = 'callhold';
 export const CALL_TRANSFER_SERVICE = 'calltransfer';
 export const HOLD_ENDPOINT = 'hold';
@@ -61,7 +61,7 @@ export const WEB_AGENT = '(web)';
 export const WEBEX = 'webex';
 export const WEBEX_WEB_CLIENT = 'webex-web-client';
 export const CALLER_ID_FILE = 'CallerId';
-export const UTILS_FILE = 'utils';
+export const UTILS_FILE = 'src/common/Utils.ts';
 export const CALLING_CLIENT_FILE = 'CallingClient';
 export const LINE_FILE = 'line';
 export const CALL_FILE = 'call';
@@ -115,7 +115,6 @@ export const KEEPALIVE_UTIL = 'startKeepaliveTimer';
 export const FAILBACK_UTIL = 'executeFailback';
 export const REG_429_RETRY_UTIL = 'handle429Retry';
 export const FAILOVER_UTIL = 'startFailoverTimer';
-export const NETWORK_CHANGE_DETECTION_UTIL = 'detectNetworkChange';
 export const CALLS_CLEARED_HANDLER_UTIL = 'callsClearedHandler';
 export const RECONNECT_UTIL = 'reconnectOnFailure';
 export const NOISE_REDUCTION_EFFECT = 'noise-reduction-effect';
@@ -200,6 +199,7 @@ export const METHODS = {
     GET_CALL_RTP_STATS: 'getCallRtpStats',
     REGISTER: 'register',
     DEREGISTER: 'deregister',
+    DELETE_REGISTRATION: 'deleteRegistration',
     NORMALIZE_LINE: 'normalizeLine',
     LINE_EMITTER: 'lineEmitter',
     GET_LOGGING_LEVEL: 'getLoggingLevel',
@@ -211,7 +211,10 @@ export const METHODS = {
     SET_MOBIUS_SERVERS: 'setMobiusServers',
     HANDLE_CONNECTION_RESTORATION: 'handleConnectionRestoration',
     RECONNECT_ON_FAILURE: 'reconnectOnFailure',
-    DETECT_NETWORK_CHANGE: 'detectNetworkChange',
+    MERCURY_OFFLINE: 'handleMercuryOffline',
+    MERCURY_ONLINE: 'handleMercuryOnline',
+    NETWORK_OFFLINE: 'handleNetworkOffline',
+    NETWORK_ONLINE: 'handleNetworkOnline',
     GET_CLIENT_REGION_INFO: 'getClientRegionInfo',
     GET_MOBIUS_SERVERS: 'getMobiusServers',
     REGISTER_CALLS_CLEARED_LISTENER: 'registerCallsClearedListener',

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

@@ -90,8 +90,9 @@ export class Registration {
         catch (error) {
             log.warn(`Delete failed with Mobius ${error}`, {
                 file: REGISTRATION_FILE,
-                method: METHODS.DEREGISTER,
+                method: METHODS.DELETE_REGISTRATION,
             });
+            await uploadLogs();
         }
         this.setStatus(RegistrationStatus.INACTIVE);
         this.lineEmitter(LINE_EVENTS.UNREGISTERED);
@@ -354,18 +355,18 @@ export class Registration {
         });
         await this.mutex.runExclusive(async () => {
             if (retry) {
-                log.log('Mercury connection is up again, re-registering with Webex Calling if needed', {
+                log.log('Network is up again, re-registering with Webex Calling if needed', {
                     file: REGISTRATION_FILE,
-                    method: this.handleConnectionRestoration.name,
+                    method: METHODS.HANDLE_CONNECTION_RESTORATION,
                 });
                 this.clearKeepaliveTimer();
                 if (this.isDeviceRegistered()) {
                     await this.deregister();
                 }
                 if (this.activeMobiusUrl) {
-                    const abort = await this.restorePreviousRegistration(this.handleConnectionRestoration.name);
+                    const abort = await this.restorePreviousRegistration(METHODS.HANDLE_CONNECTION_RESTORATION);
                     if (!abort && !this.isDeviceRegistered()) {
-                        await this.restartRegistration(this.handleConnectionRestoration.name);
+                        await this.restartRegistration(METHODS.HANDLE_CONNECTION_RESTORATION);
                     }
                 }
                 retry = false;
@@ -435,7 +436,7 @@ export class Registration {
                 this.registrationStatus = RegistrationStatus.ACTIVE;
                 this.setActiveMobiusUrl(url);
                 this.lineEmitter(LINE_EVENTS.REGISTERED, resp.body);
-                log.log(`Registration successful for deviceId: ${this.deviceInfo.device?.deviceId} userId: ${this.userId}`, {
+                log.log(`Registration successful for deviceId: ${this.deviceInfo.device?.deviceId} userId: ${this.userId} responseTrackingId: ${resp.headers?.trackingid}`, {
                     file: REGISTRATION_FILE,
                     method: METHODS.REGISTER,
                 });
@@ -466,6 +467,7 @@ export class Registration {
                 }
                 if (abort) {
                     this.setStatus(RegistrationStatus.INACTIVE);
+                    await uploadLogs();
                     break;
                 }
             }
@@ -507,7 +509,7 @@ export class Registration {
                                 if (finalError) {
                                     this.lineEmitter(LINE_EVENTS.ERROR, undefined, clientError);
                                 }
-                                this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION, REG_ACTION.KEEPALIVE_FAILURE, METRIC_TYPE.BEHAVIORAL, KEEPALIVE_UTIL, serverType, error.headers?.trackingid ?? '', event.data.keepAliveRetryCount, clientError);
+                                this.metricManager.submitRegistrationMetric(METRIC_EVENT.KEEPALIVE_ERROR, REG_ACTION.KEEPALIVE_FAILURE, METRIC_TYPE.BEHAVIORAL, KEEPALIVE_UTIL, serverType, error.headers?.trackingid ?? '', event.data.keepAliveRetryCount, clientError);
                             }, { method: KEEPALIVE_UTIL, file: REGISTRATION_FILE });
                             if (abort || event.data.keepAliveRetryCount >= RETRY_COUNT_THRESHOLD) {
                                 this.failoverImmediately = this.isCCFlow;
@@ -515,6 +517,7 @@ export class Registration {
                                 this.clearKeepaliveTimer();
                                 this.clearFailbackTimer();
                                 this.lineEmitter(LINE_EVENTS.UNREGISTERED);
+                                await uploadLogs();
                                 if (!abort) {
                                     await this.reconnectOnFailure(KEEPALIVE_UTIL);
                                 }

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

@@ -1,7 +1,7 @@
 import { v4 as uuid } from 'uuid';
 import { HTTP_METHODS, WorkerMessageType } from '../../common/types';
 let keepaliveTimer;
-export const messageHandler = (event) => {
+const messageHandler = (event) => {
     const { type } = event.data;
     const postKeepAlive = async (accessToken, deviceUrl, url) => {
         const response = await fetch(`${url}/status`, {
@@ -57,3 +57,4 @@ export const messageHandler = (event) => {
     }
 };
 self.addEventListener('message', messageHandler);
+export default messageHandler;

package/dist/module/CallingClient/windowsChromiumIceWarmupUtils.js

@@ -26,10 +26,7 @@ function waitForIceComplete(pc, timeoutMs) {
         }, timeoutMs);
     });
 }
-export default async function windowsChromiumIceWarmup({ iceServers = [
-    { urls: 'stun:stun01a-us.bcld.webex.com:5004' },
-    { urls: 'stun:stun02a-us.bcld.webex.com:5004' },
-], timeoutMs = 1000, }) {
+export default async function windowsChromiumIceWarmup({ iceServers = [], timeoutMs = 1000 }) {
     const pc1 = new RTCPeerConnection({ iceServers, iceCandidatePoolSize: 1 });
     const pc2 = new RTCPeerConnection({ iceServers, iceCandidatePoolSize: 1 });
     const candidates = { pc1: [], pc2: [] };