@webex/plugin-meetings 3.0.0-next.2 → 3.0.0-next.21

package/src/roap/turnDiscovery.ts

@@ -4,7 +4,7 @@ import {Defer} from '@webex/common';
 import Metrics from '../metrics';
 import BEHAVIORAL_METRICS from '../metrics/constants';
 import LoggerProxy from '../common/logs/logger-proxy';
-import {ROAP} from '../constants';
+import {ROAP, Enum} from '../constants';
 
 import RoapRequest from './request';
 import Meeting from '../meeting';
@@ -18,6 +18,28 @@ const TURN_DISCOVERY_TIMEOUT = 10; // in seconds
 // and do the SDP offer with seq=1
 const TURN_DISCOVERY_SEQ = 0;
 
+const TurnDiscoverySkipReason = {
+  missingHttpResponse: 'missing http response', // when we asked for the TURN discovery response to be in the http response, but it wasn't there
+  reachability: 'reachability', // when udp reachability to public clusters is ok, so we don't need TURN (this doens't apply when joinWithMedia() is used)
+  alreadyInProgress: 'already in progress', // when we try to start TURN discovery while it's already in progress
+} as const;
+
+export type TurnDiscoverySkipReason =
+  | Enum<typeof TurnDiscoverySkipReason> // this is a kind of FYI, because in practice typescript will infer the type of TurnDiscoverySkipReason as a string
+  | string // used in case of errors, contains the error message
+  | undefined; // used when TURN discovery is not skipped
+
+export type TurnServerInfo = {
+  url: string;
+  username: string;
+  password: string;
+};
+
+export type TurnDiscoveryResult = {
+  turnServerInfo?: TurnServerInfo;
+  turnDiscoverySkippedReason: TurnDiscoverySkipReason;
+};
+
 /**
  * Handles the process of finding out TURN server information from Linus.
  * This is achieved by sending a TURN_DISCOVERY_REQUEST.
@@ -27,11 +49,7 @@ export default class TurnDiscovery {
 
   private defer?: Defer; // used for waiting for the response
 
-  private turnInfo: {
-    url: string;
-    username: string;
-    password: string;
-  };
+  private turnInfo: TurnServerInfo;
 
   private responseTimer?: ReturnType<typeof setTimeout>;
 
@@ -85,7 +103,8 @@ export default class TurnDiscovery {
   }
 
   /**
-   * handles TURN_DISCOVERY_RESPONSE roap message
+   * Handles TURN_DISCOVERY_RESPONSE roap message. Use it if the roap message comes over the websocket,
+   * otherwise use handleTurnDiscoveryHttpResponse() if it comes in the http response.
    *
    * @param {Object} roapMessage
    * @param {string} from string to indicate how we got the response (used just for logging)
@@ -158,18 +177,191 @@ export default class TurnDiscovery {
   }
 
   /**
-   * handles TURN_DISCOVERY_RESPONSE roap message that came in http response
+   * Generates TURN_DISCOVERY_REQUEST roap message. When this method returns a roapMessage, it means that a TURN discovery process has started.
+   * It needs be ended by calling handleTurnDiscoveryHttpResponse() once you get a response from the backend. If you don't get any response
+   * or want to abort, you need to call abort().
    *
-   * @param {Object} roapMessage
-   * @returns {Promise}
+   * @param {Meeting} meeting
+   * @param {boolean} isForced
+   * @returns {Object}
+   */
+  public async generateTurnDiscoveryRequestMessage(
+    meeting: Meeting,
+    isForced: boolean
+  ): Promise<{roapMessage?: object; turnDiscoverySkippedReason: TurnDiscoverySkipReason}> {
+    if (this.defer) {
+      LoggerProxy.logger.warn(
+        'Roap:turnDiscovery#generateTurnDiscoveryRequestMessage --> TURN discovery already in progress'
+      );
+
+      return {
+        roapMessage: undefined,
+        turnDiscoverySkippedReason: TurnDiscoverySkipReason.alreadyInProgress,
+      };
+    }
+
+    let turnDiscoverySkippedReason: TurnDiscoverySkipReason;
+
+    if (!isForced) {
+      turnDiscoverySkippedReason = await this.getSkipReason(meeting);
+    }
+
+    if (turnDiscoverySkippedReason) {
+      return {roapMessage: undefined, turnDiscoverySkippedReason};
+    }
+
+    this.defer = new Defer();
+
+    const roapMessage = {
+      messageType: ROAP.ROAP_TYPES.TURN_DISCOVERY_REQUEST,
+      version: ROAP.ROAP_VERSION,
+      seq: TURN_DISCOVERY_SEQ,
+      headers: ['includeAnswerInHttpResponse', 'noOkInTransaction'],
+    };
+
+    LoggerProxy.logger.info(
+      'Roap:turnDiscovery#generateTurnDiscoveryRequestMessage --> generated TURN_DISCOVERY_REQUEST message'
+    );
+
+    return {roapMessage, turnDiscoverySkippedReason: undefined};
+  }
+
+  /**
+   * Handles any errors that occur during TURN discovery without re-throwing them.
+   *
+   * @param {Meeting} meeting
+   * @param {Error} error
+   * @returns {TurnDiscoveryResult}
+   */
+  private handleTurnDiscoveryFailure(meeting: Meeting, error: Error): TurnDiscoveryResult {
+    // we catch any errors and resolve with no turn information so that the normal call join flow can continue without TURN
+    LoggerProxy.logger.info(
+      `Roap:turnDiscovery#doTurnDiscovery --> TURN discovery failed, continuing without TURN: ${error}`
+    );
+
+    Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.TURN_DISCOVERY_FAILURE, {
+      correlation_id: meeting.correlationId,
+      locus_id: meeting.locusUrl.split('/').pop(),
+      reason: error.message,
+      stack: error.stack,
+    });
+
+    return {turnServerInfo: undefined, turnDiscoverySkippedReason: `failure: ${error.message}`};
+  }
+
+  /**
+   * Handles TURN_DISCOVERY_RESPONSE roap message that came in http response. If the response is not valid,
+   * it returns an object with turnServerInfo set to undefined. In that case you need to call abort()
+   * to end the TURN discovery process.
+   *
+   * @param {Meeting} meeting
+   * @param {Object|undefined} httpResponse can be undefined to indicate that we didn't get the response
+   * @returns {Promise<TurnDiscoveryResult>}
    * @memberof Roap
    */
