@observertc/observer-js 0.42.9 → 1.0.0-5f150eb.0

package/src/ObservedIceCandidate.ts

@@ -0,0 +1,64 @@
+import { ObservedPeerConnection } from './ObservedPeerConnection';
+import { IceCandidateStats } from './schema/ClientSample';
+
+export class ObservedIceCandidate implements IceCandidateStats {
+	private _visited = false;
+	public appData?: Record<string, unknown>;
+
+	transportId?: string | undefined;
+	address?: string | undefined;
+	port?: number | undefined;
+	protocol?: string | undefined;
+	candidateType?: string | undefined;
+	priority?: number | undefined;
+	url?: string | undefined;
+	relayProtocol?: string | undefined;
+	foundation?: string | undefined;
+	relatedAddress?: string | undefined;
+	relatedPort?: number | undefined;
+	usernameFragment?: string | undefined;
+	tcpType?: string | undefined;
+	attachments?: Record<string, unknown> | undefined;
+
+	public constructor(
+		public timestamp: number,
+		public id: string,
+		private readonly _peerConnection: ObservedPeerConnection
+	) {}
+
+	public get visited() {
+		const visited = this._visited;
+
+		this._visited = false;
+
+		return visited;
+	}
+
+	public getPeerConnection() {
+		return this._peerConnection;
+	}
+
+	public getIceTransport() {
+		return this._peerConnection.observedIceTransports.get(this.transportId ?? '');
+	}
+
+	public update(stats: IceCandidateStats) {
+		this._visited = true;
+
+		this.timestamp = stats.timestamp;
+		this.transportId = stats.transportId;
+		this.address = stats.address;
+		this.port = stats.port;
+		this.protocol = stats.protocol;
+		this.candidateType = stats.candidateType;
+		this.priority = stats.priority;
+		this.url = stats.url;
+		this.relayProtocol = stats.relayProtocol;
+		this.foundation = stats.foundation;
+		this.relatedAddress = stats.relatedAddress;
+		this.relatedPort = stats.relatedPort;
+		this.usernameFragment = stats.usernameFragment;
+		this.tcpType = stats.tcpType;
+		this.attachments = stats.attachments;
+	}
+}

package/src/ObservedIceCandidatePair.ts

