feat(stats): Treats local/remote relayed addresses differently.

modules/statistics/AvgRTPStatsReporter.js

  *
  * {
  *   p2p: true,
- *   conferenceSize: 1,
- *   relayed: true,
+ *   conferenceSize: 2,
+ *   localCandidateType: "relay",
+ *   remoteCandidateType: "relay",
+ *   transportType: "udp",
  *
  *   "stat_avg_rtt": {
  *     value: 200,
      * Appends the report to the analytics "data" object. The object will be
      * set under <tt>prefix</tt> + {@link this.name} key.
      * @param {Object} report the analytics "data" object
-     * @param {Object} extra properties to append to the analytics "data" object
      */
-    appendReport(report, props) {
-
-        const reportValue = {
+    appendReport(report) {
+        report[this.name] = {
             value: this.calculate(),
             samples: this.samples
         };
-
-        Object.assign(reportValue, props);
-
-        report[this.name] = reportValue;
     }
 
     /**
 class ConnectionAvgStats {
     /**
      * Creates new <tt>ConnectionAvgStats</tt>
-     * @param {JitsiConference} conference
+     * @param {AvgRTPStatsReporter} avgRtpStatsReporter
      * @param {boolean} isP2P
      * @param {number} n the number of samples, before arithmetic mean is to be
      * calculated and values submitted to the analytics module.
      */
-    constructor(conference, isP2P, n) {
+    constructor(avgRtpStatsReporter, isP2P, n) {
         /**
          * Is this instance for JVB or P2P connection ?
          * @type {boolean}
          * @type {JitsiConference}
          * @private
          */
-        this._conference = conference;
+        this._avgRtpStatsReporter = avgRtpStatsReporter;
+
+        /**
+         * The latest average E2E RTT for the JVB connection only.
+         *
+         * This is used only when {@link ConnectionAvgStats.isP2P} equals to
+         * <tt>false</tt>.
+         *
+         * @type {number}
+         */
+        this._avgEnd2EndRTT = undefined;
 
         this._onConnectionStats = (tpc, stats) => {
             if (this.isP2P === tpc.isP2P) {
                 this._calculateAvgStats(stats);
             }
         };
+
+        const conference = avgRtpStatsReporter._conference;
+
         conference.statistics.addConnectionStatsListener(
             this._onConnectionStats);
 
 
         if (this._sampleIdx >= this._n) {
             if (RTCBrowserType.supportsRTTStatistics()) {
-                const batchReport = { };
-                const props = {
-                    relayed: data.relayed,
+                const conference = this._avgRtpStatsReporter._conference;
+
+                const batchReport = {
                     p2p: this.isP2P,
-                    size: this._conference.getParticipantCount()
+                    size: conference.getParticipantCount()
                 };
 
-                this._avgRTT.appendReport(batchReport, props);
+                if (data.transport && data.transport.length) {
+                    Object.assign(batchReport, {
+                        localCandidateType:
+                            data.transport[0].localCandidateType,
+                        remoteCandidateType:
+                            data.transport[0].remoteCandidateType,
+                        transportType: data.transport[0].type
+                    });
+                }
 
-                // Report end to end RTT only for JVB
-                if (!this.isP2P) {
-                    const avgRemoteRTT = this._calculateAvgRemoteRTT();
-                    const avgLocalRTT = this._avgRTT.calculate();
+                this._avgRTT.appendReport(batchReport);
 
-                    if (!isNaN(avgLocalRTT) && !isNaN(avgRemoteRTT)) {
-                        // eslint-disable-next-line camelcase
-                        const reportValue = {
-                            value: avgLocalRTT + avgRemoteRTT
+                if (this.isP2P) {
+                    // Report RTT diff only for P2P.
+                    const jvbEnd2EndRTT = this
+                        ._avgRtpStatsReporter.jvbStatsMonitor._avgEnd2EndRTT;
+
+                    if (!isNaN(jvbEnd2EndRTT)) {
+                        const avgRTTDiff
+                            = this._avgRTT.calculate() - jvbEnd2EndRTT;
+
+                        // eslint-disable-next-line dot-notation
+                        batchReport['stat_avg_rtt_diff'] = {
+                            value: avgRTTDiff
                         };
+                    }
+                } else {
+                    // Report end to end RTT only for JVB.
+                    const avgRemoteRTT = this._calculateAvgRemoteRTT();
+                    const avgLocalRTT = this._avgRTT.calculate();
 
-                        Object.assign(reportValue, props);
+                    this._avgEnd2EndRTT = avgLocalRTT + avgRemoteRTT;
 
+                    if (!isNaN(avgLocalRTT) && !isNaN(avgRemoteRTT)) {
                         // eslint-disable-next-line dot-notation
-                        batchReport['stat_avg_end2endrtt'] = reportValue;
+                        batchReport['stat_avg_end2endrtt'] = {
+                            value: this._avgEnd2EndRTT
+                        };
                     }
                 }
 
      *
      */
     dispose() {
-        this._conference.statistics.removeConnectionStatsListener(
+
+        const conference = this._avgRtpStatsReporter._conference;
+
+        conference.statistics.removeConnectionStatsListener(
             this._onConnectionStats);
         if (!this.isP2P) {
-            this._conference.off(
+            conference.off(
                 ConnectionQualityEvents.REMOTE_STATS_UPDATED,
                 this._onRemoteStatsUpdated);
-            this._conference.off(
+            conference.off(
                 ConferenceEvents.USER_LEFT,
                 this._onUserLeft);
         }
             this._onJvb121StatusChanged);
 
         this.jvbStatsMonitor
-            = new ConnectionAvgStats(conference, false /* JVB */, n);
+            = new ConnectionAvgStats(this, false /* JVB */, n);
 
         this.p2pStatsMonitor
-            = new ConnectionAvgStats(conference, true /* P2P */, n);
+            = new ConnectionAvgStats(this, true /* P2P */, n);
     }
 
     /**
      */
     _calculateAvgStats(data) {
 
+        if (!data) {
+            logger.error('No stats');
+
+            return;
+        }
+
         const isP2P = this._conference.isP2PActive();
         const confSize = this._conference.getParticipantCount();
-        const props = {
-            relayed: data.relayed,
-            p2p: isP2P,
-            size: confSize
-        };
 
         if (!isP2P && confSize < 2) {
 
             }
         } */
 
-        if (!data) {
-            logger.error('No stats');
-
-            return;
-        }
-
         const bitrate = data.bitrate;
         const bandwidth = data.bandwidth;
         const packetLoss = data.packetLoss;
         this._sampleIdx += 1;
 
         if (this._sampleIdx >= this._n) {
-            const batchReport = { };
 
-            this._avgAudioBitrateUp.appendReport(batchReport, props);
-            this._avgAudioBitrateDown.appendReport(batchReport, props);
+            const batchReport = {
+                p2p: isP2P,
+                size: confSize
+            };
+
+            if (data.transport && data.transport.length) {
+                Object.assign(batchReport, {
+                    localCandidateType: data.transport[0].localCandidateType,
+                    remoteCandidateType: data.transport[0].remoteCandidateType,
+                    transportType: data.transport[0].type
+                });
+            }
+
+            this._avgAudioBitrateUp.appendReport(batchReport);
+            this._avgAudioBitrateDown.appendReport(batchReport);
 
-            this._avgVideoBitrateUp.appendReport(batchReport, props);
-            this._avgVideoBitrateDown.appendReport(batchReport, props);
+            this._avgVideoBitrateUp.appendReport(batchReport);
+            this._avgVideoBitrateDown.appendReport(batchReport);
 
             if (RTCBrowserType.supportsBandwidthStatistics()) {
-                this._avgBandwidthUp.appendReport(batchReport, props);
-                this._avgBandwidthDown.appendReport(batchReport, props);
+                this._avgBandwidthUp.appendReport(batchReport);
+                this._avgBandwidthDown.appendReport(batchReport);
             }
-            this._avgPacketLossUp.appendReport(batchReport, props);
-            this._avgPacketLossDown.appendReport(batchReport, props);
-            this._avgPacketLossTotal.appendReport(batchReport, props);
+            this._avgPacketLossUp.appendReport(batchReport);
+            this._avgPacketLossDown.appendReport(batchReport);
+            this._avgPacketLossTotal.appendReport(batchReport);
 
-            this._avgRemoteFPS.appendReport(batchReport, props);
+            this._avgRemoteFPS.appendReport(batchReport);
             if (!isNaN(this._avgRemoteScreenFPS.calculate())) {
-                this._avgRemoteScreenFPS.appendReport(batchReport, props);
+                this._avgRemoteScreenFPS.appendReport(batchReport);
             }
-            this._avgLocalFPS.appendReport(batchReport, props);
+            this._avgLocalFPS.appendReport(batchReport);
             if (!isNaN(this._avgLocalScreenFPS.calculate())) {
-                this._avgLocalScreenFPS.appendReport(batchReport, props);
+                this._avgLocalScreenFPS.appendReport(batchReport);
             }
 
-            this._avgCQ.appendReport(batchReport, props);
+            this._avgCQ.appendReport(batchReport);
 
             Statistics.analytics.sendEvent(AVG_RTP_STATS_EVENT, batchReport);
 

modules/statistics/RTPStatsCollector.js

     'googFrameRateSent': 'googFrameRateSent',
     'audioInputLevel': 'audioInputLevel',
     'audioOutputLevel': 'audioOutputLevel',
-    'currentRoundTripTime': 'googRtt'
+    'currentRoundTripTime': 'googRtt',
+    'remoteCandidateType': 'googRemoteCandidateType',
+    'localCandidateType': 'googLocalCandidateType'
 };
 KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_EDGE] = {
     'sendBandwidth': 'googAvailableSendBandwidth',
     return Math.max(0, value);
 };
 
-/**
- * Determines whether the local ICE candidate address is a relayed one.
- *
- * @param {TraceablePeerConnection} rtcPeerConnection the peer connection that
- * has the local ICE candidate address.
- * @param {Array} localAddressArray an array in the form
- * [ ip address, port ].
- * @return {boolean} true if the local ICE candidate is a relayed one, otherwise
- * false.
- */
-function isRelayed(rtcPeerConnection, localAddressArray) {
-    const localSdpLines
-        = rtcPeerConnection.localDescription.sdp.match(/[^\r\n]+/g);
-
-    for (const idx in localSdpLines) {
-        if (localSdpLines[idx].indexOf(localAddressArray[0])
-            && localSdpLines[idx].indexOf(localAddressArray[1])) {
-            return localSdpLines[idx].indexOf('relay') !== -1;
-        }
-    }
-
-    logger
-        .warn('The candidate address was not found in the local description.');
-
-    return false;
-}
-
 /* eslint-disable no-continue */
 
 /**
         } catch (e) { /* not supported*/ }
 
         if (now.type === 'googCandidatePair') {
-            let active, ip, localip, rtt, type;
-            let relayed = false;
+            let active, ip, localCandidateType, localip,
+                remoteCandidateType, rtt, type;
 
             try {
+                active = getStatValue(now, 'activeConnection');
+                if (!active) {
+                    continue;
+                }
+
                 ip = getStatValue(now, 'remoteAddress');
                 type = getStatValue(now, 'transportType');
                 localip = getStatValue(now, 'localAddress');
-                relayed = isRelayed(this.peerconnection, localip.split(':'));
-                active = getStatValue(now, 'activeConnection');
+                localCandidateType = getStatValue(now, 'localCandidateType');
+                remoteCandidateType = getStatValue(now, 'remoteCandidateType');
                 rtt = this.getNonNegativeStat(now, 'currentRoundTripTime');
             } catch (e) { /* not supported*/ }
             if (!ip || !type || !localip || active !== 'true') {
                     type,
                     localip,
                     p2p: this.peerconnection.isP2P,
-                    relayed,
+                    localCandidateType,
+                    remoteCandidateType,
                     rtt
                 });
             }
                 ip: `${remote.ipAddress}:${remote.portNumber}`,
                 type: local.transport,
                 localip: `${local.ipAddress}:${local.portNumber}`,
-                relayed: isRelayed(
-                    this.peerconnection, [ local.ipAddress, local.portNumber ]),
-                p2p: this.peerconnection.isP2P
+                p2p: this.peerconnection.isP2P,
+                localCandidateType: local.candidateType,
+                remoteCandidateType: remote.candidateType
             });
         }