@webex/calling 3.8.0-next.32 → 3.8.0-next.33

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

@@ -124,3 +124,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);
         });

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

@@ -1,12 +1,13 @@
 import { v4 as uuid } from 'uuid';
-import { emitFinalFailure, handleRegistrationErrors } from '../../common';
+import { METHOD_START_MESSAGE } from '../../common/constants';
+import { emitFinalFailure, handleRegistrationErrors, uploadLogs } from '../../common';
 import { METRIC_EVENT, METRIC_TYPE, REG_ACTION } from '../../Metrics/types';
 import { getMetricManager } from '../../Metrics';
 import { getCallManager } from '../calling';
 import log from '../../Logger';
 import SDKConnector from '../../SDKConnector';
 import { ALLOWED_SERVICES, HTTP_METHODS, RegistrationStatus, ServiceIndicator, } from '../../common/types';
-import { CALLING_USER_AGENT, CISCO_DEVICE_URL, DEVICES_ENDPOINT_RESOURCE, SPARK_USER_AGENT, WEBEX_WEB_CLIENT, BASE_REG_RETRY_TIMER_VAL_IN_SEC, BASE_REG_TIMER_MFACTOR, SEC_TO_MSEC_MFACTOR, REG_RANDOM_T_FACTOR_UPPER_LIMIT, REG_TRY_BACKUP_TIMER_VAL_IN_SEC, MINUTES_TO_SEC_MFACTOR, REG_429_RETRY_UTIL, REG_FAILBACK_429_MAX_RETRIES, FAILBACK_UTIL, REGISTRATION_FILE, DEFAULT_REHOMING_INTERVAL_MIN, DEFAULT_REHOMING_INTERVAL_MAX, DEFAULT_KEEPALIVE_INTERVAL, REG_TRY_BACKUP_TIMER_VAL_FOR_CC_IN_SEC, FAILOVER_UTIL, REGISTER_UTIL, RETRY_TIMER_UPPER_LIMIT, } from '../constants';
+import { CALLING_USER_AGENT, CISCO_DEVICE_URL, DEVICES_ENDPOINT_RESOURCE, SPARK_USER_AGENT, WEBEX_WEB_CLIENT, BASE_REG_RETRY_TIMER_VAL_IN_SEC, BASE_REG_TIMER_MFACTOR, SEC_TO_MSEC_MFACTOR, REG_RANDOM_T_FACTOR_UPPER_LIMIT, REG_TRY_BACKUP_TIMER_VAL_IN_SEC, MINUTES_TO_SEC_MFACTOR, REG_429_RETRY_UTIL, REG_FAILBACK_429_MAX_RETRIES, FAILBACK_UTIL, REGISTRATION_FILE, DEFAULT_REHOMING_INTERVAL_MIN, DEFAULT_REHOMING_INTERVAL_MAX, DEFAULT_KEEPALIVE_INTERVAL, REG_TRY_BACKUP_TIMER_VAL_FOR_CC_IN_SEC, FAILOVER_UTIL, REGISTER_UTIL, RETRY_TIMER_UPPER_LIMIT, METHODS, } from '../constants';
 import { LINE_EVENTS } from '../line/types';
 export class Registration {
     sdkConnector;
@@ -60,11 +61,15 @@ export class Registration {
         return this.activeMobiusUrl;
     }
     setActiveMobiusUrl(url) {
-        log.info(`ActiveMobiusUrl: ${url}`, { method: 'setActiveMobiusUrl', file: REGISTRATION_FILE });
+        log.info(`${METHOD_START_MESSAGE} with ${url}`, {
+            method: METHODS.UPDATE_ACTIVE_MOBIUS,
+            file: REGISTRATION_FILE,
+        });
         this.activeMobiusUrl = url;
         this.callManager.updateActiveMobius(url);
     }
     setMobiusServers(primaryMobiusUris, backupMobiusUris) {
+        log.log(METHOD_START_MESSAGE, { method: METHODS.SET_MOBIUS_SERVERS, file: REGISTRATION_FILE });
         this.primaryMobiusUris = primaryMobiusUris;
         this.backupMobiusUris = backupMobiusUris;
     }
@@ -93,7 +98,10 @@ export class Registration {
             });
         }
         catch (error) {
-            log.warn(`Delete failed with Mobius`, {});
+            log.warn(`Delete failed with Mobius ${error}`, {
+                file: REGISTRATION_FILE,
+                method: METHODS.DEREGISTER,
+            });
         }
         this.setStatus(RegistrationStatus.INACTIVE);
         this.lineEmitter(LINE_EVENTS.UNREGISTERED);
