@webex/calling 3.9.0-multipleLLM.2 → 3.9.0-next.10

package/dist/module/CallingClient/CallingClient.js

@@ -9,9 +9,9 @@ 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 {
@@ -27,6 +27,11 @@ export class CallingClient extends Eventing {
     mobiusHost;
     mediaEngine;
     lineDict = {};
+    isNetworkDown = false;
+    networkDownTimestamp = '';
+    networkUpTimestamp = '';
+    mercuryDownTimestamp = '';
+    mercuryUpTimestamp = '';
     constructor(webex, config) {
         super();
         this.sdkConnector = SDKConnector;
@@ -87,50 +92,143 @@ export class CallingClient extends Eventing {
         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.setupNetworkEventListeners();
+    }
+    async checkNetworkReachability() {
         try {
-            await windowsChromiumIceWarmup({
-                iceServers: [
-                    { urls: 'stun:stun01a-us.bcld.webex.com:5004' },
-                    { urls: 'stun:stun02a-us.bcld.webex.com:5004' },
-                ],
-                timeoutMs: 1000,
+            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,
             });
-            log.info(`ICE warmup completed`, '');
+            clearTimeout(timeoutId);
+            return true;
         }
-        catch (err) {
-            log.warn(`ICE warmup failed: ${err}`, '');
+        catch (error) {
+            log.warn(`Network connectivity probe failed: ${error}`, {
+                file: CALLING_CLIENT_FILE,
+                method: 'pingExternal',
+            });
+            return false;
         }
-        await this.getMobiusServers();
-        await this.createLine();
-        this.detectNetworkChange();
     }
-    async detectNetworkChange() {
+    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;
@@ -156,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}`,
@@ -165,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) {
@@ -185,6 +296,7 @@ export class CallingClient extends Eventing {
                 regionInfo.clientRegion = '';
                 regionInfo.countryCode = '';
                 if (abort) {
+                    await uploadLogs();
                     return regionInfo;
                 }
             }
@@ -218,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: {
@@ -229,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}`);
@@ -242,10 +364,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 +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}`];
         }