@observertc/observer-js 0.42.8 → 1.0.1-1b9b3c5.0

package/src/common/TypedEventEmitter.ts

@@ -1,32 +0,0 @@
-import EventEmitter from 'events';
-
-export type EventMap = {
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	[key: string]: [...unknown[]]
-}
-
-export function createTypedEventEmitter<Events extends EventMap>() {
-	return new EventEmitter() as TypedEventEmitter<Events>;
-}
-
-export interface TypedEventEmitter<Events extends EventMap> {
-	addListener<E extends keyof Events> (event: E, listener: (...data: Events[E]) => void): this
-	on<E extends keyof Events> (event: E, listener: (...data: Events[E]) => void): this
-	once<E extends keyof Events> (event: E, listener: (...data: Events[E]) => void): this
-	prependListener<E extends keyof Events> (event: E, listener: (...data: Events[E]) => void): this
-	prependOnceListener<E extends keyof Events> (event: E, listener: (...data: Events[E]) => void): this
-
-	off<E extends keyof Events>(event: E, listener: (...data: Events[E]) => void): this
-	removeAllListeners<E extends keyof Events> (event?: E): this
-	removeListener<E extends keyof Events> (event: E, listener: (...data: Events[E]) => void): this
-
-	emit<E extends keyof Events> (event: E, ...args: Events[E]): boolean
-	// The sloppy `eventNames()` return type is to mitigate type incompatibilities - see #5
-	eventNames(): (keyof Events | string | symbol)[]
-	rawListeners<E extends keyof Events> (event: E): ((...data: Events[E]) => void)[]
-	listeners<E extends keyof Events> (event: E): ((...data: Events[E]) => void)[]
-	listenerCount<E extends keyof Events> (event: E): number
-
-	getMaxListeners (): number
-	setMaxListeners (maxListeners: number): this
-}

package/src/common/callEventReports.ts

@@ -1,178 +0,0 @@
-import { CallEventReport } from '@observertc/report-schemas-js';
-import { CallEventType } from './CallEventType';
-
-export function createCallStartedEventReport(
-	serviceId: string,
-	roomId: string,
-	callId: string,
-	timestamp: number,
-	marker?: string
-): CallEventReport {
-	return {
-		name: CallEventType.CALL_STARTED,
-		serviceId,
-		roomId,
-		callId,
-		timestamp,
-		marker,
-	};
-}
-
-export function createCallEndedEventReport(
-	serviceId: string,
-	roomId: string,
-	callId: string,
-	timestamp: number,
-	marker?: string
-): CallEventReport {
-	return {
-		name: CallEventType.CALL_ENDED,
-		serviceId,
-		roomId,
-		callId,
-		timestamp,
-		marker,
-	};
-}
-
-export function createClientJoinedEventReport(
-	serviceId: string,
-	mediaUnitId: string,
-	roomId: string,
-	callId: string,
-	clientId: string,
-	timestamp: number,
-	userId?: string,
-	marker?: string
-): CallEventReport {
-	return {
-		name: CallEventType.CLIENT_JOINED,
-		serviceId,
-		mediaUnitId,
-		roomId,
-		callId,
-		clientId,
-		timestamp,
-		userId,
-		marker,
-	};
-}
-
-export function createClientLeftEventReport(
-	serviceId: string,
-	mediaUnitId: string,
-	roomId: string,
-	callId: string,
-	clientId: string,
-	timestamp: number,
-	userId?: string,
-	marker?: string
-): CallEventReport {
-	return {
-		name: CallEventType.CLIENT_LEFT,
-		serviceId,
-		mediaUnitId,
-		roomId,
-		callId,
-		clientId,
-		timestamp,
-		userId,
-		marker,
-	};
-}
-
-export function createPeerConnectionOpenedEventReport(
-	serviceId: string,
-	mediaUnitId: string,
-	roomId: string,
-	callId: string,
-	clientId: string,
-	peerConnectionId: string,
-	timestamp: number,
-	marker?: string
-): CallEventReport {
-	return {
-		name: CallEventType.PEER_CONNECTION_OPENED,
-		serviceId,
-		mediaUnitId,
-		roomId,
-		callId,
-		clientId,
-		peerConnectionId,
-		timestamp,
-		marker,
-	};
-}
-
-export function createPeerConnectionClosedEventReport(
-	serviceId: string,
-	mediaUnitId: string,
-	roomId: string,
-	callId: string,
-	clientId: string,
-	peerConnectionId: string,
-	timestamp: number,
-	marker?: string
-): CallEventReport {
-	return {
-		name: CallEventType.PEER_CONNECTION_CLOSED,
-		serviceId,
-		mediaUnitId,
-		roomId,
-		callId,
-		clientId,
-		peerConnectionId,
-		timestamp,
-		marker,
-	};
-}
-
-export function createMediaTrackAddedEventReport(
-	serviceId: string,
-	mediaUnitId: string,
-	roomId: string,
-	callId: string,
-	clientId: string,
-	peerConnectionId: string,
-	mediaTrackId: string,
-	timestamp: number,
-	marker?: string
-): CallEventReport {
-	return {
-		name: CallEventType.MEDIA_TRACK_ADDED,
-		serviceId,
-		mediaUnitId,
-		roomId,
-		callId,
-		clientId,
-		peerConnectionId,
-		mediaTrackId,
-		timestamp,
-		marker,
-	};
-}
-
-export function createMediaTrackRemovedEventReport(
-	serviceId: string,
-	mediaUnitId: string,
-	roomId: string,
-	callId: string,
-	clientId: string,
-	peerConnectionId: string,
-	mediaTrackId: string,
-	timestamp: number,
-	marker?: string
-): CallEventReport {
-	return {
-		name: CallEventType.MEDIA_TRACK_REMOVED,
-		serviceId,
-		mediaUnitId,
-		roomId,
-		callId,
-		clientId,
-		peerConnectionId,
-		mediaTrackId,
-		timestamp,
-		marker,
-	};
-}

