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

package/src/processes/detachClientProcess.ts

@@ -1,136 +0,0 @@
-import { EvaluatorContext } from '../common/types';
-import { StorageProvider } from '../storages/StorageProvider';
-import * as Models from '../models/Models';
-import { createCallEndedEventReport, createClientLeftEventReport } from '../sinks/callEventReports';
-import { ReportsCollector } from '../common/ReportsCollector';
-import { createClosePeerConnectionProcess, ClosePeerConnectionProcessInput } from './closePeerConnectionProcess';
-import { createLogger } from '../common/logger';
-import { ObservedClientSourceConfig } from '../sources/ObservedClientSource';
-import { Writable } from '../common/utils';
-
-const logger = createLogger('ClientLeftProcess');
-
-export type DetachClientProcessInput = {
-	clients: (ObservedClientSourceConfig & {
-		detached: number;
-	})[];
-	recursive: boolean;
-
-	evaluatorContext?: Writable<EvaluatorContext>;
-};
-
-export function createDetachClientProcess(
-	storageProvider: StorageProvider,
-	reports: ReportsCollector
-): (input: DetachClientProcessInput) => Promise<void> {
-	const peerConnectionClosedProcess = createClosePeerConnectionProcess(storageProvider);
-	const process = async (context: DetachClientProcessInput) => {
-		const { clients: detachedClients, recursive, evaluatorContext } = context;
-		const { callStorage, clientStorage } = storageProvider;
-
-		const clientIds = detachedClients.map((c) => c.clientId);
-
-		if (clientIds.length < 1) return;
-
-		const clients = await clientStorage.getAll(clientIds);
-		const callToClientIds = new Map<string, string[]>();
-
-		for (const client of clients.values()) {
-			const { callId, clientId } = client;
-
-			if (!callId || !clientId) {
-				continue;
-			}
-			callToClientIds.set(callId, [ ...(callToClientIds.get(callId) ?? []), clientId ]);
-		}
-
-		const peerConnectionCloseProcessInput: ClosePeerConnectionProcessInput = {
-			closedPeerConnections: [],
-			recursive,
-		};
-		const callDetaches = new Map<string, number>();
-
-		await clientStorage.removeAll(clientIds).then((deletedClientIds) => {
-			for (const { clientId, detached } of detachedClients) {
-				if (!deletedClientIds.has(clientId)) {
-					continue;
-				}
-				const deletedClient = clients.get(clientId);
-
-				if (!deletedClient) {
-					continue;
-				}
-				const { roomId, serviceId, mediaUnitId, marker, callId, userId } = deletedClient;
-
-				if (!roomId || !serviceId || !mediaUnitId || !callId) {
-					continue;
-				}
-
-				for (const peerConnectionId of deletedClient.peerConnectionIds) {
-					peerConnectionCloseProcessInput.closedPeerConnections.push({
-						peerConnectionId,
-						closed: detached,
-					});
-				}
-
-				reports.addCallEventReport(
-					createClientLeftEventReport(serviceId, mediaUnitId, roomId, callId, clientId, detached, userId, marker)
-				);
-				evaluatorContext?.detachedClients.push({
-					...deletedClient,
-					detached: Number(detached),
-				});
-
-				callDetaches.set(callId, Math.max(callDetaches.get(callId) ?? 0, detached));
-			}
-		});
-		if (recursive && 0 < peerConnectionCloseProcessInput.closedPeerConnections.length) {
-			await peerConnectionClosedProcess(peerConnectionCloseProcessInput).catch((err) => {
-				logger.error('Error occurred while closing peer connections', err);
-			});
-		}
-
-		const calls = await callStorage.getAll(callToClientIds.keys());
-		const updatedCalls = new Map<string, Models.Call>();
-		const removedCallIds: string[] = [];
-
-		for (const call of calls.values()) {
-			const { callId, serviceId, roomId } = call;
-
-			if (!callId || !roomId || !serviceId) continue;
-
-			const removedClientIds = callToClientIds.get(callId) ?? [];
-
-			call.clientIds = call.clientIds.filter((clientId) => !removedClientIds.includes(clientId));
-			if (call.clientIds.length < 1) {
-				removedCallIds.push(callId);
-			} else {
-				updatedCalls.set(callId, call);
-			}
-		}
-		if (0 < updatedCalls.size) {
-			await callStorage.setAll(updatedCalls);
-		}
-		if (0 < removedCallIds.length) {
-			await callStorage.removeAll(removedCallIds).then((deletedCalls) => {
-				for (const [ callId, deletedCall ] of deletedCalls) {
-					const { serviceId, roomId } = deletedCall;
-
-					if (!serviceId || !roomId || !callId) continue;
-
-					const ended = callDetaches.get(callId) ?? Date.now();
-					const callEvent = createCallEndedEventReport(serviceId, roomId, callId, ended);
-
-					reports.addCallEventReport(callEvent);
-
-					evaluatorContext?.endedCalls.push({
-						...deletedCall,
-						ended,
-					});
-				}
-			});
-		}
-	};
-	
-	return process;
-}

