Merge pull request #58 from damencho/global-error-handler

Global error handler and reporting those errors.

JitsiConference.js

     JitsiMeetJS._gumFailedHandler.push(function(error) {
         this.statistics.sendGetUserMediaFailed(error);
     }.bind(this));
+    JitsiMeetJS._globalOnErrorHandler.push(function(error) {
+        this.statistics.sendUnhandledError(error);
+    }.bind(this));
     this.participants = {};
     this.lastDominantSpeaker = null;
     this.dtmfManager = null;

JitsiMeetJS.js

     _gumFailedHandler: [],
     init: function (options) {
         Statistics.audioLevelsEnabled = !options.disableAudioLevels || true;
+
+        if (options.enableWindowOnErrorHandler) {
+            // if an old handler exists also fire its events
+            var oldOnErrorHandler = window.onerror;
+            window.onerror = function (message, source, lineno, colno, error) {
+
+                JitsiMeetJS.getGlobalOnErrorHandler(
+                    message, source, lineno, colno, error);
+
+                if(oldOnErrorHandler)
+                    oldOnErrorHandler(message, source, lineno, colno, error);
+            }
+        }
+
         return RTC.init(options || {});
     },
     /**
     enumerateDevices: function (callback) {
         RTC.enumerateDevices(callback);
     },
+    /**
+     * Array of functions that will receive the unhandled errors.
+     */
+    _globalOnErrorHandler: [],
+    /**
+     * @returns function that can be used to be attached to window.onerror and
+     * if options.enableWindowOnErrorHandler is enabled returns
+     * the function used by the lib.
+     * (function(message, source, lineno, colno, error)).
+     */
+    getGlobalOnErrorHandler: function (message, source, lineno, colno, error) {
+        console.error(
+            'UnhandledError: ' + message,
+            'Script: ' + source,
+            'Line: ' + lineno,
+            'Column: ' + colno,
+            'StackTrace: ', error);
+
+        JitsiMeetJS._globalOnErrorHandler.forEach(function (handler) {
+            handler(error);
+        });
+        if(!JitsiMeetJS._globalOnErrorHandler.length){
+            Statistics.sendUnhandledError(error);
+        }
+    },
 
     /**
      * Represents a hub/namespace for utility functionality which may be of

doc/API.md

     8. desktopSharingFirefoxExtensionURL - The URL to the Firefox extension for desktop sharing. "null" if no extension is required.
     9. disableAudioLevels - boolean property. Enables/disables audio levels.
     10. disableSimulcast - boolean property. Enables/disables simulcast.
+    11. enableWindowOnErrorHandler - boolean property (default false). Enables/disables attaching global onerror handler (window.onerror).
 
 * ```JitsiMeetJS.JitsiConnection``` - the ```JitsiConnection``` constructor. You can use that to create new server connection.
 
 * ```JitsiMeetJS.isDeviceListAvailable()```- returns true if retrieving the device list is support and false - otherwise.
 
 * ```JitsiMeetJS.isDesktopSharingEnabled()``` - returns true if desktop sharing is supported and false otherwise. NOTE: that method can be used after ```JitsiMeetJS.init(options)``` is completed otherwise the result will be always null.
+* ```JitsiMeetJS.getGlobalOnErrorHandler()``` - returns function that can be used to be attached to window.onerror and if options.enableWindowOnErrorHandler is enabled returns the function used by the lib. (function(message, source, lineno, colno, error)).
 
 * ```JitsiMeetJS.events``` - JS object that contains all events used by the API. You will need that JS object when you try to subscribe for connection or conference events.
     We have two event types - connection and conference. You can access the events with the following code ```JitsiMeetJS.events.<event_type>.<event_name>```.

modules/statistics/CallStats.js

     setLocalDescription:  "setLocalDescription",
     setRemoteDescription: "setRemoteDescription",
     addIceCandidate:      "addIceCandidate",
-    getUserMedia:         "getUserMedia"
+    getUserMedia:         "getUserMedia",
+    signallingError:      "signallingError"
 };
 
 /**
     CallStats._reportError.call(cs, wrtcFuncNames.addIceCandidate, e, pc);
 });
 
+/**
+ * Notifies CallStats that there is an unhandled error on the page.
+ *
+ * @param {Error} e error to send
+ * @param {RTCPeerConnection} pc connection on which failure occured.
+ * @param {CallStats} cs callstats instance related to the error (optional)
+ */
+CallStats.sendUnhandledError = _try_catch(function (e, cs) {
+    CallStats._reportError.call(cs, wrtcFuncNames.signallingError, e, null);
+});
+
 module.exports = CallStats;

modules/statistics/statistics.js

         CallStats.sendAddIceCandidateFailed(e, pc, this.callstats);
 };
 
+/**
+ * Notifies CallStats that there is an unhandled error on the page.
+ *
+ * @param {Error} e error to send
+ * @param {RTCPeerConnection} pc connection on which failure occured.
+ */
+Statistics.prototype.sendUnhandledError = function (e) {
+    if(this.callStatsIntegrationEnabled)
+        CallStats.sendUnhandledError(e, this.callstats);
+};
+
+/**
+ * Notifies CallStats that there is unhandled exception.
+ *
+ * @param {Error} e error to send
+ */
+Statistics.sendUnhandledError = function (e) {
+    CallStats.sendUnhandledError(e, null);
+};
+
 /**
  * Sends the given feedback through CallStats.
  *