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

package/src/ObservedClient.ts

@@ -10,6 +10,7 @@ import { ClientMetaTypes } from './schema/ClientMetaTypes';
 import { parseJsonAs } from './common/utils';
 import { CalculatedScore } from './scores/CalculatedScore';
 import { Detectors } from './detectors/Detectors';
+import { ObservedClientEventMonitor } from './ObservedClientEventMonitor';
 
 const logger = createLogger('ObservedClient');
 
@@ -64,6 +65,7 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 
 	public joinedAt?: number;
 	public leftAt?: number;
+	public closedAt?: number;
 	// the timestamp of the CLIENT_JOINED event
 	public operationSystem?: MetaData.OperationSystem;
 	public engine?: MetaData.Engine;
@@ -136,6 +138,8 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 	public readonly mediaDevices: MetaData.MediaDeviceInfo[] = [];
 	public issues: ClientIssue[] = [];
 
+	private _injections: Pick<ClientSample, 'clientEvents' | 'clientIssues' | 'extensionStats' | 'attachments' | 'clientMetaItems'> = {};
+
 	public constructor(settings: ObservedClientSettings<AppData>, public readonly call: ObservedCall) {
 		super();
 		this.setMaxListeners(Infinity);
@@ -160,6 +164,8 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 
 		Array.from(this.observedPeerConnections.values()).forEach((peerConnection) => peerConnection.close());
 
+		this.closedAt = Date.now();
+
 		this.emit('close');
 	}
 
@@ -204,9 +210,15 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 		this.usingTCP = false;
 		this.currentMinRttInMs = undefined;
 		this.currentMaxRttInMs = undefined;
-		
+
+		this._mergeInjections(sample);
+
+		const clientEventsPostBuffer: ClientEvent[] = [];
+
 		for (const clientEvent of sample.clientEvents ?? []) {
-			this._processClientEvent(clientEvent);
+			this._processClientEvent(clientEvent, clientEventsPostBuffer);
+
+			this.call.observer.emit('client-event', this, clientEvent);
 		}
 
 		for (const metaData of sample.clientMetaItems ?? []) {
@@ -280,7 +292,9 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 			}
 		}
 
-		sample.peerConnections?.forEach(this._updatePeerConnection.bind(this));
+		for (const clientEvent of clientEventsPostBuffer) {
+			this._processClientEvent(clientEvent);
+		}
 
 		// emit new attachments?
 		this.attachments = sample.attachments;
@@ -327,7 +341,7 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 		}
 	}
 
