@observertc/observer-js 0.9.27-beta → 0.30.0-e12fcb4.0

package/lib/sources/Sources.js

@@ -1,213 +0,0 @@
-"use strict";
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Sources = void 0;
-const ObservedCalls_1 = require("../samples/ObservedCalls");
-const events_1 = require("events");
-const logger_1 = require("../common/logger");
-const ObservedSfus_1 = require("../samples/ObservedSfus");
-const logger = (0, logger_1.createLogger)('Sources');
-class Sources {
-    constructor(config) {
-        this.config = config;
-        this._warnFlags = { autoEmitButEmitSamplesInvoked: false };
-        this._callSources = new Map();
-        // private readonly _clientSources = new Map<string, ObservedClientSource>();
-        this._sfuSources = new Map();
-        this._emitter = new events_1.EventEmitter();
-        this._observedCallsBuilder = new ObservedCalls_1.ObservedCallsBuilder();
-        this._observedSfusBuilder = new ObservedSfus_1.ObservedSfusBuilder();
-        this._numberOfSamples = 0;
-    }
-    getCallSource(callId) {
-        if (!this._callSources.has(callId))
-            return;
-        return this._callSources.get(callId);
-    }
-    getSfuSource(sfuId) {
-        if (!this._sfuSources.has(sfuId))
-            return;
-        return this._sfuSources.get(sfuId);
-    }
-    on(event, listener) {
-        this._emitter.addListener(event, listener);
-        return this;
-    }
-    off(event, listener) {
-        this._emitter.removeListener(event, listener);
-        return this;
-    }
-    _emit(event, data) {
-        return this._emitter.emit(event, data);
-    }
-    createCallSource(config) {
-        let closed = false;
-        const { serviceId, mediaUnitId, appData } = config, callConfig = __rest(config, ["serviceId", "mediaUnitId", "appData"]);
-        const clientSources = new Map();
-        const callSource = Object.assign(Object.assign({}, callConfig), { appData,
-            serviceId,
-            mediaUnitId,
-            get clients() {
-                return clientSources.values();
-            }, getClientSource: (clientId) => {
-                if (!clientSources.has(clientId))
-                    return;
-                else
-                    return clientSources.get(clientId);
-            }, createClientSource: (context) => {
-                const existingClientSource = clientSources.get(context.clientId);
-                if (existingClientSource)
-                    return existingClientSource;
-                const { appData: clientAppData } = context, clientConfig = __rest(context, ["appData"]);
-                const clientSource = this._createClientSource(callSource, Object.assign(Object.assign(Object.assign({}, callConfig), clientConfig), { appData: clientAppData, serviceId,
-                    mediaUnitId }));
-                const closeClientSource = clientSource.close;
-                clientSource.close = () => {
-                    closeClientSource();
-                    clientSources.delete(context.clientId);
-                };
-                clientSources.set(context.clientId, clientSource);
-                return clientSource;
-            }, close: () => {
-                if (closed) {
-                    return;
-                }
-                closed = true;
-                for (const clientSource of clientSources.values()) {
-                    clientSource.close();
-                }
-                clientSources.clear();
-                this._callSources.delete(config.callId);
-                this._emit('removed-call-source', callSource);
-            }, closed });
-        if (this._callSources.size < 1) {
-            this._resetTimer();
-        }
-        this._callSources.set(config.callId, callSource);
-        this._emit('added-call-source', callSource);
-        return callSource;
-    }
-    _createClientSource(callSource, config) {
-        var _a;
-        let closed = false;
-        const { appData } = config, clientConfig = __rest(config, ["appData"]);
-        const source = Object.assign(Object.assign({}, clientConfig), { appData, joined: (_a = config.joined) !== null && _a !== void 0 ? _a : Date.now(), accept: (...samples) => {
-                if (closed) {
-                    throw new Error('Cannot accept ClientSample, because the ClientSource is closed');
-                }
-                const observedCallBuilder = this._observedCallsBuilder.getOrCreateObservedCallBuilder(callSource.callId, () => {
-                    return Object.assign({}, callSource);
-                });
-                const observedClientBuilder = observedCallBuilder.getOrCreateObservedClientBuilder(config.clientId, () => {
-                    return Object.assign({}, source);
-                });
-                for (const sample of samples) {
-                    observedClientBuilder.addClientSample(sample);
-                }
-                this._incrementSamples(samples.length);
-            }, close: () => {
-                if (closed) {
-                    return;
-                }
-                closed = true;
-                this._emit('removed-client-source', source);
-            }, closed });
-        this._emit('added-client-source', source);
-        return source;
-    }
-    createSfuSource(config) {
-        var _a;
-        const existingSfuSource = this._sfuSources.get(config.sfuId);
-        if (existingSfuSource) {
-            return existingSfuSource;
-        }
-        let closed = false;
-        // config.joined = config.joined ?? Date.now();
-        const source = Object.assign(Object.assign({}, config), { joined: (_a = config.joined) !== null && _a !== void 0 ? _a : Date.now(), accept: (...samples) => {
-                if (closed) {
-                    throw new Error('Cannot accept SfuSample, because the SfuSource is closed');
-                }
-                const observedSfuBuilder = this._observedSfusBuilder.getOrCreateObservedSfuBuilder(config.sfuId, () => {
-                    return Object.assign({}, source);
-                });
-                for (const sample of samples) {
-                    observedSfuBuilder.addSfuSample(sample);
-                }
-                this._incrementSamples(samples.length);
-            }, close: () => {
-                if (closed) {
-                    return;
-                }
-                closed = true;
-                this._sfuSources.delete(config.sfuId);
-                this._emit('removed-sfu-source', source);
-            }, closed });
-        if (this._sfuSources.size < 1) {
-            this._resetTimer();
-        }
-        this._sfuSources.set(config.sfuId, source);
-        this._emit('added-sfu-source', source);
-        return source;
-    }
-    _incrementSamples(increment = 1) {
-        this._numberOfSamples += increment;
-        if (this.config.maxSamples < 1 || this._numberOfSamples < this.config.maxSamples) {
-            return;
-        }
-        this._emitSamples();
-    }
-    emitSamples() {
-        if (0 < this.config.maxSamples || 0 < this.config.maxTimeInMs) {
-            if (!this._warnFlags.autoEmitButEmitSamplesInvoked) {
-                logger.warn(`Emitting Samples is called explicitly, 
-					but samples are emitted automatically because of configuration 
-					(maxSamples: ${this.config.maxSamples}, maxTImeInMs: ${this.config.maxTimeInMs})`);
-                this._warnFlags.autoEmitButEmitSamplesInvoked = true;
-            }
-        }
-        this._emitSamples();
-    }
-    _emitSamples() {
-        this._resetTimer();
-        const observedCalls = this._observedCallsBuilder.build();
-        this._observedCallsBuilder = new ObservedCalls_1.ObservedCallsBuilder();
-        const observedSfus = this._observedSfusBuilder.build();
-        this._observedSfusBuilder = new ObservedSfus_1.ObservedSfusBuilder();
-        this._emit('observed-samples', {
-            observedCalls,
-            observedSfus,
-            numberOfSamples: this._numberOfSamples,
-        });
-        this._numberOfSamples = 0;
-    }
-    _resetTimer() {
-        if (this._timer) {
-            clearTimeout(this._timer);
-            this._timer = undefined;
-        }
-        if (0 < this.config.maxTimeInMs) {
-            this._timer = setTimeout(() => {
-                this._timer = undefined;
-                this._emitSamples();
-            }, this.config.maxTimeInMs);
-        }
-    }
-    close() {
-        [...this._callSources.values()].forEach((callSource) => callSource.close());
-        [...this._sfuSources.values()].forEach((sfuSource) => sfuSource.close());
-        this._callSources.clear();
-        this._sfuSources.clear();
-        this._emitSamples();
-    }
-}
-exports.Sources = Sources;

