feat(AvgRTPStatsReporter): batch avg RTP stats

Tries to batch as many reports as possible into single analytics event
and sends all of them under "avg.rtp.stats" event name.

Also converts dots to underscores in all of the stat names, because now
they become JSON keys where dots are not allowed.

modules/statistics/AvgRTPStatsReporter.js

 import Statistics from './statistics';
 import * as VideoType from '../../service/RTC/VideoType';
 
+/**
+ * All avg RTP stats are currently reported under 1 event name, but under
+ * different keys. This constant stores the name of this event.
+ * Example structure of "avg.rtp.stats" analytics event:
+ *
+ * {
+ *   "stat_avg_rtt": {
+ *     value: 200,
+ *     samples: [ 100, 200, 300 ]
+ *   },
+ *   "stat_avg_packetloss_total": {
+ *     value: 10,
+ *     samples: [ 5, 10, 15]
+ *   },
+ *   "p2p_stat_avg_packetloss_total": {
+ *     value: 15,
+ *     samples: [ 10, 15, 20]
+ *   }
+ * }
+ *
+ * Note that the samples array is currently emitted for debug purposes only and
+ * can be removed anytime soon from the structure.
+ *
+ * Also not all values are always present in "avg.rtp.stats", some of the values
+ * are obtained and calculated as part of different process/event pipe. For
+ * example {@link ConnectionAvgStats} instances are doing the reports for each
+ * {@link TraceablePeerConnection} and work independently from the main stats
+ * pipe.
+ *
+ * @type {string}
+ */
+const AVG_RTP_STATS_EVENT = 'avg.rtp.stats';
+
 const logger = getLogger(__filename);
 
 /**
     }
 
     /**
-     * Calculates an average and submit the report to the analytics module.
-     * @param {boolean} isP2P indicates if the report is to be submitted for
-     * the P2P connection (when conference is currently in the P2P mode). This
-     * will add 'p2p.' prefix to the name of the event. All averages should be
-     * cleared when the conference switches, between P2P and JVB modes.
+     * Appends the report to the analytics "data" object. The object will be
+     * added under {@link this.name} key or "p2p_" + {@link this.name} if
+     * <tt>isP2P</tt> is <tt>true</tt>.
+     * @param {Object} report the analytics "data" object
+     * @param {boolean} isP2P <tt>true</tt> if the stats is being report for
+     * P2P connection or <tt>false</tt> for the JVB connection.
      */