-	private _processClientEvent(event: ClientEvent) {
+	private _processClientEvent(event: ClientEvent, postBuffer?: ClientEvent[]) {
 		// eslint-disable-next-line no-console
 		// console.warn('ClientEvent', event);
 		switch (event.type) {
@@ -356,9 +370,150 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 				}
 				break;
 			}
+			case ClientEventTypes.PEER_CONNECTION_OPENED: {
+				const payload = parseJsonAs<Record<string, unknown>>(event.payload);
+
+				if (payload?.peerConnectionId && typeof payload.peerConnectionId === 'string') {
+					const observedPeerConnection = this.observedPeerConnections.get(payload.peerConnectionId);
+
+					if (observedPeerConnection) {
+						observedPeerConnection.openedAt = event.timestamp;
+					} else if (postBuffer) {
+						postBuffer.push(event);
+					} else {
+						logger.warn('Received PEER_CONNECTION_OPENED event without a corresponding observedPeerConnection', event);
+					}
+					
+				}
+				break;
+			}
+			case ClientEventTypes.PEER_CONNECTION_CLOSED: {
+				const payload = parseJsonAs<Record<string, unknown>>(event.payload);
+
+				if (payload?.peerConnectionId && typeof payload.peerConnectionId === 'string') {
+					const observedPeerConnection = this.observedPeerConnections.get(payload.peerConnectionId);
+
+					if (observedPeerConnection) {
+						observedPeerConnection.closedAt = event.timestamp;
+					} else if (postBuffer) {
+						postBuffer.push(event);
+					} else {
+						logger.warn('Received PEER_CONNECTION_CLOSED event without a corresponding observedPeerConnection', event);
+					}
+				}
+				break;
+			}
+			case ClientEventTypes.MEDIA_TRACK_ADDED: {
+				const payload = parseJsonAs<Record<string, unknown>>(event.payload);
+
+				if (payload?.peerConnectionId && typeof payload.peerConnectionId === 'string' && payload?.trackId && typeof payload.trackId === 'string') {
+					const observedPeerConnection = this.observedPeerConnections.get(payload.peerConnectionId);
+					const observedTrack = observedPeerConnection?.observedInboundTracks.get(payload.trackId) ?? observedPeerConnection?.observedOutboundTracks.get(payload.trackId);
+
+					if (observedTrack) {
+						observedTrack.addedAt = event.timestamp;
+					} else if (postBuffer) {
+						postBuffer.push(event);
+					} else {
+						logger.warn('Received MEDIA_TRACK_ADDED event without a corresponding observedPeerConnection or observedTrack', event);
+					}
+				}
+				break;
+			}
+			case ClientEventTypes.MEDIA_TRACK_REMOVED: {
+				const payload = parseJsonAs<Record<string, unknown>>(event.payload);
+
+				if (payload?.peerConnectionId && typeof payload.peerConnectionId === 'string' && payload?.trackId && typeof payload.trackId === 'string') {
+					const observedPeerConnection = this.observedPeerConnections.get(payload.peerConnectionId);
+					const observedTrack = observedPeerConnection?.observedInboundTracks.get(payload.trackId) ?? observedPeerConnection?.observedOutboundTracks.get(payload.trackId);
+
+					if (observedTrack) {
+						observedTrack.removedAt = event.timestamp;
+					} else if (postBuffer) {
+						postBuffer.push(event);
+					} else {
+						logger.warn('Received MEDIA_TRACK_REMOVED event without a corresponding observedPeerConnection or observedTrack', event);
+					}
+				}
+				break;
+			}
+			case ClientEventTypes.DATA_CHANNEL_OPEN: {
+				const payload = parseJsonAs<Record<string, unknown>>(event.payload);
+
+				if (payload?.peerConnectionId && typeof payload.peerConnectionId === 'string' && payload?.dataChannelId && typeof payload.dataChannelId === 'string') {
+					const observedPeerConnection = this.observedPeerConnections.get(payload.peerConnectionId);
+					const observedDataChannel = observedPeerConnection?.observedDataChannels.get(payload.dataChannelId);
+
+					if (observedDataChannel) {
+						observedDataChannel.addedAt = event.timestamp;
+					} else if (postBuffer) {
+						postBuffer.push(event);
+					} else {
+						logger.warn('Received DATA_CHANNEL_OPENED event without a corresponding observedPeerConnection or observedDataChannel', event);
+					}
+				}
+				break;
+			}
+			case ClientEventTypes.DATA_CHANNEL_CLOSED: {
+				const payload = parseJsonAs<Record<string, unknown>>(event.payload);
+
+				if (payload?.peerConnectionId && typeof payload.peerConnectionId === 'string' && payload?.dataChannelId && typeof payload.dataChannelId === 'string') {
+					const observedPeerConnection = this.observedPeerConnections.get(payload.peerConnectionId);
+					const observedDataChannel = observedPeerConnection?.observedDataChannels.get(payload.dataChannelId);
+
+					if (observedDataChannel) {
+						observedDataChannel.removedAt = event.timestamp;
+					} else if (postBuffer) {
+						postBuffer.push(event);
+					} else {
+						logger.warn('Received DATA_CHANNEL_CLOSE event without a corresponding observedPeerConnection or observedDataChannel', event);
+					}
+				}
+				break;
+			}
+			
 		}
