@webex/calling 3.8.0 → 3.8.1-next.10

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',
         });

package/dist/module/Metrics/index.js

@@ -11,10 +11,58 @@ class MetricManager {
         this.webex = webex;
         this.serviceIndicator = indicator;
     }
+    submitUploadLogsMetric(name, action, type, trackingId, feedbackId, correlationId, stack, callId) {
+        let data;
+        switch (name) {
+            case METRIC_EVENT.UPLOAD_LOGS_SUCCESS: {
+                data = {
+                    tags: {
+                        action,
+                        device_id: this.deviceInfo?.device?.deviceId,
+                        service_indicator: this.serviceIndicator,
+                    },
+                    fields: {
+                        device_url: this.deviceInfo?.device?.clientDeviceUri,
+                        mobius_url: this.deviceInfo?.device?.uri,
+                        calling_sdk_version: process.env.CALLING_SDK_VERSION || VERSION,
+                        correlation_id: correlationId,
+                        tracking_id: trackingId,
+                        feedback_id: feedbackId,
+                        call_id: callId,
+                    },
+                    type,
+                };
+                break;
+            }
+            case METRIC_EVENT.UPLOAD_LOGS_FAILED: {
+                data = {
+                    tags: {
+                        action,
+                        device_id: this.deviceInfo?.device?.deviceId,
+                        service_indicator: this.serviceIndicator,
+                    },
+                    fields: {
+                        device_url: this.deviceInfo?.device?.clientDeviceUri,
+                        mobius_url: this.deviceInfo?.device?.uri,
+                        calling_sdk_version: process.env.CALLING_SDK_VERSION || VERSION,
+                        correlation_id: correlationId,
+                        tracking_id: trackingId,
+                        feedback_id: feedbackId,
+                        error: stack,
+                        call_id: callId,
+                    },
+                    type,
+                };
+            }
+        }
+        if (data) {
+            this.webex.internal.metrics.submitClientMetrics(name, data);
+        }
+    }
     setDeviceInfo(deviceInfo) {
         this.deviceInfo = deviceInfo;
     }
