@observertc/observer-js 1.0.1-c3edea3.0 → 1.0.1-c9e7581.0

package/src/ObservedPeerConnection.ts

@@ -19,6 +19,8 @@ import { ObservedRemoteOutboundRtp } from './ObservedRemoteOutboundRtp';
 import { ObservedInboundTrack } from './ObservedInboundTrack';
 import { ObservedOutboundTrack } from './ObservedOutboundTrack';
 import { CalculatedScore } from './scores/CalculatedScore';
+import { ObservedTurnServer } from './ObservedTurnServer';
+import { getMedian } from './common/utils';
 
 const logger = createLogger('ObservedPeerConnection');
 
@@ -70,7 +72,27 @@ export type ObservedPeerConnectionEvents = {
 	'removed-peer-connection-transport': [ObservedPeerConnectionTransport];
 	'removed-remote-inbound-rtp': [ObservedRemoteInboundRtp];
 	'removed-remote-outbound-rtp': [ObservedRemoteOutboundRtp];
-
+	'updated-inbound-rtp': [ObservedInboundRtp];
+	'updated-outbound-rtp': [ObservedOutboundRtp];
+	'updated-inbound-track': [ObservedInboundTrack];
+	'updated-outbound-track': [ObservedOutboundTrack];
+	'updated-ice-candidate-pair': [ObservedIceCandidatePair];
+	'updated-ice-transport': [ObservedIceTransport];
+	'updated-peer-connection-transport': [ObservedPeerConnectionTransport];
+	'updated-media-source': [ObservedMediaSource];
+	'updated-media-playout': [ObservedMediaPlayout];
+	'updated-data-channel': [ObservedDataChannel];
+	'updated-ice-candidate': [ObservedIceCandidate];
+	'updated-certificate': [ObservedCertificate];
+	'updated-codec': [ObservedCodec];
+	'updated-remote-inbound-rtp': [ObservedRemoteInboundRtp];
+	'updated-remote-outbound-rtp': [ObservedRemoteOutboundRtp];
+	'muted-inbound-track': [ObservedInboundTrack];
+	'muted-outbound-track': [ObservedOutboundTrack];
+	'unmuted-inbound-track': [ObservedInboundTrack];
+	'unmuted-outbound-track': [ObservedOutboundTrack];
+
+	'update': [],
 	close: [];
 };
 