+	}
+
+	public injectMetaData(metaData: ClientMetaData) {
+		if (this.closed) return;
+		
+		if (!this._injections.clientMetaItems) this._injections.clientMetaItems = [];
+
+		this._injections.clientMetaItems.push(metaData);
+	}
+
+	public injectEvent(event: ClientEvent) {
+		if (this.closed) return;
+
+		if (!this._injections.clientEvents) this._injections.clientEvents = [];
 
-		this.call.observer.emit('client-event', this, event);
+		this._injections.clientEvents.push(event);
+	}
+
+	public injectIssue(issue: ClientIssue) {
+		if (this.closed) return;
+
+		if (!this._injections.clientIssues) this._injections.clientIssues = [];
+
+		this._injections.clientIssues.push(issue);
+	}
+
+	public injectExtensionStat(stat: ExtensionStat) {
+		if (this.closed) return;
+
+		if (!this._injections.extensionStats) this._injections.extensionStats = [];
+
+		this._injections.extensionStats.push(stat);
+	}
+
+	public injectAttachment(key: string, value: unknown) {
+		if (this.closed) return;
+
+		if (!this._injections.attachments) this._injections.attachments = {};
+
+		this._injections.attachments[key] = value;
+		
 	}
 
 	public addMetadata(metadata: ClientMetaData) {
@@ -423,6 +578,51 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 		return observedPeerConnection;
 	}
 
+	public createEventMonitor<CTX = unknown>(ctx?: CTX): ObservedClientEventMonitor<CTX> {
+		return new ObservedClientEventMonitor<CTX>(this, ctx ?? {} as CTX);
+	}
+
+	private _mergeInjections(sample: ClientSample): ClientSample {
+		if (this.closed) return sample;
+
+		if (this._injections.clientEvents) {
+			if (!sample.clientEvents) sample.clientEvents = [];
+			sample.clientEvents.push(...this._injections.clientEvents);
+			
+			this._injections.clientEvents = undefined;
+		}
+
+		if (this._injections.clientIssues) {
+			if (!sample.clientIssues) sample.clientIssues = [];
+			sample.clientIssues.push(...this._injections.clientIssues);
+			
+			this._injections.clientIssues = undefined;
+		}
+
+		if (this._injections.extensionStats) {
+			if (!sample.extensionStats) sample.extensionStats = [];
+			sample.extensionStats.push(...this._injections.extensionStats);
+			
+			this._injections.extensionStats = undefined;
+		}
+
+		if (this._injections.attachments) {
+			if (!sample.attachments) sample.attachments = {};
+			Object.assign(sample.attachments, this._injections.attachments);
+			
+			this._injections.attachments = undefined;
+		}
+
+		if (this._injections.clientMetaItems) {
+			if (!sample.clientMetaItems) sample.clientMetaItems = [];
+			sample.clientMetaItems.push(...this._injections.clientMetaItems);
+			
+			this._injections.clientMetaItems = undefined;
+		}
+
+		return sample;
+	}
+
 	// public resetSummaryMetrics() {
 	// 	this.totalDataChannelBytesReceived = 0;
 	// 	this.totalDataChannelBytesSent = 0;

package/src/ObservedClientEventMonitor.ts

