@observertc/observer-js 1.0.1-c3edea3.0 → 1.0.1-ec27289.0

package/src/Observer.ts

@@ -1,21 +1,33 @@
 import { createLogger } from './common/logger';
-import { Middleware, MiddlewareProcessor } from './common/Middleware';
 import { ObservedCall, ObservedCallSettings } from './ObservedCall';
 import { EventEmitter } from 'events';
-import { ClientEvent, ClientMetaData, ClientIssue, ExtensionStat } from './schema/ClientSample';
+import { ClientEvent, ClientMetaData, ClientIssue, ExtensionStat, ClientSample } from './schema/ClientSample';
 import { ObservedClient } from './ObservedClient';
+import { ObservedTURN } from './ObservedTURN';
+import { Detectors } from './detectors/Detectors';
+import { Updater } from './updaters/Updater';
+import { OnIntervalUpdater } from './updaters/OnIntervalUpdater';
+import { OnAllCallObserverUpdater } from './updaters/OnAllCallObserverUpdater_';
+import { OnAnyCallObserverUpdater } from './updaters/OnAnyCallObserverUpdater_';
 
 const logger = createLogger('Observer');
 
 export type ObserverEvents = {
+	'client-event': [ObservedClient, ClientEvent];
+	'call-updated': [ObservedCall],
+	'client-issue': [ObservedClient, ClientIssue],
+	'client-metadata': [ObservedClient, ClientMetaData],
+	'client-extension-stats': [ObservedClient, ExtensionStat],
 	'newcall': [ObservedCall],
+	'update': [],
 	'close': [],
 }
 
