feat(PerformanceObserverStats) remove it (#2809)

It hasn't been useful or used in years.

JitsiConference.js

         Statistics.analytics.addPermanentProperties({
             'callstats_name': this._statsCurrentId
         });
-
-        // Start performance observer for monitoring long tasks
-        if (config.longTasksStatsInterval) {
-            this.statistics.attachLongTasksStats();
-        }
     }
 
     this.eventManager.setupChatRoomListeners();

modules/statistics/PerformanceObserverStats.js

-
-import { getLogger } from '@jitsi/logger';
-
-import * as StatisticsEvents from '../../service/statistics/Events';
-import { RunningAverage } from '../util/MathUtil';
-
-const logger = getLogger('modules/statistics/PerformanceObserverStats');
-const MILLI_SECONDS = 1000;
-const SECONDS = 60;
-
-/**
- * This class creates an observer that monitors browser's performance measurement events
- * as they are recorded in the browser's performance timeline and computes an average and
- * a maximum value for the long task events. Tasks are classified as long tasks if they take
- * longer than 50ms to execute on the main thread.
- */
-export class PerformanceObserverStats {
-    /**
-     * Creates a new instance of Performance observer statistics.
-     *
-     * @param {*} emitter Event emitter for emitting stats periodically
-     * @param {*} statsInterval interval for calculating the stats
-     */
-    constructor(emitter, statsInterval) {
-        this.eventEmitter = emitter;
-        this.longTasks = 0;
-        this.maxDuration = 0;
-        this.performanceStatsInterval = statsInterval;
-        this.stats = new RunningAverage();
-    }
-
-    /**
-     * Obtains the average rate of long tasks observed per min and the
-     * duration of the longest task recorded by the observer.
-     * @returns {Object}
-     */
-    getLongTasksStats() {
-        return {
-            avgRatePerMinute: (this.stats.getAverage() * SECONDS).toFixed(2), // calc rate per min
-            maxDurationMs: this.maxDuration
-        };
-    }
-
-    /**
-     * Starts the performance observer by registering the callback function
-     * that calculates the performance statistics periodically.
-     * @returns {void}
-     */
-    startObserver() {
-        // Create a handler for when the long task event is fired.
-        this.longTaskEventHandler = list => {
-            const entries = list.getEntries();
-
-            for (const task of entries) {
-                this.longTasks++;
-                this.maxDuration = Math.max(this.maxDuration, task.duration).toFixed(3);
-            }
-        };
-
-        // Create an observer for monitoring long tasks.
-        logger.info('Creating a Performance Observer for monitoring Long Tasks');
-        this.observer = new PerformanceObserver(this.longTaskEventHandler);
-        this.observer.observe({ type: 'longtask',
-            buffered: true });
-        const startTime = Date.now();
-
-        // Calculate the average # of events/sec and emit a stats event.
-        this.longTasksIntervalId = setInterval(() => {
-            const now = Date.now();
-            const interval = this._lastTimeStamp
-                ? (now - this._lastTimeStamp) / MILLI_SECONDS
-                : (now - startTime) / MILLI_SECONDS;
-            const rate = this.longTasks / interval;
-
-            this.stats.addNext(rate);
-            this.eventEmitter.emit(
-                StatisticsEvents.LONG_TASKS_STATS, this.getLongTasksStats());
-
-            // Reset the counter and start counting events again.
-            this.longTasks = 0;
-            this._lastTimeStamp = Date.now();
-        }, this.performanceStatsInterval);
-    }
-
-    /**
-     * Stops the performance observer.
-     * @returns {void}
-     */
-    stopObserver() {
-        this.observer && this.observer.disconnect();
-        this.longTaskEventHandler = null;
-        if (this.longTasksIntervalId) {
-            clearInterval(this.longTasksIntervalId);
-            this.longTasksIntervalId = null;
-        }
-    }
-}

modules/statistics/PerformanceObserverStats.spec.js

