@observertc/observer-js 0.9.1-beta → 0.9.3-beta

package/src/Evaluator.ts

@@ -103,10 +103,11 @@ export class Evaluator {
 
 	public addObservedSamples(samples: SourcesEvents['observed-samples']): void {
 		// this triggers the evaluation
-		const { observedCalls } = samples;
+		const { observedCalls, observedSfus } = samples;
 
 		const evaluatorContext: EvaluatorContext = {
 			observedCalls,
+			observedSfus,
 			reports: this._reportsCollector,
 			storages: this._storageProvider,
 			joinedClientIds: [],
@@ -123,6 +124,16 @@ export class Evaluator {
 			removedOutboundAudioTracks: [],
 			addedOutboundVideoTrackIds: [],
 			removedOutboundVideoTracks: [],
+			joinedSfuIds: [],
+			detachedSfus: [],
+			openedSfuTransportIds: [],
+			closedSfuTransports: [],
+			addedSfuInbounRtpPadIds: [],
+			removedSfuInbounRtpPadIds: [],
+			addedSfuOutbounRtpPadIds: [],
+			removedSfuOutbounRtpPadIds: [],
+			openedSfuSctpChannelIds: [],
+			closedSfuSctpChannels: [],
 		};
 
 		const callOperations = createCallOperationContext(this._clientOperations, evaluatorContext);
@@ -178,7 +189,8 @@ export class Evaluator {
 		const transactionContext = await createTransactionContext(
 			evaluatorContext,
 			this._storageProvider,
-			evaluatorContext.observedCalls
+			evaluatorContext.observedCalls,
+			evaluatorContext.observedSfus,
 		);
 
 		await this._transactionProcessor.use(transactionContext);

package/src/Observer.ts

@@ -8,6 +8,7 @@ import { ObservedCallSourceConfig, ObservedCallSource } from './sources/Observed
 import { ObservedClientSource, ObservedClientSourceConfig } from './sources/ObservedClientSource';
 import { PartialBy } from './common/utils';
 import { createLogger, LogLevel } from './common/logger';
+import { ObservedSfuSource, ObservedSfuSourceConfig } from './sources/ObservedSfuSource';
 
 const logger = createLogger('Observer');
 
@@ -90,6 +91,7 @@ export class Observer {
 		this._evaluator.on('ready', () => {
 			this._sink.emit();
 		});
+		logger.debug(`Observer is created with config`, this.config);
 	}
 
 	public createCallSource(
@@ -137,17 +139,36 @@ export class Observer {
 	}
 
 	public createClientSource(
-		config: PartialBy<ObservedClientSourceConfig, 'serviceId' | 'mediaUnitId'>
+		config: PartialBy<ObservedClientSourceConfig, 'serviceId' | 'mediaUnitId' | 'joined'>
 	): ObservedClientSource {
 		if (this._closed) {
 			throw new Error(`Attempted to create a client source on a closed observer`);
 		}
 		const serviceId = config.serviceId ?? this.config.defaultServiceId;
 		const mediaUnitId = config.mediaUnitId ?? this.config.defaultMediaUnitId;
+		const joined = config.joined ?? Date.now();
 		return this._sources.createClientSource({
 			...config,
 			serviceId,
 			mediaUnitId,
+			joined,
+		});
+	}
+
+	public createSfuSource(
+		config: PartialBy<ObservedSfuSourceConfig, 'serviceId' | 'mediaUnitId' | 'joined'>
+	): ObservedSfuSource {
+		if (this._closed) {
+			throw new Error(`Attempted to create a sfu source on a closed observer`);
+		}
+		const serviceId = config.serviceId ?? this.config.defaultServiceId;
+		const mediaUnitId = config.mediaUnitId ?? this.config.defaultMediaUnitId;
+		const joined = config.joined ?? Date.now();
+		return this._sources.createSfuSource({
+			...config,
+			serviceId,
+			mediaUnitId,
+			joined,
 		});
 	}
 
@@ -155,18 +176,22 @@ export class Observer {
 		return this._sink;
 	}
 
-	public addEvaluator(process: EvaluatorProcess) {
+	public addEvaluators(...processes: EvaluatorProcess[]) {
 		if (this._closed) {
 			throw new Error(`Attempted to add an evaluator to a closed observer`);
 		}
-		this._evaluator.addProcess(process);
+		for (const process of processes) {
+			this._evaluator.addProcess(process);
+		}
 	}
 
-	public removeEvaluator(process: EvaluatorProcess) {
+	public removeEvaluators(...processes: EvaluatorProcess[]) {
 		if (this._closed) {
 			throw new Error(`Attempted to remove an evaluator from a closed observer`);
 		}
-		this._evaluator.removeProcess(process);
+		for (const process of processes) {
+			this._evaluator.removeProcess(process);
+		}
 	}
 
 	public calls(): AsyncIterableIterator<[string, Models.Call]> {

package/src/common/logger.ts

@@ -1,168 +1,186 @@
 export type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'silent';
 
 export interface Logger {
-	// eslint-disable @typescript-eslint/no-explicit-any
-	trace(...args: any[]): void;
-	// eslint-disable @typescript-eslint/no-explicit-any
-	debug(...args: any[]): void;
-	// eslint-disable @typescript-eslint/no-explicit-any
-	info(...args: any[]): void;
-	// eslint-disable @typescript-eslint/no-explicit-any
-	warn(...args: any[]): void;
-	// eslint-disable @typescript-eslint/no-explicit-any
-	error(...args: any[]): void;
+    /* eslint-disable @typescript-eslint/no-explicit-any */
+    trace(...args: any[]): void;
+    /* eslint-disable @typescript-eslint/no-explicit-any */
+    debug(...args: any[]): void;
+    /* eslint-disable @typescript-eslint/no-explicit-any */
+    info(...args: any[]): void;
+    /* eslint-disable @typescript-eslint/no-explicit-any */
+    warn(...args: any[]): void;
+    /* eslint-disable @typescript-eslint/no-explicit-any */
+    error(...args: any[]): void;
 }
 
 export interface WrappedLogger extends Logger {
-	init(): void;
-	level: LogLevel;
+    init(): void;
+    level: LogLevel | undefined,
 	logger: Logger;
 }
 
 export type LoggerFactory = () => Logger;
 
 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',
+    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",
 };
 
-let defaultLevel: LogLevel = 'error';
+let defaultLevel: LogLevel = "error";
+const created = Date.now();
 
 function createDefaultLoggerFactory(): LoggerFactory {
-	return () => {
-		const trace = (...args: any[]) => {
-			/* eslint-disable no-debugger, no-console */
-			console.trace(...args);
-		};
-		const debug = (...args: any[]) => {
-			/* eslint-disable no-debugger, no-console */
-			console.debug(...args);
-		};
-		const info = (...args: any[]) => {
-			/* eslint-disable no-debugger, no-console */
-			console.info(...args);
-		};
-		const warn = (...args: any[]) => {
-			/* eslint-disable no-debugger, no-console */
-			console.warn(...args);
-		};
-		const error = (...args: any[]) => {
-			/* eslint-disable no-debugger, no-console */
-			console.error(...args);
-		};
-		return {
-			trace,
-			debug,
-			info,
-			warn,
-			error,
-		};
-	};
+    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, logLevel: LogLevel) => {
-	let isTrace = false;
-	let isDebug = false;
-	let isInfo = false;
-	let isWarning = false;
-	let isError = false;
-
-	let _level = logLevel;
-	let _logger = logger;
-
-	const result = new (class implements WrappedLogger {
-		public init() {
-			isTrace = ['trace'].includes(_level);
-			isDebug = ['trace', 'debug'].includes(_level);
-			isInfo = ['trace', 'debug', 'info'].includes(_level);
-			isWarning = ['trace', 'debug', 'info', 'warn'].includes(_level);
-			isError = ['trace', 'debug', 'info', 'warn', 'error'].includes(_level);
-		}
+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() {
-			return _level;
-		}
-		public set level(value: LogLevel) {
-			_level = value;
-		}
-		trace(...args: any[]): void {
-			const tracePrefix = `${COLORS.magenta}[TRACE]${COLORS.default} ${new Date().toISOString()}`;
-			if (isTrace) {
-				logger.trace(tracePrefix, ...args);
-			}
-		}
-		debug(...args: any[]): void {
-			const debugPrefix = `${COLORS.cyan}[DEBUG]${COLORS.default} ${new Date().toISOString()}`;
-			if (isDebug) {
-				logger.debug(debugPrefix, ...args);
-			}
-		}
-		info(...args: any[]): void {
-			const infoPrefix = `${COLORS.green}[INFO]${COLORS.default} ${new Date().toISOString()}`;
-			if (isInfo) {
-				logger.info(infoPrefix, ...args);
-			}
-		}
-		warn(...args: any[]): void {
-			const warnPrefix = `${COLORS.yellow}[WARN]${COLORS.default} ${new Date().toISOString()}`;
-			if (isWarning) {
-				logger.warn(warnPrefix, ...args);
-			}
-		}
-		error(...args: any[]): void {
-			const errorPrefix = `${COLORS.red}[ERROR]${COLORS.default} ${new Date().toISOString()}`;
-			if (isError) {
-				logger.error(errorPrefix, ...args);
-			}
-		}
-	})();
-	return result;
-};
+        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);
+            }
+            
+        }
+    }
+    return result;
+}
+
 
 let actualLoggerFactory: LoggerFactory = createDefaultLoggerFactory();
 const loggers = new Map<string, WrappedLogger>();
 
-export const createLogger = (moduleName: string, logLevel?: LogLevel): Logger => {
+export const createLogger = (moduleName: string, logLevel?: LogLevel) => {
 	let wrappedLogger = loggers.get(moduleName);
 	if (!wrappedLogger) {
-		const logger = actualLoggerFactory();
-		wrappedLogger = wrapLogger(logger, logLevel ?? defaultLevel);
+        const logger = actualLoggerFactory();
+		wrappedLogger = wrapLogger(logger, moduleName, logLevel ?? defaultLevel);
 		loggers.set(moduleName, wrappedLogger);
 	} else {
 		wrappedLogger.level = logLevel ?? defaultLevel;
-	}
-	wrappedLogger.init();
-	return wrappedLogger;
-};
+    }
+    wrappedLogger.init();
+    return wrappedLogger;
+}
 
 export const setLogLevel = (level: LogLevel) => {
-	defaultLevel = level;
-	for (const wrappedLogger of Array.from(loggers.values())) {
-		wrappedLogger.level = level;
-		wrappedLogger.init();
-	}
+    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 wrappedLogger of Array.from(loggers.values())) {
-		wrappedLogger.logger = loggerFactory();
-		wrappedLogger.init();
-	}
+    actualLoggerFactory = loggerFactory;
+    for (const [moduleName, logger] of Array.from(loggers.entries())) {
+        loggers.set(moduleName, createLogger(moduleName, logger.level));
+    }
 };
 
 export const getLogLevel = () => {
-	return defaultLevel;
-};
+    return defaultLevel;
+}
+

