@webex/plugin-meetings 3.0.0-stream-classes.4 → 3.0.0

package/src/statsAnalyzer/index.ts

@@ -1,13 +1,13 @@
 /* eslint-disable prefer-destructuring */
 
-import {cloneDeep} from 'lodash';
+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_INTEVAL,
+  MQA_INTERVAL,
   NETWORK_TYPE,
   MEDIA_DEVICES,
   _UNKNOWN_,
@@ -18,6 +18,10 @@ import {
   emptyMqaInterval,
   emptyVideoReceive,
   emptyVideoTransmit,
+  emptyAudioReceiveStream,
+  emptyAudioTransmitStream,
+  emptyVideoReceiveStream,
+  emptyVideoTransmitStream,
 } from '../mediaQualityMetrics/config';
 import LoggerProxy from '../common/logs/logger-proxy';
 
@@ -27,6 +31,10 @@ import {
   getAudioReceiverMqa,
   getVideoSenderMqa,
   getVideoReceiverMqa,
+  getAudioSenderStreamMqa,
+  getAudioReceiverStreamMqa,
+  getVideoSenderStreamMqa,
+  getVideoReceiverStreamMqa,
 } from './mqaUtil';
 import {ReceiveSlot} from '../multistream/receiveSlot';
 
@@ -55,7 +63,10 @@ const emptyReceiver = {
 };
 
 type ReceiveSlotCallback = (csi: number) => ReceiveSlot | undefined;
-
+type MediaStatus = {
+  actual?: any;
+  expected?: any;
+};
 /**
  * Stats Analyzer class that will emit events based on detected quality
  *
@@ -77,6 +88,8 @@ export class StatsAnalyzer extends EventsScope {
   statsInterval: NodeJS.Timeout;
   statsResults: any;
   statsStarted: any;
+  successfulCandidatePair: any;
+  localIpAddress: string; // Returns the local IP address for diagnostics. this is the local IP of the interface used for the current media connection a host can have many local Ip Addresses
   receiveSlotCallback: ReceiveSlotCallback;
 
   /**
@@ -105,6 +118,8 @@ export class StatsAnalyzer extends EventsScope {
     this.lastMqaDataSent = {};
     this.lastEmittedStartStopEvent = {};
     this.receiveSlotCallback = receiveSlotCallback;
+    this.successfulCandidatePair = {};
+    this.localIpAddress = '';
   }
 
   /**
@@ -135,8 +150,17 @@ export class StatsAnalyzer extends EventsScope {
    * @memberof StatsAnalyzer
    * @returns {void}
    */
