jvc0/react/features/rtcstats/RTCStats.ts

// @ts-ignore
import { PC_CON_STATE_CHANGE,
    PC_STATE_CONNECTED,
    PC_STATE_FAILED

    // @ts-ignore
} from '@jitsi/rtcstats/events';
// eslint-disable-next-line lines-around-comment
// @ts-ignore
import rtcstatsInit from '@jitsi/rtcstats/rtcstats';
// eslint-disable-next-line lines-around-comment
// @ts-ignore
import traceInit from '@jitsi/rtcstats/trace-ws';


import { createRTCStatsTraceCloseEvent } from '../analytics/AnalyticsEvents';
import { sendAnalytics } from '../analytics/functions';

import logger from './logger';
import {
    DominantSpeakerData,
    E2ERTTData,
    FaceLandmarksData,
    InitOptions,
    VideoTypeData
} from './types';

/**
 * Filter out RTCPeerConnection that are created by callstats.io.
 *
 * @param {*} config - Config object sent to the PC c'tor.
 * @returns {boolean}
 */
function connectionFilter(config: any) {
    if (config?.iceServers[0] && config.iceServers[0].urls) {
        for (const iceUrl of config.iceServers[0].urls) {
            if (iceUrl.indexOf('callstats.io') >= 0) {
                return true;
            }
        }
    }
}

/**
 * Class that controls the rtcstats flow, because it overwrites and proxies global function it should only be
 * initialized once.
 */
class RTCStats {
    trace: any;
    options?: InitOptions;
    isPeerConnectionWrapped = false;
    connStateEvents: any = [];

    /**
     * Initialize the rtcstats components, if the options have changed.
     *
     * @param {Oject} newOptions -.
     * @returns {void}
     */
    maybeInit(newOptions: InitOptions) {
        const oldOptions = this.options;
        const changed = !oldOptions || (oldOptions.endpoint !== newOptions.endpoint
            || oldOptions.meetingFqn !== newOptions.meetingFqn
            || oldOptions.pollInterval !== newOptions.pollInterval
            || oldOptions.sendSdp !== newOptions.sendSdp
            || oldOptions.useLegacy !== newOptions.useLegacy);

        if (changed) {
            this.reset();

            if (newOptions.meetingFqn && newOptions.endpoint) {
                this.init(newOptions);
            } else {
                logger.warn('RTCStats is enabled but it has not been configured.');
            }
        }
    }

    /**
     * Wrapper method for the underlying trace object to be used as a static reference from inside the wrapped
     * PeerConnection.
     *
     * @param {any[]} data - The stats entry to send to the rtcstats endpoint.
     * @returns {void}
     */
    statsEntry(...data: any[]) {
        this.trace?.statsEntry(data);
    }

    /**
     * Initialize the rtcstats components. First off we initialize the trace, which is a wrapped websocket
     * that does the actual communication with the server. Secondly, the rtcstats component is initialized,
     * it overwrites GUM and PeerConnection global functions and adds a proxy over them used to capture stats.
     * Note, lib-jitsi-meet takes references to these methods before initializing so the init method needs to be
     * loaded before it does.
     *
     * @param {Object} options -.
     * @param {string} options.endpoint - The Amplitude app key required.
     * @param {string} options.meetingFqn - The meeting fqn.
     * @param {boolean} options.useLegacy - Switch to legacy chrome webrtc statistics. Parameter will only have
     * an effect on chrome based applications.
     * @param {number} options.pollInterval - The getstats poll interval in ms.
     * @param {boolean} options.sendSdp - Determines if the client sends SDP to the rtcstats server.
     * @returns {void}
     */
    init(options: InitOptions) {

        const { endpoint, meetingFqn, useLegacy, pollInterval, sendSdp } = options;

        const traceOptions = {
            endpoint,
            meetingFqn,
            onCloseCallback: this.handleTraceWSClose.bind(this),
            useLegacy
        };

        this.trace = traceInit(traceOptions);
        if (!this.isPeerConnectionWrapped) {
            const rtcstatsOptions = {
                connectionFilter,
                pollInterval,
                useLegacy,
                sendSdp,
                eventCallback: this.handleRtcstatsEvent.bind(this)
            };

            const statsEntryCallback = { statsEntry: this.statsEntry.bind(this) };

            rtcstatsInit(statsEntryCallback, rtcstatsOptions);
            this.isPeerConnectionWrapped = true;
        }
        this.options = options;
    }

    /**
     * Check whether or not the RTCStats is initialized.
     *
     * @returns {boolean}
     */
    isInitialized() {
        return this.options !== undefined;
    }

    /**
     * Resets the rtcstats.
     *
     * @returns {void}
     */
    reset() {
        delete this.options;

        if (this.trace) {
            this.trace.close();
            delete this.trace;
        }
    }

    /**
     * Send identity data to rtcstats server, this will be reflected in the identity section of the stats dump.
     * It can be generally used to send additional metadata that might be relevant such as amplitude user data
     * or deployment specific information.
     *
     * @param {any} identityData - Metadata object to send as identity.
     * @returns {void}
     */
    sendIdentityData(identityData: any) {
        this.trace?.identity('identity', null, identityData);
    }

