@observertc/observer-js 0.42.9 → 1.0.1-57a1811.0

package/lib/ObservedPeerConnection.js

@@ -2,169 +2,186 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObservedPeerConnection = void 0;
 const events_1 = require("events");
-const ObservedICE_1 = require("./ObservedICE");
+const ObservedInboundRtp_1 = require("./ObservedInboundRtp");
+const logger_1 = require("./common/logger");
+const ObservedOutboundRtp_1 = require("./ObservedOutboundRtp");
+const ObservedCertificate_1 = require("./ObservedCertificate");
+const ObservedCodec_1 = require("./ObservedCodec");
 const ObservedDataChannel_1 = require("./ObservedDataChannel");
-const ObservedInboundAudioTrack_1 = require("./ObservedInboundAudioTrack");
-const ObservedInboundVideoTrack_1 = require("./ObservedInboundVideoTrack");
-const ObservedOutboundAudioTrack_1 = require("./ObservedOutboundAudioTrack");
-const ObservedOutboundVideoTrack_1 = require("./ObservedOutboundVideoTrack");
-const CalculatedScore_1 = require("./common/CalculatedScore");
+const ObservedIceCandidate_1 = require("./ObservedIceCandidate");
+const ObservedIceCandidatePair_1 = require("./ObservedIceCandidatePair");
+const ObservedIceTransport_1 = require("./ObservedIceTransport");
+const ObservedMediaSource_1 = require("./ObservedMediaSource");
+const ObservedPeerConnectionTransport_1 = require("./ObservedPeerConnectionTransport");
+const ObservedMediaPlayout_1 = require("./ObservedMediaPlayout");
+const ObservedRemoteInboundRtp_1 = require("./ObservedRemoteInboundRtp");
+const ObservedRemoteOutboundRtp_1 = require("./ObservedRemoteOutboundRtp");
+const ObservedInboundTrack_1 = require("./ObservedInboundTrack");
+const ObservedOutboundTrack_1 = require("./ObservedOutboundTrack");
+const logger = (0, logger_1.createLogger)('ObservedPeerConnection');
 class ObservedPeerConnection extends events_1.EventEmitter {
-    constructor(_model, client) {
+    peerConnectionId;
+    client;
+    _visited = true;
+    appData;
+    calculatedScore = {
+        weight: 1,
+        value: undefined,
+    };
+    closed = false;
+    // timestamp of the PEER_CONNECTION_OPENED event
+    openedAt;
+    // timestamp of the PEER_CONNECTION_CLOSED event
+    closedAt;
+    updated = Date.now();
+    availableIncomingBitrate = 0;
+    availableOutgoingBitrate = 0;
+    totalInboundPacketsLost = 0;
+    totalInboundPacketsReceived = 0;
+    totalOutboundPacketsSent = 0;
+    totalDataChannelBytesSent = 0;
+    totalDataChannelBytesReceived = 0;
+    totalDataChannelMessagesSent = 0;
+    totalDataChannelMessagesReceived = 0;
+    totalSentAudioBytes = 0;
+    totalSentVideoBytes = 0;
+    totalSentAudioPackets = 0;
+    totalSentVideoPackets = 0;
+    totalReceivedAudioPacktes = 0;
+    totalReceivedVideoPackets = 0;
+    totalReceivedAudioBytes = 0;
+    totalReceivedVideoBytes = 0;
+    deltaInboundPacketsLost = 0;
+    deltaInboundPacketsReceived = 0;
+    deltaOutboundPacketsSent = 0;
+    deltaDataChannelBytesSent = 0;
+    deltaDataChannelBytesReceived = 0;
+    deltaDataChannelMessagesSent = 0;
+    deltaDataChannelMessagesReceived = 0;
+    deltaInboundReceivedBytes = 0;
+    deltaOutboundSentBytes = 0;
+    deltaReceivedAudioBytes = 0;
+    deltaReceivedVideoBytes = 0;
+    deltaReceivedAudioPackets = 0;
+    deltaReceivedVideoPackets = 0;
+    deltaSentAudioBytes = 0;
+    deltaSentVideoBytes = 0;
+    receivingPacketsPerSecond = 0;
+    sendingPacketsPerSecond = 0;
+    sendingAudioBitrate = 0;
+    sendingVideoBitrate = 0;
+    receivingAudioBitrate = 0;
+    receivingVideoBitrate = 0;
+    avgRttInMs;
+    avgJitter;
+    usingTCP = false;
+    usingTURN = false;
+    observedTurnServer;
+    observedCertificates = new Map();
+    observedCodecs = new Map();
+    observedDataChannels = new Map();
+    observedIceCandidates = new Map();
+    observedIceCandidatesPair = new Map();
+    observedIceTransports = new Map();
+    observedInboundRtps = new Map();
+    observedInboundTracks = new Map();
+    observedMediaPlayouts = new Map();
+    observedMediaSources = new Map();
+    observedOutboundRtps = new Map();
+    observedOutboundTracks = new Map();
+    observedPeerConnectionTransports = new Map();
+    observedRemoteInboundRtps = new Map();
+    observedRemoteOutboundRtps = new Map();
+    constructor(peerConnectionId, client) {
         super();
-        this._model = _model;
+        this.peerConnectionId = peerConnectionId;
         this.client = client;
-        this.created = Date.now();
-        this.visited = true;
-        this._stabilityScores = [];
-        this.ωpendingIssuesForScores = [];
-        this.totalInboundPacketsLost = 0;
-        this.totalInboundPacketsReceived = 0;
-        this.totalOutboundPacketsSent = 0;
-        this.totalDataChannelBytesSent = 0;
-        this.totalDataChannelBytesReceived = 0;
-        this.totalSentAudioBytes = 0;
-        this.totalSentVideoBytes = 0;
-        this.totalSentAudioPackets = 0;
-        this.totalSentVideoPackets = 0;
-        this.totalReceivedAudioPacktes = 0;
-        this.totalReceivedVideoPackets = 0;
-        this.totalReceivedAudioBytes = 0;
-        this.totalReceivedVideoBytes = 0;
-        this.deltaInboundPacketsLost = 0;
-        this.deltaInboundPacketsReceived = 0;
-        this.deltaOutboundPacketsSent = 0;
-        this.deltaDataChannelBytesSent = 0;
-        this.deltaDataChannelBytesReceived = 0;
-        this.deltaInboundReceivedBytes = 0;
-        this.deltaOutboundSentBytes = 0;
-        this.deltaReceivedAudioBytes = 0;
-        this.deltaReceivedVideoBytes = 0;
-        this.deltaReceivedAudioPackets = 0;
-        this.deltaReceivedVideoPackets = 0;
-        this.deltaSentAudioBytes = 0;
-        this.deltaSentVideoBytes = 0;
-        this.receivingPacketsPerSecond = 0;
-        this.sendingPacketsPerSecond = 0;
-        this.sendingAudioBitrate = 0;
-        this.sendingVideoBitrate = 0;
-        this.receivingAudioBitrate = 0;
-        this.receivingVideoBitrate = 0;
-        this._closed = false;
-        this._updated = Date.now();
-        this.ICE = ObservedICE_1.ObservedICE.create(this);
-        this._inboundAudioTracks = new Map();
-        this._inboundVideoTracks = new Map();
-        this._outboundAudioTracks = new Map();
-        this._outboundVideoTracks = new Map();
-        this._dataChannels = new Map();
         this.setMaxListeners(Infinity);
     }
-    get serviceId() {
-        return this.client.serviceId;
-    }
-    get roomId() {
-        return this.client.roomId;
-    }
-    get callId() {
-        return this.client.callId;
-    }
-    get clientId() {
-        return this.client.clientId;
-    }
-    get mediaUnitId() {
-        return this.client.mediaUnitId;
-    }
-    get label() {
-        return this._model.label;
-    }
-    set label(value) {
-        this._model.label = value;
-    }
-    get usingTURN() {
-        return this.ICE.usingTURN;
+    get score() {
+        return this.calculatedScore.value;
     }
-    get availableOutgoingBitrate() {
-        var _a;
-        return (_a = this.ICE.stats) === null || _a === void 0 ? void 0 : _a.availableOutgoingBitrate;
+    get visited() {
+        const visited = this._visited;
+        this._visited = false;
+        return visited;
     }
-    get availableIncomingBitrate() {
-        var _a;
-        return (_a = this.ICE.stats) === null || _a === void 0 ? void 0 : _a.availableIncomingBitrate;
+    get codecs() {
+        return [...this.observedCodecs.values()];
     }
-    get peerConnectionId() {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        return this._model.peerConnectionId;
+    get inboundRtps() {
+        return [...this.observedInboundRtps.values()];
     }
-    get reports() {
-        return this.client.reports;
+    get remoteOutboundRtps() {
+        return [...this.observedRemoteOutboundRtps.values()];
     }
-    get stats() {
-        return this._sample;
+    get outboundRtps() {
+        return [...this.observedOutboundRtps.values()];
     }
-    get updated() {
-        return this._updated;
+    get remoteInboundRtps() {
+        return [...this.observedRemoteInboundRtps.values()];
     }
-    get inboundAudioTracks() {
-        return this._inboundAudioTracks;
+    get mediaSources() {
+        return [...this.observedMediaSources.values()];
     }
-    get inboundVideoTracks() {
-        return this._inboundVideoTracks;
+    get mediaPlayouts() {
+        return [...this.observedMediaPlayouts.values()];
     }
-    get outboundAudioTracks() {
-        return this._outboundAudioTracks;
+    get dataChannels() {
+        return [...this.observedDataChannels.values()];
     }
-    get outboundVideoTracks() {
-        return this._outboundVideoTracks;
+    get peerConnectionTransports() {
+        return [...this.observedPeerConnectionTransports.values()];
     }
-    get dataChannels() {
-        return this._dataChannels;
+    get iceTransports() {
+        return [...this.observedIceTransports.values()];
     }
-    get uptimeInMs() {
-        return this._updated - this.created;
+    get iceCandidates() {
+        return [...this.observedIceCandidates.values()];
     }
-    get marker() {
-        return this._marker;
+    get iceCandidatePairs() {
+        return [...this.observedIceCandidatesPair.values()];
     }
-    set marker(value) {
-        this._marker = value;
-        this._inboundAudioTracks.forEach((track) => (track.marker = value));
-        this._inboundVideoTracks.forEach((track) => (track.marker = value));
-        this._outboundAudioTracks.forEach((track) => (track.marker = value));
-        this._outboundVideoTracks.forEach((track) => (track.marker = value));
-        this._dataChannels.forEach((channel) => (channel.marker = value));
-        this.ICE.marker = value;
+    get certificates() {
+        return [...this.observedCertificates.values()];
     }
-    addEventReport(params) {
-        var _a;
-        this.reports.addCallEventReport(Object.assign(Object.assign({}, params), { serviceId: this.serviceId, mediaUnitId: this.mediaUnitId, roomId: this.roomId, callId: this.callId, clientId: this.clientId, userId: this.client.userId, peerConnectionId: this.peerConnectionId, marker: this.client.marker, timestamp: (_a = params.timestamp) !== null && _a !== void 0 ? _a : Date.now() }));
+    get selectedIceCandidatePairs() {
+        return this.iceTransports.map((iceTransport) => iceTransport.getSelectedCandidatePair())
+            .filter((pair) => pair !== undefined);
     }
-    get closed() {
-        return this._closed;
+    get selectedIceCandiadtePairForTurn() {
+        return this.selectedIceCandidatePairs
+            .filter((pair) => pair.getLocalCandidate()?.candidateType === 'relay' &&
+            pair.getRemoteCandidate()?.url?.startsWith('turn:'));
     }
     close() {
-        if (this._closed)
+        if (this.closed)
             return;
-        this._closed = true;
-        Array.from(this._inboundAudioTracks.values()).forEach((track) => track.close());
-        Array.from(this._inboundVideoTracks.values()).forEach((track) => track.close());
-        Array.from(this._outboundAudioTracks.values()).forEach((track) => {
-            var _a;
-            this.client.call.sfuStreamIdToOutboundAudioTrack.delete((_a = track.sfuStreamId) !== null && _a !== void 0 ? _a : '');
-            track.close();
-        });
-        Array.from(this._outboundVideoTracks.values()).forEach((track) => {
-            var _a;
-            this.client.call.sfuStreamIdToOutboundVideoTrack.delete((_a = track.sfuStreamId) !== null && _a !== void 0 ? _a : '');
-            track.close();
-        });
+        this.closed = true;
+        this.observedCertificates.clear();
+        this.observedCodecs.clear();
+        this.observedDataChannels.clear();
+        this.observedIceCandidates.clear();
+        this.observedIceCandidatesPair.clear();
+        this.observedIceTransports.clear();
+        this.observedInboundRtps.clear();
+        this.observedInboundTracks.clear();
+        this.observedMediaPlayouts.clear();
+        this.observedMediaSources.clear();
+        this.observedOutboundRtps.clear();
+        this.observedOutboundTracks.clear();
+        this.observedPeerConnectionTransports.clear();
+        this.observedRemoteInboundRtps.clear();
+        this.observedRemoteOutboundRtps.clear();
+        this.client.call.observer.observedTURN.removePeerConnection(this);
         this.emit('close');
     }
-    getTrack(trackId) {
-        var _a, _b, _c;
-        return (_c = (_b = (_a = this._inboundAudioTracks.get(trackId)) !== null && _a !== void 0 ? _a : this._inboundVideoTracks.get(trackId)) !== null && _b !== void 0 ? _b : this._outboundAudioTracks.get(trackId)) !== null && _c !== void 0 ? _c : this._outboundVideoTracks.get(trackId);
-    }
-    resetMetrics() {
+    accept(sample) {
+        if (this.closed)
+            return;
+        this._visited = true;
+        this.availableIncomingBitrate = 0;
+        this.availableOutgoingBitrate = 0;
         this.deltaInboundPacketsLost = 0;
         this.deltaInboundPacketsReceived = 0;
         this.deltaOutboundPacketsSent = 0;
@@ -182,240 +199,490 @@ class ObservedPeerConnection extends events_1.EventEmitter {
         this.sendingVideoBitrate = 0;
         this.receivingAudioBitrate = 0;
         this.receivingVideoBitrate = 0;
-        this.ICE.resetMetrics();
-    }
-    update(sample, timestamp) {
-        if (this._closed)
-            return;
-        if (sample.peerConnectionId !== this._model.peerConnectionId)
-            throw new Error(`TransportId mismatch. PeerConnectionId: ${this._model.peerConnectionId} TransportId: ${sample.transportId}`);
-        this._sample = sample;
-        if (this._model.label !== sample.label) {
-            this._model.label = sample.label;
-        }
         const now = Date.now();
-        const report = Object.assign(Object.assign({ serviceId: this.client.call.serviceId, roomId: this.client.call.roomId, callId: this.client.call.callId, clientId: this.client.clientId, userId: this.client.userId, mediaUnitId: this.client.mediaUnitId }, sample), { timestamp, sampleSeq: -1, marker: this.marker });
-        this.reports.addPeerConnectionTransportReports(report);
-        this._elapsedTimeSinceLastUpdate = now - this._updated;
-        this.visited = true;
-        this._updated = now;
-        this._statsTimestamp = timestamp;
-        this.emit('update', {
-            elapsedTimeInMs: this._elapsedTimeSinceLastUpdate,
-        });
-    }
-    createInboundAudioTrack(config) {
-        if (this._closed)
-            throw new Error(`PeerConnection ${this.peerConnectionId} is closed`);
-        const result = new ObservedInboundAudioTrack_1.ObservedInboundAudioTrack(config, this);
-        result.on('close', () => {
-            this._inboundAudioTracks.delete(result.trackId);
-        });
-        this._inboundAudioTracks.set(result.trackId, result);
-        this.emit('newinboudaudiotrack', result);
-        return result;
-    }
-    createInboundVideoTrack(config) {
-        if (this._closed)
-            throw new Error(`PeerConnection ${this.peerConnectionId} is closed`);
-        const result = new ObservedInboundVideoTrack_1.ObservedInboundVideoTrack(config, this);
-        result.on('close', () => {
-            this._inboundVideoTracks.delete(result.trackId);
-        });
-        this._inboundVideoTracks.set(result.trackId, result);
-        this.emit('newinboudvideotrack', result);
-        return result;
-    }
-    createOutboundAudioTrack(config) {
-        if (this._closed)
-            throw new Error(`PeerConnection ${this.peerConnectionId} is closed`);
-        const result = new ObservedOutboundAudioTrack_1.ObservedOutboundAudioTrack(config, this);
-        result.on('close', () => {
-            this._outboundAudioTracks.delete(result.trackId);
-        });
-        this._outboundAudioTracks.set(result.trackId, result);
-        this.emit('newoutboundaudiotrack', result);
-        return result;
-    }
-    createOutboundVideoTrack(config) {
-        if (this._closed)
-            throw new Error(`PeerConnection ${this.peerConnectionId} is closed`);
-        const result = new ObservedOutboundVideoTrack_1.ObservedOutboundVideoTrack(config, this);
-        result.on('close', () => {
-            this._outboundVideoTracks.delete(result.trackId);
-        });
-        this._outboundVideoTracks.set(result.trackId, result);
-        this.emit('newoutboundvideotrack', result);
-        return result;
-    }
-    createDataChannel(channelId) {
-        if (this._closed)
-            throw new Error(`PeerConnection ${this.peerConnectionId} is closed`);
-        const result = new ObservedDataChannel_1.ObservedDataChannel({
-            channelId,
-        }, this);
-        result.on('close', () => {
-            this._dataChannels.delete(result.channelId);
-        });
-        this._dataChannels.set(result.channelId, result);
-        this.emit('newdatachannel', result);
-        return result;
-    }
-    updateMetrics() {
-        var _a;
-        let sumRttInMs = 0;
-        let sumJitter = 0;
-        const trackScores = [];
-        this._inboundAudioTracks.forEach((track) => {
-            var _a, _b;
-            track.updateMetrics();
-            this.deltaInboundPacketsLost += track.deltaLostPackets;
-            this.deltaInboundPacketsReceived += track.deltaReceivedPackets;
-            this.deltaInboundReceivedBytes += track.deltaBytesReceived;
-            this.deltaReceivedAudioBytes += track.deltaBytesReceived;
-            this.deltaReceivedAudioPackets += track.deltaReceivedPackets;
-            this.receivingAudioBitrate += track.bitrate;
-            sumRttInMs += ((_a = track.rttInMs) !== null && _a !== void 0 ? _a : 0);
-            sumJitter += ((_b = track.jitter) !== null && _b !== void 0 ? _b : 0);
-            track.score && trackScores.push(track.score);
-        });
-        this._inboundVideoTracks.forEach((track) => {
-            var _a, _b;
-            track.updateMetrics();
-            this.deltaInboundPacketsLost += track.deltaLostPackets;
-            this.deltaInboundPacketsReceived += track.deltaReceivedPackets;
-            this.deltaInboundReceivedBytes += track.deltaBytesReceived;
-            this.deltaReceivedVideoBytes += track.deltaBytesReceived;
-            this.deltaReceivedVideoPackets += track.deltaReceivedPackets;
-            this.receivingVideoBitrate += track.bitrate;
-            sumRttInMs += ((_a = track.rttInMs) !== null && _a !== void 0 ? _a : 0);
-            sumJitter += ((_b = track.jitter) !== null && _b !== void 0 ? _b : 0);
-            track.score && trackScores.push(track.score);
-        });
-        this._outboundAudioTracks.forEach((track) => {
-            var _a, _b;
-            track.updateMetrics();
-            this.deltaOutboundPacketsSent += track.deltaSentPackets;
-            this.deltaOutboundSentBytes += track.deltaSentBytes;
-            this.deltaSentAudioBytes += track.deltaSentBytes;
-            this.deltaSentAudioBytes += track.deltaSentPackets;
-            this.sendingAudioBitrate += track.bitrate;
-            sumRttInMs += ((_a = track.rttInMs) !== null && _a !== void 0 ? _a : 0);
-            sumJitter += ((_b = track.jitter) !== null && _b !== void 0 ? _b : 0);
-            track.score && trackScores.push(track.score);
-        });
-        this._outboundVideoTracks.forEach((track) => {
-            var _a, _b;
-            track.updateMetrics();
-            this.deltaOutboundPacketsSent += track.deltaSentPackets;
-            this.deltaOutboundSentBytes += track.deltaSentBytes;
-            this.deltaSentVideoBytes += track.deltaSentBytes;
-            this.deltaSentVideoBytes += track.deltaSentPackets;
-            this.sendingVideoBitrate += track.bitrate;
-            sumRttInMs += ((_a = track.rttInMs) !== null && _a !== void 0 ? _a : 0);
-            sumJitter += ((_b = track.jitter) !== null && _b !== void 0 ? _b : 0);
-            track.score && trackScores.push(track.score);
-        });
-        this._dataChannels.forEach((channel) => {
-            this.deltaDataChannelBytesSent += channel.deltaBytesSent;
-            this.deltaDataChannelBytesReceived += channel.deltaBytesReceived;
-        });
-        const iceRttInMs = (_a = this.ICE.stats) === null || _a === void 0 ? void 0 : _a.currentRoundTripTime;
-        let nrOfBelongings = this._inboundAudioTracks.size + this._inboundVideoTracks.size + this._outboundAudioTracks.size + this._outboundVideoTracks.size;
-        this.avgJitter = 0 < nrOfBelongings ? sumJitter / nrOfBelongings : undefined;
-        if (iceRttInMs) {
-            sumRttInMs += iceRttInMs;
-            nrOfBelongings += 1;
-        }
-        this.avgRttInMs = 0 < nrOfBelongings ? sumRttInMs / nrOfBelongings : undefined;
-        this.totalDataChannelBytesReceived += this.deltaDataChannelBytesReceived;
-        this.totalDataChannelBytesSent += this.deltaDataChannelBytesSent;
+        const elapsedTimeInMs = now - this.updated;
+        const elapsedTimeInSec = elapsedTimeInMs / 1000;
+        const rttMeasurementsInSec = [];
+        const jitterMeasurements = [];
+        if (sample.certificates) {
+            for (const certificate of sample.certificates) {
+                this._updateCertificateStats(certificate);
+            }
+        }
+        if (sample.codecs) {
+            for (const codec of sample.codecs) {
+                this._updateCodecStats(codec);
+            }
+        }
+        if (sample.dataChannels) {
+            for (const dataChannel of sample.dataChannels) {
+                const observedDataChannel = this._updateDataChannelStats(dataChannel);
+                if (!observedDataChannel)
+                    continue;
+                this.deltaDataChannelBytesSent += observedDataChannel.deltaBytesSent;
+                this.deltaDataChannelBytesReceived += observedDataChannel.deltaBytesReceived;
+                this.deltaDataChannelMessagesSent += observedDataChannel.deltaMessagesSent;
+                this.deltaDataChannelMessagesReceived += observedDataChannel.deltaMessagesReceived;
+            }
+        }
+        if (sample.iceCandidates) {
+            for (const iceCandidate of sample.iceCandidates) {
+                this._updateIceCandidateStats(iceCandidate);
+            }
+        }
+        if (sample.iceCandidatePairs) {
+            for (const iceCandidatePair of sample.iceCandidatePairs) {
+                const observedCandidatePair = this._updateIceCandidatePairStats(iceCandidatePair);
+                if (!observedCandidatePair)
+                    continue;
+                if (observedCandidatePair.currentRoundTripTime) {
+                    rttMeasurementsInSec.push(observedCandidatePair.currentRoundTripTime);
+                }
+                if (observedCandidatePair.availableIncomingBitrate) {
+                    this.availableIncomingBitrate += observedCandidatePair.availableIncomingBitrate;
+                }
+                if (observedCandidatePair.availableOutgoingBitrate) {
+                    this.availableOutgoingBitrate += observedCandidatePair.availableOutgoingBitrate;
+                }
+            }
+        }
+        if (sample.iceTransports) {
+            for (const iceTransport of sample.iceTransports) {
+                this._updateIceTransportStats(iceTransport);
+            }
+        }
+        if (sample.inboundRtps) {
+            for (const inboundRtp of sample.inboundRtps) {
+                const observedInboundRtp = this._updateInboundRtpStats(inboundRtp);
+                if (!observedInboundRtp)
+                    continue;
+                this.deltaInboundPacketsLost += observedInboundRtp.deltaLostPackets;
+                this.deltaInboundPacketsReceived += observedInboundRtp.deltaReceivedPackets;
+                this.deltaInboundReceivedBytes += observedInboundRtp.deltaBytesReceived;
+                switch (inboundRtp.kind) {
+                    case 'audio':
+                        this.deltaReceivedAudioBytes += observedInboundRtp.deltaBytesReceived;
+                        this.deltaReceivedAudioPackets += observedInboundRtp.deltaReceivedPackets;
+                        break;
+                    case 'video':
+                        this.deltaReceivedVideoBytes += observedInboundRtp.deltaBytesReceived;
+                        this.deltaReceivedVideoPackets += observedInboundRtp.deltaReceivedPackets;
+                        break;
+                }
+                if (observedInboundRtp.jitter) {
+                    jitterMeasurements.push(observedInboundRtp.jitter);
+                }
+            }
+        }
+        if (sample.mediaPlayouts) {
+            for (const mediaPlayout of sample.mediaPlayouts) {
+                this._updateMediaPlayoutStats(mediaPlayout);
+            }
+        }
+        if (sample.mediaSources) {
+            for (const mediaSource of sample.mediaSources) {
+                this._updateMediaSourceStats(mediaSource);
+            }
+        }
+        if (sample.outboundRtps) {
+            for (const outboundRtp of sample.outboundRtps) {
+                const observedOutboundRtp = this._updateOutboundRtpStats(outboundRtp);
+                if (!observedOutboundRtp)
+                    continue;
+                this.deltaOutboundPacketsSent += observedOutboundRtp.deltaPacketsSent ?? 0;
+                this.deltaOutboundSentBytes += observedOutboundRtp.deltaBytesSent ?? 0;
+                switch (outboundRtp.kind) {
+                    case 'audio':
+                        this.deltaSentAudioBytes += observedOutboundRtp.deltaBytesSent;
+                        this.deltaSentAudioBytes += observedOutboundRtp.deltaPacketsSent;
+                        break;
+                    case 'video':
+                        this.deltaSentVideoBytes += observedOutboundRtp.deltaBytesSent;
+                        this.deltaSentVideoBytes += observedOutboundRtp.deltaPacketsSent;
+                        break;
+                }
+            }
+        }
+        if (sample.peerConnectionTransports) {
+            for (const peerConnectionTransport of sample.peerConnectionTransports) {
+                this._updatePeerConnectionTransportStats(peerConnectionTransport);
+            }
+        }
+        if (sample.remoteInboundRtps) {
+            for (const remoteInboundRtp of sample.remoteInboundRtps) {
+                const observedRemoteInboundRtp = this._updateRemoteInboundRtpStats(remoteInboundRtp);
+                if (!observedRemoteInboundRtp)
+                    continue;
+                if (observedRemoteInboundRtp.roundTripTime) {
+                    rttMeasurementsInSec.push(observedRemoteInboundRtp.roundTripTime);
+                }
+            }
+        }
+        if (sample.remoteOutboundRtps) {
+            for (const remoteOutboundRtp of sample.remoteOutboundRtps) {
+                const observedRemoteOutboundRtp = this._updateRemoteOutboundRtpStats(remoteOutboundRtp);
+                if (!observedRemoteOutboundRtp)
+                    continue;
+            }
+        }
+        // tracks should be updated last as they are derived stats
+        // and depends on base stats but they all received in the sample sample
+        if (sample.inboundTracks) {
+            for (const inboundTrack of sample.inboundTracks) {
+                this._updateInboundTrackSample(inboundTrack);
+            }
+        }
+        if (sample.outboundTracks) {
+            for (const outboundTrack of sample.outboundTracks) {
+                this._updateOutboundTrackSample(outboundTrack);
+            }
+        }
         this.totalInboundPacketsLost += this.deltaInboundPacketsLost;
         this.totalInboundPacketsReceived += this.deltaInboundPacketsReceived;
         this.totalOutboundPacketsSent += this.deltaOutboundPacketsSent;
-        this.totalSentAudioBytes += this.deltaSentAudioBytes;
-        this.totalSentVideoBytes += this.deltaSentVideoBytes;
+        this.totalDataChannelBytesSent += this.deltaDataChannelBytesSent;
+        this.totalDataChannelBytesReceived += this.deltaDataChannelBytesReceived;
+        this.totalDataChannelMessagesSent += this.deltaDataChannelMessagesSent;
+        this.totalDataChannelMessagesReceived += this.deltaDataChannelMessagesReceived;
         this.totalReceivedAudioBytes += this.deltaReceivedAudioBytes;
         this.totalReceivedVideoBytes += this.deltaReceivedVideoBytes;
+        this.totalSentAudioBytes += this.deltaSentAudioBytes;
+        this.totalSentVideoBytes += this.deltaSentVideoBytes;
         this.totalReceivedAudioPacktes += this.deltaReceivedAudioPackets;
         this.totalReceivedVideoPackets += this.deltaReceivedVideoPackets;
         this.totalSentAudioPackets += this.deltaSentAudioBytes;
         this.totalSentVideoPackets += this.deltaSentVideoBytes;
-        if (this._elapsedTimeSinceLastUpdate && 0 < this._elapsedTimeSinceLastUpdate) {
-            this.sendingPacketsPerSecond = this.deltaOutboundPacketsSent / (this._elapsedTimeSinceLastUpdate / 1000);
-            this.receivingPacketsPerSecond = this.deltaInboundPacketsReceived / (this._elapsedTimeSinceLastUpdate / 1000);
+        this.receivingPacketsPerSecond = this.deltaInboundPacketsReceived / elapsedTimeInSec;
+        this.sendingPacketsPerSecond = this.deltaOutboundPacketsSent / elapsedTimeInSec;
+        this.sendingAudioBitrate = (this.deltaSentAudioBytes * 8) / elapsedTimeInSec;
+        this.sendingVideoBitrate = (this.deltaSentVideoBytes * 8) / elapsedTimeInSec;
+        this.receivingAudioBitrate = (this.deltaReceivedAudioBytes * 8) / elapsedTimeInSec;
+        this.receivingVideoBitrate = (this.deltaReceivedVideoBytes * 8) / elapsedTimeInSec;
+        if (rttMeasurementsInSec.length > 0) {
+            this.avgRttInMs = rttMeasurementsInSec.reduce((acc, val) => acc + val, 0) / rttMeasurementsInSec.length;
         }
         else {
-            this.sendingPacketsPerSecond = 0;
-            this.receivingPacketsPerSecond = 0;
-        }
-        // calculate quality score
-        this._updateQualityScore(trackScores);
-    }
-    _updateQualityScore(trackScores) {
-        var _a, _b, _c, _d, _e, _f, _g;
-        // Packet Jitter measured in seconds
-        // we use RTT and lost packets to calculate the base score for the connection
-        const rttInMs = (_a = this.avgRttInMs) !== null && _a !== void 0 ? _a : 0;
-        const latencyFactor = rttInMs < 150 ? 1.0 : (0, CalculatedScore_1.getRttScore)(rttInMs);
-        const totalPackets = Math.max(1, ((_b = this.totalInboundPacketsReceived) !== null && _b !== void 0 ? _b : 0) + ((_c = this.totalOutboundPacketsSent) !== null && _c !== void 0 ? _c : 0));
-        const lostPackets = ((_d = this.totalInboundPacketsLost) !== null && _d !== void 0 ? _d : 0) + ((_e = this.deltaOutboundPacketsSent) !== null && _e !== void 0 ? _e : 0);
-        const deliveryFactor = 1.0 - ((lostPackets) / (lostPackets + totalPackets));
-        // let's push the actual stability score
-        const stabilityScore = Math.pow(((latencyFactor * 0.5) + (deliveryFactor * 0.5)), 2);
-        this._stabilityScores.push(stabilityScore);
-        if (10 < this._stabilityScores.length) {
-            this._stabilityScores.shift();
-        }
-        else if (this._stabilityScores.length < 5) {
-            return;
+            this.avgRttInMs = undefined;
+        }
+        if (jitterMeasurements.length > 0) {
+            this.avgJitter = jitterMeasurements.reduce((acc, val) => acc + val, 0) / jitterMeasurements.length;
+        }
+        else {
+            this.avgJitter = undefined;
+        }
+        const selectedIceCandidatePairs = this.selectedIceCandidatePairs;
+        const selectedCandidatePairForTurn = selectedIceCandidatePairs.filter((pair) => pair.getLocalCandidate()?.candidateType === 'relay' &&
+            pair.getRemoteCandidate()?.url?.startsWith('turn:'));
+        const wasUsingTURN = this.usingTURN;
+        this.usingTCP = selectedIceCandidatePairs.some((pair) => pair.getLocalCandidate()?.protocol === 'tcp');
+        this.usingTURN = 0 < selectedCandidatePairForTurn.length;
+        if (this.usingTURN) {
+            if (!this.observedTurnServer) {
+                this.observedTurnServer = this.client.call.observer.observedTURN.addPeerConnection(this);
+            }
+            this.observedTurnServer?.updateTurnUsage(...selectedCandidatePairForTurn);
+        }
+        else if (wasUsingTURN) {
+            if (!this.usingTURN) {
+                this.client.call.observer.observedTURN.removePeerConnection(this);
+            }
+        }
+        this.calculatedScore.value = sample.score;
+        this.updated = now;
+        this._checkVisited();
+        this.emit('update');
+    }
+    _checkVisited() {
+        for (const certificate of [...this.observedCertificates.values()]) {
+            if (certificate.visited)
+                continue;
+            this.observedCertificates.delete(certificate.id);
+        }
+        for (const codec of [...this.observedCodecs.values()]) {
+            if (codec.visited)
+                continue;
+            this.observedCodecs.delete(codec.id);
+            this.emit('removed-codec', codec);
+        }
+        for (const dataChannel of [...this.observedDataChannels.values()]) {
+            if (dataChannel.visited)
+                continue;
+            this.observedDataChannels.delete(dataChannel.id);
+            this.emit('removed-data-channel', dataChannel);
+        }
+        for (const iceCandidate of [...this.observedIceCandidates.values()]) {
+            if (iceCandidate.visited)
+                continue;
+            this.observedIceCandidates.delete(iceCandidate.id);
+            this.emit('removed-ice-candidate', iceCandidate);
+        }
+        for (const iceCandidatePair of [...this.observedIceCandidatesPair.values()]) {
+            if (iceCandidatePair.visited)
+                continue;
+            this.observedIceCandidatesPair.delete(iceCandidatePair.id);
+            this.emit('removed-ice-candidate-pair', iceCandidatePair);
+        }
+        for (const iceTransport of [...this.observedIceTransports.values()]) {
+            if (iceTransport.visited)
+                continue;
+            this.observedIceTransports.delete(iceTransport.id);
+            this.emit('removed-ice-transport', iceTransport);
+        }
+        for (const inboundRtp of [...this.observedInboundRtps.values()]) {
+            if (inboundRtp.visited)
+                continue;
+            this.observedInboundRtps.delete(inboundRtp.ssrc);
+            this.emit('removed-inbound-rtp', inboundRtp);
+        }
+        for (const inboundTrack of [...this.observedInboundTracks.values()]) {
+            if (inboundTrack.visited)
+                continue;
+            this.observedInboundTracks.delete(inboundTrack.id);
+            this.emit('removed-inbound-track', inboundTrack);
+        }
+        for (const mediaPlayout of [...this.observedMediaPlayouts.values()]) {
+            if (mediaPlayout.visited)
+                continue;
+            this.observedMediaPlayouts.delete(mediaPlayout.id);
+            this.emit('removed-media-playout', mediaPlayout);
+        }
+        for (const mediaSource of [...this.observedMediaSources.values()]) {
+            if (mediaSource.visited)
+                continue;
+            this.observedMediaSources.delete(mediaSource.id);
+            this.emit('removed-media-source', mediaSource);
+        }
+        for (const outboundRtp of [...this.observedOutboundRtps.values()]) {
+            if (outboundRtp.visited)
+                continue;
+            this.observedOutboundRtps.delete(outboundRtp.ssrc);
+            this.emit('removed-outbound-rtp', outboundRtp);
+        }
+        for (const outboundTrack of [...this.observedOutboundTracks.values()]) {
+            if (outboundTrack.visited)
+                continue;
+            this.observedOutboundTracks.delete(outboundTrack.id);
+            this.emit('removed-outbound-track', outboundTrack);
+        }
+        for (const peerConnectionTransport of [...this.observedPeerConnectionTransports.values()]) {
+            if (peerConnectionTransport.visited)
+                continue;
+            this.observedPeerConnectionTransports.delete(peerConnectionTransport.id);
+            this.emit('removed-peer-connection-transport', peerConnectionTransport);
+        }
+        for (const remoteInboundRtp of [...this.observedRemoteInboundRtps.values()]) {
+            if (remoteInboundRtp.visited)
+                continue;
+            this.observedRemoteInboundRtps.delete(remoteInboundRtp.ssrc);
+            this.emit('removed-remote-inbound-rtp', remoteInboundRtp);
+        }
+        for (const remoteOutboundRtp of [...this.observedRemoteOutboundRtps.values()]) {
+            if (remoteOutboundRtp.visited)
+                continue;
+            this.observedRemoteOutboundRtps.delete(remoteOutboundRtp.ssrc);
+            this.emit('removed-remote-outbound-rtp', remoteOutboundRtp);
+        }
+    }
+    _updateCertificateStats(stats) {
+        let observedCertificate = this.observedCertificates.get(stats.id);
+        if (!observedCertificate) {
+            if (!stats.timestamp || !stats.id || !stats.fingerprint) {
+                return logger.warn(`ObservedPeerConnection received an invalid CertificateStats (missing timestamp OR id OR fingerprint field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`, stats);
+            }
+            observedCertificate = new ObservedCertificate_1.ObservedCertificate(stats.timestamp, stats.id, this);
+            this.observedCertificates.set(stats.id, observedCertificate);
+            this.emit('added-certificate', observedCertificate);
+        }
+        observedCertificate.update(stats);
+        return observedCertificate;
+    }
+    _updateCodecStats(stats) {
+        let observedCodec = this.observedCodecs.get(stats.id);
+        if (!observedCodec) {
+            if (!stats.timestamp || !stats.id || !stats.mimeType) {
+                return logger.warn(`ObservedPeerConnection received an invalid CodecStats (missing timestamp OR id OR mimeType field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`, stats);
+            }
+            observedCodec = new ObservedCodec_1.ObservedCodec(stats.timestamp, stats.id, stats.mimeType, this);
+            this.observedCodecs.set(stats.id, observedCodec);
+            this.emit('added-codec', observedCodec);
+        }
+        observedCodec.update(stats);
+        return observedCodec;
+    }
+    _updateDataChannelStats(stats) {
+        let observedDataChannel = this.observedDataChannels.get(stats.id);
+        if (!observedDataChannel) {
+            if (!stats.timestamp || !stats.id) {
+                return logger.warn(`ObservedPeerConnection received an invalid DataChannelStats (missing timestamp OR id field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`, stats);
+            }
+            observedDataChannel = new ObservedDataChannel_1.ObservedDataChannel(stats.timestamp, stats.id, this);
+            this.observedDataChannels.set(stats.id, observedDataChannel);
+            this.emit('added-data-channel', observedDataChannel);
+        }
+        observedDataChannel.update(stats);
+        return observedDataChannel;
+    }
+    _updateIceCandidateStats(stats) {
+        let observedIceCandidate = this.observedIceCandidates.get(stats.id);
+        if (!observedIceCandidate) {
+            if (!stats.timestamp || !stats.id) {
+                return logger.warn(`ObservedPeerConnection received an invalid IceCandidateStats (missing timestamp OR id field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`, stats);
+            }
+            observedIceCandidate = new ObservedIceCandidate_1.ObservedIceCandidate(stats.timestamp, stats.id, this);
+            this.observedIceCandidates.set(stats.id, observedIceCandidate);
+            this.emit('added-ice-candidate', observedIceCandidate);
+        }
+        observedIceCandidate.update(stats);
+        return observedIceCandidate;
+    }
+    _updateIceCandidatePairStats(stats) {
+        let observedIceCandidatePair = this.observedIceCandidatesPair.get(stats.id);
+        if (!observedIceCandidatePair) {
+            if (!stats.timestamp || !stats.id) {
+                return logger.warn(`ObservedPeerConnection received an invalid IceCandidateStats (missing timestamp OR id field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`, stats);
+            }
+            observedIceCandidatePair = new ObservedIceCandidatePair_1.ObservedIceCandidatePair(stats.timestamp, stats.id, this);
+            this.observedIceCandidatesPair.set(stats.id, observedIceCandidatePair);
+            this.emit('added-ice-candidate-pair', observedIceCandidatePair);
+        }
+        observedIceCandidatePair.update(stats);
+        return observedIceCandidatePair;
+    }
+    _updateIceTransportStats(stats) {
+        let observedIceTransport = this.observedIceTransports.get(stats.id);
+        if (!observedIceTransport) {
+            if (!stats.timestamp || !stats.id) {
+                return logger.warn(`ObservedPeerConnection received an invalid IceCandidateStats (missing timestamp OR id field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`, stats);
+            }
+            observedIceTransport = new ObservedIceTransport_1.ObservedIceTransport(stats.timestamp, stats.id, this);
+            this.observedIceTransports.set(stats.id, observedIceTransport);
+            this.emit('added-ice-transport', observedIceTransport);
+        }
+        observedIceTransport.update(stats);
+        return observedIceTransport;
+    }
+    _updateInboundRtpStats(stats) {
+        let observedInboundRtp = this.observedInboundRtps.get(stats.ssrc);
+        if (!observedInboundRtp) {
+            if (!stats.timestamp || !stats.id || !stats.ssrc || !stats.kind || !stats.trackIdentifier) {
+                return logger.warn(`ObservedPeerConnection received an invalid InboundRtpStats (missing timestamp OR id OR ssrc OR kind OR trackIdentifier field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`, stats);
+            }
+            observedInboundRtp = new ObservedInboundRtp_1.ObservedInboundRtp(stats.timestamp, stats.id, stats.ssrc, stats.kind, stats.trackIdentifier, this);
+            this.observedInboundRtps.set(stats.ssrc, observedInboundRtp);
+            this.emit('added-inbound-rtp', observedInboundRtp);
+        }
+        observedInboundRtp.update(stats);
+        return observedInboundRtp;
+    }
+    _updateInboundTrackSample(stats) {
+        let observedInboundTrack = this.observedInboundTracks.get(stats.id);
+        if (!observedInboundTrack) {
+            if (!stats.timestamp || !stats.id || !stats.kind) {
+                return logger.warn(`ObservedPeerConnection received an invalid InboundTrackSample (missing timestamp OR id OR kind field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`, stats);
+            }
+            const inboundRtp = [...this.observedInboundRtps.values()].find((inbRtp) => inbRtp.trackIdentifier === stats.id);
+            const mediaPlayout = inboundRtp ?
+                [...this.observedMediaPlayouts.values()].find((mp) => mp.id === inboundRtp.playoutId) : undefined;
+            observedInboundTrack = new ObservedInboundTrack_1.ObservedInboundTrack(stats.timestamp, stats.id, stats.kind, this, inboundRtp, mediaPlayout);
+            this.observedInboundTracks.set(stats.id, observedInboundTrack);
+            this.emit('added-inbound-track', observedInboundTrack);
+        }
+        observedInboundTrack.update(stats);
+        return observedInboundTrack;
+    }
+    _updateMediaPlayoutStats(stats) {
+        let observedMediaPlayout = this.observedMediaPlayouts.get(stats.id);
+        if (!observedMediaPlayout) {
+            if (!stats.timestamp || !stats.id || !stats.kind) {
+                return logger.warn(`ObservedPeerConnection received an invalid InboundRtpStats (missing timestamp OR id OR kind OR trackIdentifier field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`, stats);
+            }
+            observedMediaPlayout = new ObservedMediaPlayout_1.ObservedMediaPlayout(stats.timestamp, stats.id, stats.kind, this);
+            this.observedMediaPlayouts.set(stats.id, observedMediaPlayout);
+            this.emit('added-media-playout', observedMediaPlayout);
+        }
+        observedMediaPlayout.update(stats);
+        return observedMediaPlayout;
+    }
+    _updateMediaSourceStats(stats) {
+        let observedMediaSource = this.observedMediaSources.get(stats.id);
+        if (!observedMediaSource) {
+            if (!stats.timestamp || !stats.id || !stats.kind) {
+                return logger.warn(`ObservedPeerConnection received an invalid InboundRtpStats (missing timestamp OR id OR kind field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`, stats);
+            }
+            observedMediaSource = new ObservedMediaSource_1.ObservedMediaSource(stats.timestamp, stats.id, stats.kind, this);
+            this.observedMediaSources.set(stats.id, observedMediaSource);
+            this.emit('added-media-source', observedMediaSource);
+        }
+        observedMediaSource.update(stats);
+        return observedMediaSource;
+    }
+    _updateOutboundRtpStats(stats) {
+        let observedOutboundRtp = this.observedOutboundRtps.get(stats.ssrc);
+        if (!observedOutboundRtp) {
+            if (!stats.timestamp || !stats.id || !stats.ssrc || !stats.kind) {
+                return logger.warn(`ObservedPeerConnection received an invalid OutboundRtpStats (missing timestamp OR id OR ssrc OR kind field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`, stats);
+            }
+            observedOutboundRtp = new ObservedOutboundRtp_1.ObservedOutboundRtp(stats.timestamp, stats.id, stats.ssrc, stats.kind, this);
+            this.observedOutboundRtps.set(stats.ssrc, observedOutboundRtp);
+            this.emit('added-outbound-rtp', observedOutboundRtp);
+        }
+        observedOutboundRtp.update(stats);
+        return observedOutboundRtp;
+    }
+    _updateOutboundTrackSample(stats) {
+        let observedOutboundTrack = this.observedOutboundTracks.get(stats.id);
+        if (!observedOutboundTrack) {
+            if (!stats.timestamp || !stats.id || !stats.kind) {
+                return logger.warn(`ObservedPeerConnection received an invalid OutboundTrackSample (missing timestamp OR id OR kind field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`, stats);
+            }
+            const observedMediaSource = [...this.observedMediaSources.values()].find((mediaSource) => mediaSource.trackIdentifier === stats.id);
+            const outboundRtps = observedMediaSource
+                ? [...this.observedOutboundRtps.values()].filter((outboundRtp) => outboundRtp.mediaSourceId === observedMediaSource?.id) : undefined;
+            observedOutboundTrack = new ObservedOutboundTrack_1.ObservedOutboundTrack(stats.timestamp, stats.id, stats.kind, this, outboundRtps, observedMediaSource);
+            this.observedOutboundTracks.set(stats.id, observedOutboundTrack);
+            this.emit('added-outbound-track', observedOutboundTrack);
+        }
+        observedOutboundTrack.update(stats);
+        return observedOutboundTrack;
+    }
+    _updatePeerConnectionTransportStats(stats) {
+        let observedPeerConnectionTransport = this.observedPeerConnectionTransports.get(stats.id);
+        if (!observedPeerConnectionTransport) {
+            if (!stats.timestamp || !stats.id) {
+                return logger.warn(`ObservedPeerConnection received an invalid PeerConnectionTransportStats (missing timestamp OR id field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`, stats);
+            }
+            observedPeerConnectionTransport = new ObservedPeerConnectionTransport_1.ObservedPeerConnectionTransport(stats.timestamp, stats.id, this);
+            this.observedPeerConnectionTransports.set(stats.id, observedPeerConnectionTransport);
+            this.emit('added-peer-connection-transport', observedPeerConnectionTransport);
+        }
+        observedPeerConnectionTransport.update(stats);
+        return observedPeerConnectionTransport;
+    }
+    _updateRemoteInboundRtpStats(stats) {
+        let observedRemoteInboundRtp = this.observedRemoteInboundRtps.get(stats.ssrc);
+        if (!observedRemoteInboundRtp) {
+            if (!stats.timestamp || !stats.id || !stats.ssrc || !stats.kind) {
+                return logger.warn(`ObservedPeerConnection received an invalid RemoteInboundRtpStats (missing timestamp OR id OR ssrc OR kind field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`, stats);
+            }
+            observedRemoteInboundRtp = new ObservedRemoteInboundRtp_1.ObservedRemoteInboundRtp(stats.timestamp, stats.id, stats.ssrc, stats.kind, this);
+            this.observedRemoteInboundRtps.set(stats.ssrc, observedRemoteInboundRtp);
+            this.emit('added-remote-inbound-rtp', observedRemoteInboundRtp);
+        }
+        observedRemoteInboundRtp.update(stats);
+        return observedRemoteInboundRtp;
+    }
+    _updateRemoteOutboundRtpStats(stats) {
+        let observedRemoteOutboundRtp = this.observedRemoteOutboundRtps.get(stats.ssrc);
+        if (!observedRemoteOutboundRtp) {
+            if (!stats.timestamp || !stats.id || !stats.ssrc || !stats.kind) {
+                return logger.warn(`ObservedPeerConnection received an invalid RemoteOutboundRtpStats (missing timestamp OR id OR ssrc OR kind field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`, stats);
+            }
+            observedRemoteOutboundRtp = new ObservedRemoteOutboundRtp_1.ObservedRemoteOutboundRtp(stats.timestamp, stats.id, stats.ssrc, stats.kind, this);
+            this.observedRemoteOutboundRtps.set(stats.ssrc, observedRemoteOutboundRtp);
+            this.emit('added-remote-outbound-rtp', observedRemoteOutboundRtp);
         }
-        let counter = 0;
-        let weight = 0;
-        let totalScore = 0;
-        for (const score of this._stabilityScores) {
-            weight += 1;
-            counter += weight;
-            totalScore += weight * score;
-        }
-        const weightedStabilityScore = totalScore / counter;
-        let sumTrackScores = 0;
-        for (const trackScore of trackScores) {
-            sumTrackScores += trackScore.score;
-        }
-        const avgTrackScores = sumTrackScores / trackScores.length;
-        const score = {
-            remarks: [{
-                    severity: 'none',
-                    text: `Peer Connection stability score: ${weightedStabilityScore}`,
-                },
-                {
-                    severity: 'none',
-                    text: `Avg. Track score: ${avgTrackScores}`,
-                }],
-            score: Math.round(((weightedStabilityScore + avgTrackScores) * 5 * 100)) / 100.0,
-            timestamp: (_f = this._statsTimestamp) !== null && _f !== void 0 ? _f : Date.now(),
-        };
-        for (const pendingIssue of this.ωpendingIssuesForScores) {
-            switch (pendingIssue.severity) {
-                case 'critical':
-                    score.score = 0.0;
-                    break;
-                case 'major':
-                    score.score *= 0.5;
-                    break;
-                case 'minor':
-                    score.score *= 0.8;
-                    break;
-            }
-            score.remarks.push({
-                severity: pendingIssue.severity,
-                text: (_g = pendingIssue.description) !== null && _g !== void 0 ? _g : 'Issue occurred',
-            });
-        }
-        this.ωpendingIssuesForScores = [];
-        this.score = score;
-        this.emit('score', score);
+        observedRemoteOutboundRtp.update(stats);
+        return observedRemoteOutboundRtp;
     }
 }
 exports.ObservedPeerConnection = ObservedPeerConnection;