@webex/calling 3.9.0-webinar5k.1 → 3.10.0

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

@@ -653,6 +653,7 @@ export class Call extends Eventing {
             await uploadLogs({
                 correlationId: this.correlationId,
                 callId: this.callId,
+                broadworksCorrelationInfo: this.broadworksCorrelationInfo,
             });
         }
     }
@@ -695,6 +696,7 @@ export class Call extends Eventing {
             await uploadLogs({
                 correlationId: this.correlationId,
                 callId: this.callId,
+                broadworksCorrelationInfo: this.broadworksCorrelationInfo,
             });
         }
     }
@@ -707,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);
@@ -726,17 +728,18 @@ 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,
+                broadworksCorrelationInfo: this.broadworksCorrelationInfo,
             });
         }
     }
@@ -749,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);
         }
@@ -777,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;
         }
@@ -808,24 +811,25 @@ 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,
+                broadworksCorrelationInfo: this.broadworksCorrelationInfo,
             });
         }
     }
@@ -848,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;
         }
@@ -857,24 +861,25 @@ 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,
+                broadworksCorrelationInfo: this.broadworksCorrelationInfo,
             });
         }
     }
@@ -896,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();
@@ -935,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();
@@ -991,6 +1006,7 @@ export class Call extends Eventing {
                 await uploadLogs({
                     correlationId: this.correlationId,
                     callId: this.callId,
+                    broadworksCorrelationInfo: this.broadworksCorrelationInfo,
                 });
             }
         }, DEFAULT_SESSION_TIMER);
@@ -1010,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,
             });
@@ -1020,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) {
@@ -1108,6 +1129,7 @@ export class Call extends Eventing {
                 await uploadLogs({
                     correlationId: this.correlationId,
                     callId: this.callId,
+                    broadworksCorrelationInfo: this.broadworksCorrelationInfo,
                 });
             }
         }
@@ -1163,6 +1185,7 @@ export class Call extends Eventing {
                 await uploadLogs({
                     correlationId: this.correlationId,
                     callId: this.callId,
+                    broadworksCorrelationInfo: this.broadworksCorrelationInfo,
                 });
             }
         }
@@ -1183,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) => {
@@ -1207,10 +1230,11 @@ 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,
+                broadworksCorrelationInfo: this.broadworksCorrelationInfo,
             });
         }
     }
@@ -1223,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) => {
@@ -1240,10 +1264,11 @@ 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,
+                broadworksCorrelationInfo: this.broadworksCorrelationInfo,
             });
         }
     }
@@ -1257,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) {
@@ -1313,6 +1338,7 @@ export class Call extends Eventing {
             await uploadLogs({
                 correlationId: this.correlationId,
                 callId: this.callId,
+                broadworksCorrelationInfo: this.broadworksCorrelationInfo,
             });
         }
     };
