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

package/src/samples/ObservedSfuOutboundRtpPad.ts

@@ -1,35 +0,0 @@
-import { SfuOutboundRtpPad } from '@observertc/sample-schemas-js';
-import { ObservedSfuTransport } from './ObservedSfuTransport';
-
-export interface ObservedSfuOutboundRtpPad {
-	readonly sfuTransport: ObservedSfuTransport;
-	readonly padId: string;
-
-	samples(): IterableIterator<SfuOutboundRtpPad>;
-}
-
-export class ObservedSfuOutboundRtpPadBuilder {
-	private _samples: SfuOutboundRtpPad[] = [];
-	public constructor(
-		private _config: Omit<
-		ObservedSfuOutboundRtpPad,
-		| keyof IterableIterator<SfuOutboundRtpPad> 
-		| 'sfuTransport' 
-		| 'samples'
-		>
-	) {}
-
-	public addSample(sfuInboundRtpPad: SfuOutboundRtpPad) {
-		this._samples.push(sfuInboundRtpPad);
-	}
-
-	public build(sfuTransport: ObservedSfuTransport): ObservedSfuOutboundRtpPad {
-		const result: ObservedSfuOutboundRtpPad = {
-			sfuTransport,
-			...this._config,
-			samples: () => this._samples.values(),
-		};
-		
-		return result;
-	}
-}

package/src/samples/ObservedSfuSctpChannel.ts

@@ -1,35 +0,0 @@
-import { SfuSctpChannel } from '@observertc/sample-schemas-js';
-import { ObservedSfuTransport } from './ObservedSfuTransport';
-
-export interface ObservedSfuSctpChannel {
-	readonly sfuTransport: ObservedSfuTransport;
-	readonly channelId: string;
-  
-	samples(): IterableIterator<SfuSctpChannel>;
-}
-  
-export class ObservedSfuSctpChannelBuilder {
-	private _samples: SfuSctpChannel[] = [];
-	public constructor(
-		private _config: Omit<
-		ObservedSfuSctpChannel,
-		| keyof IterableIterator<SfuSctpChannel>
-		| 'sfuTransport'
-		| 'samples'
-		>
-	) {}
-  
-	public addSample(sfuSctpChannel: SfuSctpChannel) {
-		this._samples.push(sfuSctpChannel);
-	}
-  
-	public build(sfuTransport: ObservedSfuTransport): ObservedSfuSctpChannel {
-		const result: ObservedSfuSctpChannel = {
-			sfuTransport,
-			...this._config,
-			samples: () => this._samples.values(),
-		};
-		
-		return result;
-	}
-}

package/src/samples/ObservedSfuTransport.ts

