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

package/src/common/utils.ts

@@ -22,4 +22,10 @@ export function asyncIteratorConverter<T>(generator: AsyncGenerator<T, void, und
 			return generator.next();
 		},
 	};
+}
+
+export function isValidUuid(str: string): boolean {
+	const regexp = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-5][0-9a-f]{3}-[089ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+
+	return regexp.test(str);
 }

package/src/index.ts

@@ -1,29 +1,13 @@
 export type { ObserverConfig, ObserverEvents } from './Observer';
 
-export type { EvaluatorConfig, EvaluatorProcess } from './Evaluator';
-
-export type { SourcesConfig } from './sources/Sources';
-
 export { Observer } from './Observer';
-export type { ObserverReportsEmitter, ObserverSinkProcess } from './sinks/ObserverSink';
 export type { ObserverStorage } from './storages/ObserverStorage';
 export type { StorageProvider } from './storages/StorageProvider';
-export * as Models from './models/Models';
 
 export * as SampleSchema from '@observertc/sample-schemas-js';
 export * as ReportSchema from '@observertc/report-schemas-js';
 
-export type { CallEntry } from './entries/CallEntry';
-export type { ClientEntry } from './entries/ClientEntry';
-export type { PeerConnectionEntry } from './entries/PeerConnectionEntry';
-export type { InboundTrackEntry } from './entries/InboundTrackEntry';
-export type { OutboundTrackEntry } from './entries/OutboundTrackEntry';
-export type { SfuEntry } from './entries/SfuEntry';
-export type { SfuTransportEntry } from './entries/SfuTransportEntry';
-export type { SfuInboundRtpPadEntry } from './entries/SfuInboundRtpPadEntry';
-export type { SfuOutboundRtpPadEntry } from './entries/SfuOutboundRtpPadEntry';
-export type { SfuSctpChannelEntry } from './entries/SfuSctpChannelEntry';
-export type { GetClientCoordinate, ClientCoordinate } from './evaluators/SetClientsCoordinateEvaluator';
+export type { LogLevel, Logger } from './common/logger';
 
 export type {
 	Samples,
@@ -70,15 +54,20 @@ export type {
 	SFUTransportReport,
 } from '@observertc/report-schemas-js';
 
-export type { ObservedClientSource, ObservedClientSourceConfig } from './sources/ObservedClientSource';
-
-export type { ObservedSfuSource, ObservedSfuSourceConfig } from './sources/ObservedSfuSource';
+export type { ObservedClient, ObservedClientConfig } from './ObservedClient';
+export type { ObservedPeerConnection, ObservedPeerConnectionConfig, ObservedPeerConnectionEvents } from './ObservedPeerConnection';
+export type { ObservedInboundTrack, ObservedInboundTrackConfig, ObservedInboundTrackEvents } from './ObservedInboundTrack';
+export type { ObservedOutboundTrack, ObservedOutboundTrackConfig, ObservedOutboundTrackEvents } from './ObservedOutboundTrack';
 
-export type { ObservedCallSource, ObservedCallSourceConfig as ObservedCallConfig } from './sources/ObservedCallSource';
-
-export type { EvaluatorContext, EvaluatorMiddleware, ObserverSinkContext, ObserverSinkMiddleware } from './common/types';
+export type { EvaluatorContext, ObserverSinkContext } from './common/types';
 
 import { Observer, ObserverConfig } from './Observer';
 export function createObserver(config?: Partial<ObserverConfig>) {
 	return Observer.create(config ?? {});
 }
+
+import { LogLevel, Logger, forwardLogsTo, setLogLevel } from './common/logger';
+export function setupLogs(logLevel: LogLevel, logger: Logger) {
+	setLogLevel(logLevel);
+	forwardLogsTo(logger);
+}

package/lib/Evaluator.d.ts

@@ -1,43 +0,0 @@
-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';
-export type EvaluatorEvents = {
-    ready: Error | undefined;
-};
-export type EvaluatorConfig = {
-    fetchSamples: boolean;
-    maxIdleTimeInMs?: number;
-    findRemoteMatches?: boolean;
-};
-export type EvaluatorProcess = (evaluatorContext: EvaluatorContext) => Promise<void>;
-export declare class Evaluator {
-    readonly config: EvaluatorConfig;
-    private readonly _callSemaphore;
-    private readonly _storageProvider;
-    private readonly _reportsCollector;
-    private _index;
-    private _evaluations;
-    private _clientOperations;
-    private _emitter;
-    private _evaluatorProcesses;
-    private _callProcessor;
-    private _transactionProcessor;
-    private _customProcessor;
-    constructor(config: EvaluatorConfig, _callSemaphore: Semaphore, _storageProvider: StorageProvider, _reportsCollector: ReportsCollector);
-    addProcess(process: EvaluatorProcess): void;
-    removeProcess(process: EvaluatorProcess): void;
-    addClosedClientSource(clientSource: ObservedClientSourceConfig): void;
-    addCreatedClientSource(clientSource: ObservedClientSourceConfig): void;
-    on<K extends keyof EvaluatorEvents>(event: K, listener: (data: EvaluatorEvents[K]) => void): this;
-    once<K extends keyof EvaluatorEvents>(event: K, listener: (data: EvaluatorEvents[K]) => void): this;
-    off<K extends keyof EvaluatorEvents>(event: K, listener: (data: EvaluatorEvents[K]) => void): this;
-    private _emit;
-    addObservedSamples(samples: SourcesEvents['observed-samples']): void;
-    private _eval;
-    get ongoingProcess(): number;
-    private _process;
-}
-//# sourceMappingURL=Evaluator.d.ts.map

package/lib/Evaluator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Evaluator.d.ts","sourceRoot":"","sources":["../src/Evaluator.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAC7D,OAAO,EAAE,0BAA0B,EAAE,MAAM,gCAAgC,CAAC;AAC5E,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAW7D,MAAM,MAAM,eAAe,GAAG;IAC7B,KAAK,EAAE,KAAK,GAAG,SAAS,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC7B,YAAY,EAAE,OAAO,CAAC;IACtB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,gBAAgB,EAAE,gBAAgB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAErF,qBAAa,SAAS;aAaJ,MAAM,EAAE,eAAe;IACvC,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IACjC,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAfnC,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,YAAY,CAAoC;IAExD,OAAO,CAAC,iBAAiB,CAAoC;IAC7D,OAAO,CAAC,QAAQ,CAAsB;IAEtC,OAAO,CAAC,mBAAmB,CAA6D;IACxF,OAAO,CAAC,cAAc,CAAmC;IACzD,OAAO,CAAC,qBAAqB,CAAgC;IAC7D,OAAO,CAAC,gBAAgB,CAA8B;gBAGrC,MAAM,EAAE,eAAe,EACtB,cAAc,EAAE,SAAS,EACzB,gBAAgB,EAAE,eAAe,EACjC,iBAAiB,EAAE,gBAAgB;IAe9C,UAAU,CAAC,OAAO,EAAE,gBAAgB;IAUpC,aAAa,CAAC,OAAO,EAAE,gBAAgB;IAUvC,qBAAqB,CAAC,YAAY,EAAE,0BAA0B;IAQ9D,sBAAsB,CAAC,YAAY,EAAE,0BAA0B;IAO/D,EAAE,CAAC,CAAC,SAAS,MAAM,eAAe,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,eAAe,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,IAAI;IAMjG,IAAI,CAAC,CAAC,SAAS,MAAM,eAAe,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,eAAe,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,IAAI;IAMnG,GAAG,CAAC,CAAC,SAAS,MAAM,eAAe,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,eAAe,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,IAAI;IAMzG,OAAO,CAAC,KAAK;IAIN,kBAAkB,CAAC,OAAO,EAAE,aAAa,CAAC,kBAAkB,CAAC,GAAG,IAAI;YAqD7D,KAAK;IAyBnB,IAAW,cAAc,IAAI,MAAM,CAElC;YAEa,QAAQ;CA6BtB"}

package/lib/Evaluator.js

@@ -1,171 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Evaluator = void 0;
-const logger_1 = require("./common/logger");
-const Processor_1 = require("./middlewares/Processor");
-const TransactionContext_1 = require("./middlewares/TransactionContext");
-const CallOperationsContext_1 = require("./middlewares/CallOperationsContext");
-const CallProcessor_1 = require("./middlewares/CallProcessor");
-const TransactoinProcessor_1 = require("./middlewares/TransactoinProcessor");
-const events_1 = require("events");
-const logger = (0, logger_1.createLogger)('Evaluator');
-class Evaluator {
-    constructor(config, _callSemaphore, _storageProvider, _reportsCollector) {
-        var _a;
-        this.config = config;
-        this._callSemaphore = _callSemaphore;
-        this._storageProvider = _storageProvider;
-        this._reportsCollector = _reportsCollector;
-        this._index = 0;
-        this._evaluations = new Map();
-        this._clientOperations = new Map();
-        this._emitter = new events_1.EventEmitter();
-        this._evaluatorProcesses = new Map();
-        this._callProcessor = (0, CallProcessor_1.createCallProcessor)(_storageProvider, _reportsCollector);
-        this._transactionProcessor = (0, TransactoinProcessor_1.createTransactionProcessor)(_storageProvider, _reportsCollector, this.config.fetchSamples, BigInt((_a = this.config.maxIdleTimeInMs) !== null && _a !== void 0 ? _a : 10000), this.config.findRemoteMatches);
-        this._customProcessor = (0, Processor_1.createProcessor)();
-    }
-    addProcess(process) {
-        const middleware = (context, next) => __awaiter(this, void 0, void 0, function* () {
-            yield process(context);
-            if (next)
-                yield next(context);
-        });
-        this._evaluatorProcesses.set(process, middleware);
-        this._customProcessor.addMiddleware(middleware);
-    }
-    removeProcess(process) {
-        const middleware = this._evaluatorProcesses.get(process);
-        if (!middleware) {
-            return;
-        }
-        this._evaluatorProcesses.delete(process);
-        this._customProcessor.removeMiddleware(middleware);
-    }
-    addClosedClientSource(clientSource) {
-        this._clientOperations.set(clientSource.clientId, Object.assign(Object.assign({ type: 'detach' }, clientSource), { detached: Date.now() }));
-    }
-    addCreatedClientSource(clientSource) {
-        this._clientOperations.set(clientSource.clientId, Object.assign({ type: 'join' }, clientSource));
-    }
-    on(event, listener) {
-        this._emitter.addListener(event, listener);
-        return this;
-    }
-    once(event, listener) {
-        this._emitter.once(event, listener);
-        return this;
-    }
-    off(event, listener) {
-        this._emitter.removeListener(event, listener);
-        return this;
-    }
-    _emit(event, data) {
-        return this._emitter.emit(event, data);
-    }
-    addObservedSamples(samples) {
-        // this triggers the evaluation
-        const { observedCalls, observedSfus } = samples;
-        const 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 = (0, CallOperationsContext_1.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);
-        });
-    }
-    _eval(callOperationsContext, evaluatorContext) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const actualBlockingPoint = (_a = this._evaluations.get(this._index)) !== null && _a !== void 0 ? _a : Promise.resolve();
-            const index = ++this._index;
-            const result = new Promise((resolve, reject) => {
-                actualBlockingPoint.then(() => {
-                    this._process(callOperationsContext, evaluatorContext)
-                        .then(() => resolve())
-                        .catch((err) => reject(err));
-                });
-            });
-            const nextBlockingPoint = new Promise((resolve) => {
-                result.then(() => {
-                    this._evaluations.delete(index);
-                    resolve();
-                }).catch(() => {
-                    this._evaluations.delete(index);
-                    resolve();
-                });
-            });
-            this._evaluations.set(index, nextBlockingPoint);
-            return result;
-        });
-    }
-    get ongoingProcess() {
-        return this._evaluations.size;
-    }
-    _process(callOperationsContext, evaluatorContext) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const process = () => __awaiter(this, void 0, void 0, function* () {
-                yield this._callSemaphore.acquire();
-                yield this._callProcessor.use(callOperationsContext).finally(() => {
-                    this._callSemaphore.release();
-                });
-                const transactionContext = yield (0, TransactionContext_1.createTransactionContext)(evaluatorContext, this._storageProvider, evaluatorContext.observedCalls, evaluatorContext.observedSfus);
-                yield this._transactionProcessor.use(transactionContext);
-                yield this._customProcessor.use(evaluatorContext);
-            });
-            yield process().then(() => {
-                this._emit('ready', undefined);
-            })
-                .catch((err) => {
-                logger.warn('Error occurred while evaluating samples', err);
-                this._emit('ready', err);
-            });
-        });
-    }
-}
-exports.Evaluator = Evaluator;