    /**
     * Send console logs to rtcstats server.
     *
     * @param {Array<string|any>} logEntries - The log entries to send to the rtcstats server.
     * @returns {void}
     */
    sendLogs(logEntries: Array<string | any>) {
        this.trace?.statsEntry('logs', null, logEntries);
    }

    /**
     * Send dominant speaker data, the data will be processed by rtcstats-server and saved in the dump file.
     *
     * @param {Object} dominantSpeakerData - Dominant speaker data to be saved in the rtcstats dump.
     * @returns {void}
     */
    sendDominantSpeakerData(dominantSpeakerData: DominantSpeakerData) {
        this.trace?.statsEntry('dominantSpeaker', null, dominantSpeakerData);
    }

    /**
     * Send e2e rtt data, the data will be processed by rtcstats-server and saved in the dump file.
     *
     * @param {Object} e2eRttData - The object that holds the e2e data.
     * @returns {void}
     */
    sendE2eRttData(e2eRttData: E2ERTTData) {
        this.trace?.statsEntry('e2eRtt', null, e2eRttData);
    }

    /**
     * Send the timestamp of the start of the conference, the data will be processed by the rtcstats-server
     * and saved in the dump file.
     *
     * @param {Object} timestamp - The object which contains the timestamp.
     * @returns {void}
     */
    sendConferenceTimestamp(timestamp: number) {
        this.trace?.statsEntry('conferenceStartTimestamp', null, timestamp);
    }

    /**
     * Send videoType data, the data will be processed by rtcstats-server and saved in the dump file.
     *
     * @param {Object} videoTypeData - The object that holds the videoType data.
     * @returns {void}
     */
    sendVideoTypeData(videoTypeData: VideoTypeData) {
        this.trace?.statsEntry('setVideoType', null, videoTypeData);
    }

    /**
     * Send face landmarks data, the data will be processed by rtcstats-server and saved in the dump file.
     *
     * @param {Object} faceLandmarksData - Face landmarks data to be saved in the rtcstats dump.
     * @returns {void}
     */
    sendFaceLandmarksData(faceLandmarksData: FaceLandmarksData) {
        this.trace?.statsEntry('faceLandmarks', null, faceLandmarksData);
    }

    /**
     * Connect to the rtcstats server instance. Stats (data obtained from getstats) won't be send until the
     * connect successfully initializes, however calls to GUM are recorded in an internal buffer even if not
     * connected and sent once it is established.
     *
     * @param {boolean} isBreakoutRoom - Flag indicating if the user is in a breakout room.
     * @returns {void}
     */
    connect(isBreakoutRoom: boolean) {
        this.trace?.connect(isBreakoutRoom);
    }

    /**
     * Self explanatory; closes the web socked connection.
     * Note, at the point of writing this documentation there was no method to reset the function overwrites,
     * thus even if the websocket is closed the global function proxies are still active but send no data,
     * this shouldn't influence the normal flow of the application.
     *
     * @returns {void}
     */
    close() {
        this.trace?.close();
    }

    /**
     * RTCStats client can notify the APP of any PeerConnection related event that occurs.
     *
     * @param {Object} event - Rtcstats event.
     * @returns {void}
     */
    handleRtcstatsEvent(event: any) {
        switch (event.type) {
        case PC_CON_STATE_CHANGE: {
            const { body: { isP2P, state } = { state: null,
                isP2P: null } } = event;

            this.connStateEvents.push(event.body);

            // We only report PC related connection issues. If the rtcstats websocket is not connected at this point
            // it usually means that none of our services can be reached i.e. there's problem with the internet
            // connection and not necessarily with reaching the JVB (due to a firewall or other reasons).
            if (state === PC_STATE_FAILED && this.trace.isConnected()) {
                const connectionType = isP2P ? 'P2P' : 'JVB';
                const wasConnected = this.connStateEvents.some((connectionEvent: { isP2P: any; state: string; }) =>
                    (connectionEvent.isP2P === isP2P) && (connectionEvent.state === PC_STATE_CONNECTED));

                logger.info(`${connectionType} PeerConnection failed, previously connected: ${wasConnected}`);

                if (typeof APP !== 'undefined') {
                    APP.API.notifyPeerConnectionFailure(isP2P, wasConnected);
                }
            }

            break;
        }
        }
    }

    /**
     * The way rtcstats is currently designed the ws wouldn't normally be closed by the application logic but rather
     * by the page being closed/reloaded. Using this assumption any onclose event is most likely something abnormal
     * that happened on the ws. We then track this in order to determine how many rtcstats connection were closed
     * prematurely.
     *
     * @param {Object} closeEvent - Event sent by ws onclose.
     * @returns {void}
     */
    handleTraceWSClose(closeEvent: any) {
        logger.info('RTCStats trace ws closed', closeEvent);

        sendAnalytics(createRTCStatsTraceCloseEvent(closeEvent));
    }
}

export default new RTCStats();