@observertc/observer-js 0.9.26-beta → 0.30.0-beta

package/src/{sinks/ObserverSink.ts → ReportsCollector.ts}

@@ -19,11 +19,7 @@ import {
 	SFUTransportReport,
 } from '@observertc/report-schemas-js';
 import { EventEmitter } from 'events';
-import { ReportsCollector } from '../common/ReportsCollector';
-import { ObserverSinkContext } from '../common/types';
-import { Middleware } from '../middlewares/Middleware';
-import { createProcessor, Processor } from '../middlewares/Processor';
-import { logger } from '../middlewares/VisitObservedCallsMiddleware';
+import { ObserverSinkContext } from './common/types';
 
 export type SinkEventsMap = {
 	'call-event': {
@@ -80,23 +76,14 @@ export type SinkEventsMap = {
 	'sfu-meta': {
 		reports: SfuMetaReport[];
 	};
+	'reports': ObserverSinkContext;
+	'newreport': number;
 };
 
-export type SinkConfig = Record<string, unknown>;
 export type ObserverSinkProcess = (observerSinkContext: ObserverSinkContext) => Promise<void>;
 
-export interface ObserverReportsEmitter {
-	on<K extends keyof SinkEventsMap>(event: K, listener: (reports: SinkEventsMap[K]) => void): this;
-	off<K extends keyof SinkEventsMap>(event: K, listener: (reports: SinkEventsMap[K]) => void): this;
-	once<K extends keyof SinkEventsMap>(event: K, listener: (reports: SinkEventsMap[K]) => void): this;
-}
-
-export class SinkImpl implements ReportsCollector, ObserverReportsEmitter {
-	private _index = 0;
-	private _processes = new Map<number, Promise<void>>();
-	private _customProcesses = new Map<ObserverSinkProcess, Middleware<ObserverSinkContext>>();
-	private readonly _processor: Processor<ObserverSinkContext>;
-	
+export class ReportsCollector {
+	private _collectedReports = 0;
 	private _emitter = new EventEmitter();
 	private _callEventReports: CallEventReport[] = [];
 	private _callMetaReports: CallMetaReport[] = [];
@@ -117,8 +104,8 @@ export class SinkImpl implements ReportsCollector, ObserverReportsEmitter {
 	private _sfuTransportReports: SFUTransportReport[] = [];
 	private _sfuMetaReports: SfuMetaReport[] = [];
 
-	public constructor(public readonly config: SinkConfig) {
-		this._processor = createProcessor();
+	public constructor() {
+		// empty
 	}
 
 	public on<K extends keyof SinkEventsMap>(event: K, listener: (reports: SinkEventsMap[K]) => void): this {
@@ -141,150 +128,99 @@ export class SinkImpl implements ReportsCollector, ObserverReportsEmitter {
 
 	public addCallEventReport(report: CallEventReport) {
 		this._callEventReports.push(report);
+		this._emit('newreport', ++this._collectedReports);
 	}
 
 	public addCallMetaReport(report: CallMetaReport) {
 		this._callMetaReports.push(report);
+		this._emit('newreport', ++this._collectedReports);
 	}
 
 	public addClientDataChannelReport(report: ClientDataChannelReport) {
 		this._clientDataChannelReports.push(report);
+		this._emit('newreport', ++this._collectedReports);
 	}
 
 	public addClientExtensionReport(report: ClientExtensionReport) {
 		this._clientExtensionReports.push(report);
+		this._emit('newreport', ++this._collectedReports);
 	}
 
 	public addIceCandidatePairReport(report: IceCandidatePairReport) {
 		this._iceCandidatePairReports.push(report);
+		this._emit('newreport', ++this._collectedReports);
 	}
 
 	public addInboundAudioTrackReport(report: InboundAudioTrackReport) {
 		this._inboundAudioTrackReports.push(report);
+		this._emit('newreport', ++this._collectedReports);
 	}
 
 	public addInboundVideoTrackReport(report: InboundVideoTrackReport) {
 		this._inboundVideoTrackReports.push(report);
+		this._emit('newreport', ++this._collectedReports);
 	}
 
 	public addPeerConnectionTransportReports(report: PeerConnectionTransportReport) {
 		this._peerConnectionTransportReports.push(report);
+		this._emit('newreport', ++this._collectedReports);
 	}
 
 	public addObserverEventReport(report: ObserverEventReport) {
 		this._observerEventReports.push(report);
+		this._emit('newreport', ++this._collectedReports);
 	}
 
 	public addOutboundAudioTrackReport(report: OutboundAudioTrackReport) {
 		this._outboundAudioTrackReports.push(report);
+		this._emit('newreport', ++this._collectedReports);
 	}
 
 	public addOutboundVideoTrackReport(report: OutboundVideoTrackReport) {
 		this._outboundVideoTrackReports.push(report);
+		this._emit('newreport', ++this._collectedReports);
 	}
 
 	public addSfuEventReport(report: SfuEventReport) {
 		this._sfuEventReports.push(report);
+		this._emit('newreport', ++this._collectedReports);
 	}
 
 	public addSfuExtensionReport(report: SfuExtensionReport) {
 		this._sfuExtensionReports.push(report);
+		this._emit('newreport', ++this._collectedReports);
 	}
 
 	public addSfuInboundRtpPadReport(report: SfuInboundRtpPadReport) {
 		this._sfuInboundRtpPadReports.push(report);
+		this._emit('newreport', ++this._collectedReports);
 	}
 
 	public addSfuOutboundRtpPadReport(report: SfuOutboundRtpPadReport) {
 		this._sfuOutboundRtpPadReports.push(report);
+		this._emit('newreport', ++this._collectedReports);
 	}
 
 	public addSfuSctpStreamReport(report: SfuSctpStreamReport) {
 		this._sfuSctpStreamReports.push(report);
+		this._emit('newreport', ++this._collectedReports);
 	}
 
 	public addSfuTransportReport(report: SFUTransportReport) {
 		this._sfuTransportReports.push(report);
+		this._emit('newreport', ++this._collectedReports);
 	}
 
 	public addSfuMetaReport(report: SfuMetaReport) {
 		this._sfuMetaReports.push(report);
-	}
-
-	public getCallEventReports(): CallEventReport[] {
-		return this._callEventReports;
-	}
-
-	public getClientExtensionReports(): ClientExtensionReport[] {
-		return this._clientExtensionReports;
-	}
-
-	public getSfuEventReports(): SfuEventReport[] {
-		return this._sfuEventReports;
-	}
-
-	public getSfuExtensionReports(): SfuExtensionReport[] {
-		return this._sfuExtensionReports;
-	}
-
-	public addProcess(process: ObserverSinkProcess) {
-		const middleware: Middleware<ObserverSinkContext> = async (context, next) => {
-			await process(context);
-			if (next) await next(context);
-		};
-
-		this._customProcesses.set(process, middleware);
-		this._processor.addMiddleware(middleware);
-	}
-
-	public removeProcess(process: ObserverSinkProcess) {
-		const middleware = this._customProcesses.get(process);
-
-		if (!middleware) {
-			return;
-		}
-		this._customProcesses.delete(process);
-		this._processor.removeMiddleware(middleware);
-	}
-
-	private async _process(context: ObserverSinkContext): Promise<void> {
-		if (this._processor.getSize() < 1) {
-			// no process to execute
-			return;
-		}
-		if (this._processes.has(this._index)) {
-			logger.warn('The sink process has been called while the previous process has not yet completed. This may indicate that the observer is attempting to process more reports than it can handle.');
-		}
-
-		const actualBlockingPoint = this._processes.get(this._index) ?? Promise.resolve();
-		const index = ++this._index;
-		const result = new Promise<void>((resolve, reject) => {
-			actualBlockingPoint.then(() => {
-				this._processor.use(context)
-					.then(() => resolve())
-					.catch((err) => reject(err));
-			});
-		});
-		const nextBlockingPoint = new Promise<void>((resolve) => {
-			result.then(() => {
-				this._processes.delete(index);
-				resolve();
-			}).catch(() => {
-				this._processes.delete(index);
-				resolve();
-			});
-		});
-
-		this._processes.set(index, nextBlockingPoint);
-		
-		return result;
+		this._emit('newreport', ++this._collectedReports);
 	}
 
 	public emit(): number {
 		let result = 0;
 		// eslint-disable-next-line @typescript-eslint/no-explicit-any
 		const checkAndEmit = (eventName: keyof SinkEventsMap, reports: any[]) => {
-			if (reports.length > 0) {
+			if (0 < reports.length) {
 				this._emit(eventName, { reports });
 				result += reports.length;
 			}
@@ -292,10 +228,6 @@ export class SinkImpl implements ReportsCollector, ObserverReportsEmitter {
 		
 		const context = this._createObserverSinkContext();
 
-		this._process(context).catch((err) => {
-			logger.error('Error occurred while processing reports', err);
-		});
-
 		checkAndEmit('call-event', this._callEventReports);
 		this._callEventReports = [];
 
@@ -350,6 +282,9 @@ export class SinkImpl implements ReportsCollector, ObserverReportsEmitter {
 		checkAndEmit('sfu-meta', this._sfuMetaReports);
 		this._sfuMetaReports = [];
 
+		this._emit('reports', context);
+		this._collectedReports = 0;
+		
 		return result;
 	}
 

package/src/common/ReportsCollector.ts

@@ -19,28 +19,53 @@ import {
 	SFUTransportReport,
 } from '@observertc/report-schemas-js';
 
-export interface ReportsCollector {
-	addCallEventReport(report: CallEventReport): void;
-	addCallMetaReport(report: CallMetaReport): void;
-	addClientDataChannelReport(report: ClientDataChannelReport): void;
-	addClientExtensionReport(report: ClientExtensionReport): void;
-	addIceCandidatePairReport(report: IceCandidatePairReport): void;
-	addInboundAudioTrackReport(report: InboundAudioTrackReport): void;
-	addInboundVideoTrackReport(report: InboundVideoTrackReport): void;
-	addPeerConnectionTransportReports(report: PeerConnectionTransportReport): void;
-	addObserverEventReport(report: ObserverEventReport): void;
-	addOutboundAudioTrackReport(report: OutboundAudioTrackReport): void;
-	addOutboundVideoTrackReport(report: OutboundVideoTrackReport): void;
-	addSfuEventReport(report: SfuEventReport): void;
-	addSfuExtensionReport(report: SfuExtensionReport): void;
-	addSfuInboundRtpPadReport(report: SfuInboundRtpPadReport): void;
-	addSfuOutboundRtpPadReport(report: SfuOutboundRtpPadReport): void;
-	addSfuSctpStreamReport(report: SfuSctpStreamReport): void;
-	addSfuTransportReport(report: SFUTransportReport): void;
-	addSfuMetaReport(report: SfuMetaReport): void;
+// export interface ReportsCollector {
+// 	addCallEventReport(report: CallEventReport): void;
+// 	addCallMetaReport(report: CallMetaReport): void;
+// 	addClientDataChannelReport(report: ClientDataChannelReport): void;
+// 	addClientExtensionReport(report: ClientExtensionReport): void;
+// 	addIceCandidatePairReport(report: IceCandidatePairReport): void;
+// 	addInboundAudioTrackReport(report: InboundAudioTrackReport): void;
+// 	addInboundVideoTrackReport(report: InboundVideoTrackReport): void;
+// 	addPeerConnectionTransportReports(report: PeerConnectionTransportReport): void;
+// 	addObserverEventReport(report: ObserverEventReport): void;
+// 	addOutboundAudioTrackReport(report: OutboundAudioTrackReport): void;
+// 	addOutboundVideoTrackReport(report: OutboundVideoTrackReport): void;
+// 	addSfuEventReport(report: SfuEventReport): void;
+// 	addSfuExtensionReport(report: SfuExtensionReport): void;
+// 	addSfuInboundRtpPadReport(report: SfuInboundRtpPadReport): void;
+// 	addSfuOutboundRtpPadReport(report: SfuOutboundRtpPadReport): void;
+// 	addSfuSctpStreamReport(report: SfuSctpStreamReport): void;
+// 	addSfuTransportReport(report: SFUTransportReport): void;
+// 	addSfuMetaReport(report: SfuMetaReport): void;
 
-	getCallEventReports(): CallEventReport[];
-	getClientExtensionReports(): ClientExtensionReport[];
-	getSfuEventReports(): SfuEventReport[];
-	getSfuExtensionReports(): SfuExtensionReport[];
+// 	getCallEventReports(): CallEventReport[];
+// 	getClientExtensionReports(): ClientExtensionReport[];
+// 	getSfuEventReports(): SfuEventReport[];
+// 	getSfuExtensionReports(): SfuExtensionReport[];
+// }
+
+export type ObservedReports = ReturnType<typeof createObservedReports>;
+
+export function createObservedReports() {
+	return {
+		callEventReports: [] as CallEventReport[],
+		callMetaReports: [] as CallMetaReport[],
+		clientDataChannelReports: [] as ClientDataChannelReport[],
+		clientExtensionReports: [] as ClientExtensionReport[],
+		iceCandidatePairReports: [] as IceCandidatePairReport[],
+		inboundAudioTrackReports: [] as InboundAudioTrackReport[],
+		inboundVideoTrackReports: [] as InboundVideoTrackReport[],
+		observerEventReports: [] as ObserverEventReport[],
+		outboundAudioTrackReports: [] as OutboundAudioTrackReport[],
+		outboundVideoTrackReports: [] as OutboundVideoTrackReport[],
+		peerConnectionTransportReports: [] as PeerConnectionTransportReport[],
+		sfuEventReports: [] as SfuEventReport[],
+		sfuExtensionReports: [] as SfuExtensionReport[],
+		sfuInboundRtpPadReports: [] as SfuInboundRtpPadReport[],
+		sfuMetaReports: [] as SfuMetaReport[],
+		sfuOutboundRtpPadReports: [] as SfuOutboundRtpPadReport[],
+		sfuSctpStreamReports: [] as SfuSctpStreamReport[],
+		sfuTransportReports: [] as SFUTransportReport[],
+	};
 }

package/src/common/SingleExecutor.ts

@@ -0,0 +1,36 @@
+export type SingleExecutor = ReturnType<typeof createSingleExecutor>;
+
+export function createSingleExecutor() {
+	let semaphore = 1;
+	const tasks: (() => Promise<unknown>)[] = [];
+
+	const execute = <T = unknown>(task: () => Promise<T>) => {
+		return new Promise<T>((resolve, reject) => {
+			tasks.push(() => task().then(resolve)
+				.catch(reject));
+			run();
+		});
+	};
+
+	const run = () => {
+		if (semaphore < 1) return;
+
+		const task = tasks.shift();
+
+		if (!task) return;
+
+		const postProcess = () => {
+			++semaphore;
+			run();
+		};
+
+		--semaphore;
+
+		task()
+			.then(postProcess)
+			.catch(postProcess);
+	
+	};
+
+	return execute;
+}

package/src/common/TypedEventEmitter.ts

@@ -0,0 +1,32 @@
+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/logger.ts

@@ -13,13 +13,37 @@ export interface Logger {
 	error(...args: any[]): void;
 }
 
-export interface WrappedLogger extends Logger {
-	init(): void;
-	level: LogLevel | undefined,
-	logger: Logger;
+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 type LoggerFactory = () => Logger;
+export const getLogLevel = () => {
+	return logLevel;
+};
+
+export function forwardLogsTo(logger: Logger | null) {
+	target = logger;
+}
 
 const COLORS = {
 	black: '\x1b[30m',
@@ -33,162 +57,35 @@ const COLORS = {
 	default: '\x1b[39m',
 };
 
-let defaultLevel: LogLevel = 'error';
-const created = Date.now();
-
-function createDefaultLoggerFactory(): LoggerFactory {
-	return () => {
-		/* eslint-disable @typescript-eslint/no-explicit-any */
-		const trace = (...args: any[]) => {
-			/* eslint-disable no-debugger, no-console */
-			console.trace(...args);
-		};
-		/* eslint-disable @typescript-eslint/no-explicit-any */
-		const debug = (...args: any[]) => {
-			/* eslint-disable no-debugger, no-console */
-			console.debug(...args);
-		};
-		/* eslint-disable @typescript-eslint/no-explicit-any */
-		const info = (...args: any[]) => {
-			/* eslint-disable no-debugger, no-console */
-			console.info(...args);
-		};
-		/* eslint-disable @typescript-eslint/no-explicit-any */
-		const warn = (...args: any[]) => {
-			/* eslint-disable no-debugger, no-console */
-			console.warn(...args);
-		};
-		/* eslint-disable @typescript-eslint/no-explicit-any */
-		const error = (...args: any[]) => {
-			/* eslint-disable no-debugger, no-console */
-			console.error(...args);
-		};
-		
-		return {
-			trace,
-			debug,
-			info,
-			warn,
-			error,
-		};
-	};
-}
-
-const wrapLogger = (logger: Logger, moduleName: string, logLevel?: LogLevel) => {
-
-	let isTrace = false;
-	let isDebug = false;
-	let isInfo = false;
-	let isWarning = false;
-	let isError = false;
-
-	let _level = logLevel;
-	let _logger = logger;
-	const tracePrefix = `${COLORS.magenta}[TRACE]${COLORS.default} ${moduleName}`;
-	const debugPrefix = `${COLORS.cyan}[DEBUG]${COLORS.default} ${moduleName}`;
-	const infoPrefix = `${COLORS.green}[INFO]${COLORS.default} ${moduleName}`;
-	const warnPrefix = `${COLORS.yellow}[WARN]${COLORS.default} ${moduleName}`;
-	const errorPrefix = `${COLORS.red}[ERROR]${COLORS.default} ${moduleName}`;
-
-	const result = new class implements WrappedLogger {
-		public init() {
-			isTrace = [ 'trace' ].includes(_level ?? defaultLevel);
-			isDebug = [ 'trace', 'debug' ].includes(_level ?? defaultLevel);
-			isInfo = [ 'trace', 'debug', 'info' ].includes(_level ?? defaultLevel);
-			isWarning = [ 'trace', 'debug', 'info', 'warn' ].includes(_level ?? defaultLevel);
-			isError = [ 'trace', 'debug', 'info', 'warn', 'error' ].includes(_level ?? defaultLevel);
-		}
-		public get logger() {
-			return _logger;
-		}
-		public set logger(value: Logger) {
-			_logger = value;
-		}
-		public get level(): LogLevel | undefined {
-			return _level;
-		}
-		public set level(value: LogLevel | undefined) {
-			_level = value;
-		}
-		/* eslint-disable @typescript-eslint/no-explicit-any */
-		trace(...args: any[]): void {
-			if (isTrace) {
-				const elapsedInMs = `${COLORS.magenta}+${Date.now() - created}ms${COLORS.default}`;
-
-				logger.trace(tracePrefix, ...args, elapsedInMs);
-			}
-		}
-		/* eslint-disable @typescript-eslint/no-explicit-any */
-		debug(...args: any[]): void {
-			if (isDebug) {
-				const elapsedInMs = `${COLORS.magenta}+${Date.now() - created}ms${COLORS.default}`;
-
-				logger.debug(debugPrefix, ...args, elapsedInMs);
-			}
-		}
-		/* eslint-disable @typescript-eslint/no-explicit-any */
-		info(...args: any[]): void {
-			if (isInfo) {
-				const elapsedInMs = `${COLORS.magenta}+${Date.now() - created}ms${COLORS.default}`;
-
-				logger.info(infoPrefix, ...args, elapsedInMs);
-			}
-		}
-		/* eslint-disable @typescript-eslint/no-explicit-any */
-		warn(...args: any[]): void {
-			if (isWarning) {
-				const elapsedInMs = `${COLORS.magenta}+${Date.now() - created}ms${COLORS.default}`;
-
-				logger.warn(warnPrefix, ...args, elapsedInMs);
-			}
-		}
-		/* eslint-disable @typescript-eslint/no-explicit-any */
-		error(...args: any[]): void {
-			if (isError) {
-				const elapsedInMs = `${COLORS.magenta}+${Date.now() - created}ms${COLORS.default}`;
-
-				logger.error(errorPrefix, ...args, elapsedInMs);
-			}
-            
-		}
+export function createLogger(moduleName: string): Logger {
+	if (loggers.has(moduleName)) {
+		// eslint-disable-next-line no-console
+		console.warn(`Logger for module ${moduleName} already exists`);
+	}
+	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,
 	};
-	
-	return result;
-};
-
-let actualLoggerFactory: LoggerFactory = createDefaultLoggerFactory();
-const loggers = new Map<string, WrappedLogger>();
 
-export const createLogger = (moduleName: string, logLevel?: LogLevel) => {
-	let wrappedLogger = loggers.get(moduleName);
-
-	if (!wrappedLogger) {
-		const logger = actualLoggerFactory();
-
-		wrappedLogger = wrapLogger(logger, moduleName, logLevel ?? defaultLevel);
-		loggers.set(moduleName, wrappedLogger);
-	} else {
-		wrappedLogger.level = logLevel ?? defaultLevel;
-	}
-	wrappedLogger.init();
+	loggers.set(moduleName, logger);
 	
-	return wrappedLogger;
-};
-
-export const setLogLevel = (level: LogLevel) => {
-	defaultLevel = level;
-	for (const [ moduleName ] of Array.from(loggers.entries())) {
-		loggers.set(moduleName, createLogger(moduleName, level));
-	}
-};
-
-export const setLoggerFactory = (loggerFactory: LoggerFactory) => {
-	actualLoggerFactory = loggerFactory;
-	for (const [ moduleName, logger ] of Array.from(loggers.entries())) {
-		loggers.set(moduleName, createLogger(moduleName, logger.level));
-	}
-};
-
-export const getLogLevel = () => {
-	return defaultLevel;
-};
+	return logger;
+}

package/src/common/types.ts

@@ -18,23 +18,11 @@ import {
 	SfuSctpStreamReport,
 	SFUTransportReport,
 } from '@observertc/report-schemas-js';
-import { ObservedCalls } from '../samples/ObservedCalls';
-import { ReportsCollector } from './ReportsCollector';
 import * as Models from '../models/Models';
 import { StorageProvider } from '../storages/StorageProvider';
 import { Message } from '@bufbuild/protobuf';
-import { Middleware } from '../middlewares/Middleware';
-import { ObservedSfus } from '../samples/ObservedSfus';
-
-export type ObserverReport =
-	| CallEventReport
-	| CallMetaReport
-	| ClientExtensionReport
-	| PeerConnectionTransportReport
-	| InboundAudioTrackReport
-	| InboundVideoTrackReport
-	| OutboundAudioTrackReport
-	| OutboundVideoTrackReport;
+
+export type MediaKind = 'audio' | 'video';
 
 export interface EvaluatorContext {
 	readonly startedCallIds: string[];
@@ -97,18 +85,12 @@ export interface EvaluatorContext {
 		closed: number;
 	})[];
 
-	readonly observedCalls: ObservedCalls;
-	readonly observedSfus: ObservedSfus;
 	readonly storages: StorageProvider;
-	readonly reports: ReportsCollector;
+	readonly reports: ObserverSinkContext;
 
-	readonly clientExtensionStats: ClientExtensionReport[],
-	readonly callEvents: CallEventReport[],
-	readonly sfuEvents: SfuEventReport[],
-	readonly sfuExtensionStats: SfuExtensionReport[],
 }
 
-export type EvaluatorMiddleware = Middleware<EvaluatorContext>;
+// export type EvaluatorMiddleware = Middleware<EvaluatorContext>;
 
 export interface ObserverSinkContext {
 	readonly callEventReports: CallEventReport[];
@@ -130,5 +112,3 @@ export interface ObserverSinkContext {
 	readonly sfuTransportReports: SFUTransportReport[];
 	readonly sfuMetaReports: SfuMetaReport[];
 }
-
-export type ObserverSinkMiddleware = Middleware<ObserverSinkContext>;