@webex/calling 3.8.1 → 3.9.0-multi-llms.2

package/dist/module/CallingClient/CallingClient.js

@@ -9,10 +9,11 @@ import { MOBIUS_EVENT_KEYS, SessionType, CALLING_CLIENT_EVENT_KEYS, } from '../E
 import { ServiceIndicator, ALLOWED_SERVICES, HTTP_METHODS, RegistrationStatus, } from '../common/types';
 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 { 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, API_V1, MOBIUS_US_PROD, MOBIUS_EU_PROD, MOBIUS_US_INT, MOBIUS_EU_INT, METHODS, NETWORK_FLAP_TIMEOUT, } from './constants';
 import Line from './line';
-import { METRIC_EVENT, REG_ACTION, METRIC_TYPE } from '../Metrics/types';
+import { METRIC_EVENT, REG_ACTION, METRIC_TYPE, CONNECTION_ACTION, MOBIUS_SERVER_ACTION, } from '../Metrics/types';
 import { getMetricManager } from '../Metrics';
+import windowsChromiumIceWarmup from './windowsChromiumIceWarmupUtils';
 export class CallingClient extends Eventing {
     sdkConnector;
     webex;
@@ -26,6 +27,11 @@ export class CallingClient extends Eventing {
     mobiusHost;
     mediaEngine;
     lineDict = {};
+    isNetworkDown = false;
+    networkDownTimestamp = '';
+    networkUpTimestamp = '';
+    mercuryDownTimestamp = '';
+    mercuryUpTimestamp = '';
     constructor(webex, config) {
         super();
         this.sdkConnector = SDKConnector;
@@ -69,57 +75,175 @@ export class CallingClient extends Eventing {
                 method: this.constructor.name,
             });
         }
-        this.mobiusClusters =
-            (mobiusServiceHost && this.webex.internal.services._hostCatalog[mobiusServiceHost]) ||
-                this.webex.internal.services._hostCatalog[MOBIUS_US_PROD] ||
-                this.webex.internal.services._hostCatalog[MOBIUS_EU_PROD] ||
-                this.webex.internal.services._hostCatalog[MOBIUS_US_INT] ||
-                this.webex.internal.services._hostCatalog[MOBIUS_EU_INT];
+        if (this.webex.internal.services._hostCatalog) {
+            this.mobiusClusters =
+                (mobiusServiceHost && this.webex.internal.services._hostCatalog[mobiusServiceHost]) ||
+                    this.webex.internal.services._hostCatalog[MOBIUS_US_PROD] ||
+                    this.webex.internal.services._hostCatalog[MOBIUS_EU_PROD] ||
+                    this.webex.internal.services._hostCatalog[MOBIUS_US_INT] ||
+                    this.webex.internal.services._hostCatalog[MOBIUS_EU_INT];
+        }
+        else {
+            const mobiusObject = this.webex.internal.services._services.find((item) => item.serviceName === 'mobius');
+            this.mobiusClusters = [mobiusObject.serviceUrls[0].baseUrl];
+        }
         this.mobiusHost = '';
         this.registerSessionsListener();
         this.registerCallsClearedListener();
     }
     async init() {
+        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();
-        this.detectNetworkChange();
+        this.setupNetworkEventListeners();
     }