package/src/processes/findRemoteMatches.ts

@@ -1,104 +0,0 @@
-import { createLogger } from '../common/logger';
-import { Client, InboundTrack, OutboundTrack, PeerConnection } from '../models/Models';
-import { StorageProvider } from '../storages/StorageProvider';
-
-export const logger = createLogger('findRemoteMatches');
-
-function groupToMap<T>(input: ReadonlyMap<string, T>, getGroupKey: (value: T) => string | undefined) {
-	const result = new Map<string, T[]>();
-
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	for (const [ key, value ] of input.entries()) {
-		const groupKey = getGroupKey(value);
-
-		if (!groupKey) continue;
-
-		let group = result.get(groupKey);
-
-		if (group === undefined) {
-			group = [];
-			result.set(groupKey, group);
-		}
-		group.push(value);
-	}
-	
-	return result;
-}
-
-export async function findRemoteMatches(
-	storages: StorageProvider, 
-	clients: ReadonlyMap<string, Client>,
-	inboundTracks: ReadonlyMap<string, InboundTrack>,
-) {
-	const NOT_EXISTS = 'NotExists';
-	const remoteTrackIds = new Map<string, string>();
-	const remotePeerConnectionIds = new Map<string, string>();
-	const remoteClientIds = new Map<string, string>();
-
-	async function setupMatches(callId: string, callClients: Client[], callIboundTracks: InboundTrack[]) {
-		const peerConnectionIds = Array.from(callClients.values()).flatMap((client) => client.peerConnectionIds);
-		const peerConnections = await storages.peerConnectionStorage.getAll(peerConnectionIds).catch((err) => {
-			logger.warn(`Error while fetching for remote matching peer connections for call ${callId} `, err);
-			
-			return new Map<string, PeerConnection>() as ReadonlyMap<string, PeerConnection>;
-		});
-		const outboundTrackIds = Array.from(peerConnections.values()).flatMap((pc) => pc.outboundTrackIds);
-		const outboundTracks = await storages.outboundTrackStorage.getAll(outboundTrackIds).catch((err) => {
-			logger.warn(`Error while fetching for remote matching outbound tracks for call ${callId} `, err);
-			
-			return new Map<string, OutboundTrack>() as ReadonlyMap<string, OutboundTrack>;
-		});
-		
-		// console.warn("setupMatches", peerConnectionIds, outboundTrackIds, callsClients, callsInbTracks);
-
-		const ssrcToOutb = new Map<bigint, OutboundTrack>();
-		const sfuStreamToTrackIds = new Map<string, OutboundTrack>();
-
-		for (const outbTrack of outboundTracks.values()) {
-			if (outbTrack.sfuStreamId) {
-				sfuStreamToTrackIds.set(outbTrack.sfuStreamId, outbTrack);
-			}
-			for (const ssrc of outbTrack.ssrc) {
-				ssrcToOutb.set(ssrc, outbTrack);
-			}
-		}
-		for (const inbTrack of callIboundTracks) {
-			let outbTrack: OutboundTrack | undefined;
-
-			if (inbTrack.sfuStreamId) {
-				outbTrack = sfuStreamToTrackIds.get(inbTrack.sfuStreamId);
-			} else {
-				outbTrack = inbTrack.ssrc.map((ssrc) => ssrcToOutb.get(ssrc)).find((outb) => outb !== undefined);
-			}
-			if (outbTrack) {
-				remoteTrackIds.set(inbTrack.trackId ?? NOT_EXISTS, outbTrack.trackId ?? NOT_EXISTS);
-				remotePeerConnectionIds.set(inbTrack.trackId ?? NOT_EXISTS, outbTrack.peerConnectionId ?? NOT_EXISTS);
-				remoteClientIds.set(inbTrack.trackId ?? NOT_EXISTS, outbTrack.clientId ?? NOT_EXISTS);
-			}
-		}
-	}
-	const callsClients = groupToMap<Client>(clients, (client) => client.callId);
-	const callsInbTracks = groupToMap<InboundTrack>(inboundTracks, (inbTrack) => inbTrack.callId);
-	
-	const promises: Promise<void>[] = [];
-
-	for (const [ callId, callClients ] of callsClients) {
-		const callIboundTracks = callsInbTracks.get(callId) ?? [];
-		const promise = setupMatches(
-			callId,
-			callClients,
-			callIboundTracks
-		);
-
-		promises.push(promise);
-	}
-	await Promise.all(promises).catch((err) => {
-		logger.warn('Error occurred while fetching remote pair matches', err);
-	});
-	
-	return {
-		remoteTrackIds,
-		remotePeerConnectionIds,
-		remoteClientIds
-	};
-}