package/src/common/types.ts

@@ -14,6 +14,7 @@ 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
@@ -61,7 +62,33 @@ export interface EvaluatorContext {
 		removed: number;
 	})[];
 
+	readonly joinedSfuIds: string[];
+	readonly detachedSfus: (Omit<Models.Sfu, keyof Message> & {
+		detached: number;
+	})[];
+
+	readonly openedSfuTransportIds: string[];
+	readonly closedSfuTransports: (Omit<Models.SfuTransport, keyof Message> & {
+		closed: number;
+	})[];
+
+	readonly addedSfuInbounRtpPadIds: string[];
+	readonly removedSfuInbounRtpPadIds: (Omit<Models.SfuInboundRtpPad, keyof Message> & {
+		removed: number;
+	})[];
+
+	readonly addedSfuOutbounRtpPadIds: string[];
+	readonly removedSfuOutbounRtpPadIds: (Omit<Models.SfuOutboundRtpPad, keyof Message> & {
+		removed: number;
+	})[];
+
+	readonly openedSfuSctpChannelIds: string[];
+	readonly closedSfuSctpChannels: (Omit<Models.SfuSctpChannel, keyof Message> & {
+		closed: number;
+	})[];
+
 	readonly observedCalls: ObservedCalls;
+	readonly observedSfus: ObservedSfus;
 	readonly storages: StorageProvider;
 	readonly reports: ReportsCollector;
 }