-    async detectNetworkChange() {
+    async checkNetworkReachability() {
+        try {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 3000);
+            await fetch('https://www.google.com/generate_204', {
+                method: 'GET',
+                cache: 'no-cache',
+                mode: 'no-cors',
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            return true;
+        }
+        catch (error) {
+            log.warn(`Network connectivity probe failed: ${error}`, {
+                file: CALLING_CLIENT_FILE,
+                method: 'pingExternal',
+            });
+            return false;
+        }
+    }
+    async checkCallStatus() {
+        const loggerContext = {
+            file: CALLING_CLIENT_FILE,
+            method: 'checkCallStatus',
+        };
+        const calls = Object.values(this.callManager.getActiveCalls());
+        for (const call of calls) {
+            call
+                .postStatus()
+                .then(() => {
+                log.info(`Call is active`, loggerContext);
+            })
+                .catch((err) => {
+                log.warn(`Call Keepalive failed: ${err}`, loggerContext);
+                call.sendCallStateMachineEvt({ type: 'E_SEND_CALL_DISCONNECT' });
+            });
+        }
+    }
+    handleNetworkOffline = async () => {
+        this.networkDownTimestamp = new Date().toISOString();
+        this.isNetworkDown = !(await this.checkNetworkReachability());
+        log.warn(`Network has gone down, wait for it to come back up`, {
+            file: CALLING_CLIENT_FILE,
+            method: METHODS.NETWORK_OFFLINE,
+        });
+        if (this.isNetworkDown) {
+            const line = Object.values(this.lineDict)[0];
+            line.registration.clearKeepaliveTimer();
+        }
+    };
+    handleNetworkOnline = () => {
         log.info(METHOD_START_MESSAGE, {
             file: CALLING_CLIENT_FILE,
-            method: METHODS.DETECT_NETWORK_CHANGE,
+            method: METHODS.NETWORK_ONLINE,
         });
-        let retry = false;
-        const line = Object.values(this.lineDict)[0];
-        setInterval(async () => {
-            if (!this.webex.internal.mercury.connected &&
-                !retry &&
-                !Object.keys(this.callManager.getActiveCalls()).length) {
-                log.warn(`Network has flapped, waiting for mercury connection to be up`, {
-                    file: CALLING_CLIENT_FILE,
-                    method: METHODS.DETECT_NETWORK_CHANGE,
-                });
-                line.registration.clearKeepaliveTimer();
-                retry = true;
-            }
-            if (retry && this.webex.internal.mercury.connected) {
-                if (line.getStatus() !== RegistrationStatus.IDLE) {
-                    retry = await line.registration.handleConnectionRestoration(retry);
-                }
-                else {
-                    retry = false;
+        this.networkUpTimestamp = new Date().toISOString();
+    };
+    handleMercuryOffline = () => {
+        log.warn(`Mercury down, waiting for connection to be up`, {
+            file: CALLING_CLIENT_FILE,
+            method: METHODS.MERCURY_OFFLINE,
+        });
+        this.mercuryDownTimestamp = new Date().toISOString();
+        this.metricManager.submitConnectionMetrics(METRIC_EVENT.CONNECTION_ERROR, CONNECTION_ACTION.MERCURY_DOWN, METRIC_TYPE.BEHAVIORAL, this.mercuryDownTimestamp, this.mercuryUpTimestamp);
+    };
+    handleMercuryOnline = async () => {
+        log.info(METHOD_START_MESSAGE, {
+            file: CALLING_CLIENT_FILE,
+            method: METHODS.MERCURY_ONLINE,
+        });
+        this.mercuryUpTimestamp = new Date().toISOString();
+        if (this.isNetworkDown) {
+            const callCheckInterval = setInterval(async () => {
+                if (!Object.keys(this.callManager.getActiveCalls()).length) {
+                    clearInterval(callCheckInterval);
+                    const line = Object.values(this.lineDict)[0];
+                    if (line.getStatus() !== RegistrationStatus.IDLE) {
+                        this.isNetworkDown = await line.registration.handleConnectionRestoration(this.isNetworkDown);
+                    }
+                    else {
+                        this.isNetworkDown = false;
+                    }
                 }
+            }, NETWORK_FLAP_TIMEOUT);
+            if (Object.keys(this.callManager.getActiveCalls()).length) {
+                await this.checkCallStatus();
             }
-        }, NETWORK_FLAP_TIMEOUT);
+            this.metricManager.submitConnectionMetrics(METRIC_EVENT.CONNECTION_ERROR, CONNECTION_ACTION.NETWORK_FLAP, METRIC_TYPE.BEHAVIORAL, this.networkDownTimestamp, this.networkUpTimestamp);
+        }
+        else {
+            if (Object.keys(this.callManager.getActiveCalls()).length) {
+                await this.checkCallStatus();
+            }
+            this.metricManager.submitConnectionMetrics(METRIC_EVENT.CONNECTION_ERROR, CONNECTION_ACTION.MERCURY_UP, METRIC_TYPE.BEHAVIORAL, this.mercuryDownTimestamp, this.mercuryUpTimestamp);
+        }
+    };
+    setupNetworkEventListeners() {
+        if (typeof window !== 'undefined' && window.addEventListener) {
+            window.addEventListener('online', this.handleNetworkOnline);
+            window.addEventListener('offline', this.handleNetworkOffline);
+        }
+        this.webex.internal.mercury.on('offline', () => {
+            this.handleMercuryOffline();
+        });
+        this.webex.internal.mercury.on('online', () => {
+            this.handleMercuryOnline();
+        });
     }
     async getClientRegionInfo() {
+        let abort;
         log.info(METHOD_START_MESSAGE, {
             file: CALLING_CLIENT_FILE,
             method: METHODS.GET_CLIENT_REGION_INFO,
         });
         const regionInfo = {};
         for (const mobius of this.mobiusClusters) {
-            this.mobiusHost = `https://${mobius.host}${API_V1}`;
+            if (mobius.host) {
+                this.mobiusHost = `https://${mobius.host}${API_V1}`;
+            }
+            else {
+                this.mobiusHost = mobius;
+            }
             try {
                 const temp = await this.webex.request({
                     uri: `${this.mobiusHost}${URL_ENDPOINT}${IP_ENDPOINT}`,
@@ -130,6 +254,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}`,
@@ -139,11 +267,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) {
@@ -152,12 +289,16 @@ export class CallingClient extends Eventing {
                     method: METHODS.GET_CLIENT_REGION_INFO,
                     file: CALLING_CLIENT_FILE,
                 });
-                handleCallingClientErrors(err, (clientError) => {
-                    this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION_ERROR, REG_ACTION.REGISTER, METRIC_TYPE.BEHAVIORAL, clientError);
+                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 });
                 regionInfo.clientRegion = '';
                 regionInfo.countryCode = '';
+                if (abort) {
+                    await uploadLogs();
+                    return regionInfo;
+                }
             }
         }
         return regionInfo;
@@ -189,9 +330,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: {
@@ -200,12 +344,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}`);
@@ -213,10 +364,13 @@ export class CallingClient extends Eventing {
                     method: METHODS.GET_MOBIUS_SERVERS,
                     file: CALLING_CLIENT_FILE,
                 });
-                handleCallingClientErrors(err, (clientError) => {
-                    this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION_ERROR, REG_ACTION.REGISTER, METRIC_TYPE.BEHAVIORAL, 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;
             }
         }
@@ -224,7 +378,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}`];
         }