@observertc/observer-js 0.42.9 → 1.0.1-24e14e5.0

package/src/common/types.ts

@@ -1,46 +1,4 @@
-import {
-	CallEventReport,
-	CallMetaReport,
-	ClientDataChannelReport,
-	ClientExtensionReport,
-	IceCandidatePairReport,
-	InboundAudioTrackReport,
-	InboundVideoTrackReport,
-	ObserverEventReport,
-	OutboundAudioTrackReport,
-	OutboundVideoTrackReport,
-	PeerConnectionTransportReport,
-	SfuEventReport,
-	SfuExtensionReport,
-	SfuInboundRtpPadReport,
-	SfuMetaReport,
-	SfuOutboundRtpPadReport,
-	SfuSctpStreamReport,
-	SFUTransportReport,
-} from '@observertc/report-schemas-js';
-
 export type MediaKind = 'audio' | 'video';
 export type SupportedVideoCodecType = 'vp8' | 'vp9' | 'h264' | 'h265';
 
 // export type EvaluatorMiddleware = Middleware<EvaluatorContext>;
-
-export interface ObserverSinkContext {
-	readonly callEventReports: CallEventReport[];
-	readonly callMetaReports: CallMetaReport[];
-	readonly clientDataChannelReports: ClientDataChannelReport[];
-	readonly clientExtensionReports: ClientExtensionReport[];
-	readonly iceCandidatePairReports: IceCandidatePairReport[];
-	readonly inboundAudioTrackReports: InboundAudioTrackReport[];
-	readonly inboundVideoTrackReports: InboundVideoTrackReport[];
-	readonly peerConnectionTransportReports: PeerConnectionTransportReport[];
-	readonly observerEventReports: ObserverEventReport[];
-	readonly outboundAudioTrackReports: OutboundAudioTrackReport[];
-	readonly outboundVideoTrackReports: OutboundVideoTrackReport[];
-	readonly sfuEventReports: SfuEventReport[];
-	readonly sfuExtensionReports: SfuExtensionReport[];
-	readonly sfuInboundRtpPadReports: SfuInboundRtpPadReport[];
-	readonly sfuOutboundRtpPadReports: SfuOutboundRtpPadReport[];
-	readonly sfuSctpStreamReports: SfuSctpStreamReport[];
-	readonly sfuTransportReports: SFUTransportReport[];
-	readonly sfuMetaReports: SfuMetaReport[];
-}

package/src/common/utils.ts

@@ -30,9 +30,19 @@ export function isValidUuid(str: string): boolean {
 	return regexp.test(str);
 }
 