@@ -106,11 +128,19 @@ export class ObservedPeerConnection extends EventEmitter {
 	public closedAt?: number;
 	public updated = Date.now();
 
+	public connectionState?: string;
+	public iceConnectionState?: string;
+	public iceGatheringState?: string;
+
+	public availableIncomingBitrate = 0;
+	public availableOutgoingBitrate = 0;
 	public totalInboundPacketsLost = 0;
 	public totalInboundPacketsReceived = 0;
 	public totalOutboundPacketsSent = 0;
 	public totalDataChannelBytesSent = 0;
 	public totalDataChannelBytesReceived = 0;
+	public totalDataChannelMessagesSent = 0;
+	public totalDataChannelMessagesReceived = 0;
 
 	public totalSentAudioBytes = 0;
 	public totalSentVideoBytes = 0;
@@ -126,6 +156,8 @@ export class ObservedPeerConnection extends EventEmitter {
 	public deltaOutboundPacketsSent = 0;
 	public deltaDataChannelBytesSent = 0;
 	public deltaDataChannelBytesReceived = 0;
+	public deltaDataChannelMessagesSent = 0;
+	public deltaDataChannelMessagesReceived = 0;
 	public deltaInboundReceivedBytes = 0;
 	public deltaOutboundSentBytes = 0;
 
@@ -135,6 +167,8 @@ export class ObservedPeerConnection extends EventEmitter {
 	public deltaReceivedVideoPackets = 0;
 	public deltaSentAudioBytes = 0;
 	public deltaSentVideoBytes = 0;
+	public deltaTransportSentBytes = 0;
+	public deltaTransportReceivedBytes = 0;
 
 	public receivingPacketsPerSecond = 0;
 	public sendingPacketsPerSecond = 0;
@@ -143,12 +177,13 @@ export class ObservedPeerConnection extends EventEmitter {
 	public receivingAudioBitrate = 0;
 	public receivingVideoBitrate = 0;
 
-	public avgRttInMs?: number;
-	public avgJitter?: number;
+	public currentRttInMs?: number;
+	public currentJitter?: number;
 
 	public usingTCP = false;
 	public usingTURN = false;
 
+	public observedTurnServer?: ObservedTurnServer;
 	public readonly observedCertificates = new Map<string, ObservedCertificate>();
 	public readonly observedCodecs = new Map<string, ObservedCodec>();
 	public readonly observedDataChannels = new Map<string, ObservedDataChannel>();
@@ -239,6 +274,14 @@ export class ObservedPeerConnection extends EventEmitter {
 			.filter((pair) => pair !== undefined) as ObservedIceCandidatePair[];
 	}
 
+	public get selectedIceCandiadtePairForTurn() {
+		return this.selectedIceCandidatePairs
+			.filter((pair) => 
+				pair.getLocalCandidate()?.candidateType === 'relay' && 
+				pair.getRemoteCandidate()?.url?.startsWith('turn:')
+			);
+	}
+
 	public close() {
 		if (this.closed) return;
 		this.closed = true;
@@ -259,6 +302,10 @@ export class ObservedPeerConnection extends EventEmitter {
 		this.observedRemoteInboundRtps.clear();
 		this.observedRemoteOutboundRtps.clear();
 
+		this.client.call.observer.observedTURN.removePeerConnection(this);
+		
+		if (!this.closedAt) this.closedAt = Date.now();
+		
 		this.emit('close');
 	}
 
@@ -266,6 +313,8 @@ export class ObservedPeerConnection extends EventEmitter {
 		if (this.closed) return;
 		this._visited = true;
 
+		this.availableIncomingBitrate = 0;
+		this.availableOutgoingBitrate = 0;
 		this.deltaInboundPacketsLost = 0;
 		this.deltaInboundPacketsReceived = 0;
 		this.deltaOutboundPacketsSent = 0;
@@ -279,6 +328,9 @@ export class ObservedPeerConnection extends EventEmitter {
 		this.deltaReceivedVideoPackets = 0;
 		this.deltaSentAudioBytes = 0;
 		this.deltaSentVideoBytes = 0;
+		this.deltaTransportReceivedBytes = 0;
+		this.deltaTransportSentBytes = 0;
+
 		this.sendingAudioBitrate = 0;
 		this.sendingVideoBitrate = 0;
 		this.receivingAudioBitrate = 0;
@@ -287,6 +339,8 @@ export class ObservedPeerConnection extends EventEmitter {
 		const now = Date.now();
 		const elapsedTimeInMs = now - this.updated;
 		const elapsedTimeInSec = elapsedTimeInMs / 1000;
+		const rttMeasurementsInSec: number[] = [];
+		const jitterMeasurements: number[] = [];
 
 		if (sample.certificates) {
 			for (const certificate of sample.certificates) {
@@ -300,7 +354,14 @@ export class ObservedPeerConnection extends EventEmitter {
 		}
 		if (sample.dataChannels) {
 			for (const dataChannel of sample.dataChannels) {
-				this._updateDataChannelStats(dataChannel);
+				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) {
@@ -310,12 +371,29 @@ export class ObservedPeerConnection extends EventEmitter {
 		}
 		if (sample.iceCandidatePairs) {
 			for (const iceCandidatePair of sample.iceCandidatePairs) {
-				this._updateIceCandidatePairStats(iceCandidatePair);
+				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);
+				const observedIceTransport = this._updateIceTransportStats(iceTransport);
+
+				if (!observedIceTransport) return;
+
+				observedIceTransport.bytesReceived;
+
 			}
 		}
 		if (sample.inboundRtps) {
@@ -338,6 +416,10 @@ export class ObservedPeerConnection extends EventEmitter {
 						this.deltaReceivedVideoPackets += observedInboundRtp.deltaReceivedPackets;
 						break;
 				}
+
+				if (observedInboundRtp.jitter) {
+					jitterMeasurements.push(observedInboundRtp.jitter);
+				}
 			}
 		}
 		if (sample.mediaPlayouts) {
@@ -374,12 +456,21 @@ export class ObservedPeerConnection extends EventEmitter {
 		}
 		if (sample.peerConnectionTransports) {
 			for (const peerConnectionTransport of sample.peerConnectionTransports) {
-				this._updatePeerConnectionTransportStats(peerConnectionTransport);
+				const observedTransport = this._updatePeerConnectionTransportStats(peerConnectionTransport);
+				
+				if (!observedTransport) continue;
+
 			}
 		}
 		if (sample.remoteInboundRtps) {
 			for (const remoteInboundRtp of sample.remoteInboundRtps) {
-				this._updateRemoteInboundRtpStats(remoteInboundRtp);
+				const observedRemoteInboundRtp = this._updateRemoteInboundRtpStats(remoteInboundRtp);
+
+				if (!observedRemoteInboundRtp) continue;
+
+				if (observedRemoteInboundRtp.roundTripTime) {
+					rttMeasurementsInSec.push(observedRemoteInboundRtp.roundTripTime);
+				}
 			}
 		}
 		if (sample.remoteOutboundRtps) {
@@ -408,6 +499,8 @@ export class ObservedPeerConnection extends EventEmitter {
 		this.totalOutboundPacketsSent += this.deltaOutboundPacketsSent;
 		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;
@@ -419,20 +512,55 @@ export class ObservedPeerConnection extends EventEmitter {
 
 		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;
-
+		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.currentRttInMs = getMedian(rttMeasurementsInSec, false) * 1000;
+		} else {
+			this.currentRttInMs = undefined;
+		}
+		if (jitterMeasurements.length > 0) {
+			this.currentJitter = getMedian(jitterMeasurements, false);
+		} else {
+			this.currentJitter = undefined;
+		}
+		const wasUsingTURN = this.usingTURN;
 		const selectedIceCandidatePairs = this.selectedIceCandidatePairs;
+		const selectedCandidatePairForTurn: ObservedIceCandidatePair[] = [];
+
+		this.usingTCP = false;
+		this.usingTURN = false;
 
-		this.usingTCP = selectedIceCandidatePairs.some((pair) => pair.getLocalCandidate()?.protocol === 'tcp');
-		this.usingTURN = selectedIceCandidatePairs.some((pair) => pair.getLocalCandidate()?.candidateType === 'relay') &&
-			selectedIceCandidatePairs.some((pair) => pair.getRemoteCandidate()?.url?.startsWith('turn:'));
+		for (const selectedCandidatePair of selectedIceCandidatePairs) {
+			if (selectedCandidatePair.getLocalCandidate()?.protocol === 'tcp') {
+				this.usingTCP = true;
+			}
+			if (selectedCandidatePair.getLocalCandidate()?.candidateType === 'relay' && selectedCandidatePair.getRemoteCandidate()?.url?.startsWith('turn:')) {
+				selectedCandidatePairForTurn.push(selectedCandidatePair);
+				this.usingTURN = true;
+			}
+			this.deltaTransportReceivedBytes += selectedCandidatePair.deltaBytesReceived;
+			this.deltaTransportSentBytes += selectedCandidatePair.deltaBytesSent;
+		}
 
+		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');
 	}
 
 	private _checkVisited() {
@@ -540,12 +668,15 @@ export class ObservedPeerConnection extends EventEmitter {
 
 			observedCertificate = new ObservedCertificate(stats.timestamp, stats.id, this);
 
+			observedCertificate.update(stats);
+
 			this.observedCertificates.set(stats.id, observedCertificate);
 			this.emit('added-certificate', observedCertificate);
+		} else {
+			observedCertificate.update(stats);
+			this.emit('updated-certificate', observedCertificate);
 		}
 
-		observedCertificate.update(stats);
-
 		return observedCertificate;
 	}
 
@@ -562,11 +693,14 @@ export class ObservedPeerConnection extends EventEmitter {
 
 			observedCodec = new ObservedCodec(stats.timestamp, stats.id, stats.mimeType, this);
 
+			observedCodec.update(stats);
+			
 			this.observedCodecs.set(stats.id, observedCodec);
 			this.emit('added-codec', observedCodec);
+		} else {
+			observedCodec.update(stats);
 		}
-
-		observedCodec.update(stats);
+		this.emit('updated-codec', observedCodec);
 
 		return observedCodec;
 	}
@@ -584,11 +718,14 @@ export class ObservedPeerConnection extends EventEmitter {
 
 			observedDataChannel = new ObservedDataChannel(stats.timestamp, stats.id, this);
 
+			observedDataChannel.update(stats);
+
 			this.observedDataChannels.set(stats.id, observedDataChannel);
 			this.emit('added-data-channel', observedDataChannel);
+		} else {
+			observedDataChannel.update(stats);
 		}
-
-		observedDataChannel.update(stats);
+		this.emit('updated-data-channel', observedDataChannel);
 
 		return observedDataChannel;
 	}
@@ -606,11 +743,14 @@ export class ObservedPeerConnection extends EventEmitter {
 
 			observedIceCandidate = new ObservedIceCandidate(stats.timestamp, stats.id, this);
 
+			observedIceCandidate.update(stats);
+
 			this.observedIceCandidates.set(stats.id, observedIceCandidate);
 			this.emit('added-ice-candidate', observedIceCandidate);
+		} else {
+			observedIceCandidate.update(stats);
 		}
-
-		observedIceCandidate.update(stats);
+		this.emit('updated-ice-candidate', observedIceCandidate);
 
 		return observedIceCandidate;
 	}
@@ -628,11 +768,14 @@ export class ObservedPeerConnection extends EventEmitter {
 
 			observedIceCandidatePair = new ObservedIceCandidatePair(stats.timestamp, stats.id, this);
 
+			observedIceCandidatePair.update(stats);
+			
 			this.observedIceCandidatesPair.set(stats.id, observedIceCandidatePair);
 			this.emit('added-ice-candidate-pair', observedIceCandidatePair);
+		} else {
+			observedIceCandidatePair.update(stats);
 		}
-
-		observedIceCandidatePair.update(stats);
+		this.emit('updated-ice-candidate-pair', observedIceCandidatePair);
 
 		return observedIceCandidatePair;
 	}
@@ -650,11 +793,14 @@ export class ObservedPeerConnection extends EventEmitter {
 
 			observedIceTransport = new ObservedIceTransport(stats.timestamp, stats.id, this);
 
+			observedIceTransport.update(stats);
+			
 			this.observedIceTransports.set(stats.id, observedIceTransport);
 			this.emit('added-ice-transport', observedIceTransport);
+		} else {
+			observedIceTransport.update(stats);
 		}
-
-		observedIceTransport.update(stats);
+		this.emit('updated-ice-transport', observedIceTransport);
 
 		return observedIceTransport;
 	}
@@ -678,12 +824,15 @@ export class ObservedPeerConnection extends EventEmitter {
 				stats.trackIdentifier,
 				this
 			);
+			
+			observedInboundRtp.update(stats);
 
 			this.observedInboundRtps.set(stats.ssrc, observedInboundRtp);
 			this.emit('added-inbound-rtp', observedInboundRtp);
+		} else {
+			observedInboundRtp.update(stats);
 		}
-
-		observedInboundRtp.update(stats);
+		this.emit('updated-inbound-rtp', observedInboundRtp);
 
 		return observedInboundRtp;
 	}
@@ -712,11 +861,14 @@ export class ObservedPeerConnection extends EventEmitter {
 				mediaPlayout,
 			);
 
+			observedInboundTrack.update(stats);
+			
 			this.observedInboundTracks.set(stats.id, observedInboundTrack);
 			this.emit('added-inbound-track', observedInboundTrack);
+		} else {
+			observedInboundTrack.update(stats);
 		}
-
-		observedInboundTrack.update(stats);
+		this.emit('updated-inbound-track', observedInboundTrack);
 
 		return observedInboundTrack;
 	}
@@ -739,11 +891,14 @@ export class ObservedPeerConnection extends EventEmitter {
 				this
 			);
 
+			observedMediaPlayout.update(stats);
+
 			this.observedMediaPlayouts.set(stats.id, observedMediaPlayout);
 			this.emit('added-media-playout', observedMediaPlayout);
+		} else {
+			observedMediaPlayout.update(stats);
 		}
-
-		observedMediaPlayout.update(stats);
+		this.emit('updated-media-playout', observedMediaPlayout);
 
 		return observedMediaPlayout;
 	}
@@ -766,11 +921,14 @@ export class ObservedPeerConnection extends EventEmitter {
 				this
 			);
 
+			observedMediaSource.update(stats);
+
 			this.observedMediaSources.set(stats.id, observedMediaSource);
 			this.emit('added-media-source', observedMediaSource);
+		} else {
+			observedMediaSource.update(stats);
 		}
