@observertc/observer-js 1.0.1-9d3744d.0 → 1.0.1-a6fb9d3.0

package/src/index.ts

@@ -2,26 +2,27 @@ export type { ObserverEvents } from './Observer';
 
 export { Observer } from './Observer';
 export { ObservedCall } from './ObservedCall';
-export { ObservedInboundTrack } from './ObservedInboundTrack';
-export { ObservedOutboundTrack } from './ObservedOutboundTrack';
+export { ObservedInboundTrack } from './webrtc/ObservedInboundTrack';
+export { ObservedOutboundTrack } from './webrtc/ObservedOutboundTrack';
 export { ObservedClient } from './ObservedClient';
-export { ObservedPeerConnection } from './ObservedPeerConnection';
-export { ObservedMediaSource } from './ObservedMediaSource';
-export { ObservedMediaPlayout } from './ObservedMediaPlayout';
-export { ObservedCodec } from './ObservedCodec';
-export { ObservedCertificate } from './ObservedCertificate';
-export { ObservedDataChannel } from './ObservedDataChannel';
-export { ObservedInboundRtp } from './ObservedInboundRtp';
-export { ObservedOutboundRtp } from './ObservedOutboundRtp';
-export { ObservedRemoteInboundRtp } from './ObservedRemoteInboundRtp';
-export { ObservedRemoteOutboundRtp } from './ObservedRemoteOutboundRtp';
-export { ObservedIceCandidatePair } from './ObservedIceCandidatePair';
-export { ObservedIceCandidate } from './ObservedIceCandidate';
-export { ObservedIceTransport } from './ObservedIceTransport';
-export { ObservedPeerConnectionTransport } from './ObservedPeerConnectionTransport';
+export { ObservedPeerConnection } from './webrtc/ObservedPeerConnection';
+export { ObservedMediaSource } from './webrtc/ObservedMediaSource';
+export { ObservedMediaPlayout } from './webrtc/ObservedMediaPlayout';
+export { ObservedCodec } from './webrtc/ObservedCodec';
+export { ObservedCertificate } from './webrtc/ObservedCertificate';
+export { ObservedDataChannel } from './webrtc/ObservedDataChannel';
+export { ObservedInboundRtp } from './webrtc/ObservedInboundRtp';
+export { ObservedOutboundRtp } from './webrtc/ObservedOutboundRtp';
+export { ObservedRemoteInboundRtp } from './webrtc/ObservedRemoteInboundRtp';
+export { ObservedRemoteOutboundRtp } from './webrtc/ObservedRemoteOutboundRtp';
+export { ObservedIceCandidatePair } from './webrtc/ObservedIceCandidatePair';
+export { ObservedIceCandidate } from './webrtc/ObservedIceCandidate';
+export { ObservedIceTransport } from './webrtc/ObservedIceTransport';
+export { ObservedPeerConnectionTransport } from './webrtc/ObservedPeerConnectionTransport';
 export { ClientEventTypes } from './schema/ClientEventTypes';
 export { ClientMetaTypes } from './schema/ClientMetaTypes';
-export { ClientSample } from './schema/ClientSample';
+export { ClientSample, ClientIssue, ClientEvent, ClientMetaData } from './schema/ClientSample';
 export { ScoreCalculator } from './scores/ScoreCalculator';
-
+export { ObservedClientEventMonitor } from './ObservedClientEventMonitor';
+export { ObserverEventMonitor } from './ObserverEventMonitor';
 export { Middleware } from './common/Middleware';

package/src/mediasoup/ObservedMediasoupRouter.ts

@@ -0,0 +1,12 @@
+import { Observer } from "../Observer";
+
+export class ObservedMediasoupRouter<T extends Record<string, unknown> = Record<string, unknown>> {
+    public readonly appData: T;
+    public constructor(
+        public readonly parent: Observer,
+        appData?: T
+    ) {
+        this.appData = appData ?? {} as T;
+    }
+}
+