@@ -0,0 +1,134 @@
+import { ObservedPeerConnection } from './ObservedPeerConnection';
+import { IceCandidatePairStats } from './schema/ClientSample';
+
+export class ObservedIceCandidatePair implements IceCandidatePairStats {
+	private _visited = false;
+	public appData?: Record<string, unknown>;
+
+	transportId?: string | undefined;
+	localCandidateId?: string | undefined;
+	remoteCandidateId?: string | undefined;
+	state?: 'new' | 'in-progress' | 'waiting' | 'failed' | 'succeeded' | undefined;
+	nominated?: boolean | undefined;
+	packetsSent?: number | undefined;
+	packetsReceived?: number | undefined;
+	bytesSent?: number | undefined;
+	bytesReceived?: number | undefined;
+	lastPacketSentTimestamp?: number | undefined;
+	lastPacketReceivedTimestamp?: number | undefined;
+	totalRoundTripTime?: number | undefined;
+	currentRoundTripTime?: number | undefined;
+	availableOutgoingBitrate?: number | undefined;
+	availableIncomingBitrate?: number | undefined;
+	requestsReceived?: number | undefined;
+	requestsSent?: number | undefined;
+	responsesReceived?: number | undefined;
+	responsesSent?: number | undefined;
+	consentRequestsSent?: number | undefined;
+	packetsDiscardedOnSend?: number | undefined;
+	bytesDiscardedOnSend?: number | undefined;
+	attachments?: Record<string, unknown> | undefined;
+
+	public deltaBytesSent = 0;
+	public deltaBytesReceived = 0;
+	public deltaPacketsSent = 0;
+	public deltaPacketsReceived = 0;
+
+	public constructor(
+		public timestamp: number,
+		public id: string,
+		private readonly _peerConnection: ObservedPeerConnection,
+	) {
+	}
+
+	public get visited() {
+		const visited = this._visited;
+	
+		this._visited = false;
+	
+		return visited;
+	}
+
+	public getPeerConnection() {
+		return this._peerConnection;
+	}
+
+	public getIceTransport() {
+		return this._peerConnection.observedIceTransports.get(this.transportId ?? '');
+	}
+
+	public getLocalCandidate() {
+		return this._peerConnection.observedIceCandidates.get(this.localCandidateId ?? '');
+	}
+
+	public getRemoteCandidate() {
+		return this._peerConnection.observedIceCandidates.get(this.remoteCandidateId ?? '');
+	}
+
+	public update(stats: IceCandidatePairStats) {
+		this._visited = true;
+
+		if (this.packetsSent && stats.packetsSent && stats.packetsSent >= this.packetsSent) {
+			this.deltaPacketsSent = stats.packetsSent - this.packetsSent;
+		} else {
+			this.deltaPacketsSent = 0;
+		}
+		if (this.packetsReceived && stats.packetsReceived && stats.packetsReceived >= this.packetsReceived) {
+			this.deltaPacketsReceived = stats.packetsReceived - this.packetsReceived;
+		} else {
+			this.deltaPacketsReceived = 0;
+		}
+		if (this.bytesSent && stats.bytesSent && stats.bytesSent >= this.bytesSent) {
+			this.deltaBytesSent = stats.bytesSent - this.bytesSent;
+		} else {
+			this.deltaBytesSent = 0;
+		}
+		if (this.bytesReceived && stats.bytesReceived && stats.bytesReceived >= this.bytesReceived) {
+			this.deltaBytesReceived = stats.bytesReceived - this.bytesReceived;
+		} else {
+			this.deltaBytesReceived = 0;
+		}
+
+		this.timestamp = stats.timestamp;
+		this.transportId = stats.transportId;
+		this.localCandidateId = stats.localCandidateId;
+		this.remoteCandidateId = stats.remoteCandidateId;
+		this.state = this._convertState(stats.state);
+		this.nominated = stats.nominated;
+		this.packetsSent = stats.packetsSent;
+		this.packetsReceived = stats.packetsReceived;
+		this.bytesSent = stats.bytesSent;
+		this.bytesReceived = stats.bytesReceived;
+		this.lastPacketSentTimestamp = stats.lastPacketSentTimestamp;
+		this.lastPacketReceivedTimestamp = stats.lastPacketReceivedTimestamp;
+		this.totalRoundTripTime = stats.totalRoundTripTime;
+		this.currentRoundTripTime = stats.currentRoundTripTime;
+		this.availableOutgoingBitrate = stats.availableOutgoingBitrate;
+		this.availableIncomingBitrate = stats.availableIncomingBitrate;
+		this.requestsReceived = stats.requestsReceived;
+		this.requestsSent = stats.requestsSent;
+		this.responsesReceived = stats.responsesReceived;
+		this.responsesSent = stats.responsesSent;
+		this.consentRequestsSent = stats.consentRequestsSent;
+		this.packetsDiscardedOnSend = stats.packetsDiscardedOnSend;
+		this.bytesDiscardedOnSend = stats.bytesDiscardedOnSend;
+		this.attachments = stats.attachments;
+	}
+
+	private _convertState(state: string | undefined) {
+		switch (state) {
+			case 'new':
+			case 'in-progress':
+			case 'waiting':
+			case 'failed':
+			case 'succeeded':
+				return state;
+			case 'cancelled':
+				return 'failed';
+			case 'inprogress':
+				return 'in-progress';
+			default:
+				return undefined;
+		}
+	}
+}

package/src/ObservedIceTransport.ts

