@observertc/observer-js 0.9.27-beta → 0.30.0-e12fcb4.0

package/lib/Observer.js

@@ -8,68 +8,21 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
-var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
-var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
-    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
-    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
-    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
-    function fulfill(value) { resume("next", value); }
-    function reject(value) { resume("throw", value); }
-    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Observer = void 0;
-const ObserverSink_1 = require("./sinks/ObserverSink");
-const Sources_1 = require("./sources/Sources");
-const StorageProvider_1 = require("./storages/StorageProvider");
-const Evaluator_1 = require("./Evaluator");
-const Semaphore_1 = require("./common/Semaphore");
-const utils_1 = require("./common/utils");
 const logger_1 = require("./common/logger");
+const StorageProvider_1 = require("./storages/StorageProvider");
+const ObservedCall_1 = require("./ObservedCall");
+const ReportsCollector_1 = require("./ReportsCollector");
 const events_1 = require("events");
-const CallEntry_1 = require("./entries/CallEntry");
-const ClientEntry_1 = require("./entries/ClientEntry");
-const PeerConnectionEntry_1 = require("./entries/PeerConnectionEntry");
-const InboundTrackEntry_1 = require("./entries/InboundTrackEntry");
-const OutboundTrackEntry_1 = require("./entries/OutboundTrackEntry");
-const SfuEntry_1 = require("./entries/SfuEntry");
-const SfuTransportEntry_1 = require("./entries/SfuTransportEntry");
-const SfuInboundRtpPadEntry_1 = require("./entries/SfuInboundRtpPadEntry");
-const SfuOutboundRtpPadEntry_1 = require("./entries/SfuOutboundRtpPadEntry");
-const SfuSctpChannelEntry_1 = require("./entries/SfuSctpChannelEntry");
-const SetClientsCoordinateEvaluator_1 = require("./evaluators/SetClientsCoordinateEvaluator");
+const callEventReports_1 = require("./common/callEventReports");
 const logger = (0, logger_1.createLogger)('Observer');