@@ -1,142 +0,0 @@
-import {
-	SfuInboundRtpPad,
-	SfuOutboundRtpPad,
-	SfuSctpChannel,
-	SfuTransport,
-} from '@observertc/sample-schemas-js';
-import { ObservedSfu } from './ObservedSfu';
-import { ObservedSfuInboundRtpPad, ObservedSfuInboundRtpPadBuilder } from './ObservedSfuInboundRtpPad';
-import { ObservedSfuOutboundRtpPad, ObservedSfuOutboundRtpPadBuilder } from './ObservedSfuOutboundRtpPad';
-import { ObservedSfuSctpChannel, ObservedSfuSctpChannelBuilder } from './ObservedSfuSctpChannel';
-
-export interface ObservedSfuTransport {
-	readonly sfu: ObservedSfu;
-	readonly transportId: string;
-
-	inboundRtpPads(): IterableIterator<ObservedSfuInboundRtpPad>;
-	outboundRtpPads(): IterableIterator<ObservedSfuOutboundRtpPad>;
-	sfuSctpChannels(): IterableIterator<ObservedSfuSctpChannel>;
-
-	transportSamples(): IterableIterator<SfuTransport>;
-}
-
-export class ObservedSfuTransportBuilder {
-	private _inboundRtpPads = new Map<string, ObservedSfuInboundRtpPadBuilder>();
-	private _outboundRtpPads = new Map<string, ObservedSfuOutboundRtpPadBuilder>();
-	private _sctpChannels = new Map<string, ObservedSfuSctpChannelBuilder>();
-	private _transportSamples: SfuTransport[] = [];
-	public constructor(
-		private _config: Omit<
-		ObservedSfuTransport,
-		| keyof IterableIterator<ObservedSfuTransport>
-		| 'sfu'
-		| 'inboundRtpPads'
-		| 'outboundRtpPads'
-		| 'sfuSctpChannels'
-		| 'transportSamples'
-		>
-	) {}
-
-	public addTransportSample(transportSample: SfuTransport) {
-		this._transportSamples.push(transportSample);
-	}
-
-	public addSfuInboundRtpPad(inboundRtpPad: SfuInboundRtpPad) {
-		if (inboundRtpPad.padId) {
-			const builder = this._getSfuInboundRtpPadBuilder(inboundRtpPad.padId);
-
-			builder.addSample(inboundRtpPad);
-		}
-	}
-
-	private _getSfuInboundRtpPadBuilder(padId: string): ObservedSfuInboundRtpPadBuilder {
-		let result = this._inboundRtpPads.get(padId);
-
-		if (!result) {
-			result = new ObservedSfuInboundRtpPadBuilder({
-				padId,
-			});
-			this._inboundRtpPads.set(padId, result);
-		}
-		
-		return result;
-	}
-
-	public addSfuOutboundRtpPad(outboundRtpPad: SfuOutboundRtpPad) {
-		if (outboundRtpPad.padId) {
-			const builder = this._getSfuOutboundRtpPadBuilder(outboundRtpPad.padId);
-
-			builder.addSample(outboundRtpPad);
-		}
-	}
-
-	private _getSfuOutboundRtpPadBuilder(padId: string): ObservedSfuOutboundRtpPadBuilder {
-		let result = this._outboundRtpPads.get(padId);
-
-		if (!result) {
-			result = new ObservedSfuOutboundRtpPadBuilder({
-				padId,
-			});
-			this._outboundRtpPads.set(padId, result);
-		}
-		
-		return result;
-	}
-
-	public addSfuSctpChannel(sfuSctpChannel: SfuSctpChannel) {
-		if (sfuSctpChannel.channelId) {
-			const builder = this._getSfuSctpChannel(sfuSctpChannel.channelId);
-
-			builder.addSample(sfuSctpChannel);
-		}
-	}
-
-	private _getSfuSctpChannel(channelId: string): ObservedSfuSctpChannelBuilder {
-		let result = this._sctpChannels.get(channelId);
-
-		if (!result) {
-			result = new ObservedSfuSctpChannelBuilder({
-				channelId,
-			});
-			this._sctpChannels.set(channelId, result);
-		}
-		
-		return result;
-	}
-
-	public build(sfu: ObservedSfu): ObservedSfuTransport {
-		const sfuInboundRtpPads = new Map<string, ObservedSfuInboundRtpPad>();
-		const sfuOutboundRtpPads = new Map<string, ObservedSfuOutboundRtpPad>();
-		const sfuSctpChannelsMap = new Map<string, ObservedSfuSctpChannel>();
-
-		const result: ObservedSfuTransport = {
-			sfu,
-			...this._config,
-			transportSamples: () => this._transportSamples.values(),
-
-			inboundRtpPads: () => sfuInboundRtpPads.values(),
-			outboundRtpPads: () => sfuOutboundRtpPads.values(),
-			sfuSctpChannels: () => sfuSctpChannelsMap.values(),
-		};
-
-		for (const builder of this._inboundRtpPads.values()) {
-			const observedInboundRtpPad = builder.build(result);
-
-			sfuInboundRtpPads.set(observedInboundRtpPad.padId, observedInboundRtpPad);
-		}
-
-		for (const builder of this._outboundRtpPads.values()) {
-			const observedOutboundRtpPad = builder.build(result);
-
-			sfuOutboundRtpPads.set(observedOutboundRtpPad.padId, observedOutboundRtpPad);
-		}
-
-		for (const builder of this._sctpChannels.values()) {
-			const observedSfuSctpChannel = builder.build(result);
-
-			sfuSctpChannelsMap.set(observedSfuSctpChannel.channelId, observedSfuSctpChannel);
-		}
-
-		return result;
-	}
-}

package/src/samples/ObservedSfus.ts

