@webex/calling 3.8.0 → 3.8.1-next.2

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, } 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 { 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;
@@ -33,6 +33,8 @@ export class Registration {
     jwe;
     isCCFlow = false;
     failoverImmediately = false;
+    retryAfter;
+    scheduled429Retry = false;
     constructor(webex, serviceData, mutex, lineEmitter, logLevel, jwe) {
         this.jwe = jwe;
         this.sdkConnector = SDKConnector;
@@ -59,11 +61,15 @@ 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;
     }
@@ -92,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);
@@ -122,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) {
@@ -149,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
@@ -159,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));
@@ -174,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);
@@ -193,6 +218,7 @@ export class Registration {
             }
         }
         else {
+            await uploadLogs();
             emitFinalFailure((clientError) => {
                 this.lineEmitter(LINE_EVENTS.ERROR, undefined, clientError);
             }, loggerContext);
@@ -241,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 {
@@ -298,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,
                 });
@@ -345,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();
             }
@@ -353,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;
             }
@@ -393,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,
@@ -406,32 +445,24 @@ 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) {
+    startKeepaliveTimer(url, interval, serverType) {
         let keepAliveRetryCount = 0;
         this.clearKeepaliveTimer();
         const RETRY_COUNT_THRESHOLD = this.isCCFlow ? 4 : 5;
         this.keepaliveTimer = setInterval(async () => {
             const logContext = {
                 file: REGISTRATION_FILE,
-                method: this.startKeepaliveTimer.name,
+                method: KEEPALIVE_UTIL,
             };
             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);
+                        log.log(`Sent Keepalive, status: ${res.statusCode}`, logContext);
                         if (keepAliveRetryCount > 0) {
                             this.lineEmitter(LINE_EVENTS.RECONNECTED);
                         }
@@ -445,8 +476,8 @@ export class Registration {
                             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 });
+                            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);
@@ -454,7 +485,7 @@ export class Registration {
                             this.clearFailbackTimer();
                             this.lineEmitter(LINE_EVENTS.UNREGISTERED);
                             if (!abort) {
-                                await this.reconnectOnFailure(this.startKeepaliveTimer.name);
+                                await this.reconnectOnFailure(KEEPALIVE_UTIL);
                             }
                         }
                         else {
@@ -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/Contacts/ContactsClient.js

@@ -1,10 +1,10 @@
-import { FAILURE_MESSAGE, SCIM_ENTERPRISE_USER, SCIM_WEBEXIDENTITY_USER, STATUS_CODE, SUCCESS_MESSAGE, } from '../common/constants';
+import { FAILURE_MESSAGE, METHOD_START_MESSAGE, SCIM_ENTERPRISE_USER, SCIM_WEBEXIDENTITY_USER, STATUS_CODE, SUCCESS_MESSAGE, } from '../common/constants';
 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, OR, SCIM_ID_FILTER, USERS, encryptedFields, } from './constants';
+import { CONTACTS_FILE, 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 } from '../common/Utils';
+import { scimQuery, serviceErrorCodeHandler, uploadLogs } from '../common/Utils';
 export class ContactsClient {
     sdkConnector;
     encryptionKeyUrl;
@@ -188,8 +188,9 @@ export class ContactsClient {
     async getContacts() {
         const loggerContext = {
             file: CONTACTS_FILE,
-            method: 'getContacts',
+            method: METHODS.GET_CONTACTS,
         };
+        log.info(METHOD_START_MESSAGE, loggerContext);
         const contactList = [];
         const cloudContactsMap = {};
         try {
@@ -244,19 +245,24 @@ export class ContactsClient {
                 },
                 message: SUCCESS_MESSAGE,
             };
+            log.log('Successfully fetched contacts and groups', loggerContext);
             return contactResponse;
         }
         catch (err) {
             const errorInfo = err;
+            const extendedError = new Error(`Error fetching contacts: ${err}`);
+            log.error(extendedError, loggerContext);
             const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
+            await uploadLogs();
             return errorStatus;
         }
     }
     async createNewEncryptionKeyUrl() {
         const loggerContext = {
             file: CONTACTS_FILE,
-            method: this.createNewEncryptionKeyUrl.name,
+            method: METHODS.CREATE_NEW_ENCRYPTION_KEY_URL,
         };
+        log.info(METHOD_START_MESSAGE, loggerContext);
         let unboundedKeyUri = '';
         log.info('Requesting kms for a new KRO and key', loggerContext);
         const unboundedKeys = await this.webex.internal.encryption.kms.createUnboundKeys({ count: 1 });
@@ -265,6 +271,11 @@ export class ContactsClient {
         return unboundedKeyUri;
     }
     async fetchEncryptionKeyUrl() {
+        const loggerContext = {
+            file: CONTACTS_FILE,
+            method: METHODS.FETCH_ENCRYPTION_KEY_URL,
+        };
+        log.info(METHOD_START_MESSAGE, loggerContext);
         if (this.encryptionKeyUrl) {
             return this.encryptionKeyUrl;
         }
@@ -275,45 +286,67 @@ export class ContactsClient {
             return this.groups[0].encryptionKeyUrl;
         }
         this.encryptionKeyUrl = await this.createNewEncryptionKeyUrl();
-        log.info(`Creating a default group: ${DEFAULT_GROUP_NAME}`, {
+        log.log(`Creating a default group: ${DEFAULT_GROUP_NAME}`, {
             file: CONTACTS_FILE,
             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,
+                method: this.fetchEncryptionKeyUrl.name,
+            });
         }
         return this.encryptionKeyUrl;
     }
     async fetchDefaultGroup() {
+        const loggerContext = {
+            file: CONTACTS_FILE,
+            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,
+                method: this.fetchDefaultGroup.name,
+            });
             return this.defaultGroupId;
         }
         if (this.groups && this.groups.length) {
             for (let i = 0; i < this.groups.length; i += 1) {
                 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,
+                        method: this.fetchDefaultGroup.name,
+                    });
                     return this.defaultGroupId;
                 }
             }
         }