-export function getMedian(arr: number[]): number {
+export function getAverage(arr: number[], defaultAvgIfArrLengthIs0 = 0): number {
+	if (arr.length === 0) return defaultAvgIfArrLengthIs0;
+	
+	return arr.reduce((a, b) => a + b, 0) / arr.length;
+}
+
+export function getMedian(arr: number[], copyArrayForSorting = true): number {
 	// Sort the array in ascending order
-	const sortedArr = arr.slice().sort((a, b) => a - b);
+	const sortedArr = copyArrayForSorting 
+		? arr.slice().sort((a, b) => a - b)
+		: arr.sort((a, b) => a-b)
+
+	;
 
 	// Calculate the middle index
 	const mid = Math.floor(sortedArr.length / 2);
@@ -45,3 +55,15 @@ export function getMedian(arr: number[]): number {
 	// If the array length is even, return the average of the two middle elements
 	return (sortedArr[mid - 1] + sortedArr[mid]) / 2;
 }
+
+export function parseJsonAs<T>(json?: string): T | undefined {
+	if (!json) {
+		return undefined;
+	}
+	
+	try {
+		return JSON.parse(json) as T;
+	} catch (error) {
+		return undefined;
+	}
+}

package/src/detectors/Detector.ts

@@ -0,0 +1,6 @@
+// import { AlertState } from "../ClientMonitor";
+
+export interface Detector {
+	readonly name: string;
+	update(): void;
+}

package/src/detectors/Detectors.ts

@@ -0,0 +1,38 @@
+import { createLogger } from '../common/logger';
+import { Detector } from './Detector';
+
+const logger = createLogger('Detectors');
+
+export class Detectors {
+	private _detectors: Detector[];
+
+	public constructor(...detectors: Detector[]) {
+		this._detectors = detectors;
+	}
+
+	public add(detector: Detector) {
+		this._detectors.push(detector);
+	}
+
+	public remove(detector: Detector) {
+		this._detectors = this._detectors.filter((d) => d !== detector);
+	}
+
+	get listOfNames() {
+		return this._detectors.map((d) => d.name);
+	}
+
+	public update() {
+		for (const detector of this._detectors) {
+			try {
+				detector.update();
+			} catch (err) {
+				logger.warn(`Error updating detector ${detector?.constructor?.name}`, err);
+			}
+		}
+	}
+
+	public clear() {
+		this._detectors = [];
+	}
+}

package/src/index.ts

@@ -1,93 +1,28 @@
-export type { ObserverConfig, ObserverEvents } from './Observer';
+export type { ObserverEvents } from './Observer';
 
 export { Observer } from './Observer';
+export { ObservedCall } from './ObservedCall';
+export { ObservedInboundTrack } from './ObservedInboundTrack';
+export { ObservedOutboundTrack } from './ObservedOutboundTrack';
+export { ObservedClient } from './ObservedClient';
+export { ObservedPeerConnection } from './ObservedPeerConnection';
+export { ObservedMediaSource } from './ObservedMediaSource';
+export { ObservedMediaPlayout } from './ObservedMediaPlayout';
+export { ObservedCodec } from './ObservedCodec';
+export { ObservedCertificate } from './ObservedCertificate';
+export { ObservedDataChannel } from './ObservedDataChannel';
+export { ObservedInboundRtp } from './ObservedInboundRtp';
+export { ObservedOutboundRtp } from './ObservedOutboundRtp';
+export { ObservedRemoteInboundRtp } from './ObservedRemoteInboundRtp';
+export { ObservedRemoteOutboundRtp } from './ObservedRemoteOutboundRtp';
+export { ObservedIceCandidatePair } from './ObservedIceCandidatePair';
+export { ObservedIceCandidate } from './ObservedIceCandidate';
+export { ObservedIceTransport } from './ObservedIceTransport';
+export { ObservedPeerConnectionTransport } from './ObservedPeerConnectionTransport';
+export { ClientEventTypes } from './schema/ClientEventTypes';
+export { ClientMetaTypes } from './schema/ClientMetaTypes';
+export { ClientSample } from './schema/ClientSample';
+export { ScoreCalculator } from './scores/ScoreCalculator';
+export { ObservedClientEventMonitor } from './ObservedClientEventMonitor';
 
-export * as SampleSchema from '@observertc/sample-schemas-js';
-export * as ReportSchema from '@observertc/report-schemas-js';
-
-export type { LogLevel, Logger } from './common/logger';
-
-export type {
-	Samples,
-	ClientSample,
-	SfuSample,
-	ExtensionStat,
-	PeerConnectionTransport,
-	IceCandidatePair,
-	MediaSourceStat,
-	MediaCodecStats,
-	InboundAudioTrack,
-	InboundVideoTrack,
-	OutboundAudioTrack,
-	OutboundVideoTrack,
-	IceLocalCandidate,
-	IceRemoteCandidate,
-	CustomCallEvent,
-	SfuTransport,
-	SfuInboundRtpPad,
-	SfuOutboundRtpPad,
-	SfuSctpChannel,
-	SfuExtensionStats,
-	DataChannel,
-	MediaDevice,
-} from '@observertc/sample-schemas-js';
-
-export type {
-	CallEventReport,
-	CallMetaReport,
-	ClientDataChannelReport,
-	ClientExtensionReport,
-	IceCandidatePairReport,
-	InboundAudioTrackReport,
-	InboundVideoTrackReport,
-	ObserverEventReport,
-	OutboundAudioTrackReport,
-	OutboundVideoTrackReport,
-	PeerConnectionTransportReport,
-	SfuEventReport,
-	SfuExtensionReport,
-	SfuInboundRtpPadReport,
-	SfuMetaReport,
-	SfuOutboundRtpPadReport,
-	SfuSctpStreamReport,
-	SFUTransportReport,
-} from '@observertc/report-schemas-js';
-export type { 
-	ClientIssueMonitorConfig, 
-	ClientIssueMonitorEmittedIssueEvent, 
-	ClientIssueMonitor 
-} from './monitors/ClientIssueMonitor';
-export type {
-	CalculatedScore
-} from './common/CalculatedScore';
-export type { ObservedCall, ObservedCallModel } from './ObservedCall';
-export type { ObservedClient, ObservedClientModel } from './ObservedClient';
-export type { ObservedPeerConnection, ObservedPeerConnectionModel, ObservedPeerConnectionEvents } from './ObservedPeerConnection';
-export type { ObservedInboundAudioTrack, ObservedInboundAudioTrackModel, ObservedInboundAudioTrackEvents } from './ObservedInboundAudioTrack';
-export type { ObservedOutboundAudioTrack, ObservedOutboundAudioTrackModel, ObservedOutboundAudioTrackEvents } from './ObservedOutboundAudioTrack';
-export type { ObservedInboundVideoTrack, ObservedInboundVideoTrackModel, ObservedInboundVideoTrackEvents } from './ObservedInboundVideoTrack';
-export type { ObservedOutboundVideoTrack, ObservedOutboundVideoTrackModel, ObservedOutboundVideoTrackEvents } from './ObservedOutboundVideoTrack';
-export type { CallSummary, ClientSummary, ClientIssue } from './monitors/CallSummary';
-export type { ObserverSinkContext } from './common/types';
-export type { SfuServerMonitorMetricsRecord } from './monitors/SfuServerMonitor';
-export type { TurnUsageMonitorEvents, TurnUsageMonitor, TurnStats, TurnUsage } from './monitors/TurnUsageMonitor';
-export { 
-	CallEventType, 
-	CallEventReportType, 
-	MediaTrackAddedAttachment,
-	IceConnectionStateChangedAttachment,
-	IceGatheringStateChangedAttachment,
-	PeerConnectionStateChangedAttachment,
-} from './common/CallEventType';
-export { CallMetaType, CallMetaReportType, CallMetaReportPayloads } from './common/CallMetaReports';
-
-import { Observer, ObserverConfig } from './Observer';
-export function createObserver(config?: Partial<ObserverConfig>) {
-	return Observer.create(config ?? {});
-}
-
-import { LogLevel, Logger, forwardLogsTo, setLogLevel } from './common/logger';
-export function setupLogs(logLevel: LogLevel, logger: Logger) {
-	setLogLevel(logLevel);
-	forwardLogsTo(logger);
-}
+export { Middleware } from './common/Middleware';

package/src/monitors/TurnUsageMonitor.ts

@@ -1,187 +1,187 @@
-import { EventEmitter } from 'events';
-import { ObservedPeerConnection } from '../ObservedPeerConnection';
-import { ObservedICEEvents } from '../ObservedICE';
-import { ObservedClient } from '../ObservedClient';
-
-export type TurnUsageMonitorEvents = {
-	close: [],
-	'newturnip': [string],
-	update: [TurnUsage],
-	addpeerconnection: [ObservedPeerConnection],
-	removepeerconnection: [ObservedPeerConnection],
-}
-
-export type TurnUsage = {
-	turnIp: string;
-	totalBytesSent: number;
-	totalBytesReceived: number;
-	totalPacketsSent: number;
-	totalPacketsReceived: number;
-}
-
-export type TurnStats = {
-	turnIp: string;
-	totalBytesSent: number;
-	totalBytesReceived: number;
-	totalPacketsSent: number;
-	totalPacketsReceived: number;
-	deltaBytesSent: number;
-	deltaBytesReceived: number;
-	timestamp: number;
-	outboundBitrate: number;
-	inboundBitrate: 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;
-	emit<U extends keyof TurnUsageMonitorEvents>(event: U, ...args: TurnUsageMonitorEvents[U]): boolean;
-}
-
-export class TurnUsageMonitor extends EventEmitter {
-	private readonly _connections = new Map<string, ObservedConnection>();
-	private readonly _turnUsage = new Map<string, TurnUsage>();
-	private readonly _stats = new Map<string, TurnStats>();
-
-	private _closed = false;
-	public constructor() {
-		super();
-		this.setMaxListeners(Infinity);
-	}
-
-	public get stats(): TurnStats[] {
-		const result: TurnStats[] = [];
-
-		for (const [ turnIp, usage ] of this._turnUsage) {
-			const stats = this._stats.get(turnIp) ?? {
-				turnIp,
-				totalBytesSent: 0,
-				totalBytesReceived: 0,
-				totalPacketsSent: 0,
-				totalPacketsReceived: 0,
-				deltaBytesSent: 0,
-				deltaBytesReceived: 0,
-				timestamp: Date.now(),
-				outboundBitrate: 0,
-				inboundBitrate: 0,
-			};
-
-			stats.deltaBytesSent = usage.totalBytesSent - stats.totalBytesSent;
-			stats.deltaBytesReceived = usage.totalBytesReceived - stats.totalBytesReceived;
-			stats.timestamp = Date.now();
-			stats.outboundBitrate = (stats.deltaBytesSent * 8) / ((stats.timestamp - stats.timestamp) / 1000.0);
-			stats.inboundBitrate = (stats.deltaBytesReceived * 8) / ((stats.timestamp - stats.timestamp) / 1000.0);
-			stats.totalBytesSent = usage.totalBytesSent;
-			stats.totalBytesReceived = usage.totalBytesReceived;
-			stats.totalPacketsSent = usage.totalPacketsSent;
-			stats.totalPacketsReceived = usage.totalPacketsReceived;
-
-			this._stats.set(turnIp, stats);
-
-			result.push(stats);
-		}
-
-		return result;
-	}
-
-	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;
+// import { EventEmitter } from 'events';
+// import { ObservedPeerConnection } from '../ObservedPeerConnection';
+// import { ObservedICEEvents } from '../ObservedICE';
+// import { ObservedClient } from '../ObservedClient';
+
+// export type TurnUsageMonitorEvents = {
+// 	close: [],
+// 	'newturnip': [string],
+// 	update: [TurnUsage],
+// 	addpeerconnection: [ObservedPeerConnection],
+// 	removepeerconnection: [ObservedPeerConnection],
+// }
+
+// export type TurnUsage = {
+// 	turnIp: string;
+// 	totalBytesSent: number;
+// 	totalBytesReceived: number;
+// 	totalPacketsSent: number;
+// 	totalPacketsReceived: number;
+// }
+
+// export type TurnStats = {
+// 	turnIp: string;
+// 	totalBytesSent: number;
+// 	totalBytesReceived: number;
+// 	totalPacketsSent: number;
+// 	totalPacketsReceived: number;
+// 	deltaBytesSent: number;
+// 	deltaBytesReceived: number;
+// 	timestamp: number;
+// 	outboundBitrate: number;
+// 	inboundBitrate: 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;
+// 	emit<U extends keyof TurnUsageMonitorEvents>(event: U, ...args: TurnUsageMonitorEvents[U]): boolean;
+// }
+
+// export class TurnUsageMonitor extends EventEmitter {
+// 	private readonly _connections = new Map<string, ObservedConnection>();
+// 	private readonly _turnUsage = new Map<string, TurnUsage>();
+// 	private readonly _stats = new Map<string, TurnStats>();
+
+// 	private _closed = false;
+// 	public constructor() {
+// 		super();
+// 		this.setMaxListeners(Infinity);
+// 	}
+
+// 	public get stats(): TurnStats[] {
+// 		const result: TurnStats[] = [];
+
+// 		for (const [ turnIp, usage ] of this._turnUsage) {
+// 			const stats = this._stats.get(turnIp) ?? {
+// 				turnIp,
+// 				totalBytesSent: 0,
+// 				totalBytesReceived: 0,
+// 				totalPacketsSent: 0,
+// 				totalPacketsReceived: 0,
+// 				deltaBytesSent: 0,
+// 				deltaBytesReceived: 0,
+// 				timestamp: Date.now(),
+// 				outboundBitrate: 0,
+// 				inboundBitrate: 0,
+// 			};
+
+// 			stats.deltaBytesSent = usage.totalBytesSent - stats.totalBytesSent;
+// 			stats.deltaBytesReceived = usage.totalBytesReceived - stats.totalBytesReceived;
+// 			stats.timestamp = Date.now();
+// 			stats.outboundBitrate = (stats.deltaBytesSent * 8) / ((stats.timestamp - stats.timestamp) / 1000.0);
+// 			stats.inboundBitrate = (stats.deltaBytesReceived * 8) / ((stats.timestamp - stats.timestamp) / 1000.0);
+// 			stats.totalBytesSent = usage.totalBytesSent;
+// 			stats.totalBytesReceived = usage.totalBytesReceived;
+// 			stats.totalPacketsSent = usage.totalPacketsSent;
+// 			stats.totalPacketsReceived = usage.totalPacketsReceived;
+
+// 			this._stats.set(turnIp, stats);
+
+// 			result.push(stats);
+// 		}
+
+// 		return result;
+// 	}
+
+// 	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;
+// 			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);
-
-				this.emit('newturnip', turnIp);
-			}
+// 			let usage = this._turnUsage.get(turnIp);
+
+// 			if (!usage) {
+// 				usage = {
+// 					turnIp,
+// 					totalBytesSent: 0,
+// 					totalBytesReceived: 0,
+// 					totalPacketsSent: 0,
+// 					totalPacketsReceived: 0,
+// 				};
+// 				this._turnUsage.set(turnIp, usage);
+
+// 				this.emit('newturnip', turnIp);
+// 			}
 			
-			usage.totalBytesSent += ice.deltaBytesSent;
-			usage.totalBytesReceived += ice.deltaBytesReceived;
-			usage.totalPacketsSent += ice.deltaPacketsSent;
-			usage.totalPacketsReceived += ice.deltaPacketsReceived;
+// 			usage.totalBytesSent += ice.deltaBytesSent;
+// 			usage.totalBytesReceived += ice.deltaBytesReceived;
+// 			usage.totalPacketsSent += ice.deltaPacketsSent;
+// 			usage.totalPacketsReceived += ice.deltaPacketsReceived;
 
-			this.emit('update', usage);
-		};
+// 			this.emit('update', usage);
+// 		};
 
-		peerConnection.ICE.on('update', onUpdate);
+// 		peerConnection.ICE.on('update', onUpdate);
 
-		this._connections.set(peerConnection.peerConnectionId, {
-			peerConnection,
-			onUpdate
-		});
+// 		this._connections.set(peerConnection.peerConnectionId, {
+// 			peerConnection,
+// 			onUpdate
+// 		});
 
-		this.emit('addpeerconnection', peerConnection);
-	}
+// 		this.emit('addpeerconnection', peerConnection);
+// 	}
 