@@ -1,95 +0,0 @@
-import { iteratorConverter } from '../common/utils';
-import { ObservedSfu, ObservedSfuBuilder } from './ObservedSfu';
-
-export interface ObservedSfus {
-	sfuIds(): IterableIterator<string>;
-	sfuTransportIds(): IterableIterator<string>;
-	sfuInboundRtpPadIds(): IterableIterator<string>;
-	sfuOutboundRtpPadIds(): IterableIterator<string>;
-
-	observedSfus(): IterableIterator<ObservedSfu>;
-	getObservedSfu(sfuId: string): ObservedSfu | undefined;
-}
-
-export class ObservedSfusBuilder {
-	private _builders = new Map<string, ObservedSfuBuilder>();
-	public constructor() {
-		// nothing
-	}
-
-	public getOrCreateObservedSfuBuilder(
-		sfuId: string,
-		configSupplier: () => ConstructorParameters<typeof ObservedSfuBuilder>[0]
-	) {
-		let result = this._builders.get(sfuId);
-
-		if (!result) {
-			const config = configSupplier();
-
-			result = new ObservedSfuBuilder(config);
-			this._builders.set(sfuId, result);
-		}
-		
-		return result;
-	}
-
-	public build(): ObservedSfus {
-		const observedSfus = new Map<string, ObservedSfu>();
-
-		const sfuIdsGenerator = function *() {
-			for (const observedSfu of observedSfus.values()) {
-				yield observedSfu.sfuId;
-			}
-		};
-		const sfuIds = () => iteratorConverter<string>(sfuIdsGenerator());
-
-		const sfuTransportIdsGenerator = function *() {
-			for (const observedSfu of observedSfus.values()) {
-				for (const observedTransport of observedSfu.observedSfuTransports()) {
-					yield observedTransport.transportId;
-				}
-			}
-		};
-		const sfuTransportIds = () => iteratorConverter<string>(sfuTransportIdsGenerator());
-
-		const sfuInboundRtpPadIdsGenerator = function *() {
-			for (const observedSfu of observedSfus.values()) {
-				for (const observedTransport of observedSfu.observedSfuTransports()) {
-					for (const sfuInboundRtpPad of observedTransport.inboundRtpPads()) {
-						yield sfuInboundRtpPad.padId;
-					}
-				}
-			}
-		};
-		const sfuInboundRtpPadIds = () => iteratorConverter<string>(sfuInboundRtpPadIdsGenerator());
-
-		const sfuOutboundRtpPadIdsGenerator = function *() {
-			for (const observedSfu of observedSfus.values()) {
-				for (const observedTransport of observedSfu.observedSfuTransports()) {
-					for (const sfuOutboundRtpPad of observedTransport.outboundRtpPads()) {
-						yield sfuOutboundRtpPad.padId;
-					}
-				}
-			}
-		};
-		const sfuOutboundRtpPadIds = () => iteratorConverter<string>(sfuOutboundRtpPadIdsGenerator());
-
-		const result: ObservedSfus = {
-			sfuIds,
-			sfuTransportIds,
-			sfuInboundRtpPadIds,
-			sfuOutboundRtpPadIds,
-			observedSfus: () => observedSfus.values(),
-			getObservedSfu: (sfuId) => observedSfus.get(sfuId),
-		};
-
-		for (const builder of this._builders.values()) {
-			const observedSfu = builder.build();
-
-			observedSfus.set(observedSfu.sfuId, observedSfu);
-		}
-		this._builders.clear();
-		
-		return result;
-	}
-}

package/src/sources/ObservedCallSource.ts

@@ -1,26 +0,0 @@
-import { PartialBy } from '../common/utils';
-import { ObservedClientSource, ObservedClientSourceConfig } from './ObservedClientSource';
-
-export type ObservedCallSourceConfig<T extends Record<string, unknown>> = {
-	readonly appData: T
-	readonly serviceId: string;
-	readonly mediaUnitId: string;
-	readonly roomId: string;
-	readonly callId: string;
-
-	createCallStartedReport?: boolean,
-};
-
-export interface ObservedCallSource<T extends Record<string, unknown> = Record<string, unknown>> extends ObservedCallSourceConfig<T> {
-	readonly closed: boolean;
-	readonly clients: IterableIterator<ObservedClientSource>;
-
-	getClientSource<U extends Record<string, unknown>>(clientId: string): ObservedClientSource<U> | undefined;
-
-	createClientSource<U extends Record<string, unknown> = Record<string, unknown>>(
-		context: PartialBy<ObservedClientSourceConfig<U>, 'joined' | 'mediaUnitId' | 'serviceId' | 'callId' | 'roomId'>
-	): ObservedClientSource<U>;
-
-	// automatically close every
-	close(): void;
-}

package/src/sources/ObservedClientSource.ts

@@ -1,28 +0,0 @@
-import { ClientSample } from '@observertc/sample-schemas-js';
-
-export type ObservedClientSourceConfig<T extends Record<string, unknown> = Record<string, unknown>> = {
-	readonly appData: T;
-	readonly serviceId: string;
-	readonly mediaUnitId: string;
-	readonly roomId: string;
-	readonly clientId: string;
-	readonly callId: string;
-	readonly joined: number;
-
-	marker?: string;
-	userId?: string;
-	timeZoneId?: string;
-};
-
-export interface ObservedClientSource<T extends Record<string, unknown> = Record<string, unknown>> extends ObservedClientSourceConfig<T> {
-	readonly closed: boolean;
-
-	accept(...samples: ClientSample[]): void;
-
-	// when you close this, client is disposed. so this triggers the client to dispose
-	// therefore this triggers the call to be disposed
-	// peer connections, and tracks the creation is evented by the client,
-	// the close of those object is evented by the observer or closing this
-	// call the close of this is mandatory, as only this closes the client inside the observer
-	close(): void;
-}