-        log.info('No default group found.', {
+        log.log('No default group found.', {
             file: CONTACTS_FILE,
             method: this.fetchDefaultGroup.name,
         });
         const response = await this.createContactGroup(DEFAULT_GROUP_NAME);
         const { group } = response.data;
         if (group) {
-            return group.groupId;
+            const groupId = group.groupId;
+            log.log(`Successfully created new default group with ID: ${groupId}`, {
+                file: CONTACTS_FILE,
+                method: this.fetchDefaultGroup.name,
+            });
+            return groupId;
         }
         return '';
     }
     async createContactGroup(displayName, encryptionKeyUrl, groupType) {
         const loggerContext = {
             file: CONTACTS_FILE,
-            method: this.createContactGroup.name,
+            method: METHODS.CREATE_CONTACT_GROUP,
         };
-        log.info(`Creating contact group ${displayName}`, loggerContext);
+        log.info(`${METHOD_START_MESSAGE} with displayName: ${displayName}`, loggerContext);
         const encryptionKeyUrlFinal = encryptionKeyUrl || (await this.fetchEncryptionKeyUrl());
         if (this.groups === undefined) {
             await this.getContacts();
@@ -354,20 +387,24 @@ export class ContactsClient {
                 message: SUCCESS_MESSAGE,
             };
             this.groups?.push(group);
+            log.log(`Contact group ${displayName} successfully created`, loggerContext);
             return contactResponse;
         }
         catch (err) {
-            log.warn('Unable to create contact group.', loggerContext);
             const errorInfo = err;
+            const extendedError = new Error(`Unable to create contact group: ${err}`);
+            log.error(extendedError, loggerContext);
             const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
+            await uploadLogs();
             return errorStatus;
         }
     }
     async deleteContactGroup(groupId) {
         const loggerContext = {
             file: CONTACTS_FILE,
-            method: this.deleteContactGroup.name,
+            method: METHODS.DELETE_CONTACT_GROUP,
         };
+        log.info(`${METHOD_START_MESSAGE} with groupId: ${groupId}`, loggerContext);
         try {
             log.info(`Deleting contact group: ${groupId}`, loggerContext);
             const response = await this.webex.request({
@@ -386,21 +423,24 @@ export class ContactsClient {
             if (!this.groups?.length) {
                 this.defaultGroupId = '';
             }
+            log.log(`Contact group ${groupId} successfully deleted`, loggerContext);
             return contactResponse;
         }
         catch (err) {
-            log.warn(`Unable to delete contact group ${groupId}`, loggerContext);
             const errorInfo = err;
+            const extendedError = new Error(`Unable to delete contact group ${groupId}: ${err}`);
+            log.error(extendedError, loggerContext);
             const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
+            await uploadLogs();
             return errorStatus;
         }
     }
     async createContact(contactInfo) {
         const loggerContext = {
             file: CONTACTS_FILE,
-            method: this.createContact.name,
+            method: METHODS.CREATE_CONTACT,
         };
-        log.info(`Request to create contact: contactType: ${contactInfo.contactType}`, loggerContext);
+        log.info(`${METHOD_START_MESSAGE} with contactType: ${contactInfo.contactType}`, loggerContext);
         try {
             const contact = { ...contactInfo };
             if (!contact.encryptionKeyUrl) {
@@ -467,23 +507,24 @@ export class ContactsClient {
             else {
                 this.contacts?.push(contact);
             }
+            log.log(`Contact successfully created`, loggerContext);
             return contactResponse;
         }
         catch (err) {
-            log.warn('Failed to create contact.', {
-                file: CONTACTS_FILE,
-                method: this.createContact.name,
-            });
             const errorInfo = err;
+            const extendedError = new Error(`Failed to create contact: ${err}`);
+            log.error(extendedError, loggerContext);
             const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
+            await uploadLogs();
             return errorStatus;
         }
     }
     async deleteContact(contactId) {
         const loggerContext = {
             file: CONTACTS_FILE,
-            method: this.deleteContact.name,
+            method: METHODS.DELETE_CONTACT,
         };
+        log.info(`${METHOD_START_MESSAGE} with contactId: ${contactId}`, loggerContext);
         try {
             log.info(`Deleting contact : ${contactId}`, loggerContext);
             const response = await this.webex.request({
@@ -499,12 +540,15 @@ export class ContactsClient {
             if (contactToDelete !== undefined && contactToDelete !== -1) {
                 this.contacts?.splice(contactToDelete, 1);
             }
+            log.log(`Contact ${contactId} successfully deleted`, loggerContext);
             return contactResponse;
         }
         catch (err) {
-            log.warn(`Unable to delete contact ${contactId}`, loggerContext);
             const errorInfo = err;
+            const extendedError = new Error(`Unable to delete contact ${contactId}: ${err}`);
+            log.error(extendedError, loggerContext);
             const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
+            await uploadLogs();
             return errorStatus;
         }
     }

package/dist/module/Contacts/constants.js

@@ -20,3 +20,13 @@ export var encryptedFields;
     encryptedFields["SIP_ADDRESSES"] = "sipAddresses";
     encryptedFields["TITLE"] = "title";
 })(encryptedFields || (encryptedFields = {}));
+export const METHODS = {
+    GET_CONTACTS: 'getContacts',
+    CREATE_NEW_ENCRYPTION_KEY_URL: 'createNewEncryptionKeyUrl',
+    FETCH_ENCRYPTION_KEY_URL: 'fetchEncryptionKeyUrl',
+    FETCH_DEFAULT_GROUP: 'fetchDefaultGroup',
+    CREATE_CONTACT_GROUP: 'createContactGroup',
+    DELETE_CONTACT_GROUP: 'deleteContactGroup',
+    CREATE_CONTACT: 'createContact',
+    DELETE_CONTACT: 'deleteContact',
+};

package/dist/module/Errors/types.js

@@ -7,12 +7,14 @@ export var ERROR_TYPE;
 (function (ERROR_TYPE) {
     ERROR_TYPE["CALL_ERROR"] = "call_error";
     ERROR_TYPE["DEFAULT"] = "default_error";
+    ERROR_TYPE["BAD_REQUEST"] = "bad_request";
     ERROR_TYPE["FORBIDDEN_ERROR"] = "forbidden";
     ERROR_TYPE["NOT_FOUND"] = "not_found";
     ERROR_TYPE["REGISTRATION_ERROR"] = "registration_error";
     ERROR_TYPE["SERVICE_UNAVAILABLE"] = "service_unavailable";
     ERROR_TYPE["TIMEOUT"] = "timeout";
     ERROR_TYPE["TOKEN_ERROR"] = "token_error";
+    ERROR_TYPE["TOO_MANY_REQUESTS"] = "too_many_requests";
     ERROR_TYPE["SERVER_ERROR"] = "server_error";
 })(ERROR_TYPE || (ERROR_TYPE = {}));
 export var ERROR_CODE;

package/dist/module/Events/impl/index.js

@@ -4,7 +4,7 @@ import { LOG_PREFIX } from '../../Logger/types';
 export class Eventing extends EventEmitter {
     emit(event, ...args) {
         const timestamp = new Date().toUTCString();
-        Logger.log(`${timestamp} ${LOG_PREFIX.EVENT}: ${event.toString()} - event emitted with parameters -> ${args} = `, {
+        Logger.info(`${timestamp} ${LOG_PREFIX.EVENT}: ${event.toString()} - event emitted with parameters -> ${args} = `, {
             file: 'Events/impl/index.ts',
             method: 'emit',
         });