feat(es) migrate statistics/statistics to ES6 Class

JitsiConference.js

@@ -901,16 +901,6 @@ JitsiConference.prototype.getLocalVideoTracks = function() {
     return this.rtc ? this.rtc.getLocalVideoTracks() : null;
 };
 
-/**
- * Obtains the performance statistics.
- * @returns {Object|null}
- */
-JitsiConference.prototype.getPerformanceStats = function() {
-    return {
-        longTasksStats: this.statistics.getLongTasksStats()
-    };
-};
-
 /**
  * Attaches a handler for events(For example - "participant joined".) in the
  * conference. All possible event are defined in JitsiConferenceEvents.
@@ -3907,8 +3897,7 @@ JitsiConference.prototype._sendConferenceLeftAnalyticsEvent = function() {
         meetingId,
         participantId: `${meetingId}.${this._statsCurrentId}`,
         stats: {
-            duration: Math.floor((Date.now() - this._conferenceJoinAnalyticsEventSent) / 1000),
-            perf: this.getPerformanceStats()
+            duration: Math.floor((Date.now() - this._conferenceJoinAnalyticsEventSent) / 1000)
         }
     }));
 };

modules/statistics/statistics.js

@@ -13,368 +13,457 @@ import RTPStats from './RTPStatsCollector';
 const logger = require('@jitsi/logger').getLogger('modules/statistics/statistics');
 
 /**
- * Stores all active {@link Statistics} instances.
- * @type {Set<Statistics>}
+ * Statistics class provides various functionality related to collecting and reporting statistics.
  */
