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

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

package/src/Observer.ts

@@ -1,21 +1,36 @@
 import { createLogger } from './common/logger';
-import { Middleware, MiddlewareProcessor } from './common/Middleware';
 import { ObservedCall, ObservedCallSettings } from './ObservedCall';
 import { EventEmitter } from 'events';
-import { ClientEvent, ClientMetaData, ClientIssue, ExtensionStat } from './schema/ClientSample';
+import { ClientEvent, ClientMetaData, ClientIssue, ExtensionStat, ClientSample } from './schema/ClientSample';
 import { ObservedClient } from './ObservedClient';
+import { ObservedTURN } from './ObservedTURN';
+import { Detectors } from './detectors/Detectors';
+import { Updater } from './updaters/Updater';
+import { OnIntervalUpdater } from './updaters/OnIntervalUpdater';
+import { OnAllCallObserverUpdater } from './updaters/OnAllCallObserverUpdater';
+import { OnAnyCallObserverUpdater } from './updaters/OnAnyCallObserverUpdater';
+import { ObserverEventMonitor } from './ObserverEventMonitor';
+import { MediasoupRemoteTrackResolver } from './utils/MediasoupRemoteTrackResolver';
 
 const logger = createLogger('Observer');
 
 export type ObserverEvents = {
+	'client-event': [ObservedClient, ClientEvent];
+	'call-updated': [ObservedCall],
+	'client-issue': [ObservedClient, ClientIssue],
+	'client-metadata': [ObservedClient, ClientMetaData],
+	'client-extension-stats': [ObservedClient, ExtensionStat],
 	'newcall': [ObservedCall],
+	'update': [],
 	'close': [],
 }
 