package/src/monitors/SummaryMonitor.ts

@@ -0,0 +1,181 @@
+import { EventEmitter } from "events";
+import { CallSummary, ClientSummary } from "../common/SummaryTypes";
+import { ObservedCall } from "../ObservedCall";
+import { Observer } from "../Observer";
+import { createLogger } from "../common/logger";
+import { ObservedClient } from "../ObservedClient";
+import { ClientSample } from "../schema/ClientSample";
+
+const logger = createLogger("SummaryMonitor");
+
+export type SummaryMonitorEvents = {
+    'call-summary': [CallSummary] 
+}
+
+export interface OngoingCallSumariesMap {
+    create(call: CallSummary): void | Promise<void>;
+    update(call: CallSummary): void | Promise<void>;
+    read(callId: string): Promise<CallSummary | undefined>;
+    delete(callId: string): void | Promise<void>;
+}
+
+
+export class SummaryMonitor extends EventEmitter {
+    
+    public constructor(
+        public readonly callSummaries = createSimpleOngoingCallSummariesMap(),
+    ) {
+        super();
+
+    }
+}
+
+export function createSummaryMonitor(observer: Observer): SummaryMonitor {
+    const result = new SummaryMonitor();
+    const eventer = observer.createEventMonitor(result);
+    
+    eventer.onCallAdded = onCallAdded;
+    eventer.onCallUpdated = onCallUpdated;
+    eventer.onCallRemoved = onCallRemoved;
+    eventer.onClientAdded = onClientAdded;
+    eventer.onClientUpdated = onClientUpdated;
+    eventer.onClientClosed = onClientClosed;
+
+    return result;  
+}
+
+async function onCallAdded(call: ObservedCall, monitor: SummaryMonitor) {
+    const summary: CallSummary = {
+        startedAt: call.startedAt ?? Date.now(),
+        id: call.callId,
+        attachments: {},
+        clients: {},
+        issues: {},
+        totalScore: 0,
+        numberOfScores: 0,
+        scoreReasons: {}
+    };
+
+    await monitor.callSummaries.create(summary);
+}
+
+async function onCallUpdated(call: ObservedCall, monitor: SummaryMonitor) {
+    const summary = await monitor.callSummaries.read(call.callId);
+
+    if (!summary) return logger.warn(`Call summary not found for call ID ${call.callId}`);
+
+    // Update the summary with the latest call data
+    if (call.startedAt) {
+        summary.startedAt = call.startedAt;
+    }
+
+    if (call.score !== undefined) {
+        summary.totalScore += call.score;
+        ++summary.numberOfScores;
+
+        summary.liveState = {
+            ...summary.liveState,
+            score: call.score
+        }
+    }
+
+    await monitor.callSummaries.update(summary);
+}
+
+async function onCallRemoved(call: ObservedCall, monitor: SummaryMonitor) {
+    const summary = await monitor.callSummaries.read(call.callId);
+
+    if (!summary) return logger.warn(`Call summary not found for call ID ${call.callId}`);
+
+    summary.liveState = undefined;
+
+    await monitor.callSummaries.delete(call.callId);
+
+    monitor.emit('call-summary', summary);
+}
+
+
+async function onClientAdded(client: ObservedClient, monitor: SummaryMonitor) {
+    const callSummary = await monitor.callSummaries.read(client.call.callId);
+
+    if (!callSummary) return logger.warn(`Call summary not found for call ID ${client.call.callId}`);
+    
+    const clientSummary: ClientSummary = {
+        id: client.clientId,
+        attachments: {},
+        joinedAt: client.joinedAt ?? Date.now(),
+        leftAt: client.leftAt,
+        peerConnections: {},
+        issues: {},
+        totalScore: 0,
+        numberOfScores: 0,
+        scoreReasons: {}
+    };
+
+    callSummary.clients[client.clientId] = clientSummary;
+    
+    await monitor.callSummaries.update(callSummary);
+}
+
+async function onClientUpdated(client: ObservedClient, sample: ClientSample, monitor: SummaryMonitor) {
+    const callSummary = await monitor.callSummaries.read(client.call.callId);
+
+    if (!callSummary) return logger.warn(`Call summary not found for call ID ${client.call.callId}`);
+
+    const clientSummary = callSummary.clients[client.clientId];
+
+    if (!clientSummary) return logger.warn(`Client summary not found for client ID ${client.clientId} in call ID ${callSummary.id}`);
+
+    if (client.score !== undefined) {
+        clientSummary.totalScore += client.score;
+        ++clientSummary.numberOfScores;
+
+        clientSummary.liveState = {
+            ...clientSummary.liveState,
+            score: client.score
+        }
+    }
+
+    await monitor.callSummaries.update(callSummary);
+    
+    sample;
+
+}
+
+async function onClientClosed(client: ObservedClient, monitor: SummaryMonitor) {
+    const callSummary = await monitor.callSummaries.read(client.call.callId);
+
+    if (!callSummary) return logger.warn(`Call summary not found for call ID ${client.call.callId}`);
+
+    const clientSummary = callSummary.clients[client.clientId];
+
+    if (!clientSummary) return logger.warn(`Client summary not found for client ID ${client.clientId} in call ID ${callSummary.id}`);
+
+    clientSummary.leftAt = client.leftAt ?? Date.now();
+
+    await monitor.callSummaries.update(callSummary);
+}
+
+
+    
+
+// -----------------------------------------------------
+
+function createSimpleOngoingCallSummariesMap(): OngoingCallSumariesMap {
+    const map = new Map<string, CallSummary>();
+
+    return {
+        create(call: CallSummary) {
+            map.set(call.id, call);
+        },
+        update(call: CallSummary) {
+            // empty
+        },
+        async read(callId: string) {
+            return map.get(callId);
+        },
+        delete(callId: string) {
+            map.delete(callId);
+        }
+    };
+}

