@webex/calling 3.8.0-web-workers-keepalive.2 → 3.8.1-next.1

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

@@ -1,13 +1,13 @@
 import { v4 as uuid } from 'uuid';
-import { ERROR_CODE } from '../../Errors/types';
-import { emitFinalFailure, handleRegistrationErrors } from '../../common';
-import { METRIC_EVENT, METRIC_TYPE, REG_ACTION } from '../../Metrics/types';
+import { METHOD_START_MESSAGE } from '../../common/constants';
+import { emitFinalFailure, handleRegistrationErrors, uploadLogs } from '../../common';
+import { METRIC_EVENT, METRIC_TYPE, REG_ACTION, } from '../../Metrics/types';
 import { getMetricManager } from '../../Metrics';
 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, FAILBACK_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, } from '../constants';
+import { ALLOWED_SERVICES, HTTP_METHODS, RegistrationStatus, ServiceIndicator, } 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 { LINE_EVENTS } from '../line/types';
 export class Registration {
     sdkConnector;
@@ -18,6 +18,7 @@ export class Registration {
     registrationStatus;
     failbackTimer;
     activeMobiusUrl;
+    keepaliveTimer;
     rehomingIntervalMin;
     rehomingIntervalMax;
     mutex;
@@ -32,7 +33,8 @@ export class Registration {
     jwe;
     isCCFlow = false;
     failoverImmediately = false;
-    webWorker;
+    retryAfter;
+    scheduled429Retry = false;
     constructor(webex, serviceData, mutex, lineEmitter, logLevel, jwe) {
         this.jwe = jwe;
         this.sdkConnector = SDKConnector;
@@ -59,14 +61,29 @@ export class Registration {
         return this.activeMobiusUrl;
     }
     setActiveMobiusUrl(url) {
-        log.info(`ActiveMobiusUrl: ${url}`, { method: 'setActiveMobiusUrl', file: REGISTRATION_FILE });
+        log.info(`${METHOD_START_MESSAGE} with ${url}`, {
+            method: METHODS.UPDATE_ACTIVE_MOBIUS,
+            file: REGISTRATION_FILE,
+        });
         this.activeMobiusUrl = url;
         this.callManager.updateActiveMobius(url);
     }
     setMobiusServers(primaryMobiusUris, backupMobiusUris) {
+        log.log(METHOD_START_MESSAGE, { method: METHODS.SET_MOBIUS_SERVERS, file: REGISTRATION_FILE });
         this.primaryMobiusUris = primaryMobiusUris;
         this.backupMobiusUris = backupMobiusUris;
     }
+    async postKeepAlive(url) {
+        return this.webex.request({
+            uri: `${url}/status`,
+            method: HTTP_METHODS.POST,
+            headers: {
+                [CISCO_DEVICE_URL]: this.webex.internal.device.url,
+                [SPARK_USER_AGENT]: CALLING_USER_AGENT,
+            },
+            service: ALLOWED_SERVICES.MOBIUS,
+        });
+    }
     async deleteRegistration(url, deviceId, deviceUrl) {
         let response;
         try {
@@ -81,7 +98,10 @@ export class Registration {
             });
         }
         catch (error) {
-            log.warn(`Delete failed with Mobius`, {});
+            log.warn(`Delete failed with Mobius ${error}`, {
+                file: REGISTRATION_FILE,
+                method: METHODS.DEREGISTER,
+            });
         }
         this.setStatus(RegistrationStatus.INACTIVE);
         this.lineEmitter(LINE_EVENTS.UNREGISTERED);
@@ -111,21 +131,27 @@ export class Registration {
         }
         return abort;
     }
-    async scheduleFailback429Retry() {
-        if (this.failback429RetryAttempts >= REG_FAILBACK_429_MAX_RETRIES) {
-            return;
+    async handle429Retry(retryAfter, caller) {
+        if (caller === FAILBACK_UTIL) {
+            if (this.failback429RetryAttempts >= REG_FAILBACK_429_MAX_RETRIES) {
+                return;
+            }
+            this.clearFailbackTimer();
+            this.failback429RetryAttempts += 1;
+            log.log(`Received 429 while rehoming, 429 retry count : ${this.failback429RetryAttempts}`, {
+                file: REGISTRATION_FILE,
+                method: REG_429_RETRY_UTIL,
+            });
+            const interval = this.getRegRetryInterval(this.failback429RetryAttempts);
+            this.startFailbackTimer(interval);
+            this.scheduled429Retry = true;
+            const abort = await this.restorePreviousRegistration(REG_429_RETRY_UTIL);
+            if (!abort && !this.isDeviceRegistered()) {
+                await this.restartRegistration(REG_429_RETRY_UTIL);
+            }
         }
-        this.clearFailbackTimer();
-        this.failback429RetryAttempts += 1;
-        log.log(`Received 429 while rehoming, 429 retry count : ${this.failback429RetryAttempts}`, {
-            file: REGISTRATION_FILE,
-            method: FAILBACK_429_RETRY_UTIL,
-        });
-        const interval = this.getRegRetryInterval(this.failback429RetryAttempts);
-        this.startFailbackTimer(interval);
-        const abort = await this.restorePreviousRegistration(FAILBACK_429_RETRY_UTIL);
-        if (!abort && !this.isDeviceRegistered()) {
-            await this.restartRegistration(FAILBACK_429_RETRY_UTIL);
+        else {
+            this.retryAfter = retryAfter;
         }
     }
     getRegRetryInterval(attempt = 1) {
@@ -138,7 +164,7 @@ export class Registration {
     async startFailoverTimer(attempt = 1, timeElapsed = 0) {
         const loggerContext = {
             file: REGISTRATION_FILE,
-            method: this.startFailoverTimer.name,
+            method: FAILOVER_UTIL,
         };
         let interval = this.getRegRetryInterval(attempt);
         const TIMER_THRESHOLD = this.isCCFlow
@@ -148,12 +174,18 @@ export class Registration {
             const excessVal = timeElapsed + interval - TIMER_THRESHOLD;
             interval -= excessVal;
         }
+        if (this.retryAfter != null && interval < this.retryAfter) {
+            this.failoverImmediately = this.retryAfter + timeElapsed > TIMER_THRESHOLD;
+        }
         let abort;
         if (interval > BASE_REG_RETRY_TIMER_VAL_IN_SEC && !this.failoverImmediately) {
             const scheduledTime = Math.floor(Date.now() / 1000);
+            if (this.retryAfter != null) {
+                interval = Math.max(interval, this.retryAfter);
+            }
             setTimeout(async () => {
                 await this.mutex.runExclusive(async () => {
-                    abort = await this.attemptRegistrationWithServers(this.startFailoverTimer.name);
+                    abort = await this.attemptRegistrationWithServers(FAILOVER_UTIL);
                     const currentTime = Math.floor(Date.now() / 1000);
                     if (!abort && !this.isDeviceRegistered()) {
                         await this.startFailoverTimer(attempt + 1, timeElapsed + (currentTime - scheduledTime));
@@ -163,15 +195,19 @@ export class Registration {
             log.log(`Scheduled retry with primary in ${interval} seconds, number of attempts : ${attempt}`, loggerContext);
         }
         else if (this.backupMobiusUris.length) {
-            log.log('Failing over to backup servers.', loggerContext);
+            log.info('Failing over to backup servers.', loggerContext);
             this.failoverImmediately = false;
-            abort = await this.attemptRegistrationWithServers(this.startFailoverTimer.name, this.backupMobiusUris);
+            abort = await this.attemptRegistrationWithServers(FAILOVER_UTIL, this.backupMobiusUris);
             if (!abort && !this.isDeviceRegistered()) {
                 interval = this.getRegRetryInterval();
+                if (this.retryAfter != null && this.retryAfter < RETRY_TIMER_UPPER_LIMIT) {
+                    interval = interval < this.retryAfter ? this.retryAfter : interval;
+                }
                 setTimeout(async () => {
                     await this.mutex.runExclusive(async () => {
-                        abort = await this.attemptRegistrationWithServers(this.startFailoverTimer.name, this.backupMobiusUris);
+                        abort = await this.attemptRegistrationWithServers(FAILOVER_UTIL, this.backupMobiusUris);
                         if (!abort && !this.isDeviceRegistered()) {
+                            await uploadLogs();
                             emitFinalFailure((clientError) => {
                                 this.lineEmitter(LINE_EVENTS.ERROR, undefined, clientError);
                             }, loggerContext);
@@ -182,6 +218,7 @@ export class Registration {
             }
         }
         else {
+            await uploadLogs();
             emitFinalFailure((clientError) => {
                 this.lineEmitter(LINE_EVENTS.ERROR, undefined, clientError);
             }, loggerContext);
@@ -230,19 +267,20 @@ export class Registration {
                     });
                     await this.deregister();
                     const abort = await this.attemptRegistrationWithServers(FAILBACK_UTIL);
-                    if (!abort && !this.isDeviceRegistered()) {
-                        const abortNew = await this.restorePreviousRegistration(FAILBACK_UTIL);
-                        if (abortNew) {
-                            this.clearFailbackTimer();
-                            return;
-                        }
-                        if (!this.isDeviceRegistered()) {
-                            await this.restartRegistration(this.executeFailback.name);
-                        }
-                        else {
-                            this.failbackTimer = undefined;
-                            this.initiateFailback();
-                        }
+                    if (this.scheduled429Retry || abort || this.isDeviceRegistered()) {
+                        return;
+                    }
+                    const abortNew = await this.restorePreviousRegistration(FAILBACK_UTIL);
+                    if (abortNew) {
+                        this.clearFailbackTimer();
+                        return;
+                    }
+                    if (!this.isDeviceRegistered()) {
+                        await this.restartRegistration(this.executeFailback.name);
+                    }
+                    else {
+                        this.failbackTimer = undefined;
+                        this.initiateFailback();
                     }
                 }
                 else {
@@ -287,9 +325,13 @@ export class Registration {
         }
     }
     async handleConnectionRestoration(retry) {
+        log.info(METHOD_START_MESSAGE, {
+            method: METHODS.HANDLE_CONNECTION_RESTORATION,
+            file: REGISTRATION_FILE,
+        });
         await this.mutex.runExclusive(async () => {
             if (retry) {
-                log.info('Mercury connection is up again, re-registering with Webex Calling if needed', {
+                log.log('Mercury connection is up again, re-registering with Webex Calling if needed', {
                     file: REGISTRATION_FILE,
                     method: this.handleConnectionRestoration.name,
                 });
@@ -334,7 +376,7 @@ export class Registration {
     }
     async triggerRegistration() {
         if (this.primaryMobiusUris.length > 0) {
-            const abort = await this.attemptRegistrationWithServers(this.triggerRegistration.name, this.primaryMobiusUris);
+            const abort = await this.attemptRegistrationWithServers(REGISTRATION_UTIL, this.primaryMobiusUris);
             if (!this.isDeviceRegistered() && !abort) {
                 await this.startFailoverTimer();
             }
@@ -342,34 +384,42 @@ export class Registration {
     }
     async attemptRegistrationWithServers(caller, servers = this.primaryMobiusUris) {
         let abort = false;
+        this.retryAfter = undefined;
         if (this.failoverImmediately) {
             return abort;
         }
         if (this.isDeviceRegistered()) {
-            log.log(`[${caller}] : Device already registered with : ${this.activeMobiusUrl}`, {
+            log.info(`[${caller}] : Device already registered with : ${this.activeMobiusUrl}`, {
                 file: REGISTRATION_FILE,
-                method: this.attemptRegistrationWithServers.name,
+                method: REGISTER_UTIL,
             });
             return abort;
         }
         for (const url of servers) {
+            const serverType = (this.primaryMobiusUris.includes(url) && 'PRIMARY') ||
+                (this.backupMobiusUris?.includes(url) && 'BACKUP') ||
+                'UNKNOWN';
             try {
                 abort = false;
                 this.registrationStatus = RegistrationStatus.INACTIVE;
                 this.lineEmitter(LINE_EVENTS.CONNECTING);
-                log.log(`[${caller}] : Mobius url to contact: ${url}`, {
+                log.info(`[${caller}] : Mobius url to contact: ${url}`, {
                     file: REGISTRATION_FILE,
-                    method: this.attemptRegistrationWithServers.name,
+                    method: REGISTER_UTIL,
                 });
                 const resp = await this.postRegistration(url);
                 this.deviceInfo = resp.body;
                 this.registrationStatus = RegistrationStatus.ACTIVE;
                 this.lineEmitter(LINE_EVENTS.REGISTERED, resp.body);
+                log.log(`Registration successful for deviceId: ${this.deviceInfo.device?.deviceId} userId: ${this.userId}`, {
+                    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, undefined);
-                this.startKeepaliveTimer(this.deviceInfo.device?.uri, this.deviceInfo.keepaliveInterval);
+                this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION, REG_ACTION.REGISTER, METRIC_TYPE.BEHAVIORAL, caller, serverType, resp.headers?.trackingid ?? '', undefined, undefined);
+                this.startKeepaliveTimer(this.deviceInfo.device?.uri, this.deviceInfo.keepaliveInterval, serverType);
                 this.initiateFailback();
                 break;
             }
@@ -382,8 +432,8 @@ export class Registration {
                     else {
                         this.lineEmitter(LINE_EVENTS.UNREGISTERED);
                     }
-                    this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION_ERROR, REG_ACTION.REGISTER, METRIC_TYPE.BEHAVIORAL, clientError);
-                }, { method: this.attemptRegistrationWithServers.name, file: REGISTRATION_FILE }, this.restoreRegistrationCallBack());
+                    this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION_ERROR, REG_ACTION.REGISTER, METRIC_TYPE.BEHAVIORAL, caller, serverType, body.headers?.trackingid ?? '', undefined, clientError);
+                }, { method: caller, file: REGISTRATION_FILE }, (retryAfter, retryCaller) => this.handle429Retry(retryAfter, retryCaller), this.restoreRegistrationCallBack());
                 if (this.registrationStatus === RegistrationStatus.ACTIVE) {
                     log.info(`[${caller}] : Device is already restored, active mobius url: ${this.activeMobiusUrl}`, {
                         file: REGISTRATION_FILE,
@@ -395,76 +445,61 @@ export class Registration {
                     this.setStatus(RegistrationStatus.INACTIVE);
                     break;
                 }
-                else if (caller === this.executeFailback.name) {
-                    const error = body.statusCode;
-                    if (error === ERROR_CODE.TOO_MANY_REQUESTS) {
-                        await this.scheduleFailback429Retry();
-                        abort = true;
-                        break;
-                    }
-                }
             }
         }
         return abort;
     }
-    async startKeepaliveTimer(url, interval) {
+    startKeepaliveTimer(url, interval, serverType) {
+        let keepAliveRetryCount = 0;
         this.clearKeepaliveTimer();
         const RETRY_COUNT_THRESHOLD = this.isCCFlow ? 4 : 5;
-        await this.mutex.runExclusive(async () => {
-            if (this.isDeviceRegistered()) {
-                const accessToken = await this.webex.credentials.getUserToken();
-                if (!this.webWorker) {
-                    this.webWorker = new Worker(new URL('./webWorker.js', import.meta.url));
-                    this.webWorker.postMessage({
-                        type: WorkerMessageType.START_KEEPALIVE,
-                        accessToken: String(accessToken),
-                        deviceUrl: String(this.webex.internal.device.url),
-                        interval,
-                        retryCountThreshold: RETRY_COUNT_THRESHOLD,
-                        url,
-                    });
-                    this.webWorker.onmessage = async (event) => {
-                        const logContext = {
-                            file: REGISTRATION_FILE,
-                            method: this.startKeepaliveTimer.name,
-                        };
-                        if (event.data.type === WorkerMessageType.KEEPALIVE_SUCCESS) {
-                            log.info(`Sent Keepalive, status: ${event.data.statusCode}`, logContext);
+        this.keepaliveTimer = setInterval(async () => {
+            const logContext = {
+                file: REGISTRATION_FILE,
+                method: KEEPALIVE_UTIL,
+            };
+            await this.mutex.runExclusive(async () => {
+                if (this.isDeviceRegistered() && keepAliveRetryCount < RETRY_COUNT_THRESHOLD) {
+                    try {
+                        const res = await this.postKeepAlive(url);
+                        log.log(`Sent Keepalive, status: ${res.statusCode}`, logContext);
+                        if (keepAliveRetryCount > 0) {
                             this.lineEmitter(LINE_EVENTS.RECONNECTED);
                         }
-                        if (event.data.type === WorkerMessageType.KEEPALIVE_FAILURE) {
-                            const error = event.data.err;
-                            log.warn(`Keep-alive missed ${event.data.keepAliveRetryCount} times. Status -> ${error.statusCode} `, logContext);
-                            const abort = await handleRegistrationErrors(error, (clientError, finalError) => {
-                                if (finalError) {
-                                    this.lineEmitter(LINE_EVENTS.ERROR, undefined, clientError);
-                                }
-                                this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION, REG_ACTION.KEEPALIVE_FAILURE, METRIC_TYPE.BEHAVIORAL, clientError);
-                            }, { method: this.startKeepaliveTimer.name, file: REGISTRATION_FILE });
-                            if (abort || event.data.keepAliveRetryCount >= RETRY_COUNT_THRESHOLD) {
-                                this.failoverImmediately = this.isCCFlow;
-                                this.setStatus(RegistrationStatus.INACTIVE);
-                                this.clearKeepaliveTimer();
-                                this.clearFailbackTimer();
-                                this.lineEmitter(LINE_EVENTS.UNREGISTERED);
-                                if (!abort) {
-                                    await this.reconnectOnFailure(this.startKeepaliveTimer.name);
-                                }
+                        keepAliveRetryCount = 0;
+                    }
+                    catch (err) {
+                        keepAliveRetryCount += 1;
+                        const error = err;
+                        log.warn(`Keep-alive missed ${keepAliveRetryCount} times. Status -> ${error.statusCode} `, logContext);
+                        const abort = await handleRegistrationErrors(error, (clientError, finalError) => {
+                            if (finalError) {
+                                this.lineEmitter(LINE_EVENTS.ERROR, undefined, clientError);
                             }
-                            else {
-                                this.lineEmitter(LINE_EVENTS.RECONNECTING);
+                            this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION, REG_ACTION.KEEPALIVE_FAILURE, METRIC_TYPE.BEHAVIORAL, KEEPALIVE_UTIL, serverType, error.headers?.trackingid ?? '', keepAliveRetryCount, clientError);
+                        }, { method: KEEPALIVE_UTIL, file: REGISTRATION_FILE });
+                        if (abort || keepAliveRetryCount >= RETRY_COUNT_THRESHOLD) {
+                            this.failoverImmediately = this.isCCFlow;
+                            this.setStatus(RegistrationStatus.INACTIVE);
+                            this.clearKeepaliveTimer();
+                            this.clearFailbackTimer();
+                            this.lineEmitter(LINE_EVENTS.UNREGISTERED);
+                            if (!abort) {
+                                await this.reconnectOnFailure(KEEPALIVE_UTIL);
                             }
                         }
-                    };
+                        else {
+                            this.lineEmitter(LINE_EVENTS.RECONNECTING);
+                        }
+                    }
                 }
-            }
-        });
+            });
+        }, interval * 1000);
     }
     clearKeepaliveTimer() {
-        if (this.webWorker) {
-            this.webWorker.postMessage({ type: WorkerMessageType.CLEAR_KEEPALIVE });
-            this.webWorker.terminate();
-            this.webWorker = undefined;
+        if (this.keepaliveTimer) {
+            clearInterval(this.keepaliveTimer);
+            this.keepaliveTimer = undefined;
         }
     }
     isReconnectPending() {
@@ -473,9 +508,16 @@ export class Registration {
     async deregister() {
         try {
             await this.deleteRegistration(this.activeMobiusUrl, this.deviceInfo.device?.deviceId, this.deviceInfo.device?.clientDeviceUri);
+            log.log('Registration successfully deregistered', {
+                file: REGISTRATION_FILE,
+                method: METHODS.DEREGISTER,
+            });
         }
         catch (err) {
-            log.warn(`Delete failed with Mobius`, {});
+            log.warn(`Delete failed with Mobius: ${err}`, {
+                file: REGISTRATION_FILE,
+                method: METHODS.DEREGISTER,
+            });
         }
         this.clearKeepaliveTimer();
         this.setStatus(RegistrationStatus.INACTIVE);
@@ -504,6 +546,7 @@ export class Registration {
         return false;
     }
     async reconnectOnFailure(caller) {
+        log.info(METHOD_START_MESSAGE, { method: METHODS.RECONNECT_ON_FAILURE, file: REGISTRATION_FILE });
         this.reconnectPending = false;
         if (!this.isDeviceRegistered()) {
             if (Object.keys(this.callManager.getActiveCalls()).length === 0) {
@@ -516,7 +559,7 @@ export class Registration {
                 this.reconnectPending = true;
                 log.info('Active call(s) present, deferred reconnect till call cleanup.', {
                     file: REGISTRATION_FILE,
-                    method: this.reconnectOnFailure.name,
+                    method: METHODS.RECONNECT_ON_FAILURE,
                 });
             }
         }