@webex/calling 3.8.0 → 3.8.1-next.2

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

@@ -7,7 +7,7 @@ import { ERROR_LAYER, ERROR_TYPE } from '../../Errors/types';
 import { handleCallErrors, modifySdpForIPv4, parseMediaQualityStatistics, serviceErrorCodeHandler, uploadLogs, } from '../../common/Utils';
 import { ALLOWED_SERVICES, CallDirection, HTTP_METHODS, } from '../../common/types';
 import { createCallError } from '../../Errors/catalog/CallError';
-import { CALL_ENDPOINT_RESOURCE, CALL_FILE, CALL_HOLD_SERVICE, CALL_STATUS_RESOURCE, CALL_TRANSFER_SERVICE, CALLING_USER_AGENT, CALLS_ENDPOINT_RESOURCE, CISCO_DEVICE_URL, DEFAULT_LOCAL_CALL_ID, DEFAULT_SESSION_TIMER, DEVICES_ENDPOINT_RESOURCE, HOLD_ENDPOINT, ICE_CANDIDATES_TIMEOUT, INITIAL_SEQ_NUMBER, MEDIA_ENDPOINT_RESOURCE, NOISE_REDUCTION_EFFECT, RESUME_ENDPOINT, SPARK_USER_AGENT, SUPPLEMENTARY_SERVICES_TIMEOUT, TRANSFER_ENDPOINT, } from '../constants';
+import { CALL_ENDPOINT_RESOURCE, CALL_FILE, CALL_HOLD_SERVICE, CALL_STATUS_RESOURCE, CALL_TRANSFER_SERVICE, CALLING_USER_AGENT, CALLS_ENDPOINT_RESOURCE, CISCO_DEVICE_URL, DEFAULT_LOCAL_CALL_ID, DEFAULT_SESSION_TIMER, DEVICES_ENDPOINT_RESOURCE, HOLD_ENDPOINT, ICE_CANDIDATES_TIMEOUT, INITIAL_SEQ_NUMBER, MEDIA_ENDPOINT_RESOURCE, METHODS, NOISE_REDUCTION_EFFECT, RESUME_ENDPOINT, SPARK_USER_AGENT, SUPPLEMENTARY_SERVICES_TIMEOUT, TRANSFER_ENDPOINT, } from '../constants';
 import SDKConnector from '../../SDKConnector';
 import { Eventing } from '../../Events/impl';
 import { CALL_EVENT_KEYS, MEDIA_CONNECTION_EVENT_KEYS, MOBIUS_MIDCALL_STATE, SUPPLEMENTARY_SERVICES, } from '../../Events/types';
@@ -16,7 +16,7 @@ import log from '../../Logger';
 import { createCallerId } from './CallerId';
 import { METRIC_TYPE, METRIC_EVENT, TRANSFER_ACTION } from '../../Metrics/types';
 import { getMetricManager } from '../../Metrics';