package/src/schema/ClientEventTypes.ts

@@ -18,9 +18,10 @@ export enum ClientEventTypes {
 	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_GATHERING_STATE_CHANGE = 'ICE_GATHERING_STATE_CHANGE',
+	// ICE_CONNECTION_STATE_CHANGE = 'ICE_CONNECTION_STATE_CHANGE',
 	ICE_CANDIDATE = 'ICE_CANDIDATE',
+	ICE_CANDIDATE_ERROR = 'ICE_CANDIDATE_ERROR',
 	
 	// mediasoup events
 	PRODUCER_ADDED = 'PRODUCER_ADDED',
@@ -29,27 +30,39 @@ export enum ClientEventTypes {
 	PRODUCER_RESUMED = 'PRODUCER_RESUMED',
 	CONSUMER_ADDED = 'CONSUMER_ADDED',
 	CONSUMER_REMOVED = 'CONSUMER_REMOVED',
+	CONSUMER_PAUSED = 'CONSUMER_PAUSED',
+	CONSUMER_RESUMED = 'CONSUMER_RESUMED',
 	DATA_PRODUCER_CREATED = 'DATA_PRODUCER_CREATED',
 	DATA_PRODUCER_CLOSED = 'DATA_PRODUCER_CLOSED',
 	DATA_CONSUMER_CREATED = 'DATA_CONSUMER_CREATED',
 	DATA_CONSUMER_CLOSED = 'DATA_CONSUMER_CLOSED',
 }
 
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface ClientJoinedEventPayload extends Record<string, unknown> {
+	// empty
+}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface ClientLeftEventPayload extends Record<string, unknown> {
+}
+
 export interface PeerConnectionOpenedEventPayload extends Record<string, unknown> {
 	peerConnectionId: string;
-	iceConnectionState: string;
-	iceGatheringState: string;
-	signalingState: string;
+	iceConnectionState?: string;
+	iceGatheringState?: string;
+	signalingState?: string;
 }
 
 export interface PeerConnectionClosedEventPayload extends Record<string, unknown> {
 	peerConnectionId: string;
-	iceConnectionState: string;
-	iceGatheringState: string;
-	signalingState: string;
+	iceConnectionState?: string;
+	iceGatheringState?: string;
+	signalingState?: string;
 }
 
-export interface MediaTrackMutedEventPayload extends Record<string, unknown> {
+export interface MediaTrackAddedEventPayload extends Record<string, unknown> {
+	peerConnectionId: string;
 	trackId: string;
 	kind: 'audio' | 'video';
 	label?: string;
@@ -57,9 +70,13 @@ export interface MediaTrackMutedEventPayload extends Record<string, unknown> {
 	enabled: boolean;
 	readyState: string;
 	contentHint?: string;
+	constraints: MediaTrackConstraints,
+	capabilities: MediaTrackCapabilities,
+	settings: MediaTrackSettings,
 }
 
-export interface MediaTrackUnmutedEventPayload extends Record<string, unknown> {
+export interface MediaTrackRemovedEventPayload extends Record<string, unknown> {
+	peerConnectionId: string;
 	trackId: string;
 	kind: 'audio' | 'video';
 	label?: string;
@@ -69,7 +86,8 @@ export interface MediaTrackUnmutedEventPayload extends Record<string, unknown> {
 	contentHint?: string;
 }
 
-export interface MediaTrackAddedEventPayload extends Record<string, unknown> {
+export interface MediaTrackMutedEventPayload extends Record<string, unknown> {
+	peerConnectionId: string;
 	trackId: string;
 	kind: 'audio' | 'video';
 	label?: string;
@@ -77,12 +95,10 @@ export interface MediaTrackAddedEventPayload extends Record<string, unknown> {
 	enabled: boolean;
 	readyState: string;
 	contentHint?: string;
-	constraints: MediaTrackConstraints,
-	capabilities: MediaTrackCapabilities,
-	settings: MediaTrackSettings,
 }
 
-export interface MediaTrackRemovedEventPayload extends Record<string, unknown> {
+export interface MediaTrackUnmutedEventPayload extends Record<string, unknown> {
+	peerConnectionId: string;
 	trackId: string;
 	kind: 'audio' | 'video';
 	label?: string;
@@ -92,21 +108,173 @@ export interface MediaTrackRemovedEventPayload extends Record<string, unknown> {
 	contentHint?: string;
 }
 
+export interface IceGatheringStateChangedEventPayload extends Record<string, unknown> {
+	peerConnectionId: string;
+	iceGatheringState: string;
+}
+
+export interface PeerConnectionStateChangedEventPayload extends Record<string, unknown> {
+	peerConnectionId: string;
+	connectionState: string;
+}
+
+export interface IceConnectionStateChangedEventPayload extends Record<string, unknown> {
+	peerConnectionId: string;
+	iceConnectionState: string;
+}
+
 export interface DataChannelErrorEventPayload extends Record<string, unknown> {
 	label: string;
+	peerConnectionId: string;
 	readyState: string;
-	dataChannelId: string,
-	error: string,
+	dataChannelId: string | number | null,
+	error: string | null,
 }
 
 export interface DataChannelOpenEventPayload extends Record<string, unknown> {
+	peerConnectionId: string;
 	label: string;
 	readyState: string;
-	dataChannelId: string,
+	dataChannelId: string | number | null,
 }
 
 export interface DataChannelClosedEventPayload extends Record<string, unknown> {
+	peerConnectionId: string;
 	label: string;
 	readyState: string;
-	dataChannelId: string,
+	dataChannelId: string | number | null,
+}
+
+export interface NegotiationNeededEventPayload extends Record<string, unknown> {
+	peerConnectionId: string;
+}
+
+export interface IceCandidateEventPayload extends Record<string, unknown> {
+	peerConnectionId: string;
+
+	/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCIceCandidate/address) */
+	address?: string | null;
+
+	/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCIceCandidate/candidate) */
+	candidate?: string;
+
+	/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCIceCandidate/component) */
+	component?: RTCIceComponent | null;
+
+	/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCIceCandidate/foundation) */
+	foundation?: string | null;
+
+	/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCIceCandidate/port) */
+	port?: number | null;
+
+	/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCIceCandidate/priority) */
+	priority?: number | null;
+
+	/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCIceCandidate/protocol) */
+	protocol?: RTCIceProtocol | null;
+
+	/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCIceCandidate/relatedAddress) */
+	relatedAddress?: string | null;
+
+	/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCIceCandidate/relatedPort) */
+	relatedPort?: number | null;
+
+	/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCIceCandidate/sdpMLineIndex) */
+	sdpMLineIndex?: number | null;
+
+	/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCIceCandidate/sdpMid) */
+	sdpMid?: string | null;
+
+	/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCIceCandidate/tcpType) */
+	tcpType?: RTCIceTcpCandidateType | null;
+
+	/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCIceCandidate/type) */
+	type?: RTCIceCandidateType | null;
+
+	/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/RTCIceCandidate/usernameFragment) */
+	usernameFragment?: string | null;
+}
+
+export interface IceCandidateErrorEventPayload extends Record<string, unknown> {
+	peerConnectionId: string;
+	errorCode?: number;
+	errorText?: string;
+	address?: string | null;
+	port?: number | null;
+	url?: string | null;
+}
+
+export interface SignalingStateChangedEventPayload extends Record<string, unknown> {
+	peerConnectionId: string;
+	signalingState: string;
+}
+
+export interface ProducerAddedEventPayload extends Record<string, unknown> {
+	peerConnectionId: string;
+	producerId: string;
+}
+
+export interface ProducerRemovedEventPayload extends Record<string, unknown> {
+	peerConnectionId: string;
+	producerId: string;
+}
+
+export interface ProducerPausedEventPayload extends Record<string, unknown> {
+	peerConnectionId: string;
+	producerId: string;
+}
+
+export interface ProducerResumedEventPayload extends Record<string, unknown> {
+	peerConnectionId: string;
+	producerId: string;
 }
