@observertc/observer-js 0.42.9 → 1.0.0-beta.1

package/src/ObservedPeerConnectionTransport.ts

@@ -0,0 +1,38 @@
+import { ObservedPeerConnection } from './ObservedPeerConnection';
+import { PeerConnectionTransportStats } from './schema/ClientSample';
+
+export class ObservedPeerConnectionTransport implements PeerConnectionTransportStats {
+	private _visited = false;
+	public appData?: Record<string, unknown>;
+
+	dataChannelsOpened?: number | undefined;
+	dataChannelsClosed?: number | 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 update(stats: PeerConnectionTransportStats) {
+		this._visited = true;
+
+		this.timestamp = stats.timestamp;
+		this.dataChannelsOpened = stats.dataChannelsOpened;
+		this.dataChannelsClosed = stats.dataChannelsClosed;
+		this.attachments = stats.attachments;
+	}
+}

package/src/ObservedRemoteInboundRtp.ts

@@ -0,0 +1,64 @@
+import { MediaKind } from './common/types';
+import { ObservedPeerConnection } from './ObservedPeerConnection';
+import { RemoteInboundRtpStats } from './schema/ClientSample';
+
+export class ObservedRemoteInboundRtp implements RemoteInboundRtpStats {
+	private _visited = false;
+	public appData?: Record<string, unknown>;
+	transportId?: string | undefined;
+	codecId?: string | undefined;
+	packetsReceived?: number | undefined;
+	packetsLost?: number | undefined;
+	jitter?: number | undefined;
+	localId?: string | undefined;
+	roundTripTime?: number | undefined;
+	totalRoundTripTime?: number | undefined;
+	fractionLost?: number | undefined;
+	roundTripTimeMeasurements?: number | undefined;
+	attachments?: Record<string, unknown> | undefined;
+
+	public constructor(
+		public timestamp: number,
+		public id: string,
+		public ssrc: number,
+		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 getOutboundRtp() {
+		return this._peerConnection.observedOutboundRtps.get(this.ssrc);
+	}
+
+	public getCodec() {
+		return this._peerConnection.observedCodecs.get(this.codecId ?? '');
+	}
+
+	public update(stats: RemoteInboundRtpStats) {
+		this._visited = true;
+
+		this.timestamp = stats.timestamp;
+		this.transportId = stats.transportId;
+		this.codecId = stats.codecId;
+		this.packetsReceived = stats.packetsReceived;
+		this.packetsLost = stats.packetsLost;
+		this.jitter = stats.jitter;
+		this.localId = stats.localId;
+		this.roundTripTime = stats.roundTripTime;
+		this.totalRoundTripTime = stats.totalRoundTripTime;
+		this.fractionLost = stats.fractionLost;
+		this.roundTripTimeMeasurements = stats.roundTripTimeMeasurements;
+		this.attachments = stats.attachments;
+	}
+}

package/src/ObservedRemoteOutboundRtp.ts

@@ -0,0 +1,65 @@
+import { MediaKind } from './common/types';
+import { ObservedPeerConnection } from './ObservedPeerConnection';
+import { RemoteOutboundRtpStats } from './schema/ClientSample';
+
+export class ObservedRemoteOutboundRtp implements RemoteOutboundRtpStats {
+	private _visited = false;
+	public appData?: Record<string, unknown>;
+
+	transportId?: string | undefined;
+	codecId?: string | undefined;
+	packetsSent?: number | undefined;
+	bytesSent?: number | undefined;
+	localId?: string | undefined;
+	remoteTimestamp?: number | undefined;
+	reportsSent?: number | undefined;
+	roundTripTime?: number | undefined;
+	totalRoundTripTime?: number | undefined;
+	roundTripTimeMeasurements?: number | undefined;
+	attachments?: Record<string, unknown> | undefined;
+
+	public constructor(
+		public timestamp: number,
+		public id: string,
+		public ssrc: number,
+		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 getInboundRtp() {
+		return this._peerConnection.observedInboundRtps.get(this.ssrc);
+	}
+
+	public getCodec() {
+		return this._peerConnection.observedCodecs.get(this.codecId ?? '');
+	}
+
+	public update(stats: RemoteOutboundRtpStats) {
+		this._visited = true;
+
+		this.timestamp = stats.timestamp;
+		this.transportId = stats.transportId;
+		this.codecId = stats.codecId;
+		this.packetsSent = stats.packetsSent;
+		this.bytesSent = stats.bytesSent;
+		this.localId = stats.localId;
+		this.remoteTimestamp = stats.remoteTimestamp;
+		this.reportsSent = stats.reportsSent;
+		this.roundTripTime = stats.roundTripTime;
+		this.totalRoundTripTime = stats.totalRoundTripTime;
+		this.roundTripTimeMeasurements = stats.roundTripTimeMeasurements;
+		this.attachments = stats.attachments;
+	}
+}

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