@observertc/observer-js 1.0.1-c3edea3.0 → 1.0.1-ec27289.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,7 @@ export type ObservedPeerConnectionEvents = {
 	'removed-peer-connection-transport': [ObservedPeerConnectionTransport];
 	'removed-remote-inbound-rtp': [ObservedRemoteInboundRtp];
 	'removed-remote-outbound-rtp': [ObservedRemoteOutboundRtp];
-
+	'update': [],
 	close: [];
 };
 
@@ -106,11 +108,15 @@ export class ObservedPeerConnection extends EventEmitter {
 	public closedAt?: number;
 	public updated = Date.now();
 
+	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 +132,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 +143,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 +153,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 +250,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 +278,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 +289,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 +304,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 +315,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 +330,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 +347,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 +392,10 @@ export class ObservedPeerConnection extends EventEmitter {
 						this.deltaReceivedVideoPackets += observedInboundRtp.deltaReceivedPackets;
 						break;
 				}
+
+				if (observedInboundRtp.jitter) {
+					jitterMeasurements.push(observedInboundRtp.jitter);
+				}
 			}
 		}
 		if (sample.mediaPlayouts) {
@@ -374,12 +432,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 +475,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 +488,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 = selectedIceCandidatePairs.some((pair) => pair.getLocalCandidate()?.protocol === 'tcp');
-		this.usingTURN = selectedIceCandidatePairs.some((pair) => pair.getLocalCandidate()?.candidateType === 'relay') &&
-			selectedIceCandidatePairs.some((pair) => pair.getRemoteCandidate()?.url?.startsWith('turn:'));
+		this.usingTCP = false;
+		this.usingTURN = false;
 
+		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() {

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);
+		}
+	}
+
+}

package/src/ObservedTurnServer.ts

@@ -0,0 +1,72 @@
+import { ObservedIceCandidatePair } from './ObservedIceCandidatePair';
+import { ObservedPeerConnection } from './ObservedPeerConnection';
+import { ObservedTURN } from './ObservedTURN';
+
+export class ObservedTurnServer {
+	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 deltaBytesSent = 0;
+	public deltaBytesReceived = 0;
+	public deltaPacketsSent = 0;
+	public deltaPacketsReceived = 0;
+    
+	public readonly observedPeerConnections = new Map<string, ObservedPeerConnection>(); 
+
+	public updated = Date.now();
+
+	public constructor(
+		public readonly url: string,
+		public readonly observedTURN: ObservedTURN,
+	) {
+
+	}
+
+	public updateTurnUsage(...selectedcandidatepairs: ObservedIceCandidatePair[]) {
+		for (const selectedcandidatepair of selectedcandidatepairs) {
+			this.deltaBytesReceived += selectedcandidatepair.deltaBytesReceived;
+			this.deltaBytesSent += selectedcandidatepair.deltaBytesSent;
+			this.deltaPacketsReceived += selectedcandidatepair.deltaPacketsReceived;
+			this.deltaPacketsSent += selectedcandidatepair.deltaPacketsSent;
+		}
+	}
+
+	public update() {
+		const now = Date.now();
+		const deltaInS = (now - this.updated) / 1000;
+        
+		this.packetsSentPerSecond = this.deltaPacketsSent / deltaInS;
+		this.packetsReceivedPerSecond = this.deltaPacketsReceived / deltaInS;   
+		this.outboundBitrate = (this.deltaBytesReceived * 8) / deltaInS;
+		this.inboundBitrate = (this.deltaBytesSent * 8) / deltaInS;
+        
+		this.totalBytesSent += this.deltaBytesSent;
+		this.totalBytesReceived += this.deltaBytesReceived;
+		this.totalPacketsSent += this.deltaPacketsSent;
+		this.totalPacketsReceived += this.deltaPacketsReceived;
+		
+		this.observedTURN.totalBytesSent += this.deltaBytesSent;
+		this.observedTURN.totalBytesReceived += this.deltaBytesReceived;
+		this.observedTURN.totalPacketsSent += this.deltaPacketsSent;
+		this.observedTURN.totalPacketsReceived += this.deltaPacketsReceived;
+        
+		this.observedTURN.inboundBitrate += this.inboundBitrate;
+		this.observedTURN.outboundBitrate += this.outboundBitrate;
+		this.observedTURN.packetsReceivedPerSecond += this.packetsReceivedPerSecond;
+		this.observedTURN.packetsSentPerSecond += this.packetsSentPerSecond;
+        
+		this.deltaBytesSent = 0;
+		this.deltaBytesReceived = 0;
+		this.deltaPacketsSent = 0;
+		this.deltaPacketsReceived = 0;
+
+		this.updated = now;
+	}
+}