+
+export interface ConsumerAddedEventPayload extends Record<string, unknown> {
+	peerConnectionId: string;
+	producerId: string;
+	consumerId: string;
+	trackId: string;
+}
+
+export interface ConsumerRemovedEventPayload extends Record<string, unknown> {
+	peerConnectionId: string;
+	producerId: string;
+	consumerId: string;
+	trackId: string;
+}
+
+export interface ConsumerPausedEventPayload extends Record<string, unknown> {
+	peerConnectionId: string;
+	producerId: string;
+	consumerId: string;
+	trackId: string;
+}
+
+export interface ConsumerResumedEventPayload extends Record<string, unknown> {
+	peerConnectionId: string;
+	producerId: string;
+	consumerId: string;
+	trackId: string;
+}
+
+export interface DataProducerCreatedEventPayload extends Record<string, unknown> {
+	peerConnectionId: string;
+	dataProducerId: string;
+}
+
+export interface DataProducerClosedEventPayload extends Record<string, unknown> {
+	peerConnectionId: string;
+	dataProducerId: string;
+}
+
+export interface DataConsumerCreatedEventPayload extends Record<string, unknown> {
+	peerConnectionId: string;
+	dataProducerId: string;
+	dataConsumerId: string;
+}
+
+export interface DataConsumerClosedEventPayload extends Record<string, unknown> {
+	peerConnectionId: string;
+	dataProducerId: string;
+	dataConsumerId: string;
+}