@@ -187,7 +195,7 @@ export class Registration {
             log.log(`Scheduled retry with primary in ${interval} seconds, number of attempts : ${attempt}`, loggerContext);
         }
         else if (this.backupMobiusUris.length) {
-            log.log('Failing over to backup servers.', loggerContext);
+            log.info('Failing over to backup servers.', loggerContext);
             this.failoverImmediately = false;
             abort = await this.attemptRegistrationWithServers(FAILOVER_UTIL, this.backupMobiusUris);
             if (!abort && !this.isDeviceRegistered()) {
@@ -199,6 +207,7 @@ export class Registration {
                     await this.mutex.runExclusive(async () => {
                         abort = await this.attemptRegistrationWithServers(FAILOVER_UTIL, this.backupMobiusUris);
                         if (!abort && !this.isDeviceRegistered()) {
+                            await uploadLogs();
                             emitFinalFailure((clientError) => {
                                 this.lineEmitter(LINE_EVENTS.ERROR, undefined, clientError);
                             }, loggerContext);
@@ -209,6 +218,7 @@ export class Registration {
             }
         }
         else {
+            await uploadLogs();
             emitFinalFailure((clientError) => {
                 this.lineEmitter(LINE_EVENTS.ERROR, undefined, clientError);
             }, loggerContext);
@@ -315,9 +325,13 @@ export class Registration {
         }
     }
     async handleConnectionRestoration(retry) {
+        log.info(METHOD_START_MESSAGE, {
+            method: METHODS.HANDLE_CONNECTION_RESTORATION,
+            file: REGISTRATION_FILE,
+        });
         await this.mutex.runExclusive(async () => {
             if (retry) {
-                log.info('Mercury connection is up again, re-registering with Webex Calling if needed', {
+                log.log('Mercury connection is up again, re-registering with Webex Calling if needed', {
                     file: REGISTRATION_FILE,
                     method: this.handleConnectionRestoration.name,
                 });
@@ -375,7 +389,7 @@ export class Registration {
             return abort;
         }
         if (this.isDeviceRegistered()) {
-            log.log(`[${caller}] : Device already registered with : ${this.activeMobiusUrl}`, {
+            log.info(`[${caller}] : Device already registered with : ${this.activeMobiusUrl}`, {
                 file: REGISTRATION_FILE,
                 method: REGISTER_UTIL,
             });
@@ -386,7 +400,7 @@ export class Registration {
                 abort = false;
                 this.registrationStatus = RegistrationStatus.INACTIVE;
                 this.lineEmitter(LINE_EVENTS.CONNECTING);
-                log.log(`[${caller}] : Mobius url to contact: ${url}`, {
+                log.info(`[${caller}] : Mobius url to contact: ${url}`, {
                     file: REGISTRATION_FILE,
                     method: REGISTER_UTIL,
                 });
@@ -394,6 +408,10 @@ export class Registration {
                 this.deviceInfo = resp.body;
                 this.registrationStatus = RegistrationStatus.ACTIVE;
                 this.lineEmitter(LINE_EVENTS.REGISTERED, resp.body);
+                log.log(`Registration successful for deviceId: ${this.deviceInfo.device?.deviceId} userId: ${this.userId}`, {
+                    file: REGISTRATION_FILE,
+                    method: METHODS.REGISTER,
+                });
                 this.setActiveMobiusUrl(url);
                 this.setIntervalValues(this.deviceInfo);
                 this.metricManager.setDeviceInfo(this.deviceInfo);
@@ -441,7 +459,7 @@ export class Registration {
                 if (this.isDeviceRegistered() && keepAliveRetryCount < RETRY_COUNT_THRESHOLD) {
                     try {
                         const res = await this.postKeepAlive(url);
-                        log.info(`Sent Keepalive, status: ${res.statusCode}`, logContext);
+                        log.log(`Sent Keepalive, status: ${res.statusCode}`, logContext);
                         if (keepAliveRetryCount > 0) {
                             this.lineEmitter(LINE_EVENTS.RECONNECTED);
                         }
@@ -487,9 +505,16 @@ export class Registration {
     async deregister() {
         try {
             await this.deleteRegistration(this.activeMobiusUrl, this.deviceInfo.device?.deviceId, this.deviceInfo.device?.clientDeviceUri);
+            log.log('Registration successfully deregistered', {
+                file: REGISTRATION_FILE,
+                method: METHODS.DEREGISTER,
+            });
         }
         catch (err) {
-            log.warn(`Delete failed with Mobius`, {});
+            log.warn(`Delete failed with Mobius: ${err}`, {
+                file: REGISTRATION_FILE,
+                method: METHODS.DEREGISTER,
+            });
         }
         this.clearKeepaliveTimer();
         this.setStatus(RegistrationStatus.INACTIVE);
@@ -518,6 +543,7 @@ export class Registration {
         return false;
     }
     async reconnectOnFailure(caller) {
+        log.info(METHOD_START_MESSAGE, { method: METHODS.RECONNECT_ON_FAILURE, file: REGISTRATION_FILE });
         this.reconnectPending = false;
         if (!this.isDeviceRegistered()) {
             if (Object.keys(this.callManager.getActiveCalls()).length === 0) {
@@ -530,7 +556,7 @@ export class Registration {
                 this.reconnectPending = true;
                 log.info('Active call(s) present, deferred reconnect till call cleanup.', {
                     file: REGISTRATION_FILE,
-                    method: this.reconnectOnFailure.name,
+                    method: METHODS.RECONNECT_ON_FAILURE,
                 });
             }
         }