-  private async handleTurnDiscoveryResponseInHttpResponse(
-    roapMessage: object
-  ): Promise<{isOkRequired: boolean}> {
-    this.handleTurnDiscoveryResponse(roapMessage, 'in http response');
+  public async handleTurnDiscoveryHttpResponse(
+    meeting: Meeting,
+    httpResponse?: object
+  ): Promise<TurnDiscoveryResult> {
+    if (!this.defer) {
+      LoggerProxy.logger.warn(
+        'Roap:turnDiscovery#handleTurnDiscoveryHttpResponse --> unexpected http response, TURN discovery is not in progress'
+      );
 
-    return this.defer.promise;
+      throw new Error(
+        'handleTurnDiscoveryHttpResponse() called before generateTurnDiscoveryRequestMessage()'
+      );
+    }
+
+    if (httpResponse === undefined) {
+      return {
+        turnServerInfo: undefined,
+        turnDiscoverySkippedReason: TurnDiscoverySkipReason.missingHttpResponse,
+      };
+    }
+
+    try {
+      const roapMessage = this.parseHttpTurnDiscoveryResponse(meeting, httpResponse);
+
+      if (!roapMessage) {
+        return {
+          turnServerInfo: undefined,
+          turnDiscoverySkippedReason: TurnDiscoverySkipReason.missingHttpResponse,
+        };
+      }
+
+      this.handleTurnDiscoveryResponse(roapMessage, 'in http response');
+
+      const {isOkRequired} = await this.defer.promise;
+
+      if (isOkRequired) {
+        await this.sendRoapOK(meeting);
+      }
+
+      this.defer = undefined;
+
+      LoggerProxy.logger.info('Roap:turnDiscovery#doTurnDiscovery --> TURN discovery completed');
+
+      return {turnServerInfo: this.turnInfo, turnDiscoverySkippedReason: undefined};
+    } catch (error) {
+      this.abort();
+
+      return this.handleTurnDiscoveryFailure(meeting, error);
+    }
+  }
+
+  /**
+   * Aborts current TURN discovery. This method needs to be called if you called generateTurnDiscoveryRequestMessage(),
+   * but then never got any response from the server.
+   * @returns {void}
+   */
+  public abort() {
+    if (this.defer) {
+      this.defer.reject(new Error('TURN discovery aborted'));
+      this.defer = undefined;
+    }
+  }
+
+  /**
+   * Parses the TURN_DISCOVERY_RESPONSE roap message out of the http response
+   * and returns it.
+   *
+   * @param {Meeting} meeting
+   * @param {any} httpResponse
+   * @returns {any}
+   */
+  private parseHttpTurnDiscoveryResponse(
+    meeting: Meeting,
+    httpResponse: {mediaConnections?: Array<{remoteSdp?: string}>}
+  ) {
+    let turnDiscoveryResponse;
+
+    if (httpResponse.mediaConnections?.[0]?.remoteSdp) {
+      const remoteSdp = JSON.parse(httpResponse.mediaConnections[0].remoteSdp);
+
+      if (remoteSdp.roapMessage) {
+        // yes, it's misleading that remoteSdp actually contains a TURN discovery response, but that's how the backend works...
+        const {seq, messageType, errorType, errorCause, headers} = remoteSdp.roapMessage;
+
+        turnDiscoveryResponse = {
+          seq,
+          messageType,
+          errorType,
+          errorCause,
+          headers,
+        };
+      }
+    }
+
+    if (!turnDiscoveryResponse) {
+      Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ROAP_HTTP_RESPONSE_MISSING, {
+        correlationId: meeting.correlationId,
+        messageType: 'TURN_DISCOVERY_RESPONSE',
+        isMultistream: meeting.isMultistream,
+      });
+    }
+
+    return turnDiscoveryResponse;
   }
 
   /**
@@ -181,13 +373,19 @@ export default class TurnDiscovery {
    * @private
    * @memberof Roap
    */
