Merge pull request #510 from jitsi/p2p_analytics2

P2P analytics round 2

JitsiConference.js

@@ -14,6 +14,7 @@ import JitsiParticipant from './JitsiParticipant';
 import JitsiTrackError from './JitsiTrackError';
 import * as JitsiTrackErrors from './JitsiTrackErrors';
 import * as JitsiTrackEvents from './JitsiTrackEvents';
+import Jvb121EventGenerator from './modules/event/Jvb121EventGenerator';
 import * as MediaType from './service/RTC/MediaType';
 import ParticipantConnectionStatusHandler
     from './modules/connectivity/ParticipantConnectionStatus';
@@ -55,6 +56,10 @@ const logger = getLogger(__filename);
  * @param {number} [options.config.channelLastN=-1] The requested amount of
  * videos are going to be delivered after the value is in effect. Set to -1 for
  * unlimited or all available videos.
+ * @param {number} [options.config.forceJVB121Ratio]
+ * "Math.random() < forceJVB121Ratio" will determine whether a 2 people
+ * conference should be moved to the JVB instead of P2P. The decision is made on
+ * the responder side, after ICE succeeds on the P2P connection.
  * @constructor
  *
  * FIXME Make all methods which are called from lib-internal classes
@@ -265,6 +270,12 @@ JitsiConference.prototype._init = function(options = {}) {
         this.setLastN(options.config.channelLastN);
     }
 
+    /**
+     * Emits {@link JitsiConferenceEvents.JVB121_STATUS}.
+     * @type {Jvb121EventGenerator}
+     */
+    this.jvb121Status = new Jvb121EventGenerator(this);
+
     // creates dominant speaker detection that works only in p2p mode
     this.p2pDominantSpeakerDetection = new P2PDominantSpeakerDetection(this);
 };
