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

package/lib/updaters/OnAnyCallObserverUpdater_.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnAnyCallObserverUpdater = void 0;
+class OnAnyCallObserverUpdater {
+    observver;
+    name = 'OnAnyCallObserverUpdater';
+    description = 'Call Observer\'s update() method on any of the ObservedCall is updated';
+    constructor(observver) {
+        this.observver = observver;
+        this._onNewObservedCall = this._onNewObservedCall.bind(this);
+        this.observver.once('close', () => {
+            this.observver.off('newcall', this._onNewObservedCall);
+        });
+        this.observver.on('newcall', this._onNewObservedCall);
+    }
+    close() {
+        // do nothing, because we unsubscribe once close is emitted from observer
+    }
+    _onNewObservedCall(observedCall) {
+        const onUpdate = () => this.observver.update();
+        observedCall.once('close', () => {
+            observedCall.off('update', onUpdate);
+        });
+        observedCall.on('update', onUpdate);
+    }
+}
+exports.OnAnyCallObserverUpdater = OnAnyCallObserverUpdater;

package/lib/updaters/OnAnyClientCallUpdater.d.ts

@@ -0,0 +1,11 @@
+import { ObservedCall } from '../ObservedCall';
+import { Updater } from './Updater';
+export declare class OnAnyClientCallUpdater implements Updater {
+    private _observedCall;
+    readonly name = "OnAnyClientCallUpdater";
+    readonly description = "Call the update() method of the ObservedCall when any of the client has been updated";
+    constructor(_observedCall: ObservedCall);
+    close(): void;
+    private _onNewObservedClient;
+}
+//# sourceMappingURL=OnAnyClientCallUpdater.d.ts.map

package/lib/updaters/OnAnyClientCallUpdater.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OnAnyClientCallUpdater.d.ts","sourceRoot":"","sources":["../../src/updaters/OnAnyClientCallUpdater.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE/C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,qBAAa,sBAAuB,YAAW,OAAO;IAKpD,OAAO,CAAC,aAAa;IAJtB,QAAQ,CAAC,IAAI,4BAA4B;IACzC,QAAQ,CAAC,WAAW,0FAA0F;gBAGrG,aAAa,EAAE,YAAY;IAU7B,KAAK,IAAI,IAAI;IAIpB,OAAO,CAAC,oBAAoB;CAQ5B"}

package/lib/updaters/OnAnyClientCallUpdater.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnAnyClientCallUpdater = void 0;
+class OnAnyClientCallUpdater {
+    _observedCall;
+    name = 'OnAnyClientCallUpdater';
+    description = 'Call the update() method of the ObservedCall when any of the client has been updated';
+    constructor(_observedCall) {
+        this._observedCall = _observedCall;
+        this._onNewObservedClient = this._onNewObservedClient.bind(this);
+        this._observedCall.once('close', () => {
+            this._observedCall.off('newclient', this._onNewObservedClient);
+        });
+        this._observedCall.on('newclient', this._onNewObservedClient);
+    }
+    close() {
+        // do nothing, as close once emitted unsubscription happened
+    }
+    _onNewObservedClient(observedClient) {
+        const onUpdate = () => this._observedCall.update();
+        observedClient.once('close', () => {
+            observedClient.off('update', onUpdate);
+        });
+        observedClient.on('update', onUpdate);
+    }
+}
+exports.OnAnyClientCallUpdater = OnAnyClientCallUpdater;

package/lib/updaters/OnIntervalUpdater.d.ts

@@ -0,0 +1,10 @@
+import { Updater } from './Updater';
+export declare class OnIntervalUpdater implements Updater {
+    private readonly _update;
+    readonly name = "OnIntervalUpdater";
+    readonly description = "Call the update() method given in the constructor once the interval elapsed";
+    timer: ReturnType<typeof setInterval>;
+    constructor(intervalInMs: number, _update: () => void);
+    close(): void;
+}
+//# sourceMappingURL=OnIntervalUpdater.d.ts.map

