@webex/calling 3.9.0-next.7 → 3.9.0-next.9

package/dist/module/CallingClient/CallingClient.js

@@ -11,7 +11,7 @@ import log from '../Logger';
 import { getCallManager } from './calling/callManager';
 import { CALLING_CLIENT_FILE, CALLS_CLEARED_HANDLER_UTIL, CALLING_USER_AGENT, CISCO_DEVICE_URL, DISCOVERY_URL, GET_MOBIUS_SERVERS_UTIL, IP_ENDPOINT, SPARK_USER_AGENT, URL_ENDPOINT, NETWORK_FLAP_TIMEOUT, API_V1, MOBIUS_US_PROD, MOBIUS_EU_PROD, MOBIUS_US_INT, MOBIUS_EU_INT, METHODS, } from './constants';
 import Line from './line';
-import { METRIC_EVENT, REG_ACTION, METRIC_TYPE } from '../Metrics/types';
+import { METRIC_EVENT, REG_ACTION, METRIC_TYPE, MOBIUS_SERVER_ACTION, } from '../Metrics/types';
 import { getMetricManager } from '../Metrics';
 import windowsChromiumIceWarmup from './windowsChromiumIceWarmupUtils';
 export class CallingClient extends Eventing {
@@ -87,18 +87,30 @@ export class CallingClient extends Eventing {
         this.registerCallsClearedListener();
     }
     async init() {
-        try {
-            await windowsChromiumIceWarmup({
-                iceServers: [
-                    { urls: 'stun:stun01a-us.bcld.webex.com:5004' },
-                    { urls: 'stun:stun02a-us.bcld.webex.com:5004' },
-                ],
-                timeoutMs: 1000,
-            });
-            log.info(`ICE warmup completed`, '');
-        }
-        catch (err) {
-            log.warn(`ICE warmup failed: ${err}`, '');
+        if (typeof window !== 'undefined' && window?.navigator?.userAgent) {
+            const ua = window.navigator.userAgent;
+            if (ua.toLowerCase().includes('windows')) {
+                log.info('Starting ICE warmup for Windows Chromium based browser', {
+                    file: CALLING_CLIENT_FILE,
+                    method: 'init',
+                });
+                try {
+                    await windowsChromiumIceWarmup({
+                        iceServers: [],
+                        timeoutMs: 1000,
+                    });
+                    log.info(`ICE warmup completed`, {
+                        file: CALLING_CLIENT_FILE,
+                        method: 'init',
+                    });
+                }
+                catch (err) {
+                    log.warn(`ICE warmup failed: ${err}`, {
+                        file: CALLING_CLIENT_FILE,
+                        method: 'init',
+                    });
+                }
+            }
         }
         await this.getMobiusServers();
         await this.createLine();
@@ -156,6 +168,10 @@ export class CallingClient extends Eventing {
                     },
                     service: ALLOWED_SERVICES.MOBIUS,
                 });
+                log.log(`Response trackingId: ${temp?.headers?.trackingid}`, {
+                    file: CALLING_CLIENT_FILE,
+                    method: METHODS.GET_CLIENT_REGION_INFO,
+                });
                 const myIP = temp.body.ipv4;
                 const response = await this.webex.request({
                     uri: `${DISCOVERY_URL}/${myIP}`,
@@ -165,11 +181,20 @@ export class CallingClient extends Eventing {
                         [SPARK_USER_AGENT]: null,
                     },
                 });
+                log.log(`Response trackingId: ${response?.headers?.trackingid}`, {
+                    file: CALLING_CLIENT_FILE,
+                    method: METHODS.GET_CLIENT_REGION_INFO,
+                });
                 const clientRegionInfo = response.body;
                 regionInfo.clientRegion = clientRegionInfo?.clientRegion
                     ? clientRegionInfo.clientRegion
                     : '';
                 regionInfo.countryCode = clientRegionInfo?.countryCode ? clientRegionInfo.countryCode : '';
+                log.log(`Successfully fetched Client region info: ${regionInfo.clientRegion}, countryCode: ${regionInfo.countryCode}, and response trackingid: ${response?.headers?.trackingid}`, {
+                    file: CALLING_CLIENT_FILE,
+                    method: METHODS.GET_CLIENT_REGION_INFO,
+                });
+                this.metricManager.submitRegionInfoMetric(METRIC_EVENT.MOBIUS_DISCOVERY, MOBIUS_SERVER_ACTION.REGION_INFO, METRIC_TYPE.BEHAVIORAL, this.mobiusHost, clientRegionInfo.clientRegion, clientRegionInfo.countryCode, response?.headers?.trackingid ?? '');
                 break;
             }
             catch (err) {
@@ -185,6 +210,7 @@ export class CallingClient extends Eventing {
                 regionInfo.clientRegion = '';
                 regionInfo.countryCode = '';
                 if (abort) {
+                    await uploadLogs();
                     return regionInfo;
                 }
             }
@@ -218,9 +244,12 @@ export class CallingClient extends Eventing {
             countryCode = regionInfo.countryCode;
         }
         if (clientRegion && countryCode) {
-            log.log(`Found Region: ${clientRegion} and country: ${countryCode}, going to fetch Mobius server`, '');
+            log.log(`Found Region: ${clientRegion} and country: ${countryCode}, going to fetch Mobius server`, {
+                file: CALLING_CLIENT_FILE,
+                method: GET_MOBIUS_SERVERS_UTIL,
+            });
             try {
-                const temp = await this.webex.request({
+                const response = await this.webex.request({
                     uri: `${this.mobiusHost}${URL_ENDPOINT}?regionCode=${clientRegion}&countryCode=${countryCode}`,
                     method: HTTP_METHODS.GET,
                     headers: {
@@ -229,12 +258,19 @@ export class CallingClient extends Eventing {
                     },
                     service: ALLOWED_SERVICES.MOBIUS,
                 });
-                log.log('Mobius Server found for the region', '');
-                const mobiusServers = temp.body;
+                log.log(`Mobius Server found for the region. Response trackingId: ${response?.headers?.trackingid}`, {
+                    file: CALLING_CLIENT_FILE,
+                    method: GET_MOBIUS_SERVERS_UTIL,
+                });
+                const mobiusServers = response.body;
+                this.metricManager.submitMobiusServersMetric(METRIC_EVENT.MOBIUS_DISCOVERY, MOBIUS_SERVER_ACTION.MOBIUS_SERVERS, METRIC_TYPE.BEHAVIORAL, mobiusServers, response?.headers?.trackingid ?? '');
                 const mobiusUris = filterMobiusUris(mobiusServers, this.mobiusHost);
                 this.primaryMobiusUris = mobiusUris.primary;
                 this.backupMobiusUris = mobiusUris.backup;
-                log.info(`Final list of Mobius Servers, primary: ${mobiusUris.primary} and backup: ${mobiusUris.backup}`, '');
+                log.log(`Final list of Mobius Servers, primary: ${mobiusUris.primary} and backup: ${mobiusUris.backup}`, {
+                    file: CALLING_CLIENT_FILE,
+                    method: GET_MOBIUS_SERVERS_UTIL,
+                });
             }
             catch (err) {
                 const extendedError = new Error(`Failed to get Mobius servers: ${err}`);
@@ -242,10 +278,13 @@ export class CallingClient extends Eventing {
                     method: METHODS.GET_MOBIUS_SERVERS,
                     file: CALLING_CLIENT_FILE,
                 });
-                handleCallingClientErrors(err, (clientError) => {
+                const abort = await handleCallingClientErrors(err, (clientError) => {
                     this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION_ERROR, REG_ACTION.REGISTER, METRIC_TYPE.BEHAVIORAL, GET_MOBIUS_SERVERS_UTIL, 'UNKNOWN', err.headers?.trackingId ?? '', undefined, clientError);
                     this.emit(CALLING_CLIENT_EVENT_KEYS.ERROR, clientError);
                 }, { method: GET_MOBIUS_SERVERS_UTIL, file: CALLING_CLIENT_FILE });
+                if (abort) {
+                    await uploadLogs();
+                }
                 useDefault = true;
             }
         }
@@ -253,7 +292,10 @@ export class CallingClient extends Eventing {
             useDefault = true;
         }
         if (useDefault) {
-            log.warn(`Couldn't resolve the region and country code. Defaulting to the catalog entries to discover mobius servers`, '');
+            log.warn(`Couldn't resolve the region and country code. Defaulting to the catalog entries to discover mobius servers`, {
+                file: CALLING_CLIENT_FILE,
+                method: GET_MOBIUS_SERVERS_UTIL,
+            });
             this.mobiusHost = `https://${this.mobiusClusters[0].host}${API_V1}`;
             this.primaryMobiusUris = [`${this.mobiusHost}${URL_ENDPOINT}`];
         }

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

@@ -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';
@@ -200,6 +200,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',

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);
@@ -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: [] };