package/lib/common/Semaphore.d.ts

@@ -1,31 +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 declare function createDummySemaphore(): Semaphore;
-/**
- * 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 declare function createSimpleSemaphoreProvider(): SemaphoreProvider;
-//# sourceMappingURL=Semaphore.d.ts.map

package/lib/common/Semaphore.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Semaphore.d.ts","sourceRoot":"","sources":["../../src/common/Semaphore.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,SAAS;IAEzB;;;;OAIG;IACH,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEzB;;;OAGG;IACH,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB;AAED,wBAAgB,oBAAoB,IAAI,SAAS,CAKhD;AAED;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAEjC;;;OAGG;IACH,QAAQ,CAAC,aAAa,EAAE,SAAS,CAAC;CAClC;AAED,wBAAgB,6BAA6B,IAAI,iBAAiB,CAIjE"}

package/lib/common/Semaphore.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSimpleSemaphoreProvider = exports.createDummySemaphore = void 0;
-function createDummySemaphore() {
-    return {
-        acquire: () => Promise.resolve(),
-        release: () => Promise.resolve(),
-    };
-}
-exports.createDummySemaphore = createDummySemaphore;
-function createSimpleSemaphoreProvider() {
-    return {
-        callSemaphore: createDummySemaphore(),
-    };
-}
-exports.createSimpleSemaphoreProvider = createSimpleSemaphoreProvider;