package/src/Evaluator.ts

@@ -1,229 +0,0 @@
-import { createLogger } from './common/logger';
-import { Semaphore } from './common/Semaphore';
-import { EvaluatorContext } from './common/types';
-import { ReportsCollector } from './common/ReportsCollector';
-import { ObservedClientSourceConfig } from './sources/ObservedClientSource';
-import { SourcesEvents } from './sources/Sources';
-import { StorageProvider } from './storages/StorageProvider';
-import { createProcessor, Processor } from './middlewares/Processor';
-import { createTransactionContext, TransactionContext } from './middlewares/TransactionContext';
-import { Middleware } from './middlewares/Middleware';
-import { CallOperationsContext, CallOperation, createCallOperationContext } from './middlewares/CallOperationsContext';
-import { createCallProcessor } from './middlewares/CallProcessor';
-import { createTransactionProcessor } from './middlewares/TransactoinProcessor';
-import { EventEmitter } from 'events';
-
-const logger = createLogger('Evaluator');
-
-export type EvaluatorEvents = {
-	ready: Error | undefined;
-};
-
-export type EvaluatorConfig = {
-	fetchSamples: boolean;
-	maxIdleTimeInMs?: number,
-	findRemoteMatches?: boolean,
-};
-
-export type EvaluatorProcess = (evaluatorContext: EvaluatorContext) => Promise<void>;
-
-export class Evaluator {
-	private _index = 0;
-	private _evaluations = new Map<number, Promise<void>>();
-
-	private _clientOperations = new Map<string, CallOperation>();
-	private _emitter = new EventEmitter();
-
-	private _evaluatorProcesses = new Map<EvaluatorProcess, Middleware<EvaluatorContext>>();
-	private _callProcessor: Processor<CallOperationsContext>;
-	private _transactionProcessor: Processor<TransactionContext>;
-	private _customProcessor: Processor<EvaluatorContext>;
-
-	public constructor(
-		public readonly config: EvaluatorConfig,
-		private readonly _callSemaphore: Semaphore,
-		private readonly _storageProvider: StorageProvider,
-		private readonly _reportsCollector: ReportsCollector
-	) {
-		this._callProcessor = createCallProcessor(_storageProvider, _reportsCollector);
-
-		this._transactionProcessor = createTransactionProcessor(
-			_storageProvider,
-			_reportsCollector,
-			this.config.fetchSamples,
-			BigInt(this.config.maxIdleTimeInMs ?? 10000),
-			this.config.findRemoteMatches,
-		);
-
-		this._customProcessor = createProcessor();
-	}
-
-	public addProcess(process: EvaluatorProcess) {
-		const middleware: Middleware<EvaluatorContext> = async (context, next) => {
-			await process(context);
-			if (next) await next(context);
-		};
-
-		this._evaluatorProcesses.set(process, middleware);
-		this._customProcessor.addMiddleware(middleware);
-	}
-
-	public removeProcess(process: EvaluatorProcess) {
-		const middleware = this._evaluatorProcesses.get(process);
-
-		if (!middleware) {
-			return;
-		}
-		this._evaluatorProcesses.delete(process);
-		this._customProcessor.removeMiddleware(middleware);
-	}
-
-	public addClosedClientSource(clientSource: ObservedClientSourceConfig) {
-		this._clientOperations.set(clientSource.clientId, {
-			type: 'detach',
-			...clientSource,
-			detached: Date.now(),
-		});
-	}
-
-	public addCreatedClientSource(clientSource: ObservedClientSourceConfig) {
-		this._clientOperations.set(clientSource.clientId, {
-			type: 'join',
-			...clientSource,
-		});
-	}
-
-	public on<K extends keyof EvaluatorEvents>(event: K, listener: (data: EvaluatorEvents[K]) => void): this {
-		this._emitter.addListener(event, listener);
-		
-		return this;
-	}
-
-	public once<K extends keyof EvaluatorEvents>(event: K, listener: (data: EvaluatorEvents[K]) => void): this {
-		this._emitter.once(event, listener);
-		
-		return this;
-	}
-
-	public off<K extends keyof EvaluatorEvents>(event: K, listener: (data: EvaluatorEvents[K]) => void): this {
-		this._emitter.removeListener(event, listener);
-		
-		return this;
-	}
-
-	private _emit<K extends keyof EvaluatorEvents>(event: K, data: EvaluatorEvents[K]): boolean {
-		return this._emitter.emit(event, data);
-	}
-
-	public addObservedSamples(samples: SourcesEvents['observed-samples']): void {
-		// this triggers the evaluation
-		const { observedCalls, observedSfus } = samples;
-		
-		const evaluatorContext: EvaluatorContext = {
-			observedCalls,
-			observedSfus,
-			reports: this._reportsCollector,
-			storages: this._storageProvider,
-			joinedClientIds: [],
-			detachedClients: [],
-			startedCallIds: [],
-			endedCalls: [],
-			openedPeerConnectionIds: [],
-			closedPeerConnections: [],
-			addedInboundAudioTrackIds: [],
-			removedInboundAudioTracks: [],
-			addedInboundVideoTrackIds: [],
-			removedInboundVideoTracks: [],
-			addedOutboundAudioTrackIds: [],
-			removedOutboundAudioTracks: [],
-			addedOutboundVideoTrackIds: [],
-			removedOutboundVideoTracks: [],
-			joinedSfuIds: [],
-			detachedSfus: [],
-			openedSfuTransportIds: [],
-			closedSfuTransports: [],
-			addedSfuInbounRtpPadIds: [],
-			removedSfuInbounRtpPadIds: [],
-			addedSfuOutbounRtpPadIds: [],
-			removedSfuOutbounRtpPadIds: [],
-			openedSfuSctpChannelIds: [],
-			closedSfuSctpChannels: [],
-			
-			clientExtensionStats: [],
-			callEvents: [],
-			sfuEvents: [],
-			sfuExtensionStats: [],
-		};
-		
-		const callOperations = createCallOperationContext(this._clientOperations, evaluatorContext);
-
-		this._clientOperations.clear();
-
-		this._eval(callOperations, evaluatorContext)
-			.then(() => {
-				logger.debug('Evaluator is successfully performed eval process');
-			})
-			.catch((err) => {
-				logger.warn('Error occurred while evaluating', err);
-			});
-	}
-
-	private async _eval(callOperationsContext: CallOperationsContext, evaluatorContext: EvaluatorContext): Promise<void> {
-		const actualBlockingPoint = this._evaluations.get(this._index) ?? Promise.resolve();
-		const index = ++this._index;
-		const result = new Promise<void>((resolve, reject) => {
-			actualBlockingPoint.then(() => {
-				this._process(callOperationsContext, evaluatorContext)
-					.then(() => resolve())
-					.catch((err) => reject(err));
-			});
-		});
-		const nextBlockingPoint = new Promise<void>((resolve) => {
-			result.then(() => {
-				this._evaluations.delete(index);
-				resolve();
-			}).catch(() => {
-				this._evaluations.delete(index);
-				resolve();
-			});
-		});
-
-		this._evaluations.set(index, nextBlockingPoint);
-		
-		return result;
-	}
-
-	public get ongoingProcess(): number {
-		return this._evaluations.size;
-	}
-
-	private async _process(
-		callOperationsContext: CallOperationsContext,
-		evaluatorContext: EvaluatorContext
-	): Promise<void> {
-		const process = async () => {
-			await this._callSemaphore.acquire();
-			await this._callProcessor.use(callOperationsContext).finally(() => {
-				this._callSemaphore.release();
-			});
-			const transactionContext = await createTransactionContext(
-				evaluatorContext,
-				this._storageProvider,
-				evaluatorContext.observedCalls,
-				evaluatorContext.observedSfus,
-			);
-	
-			await this._transactionProcessor.use(transactionContext);
-	
-			await this._customProcessor.use(evaluatorContext);
-		};
-
-		await process().then(() => {
-			this._emit('ready', undefined);
-		})
-			.catch((err) => {
-				logger.warn('Error occurred while evaluating samples', err);
-				this._emit('ready', err);
-			});
-	}
-}