@@ -0,0 +1,301 @@
+import { ObservedCertificate } from './ObservedCertificate';
+import { ObservedClient } from './ObservedClient';
+import { ObservedCodec } from './ObservedCodec';
+import { ObservedDataChannel } from './ObservedDataChannel';
+import { ObservedIceCandidate } from './ObservedIceCandidate';
+import { ObservedIceCandidatePair } from './ObservedIceCandidatePair';
+import { ObservedIceTransport } from './ObservedIceTransport';
+import { ObservedInboundRtp } from './ObservedInboundRtp';
+import { ObservedInboundTrack } from './ObservedInboundTrack';
+import { ObservedMediaPlayout } from './ObservedMediaPlayout';
+import { ObservedMediaSource } from './ObservedMediaSource';
+import { ObservedOutboundRtp } from './ObservedOutboundRtp';
+import { ObservedOutboundTrack } from './ObservedOutboundTrack';
+import { ObservedPeerConnection } from './ObservedPeerConnection';
+import { ClientIssue, ClientMetaData, ExtensionStat } from './schema/ClientSample';
+
+export class ObservedClientEventMonitor<Context> {
+	public constructor(
+		public readonly observedClient: ObservedClient,
+		public readonly context: Context,
+	) {
+		this._onPeerConnconnectionAdded = this._onPeerConnconnectionAdded.bind(this);
+		this._onPeerConnectionRemoved = this._onPeerConnectionRemoved.bind(this);
+		this._onCertificateAdded = this._onCertificateAdded.bind(this);
+		this._onCertificateRemoved = this._onCertificateRemoved.bind(this);
+		this._onInboundTrackAdded = this._onInboundTrackAdded.bind(this);
+		this._onInboundTrackRemoved = this._onInboundTrackRemoved.bind(this);
+		this._onOutboundTrackAdded = this._onOutboundTrackAdded.bind(this);
+		this._onOutboundTrackRemoved = this._onOutboundTrackRemoved.bind(this);
+		this._onInboundRtpAdded = this._onInboundRtpAdded.bind(this);
+		this._onInboundRtpRemoved = this._onInboundRtpRemoved.bind(this);
+		this._onOutboundRtpAdded = this._onOutboundRtpAdded.bind(this);
+		this._onOutboundRtpRemoved = this._onOutboundRtpRemoved.bind(this);
+		this._onDataChannelAdded = this._onDataChannelAdded.bind(this);
+		this._onDataChannelRemoved = this._onDataChannelRemoved.bind(this);
+		this._onAddedIceTransport = this._onAddedIceTransport.bind(this);
+		this._onRemovedIceTransport = this._onRemovedIceTransport.bind(this);
+		this._onIceCandidateAdded = this._onIceCandidateAdded.bind(this);
+		this._onIceCandidateRemoved = this._onIceCandidateRemoved.bind(this);
+		this._onAddedIceCandidatePair = this._onAddedIceCandidatePair.bind(this);
+		this._onRemovedIceCandidatePair = this._onRemovedIceCandidatePair.bind(this);
+		this._onAddedMediaCodec = this._onAddedMediaCodec.bind(this);
+		this._onRemovedMediaCodec = this._onRemovedMediaCodec.bind(this);
+		this._onAddedMediaPlayout = this._onAddedMediaPlayout.bind(this);
+		this._onRemovedMediaPlayout = this._onRemovedMediaPlayout.bind(this);
+		this._onMediaSourceAdded = this._onMediaSourceAdded.bind(this);
+		this._onMediaSourceRemoved = this._onMediaSourceRemoved.bind(this);
+		this._onClientClosed = this._onClientClosed.bind(this);
+		this._onClientIssue = this._onClientIssue.bind(this);
+		this._onClientMetadata = this._onClientMetadata.bind(this);
+		this._onClientJoined = this._onClientJoined.bind(this);
+		this._onClientLeft = this._onClientLeft.bind(this);
+		this._onUserMediaError = this._onUserMediaError.bind(this);
+		this._onUsingTurn = this._onUsingTurn.bind(this);
+
+		this.observedClient.on('newpeerconnection', this._onPeerConnconnectionAdded);
+		this.observedClient.on('issue', this._onClientIssue);
+		this.observedClient.on('metaData', this._onClientMetadata);
+		this.observedClient.on('joined', this._onClientJoined);
+		this.observedClient.on('left', this._onClientLeft);
+		this.observedClient.on('rejoined', this._onClientJoined);
+		this.observedClient.on('usermediaerror', this._onUserMediaError);
+		this.observedClient.on('usingturn', this._onUsingTurn);
+		
+		this.observedClient.once('close', this._onClientClosed);
+	}
+
+	public onClientClosed?: (client: ObservedClient, ctx: Context) => void;
+	private _onClientClosed() {
+		this.onClientClosed?.(this.observedClient, this.context);
+
+		this.observedClient.off('newpeerconnection', this._onPeerConnconnectionAdded);
+		this.observedClient.off('issue', this._onClientIssue);
+		this.observedClient.off('metaData', this._onClientMetadata);
+		this.observedClient.off('joined', this._onClientJoined);
+		this.observedClient.off('left', this._onClientLeft);
+		this.observedClient.off('rejoined', this._onClientJoined);
+		this.observedClient.off('usermediaerror', this._onUserMediaError);
+		this.observedClient.off('usingturn', this._onUsingTurn);
+
+	}
+
+	public onPeerConnectionAdded?: (peerConnection: ObservedPeerConnection, ctx: Context) => void;
+	private _onPeerConnconnectionAdded(peerConnection: ObservedPeerConnection) {
+		this.onPeerConnectionAdded?.(peerConnection, this.context);
+
+		peerConnection.once('close', () => this._onPeerConnectionRemoved(peerConnection));
+        
+		peerConnection.on('added-certificate', this._onCertificateAdded);
+		peerConnection.on('removed-certificate', this._onCertificateRemoved);
+		peerConnection.on('added-inbound-track', this._onInboundTrackAdded);
+		peerConnection.on('removed-inbound-track', this._onInboundTrackRemoved);
+		peerConnection.on('added-outbound-track', this._onOutboundTrackAdded);
+		peerConnection.on('removed-outbound-track', this._onOutboundTrackRemoved);
+		peerConnection.on('added-inbound-rtp', this._onInboundRtpAdded);
+		peerConnection.on('removed-inbound-rtp', this._onInboundRtpRemoved);
+		peerConnection.on('added-outbound-rtp', this._onOutboundRtpAdded);
+		peerConnection.on('removed-outbound-rtp', this._onOutboundRtpRemoved);
+		peerConnection.on('added-data-channel', this._onDataChannelAdded);
+		peerConnection.on('removed-data-channel', this._onDataChannelRemoved);
+		peerConnection.on('added-ice-transport', this._onAddedIceTransport);
+		peerConnection.on('removed-ice-transport', this._onRemovedIceTransport);
+		peerConnection.on('added-ice-candidate', this._onIceCandidateAdded);
+		peerConnection.on('removed-ice-candidate', this._onIceCandidateRemoved);
+		peerConnection.on('added-ice-candidate-pair', this._onAddedIceCandidatePair);
+		peerConnection.on('removed-ice-candidate-pair', this._onRemovedIceCandidatePair);
+		peerConnection.on('added-codec', this._onAddedMediaCodec);
+		peerConnection.on('removed-codec', this._onRemovedMediaCodec);
+		peerConnection.on('added-media-playout', this._onAddedMediaPlayout);
+		peerConnection.on('removed-media-playout', this._onRemovedMediaPlayout);
+		peerConnection.on('added-media-source', this._onMediaSourceAdded);
+		peerConnection.on('removed-media-source', this._onMediaSourceRemoved);
+
+	}
+
+	public onPeerConnectionRemoved?: (peerConnection: ObservedPeerConnection, ctx: Context) => void;
+	private _onPeerConnectionRemoved(peerConnection: ObservedPeerConnection) {
+		this.onPeerConnectionRemoved?.(peerConnection, this.context);
+
+		peerConnection.off('added-certificate', this._onCertificateAdded);
+		peerConnection.off('removed-certificate', this._onCertificateRemoved);
+		peerConnection.off('added-inbound-track', this._onInboundTrackAdded);
+		peerConnection.off('removed-inbound-track', this._onInboundTrackRemoved);
+		peerConnection.off('added-outbound-track', this._onOutboundTrackAdded);
+		peerConnection.off('removed-outbound-track', this._onOutboundTrackRemoved);
+		peerConnection.off('added-inbound-rtp', this._onInboundRtpAdded);
+		peerConnection.off('removed-inbound-rtp', this._onInboundRtpRemoved);
+		peerConnection.off('added-outbound-rtp', this._onOutboundRtpAdded);
+		peerConnection.off('removed-outbound-rtp', this._onOutboundRtpRemoved);
+		peerConnection.off('added-data-channel', this._onDataChannelAdded);
+		peerConnection.off('removed-data-channel', this._onDataChannelRemoved);
+		peerConnection.off('added-ice-transport', this._onAddedIceTransport);
+		peerConnection.off('removed-ice-transport', this._onRemovedIceTransport);
+		peerConnection.off('added-ice-candidate', this._onIceCandidateAdded);
+		peerConnection.off('removed-ice-candidate', this._onIceCandidateRemoved);
+		peerConnection.off('added-ice-candidate-pair', this._onAddedIceCandidatePair);
+		peerConnection.off('removed-ice-candidate-pair', this._onRemovedIceCandidatePair);
+		peerConnection.off('added-codec', this._onAddedMediaCodec);
+		peerConnection.off('removed-codec', this._onRemovedMediaCodec);
+		peerConnection.off('added-media-playout', this._onAddedMediaPlayout);
+		peerConnection.off('removed-media-playout', this._onRemovedMediaPlayout);
+		peerConnection.off('added-media-source', this._onMediaSourceAdded);
+		peerConnection.off('removed-media-source', this._onMediaSourceRemoved);
+
+	}
+    
+	public onCertificateAdded?: (certificate: ObservedCertificate, ctx: Context) => void;
+	private _onCertificateAdded(certificate: ObservedCertificate) {
+		this.onCertificateAdded?.(certificate, this.context);
+	}
+
+	public onCertificateRemoved?: (certificate: ObservedCertificate, ctx: Context) => void;
+	private _onCertificateRemoved(certificate: ObservedCertificate) {
+		this.onCertificateRemoved?.(certificate, this.context);
+	}
+
+	public onInboundTrackAdded?: (inboundTrack: ObservedInboundTrack, ctx: Context) => void;
+	private _onInboundTrackAdded(inboundTrack: ObservedInboundTrack) {
+		this.onInboundTrackAdded?.(inboundTrack, this.context);
+	}
+
+	public onInboundTrackRemoved?: (inboundTrack: ObservedInboundTrack, ctx: Context) => void;
+	private _onInboundTrackRemoved(inboundTrack: ObservedInboundTrack) {
+		this.onInboundTrackRemoved?.(inboundTrack, this.context);
+	}
+
+	public onOutboundTrackAdded?: (outboundTrack: ObservedOutboundTrack, ctx: Context) => void;
+	private _onOutboundTrackAdded(outboundTrack: ObservedOutboundTrack) {
+		this.onOutboundTrackAdded?.(outboundTrack, this.context);
+	}
+
+	public onOutboundTrackRemoved?: (outboundTrack: ObservedOutboundTrack, ctx: Context) => void;
+	private _onOutboundTrackRemoved(outboundTrack: ObservedOutboundTrack) {
+		this.onOutboundTrackRemoved?.(outboundTrack, this.context);
+	}
+
+	public onInboundRtpAdded?: (inboundRtp: ObservedInboundRtp, ctx: Context) => void;
+	private _onInboundRtpAdded(inboundRtp: ObservedInboundRtp) {
+		this.onInboundRtpAdded?.(inboundRtp, this.context);
+	}
+
+	public onInboundRtpRemoved?: (inboundRtp: ObservedInboundRtp, ctx: Context) => void;
+	private _onInboundRtpRemoved(inboundRtp: ObservedInboundRtp) {
+		this.onInboundRtpRemoved?.(inboundRtp, this.context);
+	}
+
+	public onOutboundRtpAdded?: (outboundRtp: ObservedOutboundRtp, ctx: Context) => void;
+	private _onOutboundRtpAdded(outboundRtp: ObservedOutboundRtp) {
+		this.onOutboundRtpAdded?.(outboundRtp, this.context);
+	}
+
+	public onOutboundRtpRemoved?: (outboundRtp: ObservedOutboundRtp, ctx: Context) => void;
+	private _onOutboundRtpRemoved(outboundRtp: ObservedOutboundRtp) {
+		this.onOutboundRtpRemoved?.(outboundRtp, this.context);
+	}
+
+	public onDataChannelAdded?: (dataChannel: ObservedDataChannel, ctx: Context) => void;
+	private _onDataChannelAdded(dataChannel: ObservedDataChannel) {
+		this.onDataChannelAdded?.(dataChannel, this.context);
+	}
+
+	public onDataChannelRemoved?: (dataChannel: ObservedDataChannel, ctx: Context) => void;
+	private _onDataChannelRemoved(dataChannel: ObservedDataChannel) {
+		this.onDataChannelRemoved?.(dataChannel, this.context);
+	}
+
+	public onAddedIceTransport?: (iceTransport: ObservedIceTransport, ctx: Context) => void;
+	private _onAddedIceTransport(iceTransport: ObservedIceTransport) {
+		this.onAddedIceTransport?.(iceTransport, this.context);
+	}
+
+	public onRemovedIceTransport?: (iceTransport: ObservedIceTransport, ctx: Context) => void;
+	private _onRemovedIceTransport(iceTransport: ObservedIceTransport) {
+		this.onRemovedIceTransport?.(iceTransport, this.context);
+	}
+
+	public onIceCandidateAdded?: (iceCandidate: ObservedIceCandidate, ctx: Context) => void;
+	private _onIceCandidateAdded(iceCandidate: ObservedIceCandidate) {
+		this.onIceCandidateAdded?.(iceCandidate, this.context);
+	}
+
+	public onIceCandidateRemoved?: (iceCandidate: ObservedIceCandidate, ctx: Context) => void;
+	private _onIceCandidateRemoved(iceCandidate: ObservedIceCandidate) {
+		this.onIceCandidateRemoved?.(iceCandidate, this.context);
+	}
+
+	public onAddedIceCandidatePair?: (candidatePair: ObservedIceCandidatePair, ctx: Context) => void;
+	private _onAddedIceCandidatePair(candidatePair: ObservedIceCandidatePair) {
+		this.onAddedIceCandidatePair?.(candidatePair, this.context);
+	}
+
+	public onRemovedIceCandidatePair?: (candidatePair: ObservedIceCandidatePair, ctx: Context) => void;
+	private _onRemovedIceCandidatePair(candidatePair: ObservedIceCandidatePair) {
+		this.onRemovedIceCandidatePair?.(candidatePair, this.context);
+	}
+
+	public onAddedMediaCodec?: (codec: ObservedCodec, ctx: Context) => void;
+	private _onAddedMediaCodec(codec: ObservedCodec) {
+		this.onAddedMediaCodec?.(codec, this.context);
+	}
+
+	public onRemovedMediaCodec?: (codec: ObservedCodec, ctx: Context) => void;
+	private _onRemovedMediaCodec(codec: ObservedCodec) {
+		this.onRemovedMediaCodec?.(codec, this.context);
+	}
+
+	public onAddedMediaPlayout?: (mediaPlayout: ObservedMediaPlayout, ctx: Context) => void;
+	private _onAddedMediaPlayout(mediaPlayout: ObservedMediaPlayout) {
+		this.onAddedMediaPlayout?.(mediaPlayout, this.context);
+	}
+
+	public onRemovedMediaPlayout?: (mediaPlayout: ObservedMediaPlayout, ctx: Context) => void;
+	private _onRemovedMediaPlayout(mediaPlayout: ObservedMediaPlayout) {
+		this.onRemovedMediaPlayout?.(mediaPlayout, this.context);
+	}
+
+	public onMediaSourceAdded?: (mediaSource: ObservedMediaSource, ctx: Context) => void;
+	private _onMediaSourceAdded(mediaSource: ObservedMediaSource) {
+		this.onMediaSourceAdded?.(mediaSource, this.context);
+	}
+
+	public onMediaSourceRemoved?: (mediaSource: ObservedMediaSource, ctx: Context) => void;
+	private _onMediaSourceRemoved(mediaSource: ObservedMediaSource) {
+		this.onMediaSourceRemoved?.(mediaSource, this.context);
+	}
+
+	public onClientIssue?: (issue: ClientIssue, ctx: Context) => void;
+	private _onClientIssue(issue: ClientIssue) {
+		this.onClientIssue?.(issue, this.context);
+	}
+
+	public onClientMetadata?: (metadata: ClientMetaData, ctx: Context) => void;
+	private _onClientMetadata(metadata: ClientMetaData) {
+		this.onClientMetadata?.(metadata, this.context);
+	}
+
+	public onClientExtensionStats?: (extensionStats: ExtensionStat, ctx: Context) => void;
+	private _onClientExtensionStats(extensionStats: ExtensionStat) {
+		this.onClientExtensionStats?.(extensionStats, this.context);
+	}
+
+	public onClientJoined?: (client: ObservedClient, ctx: Context) => void;
+	private _onClientJoined() {
+		this.onClientJoined?.(this.observedClient, this.context);
+	}
+
+	public onClientLeft?: (client: ObservedClient, ctx: Context) => void;
+	private _onClientLeft() {
+		this.onClientLeft?.(this.observedClient, this.context);
+	}
+
+	public onUserMediaError?: (error: string, observedClient: ObservedClient, ctx: Context) => void;
+	private _onUserMediaError(error: string) {
+		this.onUserMediaError?.(error, this.observedClient, this.context);
+	}
+
+	public onUsingTurn?: (client: ObservedClient, ctx: Context) => void;
+	private _onUsingTurn() {
+		this.onUsingTurn?.(this.observedClient, this.context);
+	}
+}