package/src/processes/inboundTrackRemoved.ts

@@ -1,22 +0,0 @@
-import { StorageProvider } from '../storages/StorageProvider';
-
-export type InboundTrackRemoveProcessInput = {
-	removedTracks: {
-		trackId: string;
-		timestamp?: number;
-	}[];
-};
-
-export function createInboundTrackRemoveProcess(
-	storageProvider: StorageProvider
-): (input: InboundTrackRemoveProcessInput) => Promise<void> {
-	const process = async (input: InboundTrackRemoveProcessInput) => {
-		const { removedTracks } = input;
-		const { inboundTrackStorage } = storageProvider;
-		const inboundTrackIds = removedTracks.map((c) => c.trackId);
-
-		await inboundTrackStorage.removeAll(inboundTrackIds);
-	};
-	
-	return process;
-}

package/src/processes/joinClientProcess.ts

@@ -1,138 +0,0 @@
-import { EvaluatorContext } from '../common/types';
-import { StorageProvider } from '../storages/StorageProvider';
-import * as Models from '../models/Models';
-import { createCallStartedEventReport, createClientJoinedEventReport } from '../sinks/callEventReports';
-import { ReportsCollector } from '../common/ReportsCollector';
-import { createLogger } from '../common/logger';
-import { ObservedClientSourceConfig } from '../sources/ObservedClientSource';
-import { Writable } from '../common/utils';
-
-const logger = createLogger('ClientLeftProcess');
-
-export type JoinClientProcessInput = {
-	clients: ObservedClientSourceConfig[];
-
-	evaluatorContext?: Writable<EvaluatorContext>;
-};
-
-export function createJoinClientProcess(
-	storageProvider: StorageProvider,
-	reports: ReportsCollector
-): (input: JoinClientProcessInput) => Promise<void> {
-	const process = async (context: JoinClientProcessInput) => {
-		const { clients: joinedClients, evaluatorContext } = context;
-
-		if (joinedClients.length < 1) {
-			return;
-		}
-		const { callStorage, clientStorage } = storageProvider;
-
-		const callIds = joinedClients.map((c) => c.callId);
-		const existingCalls = await callStorage.getAll(callIds);
-		const newCalls = new Map<string, Models.Call>();
-		const newClients = new Map<string, Models.Client>();
-
-		for (const joinedClient of joinedClients) {
-			const { serviceId, mediaUnitId, roomId, callId, clientId, userId, joined: timestamp, timeZoneId, marker } = joinedClient;
-
-			let call = existingCalls.get(callId);
-
-			if (!call) {
-				call = new Models.Call({
-					serviceId,
-					roomId,
-					callId,
-					started: BigInt(timestamp),
-				});
-				newCalls.set(callId, call);
-			}
-			if (call.clientIds.find((callClientId) => callClientId === clientId)) {
-				logger.warn(`Call ${callId} for room ${roomId} attempted to add client ${clientId} twice`);
-				continue;
-			}
-			call.clientIds.push(clientId);
-
-			// we can extract the lowest timestamp here
-			// const joinedTimestamp
-			// for (const observedCall of (evaluatorContext?.observedCalls.getObservedCall(callId)?.getObservedClient(clientId)?.samples() ?? [])) {
-
-			// }
-			newClients.set(
-				clientId,
-				new Models.Client({
-					serviceId,
-					mediaUnitId,
-					roomId,
-					callId,
-					clientId,
-					joined: BigInt(timestamp),
-					timeZoneId,
-					marker,
-					userId,
-				})
-			);
-		}
-		const alreadyInsertedCalls =
-			0 < newCalls.size ? await callStorage.insertAll(newCalls) : new Map<string, Models.Call>();
-
-		for (const [ callId, newCall ] of newCalls) {
-			if (alreadyInsertedCalls.has(callId)) {
-				continue;
-			}
-			const { serviceId, roomId, started } = newCall;
-
-			if (!serviceId || !roomId || !started) {
-				continue;
-			}
-
-			const callEvent = createCallStartedEventReport(serviceId, roomId, callId, Number(started));
-
-			// if ((evaluatorContext?.observedCalls as ObservedCalls).getObservedCall(callId)) {
-			// 	reports.addCallEventReport(callEvent);
-			// }
-			reports.addCallEventReport(callEvent);
-			evaluatorContext?.startedCallIds.push(callId);
-		}
-
-		if (0 < existingCalls.size) {
-			await callStorage.setAll(existingCalls);
-		}
-
-		if (0 < newClients.size) {
-			await clientStorage.setAll(newClients);
-		}
-		for (const [ clientId, client ] of newClients) {
-			const {
-				serviceId,
-				mediaUnitId,
-				roomId,
-				callId,
-				clientId: savedClientId,
-				userId,
-				// timeZoneId,
-				marker,
-				joined,
-			} = client;
-
-			if (!serviceId || !mediaUnitId || !roomId || !callId || !savedClientId) {
-				continue;
-			}
-
-			const callEvent = createClientJoinedEventReport(
-				serviceId,
-				mediaUnitId,
-				roomId,
-				callId,
-				clientId,
-				Number(joined),
-				userId,
-				marker
-			);
-
-			reports.addCallEventReport(callEvent);
-			evaluatorContext?.joinedClientIds.push(clientId);
-		}
-	};
-	
-	return process;
-}

