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

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/lib/utils/MediasoupRemoteTrackResolver.d.ts

@@ -0,0 +1,25 @@
+import { ObservedCall } from '../ObservedCall';
+import { ObservedCallEventMonitor } from '../ObservedCallEventMonitor';
+import { ObservedInboundTrack } from '../ObservedInboundTrack';
+import { ObservedOutboundTrack } from '../ObservedOutboundTrack';
+import { RemoteTrackResolver } from './RemoteTrackResolver';
+export declare class MediasoupRemoteTrackResolver implements RemoteTrackResolver {
+    readonly observedCall: ObservedCall;
+    readonly eventMonitor: ObservedCallEventMonitor<{}>;
+    private _consumerIdToProducerId;
+    private _producerIdToOutboundTrack;
+    private _consumerIdToInboundTrack;
+    private _inboundTrackToConsumerId;
+    private _producerIdToConsumerIds;
+    private _outboundTrackToProducerId;
+    constructor(observedCall: ObservedCall);
+    resolveRemoteOutboundTrack(inboundTrack: ObservedInboundTrack): ObservedOutboundTrack | undefined;
+    resolveRemoteInboundTracks(outboundTrack: ObservedOutboundTrack): ObservedInboundTrack[] | undefined;
+    private _addInboundTrack;
+    private _removeInboundTrack;
+    private _addOutboundTrack;
+    private _removeOutboundTrack;
+    private _getInboundTrackAttachments;
+    private _getOutboundTrackAttachments;
+}
+//# sourceMappingURL=MediasoupRemoteTrackResolver.d.ts.map

package/lib/utils/MediasoupRemoteTrackResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MediasoupRemoteTrackResolver.d.ts","sourceRoot":"","sources":["../../src/utils/MediasoupRemoteTrackResolver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,wBAAwB,EAAE,MAAM,6BAA6B,CAAC;AACvE,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAC/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAE5D,qBAAa,4BAA6B,YAAW,mBAAmB;aAetD,YAAY,EAAE,YAAY;IAd3C,SAAgB,YAAY,EAAE,wBAAwB,CAAC,EAEtD,CAAC,CAAC;IAEH,OAAO,CAAC,uBAAuB,CAA6B;IAC5D,OAAO,CAAC,0BAA0B,CAA4C;IAC9E,OAAO,CAAC,yBAAyB,CAA2C;IAG5E,OAAO,CAAC,yBAAyB,CAA6B;IAC9D,OAAO,CAAC,wBAAwB,CAA+B;IAC/D,OAAO,CAAC,0BAA0B,CAA6B;gBAG9C,YAAY,EAAE,YAAY;IAcpC,0BAA0B,CAAC,YAAY,EAAE,oBAAoB,GAAG,qBAAqB,GAAG,SAAS;IAYjG,0BAA0B,CAAC,aAAa,EAAE,qBAAqB,GAAG,oBAAoB,EAAE,GAAG,SAAS;IAe3G,OAAO,CAAC,gBAAgB;IAuBxB,OAAO,CAAC,mBAAmB;IAsB3B,OAAO,CAAC,iBAAiB;IAazB,OAAO,CAAC,oBAAoB;IAS5B,OAAO,CAAC,2BAA2B;IAcnC,OAAO,CAAC,4BAA4B;CAWpC"}

