@webex/calling 3.8.1-web-workers-keepalive.2 → 3.9.0-multi-llms.1

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

@@ -8,7 +8,7 @@ import { getCallManager } from '../calling';
 import log from '../../Logger';
 import SDKConnector from '../../SDKConnector';
 import { ALLOWED_SERVICES, HTTP_METHODS, RegistrationStatus, ServiceIndicator, WorkerMessageType, } from '../../common/types';
-import { CALLING_USER_AGENT, CISCO_DEVICE_URL, DEVICES_ENDPOINT_RESOURCE, SPARK_USER_AGENT, WEBEX_WEB_CLIENT, BASE_REG_RETRY_TIMER_VAL_IN_SEC, BASE_REG_TIMER_MFACTOR, SEC_TO_MSEC_MFACTOR, REG_RANDOM_T_FACTOR_UPPER_LIMIT, REG_TRY_BACKUP_TIMER_VAL_IN_SEC, MINUTES_TO_SEC_MFACTOR, REG_429_RETRY_UTIL, REG_FAILBACK_429_MAX_RETRIES, FAILBACK_UTIL, REGISTRATION_FILE, DEFAULT_REHOMING_INTERVAL_MIN, DEFAULT_REHOMING_INTERVAL_MAX, DEFAULT_KEEPALIVE_INTERVAL, REG_TRY_BACKUP_TIMER_VAL_FOR_CC_IN_SEC, FAILOVER_UTIL, REGISTER_UTIL, RETRY_TIMER_UPPER_LIMIT, KEEPALIVE_UTIL, REGISTRATION_UTIL, METHODS, } from '../constants';
+import { CALLING_USER_AGENT, CISCO_DEVICE_URL, DEVICES_ENDPOINT_RESOURCE, SPARK_USER_AGENT, WEBEX_WEB_CLIENT, BASE_REG_RETRY_TIMER_VAL_IN_SEC, BASE_REG_TIMER_MFACTOR, SEC_TO_MSEC_MFACTOR, REG_RANDOM_T_FACTOR_UPPER_LIMIT, REG_TRY_BACKUP_TIMER_VAL_IN_SEC, MINUTES_TO_SEC_MFACTOR, REG_429_RETRY_UTIL, REG_FAILBACK_429_MAX_RETRIES, FAILBACK_UTIL, REGISTRATION_FILE, DEFAULT_REHOMING_INTERVAL_MIN, DEFAULT_REHOMING_INTERVAL_MAX, DEFAULT_KEEPALIVE_INTERVAL, FAILOVER_UTIL, REGISTER_UTIL, RETRY_TIMER_UPPER_LIMIT, KEEPALIVE_UTIL, REGISTRATION_UTIL, METHODS, URL_ENDPOINT, } from '../constants';
 import { LINE_EVENTS } from '../line/types';
 export class Registration {
     sdkConnector;
@@ -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);
@@ -157,9 +158,7 @@ export class Registration {
             method: FAILOVER_UTIL,
         };
         let interval = this.getRegRetryInterval(attempt);
-        const TIMER_THRESHOLD = this.isCCFlow
-            ? REG_TRY_BACKUP_TIMER_VAL_FOR_CC_IN_SEC
-            : REG_TRY_BACKUP_TIMER_VAL_IN_SEC;
+        const TIMER_THRESHOLD = REG_TRY_BACKUP_TIMER_VAL_IN_SEC;
         if (timeElapsed + interval > TIMER_THRESHOLD) {
             const excessVal = timeElapsed + interval - TIMER_THRESHOLD;
             interval -= excessVal;
@@ -220,6 +219,40 @@ export class Registration {
             this.failbackTimer = undefined;
         }
     }
