@observertc/observer-js 0.42.8 → 1.0.0-5f150eb.0

package/src/ObservedCall.ts

@@ -1,26 +1,31 @@
 import { EventEmitter } from 'events';
-import { ObservedClient, ObservedClientModel } from './ObservedClient';
+import { ObservedClient, ObservedClientSettings } from './ObservedClient';
 import { Observer } from './Observer';
-import { createClientJoinedEventReport, createClientLeftEventReport } from './common/callEventReports';
-import { getMedian, PartialBy } from './common/utils';
-import { CallEventReport } from '@observertc/report-schemas-js';
-import { createProcessor } from './common/Middleware';
-import { ClientSample } from '@observertc/sample-schemas-js';
-import { ObservedOutboundAudioTrack } from './ObservedOutboundAudioTrack';
-import { ObservedOutboundVideoTrack } from './ObservedOutboundVideoTrack';
-import { CalculatedScore } from './common/CalculatedScore';
-
-export type ObservedCallModel = {
-	serviceId: string;
-	roomId: string;
+import { ScoreCalculator } from './scores/ScoreCalculator';
+import { CalculatedScore } from './scores/CalculatedScore';
+import { DefaultCallScoreCalculator } from './scores/DefaultCallScoreCalculator';
+import { Detectors } from './detectors/Detectors';
+import { RemoteTrackResolver } from './utils/RemoteTrackResolver';
+import { OnAllClientCallUpdater } from './updaters/OnAllClientCallUpdater';
+import { Updater } from './updaters/Updater';
+import { OnIntervalUpdater } from './updaters/OnIntervalUpdater';
+import { OnAnyClientCallUpdater } from './updaters/OnAnyClientCallUpdater';
+import { ObservedCallEventMonitor } from './ObservedCallEventMonitor';
+
+export type ObservedCallSettings<AppData extends Record<string, unknown> = Record<string, unknown>> = {
 	callId: string;
+	appData?: AppData;
+	remoteTrackResolvePolicy?: 'p2p' | 'mediasoup-sfu' | 'none',
+	updatePolicy?: 'update-on-any-client-updated' | 'update-when-all-client-updated' | 'update-on-interval',
+	updateIntervalInMs?: number,
+	closeCallIfEmptyForMs?: number,
 };
 
 export type ObservedCallEvents = {
 	update: [],
 	newclient: [ObservedClient],
-	callevent: [Omit<CallEventReport, 'callId' | 'serviceId' | 'roomId'>],
 	empty: [],
+	'not-empty': [],
 	close: [],
 }
 
@@ -32,195 +37,272 @@ export declare interface ObservedCall {
 }
 
 export class ObservedCall<AppData extends Record<string, unknown> = Record<string, unknown>> extends EventEmitter {
-	public readonly created = Date.now();
+	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 totalAddedClients = 0;
+	public totalRemovedClients = 0;
 
-	public readonly processor = createProcessor<ClientSample>();
+	public numberOfIssues = 0;
+	public numberOfPeerConnections = 0;
+	public numberOfInboundRtpStreams = 0;
+	public numberOfOutboundRtpStreams = 0;
+	public numberOfDataChannels = 0;
 
-	private readonly _clients = new Map<string, ObservedClient>();
-	
-	public _scoreData?: {
-		score: CalculatedScore,
-		calculated: number,
-	};
+	public maxNumberOfClients = 0;
+	public deltaNumberOfIssues = 0;
+
+	// public deltaRttLt50Measurements = 0;
+	// public deltaRttLt150Measurements = 0;
+	// public deltaRttLt300Measurements = 0;
+	// public deltaRttGtOrEq300Measurements = 0;
 
-	public readonly sfuStreamIdToOutboundAudioTrack = new Map<string | number, ObservedOutboundAudioTrack>();
-	public readonly sfuStreamIdToOutboundVideoTrack = new Map<string | number, ObservedOutboundVideoTrack>();
-	private _closed = false;
-	// this changes as clients emitting their joined event, as the call starts when the first client joins
-	public started?: number;
-	// this changes as clients emitting their left event, as the call ends when the last client leaves
-	public ended?: number;
+	public appData: AppData;
+	public closed = false;
+	public startedAt?: number;
+	public endedAt?: number;
+	public closedAt?: number;
 
-	public observationUpdated = Date.now();
-	public observationEnded?: number;
-	public readonly observationStarted = Date.now();
+	public readonly settings: Pick<ObservedCallSettings, 'closeCallIfEmptyForMs'>;
+	private closeTimer?: ReturnType<typeof setTimeout>;
 
 	public constructor(
-		private readonly _model: ObservedCallModel,
+		settings: ObservedCallSettings<AppData>,
 		public readonly observer: Observer,
-		public readonly appData: AppData,
 	) {
 		super();
 		this.setMaxListeners(Infinity);
-	}
 
-	public get serviceId(): string {
-		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		return this._model.serviceId!;
-	}
+		this.callId = settings.callId;
+		this.appData = settings.appData ?? {} as AppData;
+		this.scoreCalculator = new DefaultCallScoreCalculator(this);
+		this.detectors = new Detectors();
+		
+		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 '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;
+		}
 
-	public get reports() {
-		return this.observer.reports;
-	}
+		switch (settings.remoteTrackResolvePolicy) {
+			case 'mediasoup-sfu':
+				break;
+		}
 
-	public get roomId() {
-		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		return this._model.roomId!;
+		this.settings = {
+			closeCallIfEmptyForMs: settings.closeCallIfEmptyForMs,
+		};
 	}
 
-	public get callId() {
-		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		return this._model.callId!;
+	public get numberOfClients() {
+		return this.observedClients.size;
 	}
 
-	public get clients(): ReadonlyMap<string, ObservedClient> {
-		return this._clients;
+	public get score() { 
+		return this.calculatedScore.value; 
 	}
 
-	public get score(): CalculatedScore | undefined {
-		const now = Date.now();
-
-		if (now - 15000 < (this._scoreData?.calculated ?? 0)) {
-			return this._scoreData?.score;
-		} else if (this.clients.size < 1) {
-			return {
-				remarks: [ {
-					severity: 'none',
-					text: 'No clients',
-				} ],
-				score: 5.0,
-				timestamp: now,
-			};
-		}
-		const scores = [ ...this.clients.values() ].map((client) => client.score?.score ?? 5.0);
-
-		this._scoreData = {
-			score: {
-				remarks: [],
-				score: getMedian(scores),
-				timestamp: now,
-			},
-			calculated: now,
-		};
+	public close() {
+		if (this.closed) return;
+		this.update(); // last update before closing
+		this.closed = true;
 
-		return this._scoreData.score;
-	}
+		this.updater?.close();
 
-	public get closed() {
-		return this._closed;
-	}
+		let minSampleTimestamps: number | undefined;
+		let maxSampleTimestamps: number | undefined;
 
-	public close() {
-		if (this._closed) return;
-		this._closed = true;
+		for (const client of this.observedClients.values()) {
+			client.close();
 
-		Array.from(this._clients.values()).forEach((client) => client.close());
+			if (client.joinedAt) minSampleTimestamps = Math.min(minSampleTimestamps ?? client.joinedAt, client.joinedAt);
+			if (client.leftAt) maxSampleTimestamps = Math.max(maxSampleTimestamps ?? client.leftAt, client.leftAt);
+		}
 
-		this.observationEnded = Date.now();
-		
+		if (this.startedAt === undefined) this.startedAt = minSampleTimestamps;
+		if (this.endedAt === undefined) this.endedAt = maxSampleTimestamps;
+
+		this.closedAt = Date.now();
 		this.emit('close');
 	}
 
-	public addEventReport(params: PartialBy<Omit<CallEventReport, 'serviceId' | 'roomId' | 'callId' >, 'timestamp'>) {
-		this.reports.addCallEventReport({
-			...params,
-			serviceId: this.serviceId,
-			roomId: this.roomId,
-			callId: this.callId,
-			timestamp: params.timestamp ?? Date.now(),
-		});
+	public getObservedClient<ClientAppData extends Record<string, unknown> = Record<string, unknown>>(clientId: string): ObservedClient<ClientAppData> | undefined {
+		if (this.closed || !this.observedClients.has(clientId)) return;
+		
+		return this.observedClients.get(clientId) as ObservedClient<ClientAppData>;
 	}
 
-	public createClient<ClientAppData extends Record<string, unknown> = Record<string, unknown>>(config: ObservedClientModel & { 
-		appData: ClientAppData, 
-		// in case we generate the CLIENT_JOINED report we can set the timestamp of the event
-		// in that case we should set the client.left to the timestamp of the leaving.
-		// by default the timestamp is set to the current time
-		joinedTimestamp?: number,
-		createClientJoinedReport?: boolean, 
-		createClientLeftReport?: boolean,
-	}) {
-		if (this._closed) throw new Error(`Call ${this.callId} is closed`);
-
-		const { 
-			appData, 
-			createClientJoinedReport, 
-			createClientLeftReport,
-			joinedTimestamp = Date.now(), 
-			...model 
-		} = config;
-		
-		const result = new ObservedClient(model, this, appData);
-		const onUpdate = ({ sample }: { sample: ClientSample }) => {
-			this.observationUpdated = Date.now();
-			if (result.joined) {
-				if (this.started === undefined || result.joined < this.started) {
-					this.started = result.joined;
-				}
-			}
-			if (result.left) {
-				if (this.ended === undefined || result.left > this.ended) {
-					this.ended = result.left;
-				}
-			}
+	public createObservedClient<ClientAppData extends Record<string, unknown> = Record<string, unknown>>(settings: ObservedClientSettings<ClientAppData>): ObservedClient<ClientAppData> {
+		if (this.closed) throw new Error(`Call ${this.callId} is closed`);
+		if (this.observedClients.has(settings.clientId)) throw new Error(`Client with id ${settings.clientId} already exists`);
 
-			this.emit('update');
+		if (!settings.closeClientIfIdleForMs) {
+			settings.closeClientIfIdleForMs = this.observer.config.closeClientIfIdleForMs;
+		}
 
-			this.processor.process(sample);
-		};
+		const result = new ObservedClient<ClientAppData>(settings, this);
+		const wasEmpty = this.observedClients.size === 0;
+		const onUpdate = () => this._onClientUpdate(result);
+		const joined = () => this._clientJoined(result);
+		const left = () => this._clientLeft(result);
 
 		result.once('close', () => {
 			result.off('update', onUpdate);
-			this._clients.delete(result.clientId);
-			
-			if (this._clients.size === 0) {
+			result.off('joined', joined);
+			result.off('left', left);
+			this.observedClients.delete(settings.clientId);
+
+			if (this.observedClients.size === 0) {
 				this.emit('empty');
+
+				if (this.settings.closeCallIfEmptyForMs) {
+					this.closeTimer = setTimeout(() => {
+						this.close();
+					}, this.settings.closeCallIfEmptyForMs);
+				}
 			}
+			++this.totalRemovedClients;
 		});
-
 		result.on('update', onUpdate);
-		this._clients.set(result.clientId, result);
-
-		if (createClientJoinedReport) {
-			this.reports.addCallEventReport(createClientJoinedEventReport(
-				this.serviceId,
-				result.mediaUnitId,
-				this.roomId,
-				this.callId,
-				result.clientId,
-				result.joined ?? joinedTimestamp,
-				result.userId,
-				result.marker,
-			));
-		}
+		result.on('joined', joined);
+		result.on('left', left);
+		++this.totalAddedClients;
 
-		result.once('close', () => {
-			if (createClientLeftReport) {
-				this.reports.addCallEventReport(createClientLeftEventReport(
-					this.serviceId,
-					result.mediaUnitId,
-					this.roomId,
-					this.callId,
-					result.clientId,
-					result.left ?? Date.now(),
-					result.userId,
-					result.marker,
-				));
-			}
-		});
+		this.observedClients.set(settings.clientId, result);
+		this.maxNumberOfClients = Math.max(this.maxNumberOfClients, this.observedClients.size);
+
+		if (this.closeTimer) {
+			clearTimeout(this.closeTimer);
+			this.closeTimer = undefined;
+		}
 
 		this.emit('newclient', result);
+
+		if (wasEmpty) {
+			this.emit('not-empty');
+		}
 		
 		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;
+	}
+
+	private _onClientUpdate(client: ObservedClient) {
+		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);
+	}
+
+	// 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,
+	// 	};
+	// }
 }