@webex/calling 3.9.0 → 3.10.0

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`, {
@@ -14,7 +14,7 @@ export const messageHandler = (event) => {
             },
         });
         if (!response.ok) {
-            throw new Error(`Keepalive failed with status: ${response.status}`);
+            throw response;
         }
         return response;
     };
@@ -39,10 +39,23 @@ export const messageHandler = (event) => {
                     keepAliveRetryCount = 0;
                 }
                 catch (err) {
+                    const headers = {};
+                    if (err.headers.has('Retry-After')) {
+                        headers['retry-after'] = err.headers.get('Retry-After');
+                    }
+                    if (err.headers.has('Trackingid')) {
+                        headers['trackingid'] = err.headers.get('Trackingid');
+                    }
+                    const error = {
+                        headers,
+                        statusCode: err.status,
+                        statusText: err.statusText,
+                        type: err.type,
+                    };
                     keepAliveRetryCount += 1;
                     postMessage({
                         type: WorkerMessageType.KEEPALIVE_FAILURE,
-                        err,
+                        err: error,
                         keepAliveRetryCount,
                     });
                 }
@@ -57,3 +70,4 @@ export const messageHandler = (event) => {
     }
 };
 self.addEventListener('message', messageHandler);
+export default messageHandler;

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

@@ -41,7 +41,7 @@ const messageHandler = (event) => {
     });
 
     if (!response.ok) {
-      throw new Error(\`Keepalive failed with status: \${response.status}\`);
+      throw response;
     }
 
     return response;
@@ -69,10 +69,26 @@ const messageHandler = (event) => {
           }
           keepAliveRetryCount = 0;
         } catch (err) {
-          keepAliveRetryCount += 1;
+          let headers = {};
+          if(err.headers.has('Retry-After')) {
+            headers['retry-after'] = err.headers.get('Retry-After');
+          } 
+
+          if(err.headers.has('Trackingid')) {
+            headers['trackingid'] = err.headers.get('Trackingid');
+          }   
+
+          const error = {
+            headers,
+            statusCode: err.status,
+            statusText: err.statusText,
+            type: err.type,
+          };
+
+          keepAliveRetryCount += 1
           self.postMessage({
             type: WorkerMessageType.KEEPALIVE_FAILURE,
-            err,
+            err: error,
             keepAliveRetryCount,
           });
         }

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) {
@@ -85,33 +139,66 @@ class MetricManager {
                 break;
             }
             case METRIC_EVENT.REGISTRATION_ERROR: {
+                let errorData;
                 if (clientError) {
-                    data = {
-                        tags: {
-                            action: 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,
-                            reg_source: caller,
-                            server_type: serverType,
-                            trackingId,
-                            keepalive_count: keepaliveCount,
-                            error: clientError.getError().message,
-                            error_type: clientError.getError().type,
-                        },
-                        type,
+                    errorData = {
+                        msg: clientError.getError().message,
+                        type: clientError.getError().type,
                     };
                 }
+                data = {
+                    tags: {
+                        action: 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,
+                        reg_source: caller,
+                        server_type: serverType,
+                        trackingId,
+                        error: errorData?.msg,
+                        error_type: errorData?.type,
+                    },
+                    type,
+                };
+                break;
+            }
+            case METRIC_EVENT.KEEPALIVE_ERROR: {
+                let errorData;
+                if (clientError) {
+                    errorData = {
+                        msg: clientError.getError().message,
+                        type: clientError.getError().type,
+                    };
+                }
+                data = {
+                    tags: {
+                        action: 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,
+                        reg_source: caller,
+                        server_type: serverType,
+                        trackingId,
+                        keepalive_count: keepaliveCount,
+                        error: errorData?.msg,
+                        error_type: errorData?.type,
+                    },
+                    type,
+                };
                 break;
             }
             default:
                 log.warn('Invalid metric name received. Rejecting request to submit metric.', {
                     file: METRIC_FILE,
-                    method: this.submitRegistrationMetric.name,
+                    method: 'submitRegistrationMetric',
                 });
                 break;
         }
@@ -165,7 +252,7 @@ class MetricManager {
             default:
                 log.warn('Invalid metric name received. Rejecting request to submit metric.', {
                     file: METRIC_FILE,
-                    method: this.submitCallMetric.name,
+                    method: 'submitCallMetric',
                 });
                 break;
         }
@@ -223,7 +310,7 @@ class MetricManager {
             default:
                 log.warn('Invalid metric name received. Rejecting request to submit metric.', {
                     file: METRIC_FILE,
-                    method: this.submitMediaMetric.name,
+                    method: 'submitMediaMetric',
                 });
                 break;
         }
@@ -273,7 +360,7 @@ class MetricManager {
             default:
                 log.warn('Invalid metric name received. Rejecting request to submit metric.', {
                     file: METRIC_FILE,
-                    method: this.submitVoicemailMetric.name,
+                    method: 'submitVoicemailMetric',
                 });
                 break;
         }
@@ -302,7 +389,7 @@ class MetricManager {
         else {
             log.warn('Invalid metric name received. Rejecting request to submit metric.', {
                 file: METRIC_FILE,
-                method: this.submitBNRMetric.name,
+                method: 'submitBNRMetric',
             });
         }
         if (data) {

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: {},