package/src/monitors/CallSummary.ts

@@ -1,38 +0,0 @@
-export interface ClientIssue extends Record<string, unknown> {
-	severity: 'critical' | 'major' | 'minor';
-	timestamp: number;
-	description?: string;
-	peerConnectionId?: string,
-	trackId?: string,
-	attachments?: Record<string, unknown>,
-}
-
-export interface ClientSummary extends Record<string, unknown> {
-	clientId: string;
-	mediaUnitId: string;
-	userId?: string;
-	joined: number;
-	left?: number;
-	durationInMs: number;
-	totalOutboundAudioBytes: number,
-	totalOutboundVideoBytes: number,
-	totalInboundAudioBytes: number,
-	totalInboundVideoBytes: number,
-	totalDataChannelBytesSent: number,
-	totalDataChannelBytesReceived: number,
-	ewmaRttInMs: number,
-	usedTurn: boolean;
-	issues: ClientIssue[];
-}
-
-export interface CallSummary extends Record<string, unknown> {
-	serviceId: string;
-	roomId: string;
-	callId: string;
-	started: number;
-	durationInMs: number;
-	maxNumberOfParticipants: number;
-	numberOfIssues: number;
-	highestSeverity?: ClientIssue['severity'],
-	clients: ClientSummary[];
-}

package/src/monitors/CallSummaryMonitor.ts

