Cleanup (#643)

* ref: Simplifies the logic for handling an incoming jingle session-initiate.

* fix: Don't redundantly log cross region

information under a field name called "label".

* cleanup: Simplifies code. Adds the userAgent as a permanent property

for statistics (so that the client doesn't have to).

* ref: Names the parameter which specifies the name of the event "eventName".

* ref: Extracts event names to AnalyticsEvents.

* ref: Exports and imports constants individually.

* fix: Fixes CONNECTION_TIMES event names.

* ref: Arranges constants alphabetically.

* ref: Adds line breaks.

JitsiConference.js

 /* global __filename, $, Promise */
 import { Strophe } from 'strophe.js';
 
+import {
+    ICE_ESTABLISHMENT_DURATION_DIFF,
+    P2P_ESTABLISHED,
+    P2P_FAILED,
+    P2P_SWITCH_TO_JVB,
+    SESSION_INITIATE,
+    SESSION_RESTART,
+    SESSION_TERMINATE
+} from './service/statistics/AnalyticsEvents';
 import AvgRTPStatsReporter from './modules/statistics/AvgRTPStatsReporter';
 import ComponentsVersions from './modules/version/ComponentsVersions';
 import ConnectionQuality from './modules/connectivity/ConnectionQuality';
 };
 
 /**
- * Handles incoming call event.
+ * Handles an incoming call event for the P2P jingle session.
+ */
+JitsiConference.prototype._onIncomingCallP2P = function(
+        jingleSession,
+        jingleOffer) {
+
+    let rejectReason;
+    const role = this.room.getMemberRole(jingleSession.remoteJid);
+
+    if (role !== 'moderator') {
+        rejectReason = {
+            reason: 'security-error',
+            reasonDescription: 'Only focus can start new sessions',
+            errorMsg: 'Rejecting session-initiate from non-focus and'
+                        + `non-moderator user: ${jingleSession.remoteJid}`
+        };
+    } else if (!RTCBrowserType.isP2PSupported()) {
+        rejectReason = {
+            reason: 'unsupported-applications',
+            reasonDescription: 'P2P not supported',
+            errorMsg: 'This client does not support P2P connections'
+        };
+    } else if (!this.isP2PEnabled() && !this.isP2PTestModeEnabled()) {
+        rejectReason = {
+            reason: 'decline',
+            reasonDescription: 'P2P disabled',
+            errorMsg: 'P2P mode disabled in the configuration'
+        };
+    } else if (this.p2pJingleSession) {
+        // Reject incoming P2P call (already in progress)
+        rejectReason = {
+            reason: 'busy',
+            reasonDescription: 'P2P already in progress',
+            errorMsg: 'Duplicated P2P "session-initiate"'
+        };
+    }
+
+    if (rejectReason) {
+        this._rejectIncomingCall(jingleSession, rejectReason);
+    } else {
+        this._acceptP2PIncomingCall(jingleSession, jingleOffer);
+    }
+};
+
+/**
+ * Handles an incoming call event.
  */
 JitsiConference.prototype.onIncomingCall = function(
         jingleSession,
         now) {
     // Handle incoming P2P call
     if (jingleSession.isP2P) {
-        const role = this.room.getMemberRole(jingleSession.remoteJid);
+        this._onIncomingCallP2P(jingleSession, jingleOffer);
+    } else {
+        if (!this.room.isFocus(jingleSession.remoteJid)) {
+            const description = 'Rejecting session-initiate from non-focus.';
 
-        if (role !== 'moderator') {
-            // Reject incoming P2P call
-            this._rejectIncomingCallNonModerator(jingleSession);
-        } else if (!RTCBrowserType.isP2PSupported()) {
-            // Reject incoming P2P call (already in progress)
             this._rejectIncomingCall(
                 jingleSession, {
-                    reasonTag: 'unsupported-applications',
-                    reasonMsg: 'P2P not supported',
-                    errorMsg: 'This client does not support P2P connections'
+                    reason: 'security-error',
+                    reasonDescription: description,
+                    errorMsg: description
                 });
-        } else if (!this.isP2PEnabled() && !this.isP2PTestModeEnabled()) {
-            this._rejectIncomingCall(
-                jingleSession, {
-                    reasonTag: 'decline',
-                    reasonMsg: 'P2P disabled',
-                    errorMsg: 'P2P mode disabled in the configuration'
-                });
-        } else if (this.p2pJingleSession) {
-            // Reject incoming P2P call (already in progress)
-            this._rejectIncomingCall(
-                jingleSession, {
-                    reasonTag: 'busy',
-                    reasonMsg: 'P2P already in progress',
-                    errorMsg: 'Duplicated P2P "session-initiate"'
-                });
-        } else {
-            // Accept incoming P2P call
-            this._acceptP2PIncomingCall(jingleSession, jingleOffer);
-        }
-
-        return;
-    } else if (!this.room.isFocus(jingleSession.remoteJid)) {
-        this._rejectIncomingCall(jingleSession);
 
-        return;
+            return;
+        }
+        this._acceptJvbIncomingCall(jingleSession, jingleOffer, now);
     }
+};
+
+/**
+ * Accepts an incoming call event for the JVB jingle session.
+ */
+JitsiConference.prototype._acceptJvbIncomingCall = function(
+        jingleSession,
+        jingleOffer,
+        now) {
 
     // Accept incoming call
     this.jvbJingleSession = jingleSession;
 
     // Log "session.restart"
     if (this.wasStopped) {
-        Statistics.sendEventToAll('session.restart');
+        Statistics.sendEventToAll(SESSION_RESTART);
     }
 
-    // add info whether call is cross-region
-    let crossRegion = null;
-
-    if (this.options.config && this.options.config.deploymentInfo
-            && typeof this.options.config.deploymentInfo.crossRegion
-            !== 'undefined') {
-        crossRegion = this.options.config.deploymentInfo.crossRegion;
-    }
     Statistics.analytics.sendEvent(
-        'session.initiate', {
-            value: now - this.room.connectionTimes['muc.joined'],
-            label: crossRegion
+        SESSION_INITIATE,
+        {
+            value: now - this.room.connectionTimes['muc.joined']
         });
     try {
         jingleSession.initialize(false /* initiator */, this.room, this.rtc);
     }
 };
 
-/**
- * Rejects incoming Jingle call with 'security-error'. Method should be used to
- * reject calls initiated by unauthorised entities.
- * @param {JingleSessionPC} jingleSession the session instance to be rejected.
- * @private
- */
-JitsiConference.prototype._rejectIncomingCallNonModerator = function(
-        jingleSession) {
-    this._rejectIncomingCall(
-        jingleSession,
-        {
-            reasonTag: 'security-error',
-            reasonMsg: 'Only focus can start new sessions',
-            errorMsg: 'Rejecting session-initiate from non-focus and'
-                        + `non-moderator user: ${jingleSession.remoteJid}`
-        });
-};
-
 /**
  * Rejects incoming Jingle call.
  * @param {JingleSessionPC} jingleSession the session instance to be rejected.
  * @param {object} [options]
- * @param {string} options.reasonTag the name of the reason element as defined
+ * @param {string} options.reason the name of the reason element as defined
  * by Jingle
- * @param {string} options.reasonMsg the reason description which will
+ * @param {string} options.reasonDescription the reason description which will
  * be included in Jingle 'session-terminate' message.
  * @param {string} options.errorMsg an error message to be logged on global
  * error handler
         GlobalOnErrorHandler.callErrorHandler(new Error(options.errorMsg));
     }
 
-    // Terminate  the jingle session with a reason
+    // Terminate the jingle session with a reason
     jingleSession.terminate(
         null /* success callback => we don't care */,
         error => {
                 'An error occurred while trying to terminate'
                     + ' invalid Jingle session', error);
         }, {
-            reason: options && options.reasonTag,
-            reasonDescription: options && options.reasonMsg,
+            reason: options && options.reason,
+            reasonDescription: options && options.reasonDescription,
             sendSessionTerminate: true
         });
 };
     if (jingleSession === this.jvbJingleSession) {
         this.wasStopped = true;
 
-        // Send session.terminate event
-        Statistics.sendEventToAll('session.terminate');
+        Statistics.sendEventToAll(SESSION_TERMINATE);
 
         // Stop the stats
         if (this.statistics) {
 
         // Log analytics event, but only for the initiator to not count it twice
         if (this.p2pJingleSession && this.p2pJingleSession.isInitiator) {
-            Statistics.sendEventToAll('p2p.failed');
+            Statistics.sendEventToAll(P2P_FAILED);
         }
         this._stopP2PSession('connectivity-error', 'ICE FAILED');
     }
             = this.p2pEstablishmentDuration - this.jvbEstablishmentDuration;
 
         Statistics.analytics.sendEvent(
-            'ice.establishmentDurationDiff', {
-                'value': establishmentDurationDiff
-            });
+            ICE_ESTABLISHMENT_DURATION_DIFF,
+            { 'value': establishmentDurationDiff });
     }
 
     if (done) {
 
     // Log the P2P established event
     if (this.p2pJingleSession.isInitiator) {
-        Statistics.sendEventToAll('p2p.established');
+        Statistics.sendEventToAll(P2P_ESTABLISHED);
     }
 };
 
 
         // Log that there will be a switch back to the JVB connection
         if (this.p2pJingleSession.isInitiator && peerCount > 1) {
-            Statistics.sendEventToAll('p2p.switch_to_jvb');
+            Statistics.sendEventToAll(P2P_SWITCH_TO_JVB);
         }
         this._stopP2PSession();
     }

