@observertc/observer-js 0.42.9 → 1.0.1-23e88d8.0

package/src/common/Middleware.ts

@@ -1,56 +1,84 @@
 export type Middleware<T> = (
 	input: T,
-	next: (nextInput: T) => void,
+	next: (nextInput: T) => void
 ) => void;
 
 export interface Processor<T> {
+	finalCallback?: Callback<T>;
 	process(value: T): void;
 	addMiddleware(...middlewares: Middleware<T>[]): Processor<T>;
 	removeMiddleware(...middlewares: Middleware<T>[]): Processor<T>;
 }
 
-export function createProcessor<T>(
-): Processor<T> {
-	const stack: Middleware<T>[] = [];
-	const result: Processor<T> = {
-		addMiddleware: (...middlewares: Middleware<T>[]) => {
-			if (middlewares && 0 < middlewares.length) {
-				stack.push(...middlewares);
-			}
-			
-			return result;
-		},
+type Callback<T> = (input: T) => void;
+
+class Executor<T> {
+	public done = false;
+	private index = 0;
+	private prevIndex = -1;
+
+	constructor(
+		private readonly stack: Middleware<T>[], 
+		private readonly finalCallback?: Callback<T>
+	) {
+	}
+
+	// Executes the middleware stack
+	public execute(input: T): void {
+		if (this.index <= this.prevIndex) {
+			throw new Error('Middleware must call next() only once!');
+		} else if (this.done) {
+			throw new Error('Middleware stack has already been executed!');
+		}
+
+		this.prevIndex = this.index;
+
+		const middleware = this.stack[this.index];
+
+		this.index++;
+
+		if (middleware) {
+			return middleware(input, (nextInput: T) => this.execute(nextInput));
+		}
+
+		this.done = true;
+		this.finalCallback?.(input);
+	}
+}
+
+export class MiddlewareProcessor<T> implements Processor<T> {
+	private stack: Middleware<T>[] = [];
+	public finalCallback?: Callback<T>;
+
+	public addMiddleware(...middlewares: Middleware<T>[]): Processor<T> {
+		if (middlewares && middlewares.length > 0) {
+			this.stack.push(...middlewares);
+		}
+		
+		return this;
+	}
 
-		removeMiddleware: (...middlewares: Middleware<T>[]) => {
-			if (middlewares && 0 < middlewares.length) {
-				for (const process of middlewares) {
-					const index = stack.indexOf(process);
+	public removeMiddleware(...middlewares: Middleware<T>[]): Processor<T> {
+		if (middlewares && middlewares.length > 0) {
+			for (const middleware of middlewares) {
+				const index = this.stack.indexOf(middleware);
 
-					if (0 < index) stack.splice(index, 1);
+				if (index >= 0) {
+					this.stack.splice(index, 1);
 				}
 			}
-			
-			return result;
-		},
-		process: (value: T) => {
-			let prevIndex = -1;
-			const execute = (index: number, input: T): void => {
-				if (index <= prevIndex) {
-					throw new Error('middleware must call next() only once!');
-				}
-				prevIndex = index;
-				const middleware = stack[index];
-
-				if (!middleware) return;
-
-				const next = (nextInput: T) => execute(index + 1, nextInput);
-							
-				return middleware(input, next);
-			};
-					
-			return execute(0, value);
-		},
-	};
-
-	return result;
-}
+		}
+
+		return this;
+	}
+
+	public process(value: T): void {
+		if (this.stack.length === 0) {
+			return this.finalCallback?.(value);
+		}
+
+		const executor = new Executor(this.stack, this.finalCallback);
+
+		executor.execute(value);
+	}
+}

package/src/common/logger.ts

@@ -1,5 +1,3 @@
-export type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'silent';
-
 export interface Logger {
 	/* eslint-disable @typescript-eslint/no-explicit-any */
 	trace(...args: any[]): void;
@@ -13,79 +11,72 @@ export interface Logger {
 	error(...args: any[]): void;
 }
 
-let logLevel: LogLevel = 'error';
-const loggers = new Map<string, Logger>();
-let target: Logger | null = {
-	// eslint-disable-next-line no-console
-	trace: (...args: any[]) => console.log(...args),
-	// eslint-disable-next-line no-console
-	debug: (...args: any[]) => console.log(...args),
-	// eslint-disable-next-line no-console
-	info: (...args: any[]) => console.log(...args),
-	// eslint-disable-next-line no-console
-	warn: (...args: any[]) => console.warn(...args),
-	// eslint-disable-next-line no-console
-	error: (...args: any[]) => console.error(...args),
-};
-
-export function setLogLevel(level: LogLevel) {
-	logLevel = level;
-	const moduleNames = Array.from(loggers.keys());
-
-	loggers.clear();
-
-	moduleNames.forEach((moduleName) => createLogger(moduleName));
+export interface ObserverLogger {
+	/* eslint-disable @typescript-eslint/no-explicit-any */
+	trace(module: string, ...args: any[]): void;
+	/* eslint-disable @typescript-eslint/no-explicit-any */
+	debug(module: string, ...args: any[]): void;
+	/* eslint-disable @typescript-eslint/no-explicit-any */
+	info(module: string, ...args: any[]): void;
+	/* eslint-disable @typescript-eslint/no-explicit-any */
+	warn(module: string, ...args: any[]): void;
+	/* eslint-disable @typescript-eslint/no-explicit-any */
+	error(module: string, ...args: any[]): void;
 }
 
-export const getLogLevel = () => {
-	return logLevel;
-};
+let mainLogger: ObserverLogger = new class implements ObserverLogger {
+	trace = () => void 0;
+	// trace(module: string, ...args: any[]) {
+	// 	// eslint-disable-next-line no-console
+	// 	console.log(`[TRACE] ${module}`, ...args);
+	// }
 
-export function forwardLogsTo(logger: Logger | null) {
-	target = logger;
-}
+	debug(module: string, ...args: any[]) {
+		// eslint-disable-next-line no-console
+		console.log(`[DEBUG] ${module}`, ...args);
+	}
+
+	info(module: string, ...args: any[]) {
+		// eslint-disable-next-line no-console
+		console.info(`[INFO] ${module}`, ...args);
+	}
 
-const COLORS = {
-	black: '\x1b[30m',
-	red: '\x1b[31m',
-	green: '\x1b[32m',
-	yellow: '\x1b[33m',
-	blue: '\x1b[34m',
-	magenta: '\x1b[35m',
-	cyan: '\x1b[36m',
-	white: '\x1b[37m',
-	default: '\x1b[39m',
-};
+	warn(module: string, ...args: any[]) {
+		// eslint-disable-next-line no-console
+		console.warn(`[WARN] ${module}`, ...args);
+	}
 
-export function createLogger(moduleName: string): Logger {
-	if (loggers.has(moduleName)) {
+	error(module: string, ...args: any[]) {
 		// eslint-disable-next-line no-console
-		console.warn(`Logger for module ${moduleName} already exists`);
+		console.error(`[ERROR] ${module}`, ...args);
 	}
-	const trace = logLevel === 'trace' ? (message: string, ...args: any[]) => {
-		target?.trace(`${COLORS.magenta}[TRACE]${COLORS.default} ${moduleName} ${message}`, ...args);
-	} : () => void 0;
-	const debug = logLevel === 'trace' || logLevel === 'debug' ? (message: string, ...args: any[]) => {
-		target?.debug(`${COLORS.cyan}[DEBUG]${COLORS.default} ${moduleName} ${message}`, ...args);
-	} : () => void 0;
-	const info = logLevel === 'trace' || logLevel === 'debug' || logLevel === 'info' ? (message: string, ...args: any[]) => {
-		target?.info(`${COLORS.green}[INFO]${COLORS.default} ${moduleName} ${message}`, ...args);
-	} : () => void 0;
-	const warn = logLevel === 'trace' || logLevel === 'debug' || logLevel === 'info' || logLevel === 'warn' ? (message: string, ...args: any[]) => {
-		target?.warn(`${COLORS.yellow}[WARN]${COLORS.default} ${moduleName} ${message}`, ...args);
-	} : () => void 0;
-	const error = logLevel === 'trace' || logLevel === 'debug' || logLevel === 'info' || logLevel === 'warn' || logLevel === 'error' ? (message: string, ...args: any[]) => {
-		target?.error(`${COLORS.red}[ERROR]${COLORS.default} ${moduleName} ${message}`, ...args);
-	} : () => void 0;
-	const logger = {
-		trace,
-		debug,
-		info,
-		warn,
-		error,
-	};
+}();
+
+export function createLogger(moduleName: string): Logger {
+	return new class implements Logger {
+		trace(...args: any[]) {
+			mainLogger.trace(moduleName, ...args);
+		}
+
+		debug(...args: any[]) {
+			mainLogger.debug(moduleName, ...args);
+		}
+
+		info(...args: any[]) {
+			mainLogger.info(moduleName, ...args);
+		}
+
+		warn(...args: any[]) {
+			mainLogger.warn(moduleName, ...args);
+		}
+
+		error(...args: any[]) {
+			mainLogger.error(moduleName, ...args);
+		}
+
+	}();
+}
 
-	loggers.set(moduleName, logger);
-	
-	return logger;
+export function setObserverLogger(logger: ObserverLogger) {
+	mainLogger = logger;
 }

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

@@ -45,3 +45,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,26 @@
-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 { ClientSample } from './schema/ClientSample';
+export { ClientEventTypes as ClientEventType } from './schema/ClientEventTypes';
+export { ClientMetaTypes as ClientMetaType } from './schema/ClientMetaTypes';
 
-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';