use statistics module to process peer connection statistics

JitsiConference.js

         this.settings);
     this.room.updateDeviceAvailability(RTC.getDeviceAvailability());
     this.rtc = new RTC(this.room, options);
-    this.statistics = new Statistics({
+    this.statistics = new Statistics(this.xmpp, {
         callStatsID: this.options.config.callStatsID,
         callStatsSecret: this.options.config.callStatsSecret,
-        disableThirdPartyRequests: this.options.config.disableThirdPartyRequests
+        disableThirdPartyRequests: this.options.config.disableThirdPartyRequests,
     });
     setupListeners(this);
     JitsiMeetJS._gumFailedHandler.push(function(error) {
 
             conference.rtc.setAudioLevel(jid, level);
         });
+        conference.statistics.addConnectionStatsListener(function (stats) {
+            var ssrc2resolution = stats.resolution;
+
+            var id2resolution = {};
+
+            // preprocess resolutions: group by user id, skip incorrect resolutions etc.
+            Object.keys(ssrc2resolution).forEach(function (ssrc) {
+                var resolution = ssrc2resolution[ssrc];
+
+                if (!resolution.width || !resolution.height ||
+                    resolution.width == -1 || resolution.height == -1) { // it also may be "-1"
+                    return;
+                }
+
+                var jid = conference.room.getJidBySSRC(ssrc);
+                if (!jid) {
+                    return;
+                }
+
+                var id;
+                if (jid === conference.room.session.me) {
+                    id = conference.myUserId();
+                } else {
+                    id = Strophe.getResourceFromJid(jid);
+                }
+
+                if (!id) {
+                    return;
+                }
+
+                // ssrc to resolution map for user id
+                var idResolutions = id2resolution[id] || {};
+                idResolutions[ssrc] = resolution;
+
+                id2resolution[id] = idResolutions;
+            });
+
+            stats.resolution = id2resolution;
+
+            conference.eventEmitter.emit(JitsiConferenceEvents.CONNECTION_STATS, stats);
+        });
         conference.xmpp.addListener(XMPPEvents.DISPOSE_CONFERENCE,
             function () {
                 conference.statistics.dispose();

JitsiConferenceEvents.js

      */
     AVATAR_CHANGED: "conference.avatarChanged",
     /**
-     * New connection statistics are received.
+     * New local connection statistics are received.
      */
-    CONNECTION_STATS_RECEIVED: "conference.connectionStatsReceived",
+    CONNECTION_STATS: "conference.connectionStats",
     /**
      * The Last N set is changed.
      */

doc/API.md

         - START_MUTED_POLICY_CHANGED - notifies that all new participants will join with muted audio/video stream (parameters - JS object with 2 properties - audio(boolean), video(boolean))
         - STARTED_MUTED - notifies that the local user has started muted
         - AVAILABLE_DEVICES_CHANGED - notifies that available participant devices changed (camera or microphone was added or removed) (parameters - id(string), devices(JS object with 2 properties - audio(boolean), video(boolean)))
+        - CONNECTION_STATS - New local connection statistics are received. (parameters - stats(object))
 
     2. connection
         - CONNECTION_FAILED - indicates that the server connection failed.

modules/statistics/RTPStatsCollector.js

-/* global require, ssrc2jid */
-/* jshint -W117 */
+/* global require */
+/* jshint -W101 */
 
 var logger = require("jitsi-meet-logger").getLogger(__filename);
 var RTCBrowserType = require("../RTC/RTCBrowserType");
 
 /* Whether we support the browser we are running into for logging statistics */
 var browserSupported = RTCBrowserType.isChrome() ||
-    RTCBrowserType.isOpera();
+        RTCBrowserType.isOpera() || RTCBrowserType.isFirefox();
 
 var keyMap = {};
 keyMap[RTCBrowserType.RTC_BROWSER_FIREFOX] = {
 {
     this.ssrc2Loss = {};
     this.ssrc2AudioLevel = {};
-    this.ssrc2bitrate = {};
+    this.ssrc2bitrate = {
+        download: 0,
+        upload: 0
+    };
     this.ssrc2resolution = {};
 }
 
 /**
- * Sets packets loss rate for given <tt>ssrc</tt> that blong to the peer
+ * Sets packets loss rate for given <tt>ssrc</tt> that belong to the peer
  * represented by this instance.
  * @param lossRate new packet loss rate value to be set.
  */
-PeerStats.prototype.setSsrcLoss = function (lossRate)
-{
-    this.ssrc2Loss = lossRate;
+PeerStats.prototype.setSsrcLoss = function (lossRate) {
+    this.ssrc2Loss = lossRate || {};
 };
 
 /**
  * represented by this instance.
  * @param resolution new resolution value to be set.
  */
-PeerStats.prototype.setSsrcResolution = function (resolution)
-{
-    if(resolution === null && this.ssrc2resolution[ssrc])
-    {
-        delete this.ssrc2resolution[ssrc];
-    }
-    else if(resolution !== null)
-        this.ssrc2resolution[ssrc] = resolution;
+PeerStats.prototype.setSsrcResolution = function (resolution) {
+    this.ssrc2resolution = resolution || {};
 };
 
 /**
- * Sets the bit rate for given <tt>ssrc</tt> that blong to the peer
+ * Sets the bit rate for given <tt>ssrc</tt> that belong to the peer
  * represented by this instance.
- * @param ssrc audio or video RTP stream SSRC.
  * @param bitrate new bitrate value to be set.
  */
-PeerStats.prototype.setSsrcBitrate = function (ssrc, bitrate)
-{
-    if(this.ssrc2bitrate[ssrc])
-    {
-        this.ssrc2bitrate[ssrc].download += bitrate.download;
-        this.ssrc2bitrate[ssrc].upload += bitrate.upload;
-    }
-    else {
-        this.ssrc2bitrate[ssrc] = bitrate;
-    }
+PeerStats.prototype.setSsrcBitrate = function (bitrate) {
+    this.ssrc2bitrate.download += bitrate.download;
+    this.ssrc2bitrate.upload += bitrate.upload;
+};
+
+/**
+ * Resets the bit rate for given <tt>ssrc</tt> that belong to the peer
+ * represented by this instance.
+ */
+PeerStats.prototype.resetSsrcBitrate = function () {
+    this.ssrc2bitrate.download = 0;
+    this.ssrc2bitrate.upload = 0;
 };
 
 /**
  * Sets new audio level(input or output) for given <tt>ssrc</tt> that identifies
  * the stream which belongs to the peer represented by this instance.
- * @param ssrc RTP stream SSRC for which current audio level value will be
- *        updated.
  * @param audioLevel the new audio level value to be set. Value is truncated to
  *        fit the range from 0 to 1.
  */
-PeerStats.prototype.setSsrcAudioLevel = function (ssrc, audioLevel)
-{
+PeerStats.prototype.setSsrcAudioLevel = function (audioLevel) {
     // Range limit 0 - 1
-    this.ssrc2AudioLevel[ssrc] = formatAudioLevel(audioLevel);
+    this.ssrc2AudioLevel = formatAudioLevel(audioLevel);
 };
 
 function ConferenceStats() {
      */
     this.GATHER_INTERVAL = 15000;
 
-    /**
-     * Log stats via the focus once every this many milliseconds.
-     */
-    this.LOG_INTERVAL = 60000;
-
     /**
      * Gather stats and store them in this.statsToBeLogged.
      */
     this.gatherStatsIntervalId = null;
 
-    /**
-     * Send the stats already saved in this.statsToBeLogged to be logged via
-     * the focus.
-     */
-    this.logStatsIntervalId = null;
-
     /**
      * Stores the statistics which will be send to the focus to be logged.
      */
         this.statsIntervalId = null;
     }
 
-    if(this.logStatsIntervalId)
-    {
-        clearInterval(this.logStatsIntervalId);
-        this.logStatsIntervalId = null;
-    }
-
     if(this.gatherStatsIntervalId)
     {
         clearInterval(this.gatherStatsIntervalId);
         self.audioLevelsIntervalMilis
     );
 
-//    if (!this.config.disableStats && browserSupported) {
-//        this.statsIntervalId = setInterval(
-//            function () {
-//                // Interval updates
-//                self.peerconnection.getStats(
-//                    function (report) {
-//                        var results = null;
-//                        if (!report || !report.result ||
-//                            typeof report.result != 'function') {
-//                            //firefox
-//                            results = report;
-//                        }
-//                        else {
-//                            //chrome
-//                            results = report.result();
-//                        }
-//                        //logger.error("Got interval report", results);
-//                        self.currentStatsReport = results;
-//                        try {
-//                            self.processStatsReport();
-//                        }
-//                        catch (e) {
-//                            logger.error("Unsupported key:" + e, e);
-//                        }
-//
-//                        self.baselineStatsReport = self.currentStatsReport;
-//                    },
-//                    self.errorCallback
-//                );
-//            },
-//            self.statsIntervalMilis
-//        );
-//    }
-//
-//    if (this.config.logStats && browserSupported) {
-//        this.gatherStatsIntervalId = setInterval(
-//            function () {
-//                self.peerconnection.getStats(
-//                    function (report) {
-//                        self.addStatsToBeLogged(report.result());
-//                    },
-//                    function () {
-//                    }
-//                );
-//            },
-//            this.GATHER_INTERVAL
-//        );
-//
-//        this.logStatsIntervalId = setInterval(
-//            function() { self.logStats(); },
-//            this.LOG_INTERVAL);
-//    }
+    if (!this.config.disableStats && browserSupported) {
+        this.statsIntervalId = setInterval(
+            function () {
+                // Interval updates
+                self.peerconnection.getStats(
+                    function (report) {
+                        var results = null;
+                        if (!report || !report.result ||
+                            typeof report.result != 'function') {
+                            //firefox
+                            results = report;
+                        }
+                        else {
+                            //chrome
+                            results = report.result();
+                        }
+                        //logger.error("Got interval report", results);
+                        self.currentStatsReport = results;
+                        try {
+                            self.processStatsReport();
+                        }
+                        catch (e) {
+                            logger.error("Unsupported key:" + e, e);
+                        }
+
+                        self.baselineStatsReport = self.currentStatsReport;
+                    },
+                    self.errorCallback
+                );
+            },
+            self.statsIntervalMilis
+        );
+    }
+
+    // logging statistics does not support firefox
+    if (this.config.logStats && (browserSupported && !RTCBrowserType.isFirefox())) {
+        this.gatherStatsIntervalId = setInterval(
+            function () {
+                self.peerconnection.getStats(
+                    function (report) {
+                        self.addStatsToBeLogged(report.result());
+                    },
+                    function () {
+                    }
+                );
+            },
+            this.GATHER_INTERVAL
+        );
+    }
 };
 
 /**
     var self = this;
     var num_records = this.statsToBeLogged.timestamps.length;
     this.statsToBeLogged.timestamps.push(new Date().getTime());
-    reports.map(function (report) {
+    reports.forEach(function (report) {
         if (!acceptReport(report.id, report.type))
             return;
         var stat = self.statsToBeLogged.stats[report.id];
             stat = self.statsToBeLogged.stats[report.id] = {};
         }
         stat.type = report.type;
-        report.names().map(function (name) {
+        report.names().forEach(function (name) {
             if (!acceptStat(report.id, report.type, name))
                 return;
             var values = stat[name];
     });
 };
 
+StatsCollector.prototype.getCollectedStats = function () {
+    return this.statsToBeLogged;
+};
 
-//FIXME:
-//StatsCollector.prototype.logStats = function () {
-//
-//    if(!APP.xmpp.sendLogs(this.statsToBeLogged))
-//        return;
-//    // Reset the stats
-//    this.statsToBeLogged.stats = {};
-//    this.statsToBeLogged.timestamps = [];
-//};
+StatsCollector.prototype.clearCollectedStats = function () {
+   // Reset the stats
+   this.statsToBeLogged.stats = {};
+   this.statsToBeLogged.timestamps = [];
+};
 
 
 /**
             lossRate = 0;
         var packetsTotal = (packetRate + lossRate);
 
-        ssrcStats.setSsrcLoss(ssrc,
-            {"packetsTotal": packetsTotal,
-                "packetsLost": lossRate,
-                "isDownloadStream": isDownloadStream});
+        ssrcStats.setSsrcLoss({
+            packetsTotal: packetsTotal,
+            packetsLost: lossRate,
+            isDownloadStream: isDownloadStream
+        });
 
 
         var bytesReceived = 0, bytesSent = 0;
             bytesSent = Math.round(((bytesSent * 8) / time) / 1000);
         }
 
-        ssrcStats.setSsrcBitrate(ssrc, {
+        ssrcStats.setSsrcBitrate({
             "download": bytesReceived,
-            "upload": bytesSent});
+            "upload": bytesSent
+        });
 
         var resolution = {height: null, width: null};
         try {
         catch(e){/*not supported*/}
 
         if (resolution.height && resolution.width) {
-            ssrcStats.setSsrcResolution(ssrc, resolution);
+            ssrcStats.setSsrcResolution(resolution);
         } else {
-            ssrcStats.setSsrcResolution(ssrc, null);
+            ssrcStats.setSsrcResolution(null);
         }
     }
 
-    var self = this;
-    // Jid stats
-    var totalPackets = {download: 0, upload: 0};
-    var lostPackets = {download: 0, upload: 0};
+    // process stats
+    var totalPackets = {
+        download: 0,
+        upload: 0
+    };
+    var lostPackets = {
+        download: 0,
+        upload: 0
+    };
     var bitrateDownload = 0;
     var bitrateUpload = 0;
     var resolutions = {};
     Object.keys(this.ssrc2stats).forEach(
-        function (jid) {
-            Object.keys(self.ssrc2stats[jid].ssrc2Loss).forEach(
-                function (ssrc) {
-                    var type = "upload";
-                    if(self.ssrc2stats[jid].ssrc2Loss[ssrc].isDownloadStream)
-                        type = "download";
-                    totalPackets[type] +=
-                        self.ssrc2stats[jid].ssrc2Loss[ssrc].packetsTotal;
-                    lostPackets[type] +=
-                        self.ssrc2stats[jid].ssrc2Loss[ssrc].packetsLost;
-                }
-            );
-            Object.keys(self.ssrc2stats[jid].ssrc2bitrate).forEach(
-                function (ssrc) {
-                    bitrateDownload +=
-                        self.ssrc2stats[jid].ssrc2bitrate[ssrc].download;
-                    bitrateUpload +=
-                        self.ssrc2stats[jid].ssrc2bitrate[ssrc].upload;
-
-                    delete self.ssrc2stats[jid].ssrc2bitrate[ssrc];
-                }
-            );
-            resolutions[jid] = self.ssrc2stats[jid].ssrc2resolution;
-        }
+        function (ssrc) {
+            var ssrcStats = this.ssrc2stats[ssrc];
+
+            // process package loss stats
+            var ssrc2Loss = ssrcStats.ssrc2Loss;
+            var type = ssrc2Loss.isDownloadStream ? "download" : "upload";
+            totalPackets[type] += ssrc2Loss.packetsTotal;
+            lostPackets[type] += ssrc2Loss.packetLost;
+
+            // process bitrate stats
+            var ssrc2bitrate = ssrcStats.ssrc2bitrate;
+            bitrateDownload += ssrc2bitrate.download;
+            bitrateUpload += ssrc2bitrate.upload;
+
+            ssrcStats.resetSsrcBitrate();
+
+            // collect resolutions
+            resolutions[ssrc] = ssrcStats.ssrc2resolution;
+        },
+        this
     );
 
     this.conferenceStats.bitrate = {"upload": bitrateUpload, "download": bitrateDownload};
             // TODO: can't find specs about what this value really is,
             // but it seems to vary between 0 and around 32k.
             audioLevel = audioLevel / 32767;
-            ssrcStats.setSsrcAudioLevel(ssrc, audioLevel);
+            ssrcStats.setSsrcAudioLevel(audioLevel);
             this.eventEmitter.emit(
                 StatisticsEvents.AUDIO_LEVEL, ssrc, audioLevel);
         }

modules/statistics/statistics.js

-/* global require, APP */
+/* global require */
 var LocalStats = require("./LocalStatsCollector.js");
 var RTPStats = require("./RTPStatsCollector.js");
 var EventEmitter = require("events");
     // have loaded by the time we needed it (i.e. CallStats.init is invoked).
 }
 
+
+/**
+ * Log stats via the focus once every this many milliseconds.
+ */
+var LOG_INTERVAL = 60000;
+
 var eventEmitter = new EventEmitter();
 
-function Statistics(options) {
+function Statistics(xmpp, options) {
     this.rtpStats = null;
     this.eventEmitter = new EventEmitter();
+    this.xmpp = xmpp;
     this.options = options || {};
     this.callStatsIntegrationEnabled
         = this.options.callStatsID && this.options.callStatsSecret
     if(this.callStatsIntegrationEnabled)
         loadCallStatsAPI();
     this.callStats = null;
+
+    /**
+     * Send the stats already saved in rtpStats to be logged via
+     * the focus.
+     */
+    this.logStatsIntervalId = null;
 }
 Statistics.audioLevelsEnabled = false;
 
     if(!Statistics.audioLevelsEnabled)
         return;
 
-    if (this.rtpStats) {
-        this.rtpStats.stop();
-    }
+    this.stopRemoteStats();
 
     this.rtpStats = new RTPStats(peerconnection, 200, 2000, this.eventEmitter);
     this.rtpStats.start();
-}
+
+    this.logStatsIntervalId = setInterval(function () {
+        var stats = this.rtpStats.getCollectedStats();
+        if (this.xmpp.sendLogs(stats)) {
+            this.rtpStats.clearCollectedStats();
+        }
+    }.bind(this), LOG_INTERVAL);
+};
 
 Statistics.localStats = [];
 
     var localStats = new LocalStats(stream, 200, callback);
     this.localStats.push(localStats);
     localStats.start();
-}
+};
 
 Statistics.prototype.addAudioLevelListener = function(listener)
 {
     if(!Statistics.audioLevelsEnabled)
         return;
     this.eventEmitter.on(StatisticsEvents.AUDIO_LEVEL, listener);
-}
+};
 
 Statistics.prototype.removeAudioLevelListener = function(listener)
 {
     if(!Statistics.audioLevelsEnabled)
         return;
     this.eventEmitter.removeListener(StatisticsEvents.AUDIO_LEVEL, listener);
-}
+};
+
+Statistics.prototype.addConnectionStatsListener = function (listener) {
+    this.eventEmitter.on(StatisticsEvents.CONNECTION_STATS, listener);
+};
+
+Statistics.prototype.removeConnectionStatsListener = function (listener) {
+    this.eventEmitter.removeListener(StatisticsEvents.CONNECTION_STATS, listener);
+};
 
 Statistics.prototype.dispose = function () {
     if(Statistics.audioLevelsEnabled) {
         Statistics.stopAllLocalStats();
-        this.stopRemote();
+        this.stopRemoteStats();
         if(this.eventEmitter)
             this.eventEmitter.removeAllListeners();
 
         this.callstats.sendTerminateEvent();
         this.callstats = null;
     }
-}
+};
 
 
 Statistics.stopAllLocalStats = function () {
     for(var i = 0; i < this.localStats.length; i++)
         this.localStats[i].stop();
     this.localStats = [];
-}
+};
 
 Statistics.stopLocalStats = function (stream) {
     if(!Statistics.audioLevelsEnabled)
             localStats.stop();
             break;
         }