-export type ProcessorInputContext<T> = {
-	call: ObservedCall;
-	client: ObservedClient;
-	data: T;
+export type ObserverConfig<AppData extends Record<string, unknown> = Record<string, unknown>> = {
+	updatePolicy?: 'update-on-any-call-updated' | 'update-when-all-call-updated' | 'update-on-interval',
+	updateIntervalInMs?: number,
+	defaultCallUpdatePolicy?: ObservedCallSettings['updatePolicy'],
+	defaultCallUpdateIntervalInMs?: number,
+	appData?: AppData,
 }
 
 export declare interface Observer {
@@ -25,21 +40,80 @@ export declare interface Observer {
 	emit<U extends keyof ObserverEvents>(event: U, ...args: ObserverEvents[U]): boolean;
 }
 
-export class Observer extends EventEmitter {
-	public readonly processors = {
-		events: new MiddlewareProcessor<ProcessorInputContext<ClientEvent>>(),
-		metaData: new MiddlewareProcessor<ProcessorInputContext<ClientMetaData>>(),
-		issues: new MiddlewareProcessor<ProcessorInputContext<ClientIssue>>(),
-		extensionStats: new MiddlewareProcessor<ProcessorInputContext<ExtensionStat>>(),
-	};
+export class Observer<AppData extends Record<string, unknown> = Record<string, unknown>> extends EventEmitter {
+	public readonly detectors: Detectors;
 
+	public readonly observedTURN = new ObservedTURN();
 	public readonly observedCalls = new Map<string, ObservedCall>();
+	public updater?: Updater;
+	
 	public closed = false;
 
-	public constructor(
-	) {
+	public totalAddedCall = 0;
+	public totalRemovedCall = 0;
+	public totalRttLt50Measurements = 0;
+	public totalRttLt150Measurements = 0;
+	public totalRttLt300Measurements = 0;
+	public totalRttGtOrEq300Measurements = 0;
+	public totalClientIssues = 0;
+
+	public numberOfClientsUsingTurn = 0;
+	public numberOfClients = 0;
+	public numberOfInboundRtpStreams = 0;
+	public numberOfOutboundRtpStreams = 0;
+	public numberOfDataChannels = 0;
+	public numberOfPeerConnections = 0;
+	
+	public get numberOfCalls() {
+		return this.observedCalls.size;
+	}
+
+	private _timer?: ReturnType<typeof setInterval>;
+
+	public constructor(public readonly config: ObserverConfig<AppData> = {
+		updatePolicy: 'update-when-all-call-updated',
+		updateIntervalInMs: undefined,
+		appData: {} as AppData,
+	}) {
 		super();
 		this.setMaxListeners(Infinity);
+		this.update = this.update.bind(this);
+
+		if (this.config.updateIntervalInMs) {
+			if (this.config.updatePolicy && this.config.updatePolicy !== 'update-on-interval') {
+				throw new Error('update policy must be update-on-interval if updateIntervalInMs is set in config');
+			}
+			this._timer = setInterval(this.update.bind(this), this.config.updateIntervalInMs);
+		}
+
+		if (this.config.updateIntervalInMs) {
+			if (this.config.updatePolicy !== 'update-on-interval') {
+				throw new Error('updatePolicy must be update-on-interval if updateIntervalInMs is set in config');
+			}
+		}
+		switch (this.config.updatePolicy) {
+			case 'update-on-any-call-updated':
+				this.updater = new OnAllCallObserverUpdater(this);	
+				break;
+			case 'update-when-all-call-updated':
+				this.updater = new OnAnyCallObserverUpdater(this);	
+				break;
+			case 'update-on-interval': 
+				if (!this.config.updateIntervalInMs) {
+					throw new Error('updateIntervalInMs setting in config must be set if updatePolicy is update-on-interval');
+				}
+				this.updater = new OnIntervalUpdater(
+					this.config.updateIntervalInMs,
+					this.update.bind(this),
+				);
+				break;
+		}
+		
+		this.detectors = new Detectors();
+	}
+
+	public get appData() {
+		return this.config.appData;
 	}
 
 	public getObservedCall<T extends Record<string, unknown> = Record<string, unknown>>(callId: string): ObservedCall<T> | undefined {
@@ -54,86 +128,127 @@ export class Observer extends EventEmitter {
 		if (this.closed) {
 			throw new Error('Attempted to create a call source on a closed observer');
 		}
-
+		if (!settings.updatePolicy) {
+			settings.updatePolicy = this.config.defaultCallUpdatePolicy;
+			settings.updateIntervalInMs = this.config.defaultCallUpdateIntervalInMs;
+		}
 		const observedCall = new ObservedCall(settings, this);
+		const onCallUpdated = () => this._onObservedCallUpdated(observedCall);
 
 		if (this.observedCalls.has(observedCall.callId)) throw new Error(`Observed Call with id ${observedCall.callId} already exists`);
 
+		if (settings.remoteTrackResolvePolicy === 'mediasoup-sfu') {
+			observedCall.remoteTrackResolver = new MediasoupRemoteTrackResolver(observedCall);
+		}
+
 		observedCall.once('close', () => {
 			this.observedCalls.delete(observedCall.callId);
+			observedCall.off('update', onCallUpdated);
+			++this.totalRemovedCall;
 		});
 
 		this.observedCalls.set(observedCall.callId, observedCall);
+		observedCall.on('update', onCallUpdated);
+		++this.totalAddedCall;
 
 		this.emit('newcall', observedCall);
 		
 		return observedCall;
 	}
 
-	public addClientEventMiddleware(...middlewares: Middleware<ProcessorInputContext<ClientEvent>>[]): Observer {
-
-		this.processors.events.addMiddleware(...middlewares);
-
-		return this;
-	}
-
-	public removeClientEventMiddleware(...middlewares: Middleware<ProcessorInputContext<ClientEvent>>[]): Observer {
-
-		this.processors.events.removeMiddleware(...middlewares);
+	public close() {
+		if (this.closed) {
+			return logger.debug('Attempted to close twice');
+		}
+		this.closed = true;
+		clearInterval(this._timer);
+		this._timer = undefined;
 
-		return this;
+		this.observedCalls.forEach((call) => call.close());
+		
+		this.emit('close');
 	}
 
-	public addClientMetaDataMiddleware(...middlewares: Middleware<ProcessorInputContext<ClientMetaData>>[]): Observer {
+	public accept(sample: ClientSample) {
+		if (this.closed) return;
+		if (!sample.callId) return logger.warn('Received sample without callId. %o', sample);
+		if (!sample.clientId) return logger.warn('Received sample without clientId %o', sample);
 
-		this.processors.metaData.addMiddleware(...middlewares);
-
-		return this;
-	}
-
-	public removeClientMetaDataMiddleware(...middlewares: Middleware<ProcessorInputContext<ClientMetaData>>[]): Observer {
+		const call = this.getObservedCall(sample.callId) ?? this.createObservedCall({
+			callId: sample.callId,
+			updateIntervalInMs: this.config.defaultCallUpdateIntervalInMs,
+			updatePolicy: this.config.defaultCallUpdatePolicy,
+		});
 
-		this.processors.metaData.removeMiddleware(...middlewares);
+		const client = call.getObservedClient(sample.clientId) ?? call.createObservedClient({
+			clientId: sample.clientId,
+		});
 
-		return this;
+		client.accept(sample);
 	}
 
-	public addClientIssueMiddleware(...middlewares: Middleware<ProcessorInputContext<ClientIssue>>[]): Observer {
-
-		this.processors.issues.addMiddleware(...middlewares);
-
-		return this;
-	}
+	public update() {
+		if (this.closed) {
+			return;
+		}
 
-	public removeClientIssueMiddleware(...middlewares: Middleware<ProcessorInputContext<ClientIssue>>[]): Observer {
+		this.numberOfInboundRtpStreams = 0;
+		this.numberOfOutboundRtpStreams = 0;
+		this.numberOfPeerConnections = 0;
+		this.numberOfDataChannels = 0;
+		this.numberOfClients = 0;
+		this.numberOfClientsUsingTurn = 0;
+
+		for (const call of this.observedCalls.values()) {
+			this.numberOfInboundRtpStreams += call.numberOfInboundRtpStreams;
+			this.numberOfOutboundRtpStreams += call.numberOfOutboundRtpStreams;
+			this.numberOfPeerConnections += call.numberOfPeerConnections;
+			this.numberOfDataChannels += call.numberOfDataChannels;
+			this.numberOfClients += call.numberOfClients;
+			this.numberOfClientsUsingTurn += call.clientsUsedTurn.size;
+		}
 
-		this.processors.issues.removeMiddleware(...middlewares);
+		this.observedTURN.update();
 
-		return this;
+		this.emit('update');
 	}
 
-	public addExtensionStatMiddleware(...middlewares: Middleware<ProcessorInputContext<ExtensionStat>>[]): Observer {
-
-		this.processors.extensionStats.addMiddleware(...middlewares);
-
-		return this;
+	private _onObservedCallUpdated(call: ObservedCall) {
+		this.totalRttLt50Measurements += call.deltaRttLt50Measurements;
+		this.totalRttLt150Measurements += call.deltaRttLt150Measurements;
+		this.totalRttLt300Measurements += call.deltaRttLt300Measurements;
+		this.totalRttGtOrEq300Measurements += call.deltaRttGtOrEq300Measurements;
+		this.totalClientIssues += call.deltaNumberOfIssues;
 	}
 
-	public removeExtensionStatMiddleware(...middlewares: Middleware<ProcessorInputContext<ExtensionStat>>[]): Observer {
-
-		this.processors.extensionStats.removeMiddleware(...middlewares);
-
-		return this;
+	public createEventMonitor<CTX = unknown>(ctx?: CTX): ObserverEventMonitor<CTX> {
+		return new ObserverEventMonitor<CTX>(this, ctx ?? {} as CTX);
 	}
 
-	public close() {
-		if (this.closed) {
-			return logger.debug('Attempted to close twice');
-		}
-		this.closed = true;
+	// public resetSummaryMetrics() {
+	// 	this.totalAddedCall = 0;
+	// 	this.totalRemovedCall = 0;
+	// 	this.totalRttLt50Measurements = 0;
+	// 	this.totalRttLt150Measurements = 0;
+	// 	this.totalRttLt300Measurements = 0;
+	// 	this.totalRttGtOrEq300Measurements = 0;
+	// 	this.totalClientIssues = 0;
+	// }
+
+	// public createSummary(): ObserverSummary {
+	// 	return {
+	// 		totalAddedCall: this.totalAddedCall,
+	// 		totalRemovedCall: this.totalRemovedCall,
+	// 		totalRttLt50Measurements: this.totalRttLt50Measurements,
+	// 		totalRttLt150Measurements: this.totalRttLt150Measurements,
+	// 		totalRttLt300Measurements: this.totalRttLt300Measurements,
+	// 		totalRttGtOrEq300Measurements: this.totalRttGtOrEq300Measurements,
+
+	// 		totalClientIssues: this.totalClientIssues,
+	// 		currentActiveCalls: this.observedCalls.size,
+	// 		currentNumberOfClients: this.numberOfClients,
+	// 		currentNumberOfClientsUsingTURN: this.numberOfClientsUsedTurn,
+	// 	};
+	// }
 
-		this.observedCalls.forEach((call) => call.close());
-		
-		this.emit('close');
-	}
 }