@webex/calling 3.8.0 → 3.8.1-next.2

package/dist/module/CallSettings/CallSettings.js

@@ -1,9 +1,10 @@
+import { METHOD_START_MESSAGE } from '../common/constants';
 import { getCallingBackEnd } from '../common/Utils';
 import SDKConnector from '../SDKConnector';
 import log from '../Logger';
 import { CALLING_BACKEND } from '../common/types';
 import { WxCallBackendConnector } from './WxCallBackendConnector';
-import { CALL_SETTINGS_FILE } from './constants';
+import { CALL_SETTINGS_FILE, METHODS } from './constants';
 import { UcmBackendConnector } from './UcmBackendConnector';
 export class CallSettings {
     sdkConnector;
@@ -21,9 +22,9 @@ export class CallSettings {
     }
     initializeBackendConnector(logger, useProdWebexApis) {
         this.callingBackend = getCallingBackEnd(this.webex);
-        log.info(`Initializing Connector for ${this.callingBackend} backend`, {
+        log.info(`${METHOD_START_MESSAGE} with ${this.callingBackend} backend`, {
             file: CALL_SETTINGS_FILE,
-            method: this.initializeBackendConnector.name,
+            method: METHODS.INITIALIZE_BACKEND_CONNECTOR,
         });
         switch (this.callingBackend) {
             case CALLING_BACKEND.BWRKS:
@@ -38,27 +39,59 @@ export class CallSettings {
         }
     }
     async getCallWaitingSetting() {
+        log.info(METHOD_START_MESSAGE, {
+            file: CALL_SETTINGS_FILE,
+            method: METHODS.GET_CALL_WAITING_SETTING,
+        });
         return this.backendConnector.getCallWaitingSetting();
     }
     async getDoNotDisturbSetting() {
+        log.info(METHOD_START_MESSAGE, {
+            file: CALL_SETTINGS_FILE,
+            method: METHODS.GET_DO_NOT_DISTURB_SETTING,
+        });
         return this.backendConnector.getDoNotDisturbSetting();
     }
     async setDoNotDisturbSetting(enabled) {
+        log.info(METHOD_START_MESSAGE, {
+            file: CALL_SETTINGS_FILE,
+            method: METHODS.SET_DO_NOT_DISTURB_SETTING,
+        });
         return this.backendConnector.setDoNotDisturbSetting(enabled);
     }
     async getCallForwardSetting() {
+        log.info(METHOD_START_MESSAGE, {
+            file: CALL_SETTINGS_FILE,
+            method: METHODS.GET_CALL_FORWARD_SETTING,
+        });
         return this.backendConnector.getCallForwardSetting();
     }
     async setCallForwardSetting(callForwardingRequest) {
+        log.info(METHOD_START_MESSAGE, {
+            file: CALL_SETTINGS_FILE,
+            method: METHODS.SET_CALL_FORWARD_SETTING,
+        });
         return this.backendConnector.setCallForwardSetting(callForwardingRequest);
     }
     async getVoicemailSetting() {
+        log.info(METHOD_START_MESSAGE, {
+            file: CALL_SETTINGS_FILE,
+            method: METHODS.GET_VOICEMAIL_SETTING,
+        });
         return this.backendConnector.getVoicemailSetting();
     }
     async setVoicemailSetting(voicemailRequest) {
+        log.info(METHOD_START_MESSAGE, {
+            file: CALL_SETTINGS_FILE,
+            method: METHODS.SET_VOICEMAIL_SETTING,
+        });
         return this.backendConnector.setVoicemailSetting(voicemailRequest);
     }
     async getCallForwardAlwaysSetting(directoryNumber) {
+        log.info(METHOD_START_MESSAGE, {
+            file: CALL_SETTINGS_FILE,
+            method: METHODS.GET_CALL_FORWARD_ALWAYS_SETTING,
+        });
         return this.backendConnector.getCallForwardAlwaysSetting(directoryNumber);
     }
 }

package/dist/module/CallSettings/UcmBackendConnector.js

@@ -1,9 +1,9 @@
 import log from '../Logger';
 import SDKConnector from '../SDKConnector';
-import { serviceErrorCodeHandler } from '../common/Utils';
-import { FAILURE_MESSAGE, STATUS_CODE, SUCCESS_MESSAGE, UCM_CONNECTOR_FILE, VOICEMAIL, WEBEX_API_CONFIG_INT_URL, WEBEX_API_CONFIG_PROD_URL, } from '../common/constants';
+import { serviceErrorCodeHandler, uploadLogs } from '../common/Utils';
+import { FAILURE_MESSAGE, METHOD_START_MESSAGE, STATUS_CODE, SUCCESS_MESSAGE, UCM_CONNECTOR_FILE, VOICEMAIL, WEBEX_API_CONFIG_INT_URL, WEBEX_API_CONFIG_PROD_URL, } from '../common/constants';
 import { HTTP_METHODS } from '../common/types';
-import { CF_ENDPOINT, ORG_ENDPOINT, PEOPLE_ENDPOINT } from './constants';
+import { CF_ENDPOINT, METHODS, ORG_ENDPOINT, PEOPLE_ENDPOINT } from './constants';
 export class UcmBackendConnector {
     sdkConnector;
     webex;
@@ -22,35 +22,76 @@ export class UcmBackendConnector {
         this.useProdWebexApis = useProdWebexApis;
     }
     getCallWaitingSetting() {
+        const loggerContext = {
+            file: UCM_CONNECTOR_FILE,
+            method: METHODS.GET_CALL_WAITING_SETTING,
+        };
+        log.info(METHOD_START_MESSAGE, loggerContext);
         return this.getMethodNotSupportedResponse();
     }
     getDoNotDisturbSetting() {
+        const loggerContext = {
+            file: UCM_CONNECTOR_FILE,
+            method: METHODS.GET_DO_NOT_DISTURB_SETTING,
+        };
+        log.info(METHOD_START_MESSAGE, loggerContext);
         return this.getMethodNotSupportedResponse();
     }
     setDoNotDisturbSetting() {
+        const loggerContext = {
+            file: UCM_CONNECTOR_FILE,
+            method: METHODS.SET_DO_NOT_DISTURB_SETTING,
+        };
+        log.info(METHOD_START_MESSAGE, loggerContext);
         return this.getMethodNotSupportedResponse();
     }
     getCallForwardSetting() {
+        const loggerContext = {
+            file: UCM_CONNECTOR_FILE,
+            method: METHODS.GET_CALL_FORWARD_SETTING,
+        };
+        log.info(METHOD_START_MESSAGE, loggerContext);
         return this.getMethodNotSupportedResponse();
     }
     setCallForwardSetting() {
+        const loggerContext = {
+            file: UCM_CONNECTOR_FILE,
+            method: METHODS.SET_CALL_FORWARD_SETTING,
+        };
+        log.info(METHOD_START_MESSAGE, loggerContext);
         return this.getMethodNotSupportedResponse();
     }
     getVoicemailSetting() {
+        const loggerContext = {
+            file: UCM_CONNECTOR_FILE,
+            method: METHODS.GET_VOICEMAIL_SETTING,
+        };
+        log.info(METHOD_START_MESSAGE, loggerContext);
         return this.getMethodNotSupportedResponse();
     }
     setVoicemailSetting() {
+        const loggerContext = {
+            file: UCM_CONNECTOR_FILE,
+            method: METHODS.SET_VOICEMAIL_SETTING,
+        };
+        log.info(METHOD_START_MESSAGE, loggerContext);
         return this.getMethodNotSupportedResponse();
     }
     getMethodNotSupportedResponse() {
-        const response = serviceErrorCodeHandler({ statusCode: 501 }, { file: UCM_CONNECTOR_FILE, method: this.getMethodNotSupportedResponse.name });
+        const loggerContext = {
+            file: UCM_CONNECTOR_FILE,
+            method: METHODS.GET_METHOD_NOT_SUPPORTED_RESPONSE,
+        };
+        log.info(METHOD_START_MESSAGE, loggerContext);
+        const response = serviceErrorCodeHandler({ statusCode: 501 }, loggerContext);
         return Promise.resolve(response);
     }
     async getCallForwardAlwaysSetting(directoryNumber) {
         const loggerContext = {
             file: UCM_CONNECTOR_FILE,
-            method: this.getCallForwardAlwaysSetting.name,
+            method: METHODS.GET_CALL_FORWARD_ALWAYS_SETTING,
         };
+        log.info(directoryNumber ? `${METHOD_START_MESSAGE} with ${directoryNumber}` : METHOD_START_MESSAGE, loggerContext);
         const webexApisUrl = this.useProdWebexApis
             ? WEBEX_API_CONFIG_PROD_URL
             : WEBEX_API_CONFIG_INT_URL;
@@ -73,6 +114,7 @@ export class UcmBackendConnector {
                             },
                         },
                     };
+                    log.log(`Successfully retrieved call forward always setting for directory number: ${directoryNumber}`, loggerContext);
                     return response;
                 }
                 const response = {
@@ -95,6 +137,9 @@ export class UcmBackendConnector {
         }
         catch (err) {
             const errorInfo = err;
+            const extendedError = new Error(`Failed to get call forward always setting: ${err}`);
+            log.error(extendedError, loggerContext);
+            await uploadLogs();
             const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
             return errorStatus;
         }

package/dist/module/CallSettings/WxCallBackendConnector.js

@@ -1,9 +1,9 @@
 import SDKConnector from '../SDKConnector';
 import log from '../Logger';
 import { HTTP_METHODS, DecodeType, CALLING_BACKEND } from '../common/types';
-import { SERVICES_ENDPOINT, STATUS_CODE, SUCCESS_MESSAGE, XML_TYPE, WEBEX_CALLING_CONNECTOR_FILE, } from '../common/constants';
-import { CALL_SETTINGS_FILE, CALL_WAITING_ENDPOINT, CF_ENDPOINT, DND_ENDPOINT, ORG_ENDPOINT, PEOPLE_ENDPOINT, USER_ENDPOINT, VM_ENDPOINT, XSI_VERSION, } from './constants';
-import { getXsiActionEndpoint, inferIdFromUuid, serviceErrorCodeHandler } from '../common/Utils';
+import { SERVICES_ENDPOINT, STATUS_CODE, SUCCESS_MESSAGE, XML_TYPE, WEBEX_CALLING_CONNECTOR_FILE, METHOD_START_MESSAGE, } from '../common/constants';
+import { CALL_WAITING_ENDPOINT, CF_ENDPOINT, DND_ENDPOINT, METHODS, ORG_ENDPOINT, PEOPLE_ENDPOINT, USER_ENDPOINT, VM_ENDPOINT, XSI_VERSION, } from './constants';
+import { getXsiActionEndpoint, inferIdFromUuid, serviceErrorCodeHandler, uploadLogs, } from '../common/Utils';
 export class WxCallBackendConnector {
     sdkConnector;
     webex;
@@ -27,9 +27,10 @@ export class WxCallBackendConnector {
     }
     async getCallWaitingSetting() {
         const loggerContext = {
-            file: CALL_SETTINGS_FILE,
-            method: 'getCallWaitingSetting',
+            file: WEBEX_CALLING_CONNECTOR_FILE,
+            method: METHODS.GET_CALL_WAITING_SETTING,
         };
+        log.info(METHOD_START_MESSAGE, loggerContext);
         try {
             if (!this.xsiEndpoint) {
                 this.xsiEndpoint = await getXsiActionEndpoint(this.webex, loggerContext, CALLING_BACKEND.WXC);
@@ -60,9 +61,13 @@ export class WxCallBackendConnector {
                 },
                 message: SUCCESS_MESSAGE,
             };
+            log.log(`Successfully got Call Waiting settings, personId: ${this.personId}`, loggerContext);
             return responseDetails;
         }
         catch (err) {
+            const extendedError = new Error(`Failed to get call waiting setting: ${err}`);
+            log.error(extendedError, loggerContext);
+            await uploadLogs();
             const errorInfo = {
                 statusCode: err instanceof Error ? Number(err.message) : '',
             };
@@ -72,9 +77,10 @@ export class WxCallBackendConnector {
     }
     async getDoNotDisturbSetting() {
         const loggerContext = {
-            file: CALL_SETTINGS_FILE,
-            method: 'getDoNotDisturbSetting',
+            file: WEBEX_CALLING_CONNECTOR_FILE,
+            method: METHODS.GET_DO_NOT_DISTURB_SETTING,
         };
+        log.info(METHOD_START_MESSAGE, loggerContext);
         try {
             const resp = await this.webex.request({
                 uri: `${this.hydraEndpoint}/${PEOPLE_ENDPOINT}/${this.personId}/${DND_ENDPOINT}?${ORG_ENDPOINT}=${this.orgId}`,
@@ -88,9 +94,13 @@ export class WxCallBackendConnector {
                 },
                 message: SUCCESS_MESSAGE,
             };
+            log.log(`Successfully got Do Not Disturb settings, personId: ${this.personId}`, loggerContext);
             return responseDetails;
         }
         catch (err) {
+            const extendedError = new Error(`Failed to get DoNotDisturb setting: ${err}`);
+            log.error(extendedError, loggerContext);
+            await uploadLogs();
             const errorInfo = err;
             const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
             return errorStatus;
@@ -98,9 +108,10 @@ export class WxCallBackendConnector {
     }
     async setDoNotDisturbSetting(enabled) {
         const loggerContext = {
-            file: CALL_SETTINGS_FILE,
-            method: 'setDoNotDisturbSetting',
+            file: WEBEX_CALLING_CONNECTOR_FILE,
+            method: METHODS.SET_DO_NOT_DISTURB_SETTING,
         };
+        log.info(METHOD_START_MESSAGE, loggerContext);
         try {
             const dndRequestBody = {
                 enabled,
@@ -118,9 +129,13 @@ export class WxCallBackendConnector {
                 },
                 message: SUCCESS_MESSAGE,
             };
+            log.log(`Successfully set Do Not Disturb settings, personId: ${this.personId}`, loggerContext);
             return responseDetails;
         }
         catch (err) {
+            const extendedError = new Error(`Failed to set DoNotDisturb setting: ${err}`);
+            log.error(extendedError, loggerContext);
+            await uploadLogs();
             const errorInfo = err;
             const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
             return errorStatus;
@@ -128,9 +143,10 @@ export class WxCallBackendConnector {
     }
     async getCallForwardSetting() {
         const loggerContext = {
-            file: CALL_SETTINGS_FILE,
-            method: 'getCallForwardingSetting',
+            file: WEBEX_CALLING_CONNECTOR_FILE,
+            method: METHODS.GET_CALL_FORWARD_SETTING,
         };
+        log.info(METHOD_START_MESSAGE, loggerContext);
         try {
             const resp = await this.webex.request({
                 uri: `${this.hydraEndpoint}/${PEOPLE_ENDPOINT}/${this.personId}/${CF_ENDPOINT}?${ORG_ENDPOINT}=${this.orgId}`,
@@ -144,9 +160,13 @@ export class WxCallBackendConnector {
                 },
                 message: SUCCESS_MESSAGE,
             };
+            log.log(`Successfully got Call Forward settings, personId: ${this.personId}`, loggerContext);
             return responseDetails;
         }
         catch (err) {
+            const extendedError = new Error(`Failed to get Call Forward setting: ${err}`);
+            log.error(extendedError, loggerContext);
+            await uploadLogs();
             const errorInfo = err;
             const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
             return errorStatus;
@@ -154,9 +174,10 @@ export class WxCallBackendConnector {
     }
     async setCallForwardSetting(callForwardingRequest) {
         const loggerContext = {
-            file: CALL_SETTINGS_FILE,
-            method: 'setCallForwardingSetting',
+            file: WEBEX_CALLING_CONNECTOR_FILE,
+            method: METHODS.SET_CALL_FORWARD_SETTING,
         };
+        log.info(METHOD_START_MESSAGE, loggerContext);
         try {
             const resp = await this.webex.request({
                 uri: `${this.hydraEndpoint}/${PEOPLE_ENDPOINT}/${this.personId}/${CF_ENDPOINT}?${ORG_ENDPOINT}=${this.orgId}`,
@@ -170,9 +191,13 @@ export class WxCallBackendConnector {
                 },
                 message: SUCCESS_MESSAGE,
             };
+            log.log(`Successfully set Call Forward settings, personId: ${this.personId}`, loggerContext);
             return responseDetails;
         }
         catch (err) {
+            const extendedError = new Error(`Failed to set Call Forward setting: ${err}`);
+            log.error(extendedError, loggerContext);
+            await uploadLogs();
             const errorInfo = err;
             const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
             return errorStatus;
@@ -180,9 +205,10 @@ export class WxCallBackendConnector {
     }
     async getVoicemailSetting() {
         const loggerContext = {
-            file: CALL_SETTINGS_FILE,
-            method: 'getVoicemailSetting',
+            file: WEBEX_CALLING_CONNECTOR_FILE,
+            method: METHODS.GET_VOICEMAIL_SETTING,
         };
+        log.info(METHOD_START_MESSAGE, loggerContext);
         try {
             const resp = await this.webex.request({
                 uri: `${this.hydraEndpoint}/${PEOPLE_ENDPOINT}/${this.personId}/${VM_ENDPOINT}?${ORG_ENDPOINT}=${this.orgId}`,
@@ -196,9 +222,13 @@ export class WxCallBackendConnector {
                 },
                 message: SUCCESS_MESSAGE,
             };
+            log.log(`Successfully got Voicemail settings, personId: ${this.personId}`, loggerContext);
             return responseDetails;
         }
         catch (err) {
+            const extendedError = new Error(`Failed to get Voicemail setting: ${err}`);
+            log.error(extendedError, loggerContext);
+            await uploadLogs();
             const errorInfo = err;
             const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
             return errorStatus;
@@ -206,9 +236,10 @@ export class WxCallBackendConnector {
     }
     async setVoicemailSetting(voicemailRequest) {
         const loggerContext = {
-            file: CALL_SETTINGS_FILE,
-            method: 'setVoicemailSetting',
+            file: WEBEX_CALLING_CONNECTOR_FILE,
+            method: METHODS.SET_VOICEMAIL_SETTING,
         };
+        log.info(METHOD_START_MESSAGE, loggerContext);
         try {
             const resp = await this.webex.request({
                 uri: `${this.hydraEndpoint}/${PEOPLE_ENDPOINT}/${this.personId}/${VM_ENDPOINT}?${ORG_ENDPOINT}=${this.orgId}`,
@@ -222,9 +253,13 @@ export class WxCallBackendConnector {
                 },
                 message: SUCCESS_MESSAGE,
             };
+            log.log(`Successfully set Voicemail settings, personId: ${this.personId}`, loggerContext);
             return responseDetails;
         }
         catch (err) {
+            const extendedError = new Error(`Failed to set Voicemail setting: ${err}`);
+            log.error(extendedError, loggerContext);
+            await uploadLogs();
             const errorInfo = err;
             const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
             return errorStatus;
@@ -233,8 +268,9 @@ export class WxCallBackendConnector {
     async getCallForwardAlwaysSetting() {
         const loggerContext = {
             file: WEBEX_CALLING_CONNECTOR_FILE,
-            method: this.getCallForwardAlwaysSetting.name,
+            method: METHODS.GET_CALL_FORWARD_ALWAYS_SETTING,
         };
+        log.info(METHOD_START_MESSAGE, loggerContext);
         const cfResponse = await this.getCallForwardSetting();
         if (cfResponse.statusCode === 200) {
             const cfa = cfResponse.data.callSetting.callForwarding.always;

package/dist/module/CallSettings/constants.js

@@ -7,3 +7,15 @@ export const CF_ENDPOINT = 'features/callForwarding';
 export const VM_ENDPOINT = 'features/voicemail';
 export const CALL_WAITING_ENDPOINT = 'CallWaiting';
 export const XSI_VERSION = 'v2.0';
+export const METHODS = {
+    INITIALIZE_BACKEND_CONNECTOR: 'initializeBackendConnector',
+    GET_CALL_WAITING_SETTING: 'getCallWaitingSetting',
+    GET_DO_NOT_DISTURB_SETTING: 'getDoNotDisturbSetting',
+    SET_DO_NOT_DISTURB_SETTING: 'setDoNotDisturbSetting',
+    GET_CALL_FORWARD_SETTING: 'getCallForwardSetting',
+    SET_CALL_FORWARD_SETTING: 'setCallForwardSetting',
+    GET_VOICEMAIL_SETTING: 'getVoicemailSetting',
+    SET_VOICEMAIL_SETTING: 'setVoicemailSetting',
+    GET_CALL_FORWARD_ALWAYS_SETTING: 'getCallForwardAlwaysSetting',
+    GET_METHOD_NOT_SUPPORTED_RESPONSE: 'getMethodNotSupportedResponse',
+};

package/dist/module/CallingClient/CallingClient.js

@@ -1,6 +1,6 @@
 import * as Media from '@webex/internal-media-core';
 import { Mutex } from 'async-mutex';
-import { v4 as uuid } from 'uuid';
+import { METHOD_START_MESSAGE } from '../common/constants';
 import { filterMobiusUris, handleCallingClientErrors, uploadLogs, validateServiceData, } from '../common/Utils';
 import { LOGGER } from '../Logger/types';
 import SDKConnector from '../SDKConnector';
@@ -9,7 +9,7 @@ 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, } 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, NETWORK_FLAP_TIMEOUT, API_V1, MOBIUS_US_PROD, MOBIUS_EU_PROD, MOBIUS_US_INT, MOBIUS_EU_INT, METHODS, } from './constants';
 import Line from './line';
 import { METRIC_EVENT, REG_ACTION, METRIC_TYPE } from '../Metrics/types';
 import { getMetricManager } from '../Metrics';
@@ -31,6 +31,10 @@ export class CallingClient extends Eventing {
         this.sdkConnector = SDKConnector;
         if (!this.sdkConnector.getWebex()) {
             SDKConnector.setWebex(webex);
+            if (config?.logger?.level && webex.logger.config) {
+                webex.logger.config.level = config.logger.level;
+            }
+            log.setWebexLogger(webex.logger);
         }
         this.mutex = new Mutex();
         this.webex = this.sdkConnector.getWebex();
@@ -81,6 +85,10 @@ export class CallingClient extends Eventing {
         this.detectNetworkChange();
     }
     async detectNetworkChange() {
+        log.info(METHOD_START_MESSAGE, {
+            file: CALLING_CLIENT_FILE,
+            method: METHODS.DETECT_NETWORK_CHANGE,
+        });
         let retry = false;
         const line = Object.values(this.lineDict)[0];
         setInterval(async () => {
@@ -89,7 +97,7 @@ export class CallingClient extends Eventing {
                 !Object.keys(this.callManager.getActiveCalls()).length) {
                 log.warn(`Network has flapped, waiting for mercury connection to be up`, {
                     file: CALLING_CLIENT_FILE,
-                    method: this.detectNetworkChange.name,
+                    method: METHODS.DETECT_NETWORK_CHANGE,
                 });
                 line.registration.clearKeepaliveTimer();
                 retry = true;
@@ -105,6 +113,10 @@ export class CallingClient extends Eventing {
         }, NETWORK_FLAP_TIMEOUT);
     }
     async getClientRegionInfo() {
+        log.info(METHOD_START_MESSAGE, {
+            file: CALLING_CLIENT_FILE,
+            method: METHODS.GET_CLIENT_REGION_INFO,
+        });
         const regionInfo = {};
         for (const mobius of this.mobiusClusters) {
             this.mobiusHost = `https://${mobius.host}${API_V1}`;
@@ -135,8 +147,13 @@ export class CallingClient extends Eventing {
                 break;
             }
             catch (err) {
+                const extendedError = new Error(`Failed to get client region info: ${err}`);
+                log.error(extendedError, {
+                    method: METHODS.GET_CLIENT_REGION_INFO,
+                    file: CALLING_CLIENT_FILE,
+                });
                 handleCallingClientErrors(err, (clientError) => {
-                    this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION_ERROR, REG_ACTION.REGISTER, METRIC_TYPE.BEHAVIORAL, clientError);
+                    this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION_ERROR, REG_ACTION.REGISTER, METRIC_TYPE.BEHAVIORAL, GET_MOBIUS_SERVERS_UTIL, 'UNKNOWN', err.headers?.trackingId ?? '', undefined, clientError);
                     this.emit(CALLING_CLIENT_EVENT_KEYS.ERROR, clientError);
                 }, { method: GET_MOBIUS_SERVERS_UTIL, file: CALLING_CLIENT_FILE });
                 regionInfo.clientRegion = '';
@@ -146,11 +163,15 @@ export class CallingClient extends Eventing {
         return regionInfo;
     }
     async getMobiusServers() {
+        log.info(METHOD_START_MESSAGE, {
+            file: CALLING_CLIENT_FILE,
+            method: METHODS.GET_MOBIUS_SERVERS,
+        });
         let useDefault = false;
         let clientRegion;
         let countryCode;
         if (this.sdkConfig?.discovery?.country && this.sdkConfig?.discovery?.region) {
-            log.info('Updating region and country from the SDK config', {
+            log.log('Updating region and country from the SDK config', {
                 file: CALLING_CLIENT_FILE,
                 method: GET_MOBIUS_SERVERS_UTIL,
             });
@@ -159,7 +180,7 @@ export class CallingClient extends Eventing {
             this.mobiusHost = this.webex.internal.services._serviceUrls.mobius;
         }
         else {
-            log.info('Updating region and country through Region discovery', {
+            log.log('Updating region and country through Region discovery', {
                 file: CALLING_CLIENT_FILE,
                 method: GET_MOBIUS_SERVERS_UTIL,
             });
@@ -187,8 +208,13 @@ export class CallingClient extends Eventing {
                 log.info(`Final list of Mobius Servers, primary: ${mobiusUris.primary} and backup: ${mobiusUris.backup}`, '');
             }
             catch (err) {
+                const extendedError = new Error(`Failed to get Mobius servers: ${err}`);
+                log.error(extendedError, {
+                    method: METHODS.GET_MOBIUS_SERVERS,
+                    file: CALLING_CLIENT_FILE,
+                });
                 handleCallingClientErrors(err, (clientError) => {
-                    this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION_ERROR, REG_ACTION.REGISTER, METRIC_TYPE.BEHAVIORAL, clientError);
+                    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 });
                 useDefault = true;
@@ -204,19 +230,22 @@ export class CallingClient extends Eventing {
         }
     }
     registerCallsClearedListener() {
-        const logContext = {
+        log.info(METHOD_START_MESSAGE, {
             file: CALLING_CLIENT_FILE,
-            method: this.registerCallsClearedListener.name,
-        };
-        log.log('Registering listener for all calls cleared event', logContext);
+            method: METHODS.REGISTER_CALLS_CLEARED_LISTENER,
+        });
         this.callManager.on(CALLING_CLIENT_EVENT_KEYS.ALL_CALLS_CLEARED, this.callsClearedHandler);
     }
     callsClearedHandler = async () => {
+        log.info(METHOD_START_MESSAGE, {
+            file: CALLING_CLIENT_FILE,
+            method: METHODS.CALLS_CLEARED_HANDLER,
+        });
         const { registration } = Object.values(this.lineDict)[0];
         if (!registration.isDeviceRegistered()) {
             await this.mutex.runExclusive(async () => {
                 if (registration.isReconnectPending()) {
-                    log.log('All calls cleared, reconnecting', {
+                    log.info('All calls cleared, reconnecting', {
                         file: CALLING_CLIENT_FILE,
                         method: CALLS_CLEARED_HANDLER_UTIL,
                     });
@@ -232,6 +261,10 @@ export class CallingClient extends Eventing {
         return this.sdkConnector;
     }
     registerSessionsListener() {
+        log.info(METHOD_START_MESSAGE, {
+            file: CALLING_CLIENT_FILE,
+            method: METHODS.REGISTER_SESSIONS_LISTENER,
+        });
         this.sdkConnector.registerListener(MOBIUS_EVENT_KEYS.CALL_SESSION_EVENT_INCLUSIVE, async (event) => {
             if (event && event.data.userSessions.userSessions) {
                 const sessionArr = event?.data.userSessions.userSessions;
@@ -250,6 +283,10 @@ export class CallingClient extends Eventing {
         });
     }
     async createLine() {
+        log.info(METHOD_START_MESSAGE, {
+            file: CALLING_CLIENT_FILE,
+            method: METHODS.CREATE_LINE,
+        });
         const line = new Line(this.webex.internal.device.userId, this.webex.internal.device.url, this.mutex, this.primaryMobiusUris, this.backupMobiusUris, this.getLoggingLevel(), this.sdkConfig?.serviceData, this.sdkConfig?.jwe);
         this.lineDict[line.lineId] = line;
     }
@@ -278,11 +315,12 @@ export class CallingClient extends Eventing {
         });
         return connectCall;
     }
-    async uploadLogs(data = {}) {
-        if (!data.feedbackId) {
-            data = { ...data, feedbackId: uuid() };
+    async uploadLogs() {
+        const result = await uploadLogs({}, true);
+        if (!result) {
+            throw new Error('Failed to upload logs: No response received.');
         }
-        return uploadLogs(data);
+        return result;
     }
 }
 export const createClient = async (webex, config) => {