-
-import * as JitsiConferenceEvents from '../../JitsiConferenceEvents';
-import browser from '../browser';
-import Listenable from '../util/Listenable';
-
-import Statistics from './statistics';
-
-/**
- * Mock object to be used in place of a real conference.
- *
- */
-class MockConference extends Listenable {
-    /**
-     * constructor
-     */
-    constructor() {
-        super();
-        this.options = {
-            config: {}
-        };
-    }
-}
-
-describe('PerformanceObserverStats', () => {
-    let mockConference, statistics;
-
-    beforeEach(() => {
-        // works only on chrome.
-        spyOn(browser, 'isChrome').and.returnValue(true);
-        mockConference = new MockConference();
-        Statistics.init({ longTasksStatsInterval: 1000 });
-        statistics = new Statistics(mockConference);
-        jasmine.clock().install();
-    });
-
-    it('Conference events start/stop observer', () => {
-        statistics.attachLongTasksStats(mockConference);
-        const startObserverSpy = spyOn(statistics.performanceObserverStats, 'startObserver');
-        const stopObserverSpy = spyOn(statistics.performanceObserverStats, 'stopObserver');
-
-        mockConference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_JOINED);
-        expect(startObserverSpy).toHaveBeenCalled();
-
-        mockConference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_LEFT);
-        expect(stopObserverSpy).toHaveBeenCalled();
-    });
-
-    it('Emits long tasks stats every sec', () => {
-        statistics.attachLongTasksStats(mockConference);
-        statistics.performanceObserverStats.eventEmitter = {
-            // eslint-disable-next-line no-empty-function
-            emit: () => {}
-        };
-        statistics.performanceObserverStats.startObserver();
-        const eventEmitSpy = spyOn(statistics.performanceObserverStats.eventEmitter, 'emit');
-
-        expect(statistics.performanceObserverStats.getLongTasksStats()).toBeTruthy();
-        expect(eventEmitSpy).not.toHaveBeenCalled();
-
-        jasmine.clock().tick(1000);
-        expect(eventEmitSpy).toHaveBeenCalled();
-    });
-
-    afterEach(() => {
-        jasmine.clock().uninstall();
-    });
-});

modules/statistics/statistics.js

-import * as JitsiConferenceEvents from '../../JitsiConferenceEvents';
 import { JitsiTrackEvents } from '../../JitsiTrackEvents';
 import { FEEDBACK } from '../../service/statistics/AnalyticsEvents';
 import * as StatisticsEvents from '../../service/statistics/Events';
 
 import analytics from './AnalyticsAdapter';
 import LocalStats from './LocalStatsCollector';
-import { PerformanceObserverStats } from './PerformanceObserverStats';
 import RTPStats from './RTPStatsCollector';
 
 const logger = require('@jitsi/logger').getLogger('modules/statistics/statistics');
         Statistics.audioLevelsInterval = options.audioLevelsInterval;
     }
 
-    if (typeof options.longTasksStatsInterval === 'number') {
-        Statistics.longTasksStatsInterval = options.longTasksStatsInterval;
-    }
-
     Statistics.disableThirdPartyRequests = options.disableThirdPartyRequests;
 
     LocalStats.init();
     this.eventEmitter.on(StatisticsEvents.LONG_TASKS_STATS, listener);
 };
 
-/**
- * Creates an instance of {@link PerformanceObserverStats} and starts the
- * observer that records the stats periodically.
- *
- * @returns {void}
- */
-Statistics.prototype.attachLongTasksStats = function() {
-    if (!browser.supportsPerformanceObserver()) {
-        logger.warn('Performance observer for long tasks not supported by browser!');
-
-        return;
-    }
-
-    this.performanceObserverStats = new PerformanceObserverStats(
-        this.eventEmitter,
-        Statistics.longTasksStatsInterval);
-
-    this.conference.on(
-        JitsiConferenceEvents.CONFERENCE_JOINED,
-        () => this.performanceObserverStats.startObserver());
-    this.conference.on(
-        JitsiConferenceEvents.CONFERENCE_LEFT,
-        () => this.performanceObserverStats.stopObserver());
-};
-
 /**
  * Obtains the current value of the LongTasks event statistics.
  *

types/hand-crafted/modules/statistics/PerformanceObserverStats.d.ts

-export class PerformanceObserverStats {
-  constructor( emitter: unknown, statsInterval: unknown ); // TODO:
-  getLongTasksStats: () => unknown; // TODO:
-  startObserver: () => void;
-  stopObserver: () => void;
-}