@@ -0,0 +1,99 @@
+import { ObservedPeerConnection } from './ObservedPeerConnection';
+import { IceTransportStats } from './schema/ClientSample';
+
+export class ObservedIceTransport implements IceTransportStats {
+	private _visited = false;
+	public appData?: Record<string, unknown>;
+
+	packetsSent?: number | undefined;
+	packetsReceived?: number | undefined;
+	bytesSent?: number | undefined;
+	bytesReceived?: number | undefined;
+	iceRole?: string | undefined;
+	iceLocalUsernameFragment?: string | undefined;
+	dtlsState?: string | undefined;
+	iceState?: string | undefined;
+	selectedCandidatePairId?: string | undefined;
+	localCertificateId?: string | undefined;
+	remoteCertificateId?: string | undefined;
+	tlsVersion?: string | undefined;
+	dtlsCipher?: string | undefined;
+	dtlsRole?: string | undefined;
+	srtpCipher?: string | undefined;
+	selectedCandidatePairChanges?: number | undefined;
+	attachments?: Record<string, unknown> | undefined;
+
+	public deltaPacketsReceived = 0;
+	public deltaPacketsSent = 0;
+	public deltaBytesReceived = 0;
+	public deltaBytesSent = 0;
+
+	public constructor(
+		public timestamp: number,
+		public id: string,
+		private readonly _peerConnection: ObservedPeerConnection
+	) {}
+
+	public get visited() {
+		const visited = this._visited;
+
+		this._visited = false;
+
+		return visited;
+	}
+
+	public getPeerConnection() {
+		return this._peerConnection;
+	}
+
+	public getSelectedCandidatePair() {
+		return this._peerConnection.observedIceCandidatesPair.get(this.selectedCandidatePairId ?? '');
+	}
+
+	public update(stats: IceTransportStats) {
+		this._visited = true;
+
+		if (this.bytesReceived !== undefined && stats.bytesReceived !== undefined && this.bytesReceived <= stats.bytesReceived) {
+			this.deltaBytesReceived = stats.bytesReceived - this.bytesReceived;
+		} else {
+			this.deltaBytesReceived = 0;
+		}
+		
+		if (this.bytesSent !== undefined && stats.bytesSent !== undefined && this.bytesSent <= stats.bytesSent) {
+			this.deltaBytesSent = stats.bytesSent - this.bytesSent;
+		} else {
+			this.deltaBytesSent = 0;
+		}
+
+		if (this.packetsReceived !== undefined && stats.packetsReceived !== undefined && this.packetsReceived <= stats.packetsReceived) {
+			this.deltaPacketsReceived = stats.packetsReceived - this.packetsReceived;
+		} else {
+			this.deltaPacketsReceived = 0;
+		}
+		
+		if (this.packetsSent !== undefined && stats.packetsSent !== undefined && this.packetsSent <= stats.packetsSent) {
+			this.deltaPacketsSent = stats.packetsSent - this.packetsSent;
+		} else {
+			this.deltaPacketsSent = 0;
+		}
+
+		this.timestamp = stats.timestamp;
+		this.packetsSent = stats.packetsSent;
+		this.packetsReceived = stats.packetsReceived;
+		this.bytesSent = stats.bytesSent;
+		this.bytesReceived = stats.bytesReceived;
+		this.iceRole = stats.iceRole;
+		this.iceLocalUsernameFragment = stats.iceLocalUsernameFragment;
+		this.dtlsState = stats.dtlsState;
+		this.iceState = stats.iceState;
+		this.selectedCandidatePairId = stats.selectedCandidatePairId;
+		this.localCertificateId = stats.localCertificateId;
+		this.remoteCertificateId = stats.remoteCertificateId;
+		this.tlsVersion = stats.tlsVersion;
+		this.dtlsCipher = stats.dtlsCipher;
+		this.dtlsRole = stats.dtlsRole;
+		this.srtpCipher = stats.srtpCipher;
+		this.selectedCandidatePairChanges = stats.selectedCandidatePairChanges;
+		this.attachments = stats.attachments;
+	}
+}

package/src/ObservedInboundRtp.ts