JitsiConferenceEventManager.js

 /* global __filename */
 import { Strophe } from 'strophe.js';
 
+import {
+    _CONNECTION_TIMES_,
+    BRIDGE_DOWN,
+    CONFERENCE_ERROR_,
+    CONNECTION_INTERRUPTED,
+    CONNECTION_RESTORED,
+    DATA_CHANNEL_OPEN,
+    FOCUS_LEFT,
+    REMOTELY_MUTED
+} from './service/statistics/AnalyticsEvents';
 import AuthenticationEvents
     from './service/authentication/AuthenticationEvents';
 import EventEmitterForwarder from './modules/util/EventEmitterForwarder';
         });
     conference.on(
         JitsiConferenceEvents.CONNECTION_INTERRUPTED,
-        Statistics.sendEventToAll.bind(Statistics, 'connection.interrupted'));
+        Statistics.sendEventToAll.bind(
+            Statistics, CONNECTION_INTERRUPTED));
     conference.on(
         JitsiConferenceEvents.CONNECTION_RESTORED,
-        Statistics.sendEventToAll.bind(Statistics, 'connection.restored'));
+        Statistics.sendEventToAll.bind(
+            Statistics, CONNECTION_RESTORED));
 }
 
 /**
 
     chatRoom.addListener(XMPPEvents.AUDIO_MUTED_BY_FOCUS,
         value => {
-            Statistics.analytics.sendEvent('conference.remotelyMuted');
+            Statistics.analytics.sendEvent(REMOTELY_MUTED);
 
             // set isMutedByFocus when setAudioMute Promise ends
             conference.rtc.setAudioMute(value).then(
 
             Object.keys(chatRoom.connectionTimes).forEach(key => {
                 const value = chatRoom.connectionTimes[key];
+                const eventName = `conference.${_CONNECTION_TIMES_}${key}`;
 
-                Statistics.analytics.sendEvent(`conference.${key}`, { value });
+                Statistics.analytics.sendEvent(eventName, { value });
             });
             Object.keys(chatRoom.xmpp.connectionTimes).forEach(key => {
                 const value = chatRoom.xmpp.connectionTimes[key];
+                const eventName = `xmpp.${_CONNECTION_TIMES_}${key}`;
 
-                Statistics.analytics.sendEvent(`xmpp.${key}`, { value });
+                Statistics.analytics.sendEvent(eventName, { value });
             });
         });
 
         JitsiConferenceErrors.VIDEOBRIDGE_NOT_AVAILABLE);
     chatRoom.addListener(
         XMPPEvents.BRIDGE_DOWN,
-        () => Statistics.analytics.sendEvent('conference.bridgeDown'));
+        () => Statistics.analytics.sendEvent(BRIDGE_DOWN));
 
     this.chatRoomForwarder.forward(XMPPEvents.RESERVATION_ERROR,
         JitsiConferenceEvents.CONFERENCE_FAILED,
 
     chatRoom.addListener(XMPPEvents.FOCUS_LEFT,
         () => {
-            Statistics.analytics.sendEvent('conference.focusLeft');
+            Statistics.analytics.sendEvent(FOCUS_LEFT);
             conference.eventEmitter.emit(
                 JitsiConferenceEvents.CONFERENCE_FAILED,
                 JitsiConferenceErrors.FOCUS_LEFT);
         });
 
     const eventLogHandler
-        = reason => Statistics.sendEventToAll(`conference.error.${reason}`);
+        = reason => Statistics.sendEventToAll(`${CONFERENCE_ERROR_}.${reason}`);
 
     chatRoom.addListener(XMPPEvents.SESSION_ACCEPT_TIMEOUT,
         jingleSession => {
 
         logger.log('(TIME) data channel opened ', now);
         conference.room.connectionTimes['data.channel.opened'] = now;
-        Statistics.analytics.sendEvent('conference.dataChannel.open',
-            { value: now });
+        Statistics.analytics.sendEvent(DATA_CHANNEL_OPEN, { value: now });
 
         conference.eventEmitter.emit(JitsiConferenceEvents.DATA_CHANNEL_OPENED);
     });

JitsiConnection.js

+import {
+    CONNECTION_DISCONNECTED_,
+    CONNECTION_FAILED_
+} from './service/statistics/AnalyticsEvents';
 import JitsiConference from './JitsiConference';
 import * as JitsiConnectionEvents from './JitsiConnectionEvents';
 import Statistics from './modules/statistics/statistics';
 import XMPP from './modules/xmpp/xmpp';
 
 /**
- * Creates new connection object for the Jitsi Meet server side video
+ * Creates a new connection object for the Jitsi Meet server side video
  * conferencing service. Provides access to the JitsiConference interface.
  * @param appID identification for the provider of Jitsi Meet video conferencing
  * services.
 
     this.addEventListener(JitsiConnectionEvents.CONNECTION_FAILED,
         (errType, msg) => {
-            // sends analytics and callstats event
-            Statistics.sendEventToAll(`connection.failed.${errType}`,
+            Statistics.sendEventToAll(
+                `${CONNECTION_FAILED_}.${errType}`,
                 { label: msg });
         });
 
             // when there is real error
             if (msg) {
                 Statistics.analytics.sendEvent(
-                    `connection.disconnected.${msg}`);
+                    `${CONNECTION_DISCONNECTED_}.${msg}`);
             }
             Statistics.sendLog(
                 JSON.stringify({ id: 'connection.disconnected',

JitsiMeetJS.js

 /* global __filename */
 