package/src/common/Semaphore.ts

@@ -1,45 +0,0 @@
-/**
- * Interface for a Semaphore, a synchronization primitive that provides exclusive access to a shared resource.
- * Semaphores are used to ensure that only one process can access the shared resource at a time.
- */
-export interface Semaphore {
-
-	/**
-	 * Acquires the semaphore, blocking until the semaphore is available.
-	 * When the semaphore is acquired, it prevents other processes from acquiring it.
-	 * @returns A Promise that resolves when the semaphore is successfully acquired.
-	 */
-	acquire(): Promise<void>;
-
-	/**
-	 * Releases the semaphore, allowing other processes to acquire it.
-	 * @returns A Promise that resolves when the semaphore is successfully released.
-	 */
-	release(): Promise<void>;
-}
-
-export function createDummySemaphore(): Semaphore {
-	return {
-		acquire: () => Promise.resolve(),
-		release: () => Promise.resolve(),
-	};
-}
-
-/**
- * Interface for a SemaphoreProvider, an object that provides semaphore instances for different shared resources.
- * SemaphoreProviders are used to manage access to shared resources across multiple processes.
- */
-export interface SemaphoreProvider {
-
-	/**
-	 * A Semaphore instance that manages access to the 'call' shared resource.
-	 * This semaphore ensures that only one process can access the 'call' resource at a time.
-	 */
-	readonly callSemaphore: Semaphore;
-}
-
-export function createSimpleSemaphoreProvider(): SemaphoreProvider {
-	return {
-		callSemaphore: createDummySemaphore(),
-	};
-}