-  public updateMediaStatus(status: object) {
-    this.meetingMediaStatus = status;
+  public updateMediaStatus(status: MediaStatus) {
+    this.meetingMediaStatus = {
+      actual: {
+        ...this.meetingMediaStatus?.actual,
+        ...status?.actual,
+      },
+      expected: {
+        ...this.meetingMediaStatus?.expected,
+        ...status?.expected,
+      },
+    };
   }
 
   /**
@@ -149,65 +173,209 @@ export class StatsAnalyzer extends EventsScope {
   sendMqaData() {
     const newMqa = cloneDeep(emptyMqaInterval);
 
+    // Fill in empty stats items for lastMqaDataSent
     Object.keys(this.statsResults).forEach((mediaType) => {
-      if (mediaType.includes('audio-send') || mediaType.includes('audio-share-send')) {
-        const audioSender = cloneDeep(emptyAudioTransmit);
+      if (!this.lastMqaDataSent[mediaType]) {
+        this.lastMqaDataSent[mediaType] = {};
+      }
+
+      if (!this.lastMqaDataSent[mediaType].send && mediaType.includes('-send')) {
+        this.lastMqaDataSent[mediaType].send = {};
+      }
+
+      if (!this.lastMqaDataSent[mediaType].recv && mediaType.includes('-recv')) {
+        this.lastMqaDataSent[mediaType].recv = {};
+      }
+    });
+
+    // Create stats the first level, totals for senders and receivers
+    const audioSender = cloneDeep(emptyAudioTransmit);
+    const audioShareSender = cloneDeep(emptyAudioTransmit);
+    const audioReceiver = cloneDeep(emptyAudioReceive);
+    const audioShareReceiver = cloneDeep(emptyAudioReceive);
+    const videoSender = cloneDeep(emptyVideoTransmit);
+    const videoShareSender = cloneDeep(emptyVideoTransmit);
+    const videoReceiver = cloneDeep(emptyVideoReceive);
+    const videoShareReceiver = cloneDeep(emptyVideoReceive);
+
+    getAudioSenderMqa({
+      audioSender,
+      statsResults: this.statsResults,
+      lastMqaDataSent: this.lastMqaDataSent,
+      baseMediaType: 'audio-send',
+    });
+    newMqa.audioTransmit.push(audioSender);
+
+    getAudioSenderMqa({
+      audioSender: audioShareSender,
+      statsResults: this.statsResults,
+      lastMqaDataSent: this.lastMqaDataSent,
+      baseMediaType: 'audio-share-send',
+    });
+    newMqa.audioTransmit.push(audioShareSender);
+
+    getAudioReceiverMqa({
+      audioReceiver,
+      statsResults: this.statsResults,
+      lastMqaDataSent: this.lastMqaDataSent,
+      baseMediaType: 'audio-recv',
+    });
+    newMqa.audioReceive.push(audioReceiver);
+
+    getAudioReceiverMqa({
+      audioReceiver: audioShareReceiver,
+      statsResults: this.statsResults,
+      lastMqaDataSent: this.lastMqaDataSent,
+      baseMediaType: 'audio-share-recv',
+    });
+    newMqa.audioReceive.push(audioShareReceiver);
+
+    getVideoSenderMqa({
+      videoSender,
+      statsResults: this.statsResults,
+      lastMqaDataSent: this.lastMqaDataSent,
+      baseMediaType: 'video-send',
+    });
+    newMqa.videoTransmit.push(videoSender);
+
+    getVideoSenderMqa({
+      videoSender: videoShareSender,
+      statsResults: this.statsResults,
+      lastMqaDataSent: this.lastMqaDataSent,
+      baseMediaType: 'video-share-send',
+    });
+    newMqa.videoTransmit.push(videoShareSender);
+
+    getVideoReceiverMqa({
+      videoReceiver,
+      statsResults: this.statsResults,
+      lastMqaDataSent: this.lastMqaDataSent,
+      baseMediaType: 'video-recv',
+    });
+    newMqa.videoReceive.push(videoReceiver);
+
+    getVideoReceiverMqa({
+      videoReceiver: videoShareReceiver,
+      statsResults: this.statsResults,
+      lastMqaDataSent: this.lastMqaDataSent,
+      baseMediaType: 'video-share-recv',
+    });
+    newMqa.videoReceive.push(videoShareReceiver);
+
+    // Add stats for individual streams
+    Object.keys(this.statsResults).forEach((mediaType) => {
+      if (mediaType.includes('audio-send')) {
+        const audioSenderStream = cloneDeep(emptyAudioTransmitStream);
+
+        getAudioSenderStreamMqa({
+          audioSenderStream,
+          statsResults: this.statsResults,
+          lastMqaDataSent: this.lastMqaDataSent,
+          mediaType,
+        });
+        newMqa.audioTransmit[0].streams.push(audioSenderStream);
+
+        this.lastMqaDataSent[mediaType].send = cloneDeep(this.statsResults[mediaType].send);
+      } else if (mediaType.includes('audio-share-send')) {
+        const audioSenderStream = cloneDeep(emptyAudioTransmitStream);
+
+        getAudioSenderStreamMqa({
+          audioSenderStream,
+          statsResults: this.statsResults,
+          lastMqaDataSent: this.lastMqaDataSent,
+          mediaType,
+        });
+        newMqa.audioTransmit[1].streams.push(audioSenderStream);
+
+        this.lastMqaDataSent[mediaType].send = cloneDeep(this.statsResults[mediaType].send);
+      } else if (mediaType.includes('audio-recv')) {
+        const audioReceiverStream = cloneDeep(emptyAudioReceiveStream);
 
-        getAudioSenderMqa({
-          audioSender,
+        getAudioReceiverStreamMqa({
+          audioReceiverStream,
           statsResults: this.statsResults,
           lastMqaDataSent: this.lastMqaDataSent,
           mediaType,
         });
-        newMqa.audioTransmit.push(audioSender);
-      } else if (mediaType.includes('audio-recv') || mediaType.includes('audio-share-recv')) {
-        const audioReceiver = cloneDeep(emptyAudioReceive);
+        newMqa.audioReceive[0].streams.push(audioReceiverStream);
 
-        getAudioReceiverMqa({
-          audioReceiver,
+        this.lastMqaDataSent[mediaType].recv = cloneDeep(this.statsResults[mediaType].recv);
+      } else if (mediaType.includes('audio-share-recv')) {
+        const audioReceiverStream = cloneDeep(emptyAudioReceiveStream);
+
+        getAudioReceiverStreamMqa({
+          audioReceiverStream,
           statsResults: this.statsResults,
           lastMqaDataSent: this.lastMqaDataSent,
           mediaType,
         });
-        newMqa.audioReceive.push(audioReceiver);
-      } else if (mediaType.includes('video-send') || mediaType.includes('video-share-send')) {
-        const videoSender = cloneDeep(emptyVideoTransmit);
+        newMqa.audioReceive[1].streams.push(audioReceiverStream);
+
+        this.lastMqaDataSent[mediaType].recv = cloneDeep(this.statsResults[mediaType].recv);
+      } else if (mediaType.includes('video-send')) {
+        const videoSenderStream = cloneDeep(emptyVideoTransmitStream);
 
-        getVideoSenderMqa({
-          videoSender,
+        getVideoSenderStreamMqa({
+          videoSenderStream,
           statsResults: this.statsResults,
           lastMqaDataSent: this.lastMqaDataSent,
           mediaType,
         });
-        newMqa.videoTransmit.push(videoSender);
-      } else if (mediaType.includes('video-recv') || mediaType.includes('video-share-recv')) {
-        const videoReceiver = cloneDeep(emptyVideoReceive);
+        newMqa.videoTransmit[0].streams.push(videoSenderStream);
 
-        getVideoReceiverMqa({
-          videoReceiver,
+        this.lastMqaDataSent[mediaType].send = cloneDeep(this.statsResults[mediaType].send);
+      } else if (mediaType.includes('video-share-send')) {
+        const videoSenderStream = cloneDeep(emptyVideoTransmitStream);
+
+        getVideoSenderStreamMqa({
+          videoSenderStream,
           statsResults: this.statsResults,
           lastMqaDataSent: this.lastMqaDataSent,
           mediaType,
         });
-        newMqa.videoReceive.push(videoReceiver);
+        newMqa.videoTransmit[1].streams.push(videoSenderStream);
+
+        this.lastMqaDataSent[mediaType].send = cloneDeep(this.statsResults[mediaType].send);
+      } else if (mediaType.includes('video-recv')) {
+        const videoReceiverStream = cloneDeep(emptyVideoReceiveStream);
+
+        getVideoReceiverStreamMqa({
+          videoReceiverStream,
+          statsResults: this.statsResults,
+          lastMqaDataSent: this.lastMqaDataSent,
+          mediaType,
+        });
+        newMqa.videoReceive[0].streams.push(videoReceiverStream);
+
+        this.lastMqaDataSent[mediaType].recv = cloneDeep(this.statsResults[mediaType].recv);
+      } else if (mediaType.includes('video-share-recv')) {
+        const videoReceiverStream = cloneDeep(emptyVideoReceiveStream);
+
+        getVideoReceiverStreamMqa({
+          videoReceiverStream,
+          statsResults: this.statsResults,
+          lastMqaDataSent: this.lastMqaDataSent,
+          mediaType,
+        });
+        newMqa.videoReceive[1].streams.push(videoReceiverStream);
+
+        this.lastMqaDataSent[mediaType].recv = cloneDeep(this.statsResults[mediaType].recv);
       }
     });
 
-    newMqa.intervalMetadata.peerReflexiveIP = this.statsResults.connectionType.local.ipAddress[0];
+    newMqa.intervalMetadata.peerReflexiveIP = this.statsResults.connectionType.local.ipAddress;
 
     // Adding peripheral information
-    newMqa.intervalMetadata.peripherals = [];
-
     newMqa.intervalMetadata.peripherals.push({information: _UNKNOWN_, name: MEDIA_DEVICES.SPEAKER});
     if (this.statsResults['audio-send']) {
       newMqa.intervalMetadata.peripherals.push({
-        information: this.statsResults['audio-send']?.trackLabel,
+        information: this.statsResults['audio-send'].trackLabel || _UNKNOWN_,
         name: MEDIA_DEVICES.MICROPHONE,
       });
     }
     if (this.statsResults['video-send']) {
       newMqa.intervalMetadata.peripherals.push({
-        information: this.statsResults['video-send']?.trackLabel,
+        information: this.statsResults['video-send'].trackLabel || _UNKNOWN_,
         name: MEDIA_DEVICES.CAMERA,
       });
     }
@@ -246,6 +414,16 @@ export class StatsAnalyzer extends EventsScope {
     this.mediaConnection = mediaConnection;
   }
 
+  /**
+   * Returns the local IP address for diagnostics.
+   * this is the local IP of the interface used for the current media connection
+   * a host can have many local Ip Addresses
+   * @returns {string | undefined} The local IP address.
+   */
+  getLocalIpAddress(): string {
+    return this.localIpAddress;
+  }
+
   /**
    * Starts the stats analyzer on interval
    *
@@ -267,7 +445,7 @@ export class StatsAnalyzer extends EventsScope {
         this.sendMqaData();
         this.mqaInterval = setInterval(() => {
           this.sendMqaData();
-        }, MQA_INTEVAL);
+        }, MQA_INTERVAL);
       });
     }
 
@@ -330,26 +508,6 @@ export class StatsAnalyzer extends EventsScope {
       this.statsResults[type].recv = cloneDeep(emptyReceiver);
     }
 
-    if (!this.statsResults.resolutions[type]) {
-      this.statsResults.resolutions[type] = {};
-    }
-
-    if (isSender && !this.statsResults.resolutions[type].send) {
-      this.statsResults.resolutions[type].send = cloneDeep(emptySender);
-    } else if (!isSender && !this.statsResults.resolutions[type].recv) {
-      this.statsResults.resolutions[type].recv = cloneDeep(emptyReceiver);
-    }
-
-    if (!this.statsResults.internal[type]) {
-      this.statsResults.internal[type] = {};
-    }
-
-    if (isSender && !this.statsResults.internal[type].send) {
-      this.statsResults.internal[type].send = cloneDeep(emptySender);
-    } else if (!isSender && !this.statsResults.internal[type].recv) {
-      this.statsResults.internal[type].recv = cloneDeep(emptyReceiver);
-    }
-
     switch (getStatsResult.type) {
       case 'outbound-rtp':
         this.processOutboundRTPResult(getStatsResult, type);
@@ -357,13 +515,9 @@ export class StatsAnalyzer extends EventsScope {
       case 'inbound-rtp':
         this.processInboundRTPResult(getStatsResult, type);
         break;
-      case 'track':
-        this.processTrackResult(getStatsResult, type);
-        break;
       case 'remote-inbound-rtp':
       case 'remote-outbound-rtp':
-        // @ts-ignore
-        this.compareSentAndReceived(getStatsResult, type, isSender);
+        this.compareSentAndReceived(getStatsResult, type);
         break;
       case 'remotecandidate':
       case 'remote-candidate':
@@ -373,7 +527,6 @@ export class StatsAnalyzer extends EventsScope {
         this.parseCandidate(getStatsResult, type, isSender, false);
         break;
       case 'media-source':
-        // @ts-ignore
         this.parseAudioSource(getStatsResult, type);
         break;
       default:
@@ -392,6 +545,13 @@ export class StatsAnalyzer extends EventsScope {
   filterAndParseGetStatsResults(statsItem: any, type: string, isSender: boolean) {
     const {types} = DEFAULT_GET_STATS_FILTER;
 
+    // get the successful candidate pair before parsing stats.
+    statsItem.report.forEach((report) => {
+      if (report.type === 'candidate-pair' && report.state === 'succeeded') {
+        this.successfulCandidatePair = report;
+      }
+    });
+
     statsItem.report.forEach((result) => {
       if (types.includes(result.type)) {
         this.parseGetStatsResult(result, type, isSender);
@@ -402,6 +562,12 @@ export class StatsAnalyzer extends EventsScope {
       this.statsResults[type].direction = statsItem.currentDirection;
       this.statsResults[type].trackLabel = statsItem.localTrackLabel;
       this.statsResults[type].csi = statsItem.csi;
+      this.extractAndSetLocalIpAddressInfoForDiagnostics(
+        this.successfulCandidatePair?.localCandidateId,
+        this.statsResults?.candidates
+      );
+      // reset the successful candidate pair.
+      this.successfulCandidatePair = {};
     }
   }
 
@@ -505,27 +671,16 @@ export class StatsAnalyzer extends EventsScope {
           .filter((key) => key.startsWith(keyPrefix))
           .reduce((prev, cur) => prev + (this.lastStatsResults[cur]?.recv[value] || 0), 0);
 
-      const getCurrentResolutionsStatsTotals = (keyPrefix: string, value: string): number =>
-        Object.keys(this.statsResults)
-          .filter((key) => key.startsWith(keyPrefix))
-          .reduce((prev, cur) => prev + (this.statsResults.resolutions[cur]?.recv[value] || 0), 0);
-
-      const getPreviousResolutionsStatsTotals = (keyPrefix: string, value: string): number =>
-        Object.keys(this.statsResults)
-          .filter((key) => key.startsWith(keyPrefix))
-          .reduce(
-            (prev, cur) => prev + (this.lastStatsResults.resolutions[cur]?.recv[value] || 0),
-            0
-          );
-
-      if (this.meetingMediaStatus.expected.sendAudio && this.lastStatsResults['audio-send']) {
+      // Audio Transmit
+      if (this.lastStatsResults['audio-send']) {
         // compare audio stats sent
         // NOTE: relies on there being only one sender.
         const currentStats = this.statsResults['audio-send'].send;
         const previousStats = this.lastStatsResults['audio-send'].send;
 
         if (
-          currentStats.totalPacketsSent === previousStats.totalPacketsSent ||
+          (this.meetingMediaStatus.expected.sendAudio &&
+            currentStats.totalPacketsSent === previousStats.totalPacketsSent) ||
           currentStats.totalPacketsSent === 0
         ) {
           LoggerProxy.logger.info(
@@ -534,7 +689,8 @@ export class StatsAnalyzer extends EventsScope {
           );
         } else {
           if (
-            currentStats.totalAudioEnergy === previousStats.totalAudioEnergy ||
+            (this.meetingMediaStatus.expected.sendAudio &&
+              currentStats.totalAudioEnergy === previousStats.totalAudioEnergy) ||
             currentStats.totalAudioEnergy === 0
           ) {
             LoggerProxy.logger.info(
@@ -543,7 +699,7 @@ export class StatsAnalyzer extends EventsScope {
             );
           }
 
-          if (currentStats.audioLevel === 0) {
+          if (this.meetingMediaStatus.expected.sendAudio && currentStats.audioLevel === 0) {
             LoggerProxy.logger.info(
               `StatsAnalyzer:index#compareLastStatsResult --> audio level is 0 for the user`
             );
@@ -558,45 +714,33 @@ export class StatsAnalyzer extends EventsScope {
         );
       }
 
-      if (this.meetingMediaStatus.expected.receiveAudio) {
-        // compare audio stats received
-        const currentPacketsReceived = getCurrentStatsTotals('audio-recv', 'totalPacketsReceived');
-        const previousPacketsReceived = getPreviousStatsTotals(
-          'audio-recv',
-          'totalPacketsReceived'
-        );
-        const currentSamplesReceived = getCurrentStatsTotals('audio-recv', 'totalSamplesReceived');
-        const previousSamplesReceived = getPreviousStatsTotals(
-          'audio-recv',
-          'totalSamplesReceived'
-        );
-
-        if (currentPacketsReceived === previousPacketsReceived || currentPacketsReceived === 0) {
-          LoggerProxy.logger.info(
-            `StatsAnalyzer:index#compareLastStatsResult --> No audio RTP packets received`,
-            currentPacketsReceived
-          );
-        } else if (
-          currentSamplesReceived === previousSamplesReceived ||
-          currentSamplesReceived === 0
-        ) {
-          LoggerProxy.logger.info(
-            `StatsAnalyzer:index#compareLastStatsResult --> No audio samples received`,
-            currentSamplesReceived
-          );
-        }
+      // Audio Receive
+      const currentAudioPacketsReceived = getCurrentStatsTotals(
+        'audio-recv',
+        'totalPacketsReceived'
+      );
+      const previousAudioPacketsReceived = getPreviousStatsTotals(
+        'audio-recv',
+        'totalPacketsReceived'
+      );
 
-        this.emitStartStopEvents('audio', previousPacketsReceived, currentPacketsReceived, false);
-      }
+      this.emitStartStopEvents(
+        'audio',
+        previousAudioPacketsReceived,
+        currentAudioPacketsReceived,
+        false
+      );
 
-      if (this.meetingMediaStatus.expected.sendVideo && this.lastStatsResults['video-send']) {
+      // Video Transmit
+      if (this.lastStatsResults['video-send']) {
         // compare video stats sent
         const currentStats = this.statsResults['video-send'].send;
         const previousStats = this.lastStatsResults['video-send'].send;
 
         if (
-          currentStats.totalPacketsSent === previousStats.totalPacketsSent ||
-          currentStats.totalPacketsSent === 0
+          this.meetingMediaStatus.expected.sendVideo &&
+          (currentStats.totalPacketsSent === previousStats.totalPacketsSent ||
+            currentStats.totalPacketsSent === 0)
         ) {
           LoggerProxy.logger.info(
             `StatsAnalyzer:index#compareLastStatsResult --> No video RTP packets sent`,
@@ -604,8 +748,9 @@ export class StatsAnalyzer extends EventsScope {
           );
         } else {
           if (
-            currentStats.framesEncoded === previousStats.framesEncoded ||
-            currentStats.framesEncoded === 0
+            this.meetingMediaStatus.expected.sendVideo &&
+            (currentStats.framesEncoded === previousStats.framesEncoded ||
+              currentStats.framesEncoded === 0)
           ) {
             LoggerProxy.logger.info(
               `StatsAnalyzer:index#compareLastStatsResult --> No video Frames Encoded`,
@@ -614,13 +759,14 @@ export class StatsAnalyzer extends EventsScope {
           }
 
           if (
-            this.statsResults.resolutions['video-send'].send.framesSent ===
-              this.lastStatsResults.resolutions['video-send'].send.framesSent ||
-            this.statsResults.resolutions['video-send'].send.framesSent === 0
+            this.meetingMediaStatus.expected.sendVideo &&
+            (this.statsResults['video-send'].send.framesSent ===
+              this.lastStatsResults['video-send'].send.framesSent ||
+              this.statsResults['video-send'].send.framesSent === 0)
           ) {
             LoggerProxy.logger.info(
               `StatsAnalyzer:index#compareLastStatsResult --> No video Frames sent`,
-              this.statsResults.resolutions['video-send'].send.framesSent
+              this.statsResults['video-send'].send.framesSent
             );
           }
         }
@@ -628,72 +774,28 @@ export class StatsAnalyzer extends EventsScope {
         this.emitStartStopEvents('video', previousStats.framesSent, currentStats.framesSent, true);
       }
 
-      if (this.meetingMediaStatus.expected.receiveVideo) {
-        // compare video stats received
-        const currentPacketsReceived = getCurrentStatsTotals('video-recv', 'totalPacketsReceived');
-        const previousPacketsReceived = getPreviousStatsTotals(
-          'video-recv',
-          'totalPacketsReceived'
-        );
-        const currentFramesReceived = getCurrentResolutionsStatsTotals(
-          'video-recv',
-          'framesReceived'
-        );
-        const previousFramesReceived = getPreviousResolutionsStatsTotals(
-          'video-recv',
-          'framesReceived'
-        );
-        const currentFramesDecoded = getCurrentStatsTotals('video-recv', 'framesDecoded');
-        const previousFramesDecoded = getPreviousStatsTotals('video-recv', 'framesDecoded');
-        const currentFramesDropped = getCurrentResolutionsStatsTotals(
-          'video-recv',
-          'framesDropped'
-        );
-        const previousFramesDropped = getPreviousResolutionsStatsTotals(
-          'video-recv',
-          'framesDropped'
-        );
+      // Video Receive
+      const currentVideoFramesDecoded = getCurrentStatsTotals('video-recv', 'framesDecoded');
+      const previousVideoFramesDecoded = getPreviousStatsTotals('video-recv', 'framesDecoded');
 
-        if (currentPacketsReceived === previousPacketsReceived || currentPacketsReceived === 0) {
-          LoggerProxy.logger.info(
-            `StatsAnalyzer:index#compareLastStatsResult --> No video RTP packets received`,
-            currentPacketsReceived
-          );
-        } else {
-          if (currentFramesReceived === previousFramesReceived || currentFramesReceived === 0) {
-            LoggerProxy.logger.info(
-              `StatsAnalyzer:index#compareLastStatsResult --> No video frames received`,
-              currentFramesReceived
-            );
-          }
-
-          if (currentFramesDecoded === previousFramesDecoded || currentFramesDecoded === 0) {
-            LoggerProxy.logger.info(
-              `StatsAnalyzer:index#compareLastStatsResult --> No video frames decoded`,
-              currentFramesDecoded
-            );
-          }
-
-          if (currentFramesDropped - previousFramesDropped > 10) {
-            LoggerProxy.logger.info(
-              `StatsAnalyzer:index#compareLastStatsResult --> video frames are getting dropped`,
-              currentFramesDropped - previousFramesDropped
-            );
-          }
-        }
-
-        this.emitStartStopEvents('video', previousFramesDecoded, currentFramesDecoded, false);
-      }
+      this.emitStartStopEvents(
+        'video',
+        previousVideoFramesDecoded,
+        currentVideoFramesDecoded,
+        false
+      );
 
-      if (this.meetingMediaStatus.expected.sendShare && this.lastStatsResults['video-share-send']) {
+      // Share Transmit
+      if (this.lastStatsResults['video-share-send']) {
         // compare share stats sent
 
         const currentStats = this.statsResults['video-share-send'].send;
         const previousStats = this.lastStatsResults['video-share-send'].send;
 
         if (
-          currentStats.totalPacketsSent === previousStats.totalPacketsSent ||
-          currentStats.totalPacketsSent === 0
+          this.meetingMediaStatus.expected.sendShare &&
+          (currentStats.totalPacketsSent === previousStats.totalPacketsSent ||
+            currentStats.totalPacketsSent === 0)
         ) {
           LoggerProxy.logger.info(
             `StatsAnalyzer:index#compareLastStatsResult --> No share RTP packets sent`,
@@ -701,8 +803,9 @@ export class StatsAnalyzer extends EventsScope {
           );
         } else {
           if (
-            currentStats.framesEncoded === previousStats.framesEncoded ||
-            currentStats.framesEncoded === 0
+            this.meetingMediaStatus.expected.sendShare &&
+            (currentStats.framesEncoded === previousStats.framesEncoded ||
+              currentStats.framesEncoded === 0)
           ) {
             LoggerProxy.logger.info(
               `StatsAnalyzer:index#compareLastStatsResult --> No share frames getting encoded`,
@@ -711,80 +814,34 @@ export class StatsAnalyzer extends EventsScope {
           }
 
           if (
-            this.statsResults.resolutions['video-share-send'].send.framesSent ===
-              this.lastStatsResults.resolutions['video-share-send'].send.framesSent ||
-            this.statsResults.resolutions['video-share-send'].send.framesSent === 0
+            this.meetingMediaStatus.expected.sendShare &&
+            (this.statsResults['video-share-send'].send.framesSent ===
+              this.lastStatsResults['video-share-send'].send.framesSent ||
+              this.statsResults['video-share-send'].send.framesSent === 0)
           ) {
             LoggerProxy.logger.info(
               `StatsAnalyzer:index#compareLastStatsResult --> No share frames sent`,
-              this.statsResults.resolutions['video-share-send'].send.framesSent
+              this.statsResults['video-share-send'].send.framesSent
             );
           }
         }
-      }
 
-      if (this.meetingMediaStatus.expected.sendShare) {
-        // TODO:need to check receive share value
-        // compare share stats received
-        const currentPacketsReceived = getCurrentStatsTotals(
-          'video-share-recv',
-          'totalPacketsReceived'
-        );
-        const previousPacketsReceived = getPreviousStatsTotals(
-          'video-share-recv',
-          'totalPacketsReceived'
-        );
-        const currentFramesReceived = getCurrentResolutionsStatsTotals(
-          'video-share-recv',
-          'framesReceived'
-        );
-        const previousFramesReceived = getPreviousResolutionsStatsTotals(
-          'video-share-recv',
-          'framesReceived'
-        );
-        const currentFramesDecoded = getCurrentStatsTotals('video-share-recv', 'framesDecoded');
-        const previousFramesDecoded = getPreviousStatsTotals('video-share-recv', 'framesDecoded');
-        const currentFramesDropped = getCurrentResolutionsStatsTotals(
-          'video-share-recv',
-          'framesDropped'
-        );
-        const previousFramesDropped = getPreviousResolutionsStatsTotals(
-          'video-share-recv',
-          'framesDropped'
-        );
-
-        if (currentPacketsReceived === previousPacketsReceived || currentPacketsReceived === 0) {
-          LoggerProxy.logger.info(
-            `StatsAnalyzer:index#compareLastStatsResult --> No share RTP packets received`,
-            currentPacketsReceived
-          );
-        } else {
-          if (currentFramesReceived === previousFramesReceived || currentFramesReceived === 0) {
-            LoggerProxy.logger.info(
-              `StatsAnalyzer:index#compareLastStatsResult --> No share frames received`,
-              currentFramesReceived
-            );
-          }
-
-          if (currentFramesDecoded === previousFramesDecoded || currentFramesDecoded === 0) {
-            LoggerProxy.logger.info(
-              `StatsAnalyzer:index#compareLastStatsResult --> No share frames decoded`,
-              currentFramesDecoded
-            );
-          }
+        this.emitStartStopEvents('share', previousStats.framesSent, currentStats.framesSent, true);
+      }
 
-          if (currentFramesDropped - previousFramesDropped > 10) {
-            LoggerProxy.logger.info(
-              `StatsAnalyzer:index#compareLastStatsResult --> share frames are getting dropped`,
-              currentFramesDropped - previousFramesDropped
-            );
-          }
-        }
+      // Share receive
+      const currentShareFramesDecoded = getCurrentStatsTotals('video-share-recv', 'framesDecoded');
+      const previousShareFramesDecoded = getPreviousStatsTotals(
+        'video-share-recv',
+        'framesDecoded'
+      );
 
-        // we are not calling emitStartStopEvents() for sending or receiving share because sharing is often started and stopped
-        // in meetings and this.meetingMediaStatus.expected values can be out of sync with the actual packet flow
-        // so we would send "sharing stopped" events incorrectly
-      }
+      this.emitStartStopEvents(
+        'share',
+        previousShareFramesDecoded,
+        currentShareFramesDecoded,
+        false
+      );
     }
   }
 
@@ -875,51 +932,20 @@ export class StatsAnalyzer extends EventsScope {
     const sendrecvType = STATS.SEND_DIRECTION;
 
     if (result.bytesSent) {
-      let kilobytes = 0;
+      const kilobytes = 0;
 
       if (result.frameWidth && result.frameHeight) {
-        this.statsResults.resolutions[mediaType][sendrecvType].width = result.frameWidth;
-        this.statsResults.resolutions[mediaType][sendrecvType].height = result.frameHeight;
-        this.statsResults.resolutions[mediaType][sendrecvType].framesSent = result.framesSent;
-        this.statsResults.resolutions[mediaType][sendrecvType].hugeFramesSent =
-          result.hugeFramesSent;
-      }
-
-      if (!this.statsResults.internal[mediaType][sendrecvType].prevBytesSent) {
-        this.statsResults.internal[mediaType][sendrecvType].prevBytesSent = result.bytesSent;
-      }
-      if (!this.statsResults.internal[mediaType][sendrecvType].framesEncoded) {
-        this.statsResults.internal[mediaType][sendrecvType].framesEncoded = result.framesEncoded;
+        this.statsResults[mediaType][sendrecvType].width = result.frameWidth;
+        this.statsResults[mediaType][sendrecvType].height = result.frameHeight;
+        this.statsResults[mediaType][sendrecvType].framesSent = result.framesSent;
+        this.statsResults[mediaType][sendrecvType].hugeFramesSent = result.hugeFramesSent;
       }
-      if (!this.statsResults.internal[mediaType][sendrecvType].keyFramesEncoded) {
-        this.statsResults.internal[mediaType][sendrecvType].keyFramesEncoded =
-          result.keyFramesEncoded;
-      }
-
-      const bytes =
-        result.bytesSent - this.statsResults.internal[mediaType][sendrecvType].prevBytesSent;
-
-      this.statsResults.internal[mediaType][sendrecvType].prevBytesSent = result.bytesSent;
-
-      kilobytes = bytes / 1024;
 
       this.statsResults[mediaType][sendrecvType].availableBandwidth = kilobytes.toFixed(1);
-      this.statsResults[mediaType].bytesSent = kilobytes;
-
-      this.statsResults[mediaType][sendrecvType].framesEncoded =
-        result.framesEncoded - this.statsResults.internal[mediaType][sendrecvType].framesEncoded;
-      this.statsResults[mediaType][sendrecvType].keyFramesEncoded =
-        result.keyFramesEncoded -
-        this.statsResults.internal[mediaType][sendrecvType].keyFramesEncoded;
-      this.statsResults.internal[mediaType].outboundRtpId = result.id;
 
-      if (!this.statsResults.internal[mediaType][sendrecvType].packetsSent) {
-        this.statsResults.internal[mediaType][sendrecvType].packetsSent = result.packetsSent;
-      }
-
-      this.statsResults[mediaType][sendrecvType].packetsSent =
-        result.packetsSent - this.statsResults.internal[mediaType][sendrecvType].packetsSent;
-      this.statsResults.internal[mediaType][sendrecvType].packetsSent = result.packetsSent;
+      this.statsResults[mediaType][sendrecvType].framesEncoded = result.framesEncoded;
+      this.statsResults[mediaType][sendrecvType].keyFramesEncoded = result.keyFramesEncoded;
+      this.statsResults[mediaType][sendrecvType].packetsSent = result.packetsSent;
 
       // Data saved to send MQA metrics
 
@@ -958,79 +984,77 @@ export class StatsAnalyzer extends EventsScope {
     if (result.bytesReceived) {
       let kilobytes = 0;
       const receiveSlot = this.receiveSlotCallback(result.ssrc);
+      const sourceState = receiveSlot?.sourceState;
       const idAndCsi = receiveSlot
         ? `id: "${receiveSlot.id || ''}"${receiveSlot.csi ? ` and csi: ${receiveSlot.csi}` : ''}`
         : '';
 
-      if (result.frameWidth && result.frameHeight) {
-        this.statsResults.resolutions[mediaType][sendrecvType].width = result.frameWidth;
-        this.statsResults.resolutions[mediaType][sendrecvType].height = result.frameHeight;
-        this.statsResults.resolutions[mediaType][sendrecvType].framesReceived =
-          result.framesReceived;
-      }
-
-      if (!this.statsResults.internal[mediaType][sendrecvType].prevBytesReceived) {
-        this.statsResults.internal[mediaType][sendrecvType].prevBytesReceived =
-          result.bytesReceived;
-      }
+      const bytes =
+        result.bytesReceived - this.statsResults[mediaType][sendrecvType].totalBytesReceived;
 
-      if (!this.statsResults.internal[mediaType][sendrecvType].pliCount) {
-        this.statsResults.internal[mediaType][sendrecvType].pliCount = result.pliCount;
-      }
+      kilobytes = bytes / 1024;
+      this.statsResults[mediaType][sendrecvType].availableBandwidth = kilobytes.toFixed(1);
 
-      if (!this.statsResults.internal[mediaType][sendrecvType].packetsLost) {
-        this.statsResults.internal[mediaType][sendrecvType].packetsLost = result.packetsLost;
+      let currentPacketsLost =
+        result.packetsLost - this.statsResults[mediaType][sendrecvType].totalPacketsLost;
+      if (currentPacketsLost < 0) {
+        currentPacketsLost = 0;
       }
+      const packetsReceivedDiff =
+        result.packetsReceived - this.statsResults[mediaType][sendrecvType].totalPacketsReceived;
+      this.statsResults[mediaType][sendrecvType].totalPacketsReceived = result.packetsReceived;
 
-      if (!this.statsResults.internal[mediaType][sendrecvType].totalPacketsReceived) {
-        this.statsResults.internal[mediaType][sendrecvType].totalPacketsReceived =
-          result.packetsReceived;
+      if (packetsReceivedDiff === 0) {
+        if (receiveSlot && sourceState === 'live') {
+          LoggerProxy.logger.info(
+            `StatsAnalyzer:index#processInboundRTPResult --> No packets received for mediaType: ${mediaType}, receive slot ${idAndCsi}. Total packets received on slot: `,
+            result.packetsReceived
+          );
+        }
       }
 
-      if (!this.statsResults.internal[mediaType][sendrecvType].lastPacketReceivedTimestamp) {
-        this.statsResults.internal[mediaType][sendrecvType].lastPacketReceivedTimestamp =
-          result.lastPacketReceivedTimestamp;
-      }
+      if (mediaType.startsWith('video') || mediaType.startsWith('share')) {
+        const videoFramesReceivedDiff =
+          result.framesReceived - this.statsResults[mediaType][sendrecvType].framesReceived;
 
-      const bytes =
-        result.bytesReceived -
-        this.statsResults.internal[mediaType][sendrecvType].prevBytesReceived;
+        if (videoFramesReceivedDiff === 0) {
+          if (receiveSlot && sourceState === 'live') {
+            LoggerProxy.logger.info(
+              `StatsAnalyzer:index#processInboundRTPResult --> No frames received for mediaType: ${mediaType},  receive slot ${idAndCsi}. Total frames received on slot: `,
+              result.framesReceived
+            );
+          }
+        }
 
-      this.statsResults.internal[mediaType][sendrecvType].prevBytesReceived = result.bytesReceived;
+        const videoFramesDecodedDiff =
+          result.framesDecoded - this.statsResults[mediaType][sendrecvType].framesDecoded;
 
-      kilobytes = bytes / 1024;
-      this.statsResults[mediaType][sendrecvType].availableBandwidth = kilobytes.toFixed(1);
-      this.statsResults[mediaType].bytesReceived = kilobytes.toFixed(1);
-
-      this.statsResults[mediaType][sendrecvType].pliCount =
-        result.pliCount - this.statsResults.internal[mediaType][sendrecvType].pliCount;
-      this.statsResults[mediaType][sendrecvType].currentPacketsLost =
-        result.packetsLost - this.statsResults.internal[mediaType][sendrecvType].packetsLost;
-      if (this.statsResults[mediaType][sendrecvType].currentPacketsLost < 0) {
-        this.statsResults[mediaType][sendrecvType].currentPacketsLost = 0;
-      }
+        if (videoFramesDecodedDiff === 0) {
+          if (receiveSlot && sourceState === 'live') {
+            LoggerProxy.logger.info(
+              `StatsAnalyzer:index#processInboundRTPResult --> No frames decoded for mediaType: ${mediaType},  receive slot ${idAndCsi}. Total frames decoded on slot: `,
+              result.framesDecoded
+            );
+          }
+        }
 
-      this.statsResults[mediaType][sendrecvType].packetsReceived =
-        result.packetsReceived -
-        this.statsResults.internal[mediaType][sendrecvType].totalPacketsReceived;
-      this.statsResults.internal[mediaType][sendrecvType].totalPacketsReceived =
-        result.packetsReceived;
+        const videoFramesDroppedDiff =
+          result.framesDropped - this.statsResults[mediaType][sendrecvType].framesDropped;
 
-      if (this.statsResults[mediaType][sendrecvType].packetsReceived === 0) {
-        if (receiveSlot) {
-          LoggerProxy.logger.info(
-            `StatsAnalyzer:index#processInboundRTPResult --> No packets received for receive slot ${idAndCsi}`,
-            this.statsResults[mediaType][sendrecvType].packetsReceived
-          );
+        if (videoFramesDroppedDiff > 10) {
+          if (receiveSlot && sourceState === 'live') {
+            LoggerProxy.logger.info(
+              `StatsAnalyzer:index#processInboundRTPResult --> Frames dropped for mediaType: ${mediaType},  receive slot ${idAndCsi}. Total frames dropped on slot: `,
+              result.framesDropped
+            );
+          }
         }
       }
 
       //  Check the over all packet Lost ratio
       this.statsResults[mediaType][sendrecvType].currentPacketLossRatio =
-        this.statsResults[mediaType][sendrecvType].currentPacketsLost > 0
-          ? this.statsResults[mediaType][sendrecvType].currentPacketsLost /
-            (this.statsResults[mediaType][sendrecvType].packetsReceived +
-              this.statsResults[mediaType][sendrecvType].currentPacketsLost)
+        currentPacketsLost > 0
+          ? currentPacketsLost / (packetsReceivedDiff + currentPacketsLost)
           : 0;
       if (this.statsResults[mediaType][sendrecvType].currentPacketLossRatio > 3) {
         LoggerProxy.logger.info(
@@ -1039,6 +1063,12 @@ export class StatsAnalyzer extends EventsScope {
         );
       }
 
+      if (result.frameWidth && result.frameHeight) {
+        this.statsResults[mediaType][sendrecvType].width = result.frameWidth;
+        this.statsResults[mediaType][sendrecvType].height = result.frameHeight;
+        this.statsResults[mediaType][sendrecvType].framesReceived = result.framesReceived;
+      }
+
       // TODO: check the packet loss value is negative values here
 
       if (result.packetsLost) {
@@ -1056,6 +1086,7 @@ export class StatsAnalyzer extends EventsScope {
       this.statsResults[mediaType][sendrecvType].totalPliCount = result.pliCount;
       this.statsResults[mediaType][sendrecvType].framesDecoded = result.framesDecoded;
       this.statsResults[mediaType][sendrecvType].keyFramesDecoded = result.keyFramesDecoded;
+      this.statsResults[mediaType][sendrecvType].framesDropped = result.framesDropped;
 
       this.statsResults[mediaType][sendrecvType].decoderImplementation =
         result.decoderImplementation;
@@ -1080,6 +1111,48 @@ export class StatsAnalyzer extends EventsScope {
     }
   }
 
+  /**
+   * extracts the local Ip address from the statsResult object by looking at stats results candidates
+   * and matches that ID with the successful candidate pair. It looks at the type of local candidate it is
+   * and then extracts the IP address from the relatedAddress or address property based on conditions known in webrtc
+   * note, there are known incompatibilities and it is possible for this to set undefined, or for the IP address to be the public IP address
+   * for example, firefox does not set the relayProtocol, and if the user is behind a NAT it might be the public IP
+   * @private
+   * @param {string} successfulCandidatePairId - The ID of the successful candidate pair.
+   * @param {Object} candidates - the stats result candidates
+   * @returns {void}
+   */
+  extractAndSetLocalIpAddressInfoForDiagnostics = (
+    successfulCandidatePairId: string,
+    candidates: {[key: string]: Record<string, unknown>}
+  ) => {
+    let newIpAddress = '';
+    if (successfulCandidatePairId && !isEmpty(candidates)) {
+      const localCandidate = candidates[successfulCandidatePairId];
+      if (localCandidate) {
+        if (localCandidate.candidateType === 'host') {
+          // if it's a host candidate, use the address property - it will be the local IP
+          newIpAddress = `${localCandidate.address}`;
+        } else if (localCandidate.candidateType === 'prflx') {
+          // if it's a peer reflexive candidate and we're not using a relay (there is no relayProtocol set)
+          // then look at the relatedAddress - it will be the local
+          //
+          // Firefox doesn't populate the relayProtocol property
+          if (!localCandidate.relayProtocol) {
+            newIpAddress = `${localCandidate.relatedAddress}`;
+          } else {
+            // if it's a peer reflexive candidate and we are using a relay -
+            // in that case the relatedAddress will be the IP of the TURN server (Linus),
+            // so we can only look at the address, but it might be local IP or public IP,
+            // depending on if the user is behind a NAT or not
+            newIpAddress = `${localCandidate.address}`;
+          }
+        }
+      }
+    }
+    this.localIpAddress = newIpAddress;
+  };
+
   /**
    * Processes remote and local candidate result and stores
    * @private
@@ -1094,118 +1167,53 @@ export class StatsAnalyzer extends EventsScope {
     if (!result || !result.id) {
       return;
     }
-    const RemoteCandidateType = {};
-    const RemoteTransport = {};
-    const RemoteIpAddress = {};
-    const RemoteNetworkType = {};
-
-    if (!result.id) return;
-
-    const sendRecvType = isSender ? STATS.SEND_DIRECTION : STATS.RECEIVE_DIRECTION;
-    const ipType = isRemote ? STATS.REMOTE : STATS.LOCAL;
-
-    if (!RemoteCandidateType[result.id]) {
-      RemoteCandidateType[result.id] = [];
-    }
-
-    if (!RemoteTransport[result.id]) {
-      RemoteTransport[result.id] = [];
-    }
-
-    if (!RemoteIpAddress[result.id]) {
-      RemoteIpAddress[result.id] = [];
-    }
-    if (!RemoteNetworkType[result.id]) {
-      RemoteNetworkType[result.id] = [];
-    }
 
-    if (
-      result.candidateType &&
-      RemoteCandidateType[result.id].indexOf(result.candidateType) === -1
-    ) {
-      RemoteCandidateType[result.id].push(result.candidateType);
+    // We only care about the successful local candidate
+    if (this.successfulCandidatePair?.localCandidateId !== result.id) {
+      return;
     }
 
-    if (result.protocol && RemoteTransport[result.id].indexOf(result.protocol) === -1) {
-      RemoteTransport[result.id].push(result.protocol.toUpperCase());
+    let transport;
+    if (result.relayProtocol) {
+      transport = result.relayProtocol.toUpperCase();
+    } else if (result.protocol) {
+      transport = result.protocol.toUpperCase();
     }
 
-    if (
-      result.ip &&
-      RemoteIpAddress[result.id].indexOf(`${result.ip}:${result.portNumber}`) === -1
-    ) {
-      RemoteIpAddress[result.id].push(`${result.ip}`); // TODO: Add ports
-    }
+    const sendRecvType = isSender ? STATS.SEND_DIRECTION : STATS.RECEIVE_DIRECTION;
+    const ipType = isRemote ? STATS.REMOTE : STATS.LOCAL;
 
-    if (result.networkType && RemoteNetworkType[result.id].indexOf(result.networkType) === -1) {
-      RemoteNetworkType[result.id].push(result.networkType);
+    if (!this.statsResults.candidates) {
+      this.statsResults.candidates = {};
     }
 
-    this.statsResults.internal.candidates[result.id] = {
-      candidateType: RemoteCandidateType[result.id],
-      ipAddress: RemoteIpAddress[result.id],
+    this.statsResults.candidates[result.id] = {
+      candidateType: result.candidateType,
+      ipAddress: result.ip, // TODO: add ports
+      relatedAddress: result.relatedAddress,
+      relatedPort: result.relatedPort,
+      relayProtocol: result.relayProtocol,
+      protocol: result.protocol,
+      address: result.address,
       portNumber: result.port,
-      networkType: RemoteNetworkType[result.id],
+      networkType: result.networkType,
       priority: result.priority,
-      transport: RemoteTransport[result.id],
+      transport,
       timestamp: result.time,
       id: result.id,
       type: result.type,
     };
 
-    this.statsResults.connectionType[ipType].candidateType = RemoteCandidateType[result.id];
-    this.statsResults.connectionType[ipType].ipAddress = RemoteIpAddress[result.id];
+    this.statsResults.connectionType[ipType].candidateType = result.candidateType;
+    this.statsResults.connectionType[ipType].ipAddress = result.ipAddress;
 
     this.statsResults.connectionType[ipType].networkType =
-      RemoteNetworkType[result.id][0] === NETWORK_TYPE.VPN
-        ? NETWORK_TYPE.UNKNOWN
-        : RemoteNetworkType[result.id][0];
-    this.statsResults.connectionType[ipType].transport = RemoteTransport[result.id];
+      result.networkType === NETWORK_TYPE.VPN ? NETWORK_TYPE.UNKNOWN : result.networkType;
+    this.statsResults.connectionType[ipType].transport = transport;
 
     this.statsResults[type][sendRecvType].totalRoundTripTime = result.totalRoundTripTime;
   };
 
-  /**
-   * Process Track results
-   *
-   * @private
-   * @param {*} result
-   * @param {*} mediaType
-   * @returns {void}
-   * @memberof StatsAnalyzer
-   */
-  private processTrackResult(result: any, mediaType: any) {
-    if (!result || result.type !== 'track') {
-      return;
-    }
-
-    const sendrecvType =
-      result.remoteSource === true ? STATS.RECEIVE_DIRECTION : STATS.SEND_DIRECTION;
-
-    if (sendrecvType === STATS.RECEIVE_DIRECTION) {
-      this.statsResults.resolutions[mediaType][sendrecvType].framesReceived = result.framesReceived;
-      this.statsResults.resolutions[mediaType][sendrecvType].framesDecoded = result.framesDecoded;
-      this.statsResults.resolutions[mediaType][sendrecvType].framesDropped = result.framesDropped;
-    }
-
-    if (result.trackIdentifier && !mediaType.includes('audio')) {
-      this.statsResults.resolutions[mediaType][sendrecvType].trackIdentifier =
-        result.trackIdentifier;
-
-      const jitterBufferDelay = result && result.jitterBufferDelay;
-      const jitterBufferEmittedCount = result && result.jitterBufferEmittedCount;
-
-      this.statsResults.resolutions[mediaType][sendrecvType].avgJitterDelay =
-        jitterBufferEmittedCount && +jitterBufferDelay / +jitterBufferEmittedCount;
-
-      // Used to calculate the jitter
-      this.statsResults.resolutions[mediaType][sendrecvType].jitterBufferDelay =
-        result.jitterBufferDelay;
-      this.statsResults.resolutions[mediaType][sendrecvType].jitterBufferEmittedCount =
-        result.jitterBufferEmittedCount;
-    }
-  }
-
   /**
    *
    * @private
@@ -1216,20 +1224,15 @@ export class StatsAnalyzer extends EventsScope {
    */
   compareSentAndReceived(result, type) {
     // Don't compare on transceivers without a sender.
-    if (!type || !this.statsResults.internal[type].send) {
+    if (!type || !this.statsResults[type].send) {
       return;
     }
 
     const mediaType = type;
 
-    if (!this.statsResults.internal[mediaType].send.totalPacketsLostOnReceiver) {
-      this.statsResults.internal[mediaType].send.totalPacketsLostOnReceiver = result.packetsLost;
-    }
-
     const currentPacketLoss =
-      result.packetsLost - this.statsResults.internal[mediaType].send.totalPacketsLostOnReceiver;
+      result.packetsLost - this.statsResults[mediaType].send.totalPacketsLostOnReceiver;
 
-    this.statsResults.internal[mediaType].send.totalPacketsLostOnReceiver = result.packetsLost;
     this.statsResults[mediaType].send.packetsLostOnReceiver = currentPacketLoss;
     this.statsResults[mediaType].send.totalPacketsLostOnReceiver = result.packetsLost;