-
-		observedMediaSource.update(stats);
+		this.emit('updated-media-source', observedMediaSource);
 
 		return observedMediaSource;
 	}
@@ -794,11 +952,14 @@ export class ObservedPeerConnection extends EventEmitter {
 				this
 			);
 
+			observedOutboundRtp.update(stats);
+
 			this.observedOutboundRtps.set(stats.ssrc, observedOutboundRtp);
 			this.emit('added-outbound-rtp', observedOutboundRtp);
+		} else {
+			observedOutboundRtp.update(stats);
 		}
-
-		observedOutboundRtp.update(stats);
+		this.emit('updated-outbound-rtp', observedOutboundRtp);
 		
 		return observedOutboundRtp;
 	}
@@ -826,11 +987,14 @@ export class ObservedPeerConnection extends EventEmitter {
 				observedMediaSource,
 			);
 
+			observedOutboundTrack.update(stats);
+
 			this.observedOutboundTracks.set(stats.id, observedOutboundTrack);
 			this.emit('added-outbound-track', observedOutboundTrack);
+		} else {
+			observedOutboundTrack.update(stats);
 		}
-
-		observedOutboundTrack.update(stats);
+		this.emit('updated-outbound-track', observedOutboundTrack);
 
 		return observedOutboundTrack;
 	}