package/src/entries/CallEntry.ts

@@ -1,62 +0,0 @@
-import * as Models from '../models/Models';
-import { StorageProvider } from '../storages/StorageProvider';
-import { createLogger } from '../common/logger';
-import { asyncIteratorConverter } from '../common/utils';
-import { ClientEntry, createClientEntry } from './ClientEntry';
-
-export const logger = createLogger('CallWrapper');
-
-export type CallEntry = ReturnType<typeof createCallEntry>;
-
-export function createCallEntry(storageProvider: StorageProvider, model?: Models.Call) {
-	if (!model) return;
-	const { 
-		callId,
-		roomId,
-		serviceId,
-		started,
-	} = model;
-
-	if (!callId) return logger.warn(`Call model without callId: ${JSON.stringify(model)}`);
-	if (!roomId) return logger.warn(`Call model without roomId: ${JSON.stringify(model)}`);
-	if (!serviceId) return logger.warn(`Call model without serviceId: ${JSON.stringify(model)}`);
-	if (!started) return logger.warn(`Call model without started: ${JSON.stringify(model)}`);
-
-	const getClient = async (clientId: string) => {
-		return model.clientIds.includes(clientId) ? createClientEntry(storageProvider, await storageProvider.clientStorage.get(clientId)) : undefined;
-	};
-
-	const asyncClientsGenerator = async function *(providedClientIds?: string[]) {
-		const { clientStorage } = storageProvider;
-		const clientModels = await Promise.all(
-			(providedClientIds ?? model.clientIds).map((clientId) => clientStorage.get(clientId))
-		);
-
-		for (const clientModel of clientModels) {
-			if (!clientModel) continue;
-			yield createClientEntry(storageProvider, clientModel);
-		}
-	};
-	
-	return {
-		callId,
-		roomId, 
-		serviceId,
-		started,
-		get clientIds(): ReadonlyArray<string> {
-			return model.clientIds;
-		},
-		getClient,
-		get clients(): AsyncIterableIterator<ClientEntry> {
-			return asyncIteratorConverter<ClientEntry>(asyncClientsGenerator());
-		},
-
-		refresh: async () => {
-			const refreshedModel = await storageProvider.callStorage.get(callId);
-
-			if (!refreshedModel) return;
-
-			model.clientIds = refreshedModel.clientIds;
-		}
-	};
-}