-  sendRoapTurnDiscoveryRequest(meeting: Meeting, isReconnecting: boolean) {
+  private sendRoapTurnDiscoveryRequest(
+    meeting: Meeting,
+    isReconnecting: boolean
+  ): Promise<TurnDiscoveryResult> {
     if (this.defer) {
       LoggerProxy.logger.warn(
         'Roap:turnDiscovery#sendRoapTurnDiscoveryRequest --> already in progress'
       );
 
-      return Promise.resolve();
+      return Promise.resolve({
+        turnServerInfo: undefined,
+        turnDiscoverySkippedReason: TurnDiscoverySkipReason.alreadyInProgress,
+      });
     }
 
     this.defer = new Defer();
@@ -215,41 +413,14 @@ export default class TurnDiscovery {
         // @ts-ignore - because of meeting.webex
         ipVersion: MeetingUtil.getIpVersion(meeting.webex),
       })
-      .then((response) => {
+      .then(async (response) => {
         const {mediaConnections} = response;
 
-        let turnDiscoveryResponse;
-
         if (mediaConnections) {
           meeting.updateMediaConnections(mediaConnections);
-
-          if (mediaConnections[0]?.remoteSdp) {
-            const remoteSdp = JSON.parse(mediaConnections[0].remoteSdp);
-
-            if (remoteSdp.roapMessage) {
-              // yes, it's misleading that remoteSdp actually contains a TURN discovery response, but that's how the backend works...
-              const {seq, messageType, errorType, errorCause, headers} = remoteSdp.roapMessage;
-
-              turnDiscoveryResponse = {
-                seq,
-                messageType,
-                errorType,
-                errorCause,
-                headers,
-              };
-            }
-          }
         }
 
-        if (!turnDiscoveryResponse) {
-          Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ROAP_HTTP_RESPONSE_MISSING, {
-            correlationId: meeting.correlationId,
-            messageType: 'TURN_DISCOVERY_RESPONSE',
-            isMultistream: meeting.isMultistream,
-          });
-        }
-
-        return turnDiscoveryResponse;
+        return this.handleTurnDiscoveryHttpResponse(meeting, response);
       });
   }
 
@@ -261,7 +432,14 @@ export default class TurnDiscovery {
    * @returns {Promise}
    */
   sendRoapOK(meeting: Meeting) {
-    LoggerProxy.logger.info('Roap:turnDiscovery#sendRoapOK --> sending OK');
+    LoggerProxy.logger.info(
+      'Roap:turnDiscovery#sendRoapOK --> TURN discovery response requires OK, sending it...'
+    );
+
+    Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.TURN_DISCOVERY_REQUIRES_OK, {
+      correlation_id: meeting.correlationId,
+      locus_id: meeting.locusUrl.split('/').pop(),
+    });
 
     return this.roapRequest.sendRoap({
       roapMessage: {
@@ -284,7 +462,7 @@ export default class TurnDiscovery {
    * @param {Meeting} meeting
    * @returns {Promise<string>} Promise with empty string if reachability is not skipped or a reason if it is skipped
    */
-  private async getSkipReason(meeting: Meeting): Promise<string> {
+  private async getSkipReason(meeting: Meeting): Promise<TurnDiscoverySkipReason> {
     const isAnyPublicClusterReachable =
       // @ts-ignore - fix type
       await meeting.webex.meetings.reachability.isAnyPublicClusterReachable();
@@ -294,10 +472,10 @@ export default class TurnDiscovery {
         'Roap:turnDiscovery#getSkipReason --> reachability has not failed, skipping TURN discovery'
       );
 
-      return 'reachability';
+      return TurnDiscoverySkipReason.reachability;
     }
 
-    return '';
+    return undefined;
   }
 
   /**
@@ -330,8 +508,12 @@ export default class TurnDiscovery {
    * @param {Boolean} [isForced]
    * @returns {Promise}
    */
-  async doTurnDiscovery(meeting: Meeting, isReconnecting?: boolean, isForced?: boolean) {
-    let turnDiscoverySkippedReason: string;
+  async doTurnDiscovery(
+    meeting: Meeting,
+    isReconnecting?: boolean,
+    isForced?: boolean
+  ): Promise<TurnDiscoveryResult> {
+    let turnDiscoverySkippedReason: TurnDiscoverySkipReason;
 
     if (!isForced) {
       turnDiscoverySkippedReason = await this.getSkipReason(meeting);
@@ -345,24 +527,20 @@ export default class TurnDiscovery {
     }
 
     try {
-      const httpResponse = await this.sendRoapTurnDiscoveryRequest(meeting, isReconnecting);
+      const turnDiscoveryResult = await this.sendRoapTurnDiscoveryRequest(meeting, isReconnecting);
+
+      if (
+        turnDiscoveryResult.turnDiscoverySkippedReason !==
+        TurnDiscoverySkipReason.missingHttpResponse
+      ) {
+        return turnDiscoveryResult;
+      }
 
       // if we haven't got the response over http, we need to wait for it to come over the websocket via Mercury
-      const {isOkRequired} = httpResponse
-        ? await this.handleTurnDiscoveryResponseInHttpResponse(httpResponse)
-        : await this.waitForTurnDiscoveryResponse();
+      const {isOkRequired} = await this.waitForTurnDiscoveryResponse();
 
       if (isOkRequired) {
         await this.sendRoapOK(meeting);
-
-        LoggerProxy.logger.info(
-          'Roap:turnDiscovery#doTurnDiscovery --> TURN discovery response requires OK'
-        );
-
-        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.TURN_DISCOVERY_REQUIRES_OK, {
-          correlation_id: meeting.correlationId,
-          locus_id: meeting.locusUrl.split('/').pop(),
-        });
       }
 
       this.defer = undefined;
@@ -371,19 +549,7 @@ export default class TurnDiscovery {
 
       return {turnServerInfo: this.turnInfo, turnDiscoverySkippedReason: undefined};
     } catch (e) {
-      // we catch any errors and resolve with no turn information so that the normal call join flow can continue without TURN
-      LoggerProxy.logger.info(
-        `Roap:turnDiscovery#doTurnDiscovery --> TURN discovery failed, continuing without TURN: ${e}`
-      );
-
-      Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.TURN_DISCOVERY_FAILURE, {
-        correlation_id: meeting.correlationId,
-        locus_id: meeting.locusUrl.split('/').pop(),
-        reason: e.message,
-        stack: e.stack,
-      });
-
-      return {turnServerInfo: undefined, turnDiscoverySkippedReason: undefined};
+      return this.handleTurnDiscoveryFailure(meeting, e);
     }
   }
 }

package/src/statsAnalyzer/index.ts

@@ -4,14 +4,7 @@ import {cloneDeep, isEmpty} from 'lodash';
 import {ConnectionState} from '@webex/internal-media-core';
 
 import EventsScope from '../common/events/events-scope';
-import {
-  DEFAULT_GET_STATS_FILTER,
-  STATS,
-  MQA_INTERVAL,
-  NETWORK_TYPE,
-  MEDIA_DEVICES,
-  _UNKNOWN_,
-} from '../constants';
+import {DEFAULT_GET_STATS_FILTER, STATS, MQA_INTERVAL, NETWORK_TYPE, _UNKNOWN_} from '../constants';
 import {
   emptyAudioReceive,
   emptyAudioTransmit,
@@ -264,7 +257,7 @@ export class StatsAnalyzer extends EventsScope {
 
     // Add stats for individual streams
     Object.keys(this.statsResults).forEach((mediaType) => {
-      if (mediaType.includes('audio-send')) {
+      if (mediaType.startsWith('audio-send')) {
         const audioSenderStream = cloneDeep(emptyAudioTransmitStream);
 
         getAudioSenderStreamMqa({
@@ -276,7 +269,7 @@ export class StatsAnalyzer extends EventsScope {
         newMqa.audioTransmit[0].streams.push(audioSenderStream);
 
         this.lastMqaDataSent[mediaType].send = cloneDeep(this.statsResults[mediaType].send);
-      } else if (mediaType.includes('audio-share-send')) {
+      } else if (mediaType.startsWith('audio-share-send')) {
         const audioSenderStream = cloneDeep(emptyAudioTransmitStream);
 
         getAudioSenderStreamMqa({
@@ -288,7 +281,7 @@ export class StatsAnalyzer extends EventsScope {
         newMqa.audioTransmit[1].streams.push(audioSenderStream);
 
         this.lastMqaDataSent[mediaType].send = cloneDeep(this.statsResults[mediaType].send);
-      } else if (mediaType.includes('audio-recv')) {
+      } else if (mediaType.startsWith('audio-recv')) {
         const audioReceiverStream = cloneDeep(emptyAudioReceiveStream);
 
         getAudioReceiverStreamMqa({
@@ -300,7 +293,7 @@ export class StatsAnalyzer extends EventsScope {
         newMqa.audioReceive[0].streams.push(audioReceiverStream);
 
         this.lastMqaDataSent[mediaType].recv = cloneDeep(this.statsResults[mediaType].recv);
-      } else if (mediaType.includes('audio-share-recv')) {
+      } else if (mediaType.startsWith('audio-share-recv')) {
         const audioReceiverStream = cloneDeep(emptyAudioReceiveStream);
 
         getAudioReceiverStreamMqa({
@@ -312,7 +305,8 @@ export class StatsAnalyzer extends EventsScope {
         newMqa.audioReceive[1].streams.push(audioReceiverStream);
 
         this.lastMqaDataSent[mediaType].recv = cloneDeep(this.statsResults[mediaType].recv);
-      } else if (mediaType.includes('video-send')) {
+      } else if (mediaType.startsWith('video-send-layer')) {
+        // We only want the stream-specific stats we get with video-send-layer-0, video-send-layer-1, etc.
         const videoSenderStream = cloneDeep(emptyVideoTransmitStream);
 
         getVideoSenderStreamMqa({
@@ -324,7 +318,7 @@ export class StatsAnalyzer extends EventsScope {
         newMqa.videoTransmit[0].streams.push(videoSenderStream);
 
         this.lastMqaDataSent[mediaType].send = cloneDeep(this.statsResults[mediaType].send);
-      } else if (mediaType.includes('video-share-send')) {
+      } else if (mediaType.startsWith('video-share-send')) {
         const videoSenderStream = cloneDeep(emptyVideoTransmitStream);
 
         getVideoSenderStreamMqa({
@@ -336,7 +330,7 @@ export class StatsAnalyzer extends EventsScope {
         newMqa.videoTransmit[1].streams.push(videoSenderStream);
 
         this.lastMqaDataSent[mediaType].send = cloneDeep(this.statsResults[mediaType].send);
-      } else if (mediaType.includes('video-recv')) {
+      } else if (mediaType.startsWith('video-recv')) {
         const videoReceiverStream = cloneDeep(emptyVideoReceiveStream);
 
         getVideoReceiverStreamMqa({
@@ -348,7 +342,7 @@ export class StatsAnalyzer extends EventsScope {
         newMqa.videoReceive[0].streams.push(videoReceiverStream);
 
         this.lastMqaDataSent[mediaType].recv = cloneDeep(this.statsResults[mediaType].recv);
-      } else if (mediaType.includes('video-share-recv')) {
+      } else if (mediaType.startsWith('video-share-recv')) {
         const videoReceiverStream = cloneDeep(emptyVideoReceiveStream);
 
         getVideoReceiverStreamMqa({
@@ -366,18 +360,23 @@ export class StatsAnalyzer extends EventsScope {
     newMqa.intervalMetadata.peerReflexiveIP = this.statsResults.connectionType.local.ipAddress;
 
     // Adding peripheral information
-    newMqa.intervalMetadata.peripherals.push({information: _UNKNOWN_, name: MEDIA_DEVICES.SPEAKER});
+    newMqa.intervalMetadata.speakerInfo = {
+      deviceName: _UNKNOWN_,
+    };
     if (this.statsResults['audio-send']) {
-      newMqa.intervalMetadata.peripherals.push({
-        information: this.statsResults['audio-send'].trackLabel || _UNKNOWN_,
-        name: MEDIA_DEVICES.MICROPHONE,
-      });
+      newMqa.intervalMetadata.microphoneInfo = {
+        deviceName: this.statsResults['audio-send'].trackLabel || _UNKNOWN_,
+      };
     }
-    if (this.statsResults['video-send']) {
-      newMqa.intervalMetadata.peripherals.push({
-        information: this.statsResults['video-send'].trackLabel || _UNKNOWN_,
-        name: MEDIA_DEVICES.CAMERA,
-      });
+
+    const existingVideoSender = Object.keys(this.statsResults).find((item) =>
+      item.includes('video-send')
+    );
+
+    if (existingVideoSender) {
+      newMqa.intervalMetadata.cameraInfo = {
+        deviceName: this.statsResults[existingVideoSender].trackLabel || _UNKNOWN_,
+      };
     }
 
     newMqa.networkType = this.statsResults.connectionType.local.networkType;
@@ -552,9 +551,21 @@ export class StatsAnalyzer extends EventsScope {
       }
     });
 
+    let videoSenderIndex = 0;
     statsItem.report.forEach((result) => {
       if (types.includes(result.type)) {
-        this.parseGetStatsResult(result, type, isSender);
+        // if the video sender has multiple streams in the report, it is a new stream object.
+        if (type === 'video-send' && result.type === 'outbound-rtp') {
+          const newType = `video-send-layer-${videoSenderIndex}`;
+          this.parseGetStatsResult(result, newType, isSender);
+          videoSenderIndex += 1;
+
+          this.statsResults[newType].direction = statsItem.currentDirection;
+          this.statsResults[newType].trackLabel = statsItem.localTrackLabel;
+          this.statsResults[newType].csi = statsItem.csi;
+        } else {
+          this.parseGetStatsResult(result, type, isSender);
+        }
       }
     });
 
@@ -664,12 +675,23 @@ export class StatsAnalyzer extends EventsScope {
       const getCurrentStatsTotals = (keyPrefix: string, value: string): number =>
         Object.keys(this.statsResults)
           .filter((key) => key.startsWith(keyPrefix))
-          .reduce((prev, cur) => prev + (this.statsResults[cur]?.recv[value] || 0), 0);
+          .reduce(
+            (prev, cur) =>
+              prev +
+              (this.statsResults[cur]?.[keyPrefix.includes('send') ? 'send' : 'recv'][value] || 0),
+            0
+          );
 
       const getPreviousStatsTotals = (keyPrefix: string, value: string): number =>
         Object.keys(this.statsResults)
           .filter((key) => key.startsWith(keyPrefix))
-          .reduce((prev, cur) => prev + (this.lastStatsResults[cur]?.recv[value] || 0), 0);
+          .reduce(
+            (prev, cur) =>
+              prev +
+              (this.lastStatsResults[cur]?.[keyPrefix.includes('send') ? 'send' : 'recv'][value] ||
+                0),
+            0
+          );
 
       // Audio Transmit
       if (this.lastStatsResults['audio-send']) {
@@ -731,47 +753,54 @@ export class StatsAnalyzer extends EventsScope {
         false
       );
 
+      const currentTotalPacketsSent = getCurrentStatsTotals('video-send', 'totalPacketsSent');
+      const previousTotalPacketsSent = getPreviousStatsTotals('video-send', 'totalPacketsSent');
+
+      const currentFramesEncoded = getCurrentStatsTotals('video-send', 'framesEncoded');
+      const previousFramesEncoded = getPreviousStatsTotals('video-send', 'framesEncoded');
+
+      const currentFramesSent = getCurrentStatsTotals('video-send', 'framesSent');
+      const previousFramesSent = getPreviousStatsTotals('video-send', 'framesSent');
+
+      const doesVideoSendExist = Object.keys(this.lastStatsResults).some((item) =>
+        item.includes('video-send')
+      );
+
       // Video Transmit
-      if (this.lastStatsResults['video-send']) {
+      if (doesVideoSendExist) {
         // compare video stats sent
-        const currentStats = this.statsResults['video-send'].send;
-        const previousStats = this.lastStatsResults['video-send'].send;
 
         if (
           this.meetingMediaStatus.expected.sendVideo &&
-          (currentStats.totalPacketsSent === previousStats.totalPacketsSent ||
-            currentStats.totalPacketsSent === 0)
+          (currentTotalPacketsSent === previousTotalPacketsSent || currentTotalPacketsSent === 0)
         ) {
           LoggerProxy.logger.info(
             `StatsAnalyzer:index#compareLastStatsResult --> No video RTP packets sent`,
-            currentStats.totalPacketsSent
+            currentTotalPacketsSent
           );
         } else {
           if (
             this.meetingMediaStatus.expected.sendVideo &&
-            (currentStats.framesEncoded === previousStats.framesEncoded ||
-              currentStats.framesEncoded === 0)
+            (currentFramesEncoded === previousFramesEncoded || currentFramesEncoded === 0)
           ) {
             LoggerProxy.logger.info(
               `StatsAnalyzer:index#compareLastStatsResult --> No video Frames Encoded`,
-              currentStats.framesEncoded
+              currentFramesEncoded
             );
           }
 
           if (
             this.meetingMediaStatus.expected.sendVideo &&
-            (this.statsResults['video-send'].send.framesSent ===
-              this.lastStatsResults['video-send'].send.framesSent ||
-              this.statsResults['video-send'].send.framesSent === 0)
+            (currentFramesSent === previousFramesSent || currentFramesSent === 0)
           ) {
             LoggerProxy.logger.info(
               `StatsAnalyzer:index#compareLastStatsResult --> No video Frames sent`,
-              this.statsResults['video-send'].send.framesSent
+              currentFramesSent
             );
           }
         }
 
-        this.emitStartStopEvents('video', previousStats.framesSent, currentStats.framesSent, true);
+        this.emitStartStopEvents('video', previousFramesSent, currentFramesSent, true);
       }
 
       // Video Receive