+    async isPrimaryActive() {
+        let status;
+        for (const mobiusUrl of this.primaryMobiusUris) {
+            try {
+                const baseUri = mobiusUrl.replace(URL_ENDPOINT, '/');
+                const response = await this.webex.request({
+                    uri: `${baseUri}ping`,
+                    method: HTTP_METHODS.GET,
+                    headers: {
+                        [CISCO_DEVICE_URL]: this.webex.internal.device.url,
+                        [SPARK_USER_AGENT]: CALLING_USER_AGENT,
+                    },
+                    service: ALLOWED_SERVICES.MOBIUS,
+                });
+                const { statusCode } = response;
+                if (statusCode === 200) {
+                    log.info(`Ping successful for primary Mobius: ${mobiusUrl}`, {
+                        file: REGISTRATION_FILE,
+                        method: FAILBACK_UTIL,
+                    });
+                    status = 'up';
+                    break;
+                }
+            }
+            catch (error) {
+                log.warn(`Ping failed for primary Mobius: ${mobiusUrl} with error: ${error}`, {
+                    file: REGISTRATION_FILE,
+                    method: FAILBACK_UTIL,
+                });
+                status = 'down';
+            }
+        }
+        return status === 'up';
+    }
     isFailbackRequired() {
         return this.isDeviceRegistered() && this.primaryMobiusUris.indexOf(this.activeMobiusUrl) === -1;
     }