@@ -0,0 +1,205 @@
+import { MediaKind } from './common/types';
+import { ObservedPeerConnection } from './ObservedPeerConnection';
+import { InboundRtpStats } from './schema/ClientSample';
+
+export class ObservedInboundRtp implements InboundRtpStats {
+	public appData?: Record<string, unknown>;
+
+	private _visited = false;
+
+	transportId?: string | undefined;
+	codecId?: string | undefined;
+	packetsReceived?: number | undefined;
+	packetsLost?: number | undefined;
+	mid?: string | undefined;
+	remoteId?: string | undefined;
+	framesDecoded?: number | undefined;
+	keyFramesDecoded?: number | undefined;
+	framesRendered?: number | undefined;
+	framesDropped?: number | undefined;
+	frameWidth?: number | undefined;
+	frameHeight?: number | undefined;
+	framesPerSecond?: number | undefined;
+	qpSum?: number | undefined;
+	totalDecodeTime?: number | undefined;
+	totalInterFrameDelay?: number | undefined;
+	totalSquaredInterFrameDelay?: number | undefined;
+	pauseCount?: number | undefined;
+	totalPausesDuration?: number | undefined;
+	freezeCount?: number | undefined;
+	totalFreezesDuration?: number | undefined;
+	lastPacketReceivedTimestamp?: number | undefined;
+	headerBytesReceived?: number | undefined;
+	packetsDiscarded?: number | undefined;
+	fecBytesReceived?: number | undefined;
+	fecPacketsReceived?: number | undefined;
+	fecPacketsDiscarded?: number | undefined;
+	bytesReceived?: number | undefined;
+	nackCount?: number | undefined;
+	firCount?: number | undefined;
+	pliCount?: number | undefined;
+	totalProcessingDelay?: number | undefined;
+	estimatedPlayoutTimestamp?: number | undefined;
+	jitterBufferDelay?: number | undefined;
+	jitterBufferTargetDelay?: number | undefined;
+	jitterBufferEmittedCount?: number | undefined;
+	jitterBufferMinimumDelay?: number | undefined;
+	totalSamplesReceived?: number | undefined;
+	concealedSamples?: number | undefined;
+	silentConcealedSamples?: number | undefined;
+	concealmentEvents?: number | undefined;
+	insertedSamplesForDeceleration?: number | undefined;
+	removedSamplesForAcceleration?: number | undefined;
+	audioLevel?: number | undefined;
+	totalAudioEnergy?: number | undefined;
+	totalSamplesDuration?: number | undefined;
+	framesReceived?: number | undefined;
+	decoderImplementation?: string | undefined;
+	playoutId?: string | undefined;
+	powerEfficientDecoder?: boolean | undefined;
+	framesAssembledFromMultiplePackets?: number | undefined;
+	totalAssemblyTime?: number | undefined;
+	retransmittedPacketsReceived?: number | undefined;
+	retransmittedBytesReceived?: number | undefined;
+	rtxSsrc?: number | undefined;
+	fecSsrc?: number | undefined;
+	totalCorruptionProbability?: number | undefined;
+	totalSquaredCorruptionProbability?: number | undefined;
+	corruptionMeasurements?: number | undefined;
+	attachments?: Record<string, unknown> | undefined;
+	jitter?: number | undefined;
+	
+	public bitrate = 0;
+	public fractionLost?: number;
+	public bitPerPixel = 0;
+
+	public deltaLostPackets = 0;
+	public deltaReceivedPackets = 0;
+	public deltaBytesReceived = 0;
+	public deltaReceivedSamples = 0;
+	public deltaSilentConcealedSamples = 0;
+
+	public constructor(
+		public timestamp: number,
+		public id: string,
+		public ssrc: number,
+		public kind: MediaKind,
+		public trackIdentifier: string,
+		private readonly _peerConnection: ObservedPeerConnection
+	) {}
+
+	public get visited() {
+		const visited = this._visited;
+
+		this._visited = false;
+
+		return visited;
+	}
+
+	public getPeerConnection() {
+		return this._peerConnection;
+	}
+
+	public getRemoteOutboundRtp() {
+		return this._peerConnection.observedRemoteOutboundRtps.get(this.ssrc);
+	}
+
+	public getIceTransport() {
+		return this._peerConnection.observedIceTransports.get(this.transportId ?? '');
+	}
+
+	public getCodec() {
+		return this._peerConnection.observedCodecs.get(this.codecId ?? '');
+	}
+
+	public getMediaPlayout() {
+		return this._peerConnection.observedMediaPlayouts.get(this.playoutId ?? '');
+	}
+
+	public getTrack() {
+		return this._peerConnection.observedInboundTracks.get(this.trackIdentifier);
+	}
+
+	public update(stats: InboundRtpStats) {
+		this._visited = true;
+		this.deltaBytesReceived = 0;
+		this.deltaLostPackets = 0;
+		this.deltaReceivedPackets = 0;
+		this.deltaReceivedSamples = 0;
+		this.deltaSilentConcealedSamples = 0;
+		this.bitrate = 0;
+		this.jitter = undefined;
+		this.fractionLost = undefined;
+		this.bitPerPixel = 0;
+
+		const elapsedTimeInMs = stats.timestamp - this.timestamp;
+
+		if (elapsedTimeInMs) {
+			// update metrics here
+			if (this.bytesReceived && stats.bytesReceived && this.bytesReceived < stats.bytesReceived) {
+				this.bitrate = ((stats.bytesReceived - (this.bytesReceived ?? 0)) * 8) / elapsedTimeInMs;
+			}
+			if (this.packetsLost && stats.packetsLost && this.packetsLost < stats.packetsLost) {
+				this.deltaLostPackets = stats.packetsLost - this.packetsLost;
+			}
+			if (this.packetsReceived && stats.packetsReceived && this.packetsReceived < stats.packetsReceived) {
+				this.deltaReceivedPackets = stats.packetsReceived - this.packetsReceived;
+			}
+			if (this.totalSamplesReceived && stats.totalSamplesReceived && this.totalSamplesReceived < stats.totalSamplesReceived) {
+				this.deltaReceivedSamples = stats.totalSamplesReceived - this.totalSamplesReceived;
+			}
+			if (this.silentConcealedSamples && stats.silentConcealedSamples && this.silentConcealedSamples < stats.silentConcealedSamples) {
+				this.deltaSilentConcealedSamples = stats.silentConcealedSamples - this.silentConcealedSamples;
+			}
+			if (stats.bytesReceived && this.framesReceived && stats.framesReceived && this.framesReceived < stats.framesReceived) {
+				this.bitPerPixel = (stats.bytesReceived - (this.bytesReceived ?? 0)) / (stats.framesReceived - this.framesReceived);
+			}
+			if (this.deltaLostPackets && this.deltaReceivedPackets) {
+				this.fractionLost = this.deltaLostPackets / (this.deltaLostPackets + this.deltaReceivedPackets);
+			}
+		}
+
+		this.timestamp = stats.timestamp;
+		this.transportId = stats.transportId;
+		this.codecId = stats.codecId;
+		this.packetsReceived = stats.packetsReceived;
+		this.packetsLost = stats.packetsLost;
+		this.mid = stats.mid;
+		this.remoteId = stats.remoteId;
+		this.framesDecoded = stats.framesDecoded;
+		this.keyFramesDecoded = stats.keyFramesDecoded;
+		this.framesRendered = stats.framesRendered;
+		this.framesDropped = stats.framesDropped;
+		this.frameWidth = stats.frameWidth;
+		this.frameHeight = stats.frameHeight;
+		this.framesPerSecond = stats.framesPerSecond;
+		this.qpSum = stats.qpSum;
+		this.totalDecodeTime = stats.totalDecodeTime;
+		this.totalInterFrameDelay = stats.totalInterFrameDelay;
+		this.totalSquaredInterFrameDelay = stats.totalSquaredInterFrameDelay;
+		this.pauseCount = stats.pauseCount;
+		this.totalPausesDuration = stats.totalPausesDuration;
+		this.freezeCount = stats.freezeCount;
+		this.totalFreezesDuration = stats.totalFreezesDuration;
+		this.lastPacketReceivedTimestamp = stats.lastPacketReceivedTimestamp;
+		this.headerBytesReceived = stats.headerBytesReceived;
+		this.packetsDiscarded = stats.packetsDiscarded;
+		this.fecBytesReceived = stats.fecBytesReceived;
+		this.fecPacketsReceived = stats.fecPacketsReceived;
+		this.fecPacketsDiscarded = stats.fecPacketsDiscarded;
+		this.bytesReceived = stats.bytesReceived;
+		this.nackCount = stats.nackCount;
+		this.firCount = stats.firCount;
+		this.pliCount = stats.pliCount;
+		this.totalProcessingDelay = stats.totalProcessingDelay;
+		this.estimatedPlayoutTimestamp = stats.estimatedPlayoutTimestamp;
+		this.jitterBufferDelay = stats.jitterBufferDelay;
+		this.jitterBufferTargetDelay = stats.jitterBufferTargetDelay;
+		this.jitterBufferEmittedCount = stats.jitterBufferEmittedCount;
+		this.jitterBufferMinimumDelay = stats.jitterBufferMinimumDelay;
+		this.totalSamplesReceived = stats.totalSamplesReceived;
+		this.concealedSamples = stats.concealedSamples;
+		this.silentConcealedSamples = stats.silentConcealedSamples;
+		this.concealmentEvents = stats.concealmentEvents;
+	}
+}