package/src/processes/outboundTrackRemoved.ts

@@ -1,22 +0,0 @@
-import { StorageProvider } from '../storages/StorageProvider';
-
-export type OutboundTrackRemoveProcessInput = {
-	removedTracks: {
-		trackId: string;
-		timestamp?: number;
-	}[];
-};
-
-export function createOutboundTrackRemoveProcess(
-	storageProvider: StorageProvider
-): (input: OutboundTrackRemoveProcessInput) => Promise<void> {
-	const process = async (input: OutboundTrackRemoveProcessInput) => {
-		const { removedTracks } = input;
-		const { outboundTrackStorage } = storageProvider;
-		const outboundTrackIds = removedTracks.map((c) => c.trackId);
-
-		await outboundTrackStorage.removeAll(outboundTrackIds);
-	};
-	
-	return process;
-}

package/src/samples/ObservedCall.ts

@@ -1,49 +0,0 @@
-import { ObservedClient, ObservedClientBuilder } from './ObservedClient';
-
-export interface ObservedCall {
-	readonly serviceId: string;
-	readonly roomId: string;
-	readonly callId: string;
-	readonly createCallStartedReport?: boolean;
-	observedClients(): IterableIterator<ObservedClient>;
-	getObservedClient(clientId: string): ObservedClient | undefined;
-}
-
-export class ObservedCallBuilder {
-	private _observedClientBuilders = new Map<string, ObservedClientBuilder>();
-	public constructor(private _config: Omit<ObservedCall, 'observedClients' | 'getObservedClient'>) {}
-
-	public getOrCreateObservedClientBuilder(
-		clientId: string,
-		configSupplier: () => ConstructorParameters<typeof ObservedClientBuilder>[0]
-	) {
-		let result = this._observedClientBuilders.get(clientId);
-
-		if (!result) {
-			const config = configSupplier();
-
-			result = new ObservedClientBuilder(config);
-			this._observedClientBuilders.set(clientId, result);
-		}
-		
-		return result;
-	}
-
-	public build(): ObservedCall {
-		const observedClients = new Map<string, ObservedClient>();
-
-		const observedCall: ObservedCall = {
-			...this._config,
-			observedClients: () => observedClients.values(),
-			getObservedClient: (clientId) => observedClients.get(clientId),
-		};
-		
-		for (const observedClientBuilder of this._observedClientBuilders.values()) {
-			const observedClient = observedClientBuilder.build(observedCall);
-
-			observedClients.set(observedClient.clientId, observedClient);
-		}
-		
-		return observedCall;
-	}
-}

package/src/samples/ObservedCalls.ts

