feat(analytics): Add support for permanent properties and new parameters format

JitsiConference.js

     var crossRegion = null;
     if (window.jitsiRegionInfo)
         crossRegion = window.jitsiRegionInfo["CrossRegion"];
-    Statistics.analytics.sendEvent("session.initiate",
-        (now - this.room.connectionTimes["muc.joined"]),
-        crossRegion);
+    Statistics.analytics.sendEvent("session.initiate",{
+            value: now - this.room.connectionTimes["muc.joined"],
+            label: crossRegion
+        });
     try{
         jingleSession.initialize(false /* initiator */,this.room);
     } catch (error) {

JitsiConferenceEventManager.js

         {
             for (var ckey in chatRoom.connectionTimes){
                 var cvalue = chatRoom.connectionTimes[ckey];
-                Statistics.analytics.sendEvent('conference.' + ckey, cvalue);
+                Statistics.analytics.sendEvent('conference.' + ckey,
+                    {value: cvalue});
             }
             for (var xkey in chatRoom.xmpp.connectionTimes){
                 var xvalue = chatRoom.xmpp.connectionTimes[xkey];
-                Statistics.analytics.sendEvent('xmpp.' + xkey, xvalue);
+                Statistics.analytics.sendEvent('xmpp.' + xkey,
+                    {value: xvalue});
             }
         });
 
         var now = window.performance.now();
         logger.log("(TIME) data channel opened ", now);
         conference.room.connectionTimes["data.channel.opened"] = now;
-        Statistics.analytics.sendEvent('conference.dataChannel.open', now);
+        Statistics.analytics.sendEvent('conference.dataChannel.open',
+            {value: now});
     });
 
     this.rtcForwarder.forward(RTCEvents.LASTN_CHANGED,

JitsiConnection.js

     this.addEventListener(JitsiConnectionEvents.CONNECTION_FAILED,
         function (errType, msg) {
             // sends analytics and callstats event
-            Statistics.sendEventToAll('connection.failed.' + errType, msg);
+            Statistics.sendEventToAll('connection.failed.' + errType,
+                {label: msg});
         }.bind(this));
 
     this.addEventListener(JitsiConnectionEvents.CONNECTION_DISCONNECTED,

JitsiMeetJS.js

                     window.performance.now();
 
                 Statistics.analytics.sendEvent(addDeviceTypeToAnalyticsEvent(
-                    "getUserMedia.success", options), options);
+                    "getUserMedia.success", options), {value: options});
 
                 if(!RTC.options.disableAudioLevels)
                     for(let i = 0; i < tracks.length; i++) {
                     Statistics.analytics.sendEvent(
                         addDeviceTypeToAnalyticsEvent(
                             "getUserMedia.failed", options) + '.' + error.name,
-                        options);
+                        {value: options});
                 }
 
                 window.connectionTimes["obtainPermissions.end"] =

modules/RTC/JitsiLocalTrack.js

                 this._setHandler("track_unmute", () => {
                     this._clearNoDataFromSourceMuteResources();
                     Statistics.sendEventToAll(
-                            this.getType() + ".track_unmute",
-                            window.performance.now() - now);
+                        this.getType() + ".track_unmute",
+                        {value: window.performance.now() - now});
                 });
             }
         });

modules/RTC/JitsiRemoteTrack.js

     var eventName = type +'.ttfm';
     if(this.hasBeenMuted)
         eventName += '.muted';
-    Statistics.analytics.sendEvent(eventName, ttfm);
+    Statistics.analytics.sendEvent(eventName, {value: ttfm});
 };
 
 /**

modules/connectivity/ParticipantConnectionStatus.js

             }));
 
         // and analytics
-        Statistics.analytics.sendEvent('peer.conn.status', null, newStatus);
+        Statistics.analytics.sendEvent('peer.conn.status',
+            {label: newStatus});
 
         this.conference.eventEmitter.emit(
             JitsiConferenceEvents.PARTICIPANT_CONN_STATUS_CHANGED,

modules/statistics/AnalyticsAdapter.js

 
 function AnalyticsAdapter() {
     this.browserName = RTCBrowserType.getBrowserName();
+    /**
+     * Map of properties that will be added to every event
+     */
+    this.permanentProperties = {};
 }
 
 // some events may happen before init or implementation script download
 
 /**
  * Sends analytics event.
- * @param action
- * @param data
- * @param label
- */
-AnalyticsAdapter.prototype.sendEvent = function (action, data, label) {
-    if(this._checkAnalyticsAndMaybeCacheEvent(
-        "sendEvent", action, data,label)) {
-        try {
-            this.analytics.sendEvent(action, data, label, this.browserName);
-        } catch (ignored) { // eslint-disable-line no-empty
-        }
-    }
-};
-
-/**
- * Sends feedback.
- * @param {object} data with proprties:
- * - {int} overall an integer between 1 and 5 indicating the user feedback
- * - {string} detailed detailed feedback from the user.
- * @param label
+ * @param {String} action the name of the event
+ * @param {Object} data can be any JSON object
  */