-    submitRegistrationMetric(name, metricAction, type, clientError) {
+    submitRegistrationMetric(name, metricAction, type, caller, serverType, trackingId, keepaliveCount, clientError) {
         let data;
         switch (name) {
             case METRIC_EVENT.REGISTRATION: {
@@ -28,6 +76,9 @@ class MetricManager {
                         device_url: this.deviceInfo?.device?.clientDeviceUri,
                         mobius_url: this.deviceInfo?.device?.uri,
                         calling_sdk_version: process.env.CALLING_SDK_VERSION || VERSION,
+                        reg_source: caller,
+                        server_type: serverType,
+                        trackingId,
                     },
                     type,
                 };
@@ -45,6 +96,10 @@ class MetricManager {
                             device_url: this.deviceInfo?.device?.clientDeviceUri,
                             mobius_url: this.deviceInfo?.device?.uri,
                             calling_sdk_version: process.env.CALLING_SDK_VERSION || VERSION,
+                            reg_source: caller,
+                            server_type: serverType,
+                            trackingId,
+                            keepalive_count: keepaliveCount,
                             error: clientError.getError().message,
                             error_type: clientError.getError().type,
                         },
@@ -256,7 +311,7 @@ class MetricManager {
     }
 }
 export const getMetricManager = (webex, indicator) => {
-    if (!metricManager) {
+    if (!metricManager && webex) {
         metricManager = new MetricManager(webex, indicator);
     }
     return metricManager;

package/dist/module/Metrics/types.js

@@ -15,6 +15,8 @@ export var METRIC_EVENT;
     METRIC_EVENT["REGISTRATION_ERROR"] = "web-calling-sdk-registration-error";
     METRIC_EVENT["VOICEMAIL"] = "web-calling-sdk-voicemail";
     METRIC_EVENT["VOICEMAIL_ERROR"] = "web-calling-sdk-voicemail-error";
+    METRIC_EVENT["UPLOAD_LOGS_SUCCESS"] = "web-calling-sdk-upload-logs-success";
+    METRIC_EVENT["UPLOAD_LOGS_FAILED"] = "web-calling-sdk-upload-logs-failed";
 })(METRIC_EVENT || (METRIC_EVENT = {}));
 export var REG_ACTION;
 (function (REG_ACTION) {
@@ -37,3 +39,4 @@ export var VOICEMAIL_ACTION;
     VOICEMAIL_ACTION["DELETE"] = "delete";
     VOICEMAIL_ACTION["TRANSCRIPT"] = "transcript";
 })(VOICEMAIL_ACTION || (VOICEMAIL_ACTION = {}));
+export const UPLOAD_LOGS_ACTION = 'upload_logs';

package/dist/module/Voicemail/BroadworksBackendConnector.js

@@ -1,10 +1,10 @@
 import { ERROR_CODE } from '../Errors/types';
 import SDKConnector from '../SDKConnector';
-import { BASE64, BEARER, BINARY, SUCCESS_MESSAGE, SUCCESS_STATUS_CODE, OBJECT, TOKEN, USER, XML_TYPE, BW_XSI_ENDPOINT_VERSION, } from '../common/constants';
-import { serviceErrorCodeHandler, getXsiActionEndpoint, getSortedVoicemailList, storeVoicemailList, fetchVoicemailList, } from '../common/Utils';
+import { BASE64, BEARER, BINARY, SUCCESS_MESSAGE, SUCCESS_STATUS_CODE, OBJECT, TOKEN, USER, XML_TYPE, BW_XSI_ENDPOINT_VERSION, METHOD_START_MESSAGE, } from '../common/constants';
+import { serviceErrorCodeHandler, getXsiActionEndpoint, getSortedVoicemailList, storeVoicemailList, fetchVoicemailList, uploadLogs, } from '../common/Utils';
 import { CALLING_BACKEND, HTTP_METHODS, SORT, } from '../common/types';
 import log from '../Logger';
-import { BROADWORKS_VOICEMAIL_FILE, BW_TOKEN_FETCH_ENDPOINT, JSON_FORMAT, MARK_AS_READ, MARK_AS_UNREAD, MESSAGE_MEDIA_CONTENT, VOICE_MESSAGING_MESSAGES, NO_VOICEMAIL_MSG, NO_VOICEMAIL_STATUS_CODE, RADIX_RAND, PREFIX, } from './constants';
+import { BROADWORKS_VOICEMAIL_FILE, BW_TOKEN_FETCH_ENDPOINT, JSON_FORMAT, MARK_AS_READ, MARK_AS_UNREAD, MESSAGE_MEDIA_CONTENT, VOICE_MESSAGING_MESSAGES, NO_VOICEMAIL_MSG, NO_VOICEMAIL_STATUS_CODE, RADIX_RAND, PREFIX, METHODS, } from './constants';
 export class BroadworksBackendConnector {
     bwtoken;
     userId;
@@ -26,10 +26,11 @@ export class BroadworksBackendConnector {
     init() {
         const loggerContext = {
             file: BROADWORKS_VOICEMAIL_FILE,
-            method: 'init',
+            method: METHODS.INIT,
         };
-        log.info('Initializing Broadworks voicemail connector', loggerContext);
+        log.info(METHOD_START_MESSAGE, loggerContext);
         const response = this.setXsiVoiceMessageURI();
+        log.log('Successfully initialized Broadworks voicemail connector', loggerContext);
         return response;
     }
     getSDKConnector() {
@@ -38,8 +39,9 @@ export class BroadworksBackendConnector {
     async getUserId() {
         const loggerContext = {
             file: BROADWORKS_VOICEMAIL_FILE,
-            method: 'getUserId',
+            method: METHODS.GET_USER_ID,
         };
+        log.info(METHOD_START_MESSAGE, loggerContext);
         try {
             await this.getBwToken();
             if (this.bwtoken && this.bwtoken.split('.').length > 1) {
@@ -54,10 +56,18 @@ export class BroadworksBackendConnector {
             const errorInfo = {
                 statusCode: err instanceof Error ? Number(err.message) : '',
             };
+            const extendedError = new Error(`Failed to get userId: ${err}`);
+            log.error(extendedError, loggerContext);
+            await uploadLogs();
             return serviceErrorCodeHandler(errorInfo, loggerContext);
         }
     }
     async getBwToken() {
+        const loggerContext = {
+            file: BROADWORKS_VOICEMAIL_FILE,
+            method: METHODS.GET_BW_TOKEN,
+        };
+        log.info(METHOD_START_MESSAGE, loggerContext);
         try {
             const bwTokenResponse = await this.webex.request({
                 uri: `${this.webex.internal.services._serviceUrls.broadworksIdpProxy}${BW_TOKEN_FETCH_ENDPOINT}`,
@@ -65,16 +75,23 @@ export class BroadworksBackendConnector {
             });
             const response = bwTokenResponse.body;
             this.bwtoken = response[TOKEN][BEARER];
+            log.log('Successfully fetched Broadworks token', loggerContext);
         }
         catch (err) {
-            log.info(`Broadworks token exception ${err}`, {});
+            const extendedError = new Error(`Broadworks token exception: ${err}`);
+            log.error(extendedError, {
+                file: BROADWORKS_VOICEMAIL_FILE,
+                method: METHODS.GET_BW_TOKEN,
+            });
+            await uploadLogs();
         }
     }
     async setXsiVoiceMessageURI() {
         const loggerContext = {
             file: BROADWORKS_VOICEMAIL_FILE,
-            method: 'setXsiVoiceMessageURI',
+            method: METHODS.SET_XSI_VOICE_MESSAGE_URI,
         };
+        log.info(METHOD_START_MESSAGE, loggerContext);
         let userIdResponse = await this.getUserId();
         this.xsiEndpoint = await getXsiActionEndpoint(this.webex, loggerContext, CALLING_BACKEND.BWRKS);
         this.xsiAccessToken = `${BEARER} ${this.bwtoken}`;
@@ -87,14 +104,15 @@ export class BroadworksBackendConnector {
                 message: SUCCESS_MESSAGE,
             };
         }
+        log.log('Successfully set XSI voice message URI', loggerContext);
         return userIdResponse;
     }
     async getVoicemailList(offset, offsetLimit, sort, refresh) {
         const loggerContext = {
             file: BROADWORKS_VOICEMAIL_FILE,
-            method: 'getVoicemailList',
+            method: METHODS.GET_VOICEMAIL_LIST,
         };
-        log.info(`Offset: ${offset} Offset limit: ${offsetLimit} Sort type:${sort}`, loggerContext);
+        log.info(`${METHOD_START_MESSAGE} with offset: ${offset}, offsetLimit: ${offsetLimit}, sort type: ${sort}`, loggerContext);
         const urlXsi = `${this.xsiVoiceMessageURI}${JSON_FORMAT}`;
         let messageinfo;
         const sortParam = Object.values(SORT).includes(sort) ? sort : SORT.DEFAULT;
@@ -127,11 +145,15 @@ export class BroadworksBackendConnector {
                 const errorInfo = {
                     statusCode: err instanceof Error ? Number(err.message) : '',
                 };
+                const extendedError = new Error(`Failed to get voicemail list: ${err}`);
+                log.error(extendedError, loggerContext);
+                await uploadLogs();
                 const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
                 return errorStatus;
             }
         }
         const { messages, moreVMAvailable } = fetchVoicemailList(this.context, offset, offsetLimit, loggerContext);
+        log.log(`Successfully fetched voicemail list with ${messages.length} messages`, loggerContext);
         const responseDetails = {
             statusCode: moreVMAvailable ? SUCCESS_STATUS_CODE : NO_VOICEMAIL_STATUS_CODE,
             data: {
@@ -144,8 +166,9 @@ export class BroadworksBackendConnector {
     async getVoicemailContent(messageId) {
         const loggerContext = {
             file: BROADWORKS_VOICEMAIL_FILE,
-            method: 'getVoicemailContent',
+            method: METHODS.GET_VOICEMAIL_CONTENT,
         };
+        log.info(`${METHOD_START_MESSAGE} with messageId: ${messageId}`, loggerContext);
         try {
             const voicemailContentUrl = `${this.xsiEndpoint}${messageId}`;
             const response = await fetch(`${voicemailContentUrl}`, {
@@ -163,7 +186,8 @@ export class BroadworksBackendConnector {
             const mediaDetails = xmlDOM.getElementsByTagName(MESSAGE_MEDIA_CONTENT)[0];
             const mediaType = mediaDetails.childNodes[1]?.textContent;
             const mediaContent = mediaDetails.childNodes[2]?.textContent;
-            log.info(`Media type is  ${mediaType}`, loggerContext);
+            log.info(`Media type is ${mediaType}`, loggerContext);
+            log.log(`Successfully fetched voicemail content for message ID: ${messageId}`, loggerContext);
             const responseDetails = {
                 statusCode: response?.status,
                 data: {
@@ -180,6 +204,9 @@ export class BroadworksBackendConnector {
             const errorInfo = {
                 statusCode: err instanceof Error ? Number(err.message) : '',
             };
+            const extendedError = new Error(`Failed to get voicemail content: ${err}`);
+            log.error(extendedError, loggerContext);
+            await uploadLogs();
             const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
             return errorStatus;
         }
@@ -190,8 +217,9 @@ export class BroadworksBackendConnector {
     async voicemailMarkAsRead(messageId) {
         const loggerContext = {
             file: BROADWORKS_VOICEMAIL_FILE,
-            method: 'voicemailMarkAsRead',
+            method: METHODS.VOICEMAIL_MARK_AS_READ,
         };
+        log.info(`${METHOD_START_MESSAGE} with messageId: ${messageId}`, loggerContext);
         try {
             const voicemailContentUrl = `${this.xsiEndpoint}${messageId}/${MARK_AS_READ}`;
             const response = await fetch(voicemailContentUrl, {
@@ -203,6 +231,7 @@ export class BroadworksBackendConnector {
             if (!response.ok) {
                 throw new Error(`${response.status}`);
             }
+            log.log(`Successfully marked voicemail with ID ${messageId} as read`, loggerContext);
             const responseDetails = {
                 statusCode: response.status,
                 data: {},
@@ -214,6 +243,9 @@ export class BroadworksBackendConnector {
             const errorInfo = {
                 statusCode: err instanceof Error ? Number(err.message) : '',
             };
+            const extendedError = new Error(`Failed to mark voicemail as read: ${err}`);
+            log.error(extendedError, loggerContext);
+            await uploadLogs();
             const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
             return errorStatus;
         }
@@ -221,8 +253,9 @@ export class BroadworksBackendConnector {
     async voicemailMarkAsUnread(messageId) {
         const loggerContext = {
             file: BROADWORKS_VOICEMAIL_FILE,
-            method: 'voicemailMarkAsUnread',
+            method: METHODS.VOICEMAIL_MARK_AS_UNREAD,
         };
+        log.info(`${METHOD_START_MESSAGE} with messageId: ${messageId}`, loggerContext);
         try {
             const voicemailContentUrl = `${this.xsiEndpoint}${messageId}/${MARK_AS_UNREAD}`;
             const response = await fetch(voicemailContentUrl, {
@@ -234,6 +267,7 @@ export class BroadworksBackendConnector {
             if (!response.ok) {
                 throw new Error(`${response.status}`);
             }
+            log.log(`Successfully marked voicemail with ID ${messageId} as unread`, loggerContext);
             const responseDetails = {
                 statusCode: response.status,
                 data: {},
@@ -245,6 +279,9 @@ export class BroadworksBackendConnector {
             const errorInfo = {
                 statusCode: err instanceof Error ? Number(err.message) : '',
             };
+            const extendedError = new Error(`Failed to mark voicemail as unread: ${err}`);
+            log.error(extendedError, loggerContext);
+            await uploadLogs();
             const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
             return errorStatus;
         }
@@ -252,8 +289,9 @@ export class BroadworksBackendConnector {
     async deleteVoicemail(messageId) {
         const loggerContext = {
             file: BROADWORKS_VOICEMAIL_FILE,
-            method: 'deleteVoicemail',
+            method: METHODS.DELETE_VOICEMAIL,
         };
+        log.info(`${METHOD_START_MESSAGE} with messageId: ${messageId}`, loggerContext);
         try {
             const voicemailContentUrl = `${this.xsiEndpoint}${messageId}`;
             const response = await fetch(voicemailContentUrl, {
@@ -265,6 +303,7 @@ export class BroadworksBackendConnector {
             if (!response.ok) {
                 throw new Error(`${response.status}`);
             }
+            log.log(`Successfully deleted voicemail with ID ${messageId}`, loggerContext);
             const responseDetails = {
                 statusCode: response.status,
                 data: {},
@@ -276,16 +315,26 @@ export class BroadworksBackendConnector {
             const errorInfo = {
                 statusCode: err instanceof Error ? Number(err.message) : '',
             };
+            const extendedError = new Error(`Failed to delete voicemail: ${err}`);
+            log.error(extendedError, loggerContext);
+            await uploadLogs();
             const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
             return errorStatus;
         }
     }
     async getVMTranscript(messageId) {
-        log.info(`Message Id: ${messageId}`, {});
+        const loggerContext = {
+            file: BROADWORKS_VOICEMAIL_FILE,
+            method: METHODS.GET_VM_TRANSCRIPT,
+        };
+        log.info(`${METHOD_START_MESSAGE} with messageId: ${messageId}`, loggerContext);
         return Promise.resolve(null);
     }
     resolveContact(callingPartyInfo) {
-        log.info(`Calling Party Info: ${callingPartyInfo}`, {});
+        log.info(`${METHOD_START_MESSAGE} with Calling Party Info: ${callingPartyInfo}`, {
+            file: BROADWORKS_VOICEMAIL_FILE,
+            method: METHODS.RESOLVE_CONTACT,
+        });
         return Promise.resolve(null);
     }
 }