Merge pull request #399 from isymchych/callstats-error-reporting

Callstats error reporting. Ivan is going to publish another PR about earlier failures that would apply on top of this one.

modules/RTC/RTC.js

                 null, null, getMediaStreamUsage());
         };
 
-        this.rtcUtils = new RTCUtils(this, onReady);
+        this.rtcUtils = new RTCUtils(this, eventEmitter, onReady);
 
         // Call onReady() if Temasys plugin is not used
         if (!RTCBrowserType.isTemasysPluginUsed()) {
                 APP.xmpp.setVideoMute(false, function(mute) {
                     eventEmitter.emit(RTCEvents.VIDEO_MUTE, mute);
                 });
-                
+
                 callback();
             };
         }

modules/RTC/RTCUtils.js

 var MediaStreamType = require("../../service/RTC/MediaStreamTypes");
 var RTCBrowserType = require("./RTCBrowserType");
 var Resolutions = require("../../service/RTC/Resolutions");
+var RTCEvents = require("../../service/RTC/RTCEvents");
 var AdapterJS = require("./adapter.screenshare");
 
 var currentResolution = null;
 }
 
 
-function RTCUtils(RTCService, onTemasysPluginReady)
+function RTCUtils(RTCService, eventEmitter, onTemasysPluginReady)
 {
     var self = this;
     this.service = RTCService;
+    this.eventEmitter = eventEmitter;
     if (RTCBrowserType.isFirefox()) {
         var FFversion = RTCBrowserType.getFirefoxVersion();
         if (FFversion >= 40) {
                 self.setAvailableDevices(um, false);
                 console.warn('Failed to get access to local media. Error ',
                     error, constraints);
+                self.eventEmitter.emit(RTCEvents.GET_USER_MEDIA_FAILED, error);
                 if (failure_callback) {
                     failure_callback(error);
                 }
             });
     } catch (e) {
         console.error('GUM failed: ', e);
+        self.eventEmitter.emit(RTCEvents.GET_USER_MEDIA_FAILED, e);
         if(failure_callback) {
             failure_callback(e);
         }

modules/statistics/CallStats.js

 var io = require('socket.io-client');
 var callStats = null;
 
+// getUserMedia calls happen before CallStats init
+// so if there are any getUserMedia errors, we store them in this array
+// and send them to callstats on init
+var pendingUserMediaErrors = [];
+
 function initCallback (err, msg) {
     console.log("Initializing Status: err="+err+" msg="+msg);
 }
             usage,
             this.confID,
             this.pcCallback.bind(this));
+
+        // notify callstats about getUserMedia failures if there were any
+        if (pendingUserMediaErrors.length) {
+            pendingUserMediaErrors.forEach(this.sendGetUserMediaFailed, this);
+            pendingUserMediaErrors.length = 0;
+        }
     },
     pcCallback: function (err, msg) {
-        if (!callStats)
+        if (!callStats) {
             return;
+        }
         console.log("Monitoring status: "+ err + " msg: " + msg);
         callStats.sendFabricEvent(this.peerconnection,
             callStats.fabricEvent.fabricSetup, this.confID);
     },
     sendMuteEvent: function (mute, type) {
-        if (!callStats)
+        if (!callStats) {
             return;
+        }
         var event = null;
         if (type === "video") {
             event = (mute? callStats.fabricEvent.videoPause :
         callStats.sendFabricEvent(this.peerconnection,
             callStats.fabricEvent.fabricSetupFailed, this.confID);
     },
-    /**
+
+   /**
      * Sends the given feedback through CallStats.
      *
      * @param overallFeedback an integer between 1 and 5 indicating the
 
         callStats.sendUserFeedback(
             this.confID, feedbackJSON);
+    },
+
+    /**
+     * Notifies CallStats that getUserMedia failed.
+     *
+     * @param {Error} e error to send
+     */
+    sendGetUserMediaFailed: function (e) {
+        if(!callStats) {
+            pendingUserMediaErrors.push(e);
+            return;
+        }
+        callStats.reportError(this.peerconnection, this.confID,
+                              callStats.webRTCFunctions.getUserMedia, e);
+    },
+
+    /**
+     * Notifies CallStats that peer connection failed to create offer.
+     *
+     * @param {Error} e error to send
+     */
+    sendCreateOfferFailed: function (e) {
+        if(!callStats) {
+            return;
+        }
+        callStats.reportError(this.peerconnection, this.confID,
+                              callStats.webRTCFunctions.createOffer, e);
+    },
+
+    /**
+     * Notifies CallStats that peer connection failed to create answer.
+     *
+     * @param {Error} e error to send
+     */
+    sendCreateAnswerFailed: function (e) {
+        if(!callStats) {
+            return;
+        }
+        callStats.reportError(this.peerconnection, this.confID,
+                              callStats.webRTCFunctions.createAnswer, e);
+    },
+
+    /**
+     * Notifies CallStats that peer connection failed to set local description.
+     *
+     * @param {Error} e error to send
+     */
+    sendSetLocalDescFailed: function (e) {
+        if(!callStats) {
+            return;
+        }
+        callStats.reportError(this.peerconnection, this.confID,
+                              callStats.webRTCFunctions.setLocalDescription, e);
+    },
+
+    /**
+     * Notifies CallStats that peer connection failed to set remote description.
+     *
+     * @param {Error} e error to send
+     */
+    sendSetRemoteDescFailed: function (e) {
+        if(!callStats) {
+            return;
+        }
+        callStats.reportError(
+            this.peerconnection, this.confID,
+            callStats.webRTCFunctions.setRemoteDescription, e);
+    },
+
+    /**
+     * Notifies CallStats that peer connection failed to add ICE candidate.
+     *
+     * @param {Error} e error to send
+     */
+    sendAddIceCandidateFailed: function (e) {
+        if(!callStats) {
+            return;
+        }
+        callStats.reportError(this.peerconnection, this.confID,
+                              callStats.webRTCFunctions.addIceCandidate, e);
     }
 };
-module.exports = CallStats;
+module.exports = CallStats;

modules/statistics/statistics.js

         APP.RTC.addListener(RTCEvents.VIDEO_MUTE, function (mute) {
             CallStats.sendMuteEvent(mute, "video");
         });
+
+        APP.RTC.addListener(RTCEvents.GET_USER_MEDIA_FAILED, function (e) {
+            CallStats.sendGetUserMediaFailed(e);
+        });
+        APP.xmpp.addListener(RTCEvents.CREATE_OFFER_FAILED, function (e) {
+            CallStats.sendCreateOfferFailed(e);
+        });
+        APP.xmpp.addListener(RTCEvents.CREATE_ANSWER_FAILED, function (e) {
+            CallStats.sendCreateAnswerFailed(e);
+        });
+        APP.xmpp.addListener(RTCEvents.SET_LOCAL_DESCRIPTION_FAILED, function (e) {
+            CallStats.sendSetLocalDescFailed(e);
+        });
+        APP.xmpp.addListener(RTCEvents.SET_REMOTE_DESCRIPTION_FAILED, function (e) {
+            CallStats.sendSetRemoteDescFailed(e);
+        });
+        APP.xmpp.addListener(RTCEvents.ADD_ICE_CANDIDATE_FAILED, function (e) {
+            CallStats.sendAddIceCandidateFailed(e);
+        });
     }
 };
 