@@ -848,11 +1012,14 @@ export class ObservedPeerConnection extends EventEmitter {
 
 			observedPeerConnectionTransport = new ObservedPeerConnectionTransport(stats.timestamp, stats.id, this);
 
+			observedPeerConnectionTransport.update(stats);
+
 			this.observedPeerConnectionTransports.set(stats.id, observedPeerConnectionTransport);
 			this.emit('added-peer-connection-transport', observedPeerConnectionTransport);
+		} else {
+			observedPeerConnectionTransport.update(stats);
 		}
-
-		observedPeerConnectionTransport.update(stats);
+		this.emit('updated-peer-connection-transport', observedPeerConnectionTransport);
 
 		return observedPeerConnectionTransport;
 	}
@@ -876,11 +1043,14 @@ export class ObservedPeerConnection extends EventEmitter {
 				this
 			);
 
+			observedRemoteInboundRtp.update(stats);
+
 			this.observedRemoteInboundRtps.set(stats.ssrc, observedRemoteInboundRtp);
 			this.emit('added-remote-inbound-rtp', observedRemoteInboundRtp);
+		} else {
+			observedRemoteInboundRtp.update(stats);
 		}
-
-		observedRemoteInboundRtp.update(stats);
+		this.emit('updated-remote-inbound-rtp', observedRemoteInboundRtp);
 
 		return observedRemoteInboundRtp;
 	}