-    report(isP2P) {
-        Statistics.analytics.sendEvent(
-            `${isP2P ? 'p2p.' : ''}${this.name}`,
-            {
-                value: this.calculate(),
-                samples: this.samples
-            });
+    appendReport(report, isP2P) {
+        report[`${isP2P ? 'p2p_' : ''}${this.name}`] = {
+            value: this.calculate(),
+            samples: this.samples
+        };
     }
 
     /**
          * Average round trip time reported by the ICE candidate pair.
          * @type {AverageStatReport}
          */
-        this._avgRTT = new AverageStatReport('stat.avg.rtt');
+        this._avgRTT = new AverageStatReport('stat_avg_rtt');
 
         /**
          * Map stores average RTT to the JVB reported by remote participants.
 
         if (this._sampleIdx >= this._n) {
             if (RTCBrowserType.supportsRTTStatistics()) {
-                this._avgRTT.report(this.isP2P);
+                const batchReport = { };
+
+                this._avgRTT.appendReport(batchReport, this.isP2P);
 
                 // Report end to end RTT only for JVB
                 if (!this.isP2P) {
                     const avgLocalRTT = this._avgRTT.calculate();
 
                     if (!isNaN(avgLocalRTT) && !isNaN(avgRemoteRTT)) {
-                        Statistics.analytics.sendEvent(
-                            'stat.avg.end2endrtt',
-                            { value: avgLocalRTT + avgRemoteRTT });
+                        // eslint-disable-next-line camelcase
+                        batchReport.stat_avg_end2endrtt
+                            = { value: avgLocalRTT + avgRemoteRTT };
                     }
                 }
+
+                Statistics.analytics.sendEvent(
+                    AVG_RTP_STATS_EVENT, batchReport);
             }
 
             this._resetAvgStats();
         let rttAvg = this._avgRemoteRTTMap.get(id);
 
         if (!rttAvg && validData) {
-            rttAvg = new AverageStatReport(`${id}.stat.rtt`);
+            rttAvg = new AverageStatReport(`${id}_stat_rtt`);
             this._avgRemoteRTTMap.set(id, rttAvg);
         }
 
          * @private
          */
         this._avgAudioBitrateUp
-            = new AverageStatReport('stat.avg.bitrate.audio.upload');
+            = new AverageStatReport('stat_avg_bitrate_audio_upload');
 
         /**
          * Average audio download bitrate
          * @private
          */
         this._avgAudioBitrateDown
-            = new AverageStatReport('stat.avg.bitrate.audio.download');
+            = new AverageStatReport('stat_avg_bitrate_audio_download');
 
         /**
          * Average video upload bitrate
          * @private
          */
         this._avgVideoBitrateUp
-            = new AverageStatReport('stat.avg.bitrate.video.upload');
+            = new AverageStatReport('stat_avg_bitrate_video_upload');
 
         /**
          * Average video download bitrate
          * @private
          */
         this._avgVideoBitrateDown
-            = new AverageStatReport('stat.avg.bitrate.video.download');
+            = new AverageStatReport('stat_avg_bitrate_video_download');
 
         /**
          * Average upload bandwidth
          * @private
          */
         this._avgBandwidthUp
-            = new AverageStatReport('stat.avg.bandwidth.upload');
+            = new AverageStatReport('stat_avg_bandwidth_upload');
 
         /**
          * Average download bandwidth
          * @private
          */
         this._avgBandwidthDown
-            = new AverageStatReport('stat.avg.bandwidth.download');
+            = new AverageStatReport('stat_avg_bandwidth_download');
 
         /**
          * Average total packet loss
          * @private
          */
         this._avgPacketLossTotal
-            = new AverageStatReport('stat.avg.packetloss.total');
+            = new AverageStatReport('stat_avg_packetloss_total');
 
         /**
          * Average upload packet loss
          * @private
          */
         this._avgPacketLossUp
-            = new AverageStatReport('stat.avg.packetloss.upload');
+            = new AverageStatReport('stat_avg_packetloss_upload');
 
         /**
          * Average download packet loss
          * @private
          */
         this._avgPacketLossDown
-            = new AverageStatReport('stat.avg.packetloss.download');
+            = new AverageStatReport('stat_avg_packetloss_download');
 
         /**
          * Average FPS for remote videos
          * @type {AverageStatReport}
          * @private
          */
-        this._avgRemoteFPS = new AverageStatReport('stat.avg.framerate.remote');
+        this._avgRemoteFPS = new AverageStatReport('stat_avg_framerate_remote');
 
         /**
          * Average FPS for remote screen streaming videos (reported only if not
          * @private
          */
         this._avgRemoteScreenFPS
-            = new AverageStatReport('stat.avg.framerate.screen.remote');
+            = new AverageStatReport('stat_avg_framerate_screen_remote');
 
         /**
          * Average FPS for local video (camera)
          * @type {AverageStatReport}
          * @private
          */
-        this._avgLocalFPS = new AverageStatReport('stat.avg.framerate.local');
+        this._avgLocalFPS = new AverageStatReport('stat_avg_framerate_local');
 
         /**
          * Average FPS for local screen streaming video (reported only if not
          * @private
          */
         this._avgLocalScreenFPS
-            = new AverageStatReport('stat.avg.framerate.screen.local');
+            = new AverageStatReport('stat_avg_framerate_screen_local');
 
         /**
          * Average connection quality as defined by
          * @type {AverageStatReport}
          * @private
          */
-        this._avgCQ = new AverageStatReport('stat.avg.cq');
+        this._avgCQ = new AverageStatReport('stat_avg_cq');
 
         this._onLocalStatsUpdated = data => this._calculateAvgStats(data);
         conference.on(
         this._sampleIdx += 1;
 
         if (this._sampleIdx >= this._n) {
-            this._avgAudioBitrateUp.report(isP2P);
-            this._avgAudioBitrateDown.report(isP2P);
+            const batchReport = { };
 
-            this._avgVideoBitrateUp.report(isP2P);
-            this._avgVideoBitrateDown.report(isP2P);
+            this._avgAudioBitrateUp.appendReport(batchReport, isP2P);
+            this._avgAudioBitrateDown.appendReport(batchReport, isP2P);
+
+            this._avgVideoBitrateUp.appendReport(batchReport, isP2P);
+            this._avgVideoBitrateDown.appendReport(batchReport, isP2P);
 
             if (RTCBrowserType.supportsBandwidthStatistics()) {
-                this._avgBandwidthUp.report(isP2P);
-                this._avgBandwidthDown.report(isP2P);
+                this._avgBandwidthUp.appendReport(batchReport, isP2P);
+                this._avgBandwidthDown.appendReport(batchReport, isP2P);
             }
-            this._avgPacketLossUp.report(isP2P);
-            this._avgPacketLossDown.report(isP2P);
-            this._avgPacketLossTotal.report(isP2P);
+            this._avgPacketLossUp.appendReport(batchReport, isP2P);
+            this._avgPacketLossDown.appendReport(batchReport, isP2P);
+            this._avgPacketLossTotal.appendReport(batchReport, isP2P);
 
-            this._avgRemoteFPS.report(isP2P);
+            this._avgRemoteFPS.appendReport(batchReport, isP2P);
             if (!isNaN(this._avgRemoteScreenFPS.calculate())) {
-                this._avgRemoteScreenFPS.report(isP2P);
+                this._avgRemoteScreenFPS.appendReport(batchReport, isP2P);
             }
-            this._avgLocalFPS.report(isP2P);
+            this._avgLocalFPS.appendReport(batchReport, isP2P);
             if (!isNaN(this._avgLocalScreenFPS.calculate())) {
-                this._avgLocalScreenFPS.report(isP2P);
+                this._avgLocalScreenFPS.appendReport(batchReport, isP2P);
             }
 
-            this._avgCQ.report(isP2P);
+            this._avgCQ.appendReport(batchReport, isP2P);
+
+            Statistics.analytics.sendEvent(AVG_RTP_STATS_EVENT, batchReport);
 
             this._resetAvgStats();
         }