package/src/ObservedInboundTrack.ts

@@ -0,0 +1,105 @@
+import { CalculatedScore } from './scores/CalculatedScore';
+import { MediaKind } from './common/types';
+import { InboundTrackSample } from './schema/ClientSample';
+import { Detectors } from './detectors/Detectors';
+import { ObservedPeerConnection } from './ObservedPeerConnection';
+import { ObservedInboundRtp } from './ObservedInboundRtp';
+import { ObservedMediaPlayout } from './ObservedMediaPlayout';
+import { InboundTrackReport } from './Reports';
+
+export class ObservedInboundTrack implements InboundTrackSample {
+	public readonly detectors: Detectors;
+	public readonly calculatedScore: CalculatedScore = {
+		weight: 1,
+		value: undefined,
+	};
+	public appData?: Record<string, unknown>;
+	public report: InboundTrackReport;
+
+	private _visited = false;
+
+	public addedAt?: number | undefined;
+	public removedAt?: number | undefined;
+
+	public muted?: boolean;
+	
+	attachments?: Record<string, unknown> | undefined;
+
+	constructor(
+		public timestamp: number,
+		public readonly id: string,
+		public readonly kind: MediaKind,
+		private readonly _peerConnection: ObservedPeerConnection,
+		private readonly _inboundRtp?: ObservedInboundRtp,
+		private readonly _mediaPlayout?: ObservedMediaPlayout,
+	) {
+		this.detectors = new Detectors();
+
+		this.report = {
+			trackId: this.id,
+			kind: this.kind,
+			fractionLostDistribution: {
+				gtOrEq050: 0,
+				lt001: 0,
+				lt005: 0,
+				lt010: 0,
+				lt020: 0,
+				lt050: 0,
+				count: 0,
+				sum: 0,
+			},
+		};
+	}
+
+	public get score() { 
+		return this.calculatedScore.value; 
+	}
+
+	public get visited() {
+		const visited = this._visited;
+
+		this._visited = false;
+
+		return visited;
+	}
+
+	public getPeerConnection() {
+		return this._peerConnection;
+	}
+
+	public getInboundRtp() {
+		return this._inboundRtp;
+	}
+
+	public getMediaPlayout() {
+		return this._mediaPlayout;
+	}
+
+	public getRemoteOutboundTrack() {
+		return this._peerConnection.client.call.remoteTrackResolver?.resolveRemoteOutboundTrack(this);
+	}
+
+	public update(stats: InboundTrackSample): void {
+		this._visited = true;
+
+		this.timestamp = stats.timestamp;
+		this.calculatedScore.value = stats.score;
+		this.attachments = stats.attachments;
+
+		const fl = this._inboundRtp?.fractionLost;
+
+		if (fl !== undefined) {
+			if (fl < 0.01) this.report.fractionLostDistribution.lt001 += 1;
+			else if (fl < 0.05) this.report.fractionLostDistribution.lt005 += 1;
+			else if (fl < 0.1) this.report.fractionLostDistribution.lt010 += 1;
+			else if (fl < 0.2) this.report.fractionLostDistribution.lt020 += 1;
+			else if (fl < 0.5) this.report.fractionLostDistribution.lt050 += 1;
+			else this.report.fractionLostDistribution.gtOrEq050 += 1;
+
+			this.report.fractionLostDistribution.count += 1;
+			this.report.fractionLostDistribution.sum += fl;
+		}
+
+		this.detectors.update();
+	}
+}