package/src/ObservedDataChannel.ts

@@ -16,6 +16,9 @@ export class ObservedDataChannel implements DataChannelStats	{
 	bytesReceived?: number | undefined;
 	attachments?: Record<string, unknown> | undefined;
 
+	public addedAt?: number | undefined;
+	public removedAt?: number | undefined;
+	
 	public deltaBytesSent = 0;
 	public deltaBytesReceived = 0;
 	public deltaMessagesSent = 0;

package/src/ObservedInboundTrack.ts

@@ -16,6 +16,9 @@ export class ObservedInboundTrack implements InboundTrackSample {
 
 	private _visited = false;
 
+	public addedAt?: number | undefined;
+	public removedAt?: number | undefined;
+	
 	attachments?: Record<string, unknown> | undefined;
 
 	constructor(

package/src/ObservedOutboundTrack.ts

@@ -15,6 +15,9 @@ export class ObservedOutboundTrack implements OutboundTrackSample {
 		value: undefined,
 	};
 
+	public addedAt?: number | undefined;
+	public removedAt?: number | undefined;
+
 	attachments?: Record<string, unknown> | undefined;
 
 	constructor(

package/src/ObservedPeerConnection.ts

@@ -280,6 +280,8 @@ export class ObservedPeerConnection extends EventEmitter {
 
 		this.client.call.observer.observedTURN.removePeerConnection(this);
 		
+		if (!this.closedAt) this.closedAt = Date.now();
+		
 		this.emit('close');
 	}
 

package/src/Observer.ts

@@ -54,7 +54,7 @@ export class Observer extends EventEmitter {
 	public totalRttGtOrEq300Measurements = 0;
 	public totalClientIssues = 0;
 
-	public numberOfClientsUsedTurn = 0;
+	public numberOfClientsUsingTurn = 0;
 	public numberOfClients = 0;
 	public numberOfInboundRtpStreams = 0;
 	public numberOfOutboundRtpStreams = 0;
@@ -186,7 +186,7 @@ export class Observer extends EventEmitter {
 		this.numberOfPeerConnections = 0;
 		this.numberOfDataChannels = 0;
 		this.numberOfClients = 0;
-		this.numberOfClientsUsedTurn = 0;
+		this.numberOfClientsUsingTurn = 0;
 
 		for (const call of this.observedCalls.values()) {
 			this.numberOfInboundRtpStreams += call.numberOfInboundRtpStreams;
@@ -194,7 +194,7 @@ export class Observer extends EventEmitter {
 			this.numberOfPeerConnections += call.numberOfPeerConnections;
 			this.numberOfDataChannels += call.numberOfDataChannels;
 			this.numberOfClients += call.numberOfClients;
-			this.numberOfClientsUsedTurn += call.clientsUsedTurn.size;
+			this.numberOfClientsUsingTurn += call.clientsUsedTurn.size;
 		}
 
 		this.observedTURN.update();

package/src/index.ts

@@ -23,5 +23,6 @@ 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';