-export type ProcessorInputContext<T> = {
-	call: ObservedCall;
-	client: ObservedClient;
-	data: T;
+export type ObserverConfig = {
+	updatePolicy?: 'update-on-any-call-updated' | 'update-when-all-call-updated' | 'update-on-interval',
+	updateIntervalInMs?: number,
+	defaultCallUpdatePolicy?: ObservedCallSettings['updatePolicy'],
+	defaultCallUpdateIntervalInMs?: number,
 }
 
 export declare interface Observer {
@@ -26,20 +38,74 @@ export declare interface Observer {
 }
 
 export class Observer extends EventEmitter {
-	public readonly processors = {
-		events: new MiddlewareProcessor<ProcessorInputContext<ClientEvent>>(),
-		metaData: new MiddlewareProcessor<ProcessorInputContext<ClientMetaData>>(),
-		issues: new MiddlewareProcessor<ProcessorInputContext<ClientIssue>>(),
-		extensionStats: new MiddlewareProcessor<ProcessorInputContext<ExtensionStat>>(),
-	};
+	public readonly detectors: Detectors;
 
+	public readonly observedTURN = new ObservedTURN();
 	public readonly observedCalls = new Map<string, ObservedCall>();
+	public updater?: Updater;
+	
 	public closed = false;
 
-	public constructor(
-	) {
+	public totalAddedCall = 0;
+	public totalRemovedCall = 0;
+	public totalRttLt50Measurements = 0;
+	public totalRttLt150Measurements = 0;
+	public totalRttLt300Measurements = 0;
+	public totalRttGtOrEq300Measurements = 0;
+	public totalClientIssues = 0;
+
+	public numberOfClientsUsingTurn = 0;
+	public numberOfClients = 0;
+	public numberOfInboundRtpStreams = 0;
+	public numberOfOutboundRtpStreams = 0;
+	public numberOfDataChannels = 0;
+	public numberOfPeerConnections = 0;
+	
+	public get numberOfCalls() {
+		return this.observedCalls.size;
+	}
+
+	private _timer?: ReturnType<typeof setInterval>;
+
+	public constructor(public readonly config: ObserverConfig = {
+		updatePolicy: 'update-when-all-call-updated',
+		updateIntervalInMs: undefined,
+	}) {
 		super();
 		this.setMaxListeners(Infinity);
+		this.update = this.update.bind(this);
+
+		if (this.config.updateIntervalInMs) {
+			if (this.config.updatePolicy && this.config.updatePolicy !== 'update-on-interval') {
+				throw new Error('update policy must be update-on-interval if updateIntervalInMs is set in config');
+			}
+			this._timer = setInterval(this.update.bind(this), this.config.updateIntervalInMs);
+		}
+
+		if (this.config.updateIntervalInMs) {
+			if (this.config.updatePolicy !== 'update-on-interval') {
+				throw new Error('updatePolicy must be update-on-interval if updateIntervalInMs is set in config');
+			}
+		}
+		switch (this.config.updatePolicy) {
+			case 'update-on-any-call-updated':
+				this.updater = new OnAllCallObserverUpdater(this);	
+				break;
+			case 'update-when-all-call-updated':
+				this.updater = new OnAnyCallObserverUpdater(this);	
+				break;
+			case 'update-on-interval': 
+				if (!this.config.updateIntervalInMs) {
+					throw new Error('updateIntervalInMs setting in config must be set if updatePolicy is update-on-interval');
+				}
+				this.updater = new OnIntervalUpdater(
+					this.config.updateIntervalInMs,
+					this.update.bind(this),
+				);
+				break;
+		}
+		
+		this.detectors = new Detectors();
 	}
 
 	public getObservedCall<T extends Record<string, unknown> = Record<string, unknown>>(callId: string): ObservedCall<T> | undefined {
@@ -54,86 +120,120 @@ export class Observer extends EventEmitter {
 		if (this.closed) {
 			throw new Error('Attempted to create a call source on a closed observer');
 		}
+		if (!settings.updatePolicy) {
+			settings.updatePolicy = this.config.defaultCallUpdatePolicy;
+			settings.updateIntervalInMs = this.config.defaultCallUpdateIntervalInMs;
+		}
 
 		const observedCall = new ObservedCall(settings, this);
+		const onCallUpdated = () => this._onObservedCallUpdated(observedCall);
 
 		if (this.observedCalls.has(observedCall.callId)) throw new Error(`Observed Call with id ${observedCall.callId} already exists`);
 
 		observedCall.once('close', () => {
 			this.observedCalls.delete(observedCall.callId);
+			observedCall.off('update', onCallUpdated);
+			++this.totalRemovedCall;
 		});
 
 		this.observedCalls.set(observedCall.callId, observedCall);
+		observedCall.on('update', onCallUpdated);
+		++this.totalAddedCall;
 
 		this.emit('newcall', observedCall);
 		
 		return observedCall;
 	}
 
-	public addClientEventMiddleware(...middlewares: Middleware<ProcessorInputContext<ClientEvent>>[]): Observer {
-
-		this.processors.events.addMiddleware(...middlewares);
-
-		return this;
-	}
-
-	public removeClientEventMiddleware(...middlewares: Middleware<ProcessorInputContext<ClientEvent>>[]): Observer {
-
-		this.processors.events.removeMiddleware(...middlewares);
-
-		return this;
-	}
-
-	public addClientMetaDataMiddleware(...middlewares: Middleware<ProcessorInputContext<ClientMetaData>>[]): Observer {
-
-		this.processors.metaData.addMiddleware(...middlewares);
+	public close() {
+		if (this.closed) {
+			return logger.debug('Attempted to close twice');
+		}
+		this.closed = true;
+		clearInterval(this._timer);
+		this._timer = undefined;
 
-		return this;
+		this.observedCalls.forEach((call) => call.close());
+		
+		this.emit('close');
 	}
 
-	public removeClientMetaDataMiddleware(...middlewares: Middleware<ProcessorInputContext<ClientMetaData>>[]): Observer {
-
-		this.processors.metaData.removeMiddleware(...middlewares);
+	public accept(sample: ClientSample) {
+		if (this.closed) return;
+		if (!sample.callId) return logger.warn('Received sample without callId. %o', sample);
+		if (!sample.clientId) return logger.warn('Received sample without clientId %o', sample);
 
-		return this;
-	}
-
-	public addClientIssueMiddleware(...middlewares: Middleware<ProcessorInputContext<ClientIssue>>[]): Observer {
+		const call = this.getObservedCall(sample.callId) ?? this.createObservedCall({
+			callId: sample.callId,
+			updateIntervalInMs: this.config.defaultCallUpdateIntervalInMs,
+			updatePolicy: this.config.defaultCallUpdatePolicy,
+		});
 
-		this.processors.issues.addMiddleware(...middlewares);
+		const client = call.getObservedClient(sample.clientId) ?? call.createObservedClient({
+			clientId: sample.clientId,
+		});
 
-		return this;
+		client.accept(sample);
 	}
 
-	public removeClientIssueMiddleware(...middlewares: Middleware<ProcessorInputContext<ClientIssue>>[]): Observer {
-
-		this.processors.issues.removeMiddleware(...middlewares);
-
-		return this;
-	}
+	public update() {
+		if (this.closed) {
+			return;
+		}
 
-	public addExtensionStatMiddleware(...middlewares: Middleware<ProcessorInputContext<ExtensionStat>>[]): Observer {
+		this.numberOfInboundRtpStreams = 0;
+		this.numberOfOutboundRtpStreams = 0;
+		this.numberOfPeerConnections = 0;
+		this.numberOfDataChannels = 0;
+		this.numberOfClients = 0;
+		this.numberOfClientsUsingTurn = 0;
+
+		for (const call of this.observedCalls.values()) {
+			this.numberOfInboundRtpStreams += call.numberOfInboundRtpStreams;
+			this.numberOfOutboundRtpStreams += call.numberOfOutboundRtpStreams;
+			this.numberOfPeerConnections += call.numberOfPeerConnections;
+			this.numberOfDataChannels += call.numberOfDataChannels;
+			this.numberOfClients += call.numberOfClients;
+			this.numberOfClientsUsingTurn += call.clientsUsedTurn.size;
+		}
 
-		this.processors.extensionStats.addMiddleware(...middlewares);
+		this.observedTURN.update();
 
-		return this;
+		this.emit('update');
 	}
 
-	public removeExtensionStatMiddleware(...middlewares: Middleware<ProcessorInputContext<ExtensionStat>>[]): Observer {
-
-		this.processors.extensionStats.removeMiddleware(...middlewares);
-
-		return this;
+	private _onObservedCallUpdated(call: ObservedCall) {
+		this.totalRttLt50Measurements += call.deltaRttLt50Measurements;
+		this.totalRttLt150Measurements += call.deltaRttLt150Measurements;
+		this.totalRttLt300Measurements += call.deltaRttLt300Measurements;
+		this.totalRttGtOrEq300Measurements += call.deltaRttGtOrEq300Measurements;
+		this.totalClientIssues += call.deltaNumberOfIssues;
 	}
 
-	public close() {
-		if (this.closed) {
-			return logger.debug('Attempted to close twice');
-		}
-		this.closed = true;
+	// public resetSummaryMetrics() {
+	// 	this.totalAddedCall = 0;
+	// 	this.totalRemovedCall = 0;
+	// 	this.totalRttLt50Measurements = 0;
+	// 	this.totalRttLt150Measurements = 0;
+	// 	this.totalRttLt300Measurements = 0;
+	// 	this.totalRttGtOrEq300Measurements = 0;
+	// 	this.totalClientIssues = 0;
+	// }
+
+	// public createSummary(): ObserverSummary {
+	// 	return {
+	// 		totalAddedCall: this.totalAddedCall,
+	// 		totalRemovedCall: this.totalRemovedCall,
+	// 		totalRttLt50Measurements: this.totalRttLt50Measurements,
+	// 		totalRttLt150Measurements: this.totalRttLt150Measurements,
+	// 		totalRttLt300Measurements: this.totalRttLt300Measurements,
+	// 		totalRttGtOrEq300Measurements: this.totalRttGtOrEq300Measurements,
+
+	// 		totalClientIssues: this.totalClientIssues,
+	// 		currentActiveCalls: this.observedCalls.size,
+	// 		currentNumberOfClients: this.numberOfClients,
+	// 		currentNumberOfClientsUsingTURN: this.numberOfClientsUsedTurn,
+	// 	};
+	// }
 
-		this.observedCalls.forEach((call) => call.close());
-		
-		this.emit('close');
-	}
 }

package/src/ObserverSummary.ts

@@ -0,0 +1,15 @@
+export type ObserverSummary = {
+	currentActiveCalls: number;
+	currentNumberOfClientsUsingTURN: number;
+	currentNumberOfClients: number;	
+
+	totalAddedCall: number;
+	totalRemovedCall: number;
+
+	totalRttLt50Measurements: number,
+	totalRttLt150Measurements: number,
+	totalRttLt300Measurements: number,
+	totalRttGtOrEq300Measurements: number,
+
+	totalClientIssues: number,
+}

package/src/common/utils.ts

@@ -30,9 +30,19 @@ export function isValidUuid(str: string): boolean {
 	return regexp.test(str);
 }
 
-export function getMedian(arr: number[]): number {
+export function getAverage(arr: number[], defaultAvgIfArrLengthIs0 = 0): number {
+	if (arr.length === 0) return defaultAvgIfArrLengthIs0;
+	
+	return arr.reduce((a, b) => a + b, 0) / arr.length;
+}
+
+export function getMedian(arr: number[], copyArrayForSorting = true): number {
 	// Sort the array in ascending order
-	const sortedArr = arr.slice().sort((a, b) => a - b);
+	const sortedArr = copyArrayForSorting 
+		? arr.slice().sort((a, b) => a - b)
+		: arr.sort((a, b) => a-b)
+
+	;
 
 	// Calculate the middle index
 	const mid = Math.floor(sortedArr.length / 2);

package/src/index.ts

@@ -19,5 +19,10 @@ export { ObservedIceCandidatePair } from './ObservedIceCandidatePair';
 export { ObservedIceCandidate } from './ObservedIceCandidate';
 export { ObservedIceTransport } from './ObservedIceTransport';
 export { ObservedPeerConnectionTransport } from './ObservedPeerConnectionTransport';
+export { ClientEventTypes } from './schema/ClientEventTypes';
+export { ClientMetaTypes } from './schema/ClientMetaTypes';
+export { ClientSample } from './schema/ClientSample';
+export { ScoreCalculator } from './scores/ScoreCalculator';
+export { ObservedClientEventMonitor } from './ObservedClientEventMonitor';
 
 export { Middleware } from './common/Middleware';

package/src/schema/ClientEventTypes.ts

@@ -0,0 +1,112 @@
+/* eslint-disable no-shadow */
+
+export enum ClientEventTypes {
+	CLIENT_JOINED = 'CLIENT_JOINED',
+	CLIENT_LEFT = 'CLIENT_LEFT',
+	PEER_CONNECTION_OPENED = 'PEER_CONNECTION_OPENED',
+	PEER_CONNECTION_CLOSED = 'PEER_CONNECTION_CLOSED',
+	MEDIA_TRACK_ADDED = 'MEDIA_TRACK_ADDED',
+	MEDIA_TRACK_REMOVED = 'MEDIA_TRACK_REMOVED',
+	MEDIA_TRACK_RESUMED = 'MEDIA_TRACK_RESUMED',
+	MEDIA_TRACK_MUTED = 'MEDIA_TRACK_MUTED',
+	MEDIA_TRACK_UNMUTED = 'MEDIA_TRACK_UNMUTED',
+	ICE_GATHERING_STATE_CHANGED = 'ICE_GATHERING_STATE_CHANGED',
+	PEER_CONNECTION_STATE_CHANGED = 'PEER_CONNECTION_STATE_CHANGED',
+	ICE_CONNECTION_STATE_CHANGED = 'ICE_CONNECTION_STATE_CHANGED',
+	DATA_CHANNEL_OPEN = 'DATA_CHANNEL_OPEN',
+	DATA_CHANNEL_CLOSED = 'DATA_CHANNEL_CLOSED',
+	DATA_CHANNEL_ERROR = 'DATA_CHANNEL_ERROR',
+	NEGOTIATION_NEEDED = 'NEGOTIATION_NEEDED',
+	SIGNALING_STATE_CHANGE = 'SIGNALING_STATE_CHANGE',
+	ICE_GATHERING_STATE_CHANGE = 'ICE_GATHERING_STATE_CHANGE',
+	ICE_CONNECTION_STATE_CHANGE = 'ICE_CONNECTION_STATE_CHANGE',
+	ICE_CANDIDATE = 'ICE_CANDIDATE',
+	
+	// mediasoup events
+	PRODUCER_ADDED = 'PRODUCER_ADDED',
+	PRODUCER_REMOVED = 'PRODUCER_REMOVED',
+	PRODUCER_PAUSED = 'PRODUCER_PAUSED',
+	PRODUCER_RESUMED = 'PRODUCER_RESUMED',
+	CONSUMER_ADDED = 'CONSUMER_ADDED',
+	CONSUMER_REMOVED = 'CONSUMER_REMOVED',
+	DATA_PRODUCER_CREATED = 'DATA_PRODUCER_CREATED',
+	DATA_PRODUCER_CLOSED = 'DATA_PRODUCER_CLOSED',
+	DATA_CONSUMER_CREATED = 'DATA_CONSUMER_CREATED',
+	DATA_CONSUMER_CLOSED = 'DATA_CONSUMER_CLOSED',
+}
+
+export interface PeerConnectionOpenedEventPayload extends Record<string, unknown> {
+	peerConnectionId: string;
+	iceConnectionState: string;
+	iceGatheringState: string;
+	signalingState: string;
+}
+
+export interface PeerConnectionClosedEventPayload extends Record<string, unknown> {
+	peerConnectionId: string;
+	iceConnectionState: string;
+	iceGatheringState: string;
+	signalingState: string;
+}
+
+export interface MediaTrackMutedEventPayload extends Record<string, unknown> {
+	trackId: string;
+	kind: 'audio' | 'video';
+	label?: string;
+	muted: boolean;
+	enabled: boolean;
+	readyState: string;
+	contentHint?: string;
+}
+
+export interface MediaTrackUnmutedEventPayload extends Record<string, unknown> {
+	trackId: string;
+	kind: 'audio' | 'video';
+	label?: string;
+	muted: boolean;
+	enabled: boolean;
+	readyState: string;
+	contentHint?: string;
+}
+
+export interface MediaTrackAddedEventPayload extends Record<string, unknown> {
+	trackId: string;
+	kind: 'audio' | 'video';
+	label?: string;
+	muted: boolean;
+	enabled: boolean;
+	readyState: string;
+	contentHint?: string;
+	constraints: MediaTrackConstraints,
+	capabilities: MediaTrackCapabilities,
+	settings: MediaTrackSettings,
+}
+
+export interface MediaTrackRemovedEventPayload extends Record<string, unknown> {
+	trackId: string;
+	kind: 'audio' | 'video';
+	label?: string;
+	muted: boolean;
+	enabled: boolean;
+	readyState: string;
+	contentHint?: string;
+}
+
+export interface DataChannelErrorEventPayload extends Record<string, unknown> {
+	label: string;
+	readyState: string;
+	dataChannelId: string,
+	error: string,
+}
+
+export interface DataChannelOpenEventPayload extends Record<string, unknown> {
+	label: string;
+	readyState: string;
+	dataChannelId: string,
+}
+
+export interface DataChannelClosedEventPayload extends Record<string, unknown> {
+	label: string;
+	readyState: string;
+	dataChannelId: string,
+}

package/src/schema/{metaTypes.ts → ClientMetaTypes.ts}

@@ -1,6 +1,6 @@
 /* eslint-disable no-shadow */
 
-export enum ClientMetaType {
+export enum ClientMetaTypes {
 	MEDIA_CONSTRAINT = 'MEDIA_CONSTRAINT',
 	MEDIA_DEVICE = 'MEDIA_DEVICE',
 	MEDIA_DEVICES_SUPPORTED_CONSTRAINTS = 'MEDIA_DEVICES_SUPPORTED_CONSTRAINTS',

package/src/updaters/ObserverUpdater.ts

@@ -0,0 +1,5 @@
+import { ObservedCall } from '../ObservedCall';
+
+export interface ObserverUpdater {
+	onCallUpdate(observedCall: ObservedCall): void;
+}

package/src/updaters/OnAllCallObserverUpdater_.ts

@@ -0,0 +1,46 @@
+import { ObservedCall } from '../ObservedCall';
+import { Observer } from '../Observer';
+import { Updater } from './Updater';
+
+export class OnAllCallObserverUpdater implements Updater {
+	public readonly name = 'OnAllCallObserverUpdater';
+	public readonly description = 'Call Observer\'s update() method when all of the ObservedCalls are updated';
+	
+	private readonly _updatedCalls = new Set<string>();
+
+	public constructor(
+		private observer: Observer
+	) {
+		this._onNewObservedCall = this._onNewObservedCall.bind(this);
+
+		this.observer.once('close', () => {
+			this.observer.off('newcall', this._onNewObservedCall);
+		});
+		this.observer.on('newcall', this._onNewObservedCall);
+	}
+
+	close(): void {
+		// do nothing, because we unsubscribe once close is emitted from observer
+	}
+
+	private _onNewObservedCall(observedCall: ObservedCall) {
+		const onUpdate = () => this._onObservedCallUpdated(observedCall);
+
+		observedCall.once('close', () => {
+			observedCall.off('update', onUpdate);
+			this._updatedCalls.delete(observedCall.callId);
+		});
+		observedCall.on('update', onUpdate);
+	}
+
+	private _onObservedCallUpdated(observedCall: ObservedCall) {
+		if (observedCall.closed) return;
+
+		this._updatedCalls.add(observedCall.callId);
+
+		if (this._updatedCalls.size < this.observer.observedCalls.size) return;
+
+		this._updatedCalls.clear();
+		this.observer.update();
+	}
+}

package/src/updaters/OnAllClientCallUpdater.ts

@@ -0,0 +1,46 @@
+import { ObservedCall } from '../ObservedCall';
+import { ObservedClient } from '../ObservedClient';
+import { Updater } from './Updater';
+ 
+export class OnAllClientCallUpdater implements Updater {
+	readonly name = 'OnAllClientCallUpdater';
+	readonly description = 'Call the update() method of the ObservedCall once all client has been updated';
+
+	private readonly _updatedClients = new Set<string>();
+
+	public constructor(
+		private _observedCall: ObservedCall
+	) {
+		this._onNewObservedClient = this._onNewObservedClient.bind(this);
+
+		this._observedCall.once('close', () => {
+			this._observedCall.off('newclient', this._onNewObservedClient);
+		});
+		this._observedCall.on('newclient', this._onNewObservedClient);
+	}
+	
+	public close(): void {
+		// do nothing, as close once emitted unsubscription happened
+	}
+
+	private _onNewObservedClient(observedClient: ObservedClient) {
+		const onUpdate = () => this._onClientUpdate(observedClient);
+
+		observedClient.once('close', () => {
+			observedClient.off('update', onUpdate);
+			this._updatedClients.delete(observedClient.clientId);
+		});
+		observedClient.on('update', onUpdate);
+	}
+
+	private _onClientUpdate(observedClient: ObservedClient) {
+		this._updatedClients.add(observedClient.clientId);
+
+		if (this._updatedClients.size < this._observedCall.observedClients.size) {
+			return;
+		}
+		this._updatedClients.clear();
+		this._observedCall.update();
+	}
+
+}	

package/src/updaters/OnAnyCallObserverUpdater_.ts

@@ -0,0 +1,32 @@
+import { ObservedCall } from '../ObservedCall';
+import { Observer } from '../Observer';
+import { Updater } from './Updater';
+ 
+export class OnAnyCallObserverUpdater implements Updater {
+	public readonly name = 'OnAnyCallObserverUpdater';
+	public readonly description = 'Call Observer\'s update() method on any of the ObservedCall is updated';
+	
+	public constructor(
+		private observver: Observer
+	) {
+		this._onNewObservedCall = this._onNewObservedCall.bind(this);
+
+		this.observver.once('close', () => {
+			this.observver.off('newcall', this._onNewObservedCall);
+		});
+		this.observver.on('newcall', this._onNewObservedCall);
+	}
+
+	close(): void {
+		// do nothing, because we unsubscribe once close is emitted from observer
+	}
+
+	private _onNewObservedCall(observedCall: ObservedCall) {
+		const onUpdate = () => this.observver.update();
+
+		observedCall.once('close', () => {
+			observedCall.off('update', onUpdate);
+		});
+		observedCall.on('update', onUpdate);
+	}
+}

package/src/updaters/OnAnyClientCallUpdater.ts

@@ -0,0 +1,32 @@
+import { ObservedCall } from '../ObservedCall';
+import { ObservedClient } from '../ObservedClient';
+import { Updater } from './Updater';
+ 
+export class OnAnyClientCallUpdater implements Updater {
+	readonly name = 'OnAnyClientCallUpdater';
+	readonly description = 'Call the update() method of the ObservedCall when any of the client has been updated';
+
+	public constructor(
+		private _observedCall: ObservedCall
+	) {
+		this._onNewObservedClient = this._onNewObservedClient.bind(this);
+
+		this._observedCall.once('close', () => {
+			this._observedCall.off('newclient', this._onNewObservedClient);
+		});
+		this._observedCall.on('newclient', this._onNewObservedClient);
+	}
+	
+	public close(): void {
+		// do nothing, as close once emitted unsubscription happened
+	}
+
+	private _onNewObservedClient(observedClient: ObservedClient) {
+		const onUpdate = () => this._observedCall.update();
+
+		observedClient.once('close', () => {
+			observedClient.off('update', onUpdate);
+		});
+		observedClient.on('update', onUpdate);
+	}
+}

package/src/updaters/OnIntervalUpdater.ts

@@ -0,0 +1,19 @@
+import { Updater } from './Updater';
+
+export class OnIntervalUpdater implements Updater {
+	readonly name = 'OnIntervalUpdater';
+	readonly description = 'Call the update() method given in the constructor once the interval elapsed';
+
+	public timer: ReturnType<typeof setInterval>;
+
+	public constructor(
+		intervalInMs: number,
+		private readonly _update: () => void,
+	) {
+		this.timer = setInterval(() => this._update(), intervalInMs);
+	}
+	
+	public close(): void {
+		clearInterval(this.timer);
+	}
+}

package/src/updaters/Updater.ts

@@ -0,0 +1,5 @@
+export interface Updater {
+	readonly name: string;
+	readonly description?: string;
+	close(): void;
+}

package/tsconfig.json

@@ -2,7 +2,7 @@
 	"compileOnSave": true,
 	"compilerOptions":
 	{
-		"lib": [ "ES2020" ],
+		"lib": [ "ES2020", "dom" ],
 		"target": "ESNext",
 		"module": "CommonJS",
 		"moduleResolution": "node",