@webex/calling 3.9.0 → 3.10.0-multi-llms.1

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

@@ -88,10 +88,11 @@ export class Registration {
             });
         }
         catch (error) {
-            log.warn(`Delete failed with Mobius ${error}`, {
+            log.warn(`Delete failed with Mobius: ${JSON.stringify(error)}`, {
                 file: REGISTRATION_FILE,
-                method: METHODS.DEREGISTER,
+                method: METHODS.DELETE_REGISTRATION,
             });
+            await uploadLogs();
         }
         this.setStatus(RegistrationStatus.INACTIVE);
         this.lineEmitter(LINE_EVENTS.UNREGISTERED);
@@ -121,6 +122,14 @@ export class Registration {
         }
         return abort;
     }
+    async handle404KeepaliveFailure(caller) {
+        if (caller === KEEPALIVE_UTIL) {
+            const abort = await this.attemptRegistrationWithServers(caller);
+            if (!abort && !this.isDeviceRegistered()) {
+                await this.startFailoverTimer();
+            }
+        }
+    }
     async handle429Retry(retryAfter, caller) {
         if (caller === FAILBACK_UTIL) {
             if (this.failback429RetryAttempts >= REG_FAILBACK_429_MAX_RETRIES) {
@@ -140,6 +149,16 @@ export class Registration {
                 await this.restartRegistration(REG_429_RETRY_UTIL);
             }
         }
+        else if (caller === KEEPALIVE_UTIL) {
+            this.clearKeepaliveTimer();
+            setTimeout(async () => {
+                log.log(`Resuming keepalive after ${retryAfter} seconds`, {
+                    file: REGISTRATION_FILE,
+                    method: REG_429_RETRY_UTIL,
+                });
+                await this.startKeepaliveTimer(this.deviceInfo.device?.uri, this.deviceInfo.keepaliveInterval, 'UNKNOWN');
+            }, retryAfter * 1000);
+        }
         else {
             this.retryAfter = retryAfter;
         }
@@ -243,7 +262,7 @@ export class Registration {
                 }
             }
             catch (error) {
-                log.warn(`Ping failed for primary Mobius: ${mobiusUrl} with error: ${error}`, {
+                log.warn(`Ping failed for primary Mobius: ${mobiusUrl} with error: ${JSON.stringify(error)}`, {
                     file: REGISTRATION_FILE,
                     method: FAILBACK_UTIL,
                 });
@@ -354,18 +373,18 @@ export class Registration {
         });
         await this.mutex.runExclusive(async () => {
             if (retry) {
-                log.log('Mercury connection is up again, re-registering with Webex Calling if needed', {
+                log.log('Network is up again, re-registering with Webex Calling if needed', {
                     file: REGISTRATION_FILE,
-                    method: this.handleConnectionRestoration.name,
+                    method: METHODS.HANDLE_CONNECTION_RESTORATION,
                 });
                 this.clearKeepaliveTimer();
                 if (this.isDeviceRegistered()) {
                     await this.deregister();
                 }
                 if (this.activeMobiusUrl) {
-                    const abort = await this.restorePreviousRegistration(this.handleConnectionRestoration.name);
+                    const abort = await this.restorePreviousRegistration(METHODS.HANDLE_CONNECTION_RESTORATION);
                     if (!abort && !this.isDeviceRegistered()) {
-                        await this.restartRegistration(this.handleConnectionRestoration.name);
+                        await this.restartRegistration(METHODS.HANDLE_CONNECTION_RESTORATION);
                     }
                 }
                 retry = false;
@@ -433,12 +452,12 @@ export class Registration {
                 const resp = await this.postRegistration(url);
                 this.deviceInfo = resp.body;
                 this.registrationStatus = RegistrationStatus.ACTIVE;
+                this.setActiveMobiusUrl(url);
                 this.lineEmitter(LINE_EVENTS.REGISTERED, resp.body);
-                log.log(`Registration successful for deviceId: ${this.deviceInfo.device?.deviceId} userId: ${this.userId}`, {
+                log.log(`Registration successful for deviceId: ${this.deviceInfo.device?.deviceId} userId: ${this.userId} responseTrackingId: ${resp.headers?.trackingid}`, {
                     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, caller, serverType, resp.headers?.trackingid ?? '', undefined, undefined);
@@ -466,6 +485,7 @@ export class Registration {
                 }
                 if (abort) {
                     this.setStatus(RegistrationStatus.INACTIVE);
+                    await uploadLogs();
                     break;
                 }
             }
@@ -494,7 +514,7 @@ export class Registration {
                     this.webWorker.onmessage = async (event) => {
                         const logContext = {
                             file: REGISTRATION_FILE,
-                            method: this.startKeepaliveTimer.name,
+                            method: KEEPALIVE_UTIL,
                         };
                         if (event.data.type === WorkerMessageType.KEEPALIVE_SUCCESS) {
                             log.info(`Sent Keepalive, status: ${event.data.statusCode}`, logContext);
@@ -507,17 +527,21 @@ 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, KEEPALIVE_UTIL, serverType, error.headers?.trackingid ?? '', event.data.keepAliveRetryCount, clientError);
-                            }, { method: KEEPALIVE_UTIL, file: REGISTRATION_FILE });
+                                this.metricManager.submitRegistrationMetric(METRIC_EVENT.KEEPALIVE_ERROR, REG_ACTION.KEEPALIVE_FAILURE, METRIC_TYPE.BEHAVIORAL, KEEPALIVE_UTIL, serverType, error.headers?.trackingid ?? '', event.data.keepAliveRetryCount, clientError);
+                            }, { method: KEEPALIVE_UTIL, file: REGISTRATION_FILE }, (retryAfter, retryCaller) => this.handle429Retry(retryAfter, retryCaller));
                             if (abort || event.data.keepAliveRetryCount >= RETRY_COUNT_THRESHOLD) {
                                 this.failoverImmediately = this.isCCFlow;
                                 this.setStatus(RegistrationStatus.INACTIVE);
                                 this.clearKeepaliveTimer();
                                 this.clearFailbackTimer();
                                 this.lineEmitter(LINE_EVENTS.UNREGISTERED);
+                                await uploadLogs();
                                 if (!abort) {
                                     await this.reconnectOnFailure(KEEPALIVE_UTIL);
                                 }
+                                else if (error.statusCode === 404) {
+                                    this.handle404KeepaliveFailure(KEEPALIVE_UTIL);
+                                }
                             }
                             else {
                                 this.lineEmitter(LINE_EVENTS.RECONNECTING);
@@ -547,7 +571,7 @@ export class Registration {
             });
         }
         catch (err) {
-            log.warn(`Delete failed with Mobius: ${err}`, {
+            log.warn(`Delete failed with Mobius: ${JSON.stringify(err)}`, {
                 file: REGISTRATION_FILE,
                 method: METHODS.DEREGISTER,
             });

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

@@ -1,7 +1,7 @@
 import { v4 as uuid } from 'uuid';
 import { HTTP_METHODS, WorkerMessageType } from '../../common/types';
 let keepaliveTimer;
-export const messageHandler = (event) => {
+const messageHandler = (event) => {
     const { type } = event.data;
     const postKeepAlive = async (accessToken, deviceUrl, url) => {
         const response = await fetch(`${url}/status`, {
@@ -14,7 +14,7 @@ export const messageHandler = (event) => {
             },
         });
         if (!response.ok) {
-            throw new Error(`Keepalive failed with status: ${response.status}`);
+            throw response;
         }
         return response;
     };
@@ -39,10 +39,23 @@ export const messageHandler = (event) => {
                     keepAliveRetryCount = 0;
                 }
                 catch (err) {
+                    const headers = {};
+                    if (err.headers?.has('Retry-After')) {
+                        headers['retry-after'] = err.headers.get('Retry-After');
+                    }
+                    if (err.headers?.has('Trackingid')) {
+                        headers['trackingid'] = err.headers.get('Trackingid');
+                    }
+                    const error = {
+                        headers,
+                        statusCode: err.status,
+                        statusText: err.statusText,
+                        type: err.type,
+                    };
                     keepAliveRetryCount += 1;
                     postMessage({
                         type: WorkerMessageType.KEEPALIVE_FAILURE,
-                        err,
+                        err: error,
                         keepAliveRetryCount,
                     });
                 }
@@ -57,3 +70,4 @@ export const messageHandler = (event) => {
     }
 };
 self.addEventListener('message', messageHandler);
+export default messageHandler;

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

@@ -41,7 +41,7 @@ const messageHandler = (event) => {
     });
 
     if (!response.ok) {
-      throw new Error(\`Keepalive failed with status: \${response.status}\`);
+      throw response;
     }
 
     return response;
@@ -69,10 +69,26 @@ const messageHandler = (event) => {
           }
           keepAliveRetryCount = 0;
         } catch (err) {
-          keepAliveRetryCount += 1;
+          let headers = {};
+          if(err.headers?.has('Retry-After')) {
+            headers['retry-after'] = err.headers.get('Retry-After');
+          } 
+
+          if(err.headers?.has('Trackingid')) {
+            headers['trackingid'] = err.headers.get('Trackingid');
+          }   
+
+          const error = {
+            headers,
+            statusCode: err.status,
+            statusText: err.statusText,
+            type: err.type,
+          };
+
+          keepAliveRetryCount += 1
           self.postMessage({
             type: WorkerMessageType.KEEPALIVE_FAILURE,
-            err,
+            err: error,
             keepAliveRetryCount,
           });
         }

package/dist/module/CallingClient/windowsChromiumIceWarmupUtils.js

@@ -0,0 +1,59 @@
+function waitForIceComplete(pc, timeoutMs) {
+    return new Promise((resolve) => {
+        if (!pc) {
+            resolve({ ok: false, reason: 'no-pc' });
+            return;
+        }
+        if (pc.iceGatheringState === 'complete') {
+            resolve({ ok: true, reached: 'already' });
+            return;
+        }
+        let done = false;
+        const onChange = () => {
+            if (pc.iceGatheringState === 'complete' && !done) {
+                done = true;
+                pc.removeEventListener('icegatheringstatechange', onChange);
+                resolve({ ok: true, reached: 'event' });
+            }
+        };
+        pc.addEventListener('icegatheringstatechange', onChange);
+        setTimeout(() => {
+            if (done)
+                return;
+            done = true;
+            pc.removeEventListener('icegatheringstatechange', onChange);
+            resolve({ ok: pc.iceGatheringState === 'complete', reached: 'timeout' });
+        }, timeoutMs);
+    });
+}
+export default async function windowsChromiumIceWarmup({ iceServers = [], timeoutMs = 1000 }) {
+    const pc1 = new RTCPeerConnection({ iceServers, iceCandidatePoolSize: 1 });
+    const pc2 = new RTCPeerConnection({ iceServers, iceCandidatePoolSize: 1 });
+    const candidates = { pc1: [], pc2: [] };
+    pc1.onicecandidate = (e) => {
+        if (e.candidate && e.candidate.type !== 'host') {
+            candidates.pc1.push(e.candidate);
+        }
+    };
+    await pc1.createDataChannel('warmup');
+    await pc1.addTransceiver('audio');
+    const offer = await pc1.createOffer();
+    await pc1.setLocalDescription(offer);
+    await waitForIceComplete(pc1, timeoutMs);
+    await pc2.setRemoteDescription(offer);
+    pc2.onicecandidate = (e) => {
+        if (e.candidate && e.candidate.type !== 'host') {
+            candidates.pc2.push(e.candidate);
+        }
+    };
+    const answer = await pc2.createAnswer();
+    await pc2.setLocalDescription(answer);
+    await pc1.setRemoteDescription(answer);
+    await waitForIceComplete(pc2, timeoutMs);
+    await Promise.all([
+        ...candidates.pc1.map((candidate) => pc2.addIceCandidate(candidate).catch(console.error)),
+        ...candidates.pc2.map((candidate) => pc1.addIceCandidate(candidate).catch(console.error)),
+    ]);
+    pc1.close();
+    pc2.close();
+}

package/dist/module/Contacts/ContactsClient.js

@@ -2,7 +2,7 @@ import { FAILURE_MESSAGE, METHOD_START_MESSAGE, SCIM_ENTERPRISE_USER, SCIM_WEBEX
 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, METHODS, OR, SCIM_ID_FILTER, USERS, encryptedFields, } from './constants';
+import { CONTACTS_CLIENT, 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, uploadLogs } from '../common/Utils';
 export class ContactsClient {
@@ -22,7 +22,7 @@ export class ContactsClient {
         this.groups = undefined;
         this.contacts = undefined;
         this.defaultGroupId = '';
-        log.setLogger(logger.level, CONTACTS_FILE);
+        log.setLogger(logger.level, CONTACTS_CLIENT);
     }
     async decryptContactDetail(encryptionKeyUrl, contactDetails) {
         const decryptedContactDetail = [...contactDetails];
@@ -130,7 +130,7 @@ export class ContactsClient {
     }
     resolveCloudContacts(contactsDataMap, inputList) {
         const loggerContext = {
-            file: CONTACTS_FILE,
+            file: CONTACTS_CLIENT,
             method: 'resolveCloudContacts',
         };
         const finalContactList = [];
@@ -187,7 +187,7 @@ export class ContactsClient {
     }
     async getContacts() {
         const loggerContext = {
-            file: CONTACTS_FILE,
+            file: CONTACTS_CLIENT,
             method: METHODS.GET_CONTACTS,
         };
         log.info(METHOD_START_MESSAGE, loggerContext);
@@ -198,6 +198,7 @@ export class ContactsClient {
                 uri: `${this.webex.internal.services._serviceUrls.contactsService}/${ENCRYPT_FILTER}/${USERS}/${CONTACT_FILTER}`,
                 method: HTTP_METHODS.GET,
             });
+            log.log(`Response code: ${response.statusCode} and Response trackingId: ${response?.headers?.trackingid}`, loggerContext);
             const responseBody = response.body;
             if (!responseBody) {
                 throw new Error(`${response}`);
@@ -249,17 +250,15 @@ export class ContactsClient {
             return contactResponse;
         }
         catch (err) {
-            const errorInfo = err;
-            const extendedError = new Error(`Error fetching contacts: ${err}`);
-            log.error(extendedError, loggerContext);
-            const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
+            log.error(`Error fetching contacts: ${JSON.stringify(err)}`, loggerContext);
+            const errorStatus = serviceErrorCodeHandler(err, loggerContext);
             await uploadLogs();
             return errorStatus;
         }
     }
     async createNewEncryptionKeyUrl() {
         const loggerContext = {
-            file: CONTACTS_FILE,
+            file: CONTACTS_CLIENT,
             method: METHODS.CREATE_NEW_ENCRYPTION_KEY_URL,
         };
         log.info(METHOD_START_MESSAGE, loggerContext);
@@ -272,7 +271,7 @@ export class ContactsClient {
     }
     async fetchEncryptionKeyUrl() {
         const loggerContext = {
-            file: CONTACTS_FILE,
+            file: CONTACTS_CLIENT,
             method: METHODS.FETCH_ENCRYPTION_KEY_URL,
         };
         log.info(METHOD_START_MESSAGE, loggerContext);
@@ -287,14 +286,14 @@ export class ContactsClient {
         }
         this.encryptionKeyUrl = await this.createNewEncryptionKeyUrl();
         log.log(`Creating a default group: ${DEFAULT_GROUP_NAME}`, {
-            file: CONTACTS_FILE,
+            file: CONTACTS_CLIENT,
             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,
+                file: CONTACTS_CLIENT,
                 method: this.fetchEncryptionKeyUrl.name,
             });
         }
@@ -302,13 +301,13 @@ export class ContactsClient {
     }
     async fetchDefaultGroup() {
         const loggerContext = {
-            file: CONTACTS_FILE,
+            file: CONTACTS_CLIENT,
             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,
+                file: CONTACTS_CLIENT,
                 method: this.fetchDefaultGroup.name,
             });
             return this.defaultGroupId;
@@ -318,7 +317,7 @@ export class ContactsClient {
                 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,
+                        file: CONTACTS_CLIENT,
                         method: this.fetchDefaultGroup.name,
                     });
                     return this.defaultGroupId;
@@ -326,7 +325,7 @@ export class ContactsClient {
             }
         }
         log.log('No default group found.', {
-            file: CONTACTS_FILE,
+            file: CONTACTS_CLIENT,
             method: this.fetchDefaultGroup.name,
         });
         const response = await this.createContactGroup(DEFAULT_GROUP_NAME);
@@ -334,7 +333,7 @@ export class ContactsClient {
         if (group) {
             const groupId = group.groupId;
             log.log(`Successfully created new default group with ID: ${groupId}`, {
-                file: CONTACTS_FILE,
+                file: CONTACTS_CLIENT,
                 method: this.fetchDefaultGroup.name,
             });
             return groupId;
@@ -343,7 +342,7 @@ export class ContactsClient {
     }
     async createContactGroup(displayName, encryptionKeyUrl, groupType) {
         const loggerContext = {
-            file: CONTACTS_FILE,
+            file: CONTACTS_CLIENT,
             method: METHODS.CREATE_CONTACT_GROUP,
         };
         log.info(`${METHOD_START_MESSAGE} with displayName: ${displayName}`, loggerContext);
@@ -377,6 +376,8 @@ export class ContactsClient {
                 method: HTTP_METHODS.POST,
                 body: groupInfo,
             });
+            log.log(`Response code: ${response.statusCode}`, loggerContext);
+            log.log(`Response trackingId: ${response?.headers?.trackingid}`, loggerContext);
             const group = response.body;
             group.displayName = displayName;
             const contactResponse = {
@@ -391,17 +392,15 @@ export class ContactsClient {
             return contactResponse;
         }
         catch (err) {
-            const errorInfo = err;
-            const extendedError = new Error(`Unable to create contact group: ${err}`);
-            log.error(extendedError, loggerContext);
-            const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
+            log.error(`Unable to create contact group: ${JSON.stringify(err)}`, loggerContext);
+            const errorStatus = serviceErrorCodeHandler(err, loggerContext);
             await uploadLogs();
             return errorStatus;
         }
     }
     async deleteContactGroup(groupId) {
         const loggerContext = {
-            file: CONTACTS_FILE,
+            file: CONTACTS_CLIENT,
             method: METHODS.DELETE_CONTACT_GROUP,
         };
         log.info(`${METHOD_START_MESSAGE} with groupId: ${groupId}`, loggerContext);
@@ -411,6 +410,7 @@ export class ContactsClient {
                 uri: `${this.webex.internal.services._serviceUrls.contactsService}/${ENCRYPT_FILTER}/${USERS}/${GROUP_FILTER}/${groupId}`,
                 method: HTTP_METHODS.DELETE,
             });
+            log.log(`Response trackingId: ${response?.headers?.trackingid}`, loggerContext);
             const contactResponse = {
                 statusCode: Number(response[STATUS_CODE]),
                 data: {},
@@ -427,17 +427,15 @@ export class ContactsClient {
             return contactResponse;
         }
         catch (err) {
-            const errorInfo = err;
-            const extendedError = new Error(`Unable to delete contact group ${groupId}: ${err}`);
-            log.error(extendedError, loggerContext);
-            const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
+            log.error(`Unable to delete contact group ${groupId}: ${JSON.stringify(err)}`, loggerContext);
+            const errorStatus = serviceErrorCodeHandler(err, loggerContext);
             await uploadLogs();
             return errorStatus;
         }
     }
     async createContact(contactInfo) {
         const loggerContext = {
-            file: CONTACTS_FILE,
+            file: CONTACTS_CLIENT,
             method: METHODS.CREATE_CONTACT,
         };
         log.info(`${METHOD_START_MESSAGE} with contactType: ${contactInfo.contactType}`, loggerContext);
@@ -487,6 +485,8 @@ export class ContactsClient {
                 method: HTTP_METHODS.POST,
                 body: requestBody,
             });
+            log.log(`Response code: ${response.statusCode}`, loggerContext);
+            log.log(`Response trackingId: ${response?.headers?.trackingid}`, loggerContext);
             const newContact = response.body;
             contact.contactId = newContact.contactId;
             const contactResponse = {
@@ -511,17 +511,15 @@ export class ContactsClient {
             return contactResponse;
         }
         catch (err) {
-            const errorInfo = err;
-            const extendedError = new Error(`Failed to create contact: ${err}`);
-            log.error(extendedError, loggerContext);
-            const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
+            log.error(`Failed to create contact: ${JSON.stringify(err)}`, loggerContext);
+            const errorStatus = serviceErrorCodeHandler(err, loggerContext);
             await uploadLogs();
             return errorStatus;
         }
     }
     async deleteContact(contactId) {
         const loggerContext = {
-            file: CONTACTS_FILE,
+            file: CONTACTS_CLIENT,
             method: METHODS.DELETE_CONTACT,
         };
         log.info(`${METHOD_START_MESSAGE} with contactId: ${contactId}`, loggerContext);
@@ -544,10 +542,8 @@ export class ContactsClient {
             return contactResponse;
         }
         catch (err) {
-            const errorInfo = err;
-            const extendedError = new Error(`Unable to delete contact ${contactId}: ${err}`);
-            log.error(extendedError, loggerContext);
-            const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
+            log.error(`Unable to delete contact ${contactId}: ${JSON.stringify(err)}`, loggerContext);
+            const errorStatus = serviceErrorCodeHandler(err, loggerContext);
             await uploadLogs();
             return errorStatus;
         }

package/dist/module/Contacts/constants.js

@@ -1,4 +1,4 @@
-export const CONTACTS_FILE = 'Contacts';
+export const CONTACTS_CLIENT = 'ContactsClient';
 export const CONTACT_FILTER = 'contacts';
 export const GROUP_FILTER = 'groups';
 export const ENCRYPT_FILTER = 'encrypt';

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.info(`${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/Logger/index.js

@@ -101,9 +101,9 @@ const logTrace = (message, context) => {
         writeToLogger(`${format(context, '[TRACE]')} - ${LOG_PREFIX.MESSAGE}:${message}`, LOGGER.TRACE);
     }
 };
-const logError = (error, context) => {
+const logError = (errorMsg, context) => {
     if (currentLogLevel >= LOGGING_LEVEL.error) {
-        writeToLogger(`${format(context, '[ERROR]')} - !${LOG_PREFIX.ERROR}!${LOG_PREFIX.MESSAGE}:${error.message}`, LOGGER.ERROR);
+        writeToLogger(`${format(context, '[ERROR]')} - !${LOG_PREFIX.ERROR}!${LOG_PREFIX.MESSAGE}:${errorMsg}`, LOGGER.ERROR);
     }
 };
 const setWebexLogger = (logger) => {