@@ -1465,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}`,
@@ -1528,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,
                 });
             }
         }
@@ -1556,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(),
@@ -1564,28 +1590,33 @@ 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,
+                    broadworksCorrelationInfo: this.broadworksCorrelationInfo,
                 });
             }
         }
         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(),
@@ -1593,28 +1624,33 @@ 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,
+                    broadworksCorrelationInfo: this.broadworksCorrelationInfo,
                 });
             }
         }
         else {
             log.warn(`Invalid information received, transfer failed for correlationId: ${this.getCorrelationId()}`, {
                 file: CALL_FILE,
-                method: this.completeTransfer.name,
+                method: METHODS.COMPLETE_TRANSFER,
             });
         }
     }
@@ -1677,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';
@@ -148,6 +147,7 @@ export const METHODS = {
     HANDLE_OUTGOING_ROAP_ANSWER: 'handleOutgoingRoapAnswer',
     HANDLE_INCOMING_ROAP_OFFER: 'handleIncomingRoapOffer',
     HANDLE_INCOMING_ROAP_ANSWER: 'handleIncomingRoapAnswer',
+    INIT: 'init',
     FORCE_SEND_STATS_REPORT: 'forceSendStatsReport',
     UPDATE_ACTIVE_MOBIUS: 'updateActiveMobius',
     DEQUEUE_WS_EVENTS: 'dequeueWsEvents',
@@ -199,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',
@@ -210,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/line/index.js

@@ -69,9 +69,6 @@ export default class Line extends Eventing {
             this.registration.setMobiusServers(this.#primaryMobiusUris, this.#backupMobiusUris);
             await this.registration.triggerRegistration();
         });
-        if (this.mobiusDeviceId) {
-            this.callManager.updateLine(this.mobiusDeviceId, this);
-        }
     }
     async deregister() {
         log.info(METHOD_START_MESSAGE, {
@@ -93,6 +90,9 @@ export default class Line extends Eventing {
         this.rehomingIntervalMax = rehomingIntervalMax;
         this.voicePortalNumber = voicePortalNumber;
         this.voicePortalExtension = voicePortalExtension;
+        if (this.mobiusDeviceId) {
+            this.callManager.updateLine(this.mobiusDeviceId, this);
+        }
     }
     lineEmitter = (event, deviceInfo, lineError) => {
         log.info(METHOD_START_MESSAGE, {

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);
@@ -121,6 +122,14 @@ export class Registration {
         }
         return abort;
     }
+    async handle404KeepaliveFailure(caller) {
+        if (caller === KEEPALIVE_UTIL) {
+            const abort = await this.attemptRegistrationWithServers(caller);
+            if (!abort && !this.isDeviceRegistered()) {
+                await this.startFailoverTimer();
+            }
+        }
+    }
     async handle429Retry(retryAfter, caller) {
         if (caller === FAILBACK_UTIL) {
             if (this.failback429RetryAttempts >= REG_FAILBACK_429_MAX_RETRIES) {
@@ -140,6 +149,16 @@ export class Registration {
                 await this.restartRegistration(REG_429_RETRY_UTIL);
             }
         }
+        else if (caller === KEEPALIVE_UTIL) {
+            this.clearKeepaliveTimer();
+            setTimeout(async () => {
+                log.log(`Resuming keepalive after ${retryAfter} seconds`, {
+                    file: REGISTRATION_FILE,
+                    method: REG_429_RETRY_UTIL,
+                });
+                await this.startKeepaliveTimer(this.deviceInfo.device?.uri, this.deviceInfo.keepaliveInterval, 'UNKNOWN');
+            }, retryAfter * 1000);
+        }
         else {
             this.retryAfter = retryAfter;
         }
@@ -354,18 +373,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;
@@ -433,12 +452,12 @@ export class Registration {
                 const resp = await this.postRegistration(url);
                 this.deviceInfo = resp.body;
                 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,
                 });
-                this.setActiveMobiusUrl(url);
                 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);
@@ -466,6 +485,7 @@ export class Registration {
                 }
                 if (abort) {
                     this.setStatus(RegistrationStatus.INACTIVE);
+                    await uploadLogs();
                     break;
                 }
             }
@@ -494,7 +514,7 @@ export class Registration {
                     this.webWorker.onmessage = async (event) => {
                         const logContext = {
                             file: REGISTRATION_FILE,
-                            method: this.startKeepaliveTimer.name,
+                            method: KEEPALIVE_UTIL,
                         };
                         if (event.data.type === WorkerMessageType.KEEPALIVE_SUCCESS) {
                             log.info(`Sent Keepalive, status: ${event.data.statusCode}`, logContext);
@@ -507,17 +527,21 @@ 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);
-                            }, { method: KEEPALIVE_UTIL, file: REGISTRATION_FILE });
+                                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 }, (retryAfter, retryCaller) => this.handle429Retry(retryAfter, retryCaller));
                             if (abort || event.data.keepAliveRetryCount >= RETRY_COUNT_THRESHOLD) {
                                 this.failoverImmediately = this.isCCFlow;
                                 this.setStatus(RegistrationStatus.INACTIVE);
                                 this.clearKeepaliveTimer();
                                 this.clearFailbackTimer();
                                 this.lineEmitter(LINE_EVENTS.UNREGISTERED);
+                                await uploadLogs();
                                 if (!abort) {
                                     await this.reconnectOnFailure(KEEPALIVE_UTIL);
                                 }
+                                else if (error.statusCode === 404) {
+                                    this.handle404KeepaliveFailure(KEEPALIVE_UTIL);
+                                }
                             }
                             else {
                                 this.lineEmitter(LINE_EVENTS.RECONNECTING);