package/src/ObservedMediaPlayout.ts

@@ -0,0 +1,49 @@
+import { MediaKind } from './common/types';
+import { ObservedPeerConnection } from './ObservedPeerConnection';
+import { MediaPlayoutStats } from './schema/ClientSample';
+
+export class ObservedMediaPlayout implements MediaPlayoutStats {
+	private _visited = false;
+	public appData?: Record<string, unknown>;
+
+	synthesizedSamplesDuration?: number | undefined;
+	synthesizedSamplesEvents?: number | undefined;
+	totalSamplesDuration?: number | undefined;
+	totalPlayoutDelay?: number | undefined;
+	totalSamplesCount?: number | undefined;
+	attachments?: Record<string, unknown> | undefined;
+
+	public constructor(
+		public timestamp: number,
+		public id: string,
+		public kind: MediaKind,
+		private readonly _peerConnection: ObservedPeerConnection
+	) {}
+
+	public get visited() {
+		const visited = this._visited;
+
+		this._visited = false;
+
+		return visited;
+	}
+
+	public getPeerConnection() {
+		return this._peerConnection;
+	}
+
+	
+
+	public update(stats: MediaPlayoutStats) {
+		this._visited = true;
+
+		this.timestamp = stats.timestamp;
+		this.synthesizedSamplesDuration = stats.synthesizedSamplesDuration;
+		this.synthesizedSamplesEvents = stats.synthesizedSamplesEvents;
+		this.totalSamplesDuration = stats.totalSamplesDuration;
+		this.totalPlayoutDelay = stats.totalPlayoutDelay;
+		this.totalSamplesCount = stats.totalSamplesCount;
+		this.attachments = stats.attachments;
+		
+	}
+}