-class Observer {
+class Observer extends events_1.EventEmitter {
     static create(providedConfig) {
-        var _a, _b;
+        var _a;
         const config = Object.assign({
             defaultServiceId: 'default-service-id',
             defaultMediaUnitId: 'default-media-unit-id',
-            sources: {
-                maxSamples: 1000,
-                maxTimeInMs: 10000,
-            },
             evaluator: {
                 fetchSamples: true,
                 maxIdleTimeInMs: 300 * 1000,
@@ -77,566 +30,49 @@ class Observer {
             sink: {},
             logLevel: 'info',
         }, providedConfig);
-        const semaphores = (_a = providedConfig.semaphores) !== null && _a !== void 0 ? _a : (0, Semaphore_1.createSimpleSemaphoreProvider)();
-        const storages = (_b = providedConfig.storages) !== null && _b !== void 0 ? _b : (0, StorageProvider_1.createSimpleStorageProvider)();
-        return new Observer(config, storages, semaphores);
+        const storages = (_a = providedConfig.storages) !== null && _a !== void 0 ? _a : (0, StorageProvider_1.createSimpleStorageProvider)();
+        return new Observer(config, storages);
     }
-    constructor(config, _storages, _semaphores) {
+    constructor(config, storage) {
+        super();
         this.config = config;
-        this._storages = _storages;
-        this._semaphores = _semaphores;
-        this._emitter = new events_1.EventEmitter();
+        this.storage = storage;
+        this.reports = new ReportsCollector_1.ReportsCollector();
+        this._observedCalls = new Map();
         this._closed = false;
-        this._sources = new Sources_1.Sources(config.sources);
-        this._sink = new ObserverSink_1.SinkImpl(config.sink);
-        this._evaluator = new Evaluator_1.Evaluator(this.config.evaluator, this._semaphores.callSemaphore, this._storages, this._sink);
-        this._sources.on('observed-samples', (event) => {
-            this._emitter.emit('processing-started');
-            this._evaluator.addObservedSamples(event);
-        });
-        this._sources.on('added-client-source', (event) => {
-            this._evaluator.addCreatedClientSource(event);
-            this._emitter.emit('client-added', event.clientId);
-        });
-        this._sources.on('removed-client-source', (event) => {
-            this._evaluator.addClosedClientSource(event);
-            this._emitter.emit('client-added', event.clientId);
-        });
-        this._evaluator.on('ready', () => {
-            this._sink.emit();
-            this._emitter.emit('processing-ended');
-        });
         logger.debug('Observer is created with config', this.config);
+        const onNewReport = (collectedReports) => {
+            if (!this.config.maxReports || this._closed)
+                return;
+            if (this.config.maxReports < collectedReports) {
+                this._emitReports();
+            }
+        };
+        this.once('close', () => this.reports.off('newreport', onNewReport));
+        this.reports.on('newreport', onNewReport);
     }
-    get sources() {
-        return this._sources;
-    }
-    on(event, listener) {
-        this._emitter.on(event, listener);
-        return this;
-    }
-    once(event, listener) {
-        this._emitter.once(event, listener);
-        return this;
-    }
-    off(event, listener) {
-        this._emitter.off(event, listener);
-        return this;
-    }
-    createCallSource(config) {
-        if (this._closed) {
-            throw new Error('Attempted to create a call source on a closed observer');
-        }
-        const { serviceId = this.config.defaultServiceId, mediaUnitId = this.config.defaultMediaUnitId, appData = {} } = config, callConfig = __rest(config, ["serviceId", "mediaUnitId", "appData"]);
-        return this._sources.createCallSource(Object.assign(Object.assign({}, callConfig), { appData,
-            mediaUnitId,
-            serviceId }));
-    }
-    createSfuSource(config) {
-        if (this._closed) {
-            throw new Error('Attempted to create a sfu source on a closed observer');
-        }
-        const { appData = {}, serviceId = this.config.defaultServiceId, mediaUnitId = this.config.defaultMediaUnitId, joined = Date.now() } = config, sfuConfig = __rest(config, ["appData", "serviceId", "mediaUnitId", "joined"]);
-        return this._sources.createSfuSource(Object.assign(Object.assign({}, sfuConfig), { appData,
-            serviceId,
-            mediaUnitId,
-            joined }));
-    }
-    evaluate() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                this._evaluator.once('ready', (err) => {
-                    if (err)
-                        reject(err);
-                    else
-                        resolve();
-                });
-                this._sources.emitSamples();
-            });
-        });
-    }
-    get reports() {
-        return this._sink;
-    }
-    addEvaluators(...processes) {
-        if (this._closed) {
-            throw new Error('Attempted to add an evaluator to a closed observer');
-        }
-        for (const process of processes) {
-            this._evaluator.addProcess(process);
-        }
-    }
-    removeEvaluators(...processes) {
-        if (this._closed) {
-            throw new Error('Attempted to remove an evaluator from a closed observer');
-        }
-        for (const process of processes) {
-            this._evaluator.removeProcess(process);
-        }
-    }
-    addCoordinateEvaluator(getClientCoordinate) {
-        if (this._closed) {
-            throw new Error('Attempted to add an evaluator to a closed observer');
-        }
-        const process = (0, SetClientsCoordinateEvaluator_1.createSetClientsCoordinateEvaluator)(getClientCoordinate);
-        this._evaluator.addProcess((context) => __awaiter(this, void 0, void 0, function* () { return process(context); }));
-    }
-    addSinks(...processes) {
-        if (this._closed) {
-            throw new Error('Attempted to add an evaluator to a closed observer');
-        }
-        for (const process of processes) {
-            this._sink.addProcess(process);
-        }
-    }
-    removeSinks(...processes) {
-        if (this._closed) {
-            throw new Error('Attempted to remove an evaluator from a closed observer');
-        }
-        for (const process of processes) {
-            this._sink.removeProcess(process);
-        }
-    }
-    calls() {
-        const storageProvider = this._storages;
-        return (0, utils_1.asyncIteratorConverter)((function () {
-            return __asyncGenerator(this, arguments, function* () {
-                var _a, e_1, _b, _c;
-                try {
-                    for (var _d = true, _e = __asyncValues(storageProvider.callStorage[Symbol.asyncIterator]()), _f; _f = yield __await(_e.next()), _a = _f.done, !_a;) {
-                        _c = _f.value;
-                        _d = false;
-                        try {
-                            const [, callModel] = _c;
-                            if (!callModel)
-                                continue;
-                            yield yield __await((0, CallEntry_1.createCallEntry)(storageProvider, callModel));
-                        }
-                        finally {
-                            _d = true;
-                        }
-                    }
-                }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                }
-            });
-        })());
-    }
-    sfus() {
-        const storageProvider = this._storages;
-        return (0, utils_1.asyncIteratorConverter)((function () {
-            return __asyncGenerator(this, arguments, function* () {
-                var _a, e_2, _b, _c;
-                try {
-                    for (var _d = true, _e = __asyncValues(storageProvider.sfuStorage[Symbol.asyncIterator]()), _f; _f = yield __await(_e.next()), _a = _f.done, !_a;) {
-                        _c = _f.value;
-                        _d = false;
-                        try {
-                            const [, sfuModel] = _c;
-                            if (!sfuModel)
-                                continue;
-                            yield yield __await((0, SfuEntry_1.createSfuEntry)(storageProvider, sfuModel));
-                        }
-                        finally {
-                            _d = true;
-                        }
-                    }
-                }
-                catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                finally {
-                    try {
-                        if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
-                    }
-                    finally { if (e_2) throw e_2.error; }
-                }
-            });
-        })());
-    }
-    sfuTransports() {
-        const storageProvider = this._storages;
-        return (0, utils_1.asyncIteratorConverter)((function () {
-            return __asyncGenerator(this, arguments, function* () {
-                var _a, e_3, _b, _c;
-                try {
-                    for (var _d = true, _e = __asyncValues(storageProvider.sfuTransportStorage[Symbol.asyncIterator]()), _f; _f = yield __await(_e.next()), _a = _f.done, !_a;) {
-                        _c = _f.value;
-                        _d = false;
-                        try {
-                            const [, sfuTransportModel] = _c;
-                            if (!sfuTransportModel)
-                                continue;
-                            yield yield __await((0, SfuTransportEntry_1.createSfuTransportEntry)(storageProvider, sfuTransportModel));
-                        }
-                        finally {
-                            _d = true;
-                        }
-                    }
-                }
-                catch (e_3_1) { e_3 = { error: e_3_1 }; }
-                finally {
-                    try {
-                        if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
-                    }
-                    finally { if (e_3) throw e_3.error; }
-                }
-            });
-        })());
-    }
-    sfuInboundRtpPads() {
-        const storageProvider = this._storages;
-        return (0, utils_1.asyncIteratorConverter)((function () {
-            return __asyncGenerator(this, arguments, function* () {
-                var _a, e_4, _b, _c;
-                try {
-                    for (var _d = true, _e = __asyncValues(storageProvider.sfuInboundRtpPadStorage[Symbol.asyncIterator]()), _f; _f = yield __await(_e.next()), _a = _f.done, !_a;) {
-                        _c = _f.value;
-                        _d = false;
-                        try {
-                            const [, sfuInboundRtpPadModel] = _c;
-                            if (!sfuInboundRtpPadModel)
-                                continue;
-                            yield yield __await((0, SfuInboundRtpPadEntry_1.createSfuInboundRtpPadEntry)(storageProvider, sfuInboundRtpPadModel));
-                        }
-                        finally {
-                            _d = true;
-                        }
-                    }
-                }
-                catch (e_4_1) { e_4 = { error: e_4_1 }; }
-                finally {
-                    try {
-                        if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
-                    }
-                    finally { if (e_4) throw e_4.error; }
-                }
-            });
-        })());
-    }
-    sfuOutboundRtpPads() {
-        const storageProvider = this._storages;
-        return (0, utils_1.asyncIteratorConverter)((function () {
-            return __asyncGenerator(this, arguments, function* () {
-                var _a, e_5, _b, _c;
-                try {
-                    for (var _d = true, _e = __asyncValues(storageProvider.sfuOutboundRtpPadStorage[Symbol.asyncIterator]()), _f; _f = yield __await(_e.next()), _a = _f.done, !_a;) {
-                        _c = _f.value;
-                        _d = false;
-                        try {
-                            const [, sfuOutboundRtpPadModel] = _c;
-                            if (!sfuOutboundRtpPadModel)
-                                continue;
-                            yield yield __await((0, SfuOutboundRtpPadEntry_1.createSfuOutboundRtpPadEntry)(storageProvider, sfuOutboundRtpPadModel));
-                        }
-                        finally {
-                            _d = true;
-                        }
-                    }
-                }
-                catch (e_5_1) { e_5 = { error: e_5_1 }; }
-                finally {
-                    try {
-                        if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
-                    }
-                    finally { if (e_5) throw e_5.error; }
-                }
-            });
-        })());
-    }
-    clients() {
-        const storageProvider = this._storages;
-        return (0, utils_1.asyncIteratorConverter)((function () {
-            return __asyncGenerator(this, arguments, function* () {
-                var _a, e_6, _b, _c;
-                try {
-                    for (var _d = true, _e = __asyncValues(storageProvider.clientStorage[Symbol.asyncIterator]()), _f; _f = yield __await(_e.next()), _a = _f.done, !_a;) {
-                        _c = _f.value;
-                        _d = false;
-                        try {
-                            const [, callModel] = _c;
-                            if (!callModel)
-                                continue;
-                            yield yield __await((0, ClientEntry_1.createClientEntry)(storageProvider, callModel));
-                        }
-                        finally {
-                            _d = true;
-                        }
-                    }
-                }
-                catch (e_6_1) { e_6 = { error: e_6_1 }; }
-                finally {
-                    try {
-                        if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
-                    }
-                    finally { if (e_6) throw e_6.error; }
-                }
-            });
-        })());
-    }
-    peerConnections() {
-        const storageProvider = this._storages;
-        return (0, utils_1.asyncIteratorConverter)((function () {
-            return __asyncGenerator(this, arguments, function* () {
-                var _a, e_7, _b, _c;
-                try {
-                    for (var _d = true, _e = __asyncValues(storageProvider.peerConnectionStorage[Symbol.asyncIterator]()), _f; _f = yield __await(_e.next()), _a = _f.done, !_a;) {
-                        _c = _f.value;
-                        _d = false;
-                        try {
-                            const [, peerConnectionModel] = _c;
-                            if (!peerConnectionModel)
-                                continue;
-                            yield yield __await((0, PeerConnectionEntry_1.createPeerConnectionEntry)(storageProvider, peerConnectionModel));
-                        }
-                        finally {
-                            _d = true;
-                        }
-                    }
-                }
-                catch (e_7_1) { e_7 = { error: e_7_1 }; }
-                finally {
-                    try {
-                        if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
-                    }
-                    finally { if (e_7) throw e_7.error; }
-                }
-            });
-        })());
-    }
-    getTrack(trackId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { inboundTrackStorage, outboundTrackStorage } = this._storages;
-            const [inbTrackModel, outbTrackModel] = yield Promise.all([
-                inboundTrackStorage.get(trackId),
-                outboundTrackStorage.get(trackId),
-            ]);
-            if (inbTrackModel)
-                return (0, InboundTrackEntry_1.createInboundTrackEntry)(this._storages, inbTrackModel);
-            else if (outbTrackModel)
-                return (0, OutboundTrackEntry_1.createOutboundTrackEntry)(this._storages, outbTrackModel);
-        });
-    }
-    getAllTracks(trackIds) {
+    createObservedCall(config) {
         return __awaiter(this, void 0, void 0, function* () {
-            const storageProvider = this._storages;
-            const { inboundTrackStorage, outboundTrackStorage } = this._storages;
-            const [inbTrackModels, outbTrackModels] = yield Promise.all([
-                inboundTrackStorage.getAll(trackIds),
-                outboundTrackStorage.getAll(trackIds),
-            ]);
-            const result = new Map();
-            for (const [trackId, model] of inbTrackModels) {
-                result.set(trackId, (0, InboundTrackEntry_1.createInboundTrackEntry)(storageProvider, model));
-            }
-            for (const [trackId, model] of outbTrackModels) {
-                result.set(trackId, (0, OutboundTrackEntry_1.createOutboundTrackEntry)(storageProvider, model));
+            if (this._closed) {
+                throw new Error('Attempted to create a call source on a closed observer');
             }
-            return result;
-        });
-    }
-    inboundTracks() {
-        const storageProvider = this._storages;
-        return (0, utils_1.asyncIteratorConverter)((function () {
-            return __asyncGenerator(this, arguments, function* () {
-                var _a, e_8, _b, _c;
-                try {
-                    for (var _d = true, _e = __asyncValues(storageProvider.inboundTrackStorage[Symbol.asyncIterator]()), _f; _f = yield __await(_e.next()), _a = _f.done, !_a;) {
-                        _c = _f.value;
-                        _d = false;
-                        try {
-                            const [, inboundTrackModel] = _c;
-                            if (!inboundTrackModel)
-                                continue;
-                            yield yield __await((0, InboundTrackEntry_1.createInboundTrackEntry)(storageProvider, inboundTrackModel));
-                        }
-                        finally {
-                            _d = true;
-                        }
-                    }
-                }
-                catch (e_8_1) { e_8 = { error: e_8_1 }; }
-                finally {
-                    try {
-                        if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
-                    }
-                    finally { if (e_8) throw e_8.error; }
-                }
+            const call = yield ObservedCall_1.ObservedCall.create(Object.assign({ serviceId: this.config.defaultServiceId, started: Date.now() }, config), this);
+            if (this._closed)
+                throw new Error('Cannot create an observed call on a closed observer');
+            if (this._observedCalls.has(call.callId))
+                throw new Error(`Observed Call with id ${call.callId} already exists`);
+            call.once('close', () => {
+                this._observedCalls.delete(call.callId);
+                this.reports.addCallEventReport((0, callEventReports_1.createCallStartedEventReport)(call.serviceId, call.roomId, call.callId, Date.now()));
             });
-        })());
-    }
-    outboundTracks() {
-        const storageProvider = this._storages;
-        return (0, utils_1.asyncIteratorConverter)((function () {
-            return __asyncGenerator(this, arguments, function* () {
-                var _a, e_9, _b, _c;
-                try {
-                    for (var _d = true, _e = __asyncValues(storageProvider.outboundTrackStorage[Symbol.asyncIterator]()), _f; _f = yield __await(_e.next()), _a = _f.done, !_a;) {
-                        _c = _f.value;
-                        _d = false;
-                        try {
-                            const [, outboundTrackModel] = _c;
-                            if (!outboundTrackModel)
-                                continue;
-                            yield yield __await((0, OutboundTrackEntry_1.createOutboundTrackEntry)(storageProvider, outboundTrackModel));
-                        }
-                        finally {
-                            _d = true;
-                        }
-                    }
-                }
-                catch (e_9_1) { e_9 = { error: e_9_1 }; }
-                finally {
-                    try {
-                        if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
-                    }
-                    finally { if (e_9) throw e_9.error; }
-                }
-            });
-        })());
-    }
-    sfuSctpChannels() {
-        const storageProvider = this._storages;
-        return (0, utils_1.asyncIteratorConverter)((function () {
-            return __asyncGenerator(this, arguments, function* () {
-                var _a, e_10, _b, _c;
-                try {
-                    for (var _d = true, _e = __asyncValues(storageProvider.sfuSctpChannelStorage[Symbol.asyncIterator]()), _f; _f = yield __await(_e.next()), _a = _f.done, !_a;) {
-                        _c = _f.value;
-                        _d = false;
-                        try {
-                            const [, sfuSctpChannelModel] = _c;
-                            if (!sfuSctpChannelModel)
-                                continue;
-                            yield yield __await((0, SfuSctpChannelEntry_1.createSfuSctpChannelEntry)(storageProvider, sfuSctpChannelModel));
-                        }
-                        finally {
-                            _d = true;
-                        }
-                    }
-                }
-                catch (e_10_1) { e_10 = { error: e_10_1 }; }
-                finally {
-                    try {
-                        if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
-                    }
-                    finally { if (e_10) throw e_10.error; }
-                }
-            });
-        })());
-    }
-    getCall(callId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (0, CallEntry_1.createCallEntry)(this._storages, yield this._storages.callStorage.get(callId));
-        });
-    }
-    getAllCalls(callIds) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const models = yield this._storages.callStorage.getAll(callIds);
-            return new Map(Array.from(models).map(([callId, model]) => [callId, (0, CallEntry_1.createCallEntry)(this._storages, model)]));
+            this._observedCalls.set(call.callId, call);
+            this.reports.addCallEventReport((0, callEventReports_1.createCallStartedEventReport)(call.serviceId, call.roomId, call.callId, call.started));
+            this.emit('newcall', call);
+            return call;
         });
     }
