Merge pull request #201 from jitsi/analytics-move

Analytics move

JitsiConference.js

 var JitsiConferenceErrors = require("./JitsiConferenceErrors");
 var JitsiParticipant = require("./JitsiParticipant");
 var Statistics = require("./modules/statistics/statistics");
+var AnalyticsAdapter = require("./modules/statistics/AnalyticsAdapter");
 var JitsiDTMFManager = require('./modules/DTMF/JitsiDTMFManager');
 var JitsiTrackEvents = require("./JitsiTrackEvents");
 var JitsiTrackErrors = require("./JitsiTrackErrors");
     // Accept incoming call
     this.room.setJingleSession(jingleSession);
     this.room.connectionTimes["session.initiate"] = now;
+    AnalyticsAdapter.sendEvent("muc.idle",
+        (now - this.room.connectionTimes["muc.joined"]));
     try{
         jingleSession.initialize(false /* initiator */,this.room);
     } catch (error) {

JitsiConferenceEventManager.js

 var AuthenticationEvents =
     require("./service/authentication/AuthenticationEvents");
 var Statistics = require("./modules/statistics/statistics");
+var AnalyticsAdapter = require("./modules/statistics/AnalyticsAdapter");
 var MediaType = require("./service/RTC/MediaType");
 
 /**
 
     this.chatRoomForwarder.forward(XMPPEvents.MUC_JOINED,
         JitsiConferenceEvents.CONFERENCE_JOINED);
+    // send some analytics events
+    chatRoom.addListener(XMPPEvents.MUC_JOINED,
+        function ()
+        {
+            for (var ckey in chatRoom.connectionTimes){
+                var cvalue = chatRoom.connectionTimes[ckey];
+                AnalyticsAdapter.sendEvent('conference.' + ckey, cvalue);
+            }
+            for (var xkey in chatRoom.xmpp.connectionTimes){
+                var xvalue = chatRoom.xmpp.connectionTimes[xkey];
+                AnalyticsAdapter.sendEvent('xmpp.' + xkey, xvalue);
+            }
+        });
 
     this.chatRoomForwarder.forward(XMPPEvents.ROOM_JOIN_ERROR,
         JitsiConferenceEvents.CONFERENCE_FAILED,
     this.chatRoomForwarder.forward(XMPPEvents.BRIDGE_DOWN,
         JitsiConferenceEvents.CONFERENCE_FAILED,
         JitsiConferenceErrors.VIDEOBRIDGE_NOT_AVAILABLE);
+    chatRoom.addListener(XMPPEvents.BRIDGE_DOWN,
+        function (){
+            AnalyticsAdapter.sendEvent('conference.bridgeDown');
+        });
 
     this.chatRoomForwarder.forward(XMPPEvents.RESERVATION_ERROR,
         JitsiConferenceEvents.CONFERENCE_FAILED,
 
     chatRoom.addListener(XMPPEvents.FOCUS_LEFT,
         function () {
+            AnalyticsAdapter.sendEvent('conference.focusLeft');
             if(!conference.connection._reload())
                 conference.eventEmitter.emit(
                     JitsiConferenceEvents.CONFERENCE_FAILED,
 
     this.chatRoomForwarder.forward(XMPPEvents.CONNECTION_INTERRUPTED,
         JitsiConferenceEvents.CONNECTION_INTERRUPTED);
+    chatRoom.addListener(XMPPEvents.CONNECTION_INTERRUPTED,
+        function () {
+            AnalyticsAdapter.sendEvent('connection.interrupted');
+        });
 
     this.chatRoomForwarder.forward(XMPPEvents.RECORDER_STATE_CHANGED,
         JitsiConferenceEvents.RECORDER_STATE_CHANGED);
         var now = window.performance.now();
         logger.log("(TIME) data channel opened ", now);
         conference.room.connectionTimes["data.channel.opened"] = now;
+        AnalyticsAdapter.sendEvent('conference.dataChannel.open', now);
     });
 
     this.rtcForwarder.forward(RTCEvents.LASTN_CHANGED,

JitsiConnection.js

 var XMPP = require("./modules/xmpp/xmpp");
 var JitsiConnectionEvents = require("./JitsiConnectionEvents");
 var JitsiConnectionErrors = require("./JitsiConnectionErrors");
+var AnalyticsAdapter = require("./modules/statistics/AnalyticsAdapter");
 
 /**
  * Creates new connection object for the Jitsi Meet server side video conferencing service. Provides access to the
 
     this.addEventListener(JitsiConnectionEvents.CONNECTION_FAILED,
         function (errType, msg) {
+            AnalyticsAdapter.sendEvent('connection.failed.' + errType);
             if(errType === JitsiConnectionErrors.OTHER_ERROR &&
                 (msg === "item-not-found" || msg === "host-unknown")) {
                     // FIXME: don't report the error if we are going to reload
                     this._reload();
                 }
         }.bind(this));
+
+    this.addEventListener(JitsiConnectionEvents.CONNECTION_DISCONNECTED,
+        function (msg) {
+            // we can see disconnects from normal tab closing of the browser
+            // and then there are no msgs, but we want to log only disconnects
+            // when there is real error
+            if(msg)
+                AnalyticsAdapter.sendEvent('connection.disconnected.' + msg);
+        });
 }
 
 /**
 JitsiConnection.prototype._reload = function () {
     if(this.retryOnFail === 0)
         return false;
+    AnalyticsAdapter.sendEvent('connection.reload');
     this.retryOnFail--;
     var states = {};
     for(var name in this.conferences) {

JitsiMeetJS.js

 var RTC = require("./modules/RTC/RTC");
 var RTCUIHelper = require("./modules/RTC/RTCUIHelper");
 var Statistics = require("./modules/statistics/statistics");
+var AnalyticsAdapter = require("./modules/statistics/AnalyticsAdapter");
 var Resolutions = require("./service/RTC/Resolutions");
 var ScriptUtil = require("./modules/util/ScriptUtil");
 var GlobalOnErrorHandler = require("./modules/util/GlobalOnErrorHandler");
     },
     logLevels: Logger.levels,
     mediaDevices: JitsiMediaDevices,
+    analytics: AnalyticsAdapter,
     init: function (options) {
         var logObject, attr;
         Statistics.audioLevelsEnabled = !options.disableAudioLevels;
         if (firePermissionPromptIsShownEvent === true) {
             window.setTimeout(function () {
                 if (!promiseFulfilled) {
-                    var browser = RTCBrowserType.getBrowserType()
-                        .split('rtc_browser.')[1];
-
-                    if (RTCBrowserType.isAndroid()) {
-                        browser = 'android';
-                    }
-
                     JitsiMediaDevices.emitEvent(
                         JitsiMediaDevicesEvents.PERMISSION_PROMPT_IS_SHOWN,
-                        browser);
+                        RTCBrowserType.getBrowserName());
                 }
             }, USER_MEDIA_PERMISSION_PROMPT_TIMEOUT);
         }

modules/RTC/JitsiRemoteTrack.js

 var JitsiTrack = require("./JitsiTrack");
 var JitsiTrackEvents = require("../../JitsiTrackEvents");
+var RTCBrowserType = require("./RTCBrowserType");
+var AnalyticsAdapter = require("../statistics/AnalyticsAdapter");
+
+var ttfmTrackerAudioAttached = false;
+var ttfmTrackerVideoAttached = false;
 
 /**
  * Represents a single media track (either audio or video).
     this.eventEmitter.emit(JitsiTrackEvents.TRACK_VIDEOTYPE_CHANGED, type);
 };
 
+/**
+ * Attach time to first media tracker only if there is conference and only
+ * for the first element.
+ * @param container the HTML container which can be 'video' or 'audio' element.
+ *        It can also be 'object' element if Temasys plugin is in use and this
+ *        method has been called previously on video or audio HTML element.
+ * @private
+ */
+JitsiRemoteTrack.prototype._attachTTFMTracker = function (container) {
+    if((ttfmTrackerAudioAttached && this.isAudioTrack())
+        || (ttfmTrackerVideoAttached && this.isVideoTrack()))
+        return;
+
+    if (this.isAudioTrack())
+        ttfmTrackerAudioAttached = true;
+    if (this.isVideoTrack())
+        ttfmTrackerVideoAttached = true;
+
+    // FIXME: this is not working for temasys
+    container.addEventListener("canplay", function () {
+        var type = (this.isVideoTrack() ? 'video' : 'audio');
+
+        var now = window.performance.now();
+        console.log("(TIME) Render " + type + ":\t", now);
+        this.conference.getConnectionTimes()[type + ".render"] = now;
+
+        var ttfm = now
+            - (this.conference.getConnectionTimes()["session.initiate"]
+            - this.conference.getConnectionTimes()["muc.joined"]);
+        this.conference.getConnectionTimes()[type + ".ttfm"] = ttfm;
+        console.log("(TIME) TTFM " + type + ":\t", ttfm);
+        AnalyticsAdapter.sendEvent(type +'.ttfm', ttfm);
+    }.bind(this));
+};
+
 module.exports = JitsiRemoteTrack;

modules/RTC/JitsiTrack.js

 
     this._maybeFireTrackAttached(container);
 
+    this._attachTTFMTracker(container);
+
     return container;
 };
 
     }
 };
 