-AnalyticsAdapter.prototype.sendFeedback = function (data, label) {
-    if(this._checkAnalyticsAndMaybeCacheEvent(
-        "sendFeedback", null, data,label)) {
+AnalyticsAdapter.prototype.sendEvent = function (action, data = {}) {
+    if(this._checkAnalyticsAndMaybeCacheEvent(action, data)) {
+        data.browserName = this.browserName;
         try {
-            this.analytics.sendFeedback(data, label, this.browserName);
+            this.analytics.sendEvent(action,
+                Object.assign({}, this.permanentProperties, data));
         } catch (ignored) { // eslint-disable-line no-empty
         }
     }
-
 };
 
 /**
  * a lazy decision, will wait for loaded or dispose methods to be called.
  * in the meantime we accumulate any events received. We should call this
  * method before trying to send the event.
- * @param {string} method - Identifies which method should we use later for the
- * cached events - "sendEvent" or "sendFeedback".
  * @param action
  * @param data
- * @param label
  */
 AnalyticsAdapter.prototype._checkAnalyticsAndMaybeCacheEvent
-= function (method, action, data, label) {
+= function (action, data) {
     if (this.analytics === null || typeof this.analytics === 'undefined') {
         // missing this.analytics but have window implementation, let's use it
         if (window.Analytics) {
         }
         else {
             AnalyticsAdapter.eventsQueue.push({
-                method: method,
                 action: action,
-                data: data,
-                label: label
+                data: data
             });
             // stored, lets break here
             return false;
     AnalyticsAdapter.eventsQueue.length = 0;
 };
 
+/**
+ * Adds map of properties that will be added to every event.
+ * @param {Object} properties the map of properties
+ */
+AnalyticsAdapter.prototype.addPermanentProperties = function (properties) {
+    this.permanentProperties
+        = Object.assign(this.permanentProperties, properties);
+};
+
 /**
  * Loaded analytics script. Sens queued events.
  */
     // new analytics lets send all events if any
     if (AnalyticsAdapter.eventsQueue.length) {
         AnalyticsAdapter.eventsQueue.forEach(function (event) {
-            switch(event.method) {
-                case "sendEvent":
-                    this.sendEvent(event.action, event.data, event.label);
-                    break;
-                case "sendFeedback":
-                    this.sendFeedback(event.data, event.label);
-                    break;
-            }
-
+            this.sendEvent(event.action, event.data);
         }.bind(this));
         AnalyticsAdapter.eventsQueue.length = 0;
     }

modules/statistics/statistics.js

 Statistics.prototype.sendFeedback = function(overall, detailed) {
     if(this.callstats)
         this.callstats.sendFeedback(overall, detailed);
-    Statistics.analytics.sendFeedback({overall, detailed});
+    Statistics.analytics.sendEvent("feedback.rating",
+        {value: overall, detailed: detailed});
 };
 
 Statistics.LOCAL_JID = require("../../service/statistics/constants").LOCAL_JID;
 
 /**
  * Sends event to analytics and callstats.
- * @param eventName {string} the event name.
- * @param msg {String} optional event info/messages.
+ * @param {string} eventName the event name.
+ * @param {Object} data the data to be sent.
  */
-Statistics.sendEventToAll = function (eventName, msg) {
-    this.analytics.sendEvent(eventName, null, msg);
-    Statistics.sendLog({name: eventName, msg: msg ? msg : ""});
+Statistics.sendEventToAll = function (eventName, data) {
+    this.analytics.sendEvent(eventName, data);
+    Statistics.sendLog({name: eventName, data});
 };
 
 module.exports = Statistics;

modules/xmpp/JingleSessionPC.js

         logger.log("(TIME) ICE " + self.peerconnection.iceConnectionState +
                     ":\t", now);
         Statistics.analytics.sendEvent(
-            'ice.' + self.peerconnection.iceConnectionState, now);
+            'ice.' + self.peerconnection.iceConnectionState, {value: now});
         switch (self.peerconnection.iceConnectionState) {
             case 'connected':
 

modules/xmpp/strophe.jingle.js

                     this.terminate(sess.sid);
                 }
                 Statistics.analytics.sendEvent(
-                    'xmpp.session-initiate', now);
+                    'xmpp.session-initiate', {value: now});
                 break;
             }
             case 'session-terminate': {
             case 'transport-replace':
                 logger.info("(TIME) Start transport replace", now);
                 Statistics.analytics.sendEvent(
-                    'xmpp.transport-replace.start', now);
+                    'xmpp.transport-replace.start', {value: now});
 
                 sess.replaceTransport($(iq).find('>jingle'), () => {
                     const successTime = window.performance.now();
                     logger.info(
                         "(TIME) Transport replace success!", successTime);
                     Statistics.analytics.sendEvent(
-                        'xmpp.transport-replace.success', successTime);
+                        'xmpp.transport-replace.success',
+                        {value: successTime});
                 }, (error) => {
                     GlobalOnErrorHandler.callErrorHandler(error);
                     logger.error('Transport replace failed', error);