package/src/schema/ClientSample.ts

@@ -170,7 +170,7 @@ export type IceCandidatePairStats = {
 	*/
 	remoteCandidateId?: string;
 
-	state?: 'new' | 'inProgress' | 'failed' | 'succeeded';
+	state?: 'new' | 'in-progress' | 'waiting' | 'failed' | 'succeeded' | 'cancelled' | 'inprogress';
 
 	/**
 	* Whether this candidate pair has been nominated.

package/src/updaters/{OnAllCallObserverUpdater_.ts → OnAllCallObserverUpdater.ts}

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

package/src/updaters/OnAllClientCallUpdater.ts

@@ -7,6 +7,7 @@ export class OnAllClientCallUpdater implements Updater {
 	readonly description = 'Call the update() method of the ObservedCall once all client has been updated';
 
 	private readonly _updatedClients = new Set<string>();
+	public closed = false;
 
 	public constructor(
 		private _observedCall: ObservedCall
@@ -20,25 +21,39 @@ export class OnAllClientCallUpdater implements Updater {
 	}
 	
 	public close(): void {
+		if (this.closed) return;
+		this.closed = true;
 		// do nothing, as close once emitted unsubscription happened
+		this._updatedClients.clear();
 	}
 
 	private _onNewObservedClient(observedClient: ObservedClient) {
+		if (this.closed) return;
+		
 		const onUpdate = () => this._onClientUpdate(observedClient);
 
 		observedClient.once('close', () => {
 			observedClient.off('update', onUpdate);
 			this._updatedClients.delete(observedClient.clientId);
+			this._updateIfEveryClientUpdated();
 		});
 		observedClient.on('update', onUpdate);
 	}
 
 	private _onClientUpdate(observedClient: ObservedClient) {
+		if (observedClient.closed) return;
+
 		this._updatedClients.add(observedClient.clientId);
+		this._updateIfEveryClientUpdated();
+	}
 
+	private _updateIfEveryClientUpdated() {
 		if (this._updatedClients.size < this._observedCall.observedClients.size) {
 			return;
+		} else if (this.closed) {
+			return;
 		}
+
 		this._updatedClients.clear();
 		this._observedCall.update();
 	}

package/src/updaters/{OnAnyCallObserverUpdater_.ts → OnAnyCallObserverUpdater.ts}

@@ -5,7 +5,8 @@ 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 closed = false;
+
 	public constructor(
 		private observver: Observer
 	) {
@@ -17,12 +18,20 @@ export class OnAnyCallObserverUpdater implements Updater {
 		this.observver.on('newcall', this._onNewObservedCall);
 	}
 
-	close(): void {
+	public close(): void {
+		if (this.closed) return;
+		this.closed = true;
 		// do nothing, because we unsubscribe once close is emitted from observer
 	}
 
 	private _onNewObservedCall(observedCall: ObservedCall) {
-		const onUpdate = () => this.observver.update();
+		if (this.closed) return;
+		
+		const onUpdate = () => {
+			if (this.closed) return;
+
+			this.observver.update();
+		};
 
 		observedCall.once('close', () => {
 			observedCall.off('update', onUpdate);

package/src/updaters/OnAnyClientCallUpdater.ts

@@ -5,6 +5,7 @@ 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 closed = false;
 
 	public constructor(
 		private _observedCall: ObservedCall
@@ -18,11 +19,17 @@ export class OnAnyClientCallUpdater implements Updater {
 	}
 	
 	public close(): void {
-		// do nothing, as close once emitted unsubscription happened
+		if (this.closed) return;
+		this.closed = true;
 	}
 
 	private _onNewObservedClient(observedClient: ObservedClient) {
-		const onUpdate = () => this._observedCall.update();
+		if (this.closed) return;
+		
+		const onUpdate = () => {
+			if (this.closed) return;
+			this._observedCall.update();
+		};
 
 		observedClient.once('close', () => {
 			observedClient.off('update', onUpdate);