-import { SERVICES_ENDPOINT } from '../../common/constants';
+import { METHOD_START_MESSAGE, SERVICES_ENDPOINT } from '../../common/constants';
 export class Call extends Eventing {
     sdkConnector;
     webex;
@@ -87,7 +87,7 @@ export class Call extends Eventing {
         this.mediaNegotiationCompleted = false;
         log.info(`Webex Calling Url:- ${this.mobiusUrl}`, {
             file: CALL_FILE,
-            method: 'constructor',
+            method: METHODS.CONSTRUCTOR,
         });
         this.seq = INITIAL_SEQ_NUMBER;
         this.callerId = createCallerId(webex, (callerInfo) => {
@@ -587,7 +587,10 @@ export class Call extends Eventing {
         });
         this.callStateMachine = interpret(callMachine)
             .onTransition((state, event) => {
-            log.log(`Call StateMachine:- state=${state.value}, event=${JSON.stringify(event.type)}`, {});
+            log.log(`Call StateMachine:- state=${state.value}, event=${JSON.stringify(event.type)}`, {
+                file: CALL_FILE,
+                method: METHODS.CONSTRUCTOR,
+            });
             if (state.value !== 'S_UNKNOWN') {
                 this.metricManager.submitCallMetric(METRIC_EVENT.CALL, state.value.toString(), METRIC_TYPE.BEHAVIORAL, this.callId, this.correlationId, undefined);
             }
@@ -595,7 +598,10 @@ export class Call extends Eventing {
             .start();
         this.mediaStateMachine = interpret(mediaMachine)
             .onTransition((state, event) => {
-            log.log(`Media StateMachine:- state=${state.value}, event=${JSON.stringify(event.type)}`, {});
+            log.log(`Media StateMachine:- state=${state.value}, event=${JSON.stringify(event.type)}`, {
+                file: CALL_FILE,
+                method: METHODS.CONSTRUCTOR,
+            });
             if (state.value !== 'S_ROAP_ERROR') {
                 this.metricManager.submitMediaMetric(METRIC_EVENT.MEDIA, state.value.toString(), METRIC_TYPE.BEHAVIORAL, this.callId, this.correlationId, this.localRoapMessage.sdp, this.remoteRoapMessage?.sdp, undefined);
             }
@@ -604,64 +610,69 @@ export class Call extends Eventing {
         this.muted = false;
     }
     handleIncomingCallSetup(event) {
-        log.info(`handleIncomingCallSetup: ${this.getCorrelationId()}  `, {
+        log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, {
             file: CALL_FILE,
-            method: this.handleIncomingCallSetup.name,
+            method: METHODS.HANDLE_INCOMING_CALL_SETUP,
         });
         this.sendCallStateMachineEvt({ type: 'E_SEND_CALL_ALERTING' });
     }
     async handleOutgoingCallSetup(event) {
-        log.info(`handleOutgoingCallSetup: ${this.getCorrelationId()}  `, {
+        log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, {
             file: CALL_FILE,
-            method: this.handleOutgoingCallSetup.name,
+            method: METHODS.HANDLE_OUTGOING_CALL_SETUP,
         });
         const message = event.data;
         try {
             const response = await this.post(message);
-            log.log(`handleOutgoingCallSetup: Response: ${JSON.stringify(response)}`, {
+            log.info(`Response: ${JSON.stringify(response)}`, {
                 file: CALL_FILE,
-                method: this.handleOutgoingCallSetup.name,
+                method: METHODS.HANDLE_OUTGOING_CALL_SETUP,
             });
-            log.log(`handleOutgoingCallSetup: Response code: ${response.statusCode}`, {
+            log.info(`Response code: ${response.statusCode}`, {
                 file: CALL_FILE,
-                method: this.handleOutgoingCallSetup.name,
+                method: METHODS.HANDLE_OUTGOING_CALL_SETUP,
             });
             this.setCallId(response.body.callId);
+            log.log(`Call setup successful for callId: ${response.body.callId}`, {
+                file: CALL_FILE,
+                method: this.handleOutgoingCallSetup.name,
+            });
         }
         catch (e) {
-            log.warn('Failed to setup the call', {
+            const extendedError = new Error(`Failed to setup the call: ${e}`);
+            log.error(extendedError, {
                 file: CALL_FILE,
-                method: this.handleOutgoingCallSetup.name,
+                method: METHODS.HANDLE_OUTGOING_CALL_SETUP,
             });
             const errData = e;
             handleCallErrors((error) => {
                 this.emit(CALL_EVENT_KEYS.CALL_ERROR, error);
                 this.submitCallErrorMetric(error);
                 this.sendCallStateMachineEvt({ type: 'E_UNKNOWN', data: errData });
-            }, ERROR_LAYER.CALL_CONTROL, (interval) => undefined, this.getCorrelationId(), errData, this.handleOutgoingCallSetup.name, CALL_FILE);
-            uploadLogs({
+            }, ERROR_LAYER.CALL_CONTROL, (interval) => undefined, this.getCorrelationId(), errData, METHODS.HANDLE_OUTGOING_CALL_SETUP, CALL_FILE);
+            await uploadLogs({
                 correlationId: this.correlationId,
                 callId: this.callId,
             });
         }
     }
     async handleCallHold(event) {
-        log.info(`handleCallHold: ${this.getCorrelationId()}  `, {
+        log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, {
             file: CALL_FILE,
-            method: this.handleCallHold.name,
+            method: METHODS.HANDLE_CALL_HOLD,
         });
         try {
             const response = await this.postSSRequest(undefined, SUPPLEMENTARY_SERVICES.HOLD);
             log.log(`Response code: ${response.statusCode}`, {
                 file: CALL_FILE,
-                method: this.handleCallHold.name,
+                method: METHODS.HANDLE_CALL_HOLD,
             });
             if (this.isHeld() === false) {
                 this.supplementaryServicesTimer = setTimeout(async () => {
-                    const errorContext = { file: CALL_FILE, method: this.handleCallHold.name };
+                    const errorContext = { file: CALL_FILE, method: METHODS.HANDLE_CALL_HOLD };
                     log.warn('Hold response timed out', {
                         file: CALL_FILE,
-                        method: this.handleCallHold.name,
+                        method: METHODS.HANDLE_CALL_HOLD,
                     });
                     const callError = createCallError('An error occurred while placing the call on hold. Wait a moment and try again.', errorContext, ERROR_TYPE.TIMEOUT, this.getCorrelationId(), ERROR_LAYER.CALL_CONTROL);
                     this.emit(CALL_EVENT_KEYS.HOLD_ERROR, callError);
@@ -670,26 +681,27 @@ export class Call extends Eventing {
             }
         }
         catch (e) {
-            log.warn('Failed to put the call on hold', {
+            const extendedError = new Error(`Failed to put the call on hold: ${e}`);
+            log.error(extendedError, {
                 file: CALL_FILE,
-                method: this.handleCallHold.name,
+                method: METHODS.HANDLE_CALL_HOLD,
             });
             const errData = e;
             handleCallErrors((error) => {
                 this.emit(CALL_EVENT_KEYS.HOLD_ERROR, error);
                 this.submitCallErrorMetric(error);
                 this.sendCallStateMachineEvt({ type: 'E_CALL_ESTABLISHED', data: errData });
-            }, ERROR_LAYER.CALL_CONTROL, (interval) => undefined, this.getCorrelationId(), errData, this.handleOutgoingCallSetup.name, CALL_FILE);
-            uploadLogs({
+            }, ERROR_LAYER.CALL_CONTROL, (interval) => undefined, this.getCorrelationId(), errData, METHODS.HANDLE_CALL_HOLD, CALL_FILE);
+            await uploadLogs({
                 correlationId: this.correlationId,
                 callId: this.callId,
             });
         }
     }
     async handleCallResume(event) {
-        log.info(`handleCallResume: ${this.getCorrelationId()}  `, {
+        log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, {
             file: CALL_FILE,
-            method: this.handleCallResume.name,
+            method: METHODS.HANDLE_CALL_RESUME,
         });
         try {
             const response = await this.postSSRequest(undefined, SUPPLEMENTARY_SERVICES.RESUME);
@@ -711,7 +723,8 @@ export class Call extends Eventing {
             }
         }
         catch (e) {
-            log.warn('Failed to resume the call', {
+            const extendedError = new Error(`Failed to resume the call: ${e}`);
+            log.error(extendedError, {
                 file: CALL_FILE,
                 method: this.handleCallResume.name,
             });
@@ -721,16 +734,16 @@ export class Call extends Eventing {
                 this.submitCallErrorMetric(error);
                 this.sendCallStateMachineEvt({ type: 'E_CALL_ESTABLISHED', data: errData });
             }, ERROR_LAYER.CALL_CONTROL, (interval) => undefined, this.getCorrelationId(), errData, this.handleOutgoingCallSetup.name, CALL_FILE);
-            uploadLogs({
+            await uploadLogs({
                 correlationId: this.correlationId,
                 callId: this.callId,
             });
         }
     }
     handleIncomingCallProgress(event) {
-        log.info(`handleIncomingCallProgress: ${this.getCorrelationId()}  `, {
+        log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, {
             file: CALL_FILE,
-            method: this.handleIncomingCallProgress.name,
+            method: METHODS.HANDLE_INCOMING_CALL_PROGRESS,
         });
         const data = event.data;
         if (data?.callProgressData?.inbandMedia) {
@@ -756,9 +769,9 @@ export class Call extends Eventing {
         this.emit(CALL_EVENT_KEYS.PROGRESS, this.correlationId);
     }
     handleIncomingRoapOfferRequest(context, event) {
-        log.info(`handleIncomingRoapOfferRequest: ${this.getCorrelationId()}  `, {
+        log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, {
             file: CALL_FILE,
-            method: this.handleIncomingRoapOfferRequest.name,
+            method: METHODS.HANDLE_INCOMING_ROAP_OFFER_REQUEST,
         });
         const message = event.data;
         if (!this.mediaConnection) {
@@ -787,9 +800,9 @@ export class Call extends Eventing {
         }
     }
     async handleOutgoingCallAlerting(event) {
-        log.info(`handleOutgoingCallAlerting: ${this.getCorrelationId()}  `, {
+        log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, {
             file: CALL_FILE,
-            method: this.handleOutgoingCallAlerting.name,
+            method: METHODS.HANDLE_OUTGOING_CALL_ALERTING,
         });
         try {
             const res = await this.patch(MobiusCallState.ALERTING);
@@ -799,7 +812,8 @@ export class Call extends Eventing {
             });
         }
         catch (err) {
-            log.warn('Failed to signal call progression', {
+            const extendedError = new Error(`Failed to signal call progression: ${err}`);
+            log.error(extendedError, {
                 file: CALL_FILE,
                 method: this.handleOutgoingCallAlerting.name,
             });
@@ -809,16 +823,16 @@ export class Call extends Eventing {
                 this.submitCallErrorMetric(error);
                 this.sendCallStateMachineEvt({ type: 'E_UNKNOWN', data: errData });
             }, ERROR_LAYER.CALL_CONTROL, (interval) => undefined, this.getCorrelationId(), errData, this.handleOutgoingCallAlerting.name, CALL_FILE);
-            uploadLogs({
+            await uploadLogs({
                 correlationId: this.correlationId,
                 callId: this.callId,
             });
         }
     }
     handleIncomingCallConnect(event) {
-        log.info(`handleIncomingCallConnect: ${this.getCorrelationId()}  `, {
+        log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, {
             file: CALL_FILE,
-            method: this.handleIncomingCallConnect.name,
+            method: METHODS.HANDLE_INCOMING_CALL_CONNECT,
         });
         this.emit(CALL_EVENT_KEYS.CONNECT, this.correlationId);
         if (this.earlyMedia || this.mediaNegotiationCompleted) {
@@ -827,9 +841,9 @@ export class Call extends Eventing {
         }
     }
     async handleOutgoingCallConnect(event) {
-        log.info(`handleOutgoingCallConnect: ${this.getCorrelationId()}  `, {
+        log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, {
             file: CALL_FILE,
-            method: this.handleOutgoingCallConnect.name,
+            method: METHODS.HANDLE_OUTGOING_CALL_CONNECT,
         });
         if (!this.remoteRoapMessage) {
             log.warn('Offer not yet received from remote end... Exiting', {
@@ -847,7 +861,8 @@ export class Call extends Eventing {
             });
         }
         catch (err) {
-            log.warn('Failed to connect the call', {
+            const extendedError = new Error(`Failed to connect the call: ${err}`);
+            log.error(extendedError, {
                 file: CALL_FILE,
                 method: this.handleOutgoingCallConnect.name,
             });
@@ -857,29 +872,29 @@ export class Call extends Eventing {
                 this.submitCallErrorMetric(error);
                 this.sendCallStateMachineEvt({ type: 'E_UNKNOWN', data: errData });
             }, ERROR_LAYER.CALL_CONTROL, (interval) => undefined, this.getCorrelationId(), errData, this.handleOutgoingCallConnect.name, CALL_FILE);
-            uploadLogs({
+            await uploadLogs({
                 correlationId: this.correlationId,
                 callId: this.callId,
             });
         }
     }
     async handleIncomingCallDisconnect(event) {
-        log.info(`handleIncomingCallDisconnect: ${this.getCorrelationId()}  `, {
+        log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, {
             file: CALL_FILE,
-            method: this.handleIncomingCallDisconnect.name,
+            method: METHODS.HANDLE_OUTGOING_CALL_DISCONNECT,
         });
         this.setDisconnectReason();
         try {
             const response = await this.delete();
-            log.log(`handleOutgoingCallDisconnect: Response code: ${response.statusCode}`, {
+            log.log(`Response code: ${response.statusCode}`, {
                 file: CALL_FILE,
-                method: this.handleIncomingCallDisconnect.name,
+                method: METHODS.HANDLE_OUTGOING_CALL_DISCONNECT,
             });
         }
         catch (e) {
             log.warn('Failed to delete the call', {
                 file: CALL_FILE,
-                method: this.handleIncomingCallDisconnect.name,
+                method: METHODS.HANDLE_OUTGOING_CALL_DISCONNECT,
             });
         }
         this.deleteCb(this.correlationId);
@@ -889,25 +904,36 @@ export class Call extends Eventing {
         }
         if (this.mediaConnection) {
             this.mediaConnection.close();
-            log.info('Closing media channel', { file: CALL_FILE, method: 'handleIncomingCallDisconnect' });
+            log.info('Closing media channel', {
+                file: CALL_FILE,
+                method: METHODS.HANDLE_OUTGOING_CALL_DISCONNECT,
+            });
         }
         this.sendMediaStateMachineEvt({ type: 'E_ROAP_TEARDOWN' });
         this.sendCallStateMachineEvt({ type: 'E_CALL_CLEARED' });
         this.emit(CALL_EVENT_KEYS.DISCONNECT, this.correlationId);
     }
     async handleOutgoingCallDisconnect(event) {
+        log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, {
+            file: CALL_FILE,
+            method: METHODS.HANDLE_OUTGOING_CALL_DISCONNECT,
+        });
         this.setDisconnectReason();
         try {
             const response = await this.delete();
-            log.log(`handleOutgoingCallDisconnect: Response code: ${response.statusCode}`, {
+            log.log(`Response code: ${response.statusCode}`, {
                 file: CALL_FILE,
-                method: this.handleOutgoingCallDisconnect.name,
+                method: METHODS.HANDLE_OUTGOING_CALL_DISCONNECT,
+            });
+            log.log(`Call disconnected successfully: ${this.correlationId}`, {
+                file: CALL_FILE,
+                method: METHODS.HANDLE_OUTGOING_CALL_DISCONNECT,
             });
         }
         catch (e) {
             log.warn('Failed to delete the call', {
                 file: CALL_FILE,
-                method: this.handleOutgoingCallDisconnect.name,
+                method: METHODS.HANDLE_OUTGOING_CALL_DISCONNECT,
             });
         }
         this.deleteCb(this.correlationId);
@@ -917,15 +943,18 @@ export class Call extends Eventing {
         }
         if (this.mediaConnection) {
             this.mediaConnection.close();
-            log.info('Closing media channel', { file: CALL_FILE, method: 'handleOutgoingCallDisconnect' });
+            log.info('Closing media channel', {
+                file: CALL_FILE,
+                method: METHODS.HANDLE_OUTGOING_CALL_DISCONNECT,
+            });
         }
         this.sendMediaStateMachineEvt({ type: 'E_ROAP_TEARDOWN' });
         this.sendCallStateMachineEvt({ type: 'E_CALL_CLEARED' });
     }
     handleCallEstablished(event) {
-        log.info(`handleCallEstablished: ${this.getCorrelationId()}  `, {
+        log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, {
             file: CALL_FILE,
-            method: this.handleCallEstablished.name,
+            method: METHODS.HANDLE_CALL_ESTABLISHED,
         });
         this.emit(CALL_EVENT_KEYS.ESTABLISHED, this.correlationId);
         this.earlyMedia = false;
@@ -933,7 +962,7 @@ export class Call extends Eventing {
         if (this.sessionTimer) {
             log.log('Resetting session timer', {
                 file: CALL_FILE,
-                method: 'handleCallEstablished',
+                method: METHODS.HANDLE_CALL_ESTABLISHED,
             });
             clearInterval(this.sessionTimer);
         }
@@ -942,7 +971,7 @@ export class Call extends Eventing {
                 const res = await this.postStatus();
                 log.info(`Session refresh successful`, {
                     file: CALL_FILE,
-                    method: 'handleCallEstablished',
+                    method: METHODS.HANDLE_CALL_ESTABLISHED,
                 });
             }
             catch (err) {
@@ -959,7 +988,7 @@ export class Call extends Eventing {
                         this.sendCallStateMachineEvt({ type: 'E_CALL_ESTABLISHED' });
                     }, interval * 1000);
                 }, this.getCorrelationId(), error, this.handleCallEstablished.name, CALL_FILE);
-                uploadLogs({
+                await uploadLogs({
                     correlationId: this.correlationId,
                     callId: this.callId,
                 });
@@ -967,15 +996,15 @@ export class Call extends Eventing {
         }, DEFAULT_SESSION_TIMER);
     }
     async handleUnknownState(event) {
-        log.info(`handleUnknownState: ${this.getCorrelationId()}  `, {
+        log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, {
             file: CALL_FILE,
-            method: this.handleUnknownState.name,
+            method: METHODS.HANDLE_UNKNOWN_STATE,
         });
         const eventData = event.data;
         if (!eventData?.media) {
             log.warn('Call failed due to signalling issue', {
                 file: CALL_FILE,
-                method: this.handleUnknownState.name,
+                method: METHODS.HANDLE_UNKNOWN_STATE,
             });
         }
         try {
@@ -983,13 +1012,13 @@ export class Call extends Eventing {
             const response = await this.delete();
             log.log(`handleOutgoingCallDisconnect: Response code: ${response.statusCode}`, {
                 file: CALL_FILE,
-                method: this.handleUnknownState.name,
+                method: METHODS.HANDLE_UNKNOWN_STATE,
             });
         }
         catch (e) {
             log.warn('Failed to delete the call', {
                 file: CALL_FILE,
-                method: this.handleUnknownState.name,
+                method: METHODS.HANDLE_UNKNOWN_STATE,
             });
         }
         this.deleteCb(this.correlationId);
@@ -1000,7 +1029,7 @@ export class Call extends Eventing {
             this.mediaConnection.close();
             log.info('Closing media channel', {
                 file: CALL_FILE,
-                method: this.handleUnknownState.name,
+                method: METHODS.HANDLE_UNKNOWN_STATE,
             });
         }
         this.sendMediaStateMachineEvt({ type: 'E_ROAP_TEARDOWN' });
@@ -1033,31 +1062,31 @@ export class Call extends Eventing {
         };
     }
     async handleRoapEstablished(context, event) {
-        log.info(`handleRoapEstablished: ${this.getCorrelationId()}  `, {
+        log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, {
             file: CALL_FILE,
-            method: 'handleRoapEstablished',
+            method: METHODS.HANDLE_ROAP_ESTABLISHED,
         });
         const { received, message } = event.data;
         this.receivedRoapOKSeq = message.seq;
         if (!received) {
             log.info('Sending Media Ok to the remote End', {
                 file: CALL_FILE,
-                method: 'handleRoapEstablished',
+                method: METHODS.HANDLE_ROAP_ESTABLISHED,
             });
             try {
                 if (this.callStateMachine.state.value === 'S_RECV_CALL_PROGRESS' ||
                     this.callStateMachine.state.value === 'S_SEND_CALL_SETUP') {
                     log.info('Media negotiation completed before call connect. Setting media negotiation completed flag.', {
                         file: CALL_FILE,
-                        method: 'handleRoapEstablished',
+                        method: METHODS.HANDLE_ROAP_ESTABLISHED,
                     });
                     this.mediaNegotiationCompleted = true;
                 }
                 message.seq = this.seq;
                 const res = await this.postMedia(message);
-                log.log(`handleRoapEstablished: Response code: ${res.statusCode}`, {
+                log.log(`Response code: ${res.statusCode}`, {
                     file: CALL_FILE,
-                    method: 'handleRoapEstablished',
+                    method: METHODS.HANDLE_ROAP_ESTABLISHED,
                 });
                 if (!this.earlyMedia && !this.mediaNegotiationCompleted) {
                     this.sendCallStateMachineEvt({ type: 'E_CALL_ESTABLISHED' });
@@ -1066,7 +1095,7 @@ export class Call extends Eventing {
             catch (err) {
                 log.warn('Failed to process MediaOk request', {
                     file: CALL_FILE,
-                    method: 'handleRoapEstablished',
+                    method: METHODS.HANDLE_ROAP_ESTABLISHED,
                 });
                 const errData = err;
                 handleCallErrors(this.getEmitterCallback(errData), ERROR_LAYER.MEDIA, (interval) => {
@@ -1076,7 +1105,7 @@ export class Call extends Eventing {
                         }, interval * 1000);
                     }
                 }, this.getCorrelationId(), errData, this.handleRoapEstablished.name, CALL_FILE);
-                uploadLogs({
+                await uploadLogs({
                     correlationId: this.correlationId,
                     callId: this.callId,
                 });
@@ -1085,7 +1114,7 @@ export class Call extends Eventing {
         else {
             log.info('Notifying internal-media-core about ROAP OK message', {
                 file: CALL_FILE,
-                method: 'handleRoapEstablished',
+                method: METHODS.HANDLE_ROAP_ESTABLISHED,
             });
             message.seq = this.seq;
             if (this.mediaConnection) {
@@ -1108,9 +1137,9 @@ export class Call extends Eventing {
         }
     }
     async handleRoapError(context, event) {
-        log.info(`handleRoapError: ${this.getCorrelationId()}`, {
+        log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, {
             file: CALL_FILE,
-            method: this.handleRoapError.name,
+            method: METHODS.HANDLE_ROAP_ERROR,
         });
         const message = event.data;
         if (message) {
@@ -1118,20 +1147,20 @@ export class Call extends Eventing {
                 const res = await this.postMedia(message);
                 log.info(`Response code: ${res.statusCode}`, {
                     file: CALL_FILE,
-                    method: this.handleRoapError.name,
+                    method: METHODS.HANDLE_ROAP_ERROR,
                 });
             }
             catch (err) {
                 log.warn('Failed to communicate ROAP error to Webex Calling', {
                     file: CALL_FILE,
-                    method: this.handleRoapError.name,
+                    method: METHODS.HANDLE_ROAP_ERROR,
                 });
                 const errData = err;
                 handleCallErrors((error) => {
                     this.emit(CALL_EVENT_KEYS.CALL_ERROR, error);
                     this.submitCallErrorMetric(error);
                 }, ERROR_LAYER.MEDIA, (interval) => undefined, this.getCorrelationId(), errData, this.handleRoapError.name, CALL_FILE);
-                uploadLogs({
+                await uploadLogs({
                     correlationId: this.correlationId,
                     callId: this.callId,
                 });
@@ -1140,15 +1169,15 @@ export class Call extends Eventing {
         if (!this.connected) {
             log.warn('Call failed due to media issue', {
                 file: CALL_FILE,
-                method: 'handleRoapError',
+                method: METHODS.HANDLE_ROAP_ERROR,
             });
             this.sendCallStateMachineEvt({ type: 'E_UNKNOWN', data: { media: true } });
         }
     }
     async handleOutgoingRoapOffer(context, event) {
-        log.info(`handleOutgoingRoapOffer: ${this.getCorrelationId()}`, {
+        log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, {
             file: CALL_FILE,
-            method: this.handleOutgoingRoapOffer.name,
+            method: METHODS.HANDLE_OUTGOING_ROAP_OFFER,
         });
         const message = event.data;
         if (!message?.sdp) {
@@ -1179,16 +1208,16 @@ export class Call extends Eventing {
                     }, interval * 1000);
                 }
             }, this.getCorrelationId(), errData, this.handleOutgoingRoapOffer.name, CALL_FILE);
-            uploadLogs({
+            await uploadLogs({
                 correlationId: this.correlationId,
                 callId: this.callId,
             });
         }
     }
     async handleOutgoingRoapAnswer(context, event) {
-        log.info(`handleOutgoingRoapAnswer: ${this.getCorrelationId()}`, {
+        log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, {
             file: CALL_FILE,
-            method: this.handleOutgoingRoapAnswer.name,
+            method: METHODS.HANDLE_OUTGOING_ROAP_ANSWER,
         });
         const message = event.data;
         try {
@@ -1212,16 +1241,16 @@ export class Call extends Eventing {
                     }, interval * 1000);
                 }
             }, this.getCorrelationId(), errData, this.handleOutgoingRoapAnswer.name, CALL_FILE);
-            uploadLogs({
+            await uploadLogs({
                 correlationId: this.correlationId,
                 callId: this.callId,
             });
         }
     }
     handleIncomingRoapOffer(context, event) {
-        log.info(`handleIncomingRoapOffer: ${this.getCorrelationId()}`, {
+        log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, {
             file: CALL_FILE,
-            method: this.handleIncomingRoapOffer.name,
+            method: METHODS.HANDLE_INCOMING_ROAP_OFFER,
         });
         const message = event.data;
         this.remoteRoapMessage = message;
@@ -1255,9 +1284,9 @@ export class Call extends Eventing {
         }
     }
     handleIncomingRoapAnswer(context, event) {
-        log.info(`handleIncomingRoapAnswer: ${this.getCorrelationId()}`, {
+        log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, {
             file: CALL_FILE,
-            method: this.handleIncomingRoapAnswer.name,
+            method: METHODS.HANDLE_INCOMING_ROAP_ANSWER,
         });
         const message = event.data;
         this.remoteRoapMessage = message;
@@ -1269,7 +1298,7 @@ export class Call extends Eventing {
     forceSendStatsReport = async ({ callFrom }) => {
         const loggerContext = {
             file: CALL_FILE,
-            method: this.forceSendStatsReport.name,
+            method: METHODS.FORCE_SEND_STATS_REPORT,
         };
         try {
             await this.mediaConnection.forceRtcMetricsSend();
@@ -1281,6 +1310,10 @@ export class Call extends Eventing {
             const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
             const errorLog = new Error(`Failed to upload webrtc telemetry statistics. ${errorStatus}`);
             log.error(errorLog, loggerContext);
+            await uploadLogs({
+                correlationId: this.correlationId,
+                callId: this.callId,
+            });
         }
     };
     initMediaConnection(localAudioTrack, debugId) {
@@ -1317,8 +1350,10 @@ export class Call extends Eventing {
         this.rtcMetrics.updateCallId(callId);
         log.info(`Setting callId : ${this.callId} for correlationId: ${this.correlationId}`, {
             file: CALL_FILE,
-            method: this.setCallId.name,
+            method: METHODS.SET_CALL_ID,
         });
+        this.callId = callId;
+        this.rtcMetrics.updateCallId(callId);
     };
     setDisconnectReason() {
         if (this.mediaInactivity) {
@@ -1338,12 +1373,16 @@ export class Call extends Eventing {
         return this.disconnectReason;
     };
     async answer(localAudioStream) {
+        log.info(`${METHOD_START_MESSAGE} with stream`, {
+            file: CALL_FILE,
+            method: METHODS.ANSWER,
+        });
         this.localAudioStream = localAudioStream;
         const localAudioTrack = localAudioStream.outputStream.getAudioTracks()[0];
         if (!localAudioTrack) {
             log.warn(`Did not find a local track while answering the call ${this.getCorrelationId()}`, {
                 file: CALL_FILE,
-                method: 'answer',
+                method: METHODS.ANSWER,
             });
             this.mediaInactivity = true;
             this.sendCallStateMachineEvt({ type: 'E_SEND_CALL_DISCONNECT' });
@@ -1360,16 +1399,20 @@ export class Call extends Eventing {
             this.sendCallStateMachineEvt({ type: 'E_SEND_CALL_CONNECT' });
         }
         else {
-            log.warn(`Call cannot be answered because the state is : ${this.callStateMachine.state.value}`, { file: CALL_FILE, method: 'answer' });
+            log.warn(`Call cannot be answered because the state is : ${this.callStateMachine.state.value}`, { file: CALL_FILE, method: METHODS.ANSWER });
         }
     }
     async dial(localAudioStream) {
+        log.info(`${METHOD_START_MESSAGE} with stream`, {
+            file: CALL_FILE,
+            method: METHODS.DIAL,
+        });
         this.localAudioStream = localAudioStream;
         const localAudioTrack = localAudioStream.outputStream.getAudioTracks()[0];
         if (!localAudioTrack) {
             log.warn(`Did not find a local track while dialing the call ${this.getCorrelationId()}`, {
                 file: CALL_FILE,
-                method: 'dial',
+                method: METHODS.DIAL,
             });
             this.deleteCb(this.getCorrelationId());
             this.emit(CALL_EVENT_KEYS.DISCONNECT, this.getCorrelationId());
@@ -1386,7 +1429,7 @@ export class Call extends Eventing {
             this.sendMediaStateMachineEvt({ type: 'E_SEND_ROAP_OFFER' });
         }
         else {
-            log.warn(`Call cannot be dialed because the state is already : ${this.mediaStateMachine.state.value}`, { file: CALL_FILE, method: 'dial' });
+            log.warn(`Call cannot be dialed because the state is already : ${this.mediaStateMachine.state.value}`, { file: CALL_FILE, method: METHODS.DIAL });
         }
     }
     post = async (roapMessage) => {
@@ -1533,7 +1576,7 @@ export class Call extends Eventing {
                     this.emit(CALL_EVENT_KEYS.TRANSFER_ERROR, error);
                     this.submitCallErrorMetric(error, TRANSFER_ACTION.BLIND);
                 }, ERROR_LAYER.CALL_CONTROL, (interval) => undefined, this.getCorrelationId(), errData, this.completeTransfer.name, CALL_FILE);
-                uploadLogs({
+                await uploadLogs({
                     correlationId: this.correlationId,
                     callId: this.callId,
                 });
@@ -1562,7 +1605,7 @@ export class Call extends Eventing {
                     this.emit(CALL_EVENT_KEYS.TRANSFER_ERROR, error);
                     this.submitCallErrorMetric(error, TRANSFER_ACTION.CONSULT);
                 }, ERROR_LAYER.CALL_CONTROL, (interval) => undefined, this.getCorrelationId(), errData, this.completeTransfer.name, CALL_FILE);
-                uploadLogs({
+                await uploadLogs({
                     correlationId: this.correlationId,
                     callId: this.callId,
                 });
@@ -1583,7 +1626,7 @@ export class Call extends Eventing {
         catch (err) {
             log.warn('Stats collection failed, using dummy stats', {
                 file: CALL_FILE,
-                method: this.getCallStats.name,
+                method: METHODS.GET_CALL_STATS,
             });
         }
         return parseMediaQualityStatistics(stats);
@@ -1591,7 +1634,7 @@ export class Call extends Eventing {
     async postMedia(roapMessage) {
         log.log('Posting message to Webex Calling', {
             file: CALL_FILE,
-            method: this.postMedia.name,
+            method: METHODS.POST_MEDIA,
         });
         return this.webex.request({
             uri: `${this.mobiusUrl}${DEVICES_ENDPOINT_RESOURCE}/${this.deviceId}/${CALLS_ENDPOINT_RESOURCE}/${this.callId}/${MEDIA_ENDPOINT_RESOURCE}`,
@@ -1617,10 +1660,10 @@ export class Call extends Eventing {
     mediaRoapEventsListener() {
         this.mediaConnection.on(MediaConnectionEventNames.ROAP_MESSAGE_TO_SEND, async (event) => {
             log.info(`ROAP message to send (rcv from MEDIA-SDK) :
-          \n type:  ${event.roapMessage?.messageType}, seq: ${event.roapMessage.seq} , version: ${event.roapMessage.version}`, {});
+          \n type:  ${event.roapMessage?.messageType}, seq: ${event.roapMessage.seq} , version: ${event.roapMessage.version}`, { file: CALL_FILE, method: METHODS.MEDIA_ROAP_EVENTS_LISTENER });
             log.info(`SDP message to send : \n ${event.roapMessage?.sdp}`, {
                 file: CALL_FILE,
-                method: this.mediaRoapEventsListener.name,
+                method: METHODS.MEDIA_ROAP_EVENTS_LISTENER,
             });
             switch (event.roapMessage.messageType) {
                 case RoapScenario.OK: {
@@ -1748,7 +1791,7 @@ export class Call extends Eventing {
             case MidCallEventType.CALL_INFO: {
                 log.log(`Received Midcall CallInfo Event for correlationId : ${this.correlationId}`, {
                     file: CALL_FILE,
-                    method: 'handleMidCallEvent',
+                    method: METHODS.HANDLE_MID_CALL_EVENT,
                 });
                 const callerData = eventData;
                 this.startCallerIdResolution(callerData.callerId);
@@ -1757,14 +1800,14 @@ export class Call extends Eventing {
             case MidCallEventType.CALL_STATE: {
                 log.log(`Received Midcall call event for correlationId : ${this.correlationId}`, {
                     file: CALL_FILE,
-                    method: 'handleMidCallEvent',
+                    method: METHODS.HANDLE_MID_CALL_EVENT,
                 });
                 const data = eventData;
                 switch (data.callState) {
                     case MOBIUS_MIDCALL_STATE.HELD: {
                         log.log(`Call is successfully held : ${this.correlationId}`, {
                             file: CALL_FILE,
-                            method: 'handleMidCallEvent',
+                            method: METHODS.HANDLE_MID_CALL_EVENT,
                         });
                         this.emit(CALL_EVENT_KEYS.HELD, this.correlationId);
                         this.held = true;
@@ -1777,7 +1820,7 @@ export class Call extends Eventing {
                     case MOBIUS_MIDCALL_STATE.CONNECTED: {
                         log.log(`Call is successfully resumed : ${this.correlationId}`, {
                             file: CALL_FILE,
-                            method: 'handleMidCallEvent',
+                            method: METHODS.HANDLE_MID_CALL_EVENT,
                         });
                         this.emit(CALL_EVENT_KEYS.RESUMED, this.correlationId);
                         this.held = false;
@@ -1790,7 +1833,7 @@ export class Call extends Eventing {
                     default: {
                         log.warn(`Unknown Supplementary service state: ${data.callState} for correlationId : ${this.correlationId}`, {
                             file: CALL_FILE,
-                            method: 'handleMidCallEvent',
+                            method: METHODS.HANDLE_MID_CALL_EVENT,
                         });
                     }
                 }
@@ -1799,13 +1842,17 @@ export class Call extends Eventing {
             default: {
                 log.warn(`Unknown Midcall type: ${eventType} for correlationId : ${this.correlationId}`, {
                     file: CALL_FILE,
-                    method: 'handleMidCallEvent',
+                    method: METHODS.HANDLE_MID_CALL_EVENT,
                 });
             }
         }
     }
     getCallerInfo = () => this.callerInfo;
     end = () => {
+        log.info(`${METHOD_START_MESSAGE}`, {
+            file: CALL_FILE,
+            method: METHODS.END,
+        });
         this.sendCallStateMachineEvt({ type: 'E_SEND_CALL_DISCONNECT' });
     };
     doHoldResume = () => {
@@ -1820,25 +1867,29 @@ export class Call extends Eventing {
         this.callerInfo = this.callerId.fetchCallerDetails(callerInfo);
     }
     sendDigit(tone) {
+        log.info(`${METHOD_START_MESSAGE} with: ${tone}`, {
+            file: CALL_FILE,
+            method: METHODS.SEND_DIGIT,
+        });
         try {
-            log.info(`Sending digit : ${tone}`, {
-                file: CALL_FILE,
-                method: 'sendDigit',
-            });
             this.mediaConnection.insertDTMF(tone);
         }
         catch (e) {
             log.warn(`Unable to send digit on call: ${e.message}`, {
                 file: CALL_FILE,
-                method: 'sendDigit',
+                method: METHODS.SEND_DIGIT,
             });
         }
     }
     mute = (localAudioStream, muteType) => {
+        log.info(`${METHOD_START_MESSAGE} with: ${muteType || 'user mute'}`, {
+            file: CALL_FILE,
+            method: METHODS.MUTE,
+        });
         if (!localAudioStream) {
             log.warn(`Did not find a local stream while muting the call ${this.getCorrelationId()}.`, {
                 file: CALL_FILE,
-                method: 'mute',
+                method: METHODS.MUTE,
             });
             return;
         }
@@ -1849,7 +1900,7 @@ export class Call extends Eventing {
             else {
                 log.info(`Call is muted by the user already - ${this.getCorrelationId()}.`, {
                     file: CALL_FILE,
-                    method: 'mute',
+                    method: METHODS.MUTE,
                 });
             }
         }
@@ -1860,7 +1911,7 @@ export class Call extends Eventing {
         else {
             log.info(`Call is muted on the system - ${this.getCorrelationId()}.`, {
                 file: CALL_FILE,
-                method: 'mute',
+                method: METHODS.MUTE,
             });
         }
     };
@@ -1869,7 +1920,7 @@ export class Call extends Eventing {
         if (!localAudioTrack) {
             log.warn(`Did not find a local track while updating media for call ${this.getCorrelationId()}. Will not update media`, {
                 file: CALL_FILE,
-                method: 'updateMedia',
+                method: METHODS.UPDATE_MEDIA,
             });
             return;
         }
@@ -1884,7 +1935,7 @@ export class Call extends Eventing {
         catch (e) {
             log.warn(`Unable to update media on call ${this.getCorrelationId()}. Error: ${e.message}`, {
                 file: CALL_FILE,
-                method: 'updateMedia',
+                method: METHODS.UPDATE_MEDIA,
             });
         }
     };
@@ -1900,14 +1951,14 @@ export class Call extends Eventing {
     async handleTimeout() {
         log.warn(`Call timed out`, {
             file: CALL_FILE,
-            method: 'handleTimeout',
+            method: METHODS.HANDLE_TIMEOUT,
         });
         this.deleteCb(this.getCorrelationId());
         this.emit(CALL_EVENT_KEYS.DISCONNECT, this.getCorrelationId());
         const response = await this.delete();
-        log.log(`handleTimeout: Response code: ${response.statusCode}`, {
+        log.log(`Response code: ${response.statusCode}`, {
             file: CALL_FILE,
-            method: this.handleTimeout.name,
+            method: METHODS.HANDLE_TIMEOUT,
         });
     }
 }