@@ -250,7 +283,8 @@ export class Registration {
     async executeFailback() {
         await this.mutex.runExclusive(async () => {
             if (this.isFailbackRequired()) {
-                if (Object.keys(this.callManager.getActiveCalls()).length === 0) {
+                const primaryServerStatus = await this.isPrimaryActive();
+                if (Object.keys(this.callManager.getActiveCalls()).length === 0 && primaryServerStatus) {
                     log.info(`Attempting failback to primary.`, {
                         file: REGISTRATION_FILE,
                         method: this.executeFailback.name,
@@ -274,7 +308,7 @@ export class Registration {
                     }
                 }
                 else {
-                    log.info('Active calls present, deferring failback to next cycle.', {
+                    log.info('Active calls present or primary Mobius is down, deferring failback to next cycle.', {
                         file: REGISTRATION_FILE,
                         method: this.executeFailback.name,
                     });
@@ -321,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;
@@ -400,12 +434,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);
@@ -433,6 +467,7 @@ export class Registration {
                 }
                 if (abort) {
                     this.setStatus(RegistrationStatus.INACTIVE);
+                    await uploadLogs();
                     break;
                 }
             }
@@ -474,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;
@@ -482,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

@@ -0,0 +1,59 @@
+function waitForIceComplete(pc, timeoutMs) {
+    return new Promise((resolve) => {
+        if (!pc) {
+            resolve({ ok: false, reason: 'no-pc' });
+            return;
+        }
+        if (pc.iceGatheringState === 'complete') {
+            resolve({ ok: true, reached: 'already' });
+            return;
+        }
+        let done = false;
+        const onChange = () => {
+            if (pc.iceGatheringState === 'complete' && !done) {
+                done = true;
+                pc.removeEventListener('icegatheringstatechange', onChange);
+                resolve({ ok: true, reached: 'event' });
+            }
+        };
+        pc.addEventListener('icegatheringstatechange', onChange);
+        setTimeout(() => {
+            if (done)
+                return;
+            done = true;
+            pc.removeEventListener('icegatheringstatechange', onChange);
+            resolve({ ok: pc.iceGatheringState === 'complete', reached: 'timeout' });
+        }, timeoutMs);
+    });
+}
+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: [] };
+    pc1.onicecandidate = (e) => {
+        if (e.candidate && e.candidate.type !== 'host') {
+            candidates.pc1.push(e.candidate);
+        }
+    };
+    await pc1.createDataChannel('warmup');
+    await pc1.addTransceiver('audio');
+    const offer = await pc1.createOffer();
+    await pc1.setLocalDescription(offer);
+    await waitForIceComplete(pc1, timeoutMs);
+    await pc2.setRemoteDescription(offer);
+    pc2.onicecandidate = (e) => {
+        if (e.candidate && e.candidate.type !== 'host') {
+            candidates.pc2.push(e.candidate);
+        }
+    };
+    const answer = await pc2.createAnswer();
+    await pc2.setLocalDescription(answer);
+    await pc1.setRemoteDescription(answer);
+    await waitForIceComplete(pc2, timeoutMs);
+    await Promise.all([
+        ...candidates.pc1.map((candidate) => pc2.addIceCandidate(candidate).catch(console.error)),
+        ...candidates.pc2.map((candidate) => pc1.addIceCandidate(candidate).catch(console.error)),
+    ]);
+    pc1.close();
+    pc2.close();
+}

package/dist/module/Contacts/ContactsClient.js

@@ -2,7 +2,7 @@ import { FAILURE_MESSAGE, METHOD_START_MESSAGE, SCIM_ENTERPRISE_USER, SCIM_WEBEX
 import { HTTP_METHODS } from '../common/types';
 import SDKConnector from '../SDKConnector';
 import log from '../Logger';
-import { CONTACTS_FILE, CONTACTS_SCHEMA, CONTACT_FILTER, DEFAULT_GROUP_NAME, ENCRYPT_FILTER, GROUP_FILTER, METHODS, OR, SCIM_ID_FILTER, USERS, encryptedFields, } from './constants';
+import { CONTACTS_CLIENT, CONTACTS_SCHEMA, CONTACT_FILTER, DEFAULT_GROUP_NAME, ENCRYPT_FILTER, GROUP_FILTER, METHODS, OR, SCIM_ID_FILTER, USERS, encryptedFields, } from './constants';
 import { ContactType, GroupType, } from './types';
 import { scimQuery, serviceErrorCodeHandler, uploadLogs } from '../common/Utils';
 export class ContactsClient {
@@ -22,7 +22,7 @@ export class ContactsClient {
         this.groups = undefined;
         this.contacts = undefined;
         this.defaultGroupId = '';
-        log.setLogger(logger.level, CONTACTS_FILE);
+        log.setLogger(logger.level, CONTACTS_CLIENT);
     }
     async decryptContactDetail(encryptionKeyUrl, contactDetails) {
         const decryptedContactDetail = [...contactDetails];
@@ -130,7 +130,7 @@ export class ContactsClient {
     }
     resolveCloudContacts(contactsDataMap, inputList) {
         const loggerContext = {
-            file: CONTACTS_FILE,
+            file: CONTACTS_CLIENT,
             method: 'resolveCloudContacts',
         };
         const finalContactList = [];
@@ -187,7 +187,7 @@ export class ContactsClient {
     }
     async getContacts() {
         const loggerContext = {
-            file: CONTACTS_FILE,
+            file: CONTACTS_CLIENT,
             method: METHODS.GET_CONTACTS,
         };
         log.info(METHOD_START_MESSAGE, loggerContext);
@@ -198,6 +198,7 @@ export class ContactsClient {
                 uri: `${this.webex.internal.services._serviceUrls.contactsService}/${ENCRYPT_FILTER}/${USERS}/${CONTACT_FILTER}`,
                 method: HTTP_METHODS.GET,
             });
+            log.log(`Response code: ${response.statusCode} and Response trackingId: ${response?.headers?.trackingid}`, loggerContext);
             const responseBody = response.body;
             if (!responseBody) {
                 throw new Error(`${response}`);
@@ -259,7 +260,7 @@ export class ContactsClient {
     }
     async createNewEncryptionKeyUrl() {
         const loggerContext = {
-            file: CONTACTS_FILE,
+            file: CONTACTS_CLIENT,
             method: METHODS.CREATE_NEW_ENCRYPTION_KEY_URL,
         };
         log.info(METHOD_START_MESSAGE, loggerContext);
@@ -272,7 +273,7 @@ export class ContactsClient {
     }
     async fetchEncryptionKeyUrl() {
         const loggerContext = {
-            file: CONTACTS_FILE,
+            file: CONTACTS_CLIENT,
             method: METHODS.FETCH_ENCRYPTION_KEY_URL,
         };
         log.info(METHOD_START_MESSAGE, loggerContext);
@@ -287,14 +288,14 @@ export class ContactsClient {
         }
         this.encryptionKeyUrl = await this.createNewEncryptionKeyUrl();
         log.log(`Creating a default group: ${DEFAULT_GROUP_NAME}`, {
-            file: CONTACTS_FILE,
+            file: CONTACTS_CLIENT,
             method: this.fetchEncryptionKeyUrl.name,
         });
         const response = await this.createContactGroup(DEFAULT_GROUP_NAME, this.encryptionKeyUrl);
         if (response.data.group?.groupId) {
             this.defaultGroupId = response.data.group?.groupId;
             log.log(`Successfully created default group with ID: ${this.defaultGroupId}`, {
-                file: CONTACTS_FILE,
+                file: CONTACTS_CLIENT,
                 method: this.fetchEncryptionKeyUrl.name,
             });
         }
@@ -302,13 +303,13 @@ export class ContactsClient {
     }
     async fetchDefaultGroup() {
         const loggerContext = {
-            file: CONTACTS_FILE,
+            file: CONTACTS_CLIENT,
             method: METHODS.FETCH_DEFAULT_GROUP,
         };
         log.info(METHOD_START_MESSAGE, loggerContext);
         if (this.defaultGroupId) {
             log.log(`Using existing default group with ID: ${this.defaultGroupId}`, {
-                file: CONTACTS_FILE,
+                file: CONTACTS_CLIENT,
                 method: this.fetchDefaultGroup.name,
             });
             return this.defaultGroupId;
@@ -318,7 +319,7 @@ export class ContactsClient {
                 if (this.groups[i].displayName === DEFAULT_GROUP_NAME) {
                     this.defaultGroupId = this.groups[i].groupId;
                     log.log(`Found default group with ID: ${this.defaultGroupId}`, {
-                        file: CONTACTS_FILE,
+                        file: CONTACTS_CLIENT,
                         method: this.fetchDefaultGroup.name,
                     });
                     return this.defaultGroupId;
@@ -326,7 +327,7 @@ export class ContactsClient {
             }
         }
         log.log('No default group found.', {
-            file: CONTACTS_FILE,
+            file: CONTACTS_CLIENT,
             method: this.fetchDefaultGroup.name,
         });
         const response = await this.createContactGroup(DEFAULT_GROUP_NAME);
@@ -334,7 +335,7 @@ export class ContactsClient {
         if (group) {
             const groupId = group.groupId;
             log.log(`Successfully created new default group with ID: ${groupId}`, {
-                file: CONTACTS_FILE,
+                file: CONTACTS_CLIENT,
                 method: this.fetchDefaultGroup.name,
             });
             return groupId;
@@ -343,7 +344,7 @@ export class ContactsClient {
     }
     async createContactGroup(displayName, encryptionKeyUrl, groupType) {
         const loggerContext = {
-            file: CONTACTS_FILE,
+            file: CONTACTS_CLIENT,
             method: METHODS.CREATE_CONTACT_GROUP,
         };
         log.info(`${METHOD_START_MESSAGE} with displayName: ${displayName}`, loggerContext);
@@ -377,6 +378,8 @@ export class ContactsClient {
                 method: HTTP_METHODS.POST,
                 body: groupInfo,
             });
+            log.log(`Response code: ${response.statusCode}`, loggerContext);
+            log.log(`Response trackingId: ${response?.headers?.trackingid}`, loggerContext);
             const group = response.body;
             group.displayName = displayName;
             const contactResponse = {
@@ -401,7 +404,7 @@ export class ContactsClient {
     }
     async deleteContactGroup(groupId) {
         const loggerContext = {
-            file: CONTACTS_FILE,
+            file: CONTACTS_CLIENT,
             method: METHODS.DELETE_CONTACT_GROUP,
         };
         log.info(`${METHOD_START_MESSAGE} with groupId: ${groupId}`, loggerContext);
@@ -411,6 +414,7 @@ export class ContactsClient {
                 uri: `${this.webex.internal.services._serviceUrls.contactsService}/${ENCRYPT_FILTER}/${USERS}/${GROUP_FILTER}/${groupId}`,
                 method: HTTP_METHODS.DELETE,
             });
+            log.log(`Response trackingId: ${response?.headers?.trackingid}`, loggerContext);
             const contactResponse = {
                 statusCode: Number(response[STATUS_CODE]),
                 data: {},
@@ -437,7 +441,7 @@ export class ContactsClient {
     }
     async createContact(contactInfo) {
         const loggerContext = {
-            file: CONTACTS_FILE,
+            file: CONTACTS_CLIENT,
             method: METHODS.CREATE_CONTACT,
         };
         log.info(`${METHOD_START_MESSAGE} with contactType: ${contactInfo.contactType}`, loggerContext);
@@ -487,6 +491,8 @@ export class ContactsClient {
                 method: HTTP_METHODS.POST,
                 body: requestBody,
             });
+            log.log(`Response code: ${response.statusCode}`, loggerContext);
+            log.log(`Response trackingId: ${response?.headers?.trackingid}`, loggerContext);
             const newContact = response.body;
             contact.contactId = newContact.contactId;
             const contactResponse = {
@@ -521,7 +527,7 @@ export class ContactsClient {
     }
     async deleteContact(contactId) {
         const loggerContext = {
-            file: CONTACTS_FILE,
+            file: CONTACTS_CLIENT,
             method: METHODS.DELETE_CONTACT,
         };
         log.info(`${METHOD_START_MESSAGE} with contactId: ${contactId}`, loggerContext);

package/dist/module/Contacts/constants.js

@@ -1,4 +1,4 @@
-export const CONTACTS_FILE = 'Contacts';
+export const CONTACTS_CLIENT = 'ContactsClient';
 export const CONTACT_FILTER = 'contacts';
 export const GROUP_FILTER = 'groups';
 export const ENCRYPT_FILTER = 'encrypt';

package/dist/module/Metrics/index.js

@@ -1,5 +1,6 @@
 import { METRIC_FILE, VERSION } from '../CallingClient/constants';
-import { METRIC_EVENT } from './types';
+import { ServiceIndicator } from '../common/types';
+import { METRIC_EVENT, } from './types';
 import log from '../Logger';
 let metricManager;
 class MetricManager {
@@ -11,48 +12,60 @@ class MetricManager {
         this.webex = webex;
         this.serviceIndicator = indicator;
     }
-    submitUploadLogsMetric(name, action, type, trackingId, feedbackId, correlationId, stack, callId) {
+    submitConnectionMetrics(name, metricAction, type, downTimestamp, upTimestamp) {
+        const metricData = {
+            tags: {
+                metricAction,
+                device_id: this.deviceInfo?.device?.deviceId,
+                service_indicator: this.serviceIndicator,
+            },
+            fields: {
+                device_url: this.deviceInfo?.device?.clientDeviceUri,
+                mobius_url: this.deviceInfo?.device?.uri,
+                calling_sdk_version: process.env.CALLING_SDK_VERSION || VERSION,
+                downTimestamp,
+                upTimestamp,
+            },
+            type,
+        };
+        if (metricData) {
+            this.webex.internal.metrics.submitClientMetrics(name, metricData);
+        }
+    }
+    submitUploadLogsMetric(name, action, type, trackingId, feedbackId, correlationId, stack, callId, broadworksCorrelationInfo) {
         let data;
+        const commonData = {
+            tags: {
+                action,
+                device_id: this.deviceInfo?.device?.deviceId,
+                service_indicator: this.serviceIndicator,
+            },
+            fields: {
+                device_url: this.deviceInfo?.device?.clientDeviceUri,
+                mobius_url: this.deviceInfo?.device?.uri,
+                calling_sdk_version: process.env.CALLING_SDK_VERSION || VERSION,
+                correlation_id: correlationId,
+                broadworksCorrelationInfo,
+                tracking_id: trackingId,
+                feedback_id: feedbackId,
+                call_id: callId,
+            },
+            type,
+        };
         switch (name) {
             case METRIC_EVENT.UPLOAD_LOGS_SUCCESS: {
-                data = {
-                    tags: {
-                        action,
-                        device_id: this.deviceInfo?.device?.deviceId,
-                        service_indicator: this.serviceIndicator,
-                    },
-                    fields: {
-                        device_url: this.deviceInfo?.device?.clientDeviceUri,
-                        mobius_url: this.deviceInfo?.device?.uri,
-                        calling_sdk_version: process.env.CALLING_SDK_VERSION || VERSION,
-                        correlation_id: correlationId,
-                        tracking_id: trackingId,
-                        feedback_id: feedbackId,
-                        call_id: callId,
-                    },
-                    type,
-                };
+                data = commonData;
                 break;
             }
             case METRIC_EVENT.UPLOAD_LOGS_FAILED: {
                 data = {
-                    tags: {
-                        action,
-                        device_id: this.deviceInfo?.device?.deviceId,
-                        service_indicator: this.serviceIndicator,
-                    },
+                    ...commonData,
                     fields: {
-                        device_url: this.deviceInfo?.device?.clientDeviceUri,
-                        mobius_url: this.deviceInfo?.device?.uri,
-                        calling_sdk_version: process.env.CALLING_SDK_VERSION || VERSION,
-                        correlation_id: correlationId,
-                        tracking_id: trackingId,
-                        feedback_id: feedbackId,
+                        ...commonData.fields,
                         error: stack,
-                        call_id: callId,
                     },
-                    type,
                 };
+                break;
             }
         }
         if (data) {
@@ -62,6 +75,47 @@ class MetricManager {
     setDeviceInfo(deviceInfo) {
         this.deviceInfo = deviceInfo;
     }
+    submitRegionInfoMetric(name, metricAction, type, mobiusHost, clientRegion, countryCode, trackingId) {
+        const data = {
+            tags: {
+                action: metricAction,
+                device_id: this.deviceInfo?.device?.deviceId,
+                service_indicator: ServiceIndicator.CALLING,
+            },
+            fields: {
+                device_url: this.deviceInfo?.device?.clientDeviceUri,
+                mobius_url: this.deviceInfo?.device?.uri,
+                calling_sdk_version: process.env.CALLING_SDK_VERSION || VERSION,
+                mobius_host: mobiusHost,
+                client_region: clientRegion,
+                country_code: countryCode,
+                tracking_id: trackingId,
+            },
+            type,
+        };
+        this.webex.internal.metrics.submitClientMetrics(name, data);
+    }
+    submitMobiusServersMetric(name, metricAction, type, mobiusServers, trackingId) {
+        const data = {
+            tags: {
+                action: metricAction,
+                device_id: this.deviceInfo?.device?.deviceId,
+                service_indicator: ServiceIndicator.CALLING,
+            },
+            fields: {
+                device_url: this.deviceInfo?.device?.clientDeviceUri,
+                mobius_url: this.deviceInfo?.device?.uri,
+                calling_sdk_version: process.env.CALLING_SDK_VERSION || VERSION,
+                primary_mobius_servers_region: mobiusServers.primary.region,
+                primary_mobius_servers_uris: mobiusServers.primary.uris.join(','),
+                backup_mobius_servers_region: mobiusServers.backup.region,
+                backup_mobius_servers_uris: mobiusServers.backup.uris.join(','),
+                tracking_id: trackingId,
+            },
+            type,
+        };
+        this.webex.internal.metrics.submitClientMetrics(name, data);
+    }
     submitRegistrationMetric(name, metricAction, type, caller, serverType, trackingId, keepaliveCount, clientError) {
         let data;
         switch (name) {

package/dist/module/Metrics/types.js

@@ -9,15 +9,23 @@ export var METRIC_EVENT;
     METRIC_EVENT["BNR_DISABLED"] = "web-calling-sdk-bnr-disabled";
     METRIC_EVENT["CALL"] = "web-calling-sdk-callcontrol";
     METRIC_EVENT["CALL_ERROR"] = "web-calling-sdk-callcontrol-error";
+    METRIC_EVENT["CONNECTION_ERROR"] = "web-calling-sdk-connection";
     METRIC_EVENT["MEDIA"] = "web-calling-sdk-media";
     METRIC_EVENT["MEDIA_ERROR"] = "web-calling-sdk-media-error";
     METRIC_EVENT["REGISTRATION"] = "web-calling-sdk-registration";
     METRIC_EVENT["REGISTRATION_ERROR"] = "web-calling-sdk-registration-error";
+    METRIC_EVENT["KEEPALIVE_ERROR"] = "web-calling-sdk-keepalive-error";
     METRIC_EVENT["VOICEMAIL"] = "web-calling-sdk-voicemail";
     METRIC_EVENT["VOICEMAIL_ERROR"] = "web-calling-sdk-voicemail-error";
     METRIC_EVENT["UPLOAD_LOGS_SUCCESS"] = "web-calling-sdk-upload-logs-success";
     METRIC_EVENT["UPLOAD_LOGS_FAILED"] = "web-calling-sdk-upload-logs-failed";
+    METRIC_EVENT["MOBIUS_DISCOVERY"] = "web-calling-sdk-mobius-discovery";
 })(METRIC_EVENT || (METRIC_EVENT = {}));
+export var MOBIUS_SERVER_ACTION;
+(function (MOBIUS_SERVER_ACTION) {
+    MOBIUS_SERVER_ACTION["REGION_INFO"] = "region-info";
+    MOBIUS_SERVER_ACTION["MOBIUS_SERVERS"] = "mobius-servers";
+})(MOBIUS_SERVER_ACTION || (MOBIUS_SERVER_ACTION = {}));
 export var REG_ACTION;
 (function (REG_ACTION) {
     REG_ACTION["REGISTER"] = "register";
@@ -40,3 +48,9 @@ export var VOICEMAIL_ACTION;
     VOICEMAIL_ACTION["TRANSCRIPT"] = "transcript";
 })(VOICEMAIL_ACTION || (VOICEMAIL_ACTION = {}));
 export const UPLOAD_LOGS_ACTION = 'upload_logs';
+export var CONNECTION_ACTION;
+(function (CONNECTION_ACTION) {
+    CONNECTION_ACTION["NETWORK_FLAP"] = "network_flap";
+    CONNECTION_ACTION["MERCURY_DOWN"] = "mercury_down";
+    CONNECTION_ACTION["MERCURY_UP"] = "mercury_up";
+})(CONNECTION_ACTION || (CONNECTION_ACTION = {}));

package/dist/module/Voicemail/BroadworksBackendConnector.js

@@ -128,6 +128,7 @@ export class BroadworksBackendConnector {
                     throw new Error(`${response.status}`);
                 }
                 const voicemailListResponse = (await response.json());
+                log.log(`Response trackingId: ${response.headers?.get('trackingid')}`, loggerContext);
                 if (Object.keys(voicemailListResponse?.VoiceMessagingMessages?.messageInfoList).length === 0) {
                     messageinfo = [];
                 }
@@ -181,6 +182,7 @@ export class BroadworksBackendConnector {
                 throw new Error(`${response.status}`);
             }
             const xmlData = await response.text();
+            log.log(`Response trackingId: ${response.headers?.get('trackingid')}`, loggerContext);
             const parser = new DOMParser();
             const xmlDOM = parser.parseFromString(xmlData, XML_TYPE);
             const mediaDetails = xmlDOM.getElementsByTagName(MESSAGE_MEDIA_CONTENT)[0];
@@ -232,6 +234,7 @@ export class BroadworksBackendConnector {
                 throw new Error(`${response.status}`);
             }
             log.log(`Successfully marked voicemail with ID ${messageId} as read`, loggerContext);
+            log.log(`Response trackingId: ${response.headers?.get('trackingid')}`, loggerContext);
             const responseDetails = {
                 statusCode: response.status,
                 data: {},

package/dist/module/Voicemail/UcmBackendConnector.js

@@ -59,6 +59,7 @@ export class UcmBackendConnector {
                     orgId: this.orgId,
                 },
             });
+            log.log(`Response trackingId: ${response?.headers?.trackingid}`, loggerContext);
             const msgInfo = response.body;
             const messageinfoArray = [];
             const ucmVmMsgInfo = msgInfo.Message;
@@ -186,6 +187,8 @@ export class UcmBackendConnector {
                 mercuryHostname: mercuryApi,
             },
         });
+        log.log(`Response code: ${response.statusCode}`, loggerContext);
+        log.log(`Response trackingId: ${response?.headers?.trackingid}`, loggerContext);
         const contentInfo = response?.body;
         const respHeaders = response.headers;
         const statusCode = response.statusCode;
@@ -224,6 +227,7 @@ export class UcmBackendConnector {
                     read: 'true',
                 },
             });
+            log.log(`Response trackingId: ${response?.headers?.trackingid}`, loggerContext);
             const responseDetails = {
                 statusCode: Number(response.statusCode),
                 data: {},
@@ -259,6 +263,7 @@ export class UcmBackendConnector {
                     read: 'false',
                 },
             });
+            log.log(`Response trackingId: ${response?.headers?.trackingid}`, loggerContext);
             const responseDetails = {
                 statusCode: Number(response.statusCode),
                 data: {},
@@ -291,6 +296,7 @@ export class UcmBackendConnector {
                     orgId: this.orgId,
                 },
             });
+            log.log(`Response trackingId: ${response?.headers?.trackingid}`, loggerContext);
             const responseDetails = {
                 statusCode: Number(response.statusCode),
                 data: {},