-}
+};
+
+Statistics.prototype.stopRemoteStats = function () {
+    if (!Statistics.audioLevelsEnabled || !this.rtpStats) {
+        return;
+    }
+
+    this.rtpStats.stop();
+    this.rtpStats = null;
 
-Statistics.prototype.stopRemote = function () {
-    if (this.rtpStats && Statistics.audioLevelsEnabled) {
-        this.rtpStats.stop();
-        this.eventEmitter.emit(StatisticsEvents.STOP);
-        this.rtpStats = null;
+    if (this.logStatsIntervalId) {
+        clearInterval(this.logStatsIntervalId);
+        this.logStatsIntervalId = null;
     }
 };
 
 Statistics.prototype.getPeerSSRCAudioLevel = function (peerJid, ssrc) {
     if(!Statistics.audioLevelsEnabled)
         return;
+    // FIXME: not used, unknown property jid2stats
     var peerStats = this.rtpStats.jid2stats[peerJid];
 
     return peerStats ? peerStats.ssrc2AudioLevel[ssrc] : null;
     if(this.callStatsIntegrationEnabled && !this.callstats) {
         this.callstats = new CallStats(session, settings, this.options);
     }
-}
+};
 
 /**
  * Returns true if the callstats integration is enabled, otherwise returns
  */
 Statistics.prototype.isCallstatsEnabled = function () {
     return this.callStatsIntegrationEnabled;
-}
+};
 
 /**
  * Notifies CallStats for connection setup errors
 Statistics.prototype.sendSetupFailedEvent = function () {
     if(this.callStatsIntegrationEnabled && this.callstats)
         this.callstats.sendSetupFailedEvent();
-}
+};
 
 /**
  * Notifies CallStats for mute events
 Statistics.prototype.sendMuteEvent = function (muted, type) {
     if(this.callStatsIntegrationEnabled)
         CallStats.sendMuteEvent(muted, type, this.callstats);
-}
+};
 
 /**
  * Notifies CallStats that getUserMedia failed.
 Statistics.prototype.sendSetLocalDescFailed = function (e, pc) {
     if(this.callStatsIntegrationEnabled)
         CallStats.sendSetLocalDescFailed(e, pc, this.callstats);
-}
+};
 
 /**
  * Notifies CallStats that peer connection failed to set remote description.
 Statistics.prototype.sendSetRemoteDescFailed = function (e, pc) {
     if(this.callStatsIntegrationEnabled)
         CallStats.sendSetRemoteDescFailed(e, pc, this.callstats);
-}
+};
 
 /**
  * Notifies CallStats that peer connection failed to add ICE candidate.
 Statistics.prototype.sendAddIceCandidateFailed = function (e, pc) {
     if(this.callStatsIntegrationEnabled)
         CallStats.sendAddIceCandidateFailed(e, pc, this.callstats);
-}
+};
 
 /**
  * Sends the given feedback through CallStats.
 function(overallFeedback, detailedFeedback){
     if(this.callStatsIntegrationEnabled && this.callstats)
         this.callstats.sendFeedback(overallFeedback, detailedFeedback);
-}
+};
 
 Statistics.LOCAL_JID = require("../../service/statistics/constants").LOCAL_JID;
 

service/statistics/Events.js

      * FIXME: needs documentation.
      */
     AUDIO_LEVEL: "statistics.audioLevel",
-    /**
-     * FIXME: needs documentation.
-     */
-    STOP: "statistics.stop"
 };