@webex/calling 3.8.0 → 3.8.1-next.10

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

@@ -1,13 +1,14 @@
 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 webWorkerStr from './webWorkerStr';
+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, } 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, 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 { LINE_EVENTS } from '../line/types';
 export class Registration {
     sdkConnector;
@@ -18,7 +19,6 @@ export class Registration {
     registrationStatus;
     failbackTimer;
     activeMobiusUrl;
-    keepaliveTimer;
     rehomingIntervalMin;
     rehomingIntervalMax;
     mutex;
@@ -33,6 +33,9 @@ export class Registration {
     jwe;
     isCCFlow = false;
     failoverImmediately = false;
+    retryAfter;
+    scheduled429Retry = false;
+    webWorker;
     constructor(webex, serviceData, mutex, lineEmitter, logLevel, jwe) {
         this.jwe = jwe;
         this.sdkConnector = SDKConnector;
@@ -59,25 +62,18 @@ 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 {
@@ -92,7 +88,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);
@@ -122,21 +121,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) {
@@ -149,7 +154,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
@@ -159,12 +164,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));
@@ -174,15 +185,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);
@@ -193,6 +208,7 @@ export class Registration {
             }
         }
         else {
+            await uploadLogs();
             emitFinalFailure((clientError) => {
                 this.lineEmitter(LINE_EVENTS.ERROR, undefined, clientError);
             }, loggerContext);
@@ -241,19 +257,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 {
@@ -298,9 +315,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,
                 });
@@ -345,7 +366,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();
             }
@@ -353,34 +374,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;
             }
@@ -393,8 +422,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,
@@ -406,69 +435,71 @@ 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;
     }
-    startKeepaliveTimer(url, interval) {
-        let keepAliveRetryCount = 0;
+    async startKeepaliveTimer(url, interval, serverType) {
         this.clearKeepaliveTimer();
         const RETRY_COUNT_THRESHOLD = this.isCCFlow ? 4 : 5;
-        this.keepaliveTimer = setInterval(async () => {
-            const logContext = {
-                file: REGISTRATION_FILE,
-                method: this.startKeepaliveTimer.name,
-            };
-            await this.mutex.runExclusive(async () => {
-                if (this.isDeviceRegistered() && keepAliveRetryCount < RETRY_COUNT_THRESHOLD) {
-                    try {
-                        const res = await this.postKeepAlive(url);
-                        log.info(`Sent Keepalive, status: ${res.statusCode}`, logContext);
-                        if (keepAliveRetryCount > 0) {
+        await this.mutex.runExclusive(async () => {
+            if (this.isDeviceRegistered()) {
+                const accessToken = await this.webex.credentials.getUserToken();
+                if (!this.webWorker) {
+                    const blob = new Blob([webWorkerStr], { type: 'application/javascript' });
+                    const blobUrl = URL.createObjectURL(blob);
+                    this.webWorker = new Worker(blobUrl);
+                    URL.revokeObjectURL(blobUrl);
+                    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.lineEmitter(LINE_EVENTS.RECONNECTED);
                         }
-                        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);
+                        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, 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;
+                                this.setStatus(RegistrationStatus.INACTIVE);
+                                this.clearKeepaliveTimer();
+                                this.clearFailbackTimer();
+                                this.lineEmitter(LINE_EVENTS.UNREGISTERED);
+                                if (!abort) {
+                                    await this.reconnectOnFailure(KEEPALIVE_UTIL);
+                                }
                             }
-                            this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION, REG_ACTION.KEEPALIVE_FAILURE, METRIC_TYPE.BEHAVIORAL, clientError);
-                        }, { method: this.startKeepaliveTimer.name, 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(this.startKeepaliveTimer.name);
+                            else {
+                                this.lineEmitter(LINE_EVENTS.RECONNECTING);
                             }
                         }
-                        else {
-                            this.lineEmitter(LINE_EVENTS.RECONNECTING);
-                        }
-                    }
+                    };
                 }
-            });
-        }, interval * 1000);
+            }
+        });
     }
     clearKeepaliveTimer() {
-        if (this.keepaliveTimer) {
-            clearInterval(this.keepaliveTimer);
-            this.keepaliveTimer = undefined;
+        if (this.webWorker) {
+            this.webWorker.postMessage({ type: WorkerMessageType.CLEAR_KEEPALIVE });
+            this.webWorker.terminate();
+            this.webWorker = undefined;
         }
     }
     isReconnectPending() {
@@ -477,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);
@@ -508,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) {
@@ -520,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,
                 });
             }
         }

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