modules/xmpp/JingleSessionPC.js

 var async = require("async");
 var transform = require("sdp-transform");
 var XMPPEvents = require("../../service/xmpp/XMPPEvents");
+var RTCEvents = require("../../service/RTC/RTCEvents");
 var RTCBrowserType = require("../RTC/RTCBrowserType");
 var SSRCReplacement = require("./LocalSSRCReplacement");
 
                 self.peerconnection.addIceCandidate(candidate);
             } catch (e) {
                 console.error('addIceCandidate failed', e.toString(), line);
+                self.eventEmitter.emit(RTCEvents.ADD_ICE_CANDIDATE_FAILED, err);
             }
         });
     });

modules/xmpp/TraceablePeerConnection.js

     webkitRTCPeerConnection, RTCSessionDescription */
 /* jshint -W101 */
 var RTC = require('../RTC/RTC');
-var RTCBrowserType = require("../RTC/RTCBrowserType.js");
-var XMPPEvents = require("../../service/xmpp/XMPPEvents");
+var RTCBrowserType = require("../RTC/RTCBrowserType");
+var RTCEvents = require("../../service/RTC/RTCEvents");
 var SSRCReplacement = require("./LocalSSRCReplacement");
 
 function TraceablePeerConnection(ice_config, constraints, session) {
     } else {
         RTCPeerConnectionType = webkitRTCPeerConnection;
     }
+    self.eventEmitter = session.eventEmitter;
     this.peerconnection = new RTCPeerConnectionType(ice_config, constraints);
     this.updateLog = [];
     this.stats = {};
             var desc = this.peerconnection.localDescription;
 
             desc = SSRCReplacement.mungeLocalVideoSSRC(desc);
-            
+
             this.trace('getLocalDescription::preTransform', dumpSDP(desc));
 
             // if we're running on FF, transform to Plan B first.
         },
         function (err) {
             self.trace('setLocalDescriptionOnFailure', err);
+            self.eventEmitter.emit(RTCEvents.SET_LOCAL_DESCRIPTION_FAILED, err);
             failureCallback(err);
         }
     );
         },
         function (err) {
             self.trace('setRemoteDescriptionOnFailure', err);
+            self.eventEmitter.emit(RTCEvents.SET_REMOTE_DESCRIPTION_FAILED, err);
             failureCallback(err);
         }
     );
         },
         function(err) {
             self.trace('createOfferOnFailure', err);
+            self.eventEmitter.emit(RTCEvents.CREATE_OFFER_FAILED, err);
             failureCallback(err);
         },
         constraints
         },
         function(err) {
             self.trace('createAnswerOnFailure', err);
+            self.eventEmitter.emit(RTCEvents.CREATE_ANSWER_FAILED, err);
             failureCallback(err);
         },
         constraints
 };
 
 module.exports = TraceablePeerConnection;
-

service/RTC/RTCEvents.js

 var RTCEvents = {
     RTC_READY: "rtc.ready",
     DATA_CHANNEL_OPEN: "rtc.data_channel_open",
+    CREATE_OFFER_FAILED: "rtc.create_offer_failed",
+    CREATE_ANSWER_FAILED: "rtc.create_answer_failed",
+    SET_LOCAL_DESCRIPTION_FAILED: "rtc.set_local_description_failed",
+    SET_REMOTE_DESCRIPTION_FAILED: "rtc.set_remote_description_failed",
+    ADD_ICE_CANDIDATE_FAILED: "rtc.add_ice_candidate_failed",
+    GET_USER_MEDIA_FAILED: "rtc.get_user_media_failed",
     LASTN_CHANGED: "rtc.lastn_changed",
     DOMINANTSPEAKER_CHANGED: "rtc.dominantspeaker_changed",
     LASTN_ENDPOINT_CHANGED: "rtc.lastn_endpoint_changed",