package/lib/updaters/OnIntervalUpdater.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OnIntervalUpdater.d.ts","sourceRoot":"","sources":["../../src/updaters/OnIntervalUpdater.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,qBAAa,iBAAkB,YAAW,OAAO;IAQ/C,OAAO,CAAC,QAAQ,CAAC,OAAO;IAPzB,QAAQ,CAAC,IAAI,uBAAuB;IACpC,QAAQ,CAAC,WAAW,iFAAiF;IAE9F,KAAK,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;gBAG5C,YAAY,EAAE,MAAM,EACH,OAAO,EAAE,MAAM,IAAI;IAK9B,KAAK,IAAI,IAAI;CAGpB"}

package/lib/updaters/OnIntervalUpdater.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnIntervalUpdater = void 0;
+class OnIntervalUpdater {
+    _update;
+    name = 'OnIntervalUpdater';
+    description = 'Call the update() method given in the constructor once the interval elapsed';
+    timer;
+    constructor(intervalInMs, _update) {
+        this._update = _update;
+        this.timer = setInterval(() => this._update(), intervalInMs);
+    }
+    close() {
+        clearInterval(this.timer);
+    }
+}
+exports.OnIntervalUpdater = OnIntervalUpdater;

package/lib/updaters/Updater.d.ts

@@ -0,0 +1,6 @@
+export interface Updater {
+    readonly name: string;
+    readonly description?: string;
+    close(): void;
+}
+//# sourceMappingURL=Updater.d.ts.map

package/lib/updaters/Updater.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Updater.d.ts","sourceRoot":"","sources":["../../src/updaters/Updater.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,OAAO;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,KAAK,IAAI,IAAI,CAAC;CACd"}

package/lib/updaters/Updater.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@observertc/observer-js",
-  "version": "1.0.1-c3edea3.0",
+  "version": "1.0.1-ec27289.0",
   "description": "Server Side NodeJS Library for processing ObserveRTC Samples",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/src/ObservedCall.ts

@@ -6,15 +6,17 @@ 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';
 
 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,
 };
 
 export type ObservedCallEvents = {
@@ -34,20 +36,62 @@ 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;
+
+	private _callStartedEvent: {
+		emitted: boolean,
+		timer?: ReturnType<typeof setTimeout>,
+	};
+	private _callEndedEvent: {
+		emitted: boolean
+	};
 
 	public constructor(
 		settings: ObservedCallSettings<AppData>,
@@ -57,16 +101,30 @@ 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.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 OnAllClientCallUpdater(this);	
+				break;
+			case 'update-when-all-client-updated':
+				this.updater = new OnAnyClientCallUpdater(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;
 		}
 
@@ -74,6 +132,17 @@ export class ObservedCall<AppData extends Record<string, unknown> = Record<strin
 			case 'mediasoup-sfu':
 				break;
 		}
+
+		this._callStartedEvent = {
+			emitted: false,
+		};
+		this._callEndedEvent = {
+			emitted: false,
+		};
+	}
+
+	public get numberOfClients() {
+		return this.observedClients.size;
 	}
 
 	public get score() { 
@@ -82,10 +151,14 @@ export class ObservedCall<AppData extends Record<string, unknown> = Record<strin
 
 	public close() {
 		if (this.closed) return;
+		this.update(); // last update before closing
 		this.closed = true;
 
+		this.updater?.close();
+
 		[ ...this.observedClients.values() ].forEach((client) => client.close());
 
+		this.closedAt = Date.now();
 		this.emit('close');
 	}
 
@@ -101,19 +174,28 @@ 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.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);
 
@@ -125,9 +207,116 @@ export class ObservedCall<AppData extends Record<string, unknown> = Record<strin
 	}
 
 	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);
+	}
+
+	// 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,
+	// 	};
+	// }
 }

package/src/ObservedCallSummary.ts

@@ -0,0 +1,22 @@
+export type ObservedCallSummary = {
+	currentActiveClients: number;
+	
+	totalAddedClients: number;
+	totalRemovedClients: number;
+    
+	totalClientsSentBytes: number,
+	totalClientsReceivedBytes: number,
+	totalClientsReceivedAudioBytes: number,
+	totalClientsReceivedVideoBytes: number,
+	totalClientsSentAudioBytes: number,
+	totalClientsSentVideoBytes: number,
+    
+	totalRttLt50Measurements: number,
+	totalRttLt150Measurements: number,
+	totalRttLt300Measurements: number,
+	totalRttGtOrEq300Measurements: number,
+    
+	numberOfIssues: number,
+    
+	numberOfClientsUsedTurn: number;
+}