-    getSfu(sfuId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (0, SfuEntry_1.createSfuEntry)(this._storages, yield this._storages.sfuStorage.get(sfuId));
-        });
-    }
-    getAllSfus(sfuIds) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const models = yield this._storages.sfuStorage.getAll(sfuIds);
-            return new Map(Array.from(models).map(([sfuId, model]) => [sfuId, (0, SfuEntry_1.createSfuEntry)(this._storages, model)]));
-        });
-    }
-    getSfuTransport(sfuTransportId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (0, SfuTransportEntry_1.createSfuTransportEntry)(this._storages, yield this._storages.sfuTransportStorage.get(sfuTransportId));
-        });
-    }
-    getAllSfuTransports(sfuTransportIds) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const models = yield this._storages.sfuTransportStorage.getAll(sfuTransportIds);
-            return new Map(Array.from(models).map(([sfuTransportId, model]) => [sfuTransportId, (0, SfuTransportEntry_1.createSfuTransportEntry)(this._storages, model)]));
-        });
-    }
-    getSfuInboundRtpPad(sfuInboundRtpPadId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (0, SfuInboundRtpPadEntry_1.createSfuInboundRtpPadEntry)(this._storages, yield this._storages.sfuInboundRtpPadStorage.get(sfuInboundRtpPadId));
-        });
-    }
-    getAllSfuInboundRtpPads(sfuInboundRtpPadIds) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const models = yield this._storages.sfuInboundRtpPadStorage.getAll(sfuInboundRtpPadIds);
-            return new Map(Array.from(models).map(([sfuInboundRtpPadId, model]) => [sfuInboundRtpPadId, (0, SfuInboundRtpPadEntry_1.createSfuInboundRtpPadEntry)(this._storages, model)]));
-        });
-    }
-    getSfuOutboundRtpPad(sfuOutboundRtpPadId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (0, SfuOutboundRtpPadEntry_1.createSfuOutboundRtpPadEntry)(this._storages, yield this._storages.sfuOutboundRtpPadStorage.get(sfuOutboundRtpPadId));
-        });
-    }
-    getAllSfuOutboundRtpPads(sfuOutboundRtpPadIds) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const models = yield this._storages.sfuOutboundRtpPadStorage.getAll(sfuOutboundRtpPadIds);
-            return new Map(Array.from(models).map(([sfuOutboundRtpPadId, model]) => [sfuOutboundRtpPadId, (0, SfuOutboundRtpPadEntry_1.createSfuOutboundRtpPadEntry)(this._storages, model)]));
-        });
-    }
-    getClient(clientId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (0, ClientEntry_1.createClientEntry)(this._storages, yield this._storages.clientStorage.get(clientId));
-        });
-    }
-    getAllClient(clientIds) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const models = yield this._storages.clientStorage.getAll(clientIds);
-            return new Map(Array.from(models).map(([clientId, model]) => [clientId, (0, ClientEntry_1.createClientEntry)(this._storages, model)]));
-        });
-    }
-    getPeerConnection(peerConnectionId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (0, PeerConnectionEntry_1.createPeerConnectionEntry)(this._storages, yield this._storages.peerConnectionStorage.get(peerConnectionId));
-        });
-    }
-    getAllPeerConnections(peerConnectionIds) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const models = yield this._storages.peerConnectionStorage.getAll(peerConnectionIds);
-            return new Map(Array.from(models).map(([peerConnectionId, model]) => [peerConnectionId, (0, PeerConnectionEntry_1.createPeerConnectionEntry)(this._storages, model)]));
-        });
-    }
-    getInboundTrack(inboundTrackId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (0, InboundTrackEntry_1.createInboundTrackEntry)(this._storages, yield this._storages.inboundTrackStorage.get(inboundTrackId));
-        });
-    }
-    getAllInboundTracks(inboundTrackIds) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const models = yield this._storages.inboundTrackStorage.getAll(inboundTrackIds);
-            return new Map(Array.from(models).map(([inboundTrackId, model]) => [inboundTrackId, (0, InboundTrackEntry_1.createInboundTrackEntry)(this._storages, model)]));
-        });
-    }
-    getOutboundTrack(outboundTrackId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (0, OutboundTrackEntry_1.createOutboundTrackEntry)(this._storages, yield this._storages.outboundTrackStorage.get(outboundTrackId));
-        });
-    }
-    getAllOutboundTracks(outboundTrackIds) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const models = yield this._storages.outboundTrackStorage.getAll(outboundTrackIds);
-            return new Map(Array.from(models).map(([outboundTrackId, model]) => [outboundTrackId, (0, OutboundTrackEntry_1.createOutboundTrackEntry)(this._storages, model)]));
-        });
-    }
-    getSfuSctpChannel(sctpChannelId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (0, SfuSctpChannelEntry_1.createSfuSctpChannelEntry)(this._storages, yield this._storages.sfuSctpChannelStorage.get(sctpChannelId));
-        });
-    }
-    getAllSfuSctpChannel(sctpChannelIds) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const models = yield this._storages.sfuSctpChannelStorage.getAll(sctpChannelIds);
-            return new Map(Array.from(models).map(([sctpChannelId, model]) => [sctpChannelId, (0, SfuSctpChannelEntry_1.createSfuSctpChannelEntry)(this._storages, model)]));
-        });
+    get observedCalls() {
+        return this._observedCalls;
     }
     get closed() {
         return this._closed;
@@ -646,8 +82,20 @@ class Observer {
             return logger.debug('Attempted to close twice');
         }
         this._closed = true;
-        this._sources.close();
-        this._emitter.emit('close');
+        this.emit('close');
+    }
+    _emitReports() {
+        if (this._reportTimer) {
+            clearTimeout(this._reportTimer);
+            this._reportTimer = undefined;
+        }
+        this.reports.emit();
+        if (this.config.maxCollectingTimeInMs) {
+            this._reportTimer = setTimeout(() => {
+                this._reportTimer = undefined;
+                this._emitReports();
+            }, this.config.maxCollectingTimeInMs);
+        }
     }
 }
 exports.Observer = Observer;