@@ -1,192 +0,0 @@
-import { EventEmitter } from 'events';
-import { CallSummary, ClientSummary } from './CallSummary';
-import { ObservedCall } from '../ObservedCall';
-import { ObservedClient } from '../ObservedClient';
-import { ObservedPeerConnection } from '../ObservedPeerConnection';
-import { ObservedOutboundVideoTrack } from '../ObservedOutboundVideoTrack';
-
-export type CallSummaryMonitorEvents = {
-	close: [],
-	summary: [CallSummary],
-}
-
-export type CallSummaryMonitorConfig = {
-	detectUserMediaIssues?: boolean;
-	detectMediaTrackQualityLimitationIssues?: boolean;
-}
-
-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(
-		public readonly config: CallSummaryMonitorConfig = {},
-	) {
-		super();
-		this.setMaxListeners(Infinity);
-	}
-
-	public addCall(call: ObservedCall) {
-		if (this.closed) return;
-
-		let callSummary: CallSummary | undefined = this._summaries.get(call.callId);
-
-		if (!callSummary) {
-			callSummary = {
-				callId: call.callId,
-				roomId: call.roomId,
-				serviceId: call.serviceId,
-				clients: [],
-				durationInMs: 0,
-				maxNumberOfParticipants: 0,
-				numberOfIssues: 0,
-				started: call.created,
-			};
-			this._summaries.set(call.callId, callSummary);
-		}
-		const constCallSummary = callSummary;
-		const onNewClient = (client: ObservedClient) => {
-			constCallSummary.maxNumberOfParticipants = Math.max(constCallSummary.maxNumberOfParticipants, call.clients.size);
-			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: ClientSummary = {
-			clientId: client.clientId,
-			mediaUnitId: client.mediaUnitId,
-			durationInMs: 0,
-			totalInboundAudioBytes: 0,
-			totalInboundVideoBytes: 0,
-			totalOutboundAudioBytes: 0,
-			totalOutboundVideoBytes: 0,
-			totalDataChannelBytesSent: 0,
-			totalDataChannelBytesReceived: 0,
-			ewmaRttInMs: 0,
-			joined: client.created,
-			userId: client.userId,
-			usedTurn: false,
-			issues: [],
-		};
-
-		callSummary.clients.push(clientSummary);
-		
-		const updateClient = () => {
-			if (client.avgRttInMs) {
-				clientSummary.ewmaRttInMs = (clientSummary.ewmaRttInMs * 0.9) + (client.avgRttInMs * 0.1);
-			}
-		};
-
-		const onUsingTurn = (usingTurn: boolean) => {
-			clientSummary.usedTurn ||= usingTurn;
-		};
-
-		const onUserMediaError = (error: string) => {
-			if (!this.config.detectUserMediaIssues) return;
-
-			client.addIssue({
-				severity: 'critical',
-				timestamp: Date.now(),
-				description: error,
-			});
-		};
-
-		const onNewPeerConnection = (peerConnection: ObservedPeerConnection) => this._addPeerConnection(clientSummary, peerConnection);
-
-		client.on('update', updateClient);
-		client.on('usingturn', onUsingTurn);
-		client.on('usermediaerror', onUserMediaError);
-		client.on('newpeerconnection', onNewPeerConnection);
-		client.once('close', () => {
-			const now = Date.now();
-
-			clientSummary.totalInboundAudioBytes = client.totalReceivedAudioBytes;
-			clientSummary.totalInboundVideoBytes = client.totalReceivedVideoBytes;
-			clientSummary.totalOutboundAudioBytes = client.totalSentAudioBytes;
-			clientSummary.totalOutboundVideoBytes = client.totalSentVideoBytes;
-			clientSummary.totalDataChannelBytesSent = client.totalDataChannelBytesSent;
-			clientSummary.totalDataChannelBytesReceived = client.totalDataChannelBytesReceived;
-			clientSummary.durationInMs = now - client.created;
-			clientSummary.left = now;
-			// client does not store issues after update emitted
-			// clientSummary.issues.push(...client.issues);
-
-			client.off('update', updateClient);
-			client.off('usingturn', onUsingTurn);
-			client.off('usermediaerror', onUserMediaError);
-			client.off('newpeerconnection', onNewPeerConnection);
-
-			callSummary.durationInMs += clientSummary.durationInMs;
-			callSummary.numberOfIssues += clientSummary.issues.length;
-			callSummary.highestSeverity = clientSummary.issues.reduce((highest, issue) => {
-				if (issue.severity === 'critical') return 'critical';
-				if (issue.severity === 'major' && highest !== 'critical') return 'major';
-				if (issue.severity === 'minor' && highest !== 'critical' && highest !== 'major') return 'minor';
-				
-				return highest;
-			}, callSummary.highestSeverity);
-		});
-	}
-
-	private _addPeerConnection(clientSummary: ClientSummary, peerConnection: ObservedPeerConnection) {
-		const onOutboundVideoTrack = (track: ObservedOutboundVideoTrack) => this._addOutboundVideoTrack(clientSummary, track);
-
-		peerConnection.on('newoutboundvideotrack', onOutboundVideoTrack);
-		peerConnection.once('close', () => {
-			peerConnection.off('newoutboundvideotrack', onOutboundVideoTrack);
-		});
-	}
-
-	private _addOutboundVideoTrack(clientSummary: ClientSummary, track: ObservedOutboundVideoTrack) {
-		const onQualityLimitationChanged = (reason: string) => {
-			if (!this.config.detectMediaTrackQualityLimitationIssues) return;
-
-			track.peerConnection.client.addIssue({
-				severity: 'minor',
-				timestamp: Date.now(),
-				description: reason,
-				peerConnectionId: track.peerConnectionId,
-				trackId: track.trackId,
-			});
-		};
-		
-		track.once('close', () => {
-			track.off('qualitylimitationchanged', onQualityLimitationChanged);
-		});
-		track.on('qualitylimitationchanged', onQualityLimitationChanged);
-	}
-
-	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/ClientIssueMonitor.ts

@@ -1,88 +0,0 @@
-import { EventEmitter } from 'events';
-import { ObservedCall } from '../ObservedCall';
-import { ObservedClient } from '../ObservedClient';
-import { ClientIssue } from './CallSummary';
-
-export type ClientIssueMonitorEmittedIssueEvent = ClientIssue & {
-	clientId: string,
-	callId: string,
-}
-
-export type ClientIssueMonitorEvents = {
-	close: [],
-	issue: [ClientIssueMonitorEmittedIssueEvent],
-	major: [ClientIssueMonitorEmittedIssueEvent],
-	minor: [ClientIssueMonitorEmittedIssueEvent],
-	critical: [ClientIssueMonitorEmittedIssueEvent],
-
-}
-
-export type ClientIssueMonitorConfig = {
-	// empty
-}
-
-export declare interface ClientIssueMonitor {
-	on<U extends keyof ClientIssueMonitorEvents>(event: U, listener: (...args: ClientIssueMonitorEvents[U]) => void): this;
-	off<U extends keyof ClientIssueMonitorEvents>(event: U, listener: (...args: ClientIssueMonitorEvents[U]) => void): this;
-	once<U extends keyof ClientIssueMonitorEvents>(event: U, listener: (...args: ClientIssueMonitorEvents[U]) => void): this;
-	emit<U extends keyof ClientIssueMonitorEvents>(event: U, ...args: ClientIssueMonitorEvents[U]): boolean;
-}
-
-export class ClientIssueMonitor extends EventEmitter {
-	private _closed = false;
-	public constructor(
-		public readonly config: ClientIssueMonitorConfig = {},
-	) {
-		super();
-		this.setMaxListeners(Infinity);
-	}
-
-	public addCall(call: ObservedCall) {
-		if (this.closed) return;
-
-		const onNewClient = (client: ObservedClient) => {
-			this._addClient(call, client);
-		};
-
-		call.once('close', () => {
-			call.off('newclient', onNewClient);
-		});
-		call.on('newclient', onNewClient);
-	}
-
-	private _addClient(call: ObservedCall, client: ObservedClient) {
-		if (this.closed) return;
-		const {
-			callId
-		} = call;
-		const {
-			clientId
-		} = client;
-		const onIssue = (issue: ClientIssue) => {
-			const event: ClientIssueMonitorEmittedIssueEvent = {
-				...issue,
-				clientId,
-				callId,
-			};
-
-			this.emit(issue.severity, event);
-			this.emit('issue', event);
-		};
-
-		client.once('close', () => {
-			client.off('issue', onIssue);
-		});
-		client.on('issue', onIssue);
-	}
-
-	public get closed() {
-		return this._closed;
-	}
-
-	public close() {
-		if (this._closed) return;
-		this._closed = true;
-
-		this.emit('close');
-	}
-}