package/lib/utils/MediasoupRemoteTrackResolver.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MediasoupRemoteTrackResolver = void 0;
+class MediasoupRemoteTrackResolver {
+    observedCall;
+    eventMonitor;
+    _consumerIdToProducerId = new Map();
+    _producerIdToOutboundTrack = new Map();
+    _consumerIdToInboundTrack = new Map();
+    // private _producerIdToOutboundTrack = new Map<string, ObservedOutboundTrack>();
+    _inboundTrackToConsumerId = new Map();
+    _producerIdToConsumerIds = new Map();
+    _outboundTrackToProducerId = new Map();
+    constructor(observedCall) {
+        this.observedCall = observedCall;
+        this.eventMonitor = this.observedCall.createEventMonitor({});
+        this.eventMonitor.onInboundTrackAdded = this._addInboundTrack.bind(this);
+        this.eventMonitor.onInboundTrackRemoved = this._removeInboundTrack.bind(this);
+        this.eventMonitor.onOutboundTrackAdded = this._addOutboundTrack.bind(this);
+        this.eventMonitor.onOutboundTrackRemoved = this._removeOutboundTrack.bind(this);
+        // this.eventMonitor.onClientEvent = (client, event) => {
+        // };
+    }
+    resolveRemoteOutboundTrack(inboundTrack) {
+        const consumerId = this._inboundTrackToConsumerId.get(inboundTrack.id);
+        if (!consumerId)
+            return;
+        const producerId = this._consumerIdToProducerId.get(consumerId);
+        if (!producerId)
+            return;
+        return this._producerIdToOutboundTrack.get(producerId);
+    }
+    resolveRemoteInboundTracks(outboundTrack) {
+        const producerId = this._outboundTrackToProducerId.get(outboundTrack.id);
+        if (!producerId)
+            return;
+        const consumerIds = this._producerIdToConsumerIds.get(producerId);
+        if (!consumerIds)
+            return;
+        return consumerIds
+            .map((consumerId) => this._consumerIdToInboundTrack.get(consumerId))
+            .filter((inboundTrack) => Boolean(inboundTrack));
+    }
+    _addInboundTrack(inboundTrack) {
+        const attachments = this._getInboundTrackAttachments(inboundTrack);
+        if (!attachments)
+            return;
+        const { producerId, consumerId } = attachments;
+        this._inboundTrackToConsumerId.set(inboundTrack.id, consumerId);
+        this._consumerIdToProducerId.set(consumerId, producerId);
+        this._consumerIdToInboundTrack.set(consumerId, inboundTrack);
+        let producerConsumers = this._producerIdToConsumerIds.get(producerId);
+        if (!producerConsumers) {
+            producerConsumers = [];
+            this._producerIdToConsumerIds.set(producerId, producerConsumers);
+        }
+        producerConsumers.push(consumerId);
+    }
+    _removeInboundTrack(inboundTrack) {
+        const consumerId = this._inboundTrackToConsumerId.get(inboundTrack.id);
+        if (!consumerId)
+            return;
+        this._inboundTrackToConsumerId.delete(inboundTrack.id);
+        this._consumerIdToProducerId.delete(consumerId);
+        this._consumerIdToInboundTrack.delete(consumerId);
+        const producerConsumers = this._producerIdToConsumerIds.get(consumerId);
+        if (!producerConsumers)
+            return;
+        const filteredProducerConsumers = producerConsumers.filter((id) => id !== consumerId);
+        if (filteredProducerConsumers.length === 0) {
+            this._producerIdToConsumerIds.delete(consumerId);
+        }
+        else {
+            this._producerIdToConsumerIds.set(consumerId, filteredProducerConsumers);
+        }
+    }
+    _addOutboundTrack(outboundTrack) {
+        const attachments = this._getOutboundTrackAttachments(outboundTrack);
+        if (!attachments)
+            return;
+        const { producerId, } = attachments;
+        this._producerIdToOutboundTrack.set(producerId, outboundTrack);
+        this._outboundTrackToProducerId.set(outboundTrack.id, producerId);
+    }
+    _removeOutboundTrack(outboundTrack) {
+        const producerId = this._outboundTrackToProducerId.get(outboundTrack.id);
+        if (!producerId)
+            return;
+        this._producerIdToOutboundTrack.delete(producerId);
+        this._outboundTrackToProducerId.delete(outboundTrack.id);
+    }
+    _getInboundTrackAttachments(inboundTrack) {
+        const { producerId, consumerId } = inboundTrack.attachments ?? {};
+        if (!producerId || !consumerId || typeof producerId !== 'string' || typeof consumerId !== 'string')
+            return;
+        return {
+            producerId,
+            consumerId
+        };
+    }
+    _getOutboundTrackAttachments(outboundTrack) {
+        const { producerId, } = outboundTrack.attachments ?? {};
+        if (!producerId || typeof producerId !== 'string')
+            return;
+        return {
+            producerId,
+        };
+    }
+}
+exports.MediasoupRemoteTrackResolver = MediasoupRemoteTrackResolver;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@observertc/observer-js",
-  "version": "1.0.1-c3edea3.0",
+  "version": "1.0.1-cda37f7.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,18 @@ 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';
 
 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 +37,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 +102,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 +133,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 +152,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 +175,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);
 
@@ -124,10 +207,121 @@ export class ObservedCall<AppData extends Record<string, unknown> = Record<strin
 		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);
+	}
+
+	// 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,
+	// 	};
+	// }
 }