-let _instances;
+export default class Statistics {
 
-/**
- * Init statistic options
- * @param options
- */
-Statistics.init = function(options) {
-    Statistics.audioLevelsEnabled = !options.disableAudioLevels;
-    if (typeof options.pcStatsInterval === 'number') {
-        Statistics.pcStatsInterval = options.pcStatsInterval;
-    }
+    /**
+     * Stores all active Statistics instances.
+     * @type {Set<Statistics>}
+     */
+    static _instances;
 
-    if (typeof options.audioLevelsInterval === 'number') {
-        Statistics.audioLevelsInterval = options.audioLevelsInterval;
+    /**
+     * Static getter for instances property
+     * Returns the Set holding all active Statistics instances. Lazily
+     * initializes the Set to allow any Set polyfills to be applied.
+     * @type {Set<Statistics>}
+     */
+    static get instances() {
+        if (!Statistics._instances) {
+            Statistics._instances = new Set();
+        }
+
+        return Statistics._instances;
     }
 
-    Statistics.disableThirdPartyRequests = options.disableThirdPartyRequests;
+    /**
+     * Flag indicating whether audio levels are enabled or not.
+     * @static
+     * @type {boolean}
+     */
+    static audioLevelsEnabled = false;
 
-    LocalStats.init();
-    WatchRTC.init(options);
-};
+    /**
+     * The interval for audio levels stats collection.
+     * @static
+     * @type {number}
+     */
+    static audioLevelsInterval = 200;
 
-/**
- * The options to configure Statistics.
- * @typedef {Object} StatisticsOptions
- * @property {string} userName - The user name to use
- * @property {string} roomName - The room name we are currently in.
- *
- * @param {JitsiConference} conference - The conference instance from which the statistics were initialized.
- * @param {StatisticsOptions} options - The options to use creating the
- * Statistics.
- */
-export default function Statistics(conference, options) {
     /**
-     * {@link RTPStats} mapped by {@link TraceablePeerConnection.id} which
-     * collect RTP statistics for each peerconnection.
-     * @type {Map<string, RTPStats}
+     * The interval for peer connection stats collection.
+     * @static
+     * @type {number}
      */
-    this.rtpStatsMap = new Map();
-    this.eventEmitter = new EventEmitter();
-    this.conference = conference;
-    this.xmpp = conference?.xmpp;
-    this.options = options || {};
+    static pcStatsInterval = 10000;
 
-    Statistics.instances.add(this);
+    /**
+     * Flag indicating whether third party requests are disabled.
+     * @static
+     * @type {boolean}
+     */
+    static disableThirdPartyRequests = false;
 
-    RTCStats.attachToConference(this.conference);
+    /**
+     * Analytics adapter for sending events.
+     * @static
+     * @type {Object}
+     */
+    static analytics = analytics;
 
-    // WatchRTC is not required to work for react native
-    if (!browser.isReactNative()) {
-        WatchRTC.start(this.options.roomName, this.options.userName);
-    }
+    /**
+     * Array holding local statistics collectors.
+     * @static
+     * @type {Array}
+     */
+    static localStats = [];
 
-}
-Statistics.audioLevelsEnabled = false;
-Statistics.audioLevelsInterval = 200;
-Statistics.pcStatsInterval = 10000;
-Statistics.disableThirdPartyRequests = false;
-Statistics.analytics = analytics;
+    /**
+     * Local JID constant.
+     * @static
+     * @type {string}
+     */
+    static LOCAL_JID = require('../../service/statistics/constants').LOCAL_JID;
 
-Object.defineProperty(Statistics, 'instances', {
     /**
-     * Returns the Set holding all active {@link Statistics} instances. Lazily
-     * initializes the Set to allow any Set polyfills to be applied.
-     * @type {Set<Statistics>}
+     * Init statistic options
+     * @static
+     * @param {Object} options - The options to initialize statistics with
      */
-    get() {
-        if (!_instances) {
-            _instances = new Set();
+    static init(options) {
+        Statistics.audioLevelsEnabled = !options.disableAudioLevels;
+        if (typeof options.pcStatsInterval === 'number') {
+            Statistics.pcStatsInterval = options.pcStatsInterval;
         }
 
-        return _instances;
-    }
-});
+        if (typeof options.audioLevelsInterval === 'number') {
+            Statistics.audioLevelsInterval = options.audioLevelsInterval;
+        }
 
-/**
- * Starts collecting RTP stats for given peerconnection.
- * @param {TraceablePeerConnection} peerconnection
- */
-Statistics.prototype.startRemoteStats = function(peerconnection) {
-    this.stopRemoteStats(peerconnection);
-
-    try {
-        const rtpStats
-            = new RTPStats(
-                peerconnection,
-                Statistics.audioLevelsInterval,
-                Statistics.pcStatsInterval,
-                this.eventEmitter);
-
-        rtpStats.start(Statistics.audioLevelsEnabled);
-        this.rtpStatsMap.set(peerconnection.id, rtpStats);
-    } catch (e) {
-        logger.error(`Failed to start collecting remote statistics: ${e}`);
-    }
-};
+        if (typeof options.longTasksStatsInterval === 'number') {
+            Statistics.longTasksStatsInterval = options.longTasksStatsInterval;
+        }
 
-Statistics.localStats = [];
+        Statistics.disableThirdPartyRequests = options.disableThirdPartyRequests;
 
-Statistics.startLocalStats = function(track, callback) {
-    if (browser.isIosBrowser()) {
-        // On iOS browsers audio is lost if the audio input device is in use by another app
-        // https://bugs.webkit.org/show_bug.cgi?id=233473
-        // The culprit was using the AudioContext, so now we close the AudioContext during
-        // the track being muted, and re-instantiate it afterwards.
-        track.addEventListener(
-        JitsiTrackEvents.NO_DATA_FROM_SOURCE,
+        LocalStats.init();
+        WatchRTC.init(options);
+    }
 
-        /**
-         * Closes AudioContext on no audio data, and enables it on data received again.
-         *
-         * @param {boolean} value - Whether we receive audio data or not.
-         */
-        async value => {
-            if (value) {
-                for (const localStat of Statistics.localStats) {
-                    localStat.stop();
+    /**
+     * Starts collecting local statistics for a track.
+     * @static
+     * @param {JitsiTrack} track - The track to collect statistics for
+     * @param {Function} callback - The callback to invoke with audio levels
+     */
+    static startLocalStats(track, callback) {
+        if (browser.isIosBrowser()) {
+            // On iOS browsers audio is lost if the audio input device is in use by another app
+            // https://bugs.webkit.org/show_bug.cgi?id=233473
+            // The culprit was using the AudioContext, so now we close the AudioContext during
+            // the track being muted, and re-instantiate it afterwards.
+            track.addEventListener(
+            JitsiTrackEvents.NO_DATA_FROM_SOURCE,
+
+            /**
+             * Closes AudioContext on no audio data, and enables it on data received again.
+             *
+             * @param {boolean} value - Whether we receive audio data or not.
+             */
+            async value => {
+                if (value) {
+                    for (const localStat of Statistics.localStats) {
+                        localStat.stop();
+                    }
+
+                    await LocalStats.disconnectAudioContext();
+                } else {
+                    LocalStats.connectAudioContext();
+                    for (const localStat of Statistics.localStats) {
+                        localStat.start();
+                    }
                 }
+            });
+        }
 
-                await LocalStats.disconnectAudioContext();
-            } else {
-                LocalStats.connectAudioContext();
-                for (const localStat of Statistics.localStats) {
-                    localStat.start();
-                }
-            }
-        });
-    }
+        if (!Statistics.audioLevelsEnabled) {
+            return;
+        }
 
-    if (!Statistics.audioLevelsEnabled) {
-        return;
-    }
+        track.addEventListener(
+            JitsiTrackEvents.LOCAL_TRACK_STOPPED,
+            () => {
+                Statistics.stopLocalStats(track);
+            });
 
-    track.addEventListener(
-        JitsiTrackEvents.LOCAL_TRACK_STOPPED,
-        () => {
-            Statistics.stopLocalStats(track);
-        });
+        const stream = track.getOriginalStream();
+        const localStats = new LocalStats(stream, Statistics.audioLevelsInterval,
+            callback);
 
-    const stream = track.getOriginalStream();
-    const localStats = new LocalStats(stream, Statistics.audioLevelsInterval,
-        callback);
+        this.localStats.push(localStats);
+        localStats.start();
+    }
 
-    this.localStats.push(localStats);
-    localStats.start();
-};
+    /**
+     * Stops collecting local statistics for a track.
+     * @static
+     * @param {JitsiTrack} track - The track to stop collecting statistics for
+     */
+    static stopLocalStats(track) {
+        if (!Statistics.audioLevelsEnabled) {
+            return;
+        }
 
-Statistics.prototype.addAudioLevelListener = function(listener) {
-    if (!Statistics.audioLevelsEnabled) {
-        return;
-    }
-    this.eventEmitter.on(StatisticsEvents.AUDIO_LEVEL, listener);
-};
+        const stream = track.getOriginalStream();
 
-Statistics.prototype.removeAudioLevelListener = function(listener) {
-    if (!Statistics.audioLevelsEnabled) {
-        return;
+        for (let i = 0; i < Statistics.localStats.length; i++) {
+            if (Statistics.localStats[i].stream === stream) {
+                const localStats = Statistics.localStats.splice(i, 1);
+
+                localStats[0].stop();
+                break;
+            }
+        }
     }
-    this.eventEmitter.removeListener(StatisticsEvents.AUDIO_LEVEL, listener);
-};
 
-Statistics.prototype.addBeforeDisposedListener = function(listener) {
-    this.eventEmitter.on(StatisticsEvents.BEFORE_DISPOSED, listener);
-};
+    /**
+     * Sends event to analytics and logs a message to the logger/console.
+     * @static
+     * @param {string | Object} event - The event name, or an object which represents the entire event
+     * @param {Object} properties - Properties to attach to the event
+     */
+    static sendAnalyticsAndLog(event, properties = {}) {
+        if (!event) {
+            logger.warn('No event or event name given.');
 
-Statistics.prototype.removeBeforeDisposedListener = function(listener) {
-    this.eventEmitter.removeListener(
-        StatisticsEvents.BEFORE_DISPOSED, listener);
-};
+            return;
+        }
 
-Statistics.prototype.addConnectionStatsListener = function(listener) {
-    this.eventEmitter.on(StatisticsEvents.CONNECTION_STATS, listener);
-};
+        let eventToLog;
 
-Statistics.prototype.removeConnectionStatsListener = function(listener) {
-    this.eventEmitter.removeListener(
-        StatisticsEvents.CONNECTION_STATS,
-        listener);
-};
+        // Also support an API with a single object as an event.
+        if (typeof event === 'object') {
+            eventToLog = event;
+        } else {
+            eventToLog = {
+                name: event,
+                properties
+            };
+        }
 
-Statistics.prototype.addEncodeTimeStatsListener = function(listener) {
-    this.eventEmitter.on(StatisticsEvents.ENCODE_TIME_STATS, listener);
-};
+        logger.debug(JSON.stringify(eventToLog));
 
-Statistics.prototype.removeEncodeTimeStatsListener = function(listener) {
-    this.eventEmitter.removeListener(StatisticsEvents.ENCODE_TIME_STATS, listener);
-};
+        // We do this last, because it may modify the object which is passed.
+        this.analytics.sendEvent(event, properties);
+    }
 
-Statistics.prototype.addByteSentStatsListener = function(listener) {
-    this.eventEmitter.on(StatisticsEvents.BYTE_SENT_STATS, listener);
-};
+    /**
+     * Sends event to analytics.
+     * @static
+     * @param {string | Object} eventName - The event name, or an object which represents the entire event
+     * @param {Object} properties - Properties to attach to the event
+     */
+    static sendAnalytics(eventName, properties = {}) {
+        this.analytics.sendEvent(eventName, properties);
+    }
 
-Statistics.prototype.removeByteSentStatsListener = function(listener) {
-    this.eventEmitter.removeListener(StatisticsEvents.BYTE_SENT_STATS,
-        listener);
-};
+    /**
+     * The options to configure Statistics.
+     * @typedef {Object} StatisticsOptions
+     * @property {string} userName - The user name to use
+     * @property {string} roomName - The room name we are currently in.
+     *
+     * @param {JitsiConference} conference - The conference instance from which the statistics were initialized.
+     * @param {StatisticsOptions} options - The options to use creating the
+     * Statistics.
+     */
+    constructor(conference, options) {
+        /**
+         * {@link RTPStats} mapped by {@link TraceablePeerConnection.id} which
+         * collect RTP statistics for each peerconnection.
+         * @type {Map<string, RTPStats}
+         */
+        this.rtpStatsMap = new Map();
+        this.eventEmitter = new EventEmitter();
+        this.conference = conference;
+        this.xmpp = conference?.xmpp;
+        this.options = options || {};
 
-/**
- * Add a listener that would be notified on a LONG_TASKS_STATS event.
- *
- * @param {Function} listener a function that would be called when notified.
- * @returns {void}
- */
-Statistics.prototype.addLongTasksStatsListener = function(listener) {
-    this.eventEmitter.on(StatisticsEvents.LONG_TASKS_STATS, listener);
-};
+        Statistics.instances.add(this);
 
-/**
- * Obtains the current value of the LongTasks event statistics.
- *
- * @returns {Object|null} stats object if the observer has been
- * created, null otherwise.
- */
-Statistics.prototype.getLongTasksStats = function() {
-    return this.performanceObserverStats
-        ? this.performanceObserverStats.getLongTasksStats()
-        : null;
-};
+        RTCStats.attachToConference(this.conference);
 
-/**
- * Removes the given listener for the LONG_TASKS_STATS event.
- *
- * @param {Function} listener the listener we want to remove.
- * @returns {void}
- */
-Statistics.prototype.removeLongTasksStatsListener = function(listener) {
-    this.eventEmitter.removeListener(StatisticsEvents.LONG_TASKS_STATS, listener);
-};
-
-/**
- * Updates the list of speakers for which the audio levels are to be calculated. This is needed for the jvb pc only.
- *
- * @param {Array<string>} speakerList The list of remote endpoint ids.
- * @returns {void}
- */
-Statistics.prototype.setSpeakerList = function(speakerList) {
-    for (const rtpStats of Array.from(this.rtpStatsMap.values())) {
-        if (!rtpStats.peerconnection.isP2P) {
-            rtpStats.setSpeakerList(speakerList);
+        // WatchRTC is not required to work for react native
+        if (!browser.isReactNative()) {
+            WatchRTC.start(this.options.roomName, this.options.userName);
         }
     }
-};
 
-Statistics.prototype.dispose = function() {
-    try {
-        this.eventEmitter.emit(StatisticsEvents.BEFORE_DISPOSED);
+    /**
+     * Starts collecting RTP stats for given peerconnection.
+     * @param {TraceablePeerConnection} peerconnection
+     */
+    startRemoteStats(peerconnection) {
+        this.stopRemoteStats(peerconnection);
+
+        try {
+            const rtpStats
+                = new RTPStats(
+                    peerconnection,
+                    Statistics.audioLevelsInterval,
+                    Statistics.pcStatsInterval,
+                    this.eventEmitter);
+
+            rtpStats.start(Statistics.audioLevelsEnabled);
+            this.rtpStatsMap.set(peerconnection.id, rtpStats);
+        } catch (e) {
+            logger.error(`Failed to start collecting remote statistics: ${e}`);
+        }
+    }
 
-        for (const tpcId of this.rtpStatsMap.keys()) {
-            this._stopRemoteStats(tpcId);
+    /**
+     * Adds a listener for audio level events.
+     * @param {Function} listener - The listener to add
+     */
+    addAudioLevelListener(listener) {
+        if (!Statistics.audioLevelsEnabled) {
+            return;
         }
-        if (this.eventEmitter) {
-            this.eventEmitter.removeAllListeners();
+        this.eventEmitter.on(StatisticsEvents.AUDIO_LEVEL, listener);
+    }
+
+    /**
+     * Removes an audio level listener.
+     * @param {Function} listener - The listener to remove
+     */
+    removeAudioLevelListener(listener) {
+        if (!Statistics.audioLevelsEnabled) {
+            return;
         }
-    } finally {
-        Statistics.instances.delete(this);
+        this.eventEmitter.removeListener(StatisticsEvents.AUDIO_LEVEL, listener);
     }
-};
 
-Statistics.stopLocalStats = function(track) {
-    if (!Statistics.audioLevelsEnabled) {
-        return;
+    /**
+     * Adds a listener for before disposed events.
+     * @param {Function} listener - The listener to add
+     */
+    addBeforeDisposedListener(listener) {
+        this.eventEmitter.on(StatisticsEvents.BEFORE_DISPOSED, listener);
     }
 
-    const stream = track.getOriginalStream();
+    /**
+     * Removes a before disposed listener.
+     * @param {Function} listener - The listener to remove
+     */
+    removeBeforeDisposedListener(listener) {
+        this.eventEmitter.removeListener(
+            StatisticsEvents.BEFORE_DISPOSED, listener);
+    }
 
-    for (let i = 0; i < Statistics.localStats.length; i++) {
-        if (Statistics.localStats[i].stream === stream) {
-            const localStats = Statistics.localStats.splice(i, 1);
+    /**
+     * Adds a listener for connection stats events.
+     * @param {Function} listener - The listener to add
+     */
+    addConnectionStatsListener(listener) {
+        this.eventEmitter.on(StatisticsEvents.CONNECTION_STATS, listener);
+    }
 
-            localStats[0].stop();
-            break;
-        }
+    /**
+     * Removes a connection stats listener.
+     * @param {Function} listener - The listener to remove
+     */
+    removeConnectionStatsListener(listener) {
+        this.eventEmitter.removeListener(
+            StatisticsEvents.CONNECTION_STATS,
+            listener);
     }
-};
 
-/**
- * Stops remote RTP stats for given peerconnection ID.
- * @param {string} tpcId {@link TraceablePeerConnection.id}
- * @private
- */
-Statistics.prototype._stopRemoteStats = function(tpcId) {
-    const rtpStats = this.rtpStatsMap.get(tpcId);
+    /**
+     * Adds a listener for encode time stats events.
+     * @param {Function} listener - The listener to add
+     */
+    addEncodeTimeStatsListener(listener) {
+        this.eventEmitter.on(StatisticsEvents.ENCODE_TIME_STATS, listener);
+    }
 
-    if (rtpStats) {
-        rtpStats.stop();
-        this.rtpStatsMap.delete(tpcId);
+    /**
+     * Removes an encode time stats listener.
+     * @param {Function} listener - The listener to remove
+     */
+    removeEncodeTimeStatsListener(listener) {
+        this.eventEmitter.removeListener(StatisticsEvents.ENCODE_TIME_STATS, listener);
     }
-};
 
-/**
- * Stops collecting RTP stats for given peerconnection
- * @param {TraceablePeerConnection} tpc
- */
-Statistics.prototype.stopRemoteStats = function(tpc) {
-    this._stopRemoteStats(tpc.id);
-};
+    /**
+     * Adds a listener for byte sent stats events.
+     * @param {Function} listener - The listener to add
+     */
+    addByteSentStatsListener(listener) {
+        this.eventEmitter.on(StatisticsEvents.BYTE_SENT_STATS, listener);
+    }
 
-/**
- * Sends the given feedback
- *
- * @param overall an integer between 1 and 5 indicating the user's rating.
- * @param comment the comment from the user.
- * @returns {Promise} Resolves immediately.
- */
-Statistics.prototype.sendFeedback = function(overall, comment) {
-    // Statistics.analytics.sendEvent is currently fire and forget, without
-    // confirmation of successful send.
-    Statistics.analytics.sendEvent(
-        FEEDBACK,
-        {
-            rating: overall,
-            comment
-        });
+    /**
+     * Removes a byte sent stats listener.
+     * @param {Function} listener - The listener to remove
+     */
+    removeByteSentStatsListener(listener) {
+        this.eventEmitter.removeListener(StatisticsEvents.BYTE_SENT_STATS,
+            listener);
+    }
 
-    return Promise.resolve();
-};
+    /**
+     * Add a listener that would be notified on a LONG_TASKS_STATS event.
+     *
+     * @param {Function} listener a function that would be called when notified.
+     * @returns {void}
+     */
+    addLongTasksStatsListener(listener) {
+        this.eventEmitter.on(StatisticsEvents.LONG_TASKS_STATS, listener);
+    }
 
-Statistics.LOCAL_JID = require('../../service/statistics/constants').LOCAL_JID;
+    /**
+     * Removes the given listener for the LONG_TASKS_STATS event.
+     *
+     * @param {Function} listener the listener we want to remove.
+     * @returns {void}
+     */
+    removeLongTasksStatsListener(listener) {
+        this.eventEmitter.removeListener(StatisticsEvents.LONG_TASKS_STATS, listener);
+    }
 
-/**
- * Sends event to analytics and logs a message to the logger/console.
- *
- * @param {string | Object} event the event name, or an object which
- * represents the entire event.
- * @param {Object} properties properties to attach to the event (if an event
- * name as opposed to an event object is provided).
- */
-Statistics.sendAnalyticsAndLog = function(event, properties = {}) {
-    if (!event) {
-        logger.warn('No event or event name given.');
+    /**
+     * Updates the list of speakers for which the audio levels are to be calculated. This is needed for the jvb pc only.
+     *
+     * @param {Array<string>} speakerList The list of remote endpoint ids.
+     * @returns {void}
+     */
+    setSpeakerList(speakerList) {
+        for (const rtpStats of Array.from(this.rtpStatsMap.values())) {
+            if (!rtpStats.peerconnection.isP2P) {
+                rtpStats.setSpeakerList(speakerList);
+            }
+        }
+    }
 
-        return;
+    /**
+     * Disposes of this instance, stopping any ongoing stats collection.
+     */
+    dispose() {
+        try {
+            this.eventEmitter.emit(StatisticsEvents.BEFORE_DISPOSED);
+
+            for (const tpcId of this.rtpStatsMap.keys()) {
+                this._stopRemoteStats(tpcId);
+            }
+            if (this.eventEmitter) {
+                this.eventEmitter.removeAllListeners();
+            }
+        } finally {
+            Statistics.instances.delete(this);
+        }
     }
 
-    let eventToLog;
+    /**
+     * Stops remote RTP stats for given peerconnection ID.
+     * @param {string} tpcId {@link TraceablePeerConnection.id}
+     * @private
+     */
+    _stopRemoteStats(tpcId) {
+        const rtpStats = this.rtpStatsMap.get(tpcId);
 
-    // Also support an API with a single object as an event.
-    if (typeof event === 'object') {
-        eventToLog = event;
-    } else {
-        eventToLog = {
-            name: event,
-            properties
-        };
+        if (rtpStats) {
+            rtpStats.stop();
+            this.rtpStatsMap.delete(tpcId);
+        }
     }
 
-    logger.debug(JSON.stringify(eventToLog));
+    /**
+     * Stops collecting RTP stats for given peerconnection
+     * @param {TraceablePeerConnection} tpc
+     */
+    stopRemoteStats(tpc) {
+        this._stopRemoteStats(tpc.id);
+    }
 
-    // We do this last, because it may modify the object which is passed.
-    this.analytics.sendEvent(event, properties);
-};
+    /**
+     * Sends the given feedback
+     *
+     * @param {number} overall an integer between 1 and 5 indicating the user's rating.
+     * @param {string} comment the comment from the user.
+     * @returns {Promise} Resolves immediately.
+     */
+    sendFeedback(overall, comment) {
+        // Statistics.analytics.sendEvent is currently fire and forget, without
+        // confirmation of successful send.
+        Statistics.analytics.sendEvent(
+            FEEDBACK,
+            {
+                rating: overall,
+                comment
+            });
+
+        return Promise.resolve();
+    }
+}
 
-/**
- * Sends event to analytics.
- *
- * @param {string | Object} eventName the event name, or an object which
- * represents the entire event.
- * @param {Object} properties properties to attach to the event
- */
-Statistics.sendAnalytics = function(eventName, properties = {}) {
-    this.analytics.sendEvent(eventName, properties);
-};