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

package/src/ObservedCall.ts

@@ -6,15 +6,22 @@ import { CalculatedScore } from './scores/CalculatedScore';
 import { DefaultCallScoreCalculator } from './scores/DefaultCallScoreCalculator';
 import { Detectors } from './detectors/Detectors';
 import { RemoteTrackResolver } from './utils/RemoteTrackResolver';
-import { CallUpdater } from './utils/CallUpdater';
-import { OnAllClientCallUpdater } from './utils/OnAllClientCallUpdater';
-import { OnAnyClientCallUpdater } from './utils/onAnyClientCallUpdater';
+import { OnAllClientCallUpdater } from './updaters/OnAllClientCallUpdater';
+import { Updater } from './updaters/Updater';
+import { OnIntervalUpdater } from './updaters/OnIntervalUpdater';
+import { OnAnyClientCallUpdater } from './updaters/OnAnyClientCallUpdater';
+import { ObservedCallEventMonitor } from './ObservedCallEventMonitor';
+import { createLogger } from './common/logger';
+
+const logger = createLogger('ObservedCall');
 
 export type ObservedCallSettings<AppData extends Record<string, unknown> = Record<string, unknown>> = {
 	callId: string;
 	appData?: AppData;
 	remoteTrackResolvePolicy?: 'p2p' | 'mediasoup-sfu',
-	callUpdaterPolicy?: 'onAnyClientUpdate' | 'onAllClientsUpdate',
+	updatePolicy?: 'update-on-any-client-updated' | 'update-when-all-client-updated' | 'update-on-interval',
+	updateIntervalInMs?: number,
+	maxIdleIfEmptyMs?: number,
 };
 
 export type ObservedCallEvents = {
@@ -34,20 +41,57 @@ export declare interface ObservedCall {
 
 export class ObservedCall<AppData extends Record<string, unknown> = Record<string, unknown>> extends EventEmitter {
 	public readonly detectors: Detectors;
+	public updater?: Updater;
+	public scoreCalculator: ScoreCalculator;
 	public readonly callId: string;
 	public readonly observedClients = new Map<string, ObservedClient>();
+	public readonly clientsUsedTurn = new Set<string>();
 	public readonly calculatedScore: CalculatedScore = {
 		weight: 1,
 		value: undefined,
 	};
 	public remoteTrackResolver?: RemoteTrackResolver;
-	public callUpdater?: CallUpdater;
 	
-	public appData?: AppData;
+	public totalAddedClients = 0;
+	public totalRemovedClients = 0;
+
+	public totalClientsReceivedAudioBytes = 0;
+	public totalClientsReceivedVideoBytes = 0;
+	public totalClientsReceivedDataChannelBytes = 0;
+	public totalClientsReceivedBytes = 0;
+
+	public totalClientsSentAudioBytes = 0;
+	public totalClientsSentDataChannelBytes = 0;
+	public totalClientsSentVideoBytes = 0;
+	public totalClientsSentBytes = 0;
+
+	public totalRttLt50Measurements = 0;
+	public totalRttLt150Measurements = 0;
+	public totalRttLt300Measurements = 0;
+	public totalRttGtOrEq300Measurements = 0;
+
+	public numberOfIssues = 0;
+	public numberOfPeerConnections = 0;
+	public numberOfInboundRtpStreams = 0;
+	public numberOfOutboundRtpStreams = 0;
+	public numberOfDataChannels = 0;
+
+	public maxNumberOfClients = 0;
+	public deltaNumberOfIssues = 0;
+
+	public deltaRttLt50Measurements = 0;
+	public deltaRttLt150Measurements = 0;
+	public deltaRttLt300Measurements = 0;
+	public deltaRttGtOrEq300Measurements = 0;
+
+	public appData: AppData;
 	public closed = false;
-	public started?: number;
-	public ended?: number;
-	public scoreCalculator: ScoreCalculator;
+	public startedAt?: number;
+	public endedAt?: number;
+	public closedAt?: number;
+
+	public maxIdleIfEmptyMs?: number;
+	private _autoCloseTimer?: ReturnType<typeof setTimeout>;
 
 	public constructor(
 		settings: ObservedCallSettings<AppData>,
@@ -57,16 +101,31 @@ export class ObservedCall<AppData extends Record<string, unknown> = Record<strin
 		this.setMaxListeners(Infinity);
 
 		this.callId = settings.callId;
-		this.appData = settings.appData;
+		this.appData = settings.appData ?? {} as AppData;
 		this.scoreCalculator = new DefaultCallScoreCalculator(this);
+		this.maxIdleIfEmptyMs = settings.maxIdleIfEmptyMs;
 		this.detectors = new Detectors();
 		
-		switch (settings.callUpdaterPolicy) {
-			case 'onAllClientsUpdate':
-				this.callUpdater = new OnAllClientCallUpdater(this);	
+		if (settings.updateIntervalInMs) {
+			if (settings.updatePolicy !== 'update-on-interval') {
+				throw new Error('updatePolicy must be update-on-interval if updateIntervalInMs is set in config');
+			}
+		}
+		switch (settings.updatePolicy) {
+			case 'update-on-any-client-updated':
+				this.updater = new OnAnyClientCallUpdater(this);	
+				break;
+			case 'update-when-all-client-updated':
+				this.updater = new OnAllClientCallUpdater(this);	
 				break;
-			case 'onAnyClientUpdate':
-				this.callUpdater = new OnAnyClientCallUpdater(this);	
+			case 'update-on-interval': 
+				if (!settings.updateIntervalInMs) {
+					throw new Error('updateIntervalInMs setting in config must be set if updatePolicy is update-on-interval');
+				}
+				this.updater = new OnIntervalUpdater(
+					settings.updateIntervalInMs,
+					this.update.bind(this),
+				);
 				break;
 		}
 
@@ -76,16 +135,35 @@ export class ObservedCall<AppData extends Record<string, unknown> = Record<strin
 		}
 	}
 
+	public get numberOfClients() {
+		return this.observedClients.size;
+	}
+
 	public get score() { 
 		return this.calculatedScore.value; 
 	}
 
 	public close() {
 		if (this.closed) return;
+		this.update(); // last update before closing
 		this.closed = true;
 
-		[ ...this.observedClients.values() ].forEach((client) => client.close());
+		this.updater?.close();
+
+		let minSampleTimestamps: number | undefined;
+		let maxSampleTimestamps: number | undefined;
+
+		for (const client of this.observedClients.values()) {
+			client.close();
+
+			if (client.joinedAt) minSampleTimestamps = Math.min(minSampleTimestamps ?? client.joinedAt, client.joinedAt);
+			if (client.leftAt) maxSampleTimestamps = Math.max(maxSampleTimestamps ?? client.leftAt, client.leftAt);
+		}
+
+		if (this.startedAt === undefined) this.startedAt = minSampleTimestamps;
+		if (this.endedAt === undefined) this.endedAt = maxSampleTimestamps;
 
+		this.closedAt = Date.now();
 		this.emit('close');
 	}
 
@@ -101,33 +179,171 @@ export class ObservedCall<AppData extends Record<string, unknown> = Record<strin
 
 		const result = new ObservedClient<ClientAppData>(settings, this);
 		const wasEmpty = this.observedClients.size === 0;
-		const onUpdate = () => this.callUpdater?.onClientUpdate(result);
+		const onUpdate = () => this._onClientUpdate(result);
+		const joined = () => this._clientJoined(result);
+		const left = () => this._clientLeft(result);
 
 		result.once('close', () => {
 			result.off('update', onUpdate);
+			result.off('joined', joined);
+			result.off('left', left);
 			this.observedClients.delete(settings.clientId);
 
 			if (this.observedClients.size === 0) {
 				this.emit('empty');
+
+				this._createAutoClose();
 			}
+			++this.totalRemovedClients;
 		});
 		result.on('update', onUpdate);
+		result.on('joined', joined);
+		result.on('left', left);
+		++this.totalAddedClients;
 
 		this.observedClients.set(settings.clientId, result);
+		this.maxNumberOfClients = Math.max(this.maxNumberOfClients, this.observedClients.size);
 
 		this.emit('newclient', result);
 
 		if (wasEmpty) {
 			this.emit('not-empty');
+
+			clearTimeout(this._autoCloseTimer);
+			this._autoCloseTimer = undefined;
 		}
 		
 		return result;
 	}
 
+	public createEventMonitor<CTX>(context: CTX): ObservedCallEventMonitor<CTX> {
+		return new ObservedCallEventMonitor(this, context);
+	}
+
 	public update() {
+		if (this.closed) return;
+		
+		this.numberOfInboundRtpStreams = 0;
+		this.numberOfOutboundRtpStreams = 0;
+		this.numberOfPeerConnections = 0;
+		this.numberOfDataChannels = 0;
+
+		for (const client of this.observedClients.values()) {
+			this.numberOfInboundRtpStreams += client.numberOfInboundRtpStreams;
+			this.numberOfOutboundRtpStreams += client.numberOfOutboundRtpStreams;
+			this.numberOfPeerConnections += client.numberOfPeerConnections;
+			this.numberOfDataChannels += client.numberOfDataChannels;
+		}
+
 		this.detectors.update();
 		this.scoreCalculator.update();
 
 		this.emit('update');
+
+		this.deltaNumberOfIssues = 0;
+		this.deltaRttLt50Measurements = 0;
+		this.deltaRttLt150Measurements = 0;
+		this.deltaRttLt300Measurements = 0;
+		this.deltaRttGtOrEq300Measurements = 0;
+	}
+
+	private _onClientUpdate(client: ObservedClient) {
+		this.totalClientsReceivedAudioBytes += client.deltaReceivedAudioBytes;
+		this.totalClientsReceivedVideoBytes += client.deltaReceivedVideoBytes;
+		this.totalClientsReceivedDataChannelBytes += client.deltaDataChannelBytesReceived;
+		this.totalClientsReceivedBytes += client.deltaTransportReceivedBytes;
+		this.totalClientsSentAudioBytes += client.deltaSentAudioBytes;
+		this.totalClientsSentVideoBytes += client.deltaSentVideoBytes;
+		this.totalClientsSentDataChannelBytes += client.deltaDataChannelBytesSent;
+		this.totalClientsSentBytes += client.deltaTransportSentBytes;
+		
+		this.deltaRttLt50Measurements += client.deltaRttLt50Measurements;
+		this.deltaRttLt150Measurements += client.deltaRttLt150Measurements;
+		this.deltaRttLt300Measurements += client.deltaRttLt300Measurements;
+		this.deltaRttGtOrEq300Measurements += client.deltaRttGtOrEq300Measurements;
+
+		this.totalRttLt50Measurements += client.deltaRttLt50Measurements;
+		this.totalRttLt150Measurements += client.deltaRttLt150Measurements;
+		this.totalRttLt300Measurements += client.deltaRttLt300Measurements;
+		this.totalRttGtOrEq300Measurements += client.deltaRttGtOrEq300Measurements;
+
+		this.deltaNumberOfIssues += client.deltaNumberOfIssues;
+		this.numberOfIssues += client.deltaNumberOfIssues;
+		
+		if (client.usingTURN) {
+			this.clientsUsedTurn.add(client.clientId);
+		}
+	}
+
+	private _clientJoined(client: ObservedClient) {
+		if (!client.joinedAt) return;
+
+		this.startedAt = Math.min(this.startedAt ?? client.joinedAt, client.joinedAt);
+	}
+
+	private _clientLeft(client: ObservedClient) {
+		if (!client.leftAt) return;
+
+		this.endedAt = Math.max(this.endedAt ?? client.leftAt, client.leftAt);
+	}
+
+	private _createAutoClose() {
+		if (this.closed) return;
+		if (this.maxIdleIfEmptyMs === undefined || this.maxIdleIfEmptyMs < 1) return;
+
+		this._autoCloseTimer = setTimeout(() => {
+			if (this.closed) return;
+			if (this.observedClients.size > 0) return;
+
+			logger.debug(`Call ${this.callId} is empty for ${this.maxIdleIfEmptyMs}ms, closing...`);
+			this.close();
+		}, this.maxIdleIfEmptyMs);
 	}
+
+	// public resetSummaryMetrics() {
+	// 	this.totalAddedClients = 0;
+	// 	this.totalRemovedClients = 0;
+
+	// 	this.totalClientsReceivedAudioBytes = 0;
+	// 	this.totalClientsReceivedVideoBytes = 0;
+	// 	this.totalClientsReceivedBytes = 0;
+
+	// 	this.totalClientsSentAudioBytes = 0;
+	// 	this.totalClientsSentVideoBytes = 0;
+	// 	this.totalClientsSentBytes = 0;
+
+	// 	this.totalRttLt50Measurements = 0;
+	// 	this.totalRttLt150Measurements = 0;
+	// 	this.totalRttLt300Measurements = 0;
+	// 	this.totalRttGtOrEq300Measurements = 0;
+
+	// 	this.numberOfIssues = 0;
+
+	// 	this.clientsUsedTurn.clear();
+		
+	// }
+
+	// public createSummary(): ObservedCallSummary {
+	// 	return {
+	// 		currentActiveClients: this.observedClients.size,
+	// 		totalAddedClients: this.totalAddedClients,
+	// 		totalRemovedClients: this.totalRemovedClients,
+			
+	// 		totalClientsReceivedAudioBytes: this.totalClientsReceivedBytes,
+	// 		totalClientsReceivedVideoBytes: this.totalClientsReceivedVideoBytes,
+	// 		totalClientsReceivedBytes: this.totalClientsReceivedBytes,
+
+	// 		totalClientsSentAudioBytes: this.totalClientsSentAudioBytes,
+	// 		totalClientsSentVideoBytes: this.totalClientsSentVideoBytes,
+	// 		totalClientsSentBytes: this.totalClientsSentBytes,
+
+	// 		totalRttLt50Measurements: this.totalRttLt50Measurements,
+	// 		totalRttLt150Measurements: this.totalRttLt150Measurements,
+	// 		totalRttLt300Measurements: this.totalRttLt300Measurements,
+	// 		totalRttGtOrEq300Measurements: this.totalRttGtOrEq300Measurements,
+
+	// 		numberOfIssues: this.numberOfIssues,
+	// 		numberOfClientsUsedTurn: this.clientsUsedTurn.size,
+	// 	};
+	// }
 }