@@ -0,0 +1,59 @@
+import { v4 as uuid } from 'uuid';
+import { HTTP_METHODS, WorkerMessageType } from '../../common/types';
+let keepaliveTimer;
+export const messageHandler = (event) => {
+    const { type } = event.data;
+    const postKeepAlive = async (accessToken, deviceUrl, url) => {
+        const response = await fetch(`${url}/status`, {
+            method: HTTP_METHODS.POST,
+            headers: {
+                'cisco-device-url': deviceUrl,
+                'spark-user-agent': 'webex-calling/beta',
+                Authorization: `${accessToken}`,
+                trackingId: `web_worker_${uuid()}`,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Keepalive failed with status: ${response.status}`);
+        }
+        return response;
+    };
+    if (type === WorkerMessageType.START_KEEPALIVE) {
+        let keepAliveRetryCount = 0;
+        const { accessToken, deviceUrl, interval, retryCountThreshold, url } = event.data;
+        if (keepaliveTimer) {
+            clearInterval(keepaliveTimer);
+            keepaliveTimer = undefined;
+        }
+        keepaliveTimer = setInterval(async () => {
+            if (keepAliveRetryCount < retryCountThreshold) {
+                try {
+                    const res = await postKeepAlive(accessToken, deviceUrl, url);
+                    const statusCode = res.status;
+                    if (keepAliveRetryCount > 0) {
+                        postMessage({
+                            type: WorkerMessageType.KEEPALIVE_SUCCESS,
+                            statusCode,
+                        });
+                    }
+                    keepAliveRetryCount = 0;
+                }
+                catch (err) {
+                    keepAliveRetryCount += 1;
+                    postMessage({
+                        type: WorkerMessageType.KEEPALIVE_FAILURE,
+                        err,
+                        keepAliveRetryCount,
+                    });
+                }
+            }
+        }, interval * 1000);
+    }
+    if (type === WorkerMessageType.CLEAR_KEEPALIVE) {
+        if (keepaliveTimer) {
+            clearInterval(keepaliveTimer);
+            keepaliveTimer = undefined;
+        }
+    }
+};
+self.addEventListener('message', messageHandler);

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

@@ -0,0 +1,93 @@
+const webWorkerStr = `/* eslint-env worker */
+
+const uuid = () => {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+    const r = (Math.random() * 16) | 0;
+    const v = c === 'x' ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+  });
+};
+
+// Enum values from the original imports
+const HTTP_METHODS = {
+  GET: 'GET',
+  POST: 'POST',
+  PUT: 'PUT',
+  DELETE: 'DELETE',
+  PATCH: 'PATCH',
+};
+
+const WorkerMessageType = {
+  START_KEEPALIVE: 'START_KEEPALIVE',
+  CLEAR_KEEPALIVE: 'CLEAR_KEEPALIVE',
+  KEEPALIVE_SUCCESS: 'KEEPALIVE_SUCCESS',
+  KEEPALIVE_FAILURE: 'KEEPALIVE_FAILURE',
+};
+
+let keepaliveTimer;
+
+const messageHandler = (event) => {
+  const {type} = event.data;
+
+  const postKeepAlive = async (accessToken, deviceUrl, url) => {
+    const response = await fetch(\`\${url}/status\`, {
+      method: HTTP_METHODS.POST,
+      headers: {
+        'cisco-device-url': deviceUrl,
+        'spark-user-agent': 'webex-calling/beta',
+        Authorization: \`\${accessToken}\`,
+        trackingId: \`web_worker_\${uuid()}\`,
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(\`Keepalive failed with status: \${response.status}\`);
+    }
+
+    return response;
+  };
+
+  if (type === WorkerMessageType.START_KEEPALIVE) {
+    let keepAliveRetryCount = 0;
+    const {accessToken, deviceUrl, interval, retryCountThreshold, url} = event.data;
+
+    if (keepaliveTimer) {
+      clearInterval(keepaliveTimer);
+      keepaliveTimer = undefined;
+    }
+
+    keepaliveTimer = setInterval(async () => {
+      if (keepAliveRetryCount < retryCountThreshold) {
+        try {
+          const res = await postKeepAlive(accessToken, deviceUrl, url);
+          const statusCode = res.status;
+          if (keepAliveRetryCount > 0) {
+            self.postMessage({
+              type: WorkerMessageType.KEEPALIVE_SUCCESS,
+              statusCode,
+            });
+          }
+          keepAliveRetryCount = 0;
+        } catch (err) {
+          keepAliveRetryCount += 1;
+          self.postMessage({
+            type: WorkerMessageType.KEEPALIVE_FAILURE,
+            err,
+            keepAliveRetryCount,
+          });
+        }
+      }
+    }, interval * 1000);
+  }
+
+  if (type === WorkerMessageType.CLEAR_KEEPALIVE) {
+    if (keepaliveTimer) {
+      clearInterval(keepaliveTimer);
+      keepaliveTimer = undefined;
+    }
+  }
+};
+
+self.addEventListener('message', messageHandler);
+`;
+export default webWorkerStr;