package/src/sources/ObservedSfuSource.ts

@@ -1,19 +0,0 @@
-import { SfuSample } from '@observertc/sample-schemas-js';
-
-export type ObservedSfuSourceConfig<T extends Record<string, unknown> = Record<string, unknown>> = {
-	readonly appData: T;
-	readonly serviceId: string;
-	readonly mediaUnitId: string;
-	readonly sfuId: string;
-	readonly joined: number;
-
-	timeZoneId?: string;
-};
-
-export interface ObservedSfuSource<T extends Record<string, unknown> = Record<string, unknown>> extends ObservedSfuSourceConfig<T> {
-	readonly closed: boolean;
-
-	accept(...samples: SfuSample[]): void;
-
-	close(): void;
-}

package/src/sources/Sources.ts

@@ -1,301 +0,0 @@
-import { ClientSample, SfuSample } from '@observertc/sample-schemas-js';
-import { ObservedCalls, ObservedCallsBuilder } from '../samples/ObservedCalls';
-import { ObservedClientSource, ObservedClientSourceConfig } from './ObservedClientSource';
-import { EventEmitter } from 'events';
-import { createLogger } from '../common/logger';
-import { PartialBy } from '../common/utils';
-import { ObservedSfuSourceConfig, ObservedSfuSource } from './ObservedSfuSource';
-import { ObservedSfus, ObservedSfusBuilder } from '../samples/ObservedSfus';
-import { ObservedCallSource, ObservedCallSourceConfig } from './ObservedCallSource';
-
-const logger = createLogger('Sources');
-
-export type SourcesConfig = {
-	maxSamples: number;
-	maxTimeInMs: number;
-};
-
-export type SourcesEvents = {
-	'observed-samples': {
-		observedCalls: ObservedCalls;
-		observedSfus: ObservedSfus;
-		numberOfSamples: number;
-	};
-	'removed-client-source': ObservedClientSourceConfig;
-	'added-client-source': ObservedClientSourceConfig;
-	'removed-sfu-source': ObservedSfuSourceConfig;
-	'added-sfu-source': ObservedSfuSourceConfig;
-	'added-call-source': ObservedCallSource;
-	'removed-call-source': ObservedCallSource;
-};
-
-export class Sources {
-	
-	private readonly _warnFlags = { autoEmitButEmitSamplesInvoked: false };
-	private readonly _callSources = new Map<string, ObservedCallSource>();
-	// private readonly _clientSources = new Map<string, ObservedClientSource>();
-	private readonly _sfuSources = new Map<string, ObservedSfuSource>();
-	private readonly _emitter = new EventEmitter();
-	
-	private _observedCallsBuilder = new ObservedCallsBuilder();
-	private _observedSfusBuilder = new ObservedSfusBuilder();
-	private _timer?: ReturnType<typeof setTimeout>;
-	private _numberOfSamples = 0;
-
-	public constructor(public readonly config: SourcesConfig) {}
-
-	public getCallSource<T extends Record<string, unknown> = Record<string, unknown>>(callId: string): ObservedCallSource<T> | undefined {
-		if (!this._callSources.has(callId)) return;
-		
-		return this._callSources.get(callId) as ObservedCallSource<T>;
-	}
-
-	public getSfuSource<T extends Record<string, unknown> = Record<string, unknown>>(sfuId: string) {
-		if (!this._sfuSources.has(sfuId)) return;
-
-		return this._sfuSources.get(sfuId) as ObservedSfuSource<T>;
-	}
-
-	public on<K extends keyof SourcesEvents>(event: K, listener: (data: SourcesEvents[K]) => void): this {
-		this._emitter.addListener(event, listener);
-		
-		return this;
-	}
-
-	public off<K extends keyof SourcesEvents>(event: K, listener: (data: SourcesEvents[K]) => void): this {
-		this._emitter.removeListener(event, listener);
-		
-		return this;
-	}
-
-	private _emit<K extends keyof SourcesEvents>(event: K, data: SourcesEvents[K]): boolean {
-		return this._emitter.emit(event, data);
-	}
-
-	public createCallSource<T extends Record<string, unknown> = Record<string, unknown>>(
-		config: ObservedCallSourceConfig<T>
-	): ObservedCallSource<T> {
-		let closed = false;
-		const { 
-			serviceId,
-			mediaUnitId,
-			appData, 
-			...callConfig 
-		} = config;
-		const clientSources = new Map<string, ObservedClientSource>();
-		const callSource: ObservedCallSource<T> = {
-			...callConfig,
-			appData,
-			serviceId,
-			mediaUnitId,
-			get clients() {
-				return clientSources.values();
-			},
-
-			getClientSource: <U extends Record<string, unknown> = Record<string, unknown>>(clientId: string) => {
-				if (!clientSources.has(clientId)) return;
-				else return clientSources.get(clientId) as ObservedClientSource<U>;
-			},
-
-			createClientSource: <U extends Record<string, unknown> = Record<string, unknown>>(context: ObservedClientSourceConfig<U>) => {
-				const existingClientSource = clientSources.get(context.clientId);
-
-				if (existingClientSource) return existingClientSource as ObservedClientSource<U>;
-				
-				const { appData: clientAppData, ...clientConfig } = context;
-				const clientSource = this._createClientSource<U>(callSource, {
-					...callConfig,
-					...clientConfig,
-					appData: clientAppData,
-					serviceId,
-					mediaUnitId,
-				});
-				const closeClientSource = clientSource.close;
-
-				clientSource.close = () => {
-					closeClientSource();
-					clientSources.delete(context.clientId);
-				};
-				clientSources.set(context.clientId, clientSource);
-				
-				return clientSource as ObservedClientSource<U>;
-			},
-			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;
-	}
-
-	private _createClientSource<T extends Record<string, unknown> = Record<string, unknown>>(callSource: ObservedCallSource, config: PartialBy<ObservedClientSourceConfig<T>, 'joined'>): ObservedClientSource<T> {
-		let closed = false;
-		const {
-			appData,
-			...clientConfig
-		} = config;
-
-		const source: ObservedClientSource<T> = {
-			...clientConfig,
-			appData,
-			joined: config.joined ?? Date.now(),
-
-			accept: (...samples: ClientSample[]) => {
-				if (closed) {
-					throw new Error('Cannot accept ClientSample, because the ClientSource is closed');
-				}
-				const observedCallBuilder = this._observedCallsBuilder.getOrCreateObservedCallBuilder(callSource.callId, () => {
-					return {
-						...callSource,
-					};
-				});
-				const observedClientBuilder = observedCallBuilder.getOrCreateObservedClientBuilder(config.clientId, () => {
-					return {
-						...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;
-	}
-
-	public createSfuSource<T extends Record<string, unknown> = Record<string, unknown>>(config: PartialBy<ObservedSfuSourceConfig<T>, 'joined'>): ObservedSfuSource {
-		const existingSfuSource = this._sfuSources.get(config.sfuId);
-
-		if (existingSfuSource) {
-			return existingSfuSource;
-		}
-		let closed = false;
-		// config.joined = config.joined ?? Date.now();
-		const source: ObservedSfuSource = {
-			...config,
-			joined: config.joined ?? Date.now(),
-
-			accept: (...samples: SfuSample[]) => {
-				if (closed) {
-					throw new Error('Cannot accept SfuSample, because the SfuSource is closed');
-				}
-				const observedSfuBuilder = this._observedSfusBuilder.getOrCreateObservedSfuBuilder(config.sfuId, () => {
-					return {
-						...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;
-	}
-
-	private _incrementSamples(increment = 1) {
-		this._numberOfSamples += increment;
-		if (this.config.maxSamples < 1 || this._numberOfSamples < this.config.maxSamples) {
-			return;
-		}
-		this._emitSamples();
-	}
-
-	public 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();
-	}
-
-	private _emitSamples() {
-		this._resetTimer();
-		const observedCalls = this._observedCallsBuilder.build();
-
-		this._observedCallsBuilder = new ObservedCallsBuilder();
-		const observedSfus = this._observedSfusBuilder.build();
-
-		this._observedSfusBuilder = new ObservedSfusBuilder();
-		this._emit('observed-samples', {
-			observedCalls,
-			observedSfus,
-			numberOfSamples: this._numberOfSamples,
-		});
-		this._numberOfSamples = 0;
-	}
-
-	private _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);
-		}
-	}
-
-	public close() {
-		[ ...this._callSources.values() ].forEach((callSource) => callSource.close());
-		[ ...this._sfuSources.values() ].forEach((sfuSource) => sfuSource.close());
-		this._callSources.clear();
-		this._sfuSources.clear();		
-		this._emitSamples();
-	}
-}