@@ -1,143 +0,0 @@
-import { iteratorConverter } from '../common/utils';
-import { ObservedCall, ObservedCallBuilder } from './ObservedCall';
-
-export interface ObservedCalls {
-	callIds(): IterableIterator<string>;
-	clientIds(): IterableIterator<string>;
-	peerConnectionIds(): IterableIterator<string>;
-	inboundAudioTrackIds(): IterableIterator<string>;
-	inboundVideoTrackIds(): IterableIterator<string>;
-	outboundAudioTrackIds(): IterableIterator<string>;
-	outboundVideoTrackIds(): IterableIterator<string>;
-
-	observedCalls(): IterableIterator<ObservedCall>;
-	getObservedCall(callId: string): ObservedCall | undefined;
-}
-
-export class ObservedCallsBuilder {
-	private _builders = new Map<string, ObservedCallBuilder>();
-	public constructor() {
-		// nothing
-	}
-
-	public getOrCreateObservedCallBuilder(
-		callId: string,
-		configSupplier: () => ConstructorParameters<typeof ObservedCallBuilder>[0]
-	) {
-		let result = this._builders.get(callId);
-
-		if (!result) {
-			const config = configSupplier();
-
-			result = new ObservedCallBuilder(config);
-			this._builders.set(callId, result);
-		}
-		
-		return result;
-	}
-
-	public build(): ObservedCalls {
-		const observedCalls = new Map<string, ObservedCall>();
-
-		const callIdsGenerator = function *() {
-			for (const observedCall of observedCalls.values()) {
-				yield observedCall.callId;
-			}
-		};
-		const callIds = () => iteratorConverter<string>(callIdsGenerator());
-
-		const clientIdsGenerator = function *() {
-			for (const observedCall of observedCalls.values()) {
-				for (const observedClient of observedCall.observedClients()) {
-					yield observedClient.clientId;
-				}
-			}
-		};
-		const clientIds = () => iteratorConverter<string>(clientIdsGenerator());
-
-		const peerConnectionIdsGenerator = function *() {
-			for (const observedCall of observedCalls.values()) {
-				for (const observedClient of observedCall.observedClients()) {
-					for (const observedPeerConnection of observedClient.observedPeerConnections()) {
-						yield observedPeerConnection.peerConnectionId;
-					}
-				}
-			}
-		};
-		const peerConnectionIds = () => iteratorConverter<string>(peerConnectionIdsGenerator());
-
-		const inboundAudioTrackIdsGenerator = function *() {
-			for (const observedCall of observedCalls.values()) {
-				for (const observedClient of observedCall.observedClients()) {
-					for (const observedPeerConnection of observedClient.observedPeerConnections()) {
-						for (const inboundAudioTrack of observedPeerConnection.inboundAudioTracks()) {
-							yield inboundAudioTrack.trackId;
-						}
-					}
-				}
-			}
-		};
-		const inboundAudioTrackIds = () => iteratorConverter<string>(inboundAudioTrackIdsGenerator());
-
-		const inboundVideoTrackIdsGenerator = function *() {
-			for (const observedCall of observedCalls.values()) {
-				for (const observedClient of observedCall.observedClients()) {
-					for (const observedPeerConnection of observedClient.observedPeerConnections()) {
-						for (const inboundVideoTrack of observedPeerConnection.inboundVideoTracks()) {
-							yield inboundVideoTrack.trackId;
-						}
-					}
-				}
-			}
-		};
-		const inboundVideoTrackIds = () => iteratorConverter<string>(inboundVideoTrackIdsGenerator());
-
-		const outboundAudioTrackIdsGenerator = function *() {
-			for (const observedCall of observedCalls.values()) {
-				for (const observedClient of observedCall.observedClients()) {
-					for (const observedPeerConnection of observedClient.observedPeerConnections()) {
-						for (const outboundAudioTrack of observedPeerConnection.outboundAudioTracks()) {
-							yield outboundAudioTrack.trackId;
-						}
-					}
-				}
-			}
-		};
-		const outboundAudioTrackIds = () => iteratorConverter<string>(outboundAudioTrackIdsGenerator());
-
-		const outboundVideoTrackIdsGenerator = function *() {
-			for (const observedCall of observedCalls.values()) {
-				for (const observedClient of observedCall.observedClients()) {
-					for (const observedPeerConnection of observedClient.observedPeerConnections()) {
-						for (const outboundVideoTrack of observedPeerConnection.outboundVideoTracks()) {
-							yield outboundVideoTrack.trackId;
-						}
-					}
-				}
-			}
-		};
-		const outboundVideoTrackIds = () => iteratorConverter<string>(outboundVideoTrackIdsGenerator());
-
-		const result: ObservedCalls = {
-			callIds,
-			clientIds,
-			peerConnectionIds,
-			inboundAudioTrackIds,
-			inboundVideoTrackIds,
-			outboundAudioTrackIds,
-			outboundVideoTrackIds,
-			observedCalls: () => observedCalls.values(),
-			getObservedCall: (callId) => observedCalls.get(callId),
-		};
-
-		for (const builder of this._builders.values()) {
-			const observedCall = builder.build();
-
-			observedCalls.set(observedCall.callId, observedCall);
-		}
-		this._builders.clear();
-		
-		return result;
-	}
-
-}