package/src/middlewares/CommitTransactionMiddleware.ts

@@ -1,10 +1,4 @@
 import { createLogger } from '../common/logger';
-import { EvaluatorContext } from '../common/types';
-import { ObservedCall } from '../samples/ObservedCall';
-import { ObservedCalls } from '../samples/ObservedCalls';
-import { ObservedClient } from '../samples/ObservedClient';
-import { ObservedPeerConnection } from '../samples/ObservedPeerConnection';
-import { createPeerConnectionOpenedEventReport } from '../sinks/callEventReports';
 import { ObserverStorage } from '../storages/ObserverStorage';
 import { StorageProvider } from '../storages/StorageProvider';
 import { Middleware } from './Middleware';
@@ -267,6 +261,52 @@ export function createCommitTransactionMiddleware(storageProvider: StorageProvid
 		evaluatorContext.addedOutboundVideoTrackIds.push(
 			...addedUnits(oldOutboundVideoTrackModels, updatedOutboundVideoTracks)
 		);
+
+		evaluatorContext.joinedSfuIds.push(
+			...addedUnits(oldSfuModels, updatedSfus)
+		);
+		evaluatorContext.detachedSfus.push(
+			...Array.from(removedSfuModels.values()).map((o) => {
+				return {
+					...o,
+					detached: Date.now(),
+				};
+			})
+		);
+
+		evaluatorContext.openedSfuTransportIds.push(
+			...addedUnits(oldSfuTransportModels, updatedSfuTransports)
+		);
+		evaluatorContext.closedSfuTransports.push(
+			...Array.from(removedSfuTransportModels.values()).map((o) => {
+				return {
+					...o,
+					closed: Date.now(),
+				};
+			})
+		);
+
+		evaluatorContext.removedSfuInbounRtpPadIds.push(...removedUnits(removedSfuInboundRtpPadModels));
+		evaluatorContext.addedSfuInbounRtpPadIds.push(
+			...addedUnits(oldSfuInboundRtpPadModels, updatedSfuInboundRtpPads)
+		);
+
+		evaluatorContext.removedSfuOutbounRtpPadIds.push(...removedUnits(removedSfuOutboundRtpPadModels));
+		evaluatorContext.addedSfuOutbounRtpPadIds.push(
+			...addedUnits(oldSfuOutboundRtpPadModels, updatedSfuOutboundRtpPads)
+		);
+
+		evaluatorContext.openedSfuSctpChannelIds.push(
+			...addedUnits(oldSfuSctpChannelModels, updatedSfuSctpChannels)
+		);
+		evaluatorContext.closedSfuSctpChannels.push(
+			...Array.from(removedSfuSctpChannelModels.values()).map((o) => {
+				return {
+					...o,
+					closed: Date.now(),
+				};
+			})
+		);
 	};
 
 	const result = async (context: TransactionContext, next?: Middleware<TransactionContext>) => {

package/src/middlewares/TransactionContext.ts

@@ -6,10 +6,12 @@ import { ReportsCollector } from '../common/ReportsCollector';
 import { v4 as uuid } from 'uuid';
 import { EvaluatorContext } from '../common/types';
 import { Writable } from '../common/utils';
+import { ObservedSfus } from '../samples/ObservedSfus';
 
 export type TransactionContext = {
 	id: string;
 	observedCalls: ObservedCalls;
+	observedSfus: ObservedSfus;
 
 	clients: ReadonlyMap<string, Models.Client>;
 
@@ -44,13 +46,14 @@ export type TransactionContext = {
 	deletedSfuSctpChannels: Set<string>;
 
 	// build for another middleware
-	evaluatorContext: Writable<Omit<EvaluatorContext, 'observedCalls'>>;
+	evaluatorContext: Writable<Omit<EvaluatorContext, 'observedCalls' | 'observedSfus'>>;
 };
 
 export async function createTransactionContext(
 	evaluatorContext: EvaluatorContext,
 	storageProvider: StorageProvider,
-	observedCalls: ObservedCalls
+	observedCalls: ObservedCalls,
+	observedSfus: ObservedSfus,
 ): Promise<TransactionContext> {
 	const {
 		clientStorage,
@@ -103,7 +106,8 @@ export async function createTransactionContext(
 	const transactionContext: TransactionContext = {
 		id: uuid(),
 		observedCalls,
-
+		observedSfus,
+		
 		clients,
 		updatedPeerConnections: new Map<string, Models.PeerConnection>(peerConnections.entries()),
 		deletedPeerConnections: new Set<string>(),

package/src/middlewares/TransactoinProcessor.ts

@@ -4,6 +4,7 @@ import { createCommitTransactionMiddleware } from './CommitTransactionMiddleware
 import { Processor, createProcessor } from './Processor';
 import { TransactionContext } from './TransactionContext';
 import { createVisitObservedCallsMiddleware } from './VisitObservedCallsMiddleware';
+import { createVisitObservedSfusMiddleware } from './VisitObservedSfusMiddleware';
 
 export function createTransactionProcessor(
 	storageProvider: StorageProvider,
@@ -11,8 +12,9 @@ export function createTransactionProcessor(
 	fetchSamples: boolean
 ): Processor<TransactionContext> {
 	return createProcessor(
-		// all of these middleware must execute sequentially!
+		// all of these middlewares must execute sequentially!
 		createVisitObservedCallsMiddleware(reportsCollector, fetchSamples),
+		createVisitObservedSfusMiddleware(reportsCollector, fetchSamples),
 
 		// must be the last one!
 		createCommitTransactionMiddleware(storageProvider)

package/src/middlewares/VisitObservedCallsMiddleware.ts

@@ -6,7 +6,7 @@ import { visitPeerConnection } from './visitors/visitPeerConnection';
 import { createLogger } from '../common/logger';
 import { visitInboundAudioTrack } from './visitors/visitInboundAudioTrack';
 import { visitOutboundAudioTrack } from './visitors/visitOutboundAudioTrack';
-import { visitOutboundVideoTrack } from './visitors/visitOutboundVideoTarcks';
+import { visitOutboundVideoTrack } from './visitors/visitOutboundVideoTarck';
 
 export const logger = createLogger('VisitObservedCallsMiddleware');