-	public removePeerConnection(peerConnection: ObservedPeerConnection) {
-		if (this.closed) return;
-		if (!this._connections.has(peerConnection.peerConnectionId)) return;
+// 	public removePeerConnection(peerConnection: ObservedPeerConnection) {
+// 		if (this.closed) return;
+// 		if (!this._connections.has(peerConnection.peerConnectionId)) return;
 
-		const { onUpdate } = this._connections.get(peerConnection.peerConnectionId) ?? {};
+// 		const { onUpdate } = this._connections.get(peerConnection.peerConnectionId) ?? {};
 		
-		if (!onUpdate) return;
+// 		if (!onUpdate) return;
 
-		peerConnection.ICE.off('update', onUpdate);
+// 		peerConnection.ICE.off('update', onUpdate);
 
-		this._connections.delete(peerConnection.peerConnectionId);
+// 		this._connections.delete(peerConnection.peerConnectionId);
 
-		this.emit('removepeerconnection', peerConnection);
-	}
+// 		this.emit('removepeerconnection', peerConnection);
+// 	}
 
-	public get turnIps() {
-		return Array.from(this._turnUsage.keys());
-	}
+// 	public get turnIps() {
+// 		return Array.from(this._turnUsage.keys());
+// 	}
 
-	public get peerConnections() {
-		return Array.from(this._connections.values()).map(({ peerConnection }) => peerConnection);
-	}
+// 	public get peerConnections() {
+// 		return Array.from(this._connections.values()).map(({ peerConnection }) => peerConnection);
+// 	}
 
-	public getUsage(turnIp: string) {
-		return this._turnUsage.get(turnIp);
-	}
+// 	public getUsage(turnIp: string) {
+// 		return this._turnUsage.get(turnIp);
+// 	}
 
-	public get clients(): ReadonlyMap<string, ObservedClient> {
-		const result = new Map<string, ObservedClient>();
+// 	public get clients(): ReadonlyMap<string, ObservedClient> {
+// 		const result = new Map<string, ObservedClient>();
 
-		for (const pc of this.peerConnections) {
-			if (result.has(pc.clientId)) continue;
+// 		for (const pc of this.peerConnections) {
+// 			if (result.has(pc.clientId)) continue;
 			
-			result.set(pc.clientId, pc.client);
-		}
+// 			result.set(pc.clientId, pc.client);
+// 		}
 
-		return result;
-	}
+// 		return result;
+// 	}
 
-	public get closed() {
-		return this._closed;
-	}
+// 	public get closed() {
+// 		return this._closed;
+// 	}
 
-	public close() {
-		if (this._closed) return;
-		this._closed = true;
+// 	public close() {
+// 		if (this._closed) return;
+// 		this._closed = true;
 
-		this.emit('close');
-	}
-}
+// 		this.emit('close');
+// 	}
+// }