@observertc/observer-js 0.40.8-beta → 0.40.9-beta

package/src/ObservedSfu.ts

@@ -12,7 +12,9 @@ export type ObservedSfuModel= {
 };
 
 export type ObservedSfuEvents = {
-	update: [],
+	update: [{
+		elapsedTimeInMs: number;
+	}],
 	close: [],
 	newtransport: [ObservedSfuTransport],
 };
@@ -103,6 +105,9 @@ export class ObservedSfu<AppData extends Record<string, unknown> = Record<string
 			this._timeZoneOffsetInHours = sample.timeZoneOffsetInHours;
 		}
 
+		const now = Date.now();
+		const elapsedTimeInMs = now - this._updated;
+
 		for (const customSfuEvents of sample.customSfuEvents ?? []) {
 			const report: SfuEventReport = {
 				serviceId: this.serviceId,
@@ -174,8 +179,10 @@ export class ObservedSfu<AppData extends Record<string, unknown> = Record<string
 			observedSfuSctpChannel.update(sctpChannel, sample.timestamp);
 		}
 
-		this._updated = Date.now();
-		this.emit('update');
+		this._updated = now;
+		this.emit('update', {
+			elapsedTimeInMs,
+		});
 	}
 
 	private _createTransport(model: ObservedSfuTransportModel) {

package/src/ObservedSfuInboundRtpPad.ts

@@ -8,7 +8,9 @@ export type ObservedSfuInboundRtpPadModel= {
 };
 
 export type ObservedSfuInboundRtpPadEvents = {
-	update: [],
+	update: [{
+		elapsedTimeInMs: number;
+	}],
 	close: [],
 };
 
@@ -76,6 +78,8 @@ export class ObservedSfuInboundRtpPad extends EventEmitter {
 	}
 
 	public update(sample: SfuInboundRtpPad, timestamp: number) {
+		const now = Date.now();
+		const elapsedTimeInMs = now - this._updated;
 
 		const { streamId: sfuStreamId, padId: rtpPadId, ...reportData } = sample;
 
@@ -94,7 +98,9 @@ export class ObservedSfuInboundRtpPad extends EventEmitter {
 		this.reports.addSfuInboundRtpPadReport(report);
 		this.stats = sample;
 
-		this._updated = Date.now();
-		this.emit('update');
+		this._updated = now;
+		this.emit('update', {
+			elapsedTimeInMs,
+		});
 	}
 }

package/src/ObservedSfuOutboundRtpPad.ts

@@ -8,7 +8,9 @@ export type ObservedSfuOutboundRtpPadModel= {
 };
 
 export type ObservedSfuOutboundRtpPadEvents = {
-	update: [],
+	update: [{
+		elapsedTimeInMs: number;
+	}],
 	close: [],
 };
 
@@ -76,6 +78,8 @@ export class ObservedSfuOutboundRtpPad extends EventEmitter {
 	}
 
 	public update(sample: SfuOutboundRtpPad, timestamp: number) {
+		const now = Date.now();
+		const elapsedTimeInMs = now - this._updated;
 
 		const { streamId: sfuStreamId, padId: rtpPadId, sinkId: sfuSinkId, ...reportData } = sample;
 
@@ -95,7 +99,9 @@ export class ObservedSfuOutboundRtpPad extends EventEmitter {
 		this.reports.addSfuOutboundRtpPadReport(report);
 		this.stats = sample;
 
-		this._updated = Date.now();
-		this.emit('update');
+		this._updated = now;
+		this.emit('update', {
+			elapsedTimeInMs,
+		});
 	}
 }

package/src/ObservedSfuSctpChannel.ts

@@ -8,7 +8,9 @@ export type ObservedSfuSctpChannelModel= {
 };
 
 export type ObservedSfuSctpChannelEvents = {
-	update: [],
+	update: [{
+		elapsedTimeInMs: number;
+	}],
 	close: [],
 };
 
@@ -76,6 +78,8 @@ export class ObservedSfuSctpChannel extends EventEmitter {
 	}
 
 	public update(sample: SfuSctpChannel, timestamp: number) {
+		const now = Date.now();
+		const elapsedTimeInMs = now - this._updated;
 
 		const report: SfuSctpStreamReport = {
 			serviceId: this.serviceId,
@@ -91,7 +95,9 @@ export class ObservedSfuSctpChannel extends EventEmitter {
 		this.reports.addSfuTransportReport(report);
 		this.stats = sample;
 
-		this._updated = Date.now();
-		this.emit('update');
+		this._updated = now;
+		this.emit('update', {
+			elapsedTimeInMs,
+		});
 	}
 }

package/src/ObservedSfuTransport.ts

@@ -11,7 +11,9 @@ export type ObservedSfuTransportModel= {
 };
 
 export type ObservedSfuTransportEvents = {
-	update: [],
+	update: [{
+		elapsedTimeInMs: number;
+	}],
 	close: [],
 	newsfuoutboundrtppad: [ObservedSfuOutboundRtpPad],
 	newsfuinboundrtppad: [ObservedSfuInboundRtpPad],
@@ -110,7 +112,9 @@ export class ObservedSfuTransport extends EventEmitter {
 	}
 
 	public update(sample: SfuTransport, timestamp: number) {
-		
+		const now = Date.now();
+		const elapsedTimeInMs = now - this._updated;
+
 		const report: SFUTransportReport = {
 			serviceId: this.serviceId,
 			mediaUnitId: this.mediaUnitId,
@@ -125,8 +129,10 @@ export class ObservedSfuTransport extends EventEmitter {
 		this.reports.addSfuTransportReport(report);
 		this.stats = sample;
 
-		this._updated = Date.now();
-		this.emit('update');
+		this._updated = now;
+		this.emit('update', {
+			elapsedTimeInMs,
+		});
 	}
 
 	public createSfuOutboundRtpPad(model: ObservedSfuOutboundRtpPadModel) {

package/src/Observer.ts

@@ -6,6 +6,10 @@ import { PartialBy } from './common/utils';
 import { createCallEndedEventReport, createCallStartedEventReport } from './common/callEventReports';
 import { ObserverSinkContext } from './common/types';
 import { ObservedSfu, ObservedSfuModel } from './ObservedSfu';
+import { CallSummaryMonitor } from './monitors/CallSummaryMonitor';
+import { TurnUsageMonitor } from './monitors/TurnUsageMonitor';
+import { ObservedClient } from './ObservedClient';
+import { ObservedPeerConnection } from './ObservedPeerConnection';
 
 const logger = createLogger('Observer');
 
@@ -69,6 +73,7 @@ export class Observer extends EventEmitter {
 	public readonly reports = new ReportsCollector();
 	private readonly _observedCalls = new Map<string, ObservedCall>();
 	private readonly _observedSfus = new Map<string, ObservedSfu>();
+	private readonly _monitors = new Map<string, { close:() => void, once: (e: 'close', l: () => void) => void }>();
 
 	private _reportTimer?: ReturnType<typeof setTimeout>;
 	private _closed = false;
@@ -160,6 +165,87 @@ export class Observer extends EventEmitter {
 		return sfu;
 	}
 
+	public createCallSummaryMonitor(options?: { timeoutAfterCallClose?: number }): CallSummaryMonitor {
+		if (this._closed) throw new Error('Cannot create a call summary monitor on a closed observer');
+
+		const existingMonitor = this._monitors.get(CallSummaryMonitor.name);
+		
+		if (existingMonitor) return existingMonitor as CallSummaryMonitor;
+
+		const monitor = new CallSummaryMonitor();
+		const onNewCall = (call: ObservedCall) => {
+			monitor.addCall(call);
+
+			call.once('close', () => setTimeout(() => {
+				const summary = monitor.takeSummary(call.callId);
+
+				summary && monitor.emit('summary', summary);
+				
+			}, options?.timeoutAfterCallClose ?? 1000));
+		};
+
+		monitor.once('close', () => {
+			this._monitors.delete(CallSummaryMonitor.name);
+			this.off('newcall', onNewCall);
+		});
+
+		this._monitors.set(CallSummaryMonitor.name, monitor);
+		this.on('newcall', onNewCall);
+		
+		this.once('close', () => {
+			monitor.close();
+		});
+
+		return monitor;
+	}
+
+	public createTurnUsageMonitor() {
+		if (this._closed) throw new Error('Cannot create a turn usage monitor on a closed observer');
+
+		const existingMonitor = this._monitors.get(TurnUsageMonitor.name);
+		
+		if (existingMonitor) return existingMonitor as TurnUsageMonitor;
+
+		const monitor = new TurnUsageMonitor();
+
+		const onNewCall = (call: ObservedCall) => {
+			const onNewClient = (client: ObservedClient) => {
+				const onNewPeerConnection = (pc: ObservedPeerConnection) => {
+					const onUsingTurnChanged = (usingTurn: boolean) => {
+						if (usingTurn) monitor.addPeerConnection(pc);
+						else monitor.removePeerConnection(pc);
+					};
+
+					pc.once('close', () => {
+						pc.ICE.off('usingturnchanged', onUsingTurnChanged);
+						monitor.removePeerConnection(pc);
+					});
+					pc.ICE.on('usingturnchanged', onUsingTurnChanged);
+				};
+
+				client.once('close', () => client.off('newpeerconnection', onNewPeerConnection));
+				client.on('newpeerconnection', onNewPeerConnection);
+			};
+
+			call.once('close', () => call.off('newclient', onNewClient));
+			call.on('newclient', onNewClient);
+		};
+
+		monitor.once('close', () => {
+			this._monitors.delete(CallSummaryMonitor.name);
+			this.off('newcall', onNewCall);
+		});
+
+		this._monitors.set(CallSummaryMonitor.name, monitor);
+		this.on('newcall', onNewCall);
+		
+		this.once('close', () => {
+			monitor.close();
+		});
+
+		return monitor;
+	}
+
 	public get observedCalls(): ReadonlyMap<string, ObservedCall> {
 		return this._observedCalls;
 	}

package/src/{CallSummary.ts → monitors/CallSummary.ts}

@@ -1,8 +1,14 @@
 export interface ClientSummary {
 	clientId: string;
-	userId: string;
+	mediaUnitId: string;
+	userId?: string;
 	joined: number;
 	durationInMs: number;
+	avgOutboundAudioBitrate: number,
+	avgOutboundVideoBitrate: number,
+	avgInboundAudioBitrate: number,
+	avgInboundVideoBitrate: number,
+	ewmaRttInMs: number,
 }
 
 export interface CallSummary {
@@ -12,4 +18,4 @@ export interface CallSummary {
 	started: number;
 	durationInMs: number;
 	clients: ClientSummary[];
-}
+}

package/src/monitors/CallSummaryMonitor.ts

@@ -0,0 +1,107 @@
+import { EventEmitter } from 'events';
+import { CallSummary } from './CallSummary';
+import { ObservedCall } from '../ObservedCall';
+import { ObservedClient } from '../ObservedClient';
+
+export type CallSummaryMonitorEvents = {
+	close: [],
+	summary: [CallSummary],
+}
+
+export declare interface CallSummaryMonitor {
+	on<U extends keyof CallSummaryMonitorEvents>(event: U, listener: (...args: CallSummaryMonitorEvents[U]) => void): this;
+	off<U extends keyof CallSummaryMonitorEvents>(event: U, listener: (...args: CallSummaryMonitorEvents[U]) => void): this;
+	once<U extends keyof CallSummaryMonitorEvents>(event: U, listener: (...args: CallSummaryMonitorEvents[U]) => void): this;
+	emit<U extends keyof CallSummaryMonitorEvents>(event: U, ...args: CallSummaryMonitorEvents[U]): boolean;
+}
+
+export class CallSummaryMonitor extends EventEmitter {
+	private readonly _summaries = new Map<string, CallSummary>();
+
+	private _closed = false;
+	public constructor() {
+		super();
+	}
+
+	public addCall(call: ObservedCall) {
+		if (this.closed) return;
+
+		let callSummary = this._summaries.get(call.callId);
+
+		if (!callSummary) {
+			callSummary = {
+				callId: call.callId,
+				roomId: call.roomId,
+				serviceId: call.serviceId,
+				clients: [],
+				durationInMs: 0,
+				started: call.created,
+			};
+			this._summaries.set(call.callId, callSummary);
+		}
+		const constCallSummary = callSummary;
+		const onNewClient = (client: ObservedClient) => this._addClient(constCallSummary, client);
+
+		call.once('close', () => {
+			call.off('newclient', onNewClient);
+		});
+		call.on('newclient', onNewClient);
+	}
+
+	private _addClient(callSummary: CallSummary, client: ObservedClient) {
+		if (this.closed) return;
+		const clientSummary = {
+			clientId: client.clientId,
+			mediaUnitId: client.mediaUnitId,
+			durationInMs: 0,
+			avgInboundAudioBitrate: 0,
+			avgInboundVideoBitrate: 0,
+			avgOutboundAudioBitrate: 0,
+			avgOutboundVideoBitrate: 0,
+			ewmaRttInMs: 0,
+			joined: client.created,
+			userId: client.userId,
+		};
+
+		callSummary.clients.push(clientSummary);
+		
+		const updateClient = () => {
+			if (client.avgRttInMs) {
+				clientSummary.ewmaRttInMs = (clientSummary.ewmaRttInMs * 0.9) + (client.avgRttInMs * 0.1);
+			}
+		};
+
+		client.on('update', updateClient);
+		client.once('close', () => {
+			const elapsedTimeInS = (Date.now() - client.created) / 1000;
+
+			clientSummary.avgInboundAudioBitrate = (client.totalReceivedBytes * 8) / elapsedTimeInS;
+			clientSummary.avgInboundVideoBitrate = (client.totalReceivedBytes * 8) / elapsedTimeInS;
+			clientSummary.avgOutboundAudioBitrate = (client.totalSentBytes * 8) / elapsedTimeInS;
+			clientSummary.avgOutboundVideoBitrate = (client.totalSentBytes * 8) / elapsedTimeInS;
+			clientSummary.durationInMs = elapsedTimeInS * 1000;
+			client.off('update', updateClient);
+		});
+	}
+
+	public takeSummary(callId: string): CallSummary | undefined {
+		if (this.closed) return;
+		
+		const summary = this._summaries.get(callId);
+
+		this._summaries.delete(callId);
+
+		return summary;
+	}
+
+	public get closed() {
+		return this._closed;
+	}
+
+	public close() {
+		if (this._closed) return;
+		this._closed = true;
+
+		this.emit('close');
+	}
+}

package/src/monitors/TurnUsageMonitor.ts

@@ -0,0 +1,108 @@
+import { EventEmitter } from 'events';
+import { ObservedPeerConnection } from '../ObservedPeerConnection';
+import { ObservedICEEvents } from '../ObservedICE';
+
+export type TurnUsageMonitorEvents = {
+	close: [],
+}
+
+export type TurnUsage = {
+	turnIp: string;
+	totalBytesSent: number;
+	totalBytesReceived: number;
+	totalPacketsSent: number;
+	totalPacketsReceived: number;
+}
+
+type ObservedConnection = {
+	peerConnection: ObservedPeerConnection,
+	onUpdate: (...e: ObservedICEEvents['update']) => void;
+
+}
+
+export declare interface TurnUsageMonitor {
+	on<U extends keyof TurnUsageMonitorEvents>(event: U, listener: (...args: TurnUsageMonitorEvents[U]) => void): this;
+	off<U extends keyof TurnUsageMonitorEvents>(event: U, listener: (...args: TurnUsageMonitorEvents[U]) => void): this;
+	once<U extends keyof TurnUsageMonitorEvents>(event: U, listener: (...args: TurnUsageMonitorEvents[U]) => void): this;
+}
+
+export class TurnUsageMonitor extends EventEmitter {
+	private readonly _connections = new Map<string, ObservedConnection>();
+	private readonly _turnUsage = new Map<string, TurnUsage>();
+
+	private _closed = false;
+	public constructor() {
+		super();
+	}
+
+	public addPeerConnection(peerConnection: ObservedPeerConnection) {
+		if (this.closed) return;
+		if (this._connections.has(peerConnection.peerConnectionId)) return;
+
+		const ice = peerConnection.ICE;
+		const onUpdate = () => {
+			const turnIp = ice?.selectedRemoteCandidate?.address;
+			
+			if (!peerConnection.usingTURN || !turnIp) return;
+			
+			let usage = this._turnUsage.get(turnIp);
+
+			if (!usage) {
+				usage = {
+					turnIp,
+					totalBytesSent: 0,
+					totalBytesReceived: 0,
+					totalPacketsSent: 0,
+					totalPacketsReceived: 0
+				};
+				this._turnUsage.set(turnIp, usage);
+			}
+			
+			usage.totalBytesSent += ice.deltaBytesSent;
+			usage.totalBytesReceived += ice.deltaBytesReceived;
+			usage.totalPacketsSent += ice.deltaPacketsSent;
+			usage.totalPacketsReceived += ice.deltaPacketsReceived;
+		};
+
+		this._connections.set(peerConnection.peerConnectionId, {
+			peerConnection,
+			onUpdate
+		});
+
+		peerConnection.ICE.on('update', onUpdate);
+	}
+
+	public removePeerConnection(peerConnection: ObservedPeerConnection) {
+		if (this.closed) return;
+		if (!this._connections.has(peerConnection.peerConnectionId)) return;
+		
+		const { onUpdate } = this._connections.get(peerConnection.peerConnectionId) ?? {};
+		
+		if (!onUpdate) return;
+
+		peerConnection.ICE.off('update', onUpdate);
+	}
+
+	public get turnIps() {
+		return Array.from(this._turnUsage.keys());
+	}
+
+	public get peerConnections() {
+		return Array.from(this._connections.values()).map(({ peerConnection }) => peerConnection);
+	}
+
+	public getUsage(turnIp: string) {
+		return this._turnUsage.get(turnIp);
+	}
+
+	public get closed() {
+		return this._closed;
+	}
+
+	public close() {
+		if (this._closed) return;
+		this._closed = true;
+
+		this.emit('close');
+	}
+}

package/lib/CallSummary.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"CallSummary.d.ts","sourceRoot":"","sources":["../src/CallSummary.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,aAAa;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,WAAW;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,aAAa,EAAE,CAAC;CACzB"}