@webex/calling 3.8.0 → 3.8.1-next.2

package/dist/module/CallingClient/calling/callManager.js

@@ -1,4 +1,5 @@
-import { CALL_MANAGER_FILE } from '../constants';
+import { METHOD_START_MESSAGE } from '../../common/constants';
+import { CALL_MANAGER_FILE, METHODS } from '../constants';
 import { CALLING_CLIENT_EVENT_KEYS, LINE_EVENT_KEYS } from '../../Events/types';
 import { Eventing } from '../../Events/impl';
 import SDKConnector from '../../SDKConnector';
@@ -28,6 +29,10 @@ export class CallManager extends Eventing {
         this.listenForWsEvents();
     }
     createCall = (direction, deviceId, lineId, destination) => {
+        log.info(`${METHOD_START_MESSAGE} with ${direction}, ${deviceId} and ${lineId}`, {
+            file: CALL_MANAGER_FILE,
+            method: METHODS.CREATE_CALL,
+        });
         log.log('Creating call object', {});
         const newCall = createCall(this.activeMobiusUrl, this.webex, direction, deviceId, lineId, (correlationId) => {
             delete this.callCollection[correlationId];
@@ -35,6 +40,10 @@ export class CallManager extends Eventing {
             log.info(`DELETE:: Deleted corelationId: ${newCall.getCorrelationId()} from CallManager, Number of call records :- ${activeCalls}`, {});
             if (activeCalls === 0) {
                 this.emit(CALLING_CLIENT_EVENT_KEYS.ALL_CALLS_CLEARED);
+                log.log('All calls have been cleared', {
+                    file: CALL_MANAGER_FILE,
+                    method: METHODS.CREATE_CALL,
+                });
             }
         }, this.serviceIndicator, destination);
         this.callCollection[newCall.getCorrelationId()] = newCall;
@@ -44,20 +53,32 @@ export class CallManager extends Eventing {
     };
     updateActiveMobius(url) {
         this.activeMobiusUrl = url;
+        log.log(`Successfully updated active Mobius URL to: ${url}`, {
+            file: CALL_MANAGER_FILE,
+            method: METHODS.UPDATE_ACTIVE_MOBIUS,
+        });
     }
     listenForWsEvents() {
         this.sdkConnector.registerListener('event:mobius', async (event) => {
             this.dequeueWsEvents(event);
         });
+        log.info('Successfully registered listener for Mobius events', {
+            file: CALL_MANAGER_FILE,
+            method: METHODS.REGISTER_SESSIONS_LISTENER,
+        });
     }
     dequeueWsEvents(event) {
+        log.info(`${METHOD_START_MESSAGE} with event ${event}`, {
+            file: CALL_MANAGER_FILE,
+            method: METHODS.DEQUEUE_WS_EVENTS,
+        });
         const mobiusEvent = event;
         const { callId, correlationId } = mobiusEvent.data;
         switch (mobiusEvent.data.eventType) {
             case MobiusEventType.CALL_SETUP: {
                 log.log(`Received call Setup message for call: ${callId}`, {
                     file: CALL_MANAGER_FILE,
-                    method: 'dequeueWsEvents',
+                    method: METHODS.DEQUEUE_WS_EVENTS,
                 });
                 if (mobiusEvent.data.midCallService) {
                     mobiusEvent.data.midCallService.forEach((midCallEvent) => {
@@ -66,9 +87,9 @@ export class CallManager extends Eventing {
                             call.handleMidCallEvent(midCallEvent);
                         }
                         else {
-                            log.log(`Dropping midcall event of type: ${midCallEvent.eventType} as it doesn't match with any existing call`, {
+                            log.info(`Dropping midcall event of type: ${midCallEvent.eventType} as it doesn't match with any existing call`, {
                                 file: CALL_MANAGER_FILE,
-                                method: 'dequeueWsEvents',
+                                method: METHODS.DEQUEUE_WS_EVENTS,
                             });
                         }
                     });
@@ -81,13 +102,13 @@ export class CallManager extends Eventing {
                     newCall = this.createCall(CallDirection.INBOUND, mobiusEvent.data.deviceId, lineId, {});
                     log.log(`New incoming call created with correlationId from Call Setup message: ${newCall.getCorrelationId()}`, {
                         file: CALL_MANAGER_FILE,
-                        method: 'dequeueWsEvents',
+                        method: METHODS.DEQUEUE_WS_EVENTS,
                     });
                     newCall.setCallId(callId);
                     if (mobiusEvent.data.broadworksCorrelationInfo) {
-                        log.log(`Found broadworksCorrelationInfo: ${mobiusEvent.data.broadworksCorrelationInfo}`, {
+                        log.info(`Found broadworksCorrelationInfo: ${mobiusEvent.data.broadworksCorrelationInfo}`, {
                             file: CALL_MANAGER_FILE,
-                            method: 'dequeueWsEvents',
+                            method: METHODS.DEQUEUE_WS_EVENTS,
                         });
                         newCall.setBroadworksCorrelationInfo(mobiusEvent.data.broadworksCorrelationInfo);
                     }
@@ -95,14 +116,14 @@ export class CallManager extends Eventing {
                 else {
                     log.info(`Found the call Object with a matching callId: ${callId} from our records with correlationId: ${newId}`, {
                         file: CALL_MANAGER_FILE,
-                        method: 'dequeueWsEvents',
+                        method: METHODS.DEQUEUE_WS_EVENTS,
                     });
                     newCall = this.getCall(newId);
                 }
                 if (mobiusEvent.data.callerId) {
                     log.info('Processing Caller-Id data', {
                         file: CALL_MANAGER_FILE,
-                        method: 'dequeueWsEvents',
+                        method: METHODS.DEQUEUE_WS_EVENTS,
                     });
                     newCall.startCallerIdResolution(mobiusEvent.data.callerId);
                 }
@@ -113,7 +134,7 @@ export class CallManager extends Eventing {
             case MobiusEventType.CALL_PROGRESS: {
                 log.log(`Received call progress mobiusEvent for call: ${correlationId}`, {
                     file: CALL_MANAGER_FILE,
-                    method: 'dequeueWsEvents',
+                    method: METHODS.DEQUEUE_WS_EVENTS,
                 });
                 const call = this.getCall(correlationId);
                 call.sendCallStateMachineEvt({ type: 'E_RECV_CALL_PROGRESS', data: mobiusEvent.data });
@@ -122,7 +143,7 @@ export class CallManager extends Eventing {
             case MobiusEventType.CALL_MEDIA: {
                 log.log(`Received call media mobiusEvent for call: ${correlationId}`, {
                     file: CALL_MANAGER_FILE,
-                    method: 'dequeueWsEvents',
+                    method: METHODS.DEQUEUE_WS_EVENTS,
                 });
                 let activeCall;
                 if (correlationId) {
@@ -133,7 +154,7 @@ export class CallManager extends Eventing {
                     if (newId) {
                         log.info(`Found the call Object with a matching callId: ${callId} from our records with correlationId: ${newId}`, {
                             file: CALL_MANAGER_FILE,
-                            method: 'dequeueWsEvents',
+                            method: METHODS.DEQUEUE_WS_EVENTS,
                         });
                         activeCall = this.getCall(newId);
                     }
@@ -142,7 +163,7 @@ export class CallManager extends Eventing {
                         activeCall = this.createCall(CallDirection.INBOUND, mobiusEvent.data.deviceId, lineId, {});
                         log.log(`New incoming call created with correlationId from ROAP Message: ${activeCall.getCorrelationId()}`, {
                             file: CALL_MANAGER_FILE,
-                            method: 'dequeueWsEvents',
+                            method: METHODS.DEQUEUE_WS_EVENTS,
                         });
                         activeCall.setCallId(callId);
                     }
@@ -150,18 +171,18 @@ export class CallManager extends Eventing {
                 if (activeCall) {
                     log.info(`SDP from mobius ${mobiusEvent.data.message?.sdp}`, {
                         file: CALL_MANAGER_FILE,
-                        method: 'dequeueWsEvents',
+                        method: METHODS.DEQUEUE_WS_EVENTS,
                     });
                     log.log(`ROAP message from mobius with type:  ${mobiusEvent.data.message?.messageType}, seq: ${mobiusEvent.data.message?.seq} , version: ${mobiusEvent.data.message?.version}`, {
                         file: CALL_MANAGER_FILE,
-                        method: 'dequeueWsEvents',
+                        method: METHODS.DEQUEUE_WS_EVENTS,
                     });
                     const mediaState = mobiusEvent.data.message?.messageType;
                     switch (mediaState) {
                         case MediaState.OFFER: {
                             log.log('Received OFFER', {
                                 file: CALL_MANAGER_FILE,
-                                method: 'dequeueWsEvents',
+                                method: METHODS.DEQUEUE_WS_EVENTS,
                             });
                             activeCall.sendMediaStateMachineEvt({
                                 type: 'E_RECV_ROAP_OFFER',
@@ -172,7 +193,7 @@ export class CallManager extends Eventing {
                         case MediaState.ANSWER: {
                             log.log('Received ANSWER', {
                                 file: CALL_MANAGER_FILE,
-                                method: 'dequeueWsEvents',
+                                method: METHODS.DEQUEUE_WS_EVENTS,
                             });
                             activeCall.sendMediaStateMachineEvt({
                                 type: 'E_RECV_ROAP_ANSWER',
@@ -183,7 +204,7 @@ export class CallManager extends Eventing {
                         case MediaState.OFFER_REQUEST: {
                             log.log('Received OFFER_REQUEST', {
                                 file: CALL_MANAGER_FILE,
-                                method: 'dequeueWsEvents',
+                                method: METHODS.DEQUEUE_WS_EVENTS,
                             });
                             activeCall.sendMediaStateMachineEvt({
                                 type: 'E_RECV_ROAP_OFFER_REQUEST',
@@ -194,7 +215,7 @@ export class CallManager extends Eventing {
                         case MediaState.OK: {
                             log.log('Received OK', {
                                 file: CALL_MANAGER_FILE,
-                                method: 'dequeueWsEvents',
+                                method: METHODS.DEQUEUE_WS_EVENTS,
                             });
                             const mediaOk = {
                                 received: true,
@@ -209,22 +230,22 @@ export class CallManager extends Eventing {
                         case MediaState.ERROR: {
                             log.log('Received Error...', {
                                 file: CALL_MANAGER_FILE,
-                                method: 'dequeueWsEvents',
+                                method: METHODS.DEQUEUE_WS_EVENTS,
                             });
                             break;
                         }
                         default: {
                             log.log(`Unknown Media mobiusEvent: ${mediaState} `, {
                                 file: CALL_MANAGER_FILE,
-                                method: 'dequeueWsEvents',
+                                method: METHODS.DEQUEUE_WS_EVENTS,
                             });
                         }
                     }
                 }
                 else {
-                    log.log(`CorrelationId: ${correlationId} doesn't exist , discarding..`, {
+                    log.info(`CorrelationId: ${correlationId} doesn't exist , discarding..`, {
                         file: CALL_MANAGER_FILE,
-                        method: 'dequeueWsEvents',
+                        method: METHODS.DEQUEUE_WS_EVENTS,
                     });
                 }
                 break;
@@ -232,7 +253,7 @@ export class CallManager extends Eventing {
             case MobiusEventType.CALL_CONNECTED: {
                 log.log(`Received call connect for call: ${correlationId}`, {
                     file: CALL_MANAGER_FILE,
-                    method: 'dequeueWsEvents',
+                    method: METHODS.DEQUEUE_WS_EVENTS,
                 });
                 const call = this.getCall(correlationId);
                 call.sendCallStateMachineEvt({ type: 'E_RECV_CALL_CONNECT', data: mobiusEvent.data });
@@ -241,7 +262,7 @@ export class CallManager extends Eventing {
             case MobiusEventType.CALL_DISCONNECTED: {
                 log.log(`Received call disconnect for call: ${correlationId}`, {
                     file: CALL_MANAGER_FILE,
-                    method: 'dequeueWsEvents',
+                    method: METHODS.DEQUEUE_WS_EVENTS,
                 });
                 const call = this.getCall(correlationId);
                 if (call) {
@@ -252,7 +273,7 @@ export class CallManager extends Eventing {
             default: {
                 log.log(`Unknown Call Event mobiusEvent: ${mobiusEvent.data.eventType}`, {
                     file: CALL_MANAGER_FILE,
-                    method: 'dequeueWsEvents',
+                    method: METHODS.DEQUEUE_WS_EVENTS,
                 });
             }
         }
@@ -265,6 +286,10 @@ export class CallManager extends Eventing {
     };
     updateLine(deviceId, line) {
         this.lineDict[deviceId] = line;
+        log.log(`Successfully updated line for deviceId: ${deviceId}`, {
+            file: CALL_MANAGER_FILE,
+            method: METHODS.UPDATE_LINE,
+        });
     }
     getLineId(deviceId) {
         return this.lineDict[deviceId].lineId;

package/dist/module/CallingClient/constants.js

@@ -108,11 +108,13 @@ export const REG_RANDOM_T_FACTOR_UPPER_LIMIT = 10000;
 export const REG_TRY_BACKUP_TIMER_VAL_IN_SEC = 1200;
 export const REG_TRY_BACKUP_TIMER_VAL_FOR_CC_IN_SEC = 114;
 export const REG_FAILBACK_429_MAX_RETRIES = 5;
-export const REGISTER_UTIL = 'registerDevice';
+export const RETRY_TIMER_UPPER_LIMIT = 60;
+export const REGISTRATION_UTIL = 'triggerRegistration';
+export const REGISTER_UTIL = 'attemptRegistrationWithServers';
 export const GET_MOBIUS_SERVERS_UTIL = 'getMobiusServers';
 export const KEEPALIVE_UTIL = 'startKeepaliveTimer';
 export const FAILBACK_UTIL = 'executeFailback';
-export const FAILBACK_429_RETRY_UTIL = 'scheduleFailback429Retry';
+export const REG_429_RETRY_UTIL = 'handle429Retry';
 export const FAILOVER_UTIL = 'startFailoverTimer';
 export const NETWORK_CHANGE_DETECTION_UTIL = 'detectNetworkChange';
 export const CALLS_CLEARED_HANDLER_UTIL = 'callsClearedHandler';
@@ -123,3 +125,101 @@ export const MOBIUS_EU_PROD = 'mobius-eu-central-1.prod.infra.webex.com';
 export const MOBIUS_US_INT = 'mobius-us-east-1.int.infra.webex.com';
 export const MOBIUS_EU_INT = 'mobius-eu-central-1.int.infra.webex.com';
 export const ICE_CANDIDATES_TIMEOUT = 3000;
+export const METHODS = {
+    CONSTRUCTOR: 'constructor',
+    CREATE_CALL: 'createCall',
+    HANDLE_INCOMING_CALL_SETUP: 'handleIncomingCallSetup',
+    HANDLE_OUTGOING_CALL_SETUP: 'handleOutgoingCallSetup',
+    HANDLE_CALL_HOLD: 'handleCallHold',
+    HANDLE_CALL_RESUME: 'handleCallResume',
+    HANDLE_INCOMING_CALL_PROGRESS: 'handleIncomingCallProgress',
+    HANDLE_INCOMING_ROAP_OFFER_REQUEST: 'handleIncomingRoapOfferRequest',
+    HANDLE_OUTGOING_CALL_ALERTING: 'handleOutgoingCallAlerting',
+    HANDLE_INCOMING_CALL_CONNECT: 'handleIncomingCallConnect',
+    HANDLE_OUTGOING_CALL_CONNECT: 'handleOutgoingCallConnect',
+    HANDLE_INCOMING_CALL_DISCONNECT: 'handleIncomingCallDisconnect',
+    HANDLE_OUTGOING_CALL_DISCONNECT: 'handleOutgoingCallDisconnect',
+    HANDLE_CALL_ESTABLISHED: 'handleCallEstablished',
+    HANDLE_UNKNOWN_STATE: 'handleUnknownState',
+    HANDLE_TIMEOUT: 'handleTimeout',
+    GET_EMITTER_CALLBACK: 'getEmitterCallback',
+    HANDLE_ROAP_ESTABLISHED: 'handleRoapEstablished',
+    HANDLE_ROAP_ERROR: 'handleRoapError',
+    HANDLE_OUTGOING_ROAP_OFFER: 'handleOutgoingRoapOffer',
+    HANDLE_OUTGOING_ROAP_ANSWER: 'handleOutgoingRoapAnswer',
+    HANDLE_INCOMING_ROAP_OFFER: 'handleIncomingRoapOffer',
+    HANDLE_INCOMING_ROAP_ANSWER: 'handleIncomingRoapAnswer',
+    FORCE_SEND_STATS_REPORT: 'forceSendStatsReport',
+    UPDATE_ACTIVE_MOBIUS: 'updateActiveMobius',
+    DEQUEUE_WS_EVENTS: 'dequeueWsEvents',
+    GET_CALL: 'getCall',
+    GET_ACTIVE_CALLS: 'getActiveCalls',
+    UPDATE_LINE: 'updateLine',
+    GET_LINE_ID: 'getLineId',
+    INIT_MEDIA_CONNECTION: 'initMediaConnection',
+    GET_DIRECTION: 'getDirection',
+    GET_CALL_ID: 'getCallId',
+    GET_CORRELATION_ID: 'getCorrelationId',
+    SEND_CALL_STATE_MACHINE_EVT: 'sendCallStateMachineEvt',
+    SEND_MEDIA_STATE_MACHINE_EVT: 'sendMediaStateMachineEvt',
+    SET_CALL_ID: 'setCallId',
+    SET_DISCONNECT_REASON: 'setDisconnectReason',
+    GET_DISCONNECT_REASON: 'getDisconnectReason',
+    ANSWER: 'answer',
+    DIAL: 'dial',
+    POST: 'post',
+    PATCH: 'patch',
+    POST_SS_REQUEST: 'postSSRequest',
+    POST_STATUS: 'postStatus',
+    COMPLETE_TRANSFER: 'completeTransfer',
+    GET_CALL_STATS: 'getCallStats',
+    POST_MEDIA: 'postMedia',
+    MEDIA_ROAP_EVENTS_LISTENER: 'mediaRoapEventsListener',
+    MEDIA_TRACK_LISTENER: 'mediaTrackListener',
+    ON_EFFECT_ENABLED: 'onEffectEnabled',
+    ON_EFFECT_DISABLED: 'onEffectDisabled',
+    UPDATE_TRACK: 'updateTrack',
+    REGISTER_EFFECT_LISTENER: 'registerEffectListener',
+    UNREGISTER_LISTENERS: 'unregisterListeners',
+    REGISTER_LISTENERS: 'registerListeners',
+    DELETE: 'delete',
+    SUBMIT_CALL_ERROR_METRIC: 'submitCallErrorMetric',
+    HANDLE_MID_CALL_EVENT: 'handleMidCallEvent',
+    GET_CALLER_INFO: 'getCallerInfo',
+    END: 'end',
+    DO_HOLD_RESUME: 'doHoldResume',
+    START_CALLER_ID_RESOLUTION: 'startCallerIdResolution',
+    SEND_DIGIT: 'sendDigit',
+    MUTE: 'mute',
+    IS_MUTED: 'isMuted',
+    IS_CONNECTED: 'isConnected',
+    IS_HELD: 'isHeld',
+    UPDATE_MEDIA: 'updateMedia',
+    SET_BROADWORKS_CORRELATION_INFO: 'setBroadworksCorrelationInfo',
+    GET_BROADWORKS_CORRELATION_INFO: 'getBroadworksCorrelationInfo',
+    GET_CALL_RTP_STATS: 'getCallRtpStats',
+    REGISTER: 'register',
+    DEREGISTER: 'deregister',
+    NORMALIZE_LINE: 'normalizeLine',
+    LINE_EMITTER: 'lineEmitter',
+    GET_LOGGING_LEVEL: 'getLoggingLevel',
+    GET_ACTIVE_MOBIUS_URL: 'getActiveMobiusUrl',
+    GET_STATUS: 'getStatus',
+    GET_DEVICE_ID: 'getDeviceId',
+    MAKE_CALL: 'makeCall',
+    INCOMING_CALL_LISTENER: 'incomingCallListener',
+    SET_MOBIUS_SERVERS: 'setMobiusServers',
+    HANDLE_CONNECTION_RESTORATION: 'handleConnectionRestoration',
+    RECONNECT_ON_FAILURE: 'reconnectOnFailure',
+    DETECT_NETWORK_CHANGE: 'detectNetworkChange',
+    GET_CLIENT_REGION_INFO: 'getClientRegionInfo',
+    GET_MOBIUS_SERVERS: 'getMobiusServers',
+    REGISTER_CALLS_CLEARED_LISTENER: 'registerCallsClearedListener',
+    CALLS_CLEARED_HANDLER: 'callsClearedHandler',
+    REGISTER_SESSIONS_LISTENER: 'registerSessionsListener',
+    CREATE_LINE: 'createLine',
+    GET_LINES: 'getLines',
+    UPLOAD_LOGS: 'uploadLogs',
+    GET_SDK_CONNECTOR: 'getSDKConnector',
+    GET_CONNECTED_CALL: 'getConnectedCall',
+};

package/dist/module/CallingClient/line/index.js

@@ -1,7 +1,8 @@
 import { v4 as uuid } from 'uuid';
+import { METHOD_START_MESSAGE } from '../../common/constants';
 import { CallDirection, RegistrationStatus, ServiceIndicator, } from '../../common/types';
 import { LINE_EVENTS } from './types';
-import { LINE_FILE, VALID_PHONE_REGEX } from '../constants';
+import { LINE_FILE, METHODS, VALID_PHONE_REGEX } from '../constants';
 import log from '../../Logger';
 import { createRegistration } from '../registration';
 import { Eventing } from '../../Events/impl';
@@ -59,6 +60,10 @@ export default class Line extends Eventing {
         this.incomingCallListener();
     }
     async register() {
+        log.info(METHOD_START_MESSAGE, {
+            file: LINE_FILE,
+            method: METHODS.REGISTER,
+        });
         await this.#mutex.runExclusive(async () => {
             this.emit(LINE_EVENTS.CONNECTING);
             this.registration.setMobiusServers(this.#primaryMobiusUris, this.#backupMobiusUris);
@@ -69,6 +74,10 @@ export default class Line extends Eventing {
         }
     }
     async deregister() {
+        log.info(METHOD_START_MESSAGE, {
+            file: LINE_FILE,
+            method: METHODS.DEREGISTER,
+        });
         await this.registration.deregister();
         this.registration.setStatus(RegistrationStatus.IDLE);
     }
@@ -86,6 +95,10 @@ export default class Line extends Eventing {
         this.voicePortalExtension = voicePortalExtension;
     }
     lineEmitter = (event, deviceInfo, lineError) => {
+        log.info(METHOD_START_MESSAGE, {
+            file: LINE_FILE,
+            method: METHODS.LINE_EMITTER,
+        });
         switch (event) {
             case LINE_EVENTS.REGISTERED:
                 if (deviceInfo) {
@@ -116,6 +129,10 @@ export default class Line extends Eventing {
     getStatus = () => this.registration.getStatus();
     getDeviceId = () => this.registration.getDeviceInfo().device?.deviceId;
     makeCall = (dest) => {
+        log.info(METHOD_START_MESSAGE, {
+            file: LINE_FILE,
+            method: METHODS.MAKE_CALL,
+        });
         let call;
         if (dest) {
             const match = dest.address.match(VALID_PHONE_REGEX);
@@ -129,10 +146,16 @@ export default class Line extends Eventing {
                     address: `tel:${sanitizedNumber}`,
                 };
                 call = this.callManager.createCall(CallDirection.OUTBOUND, this.registration.getDeviceInfo().device?.deviceId, this.lineId, formattedDest);
-                log.log(`New call created, callId: ${call.getCallId()}`, {});
+                log.log(`New call created, callId: ${call?.getCallId()}`, {
+                    file: LINE_FILE,
+                    method: METHODS.MAKE_CALL,
+                });
             }
             else {
-                log.warn('Invalid phone number detected', {});
+                log.warn('Invalid phone number detected', {
+                    file: LINE_FILE,
+                    method: METHODS.MAKE_CALL,
+                });
                 const err = new LineError('An invalid phone number was detected. Check the number and try again.', {}, ERROR_TYPE.CALL_ERROR, RegistrationStatus.ACTIVE);
                 this.emit(LINE_EVENTS.ERROR, err);
             }
@@ -140,17 +163,23 @@ export default class Line extends Eventing {
         }
         if (this.serviceData.indicator === ServiceIndicator.GUEST_CALLING) {
             call = this.callManager.createCall(CallDirection.OUTBOUND, this.registration.getDeviceInfo().device?.deviceId, this.lineId);
-            log.log(`New guest call created, callId: ${call.getCallId()}`, {});
+            log.info(`New guest call created, callId: ${call.getCallId()}`, {
+                file: LINE_FILE,
+                method: METHODS.MAKE_CALL,
+            });
             return call;
         }
         return undefined;
     };
     incomingCallListener() {
-        const logContext = {
+        log.info(METHOD_START_MESSAGE, {
             file: LINE_FILE,
-            method: this.incomingCallListener.name,
-        };
-        log.log('Listening for incoming calls... ', logContext);
+            method: METHODS.INCOMING_CALL_LISTENER,
+        });
+        log.info('Listening for incoming calls... ', {
+            file: LINE_FILE,
+            method: METHODS.INCOMING_CALL_LISTENER,
+        });
         this.callManager.on(LINE_EVENT_KEYS.INCOMING_CALL, (callObj) => {
             this.emit(LINE_EVENTS.INCOMING_CALL, callObj);
         });