+/**
+ * Attach time to first media tracker only if there is conference and only
+ * for the first element.
+ * @param container the HTML container which can be 'video' or 'audio' element.
+ *        It can also be 'object' element if Temasys plugin is in use and this
+ *        method has been called previously on video or audio HTML element.
+ * @private
+ */
+JitsiTrack.prototype._attachTTFMTracker = function (container) {
+};
+
 /**
  * Removes attached event listeners.
  *

modules/RTC/RTCBrowserType.js

         return currentBrowser;
     },
 
+    /**
+     * Gets current browser name, split from the type.
+     * @returns {string}
+     */
+    getBrowserName: function () {
+        var browser = currentBrowser.split('rtc_browser.')[1];
+        if (RTCBrowserType.isAndroid()) {
+            browser = 'android';
+        }
+        return browser;
+    },
+
     /**
      * Checks if current browser is Chrome.
      * @returns {boolean}

modules/statistics/AnalyticsAdapter.js

+var RTCBrowserType = require("../RTC/RTCBrowserType");
+
+function NoopAnalytics() {}
+NoopAnalytics.prototype.sendEvent = function () {};
+
+// XXX Since we asynchronously load the integration of the analytics API and the
+// analytics API may asynchronously load its implementation (e.g. Google
+// Analytics), we cannot make the decision with respect to which analytics
+// implementation we will use here and we have to postpone it i.e. we will make
+// a lazy decision.
+
+function AnalyticsAdapter() {
+    this.browserActionSuffix = '.' + RTCBrowserType.getBrowserName();
+}
+
+AnalyticsAdapter.prototype.sendEvent = function (action, data)
+{
+    var a = this.analytics;
+
+    if (a === null || typeof a === 'undefined') {
+        var AnalyticsImpl = window.Analytics || NoopAnalytics;
+
+        this.analytics = a = new AnalyticsImpl();
+    }
+    try {
+        a.sendEvent(action + this.browserActionSuffix, data);
+    } catch (ignored) {}
+};
+
+module.exports = new AnalyticsAdapter();

modules/xmpp/JingleSessionPC.js

 var RTCBrowserType = require("../RTC/RTCBrowserType");
 var RTC = require("../RTC/RTC");
 var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
+var AnalyticsAdapter = require("../statistics/AnalyticsAdapter");
 
 /**
  * Constant tells how long we're going to wait for IQ response, before timeout
             self.peerconnection.iceConnectionState] = now;
         logger.log("(TIME) ICE " + self.peerconnection.iceConnectionState +
                     ":\t", now);
+        AnalyticsAdapter.sendEvent(
+            'ice.' + self.peerconnection.iceConnectionState, now);
         switch (self.peerconnection.iceConnectionState) {
             case 'connected':
 

modules/xmpp/strophe.jingle.js

 var XMPPEvents = require("../../service/xmpp/XMPPEvents");
 var RTCBrowserType = require("../RTC/RTCBrowserType");
 var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
-
+var AnalyticsAdapter = require("../statistics/AnalyticsAdapter");
 
 module.exports = function(XMPP, eventEmitter) {
     Strophe.addConnectionPlugin('jingle', {
                             .up();
                         this.terminate(sess.sid);
                     }
+                    AnalyticsAdapter.sendEvent('xmpp.session-initiate', now);
                     break;
                 case 'session-terminate':
                     logger.log('terminating...', sess.sid);
                     this.terminate(sess.sid, reasonCondition, reasonText);
                     break;
                 case 'transport-replace':
-                    logger.info("(TIME) Start transport replace",
-                                window.performance.now());
+                    var now = window.performance.now();
+                    logger.info("(TIME) Start transport replace", now);
+                    AnalyticsAdapter.sendEvent(
+                        'xmpp.transport-replace.start', now);
+
                     sess.replaceTransport($(iq).find('>jingle'),
                         function () {
+                            var now = window.performance.now();
                             logger.info(
-                                "(TIME) Transport replace success!",
-                                window.performance.now());
+                                "(TIME) Transport replace success!", now);
+                            AnalyticsAdapter.sendEvent(
+                                'xmpp.transport-replace.success', now);
                         },
                         function(error) {
                             GlobalOnErrorHandler.callErrorHandler(error);