package/src/entries/ClientEntry.ts

@@ -1,106 +0,0 @@
-import * as Models from '../models/Models';
-import { StorageProvider } from '../storages/StorageProvider';
-import { logger, createCallEntry } from './CallEntry';
-import { asyncIteratorConverter } from '../common/utils';
-import { PeerConnectionEntry, createPeerConnectionEntry } from './PeerConnectionEntry';
-
-export type ClientEntry = ReturnType<typeof createClientEntry>;
-
-export function createClientEntry(storageProvider: StorageProvider, model?: Models.Client) {
-	if (!model) return;
-
-	const {
-		clientId, 
-		roomId, 
-		serviceId, 
-		mediaUnitId, 
-		callId, 
-		joined, 
-		timeZoneId, 
-	} = model;
-
-	if (!callId) return logger.warn(`Client model without callId: ${JSON.stringify(model)}`);
-	if (!roomId) return logger.warn(`Client model without roomId: ${JSON.stringify(model)}`);
-	if (!clientId) return logger.warn(`Client model without clientId: ${JSON.stringify(model)}`);
-	if (!serviceId) return logger.warn(`Client model without serviceId: ${JSON.stringify(model)}`);
-	if (!mediaUnitId) return logger.warn(`Client model without mediaUnitId: ${JSON.stringify(model)}`);
-
-	const getCall = async () => {
-		return createCallEntry(storageProvider, await storageProvider.callStorage.get(callId));
-	};
-
-	const asyncPeerConnectionGenerator = async function *(providedPeerConnectionIds?: string[]) {
-		const peerConnectionModels = await Promise.all(
-			(providedPeerConnectionIds ?? model.peerConnectionIds).map((peerConnectionId) => storageProvider.peerConnectionStorage.get(peerConnectionId))
-		);
-
-		for (const peerConnectionModel of peerConnectionModels) {
-			if (!peerConnectionModel) continue;
-			yield createPeerConnectionEntry(storageProvider, peerConnectionModel);
-		}
-	};
-
-	return {
-		clientId,
-		roomId,
-		serviceId,
-		mediaUnitId,
-		callId,
-		joined,
-		timeZoneId,
-		get browser() {
-			return model.browser;
-		},
-		get engine() {
-			return model.engine;
-		},
-		get operationSystem() {
-			return model.operationSystem;
-		},
-		get platform() {
-			return model.platform;
-		},
-		get peerConnectionIds(): ReadonlyArray<string> {
-			return model.peerConnectionIds;
-		},
-		get marker() {
-			return model.marker;
-		},
-		get coordinates(): { latitude: number; longitude: number } | undefined {
-			if (!model.coordinates) return;
-
-			const {
-				longitude,
-				latitude
-			} = model.coordinates;
-
-			if (!latitude) return;
-			if (!longitude) return;
-
-			return {
-				latitude,
-				longitude
-			};
-		},
-		getCall,
-		get peerConnections(): AsyncIterableIterator<PeerConnectionEntry> {
-			return asyncIteratorConverter<PeerConnectionEntry>(asyncPeerConnectionGenerator());
-		},
-		getPeerConnection: async (peerConnectionId: string) => {
-			return model.peerConnectionIds.includes(peerConnectionId) ? createPeerConnectionEntry(storageProvider, await storageProvider.peerConnectionStorage.get(peerConnectionId)) : undefined;
-		},
-
-		refresh: async () => {
-			const refreshedModel = await storageProvider.clientStorage.get(clientId);
-
-			if (!refreshedModel) return;
-
-			model.browser = refreshedModel.browser;
-			model.engine = refreshedModel.engine;
-			model.operationSystem = refreshedModel.operationSystem;
-			model.platform = refreshedModel.platform;
-			model.peerConnectionIds = refreshedModel.peerConnectionIds;
-			model.marker = refreshedModel.marker;
-		}
-	};
-}