@@ -1459,6 +1470,18 @@ JitsiConference.prototype.onCallEnded
         // Let the RTC service do any cleanups
         this.rtc.onCallEnded();
     } else if (jingleSession === this.p2pJingleSession) {
+        // It's the responder who decides to enforce JVB mode, so that both
+        // initiator and responder are aware if it was intentional.
+        if (reasonCondition === 'decline' && reasonText === 'force JVB121') {
+            logger.info('In forced JVB 121 mode...');
+            Statistics.analytics.addPermanentProperties({ forceJvb121: true });
+        } else if (reasonCondition === 'connectivity-error'
+            && reasonText === 'ICE FAILED') {
+            // It can happen that the other peer detects ICE failed and
+            // terminates the session, before we get the event on our side.
+            // But we are able to parse the reason and mark it here.
+            Statistics.analytics.addPermanentProperties({ p2pFailed: true });
+        }
         this._stopP2PSession();
     } else {
         logger.error(
@@ -1898,6 +1921,11 @@ JitsiConference.prototype._onIceConnectionFailed = function(session) {
     // We do nothing for the JVB connection, because it's up to the Jicofo to
     // eventually come up with the new offer (at least for the time being).
     if (session.isP2P) {
+        // Add p2pFailed property to analytics to distinguish, between "good"
+        // and "bad" connection
+        Statistics.analytics.addPermanentProperties({ p2pFailed: true });
+
+        // Log analytics event, but only for the initiator to not count it twice
         if (this.p2pJingleSession && this.p2pJingleSession.isInitiator) {
             Statistics.sendEventToAll('p2p.failed');
         }
@@ -2000,12 +2028,26 @@ JitsiConference.prototype._addRemoteTracks = function(logName, remoteTracks) {
  */
 JitsiConference.prototype._onIceConnectionEstablished
 = function(jingleSession) {
+    const forceJVB121Ratio = this.options.config.forceJVB121Ratio;
+
     // We don't care about the JVB case, there's nothing to be done
     if (!jingleSession.isP2P) {
         return;
     } else if (this.p2pJingleSession !== jingleSession) {
         logger.error('CONNECTION_ESTABLISHED - wrong P2P session instance ?!');
 
+        return;
+    } else if (!jingleSession.isInitiator
+        && typeof forceJVB121Ratio === 'number'
+        && Math.random() < forceJVB121Ratio) {
+        logger.info(`Forcing JVB 121 mode (ratio=${forceJVB121Ratio})...`);
+        this._rejectIncomingCall(
+            jingleSession, {
+                reasonTag: 'decline',
+                reasonMsg: 'force JVB121'
+            });
+        Statistics.analytics.addPermanentProperties({ forceJvb121: true });
+
         return;
     }
 
@@ -2118,6 +2160,13 @@ JitsiConference.prototype._setP2PStatus = function(newStatus) {
     if (newStatus) {
         logger.info('Peer to peer connection established!');
 
+        // When we end up in a valid P2P session need to reset the properties
+        // in case they have persisted, after session with another peer.
+        Statistics.analytics.addPermanentProperties({
+            p2pFailed: false,
+            forceJvb121: false
+        });
+
         // Sync up video transfer active in case p2pJingleSession not existed
         // when the lastN value was being adjusted.
         const isVideoActive = this.rtc.getLastN() !== 0;

JitsiConferenceEvents.js

@@ -77,6 +77,22 @@ export const DTMF_SUPPORT_CHANGED = 'conference.dtmfSupportChanged';
  */
 export const ENDPOINT_MESSAGE_RECEIVED = 'conference.endpoint_message_received';
 
+/**
+ * NOTE This is lib-jitsi-meet internal event and can be removed at any time !
+ *
+ * Event emitted when conference transits, between one to one and multiparty JVB
+ * conference. If the conference switches to P2P it's neither one to one nor
+ * a multiparty JVB conference, but P2P (the status argument of this event will
+ * be <tt>false</tt>).
+ *
+ * The first argument is a boolean which carries the previous value and
+ * the seconds argument is a boolean with the new status. The event is emitted
+ * only if the previous and the new values are different.
+ *
+ * @type {string}
+ */
+export const JVB121_STATUS = 'conference.jvb121Status';
+
 /**
  * You are kicked from the conference.
  */

modules/event/Jvb121EventGenerator.js

@@ -0,0 +1,55 @@
+/* global __filename */
+
+import { getLogger } from 'jitsi-meet-logger';
+import * as JitsiConferenceEvents from '../../JitsiConferenceEvents';
+
+const logger = getLogger(__filename);
+
+/**
+ * Emits {@link JitsiConferenceEvents.JVB121_STATUS} events based on the current
+ * P2P status and the conference participants count. See the event description
+ * for more info.
+ */
+export default class Jvb121EventGenerator {
+    /**
+     * Creates new <tt>Jvb121EventGenerator</tt> for the given conference.
+     * @param {JitsiConference} conference
+     */
+    constructor(conference) {
+        this._conference = conference;
+
+        /**
+         * Indicates whether it's a one to one JVB conference (<tt>true</tt>)
+         * or a multiparty (<tt>false</tt>). Will be also <tt>false</tt> if
+         * the conference is currently in the P2P mode.
+         * @type {boolean}
+         * @private
+         */
+        this._jvb121 = true;
+
+        this._conference.addEventListener(
+            JitsiConferenceEvents.USER_JOINED, () => this.evaluateStatus());
+        this._conference.addEventListener(
+            JitsiConferenceEvents.USER_LEFT, () => this.evaluateStatus());
+        this._conference.addEventListener(
+            JitsiConferenceEvents.P2P_STATUS, () => this.evaluateStatus());
+    }
+
+    /**
+     * Checks whether the JVB121 value should be updated and a new event
+     * emitted.
+     */
+    evaluateStatus() {
+        const oldStatus = this._jvb121;
+        const newStatus
+            = !this._conference.isP2PActive()
+                && this._conference.getParticipantCount() <= 2;
+
+        if (oldStatus !== newStatus) {
+            this._jvb121 = newStatus;
+            logger.debug(`JVB121 status ${oldStatus} => ${newStatus}`);
+            this._conference.eventEmitter.emit(
+                JitsiConferenceEvents.JVB121_STATUS, oldStatus, newStatus);
+        }
+    }
+}

modules/statistics/AvgRTPStatsReporter.js

@@ -9,8 +9,55 @@ import RTCBrowserType from '../RTC/RTCBrowserType';
 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);
 
+/**
+ * Figures out what prefix should be added to the stat name.
+ * @param {boolean} isP2P is it P2P or JVB conference ?
+ * @param {number} conferenceSize how many participants are there in
+ * the conference (including us)
+ * @return {string} "" (for JVB conference) or "p2p_" (for P2P) or "jvb121_"
+ * (for JVB 2 participant conference).
+ */
+function getPrefix(isP2P, conferenceSize) {
+    return isP2P
+        ? 'p2p_'
+        : conferenceSize === 2 ? 'jvb121_' : '';
+}
+
 /**
  * This will calculate an average for one, named stat and submit it to
  * the analytics module when requested. It automatically counts the samples.
@@ -25,6 +72,7 @@ class AverageStatReport {
         this.name = name;
         this.count = 0;
         this.sum = 0;
+        this.samples = [];
     }
 
     /**
@@ -39,6 +87,7 @@ class AverageStatReport {
                 nextValue);
         } else if (!isNaN(nextValue)) {
             this.sum += nextValue;
+            this.samples.push(nextValue);
             this.count += 1;
         }
     }
@@ -53,16 +102,19 @@ class AverageStatReport {
     }
 
     /**
-     * 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
+     * set under <tt>prefix</tt> + {@link this.name} key.
+     * @param {Object} report the analytics "data" object
+     * @param {string} prefix the prefix string that will be added at
+     * the beginning of the key name.
      */
-    report(isP2P) {
-        Statistics.analytics.sendEvent(
-            `${isP2P ? 'p2p.' : ''}${this.name}`,
-            { value: this.calculate() });
+    appendReport(report, prefix) {
+        const keyName = `${prefix}${this.name}`;
+
+        report[keyName] = {
+            value: this.calculate(),
+            samples: this.samples
+        };
     }
 
     /**
@@ -70,6 +122,7 @@ class AverageStatReport {
      * calculated using this instance.
      */
     reset() {
+        this.samples = [];
         this.sum = 0;
         this.count = 0;
     }
@@ -114,7 +167,7 @@ class ConnectionAvgStats {
          * 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.
@@ -177,7 +230,11 @@ class ConnectionAvgStats {
 
         if (this._sampleIdx >= this._n) {
             if (RTCBrowserType.supportsRTTStatistics()) {
-                this._avgRTT.report(this.isP2P);
+                const batchReport = { };
+                const confSize = this._conference.getParticipantCount();
+                const prefix = getPrefix(this.isP2P, confSize);
+
+                this._avgRTT.appendReport(batchReport, prefix);
 
                 // Report end to end RTT only for JVB
                 if (!this.isP2P) {
@@ -185,11 +242,14 @@ class ConnectionAvgStats {
                     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[`${prefix}stat_avg_end2endrtt`]
+                            = { value: avgLocalRTT + avgRemoteRTT };
                     }
                 }
+
+                Statistics.analytics.sendEvent(
+                    AVG_RTP_STATS_EVENT, batchReport);
             }
 
             this._resetAvgStats();
@@ -232,7 +292,7 @@ class ConnectionAvgStats {
         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);
         }
 
@@ -326,7 +386,7 @@ export default class AvgRTPStatsReporter {
          * @private
          */
         this._avgAudioBitrateUp
-            = new AverageStatReport('stat.avg.bitrate.audio.upload');
+            = new AverageStatReport('stat_avg_bitrate_audio_upload');
 
         /**
          * Average audio download bitrate
@@ -334,7 +394,7 @@ export default class AvgRTPStatsReporter {
          * @private
          */
         this._avgAudioBitrateDown
-            = new AverageStatReport('stat.avg.bitrate.audio.download');
+            = new AverageStatReport('stat_avg_bitrate_audio_download');
 
         /**
          * Average video upload bitrate
@@ -342,7 +402,7 @@ export default class AvgRTPStatsReporter {
          * @private
          */
         this._avgVideoBitrateUp
-            = new AverageStatReport('stat.avg.bitrate.video.upload');
+            = new AverageStatReport('stat_avg_bitrate_video_upload');
 
         /**
          * Average video download bitrate
@@ -350,7 +410,7 @@ export default class AvgRTPStatsReporter {
          * @private
          */
         this._avgVideoBitrateDown
-            = new AverageStatReport('stat.avg.bitrate.video.download');
+            = new AverageStatReport('stat_avg_bitrate_video_download');
 
         /**
          * Average upload bandwidth
@@ -358,7 +418,7 @@ export default class AvgRTPStatsReporter {
          * @private
          */
         this._avgBandwidthUp
-            = new AverageStatReport('stat.avg.bandwidth.upload');
+            = new AverageStatReport('stat_avg_bandwidth_upload');
 
         /**
          * Average download bandwidth
@@ -366,7 +426,7 @@ export default class AvgRTPStatsReporter {
          * @private
          */
         this._avgBandwidthDown
-            = new AverageStatReport('stat.avg.bandwidth.download');
+            = new AverageStatReport('stat_avg_bandwidth_download');
 
         /**
          * Average total packet loss
@@ -374,7 +434,7 @@ export default class AvgRTPStatsReporter {
          * @private
          */
         this._avgPacketLossTotal
-            = new AverageStatReport('stat.avg.packetloss.total');
+            = new AverageStatReport('stat_avg_packetloss_total');
 
         /**
          * Average upload packet loss
@@ -382,7 +442,7 @@ export default class AvgRTPStatsReporter {
          * @private
          */
         this._avgPacketLossUp
-            = new AverageStatReport('stat.avg.packetloss.upload');
+            = new AverageStatReport('stat_avg_packetloss_upload');
 
         /**
          * Average download packet loss
@@ -390,14 +450,14 @@ export default class AvgRTPStatsReporter {
          * @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
@@ -406,14 +466,14 @@ export default class AvgRTPStatsReporter {
          * @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
@@ -422,7 +482,7 @@ export default class AvgRTPStatsReporter {
          * @private
          */
         this._avgLocalScreenFPS
-            = new AverageStatReport('stat.avg.framerate.screen.local');
+            = new AverageStatReport('stat_avg_framerate_screen_local');
 
         /**
          * Average connection quality as defined by
@@ -430,7 +490,7 @@ export default class AvgRTPStatsReporter {
          * @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(
@@ -447,6 +507,19 @@ export default class AvgRTPStatsReporter {
             ConferenceEvents.P2P_STATUS,
             this._onP2PStatusChanged);
 
+        this._onJvb121StatusChanged = (oldStatus, newStatus) => {
+            // We want to reset only on the transition from false => true,
+            // because otherwise those stats are resetted on JVB <=> P2P
+            // transition.
+            if (newStatus === true) {
+                logger.info('Resetting JVB avg RTP stats');
+                this._resetAvgJvbStats();
+            }
+        };
+        conference.on(
+            ConferenceEvents.JVB121_STATUS,
+            this._onJvb121StatusChanged);
+
         this.jvbStatsMonitor
             = new ConnectionAvgStats(conference, false /* JVB */, n);
 
@@ -463,9 +536,10 @@ export default class AvgRTPStatsReporter {
     _calculateAvgStats(data) {
 
         const isP2P = this._conference.isP2PActive();
-        const peerCount = this._conference.getParticipants().length;
+        const confSize = this._conference.getParticipantCount();
+        const prefix = getPrefix(isP2P, confSize);
 
-        if (!isP2P && peerCount < 1) {
+        if (!isP2P && confSize < 2) {
 
             // There's no point in collecting stats for a JVB conference of 1.
             // That happens for short period of time after everyone leaves
@@ -545,30 +619,34 @@ export default class AvgRTPStatsReporter {
         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, prefix);
+            this._avgAudioBitrateDown.appendReport(batchReport, prefix);
+
+            this._avgVideoBitrateUp.appendReport(batchReport, prefix);
+            this._avgVideoBitrateDown.appendReport(batchReport, prefix);
 
             if (RTCBrowserType.supportsBandwidthStatistics()) {
-                this._avgBandwidthUp.report(isP2P);
-                this._avgBandwidthDown.report(isP2P);
+                this._avgBandwidthUp.appendReport(batchReport, prefix);
+                this._avgBandwidthDown.appendReport(batchReport, prefix);
             }
-            this._avgPacketLossUp.report(isP2P);
-            this._avgPacketLossDown.report(isP2P);
-            this._avgPacketLossTotal.report(isP2P);
+            this._avgPacketLossUp.appendReport(batchReport, prefix);
+            this._avgPacketLossDown.appendReport(batchReport, prefix);
+            this._avgPacketLossTotal.appendReport(batchReport, prefix);
 
-            this._avgRemoteFPS.report(isP2P);
+            this._avgRemoteFPS.appendReport(batchReport, prefix);
             if (!isNaN(this._avgRemoteScreenFPS.calculate())) {
-                this._avgRemoteScreenFPS.report(isP2P);
+                this._avgRemoteScreenFPS.appendReport(batchReport, prefix);
             }
-            this._avgLocalFPS.report(isP2P);
+            this._avgLocalFPS.appendReport(batchReport, prefix);
             if (!isNaN(this._avgLocalScreenFPS.calculate())) {
-                this._avgLocalScreenFPS.report(isP2P);
+                this._avgLocalScreenFPS.appendReport(batchReport, prefix);
             }
 
-            this._avgCQ.report(isP2P);
+            this._avgCQ.appendReport(batchReport, prefix);
+
+            Statistics.analytics.sendEvent(AVG_RTP_STATS_EVENT, batchReport);
 
             this._resetAvgStats();
         }
@@ -667,6 +745,18 @@ export default class AvgRTPStatsReporter {
         return peerFpsSum / peerSsrcCount;
     }
 
+    /**
+     * Resets the stats related to JVB connection. Must not be called when in
+     * P2P mode, because then the {@link AverageStatReport} instances are
+     * tracking P2P stats. Note that this should never happen unless something
+     * is wrong with the P2P and JVB121 events.
+     * @private
+     */
+    _resetAvgJvbStats() {
+        this._resetAvgStats();
+        this.jvbStatsMonitor._resetAvgStats();
+    }
+
     /**
      * Reset cache of all averages and {@link _sampleIdx}.
      * @private
@@ -705,6 +795,9 @@ export default class AvgRTPStatsReporter {
         this._conference.off(
             ConnectionQualityEvents.LOCAL_STATS_UPDATED,
             this._onLocalStatsUpdated);
+        this._conference.off(
+            ConferenceEvents.JVB121_STATUS,
+            this._onJvb121StatusChanged);
         this.jvbStatsMonitor.dispose();
         this.p2pStatsMonitor.dispose();
     }

modules/xmpp/JingleSessionPC.js

@@ -570,10 +570,7 @@ export default class JingleSessionPC extends JingleSession {
         // a lot later. See webrtc issue #2340
         // logger.log('was this the last candidate', this.lasticecandidate);
         this.connection.sendIQ(
-            cand, null, this.newJingleErrorHandler(cand, error => {
-                GlobalOnErrorHandler.callErrorHandler(
-                    new Error(`Jingle error: ${JSON.stringify(error)}`));
-            }), IQ_TIMEOUT);
+            cand, null, this.newJingleErrorHandler(cand), IQ_TIMEOUT);
     }
 
     /**
@@ -2063,7 +2060,7 @@ export default class JingleSessionPC extends JingleSession {
      *  reason: {the name of XMPP error reason element or 'timeout' if the
       *          request has timed out within <tt>IQ_TIMEOUT</tt> milliseconds}
      *  source: {request.tree() that provides original request}
-     *  session: {JingleSessionPC instance on which the error occurred}
+     *  session: {this JingleSessionPC.toString()}
      * }
      * @param request Strophe IQ instance which is the request to be dumped into
      *        the error structure
@@ -2072,7 +2069,7 @@ export default class JingleSessionPC extends JingleSession {
      * @returns {function(this:JingleSessionPC)}
      */
     newJingleErrorHandler(request, failureCb) {
-        return function(errResponse) {
+        return errResponse => {
 
             const error = {};
 
@@ -2100,15 +2097,21 @@ export default class JingleSessionPC extends JingleSession {
                 error.source = error.source.outerHTML;
             }
 
-            // Commented to fix JSON.stringify(error) exception for circular
-            // dependancies when we print that error.
-            // FIXME: Maybe we can include part of the session object
-            // error.session = this;
+            error.session = this.toString();
 
             if (failureCb) {
                 failureCb(error);
+            } else if (this.state === JingleSessionState.ENDED
+                        && error.reason === 'item-not-found') {
+                // When remote peer decides to terminate the session, but it
+                // still have few messages on the queue for processing,
+                // it will first send us 'session-terminate' (we enter ENDED)
+                // and then follow with 'item-not-found' for the queued requests
+                // We don't want to have that logged on error level.
+                logger.debug('Jingle error', error);
             } else {
-                logger.error('Jingle error', error);
+                GlobalOnErrorHandler.callErrorHandler(
+                    new Error(`Jingle error: ${JSON.stringify(error)}`));
             }
         };
     }