+import {
+    GET_USER_MEDIA_DEVICE_NOT_FOUND_,
+    GET_USER_MEDIA_FAIL_,
+    GET_USER_MEDIA_FAILED_,
+    GET_USER_MEDIA_SUCCESS_,
+    GET_USER_MEDIA_USER_CANCEL_
+} from './service/statistics/AnalyticsEvents';
 import AuthUtil from './modules/util/AuthUtil';
 import * as ConnectionQualityEvents
     from './service/connectivity/ConnectionQualityEvents';
                 window.connectionTimes['obtainPermissions.end']
                     = window.performance.now();
 
-                Statistics.analytics.sendEvent(addDeviceTypeToAnalyticsEvent(
-                    'getUserMedia.success', options), { value: options });
+                Statistics.analytics.sendEvent(
+                    addDeviceTypeToAnalyticsEvent(
+                        GET_USER_MEDIA_SUCCESS_, options),
+                    { value: options });
 
                 if (!RTC.options.disableAudioLevels) {
                     for (let i = 0; i < tracks.length; i++) {
                             newResolution);
 
                         Statistics.analytics.sendEvent(
-                            `getUserMedia.fail.resolution.${oldResolution}`);
+                            `${GET_USER_MEDIA_FAIL_}.resolution.${
+                                oldResolution}`);
 
                         return this.createLocalTracks(options);
                     }
 
                     Statistics.sendLog(JSON.stringify(logObject));
                     Statistics.analytics.sendEvent(
-                        'getUserMedia.userCancel.extensionInstall');
+                        `${GET_USER_MEDIA_USER_CANCEL_}.extensionInstall`);
                 } else if (JitsiTrackErrors.NOT_FOUND === error.name) {
                     // logs not found devices with just application log to cs
                     const logObject = {
 
                     Statistics.sendLog(JSON.stringify(logObject));
                     Statistics.analytics.sendEvent(
-                        `getUserMedia.deviceNotFound.${
+                        `${GET_USER_MEDIA_DEVICE_NOT_FOUND_}.${
                             error.gum.devices.join('.')}`);
                 } else {
                     // Report gUM failed to the stats
                     Statistics.sendGetUserMediaFailed(error);
-                    const event
+                    const eventName
                         = addDeviceTypeToAnalyticsEvent(
-                            'getUserMedia.failed',
-                            options);
+                            GET_USER_MEDIA_FAILED_, options);
 
                     Statistics.analytics.sendEvent(
-                        `${event}.${error.name}`,
+                        `${eventName}.${error.name}`,
                         { value: options });
                 }
 
     },
 
     /**
-     * Checks if its possible to enumerate available cameras/micropones.
+     * Checks if its possible to enumerate available cameras/microphones.
      * @returns {Promise<boolean>} a Promise which will be resolved only once
      * the WebRTC stack is ready, either with true if the device listing is
      * available available or with false otherwise.

modules/RTC/JitsiLocalTrack.js

 /* global __filename, Promise */
 
+import {
+    _NO_DATA_FROM_SOURCE,
+    _TRACK_UNMUTE
+} from '../../service/statistics/AnalyticsEvents';
 import CameraFacingMode from '../../service/RTC/CameraFacingMode';
 import { getLogger } from 'jitsi-meet-logger';
 import JitsiTrack from './JitsiTrack';
                     this._setHandler('track_unmute', () => {
                         this._clearNoDataFromSourceMuteResources();
                         Statistics.sendEventToAll(
-                            `${this.getType()}.track_unmute`,
+                            `${this.getType()}.${_TRACK_UNMUTE}`,
                             { value: window.performance.now() - now });
                     });
                 }
      */
     _fireNoDataFromSourceEvent() {
         this.emit(NO_DATA_FROM_SOURCE);
-        const eventName = `${this.getType()}.no_data_from_source`;
+        const eventName = `${this.getType()}.${_NO_DATA_FROM_SOURCE}`;
 
         Statistics.analytics.sendEvent(eventName);
         const log = { name: eventName };

modules/RTC/JitsiRemoteTrack.js

+import { _TTFM_ } from '../../service/statistics/AnalyticsEvents';
 import JitsiTrack from './JitsiTrack';
 import * as JitsiTrackEvents from '../../JitsiTrackEvents';
 import RTCBrowserType from './RTCBrowserType';
 
         this.conference.getConnectionTimes()[`${type}.ttfm`] = ttfm;
         console.log(`(TIME) TTFM ${type}:\t`, ttfm);
-        let eventName = `${type}.ttfm`;
+        let eventName = `${type}.${_TTFM_}`;
 
         if (this.hasBeenMuted) {
             eventName += '.muted';

modules/RTC/RTCUtils.js

           webkitRTCPeerConnection,
           webkitURL
 */
+import { DEVICE_LIST } from '../../service/statistics/AnalyticsEvents';
 import CameraFacingMode from '../../service/RTC/CameraFacingMode';
 import EventEmitter from 'events';
 import { getLogger } from 'jitsi-meet-logger';
                 };
             });
 
-    Statistics.analytics.sendEvent(
-        'devices.deviceList', {
-            devices: devicesPropsArray
-        });
+    Statistics.analytics.sendEvent(DEVICE_LIST, { devices: devicesPropsArray });
 }
 
 /**

modules/statistics/AnalyticsAdapter.js

 
     /**
      * Cache analytics event.
-     * @param {String} action the name of the event
+     * @param {String} eventName the name of the event
      * @param {Object} data can be any JSON object
      */
-    sendEvent(action, data = {}) {
+    sendEvent(eventName, data = {}) {
         this.eventCache.push({
-            action,
+            eventName,
             data
         });
     }
      */
     constructor() {
         this.disposed = false;
-        this.browserName = RTCBrowserType.getBrowserName();
         this.analyticsHandlers = new Set();
 
         /**
          * Map of properties that will be added to every event
          */
         this.permanentProperties = {
-            callstatsname: Settings.callStatsUserName
+            callstatsname: Settings.callStatsUserName,
+            userAgent: navigator.userAgent,
+            browserName: RTCBrowserType.getBrowserName()
         };
 
         this.analyticsHandlers.add(cacheAnalytics);
 
     /**
      * Sends analytics event.
-     * @param {String} action the name of the event
+     * @param {String} eventName the name of the event
      * @param {Object} data can be any JSON object
      */
-    sendEvent(action, data = {}) {
-        const modifiedData = Object.assign(
-            { browserName: this.browserName }, this.permanentProperties, data);
+    sendEvent(eventName, data = {}) {
+        const modifiedData = Object.assign({}, this.permanentProperties, data);
 
         this.analyticsHandlers.forEach(
             analytics =>
                 analytics.sendEvent(
-                    action,
+                    eventName,
                     analytics === cacheAnalytics ? data : modifiedData
                 )
         );
         }
         this.analyticsHandlers = new Set(handlers);
         cacheAnalytics.drainCachedEvents().forEach(
-            ev => this.sendEvent(ev.action, ev.data));
+            ev => this.sendEvent(ev.eventName, ev.data));
     }
 
     /**

modules/statistics/AvgRTPStatsReporter.js

 /* global __filename */
 
+import { AVG_RTP_STATS } from '../../service/statistics/AnalyticsEvents';
 import { getLogger } from 'jitsi-meet-logger';
 import * as ConnectionQualityEvents
     from '../../service/connectivity/ConnectionQualityEvents';
 import Statistics from './statistics';
 import * as VideoType from '../../service/RTC/VideoType';
 
-/**
- * All avg RTP stats are currently reported under 1 event name, but with
- * different properties that allows to distinguish between a P2P call, a call
- * relayed through TURN or the JVB, and multiparty vs 1:1. This constant stores
- * the name of this event. Example structure of "avg.rtp.stats" analytics event:
- *
- * {
- *   p2p: true,
- *   conferenceSize: 2,
- *   localCandidateType: "relay",
- *   remoteCandidateType: "relay",
- *   transportType: "udp",
- *
- *   "stat_avg_rtt": {
- *     value: 200,
- *     samples: [ 100, 200, 300 ]
- *   },
- *   "stat_avg_packetloss_total": {
- *     value: 10,
- *     samples: [ 5, 10, 15]
- *   }
- * }
- *
- * 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);
 
 /**
                     }
                 }
 
-                Statistics.analytics.sendEvent(
-                    AVG_RTP_STATS_EVENT, batchReport);
+                Statistics.analytics.sendEvent(AVG_RTP_STATS, batchReport);
             }
 
             this._resetAvgStats();
 
             this._avgCQ.appendReport(batchReport);
 
-            Statistics.analytics.sendEvent(AVG_RTP_STATS_EVENT, batchReport);
+            Statistics.analytics.sendEvent(AVG_RTP_STATS, batchReport);
 
             this._resetAvgStats();
         }

modules/statistics/statistics.js

 import EventEmitter from 'events';
 
+import {
+    FEEDBACK,
+    ICE_FAILED
+} from '../../service/statistics/AnalyticsEvents';
 import analytics from './AnalyticsAdapter';
 import CallStats from './CallStats';
 import LocalStats from './LocalStatsCollector';
 };
 
 /**
- * Notifies CallStats and analytics(if present) for ice connection failed
+ * Notifies CallStats and analytics (if present) for ice connection failed
  * @param {TraceablePeerConnection} tpc connection on which failure occurred.
  */
 Statistics.prototype.sendIceConnectionFailedEvent = function(tpc) {
     if (instance) {
         instance.sendIceConnectionFailedEvent();
     }
-    Statistics.analytics.sendEvent('connection.ice_failed');
+    Statistics.analytics.sendEvent(ICE_FAILED);
 };
 
 /**
  */
 Statistics.prototype.sendFeedback = function(overall, detailed) {
     CallStats.sendFeedback(this._getCallStatsConfID(), overall, detailed);
-    Statistics.analytics.sendEvent('feedback.rating',
-        { value: overall,
-            detailed });
+    Statistics.analytics.sendEvent(
+        FEEDBACK,
+        {
+            value: overall,
+            detailed
+        });
 };
 
 Statistics.LOCAL_JID = require('../../service/statistics/constants').LOCAL_JID;
  */
 Statistics.sendEventToAll = function(eventName, data) {
     this.analytics.sendEvent(eventName, data);
-    Statistics.sendLog(JSON.stringify({ name: eventName,
-        data }));
+    Statistics.sendLog(
+        JSON.stringify(
+            {
+                name: eventName,
+                data
+            }));
 };

modules/xmpp/JingleSessionPC.js

 /* global __filename, $ */
 
+import {
+    _ICE_CHECKING_DURATION,
+    _ICE_CONNECTION_STATE_,
+    _ICE_ESTABLISHMENT_DURATION,
+    _ICE_GATHERING_DURATION
+} from '../../service/statistics/AnalyticsEvents';
 import async from 'async';
 import { getLogger } from 'jitsi-meet-logger';
 import { $iq, Strophe } from 'strophe.js';
                 // End of gathering
                 let eventName = this.isP2P ? 'p2p.ice.' : 'ice.';
 
-                eventName += this.isInitiator ? 'initiator' : 'responder';
-                eventName += '.gatheringDuration';
+                eventName += this.isInitiator ? 'initiator.' : 'responder.';
+                eventName += _ICE_GATHERING_DURATION;
                 Statistics.analytics.sendEvent(
                     eventName,
                     { value: now - this._gatheringStartedTimestamp });
                 `(TIME) ICE ${this.peerconnection.iceConnectionState}`
                     + ` P2P? ${this.isP2P}:\t`,
                 now);
+            const iceConnectionEventName
+                = `${this.isP2P ? 'p2p.' : ''}${_ICE_CONNECTION_STATE_}.${
+                    this.peerconnection.iceConnectionState}`;
+
             Statistics.analytics.sendEvent(
-                `${this.isP2P ? 'p2p.ice.' : 'ice.'}`
-                    + `${this.peerconnection.iceConnectionState}`,
-                { value: now });
+                iceConnectionEventName, { value: now });
             this.room.eventEmitter.emit(
                 XMPPEvents.ICE_CONNECTION_STATE_CHANGED,
                 this,
 
                     eventName += this.isInitiator ? 'initiator.' : 'responder.';
                     Statistics.analytics.sendEvent(
-                        `${eventName}checksDuration`,
+                        `${eventName}${_ICE_CHECKING_DURATION}`,
                         {
                             value: now - this._iceCheckingStartedTimestamp
                         });
                     this.establishmentDuration = now - iceStarted;
 
                     Statistics.analytics.sendEvent(
-                        `${eventName}establishmentDuration`,
+                        `${eventName}${_ICE_ESTABLISHMENT_DURATION}`,
                         {
                             value: this.establishmentDuration
                         });

modules/xmpp/strophe.jingle.js

 /* global $, __filename */
 
+import {
+    SESSION_INITIATE_RECEIVED,
+    TRANSPORT_REPLACE_START,
+    TRANSPORT_REPLACE_SUCCESS
+} from '../../service/statistics/AnalyticsEvents';
 import { getLogger } from 'jitsi-meet-logger';
 import { $iq, Strophe } from 'strophe.js';
 
             this.eventEmitter.emit(XMPPEvents.CALL_INCOMING,
                 sess, $(iq).find('>jingle'), now);
             Statistics.analytics.sendEvent(
-                'xmpp.session-initiate', { value: now });
+                SESSION_INITIATE_RECEIVED, { value: now });
             break;
         }
         case 'session-accept': {
         case 'transport-replace':
             logger.info('(TIME) Start transport replace', now);
             Statistics.analytics.sendEvent(
-                'xmpp.transport-replace.start',
+                TRANSPORT_REPLACE_START,
                 { value: now });
 
             sess.replaceTransport($(iq).find('>jingle'), () => {
 
                 logger.info('(TIME) Transport replace success!', successTime);
                 Statistics.analytics.sendEvent(
-                    'xmpp.transport-replace.success',
+                    TRANSPORT_REPLACE_SUCCESS,
                     { value: successTime });
             }, error => {
                 GlobalOnErrorHandler.callErrorHandler(error);

service/statistics/AnalyticsEvents.js

+/**
+ * Note that an event's own properties and its permanent properties are
+ * are merged in one object. Because of this an event should never use
+ * properties with names that are already used by permanent properties
+ * (unless the intention is to override a permanent property). Here is a
+ * (non-exhaustive) list of currently know permanent properties:
+ *
+ * abtestSuspendVideo
+ * browserName
+ * callstatsname
+ * crossRegion
+ * forceJvb121
+ * region
+ * roomName
+ * shard
+ * size
+ * userAgent
+ * userRegion
+ *
+ * The naming convention for the constants below uses "_" as a prefix or
+ * suffix to indicate that known usage of the constant prepends or appends
+ * a string to the name of the event.
+ */
+
+/**
+ * Properties: value
+ *
+ * TODO: document, reformat
+ *
+ * Full event names (uncertain):
+ * conference.muc.joined (???)
+ * conference.sharingDesktop.start (???)
+ * conference.sharingDesktop.stop (???)
+ * xmpp.attached (???)
+ * xmpp.attaching (???)
+ * xmpp.connected (???)
+ * xmpp.connecting (???)
+ * xmpp.session-initiate (???)
+ */
+export const _CONNECTION_TIMES_ = '';
+
+/**
+ * TODO: document, reformat (group together with other ICE events)
+ *
+ * Known full event names:
+ * ice.initiator.checksDuration
+ * ice.responder.checksDuration
+ * p2p.ice.initiator.checksDuration
+ * p2p.ice.responder.checksDuration
+ *
+ * Properties: value
+ */
+export const _ICE_CHECKING_DURATION = 'checksDuration';
+
+/**
+ * TODO: document, reformat
+ *
+ * Known full event names:
+ * ice.checking
+ * ice.closed
+ * ice.completed
+ * ice.connected
+ * ice.disconnected
+ * ice.failed
+ * p2p.ice.checking
+ * p2p.ice.closed
+ * p2p.ice.completed
+ * p2p.ice.connected
+ * p2p.ice.disconnected
+ * p2p.ice.failed
+ *
+ * Properties: value
+ */
+export const _ICE_CONNECTION_STATE_ = 'ice';
+
+/**
+ * TODO: document, reformat (group together with other ICE events)
+ *
+ * Known full event names:
+ * ice.initiator.establishmentDuration
+ * ice.responder.establishmentDuration
+ * p2p.ice.initiator.establishmentDuration
+ * p2p.ice.responder.establishmentDuration
+ *
+ * Properties: value
+ */
+export const _ICE_ESTABLISHMENT_DURATION = 'establishmentDuration';
+
+/**
+ * TODO: document, reformat
+ *
+ * Known full event names:
+ * ice.initiator.gatheringDuration
+ * ice.responder.gatheringDuration
+ * p2p.ice.initiator.gatheringDuration
+ * p2p.ice.responder.gatheringDuration
+ *
+ * Properties: value
+ */
+export const _ICE_GATHERING_DURATION = 'gatheringDuration';
+
+/**
+ * TODO: document, reformat
+ *
+ * Known full event names:
+ * audio.no_data_from_source
+ * video.no_data_from_source
+ */
+export const _NO_DATA_FROM_SOURCE = 'no_data_from_source';
+
+/**
+ * TODO: document, reformat
+ *
+ * Known full event names:
+ * audio.track_unmute
+ * video.track_unmute
+ */
+export const _TRACK_UNMUTE = 'track_unmute';
+
+/**
+ * TODO: document, reformat
+ *
+ * TTMF: Time To First Media
+ *
+ * Known full event names:
+ * audio.ttfm
+ * video.ttfm
+ * audio.ttfm.muted
+ * video.ttfm.muted
+ */
+export const _TTFM_ = 'ttfm';
+
+/**
+ * All average RTP stats are currently reported under 1 event name, but with
+ * different properties that allows to distinguish between a P2P call, a
+ * call relayed through TURN or the JVB, and multiparty vs 1:1.
+ * Example structure of an "avg.rtp.stats" analytics event:
+ *
+ * {
+     *   p2p: true,
+     *   conferenceSize: 2,
+     *   localCandidateType: "relay",
+     *   remoteCandidateType: "relay",
+     *   transportType: "udp",
+     *
+     *   "stat_avg_rtt": {
+     *     value: 200,
+     *     samples: [ 100, 200, 300 ]
+     *   },
+     *   "stat_avg_packetloss_total": {
+     *     value: 10,
+     *     samples: [ 5, 10, 15]
+     *   }
+     * }
+ *
+ * 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.
+ */
+export const AVG_RTP_STATS = 'avg.rtp.stats';
+
+/**
+ * Properties: none
+ *
+ * TODO: document, deprecate?
+ */
+export const BRIDGE_DOWN = 'conference.bridgeDown';
+
+/**
+ * Properties: none
+ *
+ * Known full event names:
+ * conference.error.p2pSessionAcceptTimeout
+ * conference.error.sessionAcceptTimeout
+ *
+ * TODO: document, reformat
+ */
+export const CONFERENCE_ERROR_ = 'conference.error';
+
+/**
+ * Properties: none
+ *
+ * TODO: document
+ */
+export const CONNECTION_INTERRUPTED = 'connection.interrupted';
+
+/**
+ * Properties: none
+ *
+ * Known full event names: NONE
+ *
+ * TODO: document, reformat?, deprecate?
+ */
+export const CONNECTION_DISCONNECTED_ = 'connection.disconnected';
+
+/**
+ * Properties: label
+ *
+ * Known full event names:
+ * connection.failed.connection.droppedError
+ * connection.failed.connection.otherError
+ * connection.failed.connection.passwordRequired
+ *
+ * TODO: document, reformat
+ */
+export const CONNECTION_FAILED_ = 'connection.failed';
+
+/**
+ * Properties: none
+ *
+ * TODO: document
+ */
+export const CONNECTION_RESTORED = 'connection.restored';
+
+/**
+ * Properties: value
+ *
+ * TODO: document, deprecate (is it the same as the one which is part of
+ * CONNECTION_TIMES?)
+ */
+export const DATA_CHANNEL_OPEN = 'conference.dataChannel.open';
+
+/**
+ * TODO: document, reformat
+ */
+export const DEVICE_LIST = 'devices.deviceList';
+
+/**
+ * User feedback event.
+ * Properties: value, detailed
+ *
+ * TODO: document
+ */
+export const FEEDBACK = 'feedback.rating';
+
+/**
+ * Properties: none
+ *
+ * TODO: document
+ */
+export const FOCUS_LEFT = 'conference.focusLeft';
+
+/**
+ * Properties: none
+ *
+ * Known full event names:
+ * getUserMedia.deviceNotFound.audio
+ * getUserMedia.deviceNotFound.audio.video
+ * getUserMedia.deviceNotFound.video
+ * getUserMedia.deviceNotFound.screen
+ *
+ * TODO: document, reformat, merge with GET_USER_MEDIA_FAILED?
+ */
+export const GET_USER_MEDIA_DEVICE_NOT_FOUND_
+    = 'getUserMedia.deviceNotFound';
+
+/**
+ * Properties: none
+ *
+ * Known full event names:
+ * getUserMedia.fail.resolution.180
+ * getUserMedia.fail.resolution.360
+ * getUserMedia.fail.resolution.640
+ * getUserMedia.fail.resolution.720
+ * getUserMedia.fail.resolution.960
+ *
+ * TODO: reformat, merge with GET_USER_MEDIA_FAILED
+ */
+export const GET_USER_MEDIA_FAIL_ = 'getUserMedia.fail';
+
+/**
+ * Properties: value
+ *
+ * Known full event names:
+ * getUserMedia.failed.Error
+ * getUserMedia.failed.TypeError
+ * getUserMedia.failed.audio.TypeError
+ * getUserMedia.failed.audio.gum.general
+ * getUserMedia.failed.audio.gum.permission_denied
+ * getUserMedia.failed.audio.track.no_data_from_source
+ * getUserMedia.failed.audio.video.180.gum.general
+ * getUserMedia.failed.audio.video.360.gum.general
+ * getUserMedia.failed.audio.video.360.gum.permission_denied
+ * getUserMedia.failed.audio.video.360.track.no_data_from_source
+ * getUserMedia.failed.audio.video.720.TypeError
+ * getUserMedia.failed.audio.video.720.gum.constraint_failed
+ * getUserMedia.failed.audio.video.720.gum.general
+ * getUserMedia.failed.audio.video.720.gum.permission_denied
+ * getUserMedia.failed.audio.video.720.track.no_data_from_source
+ * getUserMedia.failed.audio.video.960.gum.permission_denied
+ * getUserMedia.failed.audio.video.undefined.gum.general
+ * getUserMedia.failed.desktop.TypeError
+ * getUserMedia.failed.desktop.gum.chrome_extension_generic_error
+ * getUserMedia.failed.desktop.gum.chrome_extension_installation_error
+ * getUserMedia.failed.desktop.gum.chrome_extension_user_gesture_required
+ * getUserMedia.failed.desktop.gum.general
+ * getUserMedia.failed.desktop.track.no_data_from_source
+ * getUserMedia.failed.gum.chrome_extension_generic_error
+ * getUserMedia.failed.gum.chrome_extension_installation_error
+ * getUserMedia.failed.gum.constraint_failed
+ * getUserMedia.failed.gum.firefox_extension_needed
+ * getUserMedia.failed.gum.general
+ * getUserMedia.failed.gum.permission_denied
+ * getUserMedia.failed.undefined
+ * getUserMedia.failed.video.360.gum.permission_denied
+ * getUserMedia.failed.video.720.TypeError
+ * getUserMedia.failed.video.720.gum.constraint_failed
+ * getUserMedia.failed.video.720.gum.general
+ * getUserMedia.failed.video.720.gum.permission_denied
+ * getUserMedia.failed.video.720.track.no_data_from_source
+ * getUserMedia.failed.video.undefined.TypeError
+ * getUserMedia.failed.video.undefined.gum.general
+ * getUserMedia.failed.video.undefined.track.no_data_from_source
+ *
+ * TODO: reformat
+ */
+export const GET_USER_MEDIA_FAILED_ = 'getUserMedia.failed';
+
+/**
+ * Properties: value
+ *
+ * Known full event names:
+ * getUserMedia.success
+ * getUserMedia.success.audio
+ * getUserMedia.success.audio.video.180
+ * getUserMedia.success.audio.video.300
+ * getUserMedia.success.audio.video.360
+ * getUserMedia.success.audio.video.720
+ * getUserMedia.success.audio.video.960
+ * getUserMedia.success.audio.video.undefined
+ * getUserMedia.success.desktop
+ * getUserMedia.success.video.180
+ * getUserMedia.success.video.360
+ * getUserMedia.success.video.720
+ * getUserMedia.success.video.960
+ * getUserMedia.success.video.undefined
+ *
+ * TODO: document, reformat
+ */
+export const GET_USER_MEDIA_SUCCESS_ = 'getUserMedia.success';
+
+/**
+ * Properties: none
+ *
+ * Known full event names:
+ * getUserMedia.userCancel.extensionInstall
+ *
+ * TODO: document, reformat
+ */
+export const GET_USER_MEDIA_USER_CANCEL_ = 'getUserMedia.userCancel';
+
+/**
+ * Properties: value
+ *
+ * The "value" property contains the difference in milliseconds between
+ * the ICE establishment time for the P2P and JVB connections (e.g. a value
+ * of 10 would indicate that the P2P was 10ms slower than JVB).
+ */
+export const ICE_ESTABLISHMENT_DURATION_DIFF
+    = 'ice.establishmentDurationDiff';
+
+/**
+ * Properties: none
+ *
+ * TODO: document
+ * TODO: do we need this in addition to _ICE_CONNECTION_STATE?
+ */
+export const ICE_FAILED = 'connection.ice_failed';
+
+/**
+ * Properties: none
+ *
+ * TODO: document
+ */
+export const P2P_ESTABLISHED = 'p2p.established';
+
+/**
+ * Properties: none
+ *
+ * TODO: document
+ */
+export const P2P_FAILED = 'p2p.failed';
+
+/**
+ * Properties: none
+ *
+ * TODO: document
+ */
+export const P2P_SWITCH_TO_JVB = 'p2p.switch_to_jvb';
+
+/**
+ * Properties: none
+ *
+ * TODO: document
+ */
+export const REMOTELY_MUTED = 'conference.remotelyMuted';
+
+/**
+ * Properties: value
+ *
+ * TODO: document
+ *
+ * The "value" property contains the delay in milliseconds between joining
+ * the MUC and receiving a Jingle session-initiate from Jicofo (but not
+ * P2P).
+ */
+export const SESSION_INITIATE = 'session.initiate';
+
+/**
+ * Properties: value
+ *
+ * TODO: document
+ */
+export const SESSION_INITIATE_RECEIVED = 'xmpp.session-initiate';
+
+/**
+ * Properties: none
+ *
+ * TODO: document
+ */
+export const SESSION_TERMINATE = 'session.terminate';
+
+/**
+ * Properties: none
+ *
+ * TODO: document
+ */
+export const SESSION_RESTART = 'session.restart';
+
+/**
+ * Properties: value
+ *
+ * TODO: document
+ */
+export const TRANSPORT_REPLACE_START = 'xmpp.transport-replace.start';
+
+/**
+ * Properties: value
+ *
+ * TODO: document
+ */
+export const TRANSPORT_REPLACE_SUCCESS = 'xmpp.transport-replace.success';