@@ -904,11 +1074,14 @@ export class ObservedPeerConnection extends EventEmitter {
 				this
 			);
 
+			observedRemoteOutboundRtp.update(stats);
+
 			this.observedRemoteOutboundRtps.set(stats.ssrc, observedRemoteOutboundRtp);
 			this.emit('added-remote-outbound-rtp', observedRemoteOutboundRtp);
+		} else {
+			observedRemoteOutboundRtp.update(stats);
 		}
-
-		observedRemoteOutboundRtp.update(stats);
+		this.emit('updated-remote-outbound-rtp', observedRemoteOutboundRtp);
 
 		return observedRemoteOutboundRtp;
 	}

package/src/ObservedTURN.ts

@@ -0,0 +1,86 @@
+import { EventEmitter } from 'stream';
+import { ObservedPeerConnection } from './ObservedPeerConnection';
+import { ObservedTurnServer } from './ObservedTurnServer';
+import { createLogger } from './common/logger';
+
+const logger = createLogger('ObservedTURN');
+
+export type ObservedTURNEventMap = {
+	'update': [ObservedTURN];
+	'close': [];
+}
+
+export declare interface ObservedTURN {
+	on<U extends keyof ObservedTURNEventMap>(event: U, listener: (...args: ObservedTURNEventMap[U]) => void): this;
+	off<U extends keyof ObservedTURNEventMap>(event: U, listener: (...args: ObservedTURNEventMap[U]) => void): this;
+	once<U extends keyof ObservedTURNEventMap>(event: U, listener: (...args: ObservedTURNEventMap[U]) => void): this;
+	emit<U extends keyof ObservedTURNEventMap>(event: U, ...args: ObservedTURNEventMap[U]): boolean;
+}
+
+export class ObservedTURN extends EventEmitter {
+	public totalBytesSent = 0;
+	public totalBytesReceived = 0;
+	public totalPacketsSent = 0;
+	public totalPacketsReceived = 0;
+
+	public packetsSentPerSecond = 0;
+	public packetsReceivedPerSecond = 0;
+	public outboundBitrate = 0;
+	public inboundBitrate = 0;
+	public numberOfClients = 0;
+    
+	public readonly servers = new Map<string, ObservedTurnServer>();
+
+	public constructor(
+	) {
+		super();
+	}
+
+	public update() {
+		const clientIds = new Set<string>();
+        
+		this.packetsReceivedPerSecond = 0;
+		this.packetsSentPerSecond = 0;
+		this.outboundBitrate = 0;
+		this.inboundBitrate = 0;
+
+		for (const server of this.servers.values()) {
+			server.update();
+			server.observedPeerConnections.forEach((pc) => clientIds.add(pc.client.clientId));
+		}
+
+		this.numberOfClients = clientIds.size;
+	}
+
+	public addPeerConnection(peerConnection: ObservedPeerConnection) {
+		const turnPairs = peerConnection.selectedIceCandidatePairs.filter((pair) => pair.getLocalCandidate()?.candidateType === 'relay' && pair.getRemoteCandidate()?.url?.startsWith('turn:'));
+
+		if (turnPairs.length !== 1) {
+			return (logger.warn(`Expected exactly one TURN pair, but found for peerconnection ${peerConnection.peerConnectionId}`, turnPairs.length), undefined);
+		}
+
+		const candidatePair = turnPairs[0];
+		const rawUrl = candidatePair.getRemoteCandidate()?.url;
+
+		if (!rawUrl) {
+			return (logger.warn(`No remote candidate URL found for peerconnection ${peerConnection.peerConnectionId}`), undefined);
+		}
+
+		const turnUrl = new URL(rawUrl);
+		const turnServerUrl = `${turnUrl.protocol}//${turnUrl.hostname}:${turnUrl.port}`;
+		let turnServer = this.servers.get(turnServerUrl);
+        
+		if (!turnServer) {
+			turnServer = new ObservedTurnServer(turnServerUrl, this);
+		}
+
+		return turnServer;
+	}
+
+	public removePeerConnection(peerConnection: ObservedPeerConnection) {
+		for (const turnServer of this.servers.values()) {
+			turnServer.observedPeerConnections.delete(peerConnection.peerConnectionId);
+		}
+	}
+
+}