@observertc/observer-js 0.30.1-beta → 0.30.3-beta

package/src/ObservedInboundTrack.ts

@@ -28,6 +28,14 @@ export type ObservedInboundTrackStats<K extends MediaKind> = ObservedInboundTrac
 	bitrate: number;
 	fractionLost: number;
 	rttInMs?: number;
+	lostPackets?: number;
+	receivedPackets?: number;
+	receivedFrames?: number;
+	decodedFrames?: number;
+	droppedFrames?: number;
+	receivedSamples?: number;
+	silentConcealedSamples?: number;
+	fractionLoss?: number;
 };
 
 // {
@@ -67,6 +75,8 @@ export class ObservedInboundTrack<Kind extends MediaKind> extends EventEmitter	{
 
 		return new ObservedInboundTrack<K>(model, peerConnection, storageProvider);
 	}
+	
+	public created = Date.now();
 
 	private readonly _stats = new Map<number, ObservedInboundTrackStats<Kind>>();
 	private readonly _execute = createSingleExecutor();
@@ -74,8 +84,27 @@ export class ObservedInboundTrack<Kind extends MediaKind> extends EventEmitter	{
 	private _closed = false;
 	private _updated = Date.now();
 	private _remoteOutboundTrack?: ObservedOutboundTrack<Kind>;
-	public bitrate = -1;
-	public rttInMs = -1;
+	public bitrate = 0;
+	public rttInMs?: number;
+	public fractionLoss = 0;
+
+	public totalLostPackets = 0;
+	public totalReceivedPackets = 0;
+	public totalBytesReceived = 0;
+	public totalReceivedFrames = 0;
+	public totalDecodedFrames = 0;
+	public totalDroppedFrames = 0;
+	public totalReceivedSamples = 0;
+	public totalSilentConcealedSamples = 0;
+	
+	public deltaLostPackets = 0;
+	public deltaReceivedPackets = 0;
+	public deltaBytesReceived = 0;
+	public deltaReceivedFrames = 0;
+	public deltaDecodedFrames = 0;
+	public deltaDroppedFrames = 0;
+	public deltaReceivedSamples = 0;
+	public deltaSilentConcealedSamples = 0;
 	
 	private constructor(
 		private readonly _model: Models.InboundTrack,
@@ -145,6 +174,10 @@ export class ObservedInboundTrack<Kind extends MediaKind> extends EventEmitter	{
 		return this.peerConnection.reports;
 	}
 
+	public get uptimeInMs() {
+		return this._updated - this.created;
+	}
+
 	public set remoteOutboundTrack(track: ObservedOutboundTrack<Kind> | undefined) {
 		if (this._closed) return;
 		if (this._remoteOutboundTrack) return;
@@ -174,6 +207,19 @@ export class ObservedInboundTrack<Kind extends MediaKind> extends EventEmitter	{
 			.finally(() => this.emit('close'));
 	}
 
+	public resetMetrics() {
+		this.bitrate = 0;
+		this.rttInMs = undefined;
+		this.deltaBytesReceived = 0;
+		this.deltaLostPackets = 0;
+		this.deltaReceivedFrames = 0;
+		this.deltaDecodedFrames = 0;
+		this.deltaDroppedFrames = 0;
+		this.deltaReceivedSamples = 0;
+		this.deltaSilentConcealedSamples = 0;
+		this.fractionLoss = 0;
+	}
+
 	public async update(sample: ObservedInboundTrackStatsUpdate<Kind>, timestamp: number) {
 		if (this._closed) return;
 		let executeSave = false;
@@ -189,6 +235,11 @@ export class ObservedInboundTrack<Kind extends MediaKind> extends EventEmitter	{
 			...sample,
 			timestamp,
 			sampleSeq: -1,
+
+			remoteClientId: sample.remoteClientId ?? this.remoteOutboundTrack?.peerConnection.client.clientId,
+			remoteUserId: this.remoteOutboundTrack?.peerConnection.client.userId,
+			remoteTrackId: this.remoteOutboundTrack?.trackId,
+			remotePeerConnectionId: this.remoteOutboundTrack?.peerConnection.peerConnectionId,
 		};
 
 		if (this.kind === 'audio') this.reports.addInboundAudioTrackReport(report);
@@ -211,19 +262,62 @@ export class ObservedInboundTrack<Kind extends MediaKind> extends EventEmitter	{
 		const lostPackets = (sample.packetsLost ?? 0) - (lastStat?.packetsLost ?? 0);
 		const receivedPackets = (sample.packetsReceived ?? 0) - (lastStat?.packetsReceived ?? 0);
 		const fractionLost = 0 < receivedPackets && 0 < lostPackets ? (lostPackets / (receivedPackets + lostPackets)) : 0;
+		let decodedFrames: number | undefined;
+		let droppedFrames: number | undefined;
+		let receivedFrames: number | undefined;
+		let silentConcealedSamples: number | undefined;
+
+		if (this.kind === 'video') {
+			const videoSample = sample as InboundVideoTrack;
+			const lastVideoStat = lastStat as InboundVideoTrack | undefined;
+
+			decodedFrames = (videoSample.framesDecoded ?? 0) - (lastVideoStat?.framesDecoded ?? 0);
+			droppedFrames = (videoSample.framesDropped ?? 0) - (lastVideoStat?.framesDropped ?? 0);
+			receivedFrames = (videoSample.framesReceived ?? 0) - (lastVideoStat?.framesReceived ?? 0);
+		} else if (this.kind === 'audio') {
+			const audioSample = sample as InboundAudioTrack;
+			const lastAudioStat = lastStat as InboundAudioTrack | undefined;
+
+			silentConcealedSamples = (audioSample.silentConcealedSamples ?? 0) - (lastAudioStat?.silentConcealedSamples ?? 0);
+		}
+
 		const stats: ObservedInboundTrackStats<Kind> = {
 			...sample,
 			fractionLost,
 			rttInMs,
 			bitrate,
 			ssrc: sample.ssrc,
+			lostPackets,
+			receivedPackets,
+			receivedFrames,
+			decodedFrames,
+			droppedFrames,
+			silentConcealedSamples,
 		};
 
 		this._stats.set(sample.ssrc, stats);
 
 		this.bitrate = [ ...this._stats.values() ].reduce((acc, stat) => acc + stat.bitrate, 0);
 		this.rttInMs = [ ...this._stats.values() ].reduce((acc, stat) => acc + (stat.rttInMs ?? 0), 0) / (this._stats.size || 1);
-		
+		this.totalLostPackets = [ ...this._stats.values() ].reduce((acc, stat) => acc + (stat.lostPackets ?? 0), 0);
+		this.totalReceivedPackets = [ ...this._stats.values() ].reduce((acc, stat) => acc + (stat.receivedPackets ?? 0), 0);
+		this.totalBytesReceived = [ ...this._stats.values() ].reduce((acc, stat) => acc + (stat.bytesReceived ?? 0), 0);
+		this.totalReceivedFrames = [ ...this._stats.values() ].reduce((acc, stat) => acc + (stat.receivedFrames ?? 0), 0);
+		this.totalDecodedFrames = [ ...this._stats.values() ].reduce((acc, stat) => acc + (stat.decodedFrames ?? 0), 0);
+		this.totalDroppedFrames = [ ...this._stats.values() ].reduce((acc, stat) => acc + (stat.droppedFrames ?? 0), 0);
+		this.totalReceivedSamples = [ ...this._stats.values() ].reduce((acc, stat) => acc + (stat.receivedSamples ?? 0), 0);
+		this.totalSilentConcealedSamples = [ ...this._stats.values() ].reduce((acc, stat) => acc + (stat.silentConcealedSamples ?? 0), 0);
+
+		this.deltaLostPackets = [ ...this._stats.values() ].reduce((acc, stat) => acc + (stat.lostPackets ?? 0), 0);
+		this.deltaReceivedPackets = [ ...this._stats.values() ].reduce((acc, stat) => acc + (stat.receivedPackets ?? 0), 0);
+		this.deltaBytesReceived = [ ...this._stats.values() ].reduce((acc, stat) => acc + (stat.bytesReceived ?? 0), 0);
+		this.deltaReceivedFrames = [ ...this._stats.values() ].reduce((acc, stat) => acc + (stat.receivedFrames ?? 0), 0);
+		this.deltaDecodedFrames = [ ...this._stats.values() ].reduce((acc, stat) => acc + (stat.decodedFrames ?? 0), 0);
+		this.deltaDroppedFrames = [ ...this._stats.values() ].reduce((acc, stat) => acc + (stat.droppedFrames ?? 0), 0);
+		this.deltaReceivedSamples = [ ...this._stats.values() ].reduce((acc, stat) => acc + (stat.receivedSamples ?? 0), 0);
+		this.deltaSilentConcealedSamples = [ ...this._stats.values() ].reduce((acc, stat) => acc + (stat.silentConcealedSamples ?? 0), 0);
+		this.fractionLoss = 0 < this.deltaReceivedPackets && 0 < this.deltaLostPackets ? (this.deltaLostPackets / (this.deltaReceivedPackets + this.deltaLostPackets)) : 0;
+
 		if (executeSave) await this._save();
 
 		this._updated = timestamp;

package/src/ObservedOutboundTrack.ts

@@ -25,6 +25,12 @@ export type ObservedOutboundTrackStats<K extends MediaKind> = ObservedOutboundTr
 	ssrc: number;
 	bitrate: number;
 	rttInMs?: number;
+
+	deltaLostPackets: number;
+	deltaSentPackets: number;
+	deltaSentBytes: number;
+	deltaSentFrames?: number;
+	deltaEncodedFrames?: number;
 };
 
 // export type ObservedOutboundTrackStatsUpdate<K extends MediaKind> = {
@@ -64,9 +70,22 @@ export class ObservedOutboundTrack<Kind extends MediaKind> extends EventEmitter
 		return new ObservedOutboundTrack<K>(model, peerConnection, storageProvider);
 	}
 
-	public bitrate?: number;
+	public bitrate = 0;
 	public rttInMs?: number;
 
+	public totalLostPackets = 0;
+	public totalSentPackets = 0;
+	public totalSentBytes = 0;
+	public totalSentFrames = 0;
+
+	public deltaLostPackets = 0;
+	public deltaSentPackets = 0;
+	public deltaSentBytes = 0;
+	public deltaSentFrames = 0;
+	public deltaEncodedFrames = 0;
+
+	public created = Date.now();
+
 	private readonly _stats = new Map<number, ObservedOutboundTrackStats<Kind>>();
 	private readonly _execute = createSingleExecutor();
 	
@@ -96,10 +115,6 @@ export class ObservedOutboundTrack<Kind extends MediaKind> extends EventEmitter
 		return this._model.sfuStreamId;
 	}
 
-	public get closed() {
-		return this._closed;
-	}
-
 	public get remoteInboundTracks(): ReadonlyMap<string, ObservedInboundTrack<Kind>> {
 		return this._remoteInboundTracks;
 	}
@@ -111,7 +126,19 @@ export class ObservedOutboundTrack<Kind extends MediaKind> extends EventEmitter
 	public get updated() {
 		return this._updated;
 	}
+	
+	public get stats(): ReadonlyMap<number, ObservedOutboundTrackStats<Kind>> {
+		return this._stats;
+	}
 
+	public get uptimeInMs() {
+		return this._updated - this.created;
+	}
+
+	public get closed() {
+		return this._closed;
+	}
+	
 	public close() {
 		if (this._closed) return;
 
@@ -122,8 +149,15 @@ export class ObservedOutboundTrack<Kind extends MediaKind> extends EventEmitter
 			.finally(() => this.emit('close'));
 	}
 
-	public get stats(): ReadonlyMap<number, ObservedOutboundTrackStats<Kind>> {
-		return this._stats;
+	public resetMetrics() {
+		this.bitrate = 0;
+		this.rttInMs = 0;
+
+		this.deltaLostPackets = 0;
+		this.deltaSentPackets = 0;
+		this.deltaSentBytes = 0;
+		this.deltaSentFrames = 0;
+		this.deltaEncodedFrames = 0;
 	}
 
 	public async update(sample: ObservedOutboundTrackStatsUpdate<Kind>, timestamp: number): Promise<void> {
@@ -150,13 +184,30 @@ export class ObservedOutboundTrack<Kind extends MediaKind> extends EventEmitter
 		const lastStat = this._stats.get(sample.ssrc);
 		const rttInMs = sample.roundTripTime ? sample.roundTripTime * 1000 : undefined;
 		const bitrate = ((sample.bytesSent ?? 0) - (lastStat?.bytesSent ?? 0)) * 8 / (elapsedTimeInMs / 1000);
-		// const lostPackets = (sample.packetsLost ?? 0) - (lastStat?.packetsLost ?? 0);
-		// const sentPackets = (sample.packetsSent ?? 0) - (lastStat?.packetsSent ?? 0);
+		const deltaLostPackets = (sample.packetsLost ?? 0) - (lastStat?.packetsLost ?? 0);
+		const deltaSentPackets = (sample.packetsSent ?? 0) - (lastStat?.packetsSent ?? 0);
+		const deltaSentBytes = (sample.bytesSent ?? 0) - (lastStat?.bytesSent ?? 0);
+		let deltaEncodedFrames: number | undefined;
+		let deltaSentFrames: number | undefined;
+
+		if (this.kind === 'video') {
+			const videoSample = sample as OutboundVideoTrack;
+			const lastVideoStats = lastStat as OutboundVideoTrack | undefined;
+
+			deltaEncodedFrames = (videoSample.framesEncoded ?? 0) - (lastVideoStats?.framesEncoded ?? 0);
+			deltaSentFrames = (videoSample.framesSent ?? 0) - (lastVideoStats?.framesSent ?? 0);
+		}
 		const stats: ObservedOutboundTrackStats<Kind> = {
 			...sample,
 			rttInMs,
 			bitrate,
 			ssrc: sample.ssrc,
+
+			deltaLostPackets,
+			deltaSentPackets,
+			deltaSentBytes,
+			deltaEncodedFrames,
+			deltaSentFrames,
 		};
 
 		this._stats.set(sample.ssrc, stats);
@@ -164,6 +215,16 @@ export class ObservedOutboundTrack<Kind extends MediaKind> extends EventEmitter
 		this.bitrate = [ ...this._stats.values() ].reduce((acc, stat) => acc + stat.bitrate, 0);
 		this.rttInMs = [ ...this._stats.values() ].reduce((acc, stat) => acc + (stat.rttInMs ?? 0), 0) / (this._stats.size || 1);
 
+		this.totalLostPackets = [ ...this._stats.values() ].reduce((acc, stat) => acc + (stat.packetsLost ?? 0), 0);
+		this.totalSentPackets = [ ...this._stats.values() ].reduce((acc, stat) => acc + (stat.packetsSent ?? 0), 0);
+		this.totalSentBytes = [ ...this._stats.values() ].reduce((acc, stat) => acc + (stat.bytesSent ?? 0), 0);
+
+		this.deltaEncodedFrames = [ ...this._stats.values() ].reduce((acc, stat) => acc + (stat.deltaEncodedFrames ?? 0), 0);
+		this.deltaSentFrames = [ ...this._stats.values() ].reduce((acc, stat) => acc + (stat.deltaSentFrames ?? 0), 0);
+		this.deltaLostPackets = [ ...this._stats.values() ].reduce((acc, stat) => acc + stat.deltaLostPackets, 0);
+		this.deltaSentPackets = [ ...this._stats.values() ].reduce((acc, stat) => acc + stat.deltaSentPackets, 0);
+		this.deltaSentBytes = [ ...this._stats.values() ].reduce((acc, stat) => acc + stat.deltaSentBytes, 0);
+
 		// setting up sfu connection as it is not always available at the first sample
 		if (sample.sfuStreamId && !this._model.sfuStreamId) {
 			this._model.sfuStreamId = sample.sfuStreamId;

package/src/ObservedPeerConnection.ts

@@ -1,12 +1,13 @@
 import { EventEmitter } from 'events';
 import * as Models from './models/Models';
 import { StorageProvider } from './storages/StorageProvider';
-import { PeerConnectionTransport } from '@observertc/sample-schemas-js';
+import { IceLocalCandidate, IceRemoteCandidate, PeerConnectionTransport } from '@observertc/sample-schemas-js';
 import { ObservedClient } from './ObservedClient';
 import { ObservedInboundTrack, ObservedInboundTrackConfig } from './ObservedInboundTrack';
 import { ObservedOutboundTrack, ObservedOutboundTrackConfig } from './ObservedOutboundTrack';
 import { PeerConnectionTransportReport } from '@observertc/report-schemas-js';
 import { createSingleExecutor } from './common/SingleExecutor';
+import { ObservedICE } from './ObservedICE';
 
 export type ObservedPeerConnectionEvents = {
 	update: [],
@@ -15,6 +16,10 @@ export type ObservedPeerConnectionEvents = {
 	newinboudvideotrack: [ObservedInboundTrack<'video'>],
 	newoutboundaudiotrack: [ObservedOutboundTrack<'audio'>],
 	newoutboundvideotrack: [ObservedOutboundTrack<'video'>],
+
+	iceconnectionstatechange: [string],
+	icegatheringstatechange: [string],
+	connectionstatechange: [string],
 };
 
 export type ObservedPeerConnectionConfig = {
@@ -51,10 +56,51 @@ export class ObservedPeerConnection extends EventEmitter {
 		return new ObservedPeerConnection(model, client, storageProvider);
 	}
 
+	public created = Date.now();
+
+	public totalInboundPacketsLost = 0;
+	public totalInboundPacketsReceived = 0;
+	public totalOutboundPacketsSent = 0;
+	public totalDataChannelBytesSent = 0;
+	public totalDataChannelBytesReceived = 0;
+
+	public totalSentAudioBytes = 0;
+	public totalSentVideoBytes = 0;
+	public totalSentAudioPackets = 0;
+	public totalSentVideoPackets = 0;
+	public totalReceivedAudioPacktes = 0;
+	public totalReceivedVideoPackets = 0;
+	public totalReceivedAudioBytes = 0;
+	public totalReceivedVideoBytes = 0;
+
+	public deltaInboundLostPackets = 0;
+	public deltaInboundReceivedPackets = 0;
+	public deltaOutboundSentPackets = 0;
+	public deltaDataChannelBytesSent = 0;
+	public deltaDataChannelBytesReceived = 0;
+	public deltaInboundReceivedBytes = 0;
+	public deltaOutboundSentBytes = 0;
+	
+	public deltaReceivedAudioBytes = 0;
+	public deltaReceivedVideoBytes = 0;
+	public deltaReceivedAudioPackets = 0;
+	public deltaReceivedVideoPackets = 0;
+	public deltaSentAudioBytes = 0;
+	public deltaSentVideoBytes = 0;
+	public sendingAudioBitrate = 0;
+	public sendingVideoBitrate = 0;
+	public receivingAudioBitrate = 0;
+	public receivingVideoBitrate = 0;
+    
+	public avgRttInS?: number;
+
 	private _closed = false;
 	private _updated = Date.now();
 	private _sample?: ObservedPeerConnectionStats;
+	private _selectedLocalIceCandidate?: IceLocalCandidate;
+	private _selectedRemoteIceCandidate?: IceRemoteCandidate;
 
+	public readonly ICE = ObservedICE.create(this);
 	private readonly _inboundAudioTracks = new Map<string, ObservedInboundTrack<'audio'>>();
 	private readonly _inboundVideoTracks = new Map<string, ObservedInboundTrack<'video'>>();
 	private readonly _outboundAudioTracks = new Map<string, ObservedOutboundTrack<'audio'>>();
@@ -86,6 +132,14 @@ export class ObservedPeerConnection extends EventEmitter {
 		return this._updated;
 	}
 
+	public get selectedLocalIceCandidate() {
+		return this._selectedLocalIceCandidate;
+	}
+
+	public get selectedRemoteIceCandidate() {
+		return this._selectedRemoteIceCandidate;
+	}
+
 	public get inboundAudioTracks(): ReadonlyMap<string, ObservedInboundTrack<'audio'>> {
 		return this._inboundAudioTracks;
 	}
@@ -102,6 +156,10 @@ export class ObservedPeerConnection extends EventEmitter {
 		return this._outboundVideoTracks;
 	}
 
+	public get uptimeInMs() {
+		return this._updated - this.created;
+	}
+
 	public get closed() {
 		return this._closed;
 	}
@@ -120,6 +178,119 @@ export class ObservedPeerConnection extends EventEmitter {
 			.finally(() => this.emit('close')); 
 	}
 
+	public getTrack(trackId: string): ObservedInboundTrack<'audio'> | ObservedInboundTrack<'video'> | ObservedOutboundTrack<'audio'> | ObservedOutboundTrack<'video'> | undefined {
+		return this._inboundAudioTracks.get(trackId) ?? this._inboundVideoTracks.get(trackId) ?? this._outboundAudioTracks.get(trackId) ?? this._outboundVideoTracks.get(trackId);
+	}
+
+	public resetMetrics() {
+		this.deltaInboundLostPackets = 0;
+		this.deltaInboundReceivedPackets = 0;
+		this.deltaOutboundSentPackets = 0;
+
+		this.deltaDataChannelBytesSent = 0;
+		this.deltaDataChannelBytesReceived = 0;
+		this.deltaReceivedAudioBytes = 0;
+		this.deltaReceivedVideoBytes = 0;
+		this.deltaSentAudioBytes = 0;
+		this.deltaSentVideoBytes = 0;
+
+		this._inboundAudioTracks.forEach((track) => track.resetMetrics());
+		this._inboundVideoTracks.forEach((track) => track.resetMetrics());
+		this._outboundAudioTracks.forEach((track) => track.resetMetrics());
+		this._outboundVideoTracks.forEach((track) => track.resetMetrics());
+	}
+
+	public updateMetrics() {
+		this.totalInboundPacketsLost = 0;
+		this.totalInboundPacketsReceived = 0;
+		this.totalOutboundPacketsSent = 0;
+		this.totalDataChannelBytesSent = 0;
+		this.totalDataChannelBytesReceived = 0;
+	
+		this.totalSentAudioBytes = 0;
+		this.totalSentVideoBytes = 0;
+		this.totalReceivedAudioBytes = 0;
+		this.totalReceivedVideoBytes = 0;
+		this.sendingAudioBitrate = 0;
+		this.sendingVideoBitrate = 0;
+		this.receivingAudioBitrate = 0;
+		this.receivingVideoBitrate = 0;
+
+		let sumRttInS = 0;
+
+		this._inboundAudioTracks.forEach((track) => {
+			this.deltaInboundLostPackets += track.deltaLostPackets;
+			this.deltaInboundReceivedPackets += track.deltaReceivedPackets;
+			this.deltaInboundReceivedBytes += track.deltaBytesReceived;
+			
+			this.deltaReceivedAudioBytes += track.deltaBytesReceived;
+			this.deltaReceivedAudioPackets += track.deltaReceivedPackets;
+			
+			this.receivingAudioBitrate += track.bitrate;
+
+			this.totalInboundPacketsLost += track.totalLostPackets;
+			this.totalInboundPacketsReceived += track.totalReceivedPackets;
+			this.totalReceivedAudioBytes += track.totalBytesReceived;
+			this.totalReceivedAudioPacktes += track.totalReceivedPackets;
+
+			sumRttInS = (track.rttInMs ?? 0) / 1000.0;
+		});
+
+		this._inboundVideoTracks.forEach((track) => {
+			this.deltaInboundLostPackets += track.deltaLostPackets;
+			this.deltaInboundReceivedPackets += track.deltaReceivedPackets;
+			this.deltaInboundReceivedBytes += track.deltaBytesReceived;
+			
+			this.deltaReceivedVideoBytes += track.deltaBytesReceived;
+			this.deltaReceivedVideoPackets += track.deltaReceivedPackets;
+			
+			this.receivingVideoBitrate += track.bitrate;
+
+			this.totalInboundPacketsLost += track.totalLostPackets;
+			this.totalInboundPacketsReceived += track.totalReceivedPackets;
+			this.totalReceivedVideoBytes += track.totalBytesReceived;
+			this.totalReceivedVideoPackets += track.totalReceivedPackets;
+
+			sumRttInS = (track.rttInMs ?? 0) / 1000.0;
+		});
+
+		this._outboundAudioTracks.forEach((track) => {
+			this.deltaOutboundSentPackets += track.deltaSentPackets;
+			this.deltaOutboundSentBytes += track.deltaSentBytes;
+			
+			this.deltaSentAudioBytes += track.deltaSentBytes;
+			this.deltaSentAudioBytes += track.deltaSentPackets;
+			
+			this.sendingAudioBitrate += track.bitrate;
+
+			this.totalOutboundPacketsSent += track.totalSentPackets;
+			this.totalSentAudioBytes += track.totalSentBytes;
+			this.totalSentAudioPackets += track.totalSentPackets;
+
+			sumRttInS = (track.rttInMs ?? 0) / 1000.0;
+		});
+
+		this._outboundVideoTracks.forEach((track) => {
+			this.deltaOutboundSentPackets += track.deltaSentPackets;
+			this.deltaOutboundSentBytes += track.deltaSentBytes;
+			
+			this.deltaSentVideoBytes += track.deltaSentBytes;
+			this.deltaSentVideoBytes += track.deltaSentPackets;
+			
+			this.sendingVideoBitrate += track.bitrate;
+
+			this.totalOutboundPacketsSent += track.totalSentPackets;
+			this.totalSentVideoBytes += track.totalSentBytes;
+			this.totalSentVideoPackets += track.totalSentPackets;
+
+			sumRttInS = (track.rttInMs ?? 0) / 1000.0;
+		});
+
+		const nrOfBelongings = this._inboundAudioTracks.size + this._inboundVideoTracks.size + this._outboundAudioTracks.size + this._outboundVideoTracks.size;
+
+		this.avgRttInS = 0 < nrOfBelongings ? sumRttInS / nrOfBelongings : undefined;
+	}
+
 	public update(sample: PeerConnectionTransport, timestamp: number) {
 		if (this._closed) return;
 		if (sample.peerConnectionId !== this._model.peerConnectionId) throw new Error(`TransportId mismatch. PeerConnectionId: ${ this._model.peerConnectionId } TransportId: ${ sample.transportId}`);
@@ -144,6 +315,11 @@ export class ObservedPeerConnection extends EventEmitter {
 		this.emit('update');
 	}
 
+	public updateSelectedCandidate(localCandidate: IceLocalCandidate, remoteCandidate: IceRemoteCandidate) {
+		this._selectedLocalIceCandidate = localCandidate;
+		this._selectedRemoteIceCandidate = remoteCandidate;
+	}
+
 	public async createInboundAudioTrack(config: Omit<ObservedInboundTrackConfig<'audio'>, 'kind'>): Promise<ObservedInboundTrack<'audio'>> {
 		if (this._closed) throw new Error(`PeerConnection ${this.peerConnectionId} is closed`);
 
@@ -152,6 +328,13 @@ export class ObservedPeerConnection extends EventEmitter {
 			trackId: config.trackId,
 		}, this, this._storageProvider);
 
+		const pendingTracksTimestamp = this.client.ωpendingCreatedTracksTimestamp.get(result.trackId);
+
+		if (pendingTracksTimestamp) {
+			this.client.ωpendingCreatedTracksTimestamp.delete(result.trackId);
+			result.created = pendingTracksTimestamp;
+		}
+		
 		result.on('close', () => {
 			this._inboundAudioTracks.delete(result.trackId);
 			this._model.inboundTrackIds = this._model.inboundTrackIds.filter((id) => id !== result.trackId);
@@ -173,6 +356,13 @@ export class ObservedPeerConnection extends EventEmitter {
 			kind: 'video',
 			trackId: config.trackId,
 		}, this, this._storageProvider);
+		
+		const pendingTracksTimestamp = this.client.ωpendingCreatedTracksTimestamp.get(result.trackId);
+
+		if (pendingTracksTimestamp) {
+			this.client.ωpendingCreatedTracksTimestamp.delete(result.trackId);
+			result.created = pendingTracksTimestamp;
+		}
 
 		result.on('close', () => {
 			this._inboundVideoTracks.delete(result.trackId);
@@ -196,6 +386,13 @@ export class ObservedPeerConnection extends EventEmitter {
 			trackId: config.trackId,
 		}, this, this._storageProvider);
 
+		const pendingTracksTimestamp = this.client.ωpendingCreatedTracksTimestamp.get(result.trackId);
+
+		if (pendingTracksTimestamp) {
+			this.client.ωpendingCreatedTracksTimestamp.delete(result.trackId);
+			result.created = pendingTracksTimestamp;
+		}
+
 		result.on('close', () => {
 			this._outboundAudioTracks.delete(result.trackId);
 			this._model.outboundTrackIds = this._model.outboundTrackIds.filter((id) => id !== result.trackId);
@@ -222,6 +419,13 @@ export class ObservedPeerConnection extends EventEmitter {
 			trackId: config.trackId,
 		}, this, this._storageProvider);
 
+		const pendingTracksTimestamp = this.client.ωpendingCreatedTracksTimestamp.get(result.trackId);
+
+		if (pendingTracksTimestamp) {
+			this.client.ωpendingCreatedTracksTimestamp.delete(result.trackId);
+			result.created = pendingTracksTimestamp;
+		}
+
 		result.on('close', () => {
 			this._outboundVideoTracks.delete(result.trackId);
 			result.sfuStreamId && this.client.call.sfuStreamIdToOutboundVideoTrack.set(result.sfuStreamId, result);

package/src/common/CallEventType.ts

@@ -0,0 +1,23 @@
+// eslint-disable-next-line no-shadow
+
+export enum CallEventType {
+	CALL_STARTED = 'CALL_STARTED',
+	CALL_ENDED = 'CALL_ENDED',
+	CLIENT_JOINED = 'CLIENT_JOINED',
+	CLIENT_LEFT = 'CLIENT_LEFT',
+	PEER_CONNECTION_OPENED = 'PEER_CONNECTION_OPENED',
+	PEER_CONNECTION_CLOSED = 'PEER_CONNECTION_CLOSED',
+	MEDIA_TRACK_ADDED = 'MEDIA_TRACK_ADDED',
+	MEDIA_TRACK_REMOVED = 'MEDIA_TRACK_REMOVED',
+	MEDIA_TRACK_RESUMED = 'MEDIA_TRACK_RESUMED',
+	MEDIA_TRACK_MUTED = 'MEDIA_TRACK_MUTED',
+	MEDIA_TRACK_UNMUTED = 'MEDIA_TRACK_UNMUTED',
+	ICE_GATHERING_STATE_CHANGED = 'ICE_GATHERING_STATE_CHANGED',
+	PEER_CONNECTION_STATE_CHANGED = 'PEER_CONNECTION_STATE_CHANGED',
+	ICE_CONNECTION_STATE_CHANGED = 'ICE_CONNECTION_STATE_CHANGED',
+	DATA_CHANNEL_OPEN = 'DATA_CHANNEL_OPEN',
+	DATA_CHANNEL_CLOSED = 'DATA_CHANNEL_CLOSED',
+	DATA_CHANNEL_ERROR = 'DATA_CHANNEL_ERROR',
+	NEGOTIATION_NEEDED = 'NEGOTIATION_NEEDED',
+	SIGNALING_STATE_CHANGE = 'SIGNALING_STATE_CHANGE',
+}

package/src/common/callEventReports.ts

@@ -1,16 +1,6 @@
 import { CallEventReport } from '@observertc/report-schemas-js';
+import { CallEventType } from './CallEventType';
 
-// eslint-disable-next-line no-shadow
-export enum CallEventType {
-	CALL_STARTED = 'CALL_STARTED',
-	CALL_ENDED = 'CALL_ENDED',
-	CLIENT_JOINED = 'CLIENT_JOINED',
-	CLIENT_LEFT = 'CLIENT_LEFT',
-	PEER_CONNECTION_OPENED = 'PEER_CONNECTION_OPENED',
-	PEER_CONNECTION_CLOSED = 'PEER_CONNECTION_CLOSED',
-	MEDIA_TRACK_ADDED = 'MEDIA_TRACK_ADDED',
-	MEDIA_TRACK_REMOVED = 'MEDIA_TRACK_REMOVED',
-}
 export function createCallStartedEventReport(
 	serviceId: string,
 	roomId: string,