fix(calling): update call keepalive retry logic

packages/calling/src/CallingClient/calling/call.test.ts

@@ -977,6 +977,34 @@ describe('State Machine handler tests', () => {
     );
   });
 
+  it('session refresh 401 emits token error and ends the call', async () => {
+    expect.assertions(4);
+    const statusPayload = <WebexRequestPayload>(<unknown>{
+      statusCode: 401,
+    });
+
+    webex.request.mockReturnValue(statusPayload);
+    jest.spyOn(global, 'clearInterval');
+
+    const emitSpy = jest.spyOn(call, 'emit');
+
+    call.on(CALL_EVENT_KEYS.CALL_ERROR, (errObj) => {
+      expect(errObj.type).toStrictEqual(ERROR_TYPE.TOKEN_ERROR);
+    });
+
+    const funcSpy = jest.spyOn(call, 'postStatus').mockRejectedValue(statusPayload);
+
+    call['handleCallEstablished']({} as CallEvent);
+
+    jest.advanceTimersByTime(DEFAULT_SESSION_TIMER);
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(clearInterval).toHaveBeenCalledTimes(1);
+    expect(funcSpy).toBeCalledTimes(1);
+    expect(emitSpy).toHaveBeenCalledWith(CALL_EVENT_KEYS.DISCONNECT, call.getCorrelationId());
+  });
+
   it('session refresh failure', async () => {
     expect.assertions(4);
     const statusPayload = <WebexRequestPayload>(<unknown>{
@@ -1015,6 +1043,86 @@ describe('State Machine handler tests', () => {
     expect(funcSpy).toBeCalledTimes(1);
   });
 
+  it('session refresh 500 schedules retry via retry-after or default interval', async () => {
+    const errorPayload = <WebexRequestPayload>(<unknown>{
+      statusCode: 500,
+      headers: {
+        'retry-after': 1,
+      },
+    });
+
+    const okPayload = <WebexRequestPayload>(<unknown>{statusCode: 200, body: {}});
+
+    const sendEvtSpy = jest.spyOn(call as any, 'sendCallStateMachineEvt');
+    const postStatusSpy = jest
+      .spyOn(call as any, 'postStatus')
+      .mockRejectedValueOnce(errorPayload)
+      .mockResolvedValueOnce(okPayload);
+
+    if (call['sessionTimer'] === undefined) {
+      call['handleCallEstablished']({} as CallEvent);
+    }
+
+    jest.advanceTimersByTime(DEFAULT_SESSION_TIMER);
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(postStatusSpy).toHaveBeenCalledTimes(1);
+    expect(sendEvtSpy).toHaveBeenCalledWith({type: 'E_CALL_ESTABLISHED'});
+  });
+
+  it('keepalive ends after reaching max retry count', async () => {
+    const resolvePromise = async () => {
+      await Promise.resolve();
+      await Promise.resolve();
+    };
+
+    const errorPayload = <WebexRequestPayload>(<unknown>{
+      statusCode: 500,
+      headers: {
+        'retry-after': 1,
+      },
+    });
+
+    jest.spyOn(global, 'clearInterval');
+    const warnSpy = jest.spyOn(log, 'warn');
+    const postStatusSpy = jest.spyOn(call, 'postStatus').mockRejectedValue(errorPayload);
+
+    // Put the call in the S_CALL_ESTABLISHED state and set it as connected
+    call['callStateMachine'].state.value = 'S_CALL_ESTABLISHED';
+    call['connected'] = true;
+
+    // Call handleCallEstablished which will setup interval
+    call['handleCallEstablished']({} as CallEvent);
+
+    // Advance timer to trigger the first failure (uses DEFAULT_SESSION_TIMER)
+    jest.advanceTimersByTime(DEFAULT_SESSION_TIMER);
+    await resolvePromise();
+
+    // Now advance by 1 second for each of the 3 more retry attempts (retry-after: 1 second each)
+    // Need to do this separately to allow state machine to process and create new intervals
+    jest.advanceTimersByTime(1000);
+    await resolvePromise();
+
+    jest.advanceTimersByTime(1000);
+    await resolvePromise();
+
+    jest.advanceTimersByTime(1000);
+    await resolvePromise();
+
+    // The error handler should detect we're at max retry count and stop
+    expect(warnSpy).toHaveBeenCalledWith(
+      `Max call keepalive retry attempts reached for call: ${call.getCorrelationId()}`,
+      {
+        file: 'call',
+        method: 'handleCallEstablished',
+      }
+    );
+    expect(postStatusSpy).toHaveBeenCalledTimes(4);
+    expect(call['callKeepaliveRetryCount']).toBe(0);
+    expect(call['sessionTimer']).toBeUndefined();
+  });
+
   it('state changes during successful incoming call', async () => {
     const statusPayload = <WebexRequestPayload>(<unknown>{
       statusCode: 200,

packages/calling/src/CallingClient/calling/call.ts

@@ -45,6 +45,7 @@ import {
   HOLD_ENDPOINT,
   ICE_CANDIDATES_TIMEOUT,
   INITIAL_SEQ_NUMBER,
+  MAX_CALL_KEEPALIVE_RETRY_COUNT,
   MEDIA_ENDPOINT_RESOURCE,
   METHODS,
   NOISE_REDUCTION_EFFECT,
@@ -169,6 +170,10 @@ export class Call extends Eventing<CallEventTypes> implements ICall {
 
   private rtcMetrics: RtcMetrics;
 
+  private callKeepaliveRetryCount = 0;
+
+  private callKeepaliveInterval?: number;
+
   /**
    * Getter to check if the call is muted or not.
    *
@@ -1501,10 +1506,12 @@ export class Call extends Eventing<CallEventTypes> implements ICall {
    */
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   private handleCallEstablished(event: CallEvent) {
-    log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, {
+    const loggerContext = {
       file: CALL_FILE,
       method: METHODS.HANDLE_CALL_ESTABLISHED,
-    });
+    };
+
+    log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, loggerContext);
 
     this.emit(CALL_EVENT_KEYS.ESTABLISHED, this.correlationId);
 
@@ -1515,22 +1522,19 @@ export class Call extends Eventing<CallEventTypes> implements ICall {
 
     /* Session timers need to be reset at all offer/answer exchanges */
     if (this.sessionTimer) {
-      log.log('Resetting session timer', {
-        file: CALL_FILE,
-        method: METHODS.HANDLE_CALL_ESTABLISHED,
-      });
+      log.log('Resetting session timer', loggerContext);
+
       clearInterval(this.sessionTimer);
     }
 
     this.sessionTimer = setInterval(async () => {
       try {
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         const res = await this.postStatus();
+        this.callKeepaliveRetryCount = 0;
+        this.callKeepaliveInterval = undefined;
 
-        log.info(`Session refresh successful`, {
-          file: CALL_FILE,
-          method: METHODS.HANDLE_CALL_ESTABLISHED,
-        });
+        log.info(`Session refresh successful`, loggerContext);
       } catch (err: unknown) {
         const error = <WebexRequestPayload>err;
 
@@ -1544,34 +1548,54 @@ export class Call extends Eventing<CallEventTypes> implements ICall {
           clearInterval(this.sessionTimer);
         }
 
-        handleCallErrors(
+        const abort = await handleCallErrors(
           (callError: CallError) => {
             this.emit(CALL_EVENT_KEYS.CALL_ERROR, callError);
             this.submitCallErrorMetric(callError);
           },
           ERROR_LAYER.CALL_CONTROL,
           (interval: number) => {
-            setTimeout(() => {
-              /* We first post the status and then recursively call the handler which
-               * starts the timer again
-               */
-              this.postStatus();
-              this.sendCallStateMachineEvt({type: 'E_CALL_ESTABLISHED'});
-            }, interval * 1000);
+            this.callKeepaliveRetryCount += 1;
+            this.callKeepaliveInterval = interval * 1000;
+
+            // If we have reached the max retry count, do not attempt to refresh the session
+            if (this.callKeepaliveRetryCount === MAX_CALL_KEEPALIVE_RETRY_COUNT) {
+              this.callKeepaliveRetryCount = 0;
+              clearInterval(this.sessionTimer);
+              this.sessionTimer = undefined;
+              this.callKeepaliveInterval = undefined;
+
+              log.warn(
+                `Max call keepalive retry attempts reached for call: ${this.getCorrelationId()}`,
+                loggerContext
+              );
+
+              return;
+            }
+
+            // Scheduling next keepalive attempt - calling handleCallEstablished
+            this.sendCallStateMachineEvt({type: 'E_CALL_ESTABLISHED'});
           },
           this.getCorrelationId(),
           error,
-          this.handleCallEstablished.name,
+          'handleCallEstablished',
           CALL_FILE
         );
 
+        if (abort) {
+          this.sendCallStateMachineEvt({type: 'E_SEND_CALL_DISCONNECT'});
+          this.emit(CALL_EVENT_KEYS.DISCONNECT, this.getCorrelationId());
+          this.callKeepaliveRetryCount = 0;
+          this.callKeepaliveInterval = undefined;
+        }
+
         await uploadLogs({
           correlationId: this.correlationId,
           callId: this.callId,
           broadworksCorrelationInfo: this.broadworksCorrelationInfo,
         });
       }
-    }, DEFAULT_SESSION_TIMER);
+    }, this.callKeepaliveInterval || DEFAULT_SESSION_TIMER);
   }
 
   /**

packages/calling/src/CallingClient/constants.ts

@@ -12,6 +12,7 @@ export const DEFAULT_LOCAL_CALL_ID = 'DefaultLocalId';
 export const DEFAULT_REHOMING_INTERVAL_MAX = 120;
 export const DEFAULT_REHOMING_INTERVAL_MIN = 60;
 export const DEFAULT_SESSION_TIMER = 1000 * 60 * 10;
+export const MAX_CALL_KEEPALIVE_RETRY_COUNT = 4;
 export const DEVICES_ENDPOINT_RESOURCE = 'devices';
 export const DISCOVERY_URL = 'https://ds.ciscospark.com/v1/region';
 export const DUMMY_METRICS = {