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

package/src/ObservedClient.ts

@@ -1,5 +1,5 @@
 import { EventEmitter } from 'events';
-import { ObservedPeerConnection } from './ObservedPeerConnection';
+import { ObservedPeerConnection } from './webrtc/ObservedPeerConnection';
 import { createLogger } from './common/logger';
 // eslint-disable-next-line camelcase
 import { ClientEvent, ClientMetaData, ClientSample, PeerConnectionSample, ClientIssue, ExtensionStat } from './schema/ClientSample';
@@ -10,21 +10,18 @@ import { ClientMetaTypes } from './schema/ClientMetaTypes';
 import { parseJsonAs } from './common/utils';
 import { CalculatedScore } from './scores/CalculatedScore';
 import { Detectors } from './detectors/Detectors';
+import { clear } from 'console';
 
 const logger = createLogger('ObservedClient');
 
 export type ObservedClientSettings<AppData extends Record<string, unknown> = Record<string, unknown>> = {
 	clientId: string;
+	maxIdleTimeMs?: number;
 	appData?: AppData;
 };
 
 export type ObservedClientEvents = {
-	update: [
-		{
-			sample: ClientSample;
-			elapsedTimeInMs: number;
-		}
-	];
+	update: [sample: ClientSample, elapsedTimeInMs: number];
 	close: [];
 	joined: [];
 	issue: [ClientIssue];
@@ -33,8 +30,9 @@ export type ObservedClientEvents = {
 	left: [];
 	usingturn: [boolean];
 	usermediaerror: [string];
+	extensionStats: [ExtensionStat];
+	clientEvent: [ClientEvent];
 
-	// do we need this?
 	newpeerconnection: [ObservedPeerConnection];
 };
 
@@ -48,14 +46,12 @@ export declare interface ObservedClient {
 export class ObservedClient<AppData extends Record<string, unknown> = Record<string, unknown>> extends EventEmitter {
 	public readonly detectors: Detectors;
 
-	public readonly clientId: string;
 	public readonly observedPeerConnections = new Map<string, ObservedPeerConnection>();
 	public readonly calculatedScore: CalculatedScore = {
 		weight: 1,
 		value: undefined,
 	};
 
-	public appData: AppData;
 	public attachments?: Record<string, unknown>;
 
 	public updated = Date.now();
@@ -64,6 +60,8 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 
 	public joinedAt?: number;
 	public leftAt?: number;
+	public closedAt?: number;
+	public lastSampleTimestamp?: number;
 	// the timestamp of the CLIENT_JOINED event
 	public operationSystem?: MetaData.OperationSystem;
 	public engine?: MetaData.Engine;
@@ -136,15 +134,27 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 	public readonly mediaDevices: MetaData.MediaDeviceInfo[] = [];
 	public issues: ClientIssue[] = [];
 
-	public constructor(settings: ObservedClientSettings<AppData>, public readonly call: ObservedCall) {
+	private _injections: Pick<ClientSample, 'clientEvents' | 'clientIssues' | 'extensionStats' | 'attachments' | 'clientMetaItems'> = {};
+	private _autoCloseTimer?: ReturnType<typeof setTimeout>;
+
+	public constructor(
+		public readonly settings: ObservedClientSettings<AppData>, 
+		public readonly call: ObservedCall
+	) {
 		super();
 		this.setMaxListeners(Infinity);
+		this._createAutoClose();
 
-		this.clientId = settings.clientId;
-		this.appData = settings.appData ?? {} as AppData;
-		
 		this.detectors = new Detectors();
 	}
+
+	public get clientId() {	
+		return this.settings.clientId;
+	}
+
+	public get appData(): AppData {
+		return this.settings.appData ?? {} as AppData;
+	}
 	
 	public get numberOfPeerConnections() {
 		return this.observedPeerConnections.size;
@@ -158,13 +168,42 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 		if (this.closed) return;
 		this.closed = true;
 
+		this._injections.clientEvents?.forEach((clientEvent) => this._processClientEvent(clientEvent));
+		this._injections.clientIssues?.forEach((clientIssue) => this.addIssue(clientIssue));
+		this._injections.extensionStats?.forEach((extensionStat) => this.addExtensionStats(extensionStat));
+		this._injections.clientMetaItems?.forEach((clientMetaItem) => this.addMetadata(clientMetaItem));
+
 		Array.from(this.observedPeerConnections.values()).forEach((peerConnection) => peerConnection.close());
+		if (!this.leftAt) {
+			this.leftAt = this.lastSampleTimestamp;
+
+			if (this.leftAt) {
+				this.emit('left');
+			}
+		}
+		this.closedAt = Date.now();
 
 		this.emit('close');
 	}
 
+	private _createAutoClose() {
+		if (this.closed) return;
+		if (this.settings.maxIdleTimeMs === undefined || this.settings.maxIdleTimeMs < 1) return;
+
+		clearTimeout(this._autoCloseTimer);
+
+		this._autoCloseTimer = setTimeout(() => {
+			if (this.closed) return;
+
+			logger.debug(`Client ${this.clientId} is idle for ${this.settings.maxIdleTimeMs}ms, closing...`);
+			this.close();
+		}, this.settings.maxIdleTimeMs);
+	}
+
 	public accept(sample: ClientSample): void {
 		if (this.closed) throw new Error(`Client ${this.clientId} is closed`);
+		
+		this._createAutoClose();
 
 		const now = Date.now();
 		const elapsedInMs = now - this.updated;
@@ -204,9 +243,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 +325,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;
@@ -313,11 +360,12 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 		this.calculatedScore.value = sample.score;
 		this.detectors.update();
 
+		this.lastSampleTimestamp = sample.timestamp;
 		// emit update
-		this.emit('update', {
+		this.emit('update', 
 			sample,
-			elapsedTimeInMs: now - this.updated,
-		});
+			now - this.updated,
+		);
 		this.updated = now;
 
 		// if result changed after update
@@ -327,7 +375,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) {
@@ -343,6 +391,7 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 						logger.warn(`Client ${this.clientId} joinedAt timestamp was updated to ${event.timestamp}. the joined event will not be emitted.`);
 					}
 				}
+				logger.debug('Client %s joined at %o', this.clientId, event);
 				break;
 			}
 			case ClientEventTypes.CLIENT_LEFT: {
@@ -353,12 +402,262 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 					} else {
 						logger.warn(`Client ${this.clientId} leftAt timestamp was already set`);
 					}
+
+				}
+				logger.debug('Client %s left at %o', this.clientId, event);
+				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: %o', 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: %o', 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: %o', 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: %o', 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: %o', 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: %o', event);
+					}
+				}
+				break;
+			}
+			case ClientEventTypes.MEDIA_TRACK_MUTED: {
+				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 observedInboundTrack = observedPeerConnection?.observedInboundTracks.get(payload.trackId); 
+					const observedOutboundTrack = observedPeerConnection?.observedOutboundTracks.get(payload.trackId);
+
+					if (observedPeerConnection) {
+						if (observedInboundTrack) {
+							observedInboundTrack.muted = true;
+							observedPeerConnection?.emit('muted-inbound-track', observedInboundTrack);
+						} else if (observedOutboundTrack) {
+							observedOutboundTrack.muted = true;
+							observedPeerConnection?.emit('muted-outbound-track', observedOutboundTrack);
+						}
+					} else if (postBuffer) {
+						postBuffer.push(event);
+					} else {
+						logger.warn('Received MEDIA_TRACK_MUTED event without a corresponding observedPeerConnection or observedTrack: %o', event);
+					}
+				}
+
+				break;
+			}
+			case ClientEventTypes.MEDIA_TRACK_UNMUTED: {
+				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 observedInboundTrack = observedPeerConnection?.observedInboundTracks.get(payload.trackId); 
+					const observedOutboundTrack = observedPeerConnection?.observedOutboundTracks.get(payload.trackId);
+
+					if (observedPeerConnection) {
+						if (observedInboundTrack) {
+							observedInboundTrack.muted = false;
+							observedPeerConnection?.emit('unmuted-inbound-track', observedInboundTrack);
+						} else if (observedOutboundTrack) {
+							observedOutboundTrack.muted = false;
+							observedPeerConnection?.emit('unmuted-outbound-track', observedOutboundTrack);
+						}
+					} else if (postBuffer) {
+						postBuffer.push(event);
+					} else {
+						logger.warn('Received MEDIA_TRACK_UNMUTED event without a corresponding observedPeerConnection or observedTrack: %o', event);
+					}
+				}
+				break;
+			}
+			case ClientEventTypes.ICE_CONNECTION_STATE_CHANGED: {
+				const payload = parseJsonAs<Record<string, unknown>>(event.payload);
+
+				if (payload?.peerConnectionId && typeof payload.peerConnectionId === 'string' && payload?.iceConnectionState && typeof payload.iceConnectionState === 'string') {
+					const observedPeerConnection = this.observedPeerConnections.get(payload.peerConnectionId);
+
+					if (observedPeerConnection) {
+						observedPeerConnection.iceConnectionState = payload.iceConnectionState;
+						observedPeerConnection.emit('iceconnectionstatechange', {
+							state: payload.iceConnectionState,
+						});
+					} else if (postBuffer) {
+						postBuffer.push(event);
+					} else {
+						logger.warn('Received ICE_CONNECTION_STATE_CHANGED event without a corresponding observedPeerConnection: %o', event);
+					}
+				}
+				break;
+			}
+			case ClientEventTypes.ICE_GATHERING_STATE_CHANGED: {
+				const payload = parseJsonAs<Record<string, unknown>>(event.payload);
+
+				if (payload?.peerConnectionId && typeof payload.peerConnectionId === 'string' && payload?.iceGatheringState && typeof payload.iceGatheringState === 'string') {
+					const observedPeerConnection = this.observedPeerConnections.get(payload.peerConnectionId);
+
+					if (observedPeerConnection) {
+						observedPeerConnection.iceGatheringState = payload.iceGatheringState;
+						observedPeerConnection.emit('icegatheringstatechange', {
+							state: payload.iceGatheringState,
+						});
+					} else if (postBuffer) {
+						postBuffer.push(event);
+					} else {
+						logger.warn('Received ICE_GATHERING_STATE_CHANGED event without a corresponding observedPeerConnection: %o', event);
+					}
+				}
+				break;
+			}
+			case ClientEventTypes.PEER_CONNECTION_STATE_CHANGED: {
+				const payload = parseJsonAs<Record<string, unknown>>(event.payload);
+
+				if (payload?.peerConnectionId && typeof payload.peerConnectionId === 'string' && payload?.peerConnectionState && typeof payload.peerConnectionState === 'string') {
+					const observedPeerConnection = this.observedPeerConnections.get(payload.peerConnectionId);
+
+					if (observedPeerConnection) {
+						observedPeerConnection.connectionState = payload.peerConnectionState;
+						observedPeerConnection.emit('connectionstatechange', {
+							state: payload.peerConnectionState,
+						});
+					} else if (postBuffer) {
+						postBuffer.push(event);
+					} else {
+						logger.warn('Received PEER_CONNECTION_STATE_CHANGED event without a corresponding observedPeerConnection: %o', event);
+					}
 				}
 				break;
 			}
 		}
+		
+		this.emit('clientEvent', event);
+	}
+
+	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) {
@@ -395,6 +694,7 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 
 	public addExtensionStats(stats: ExtensionStat) {
 		this.call.observer.emit('client-extension-stats', this, stats);
+		this.emit('extensionStats', stats);
 	}
 
 	private _updatePeerConnection(sample: PeerConnectionSample): ObservedPeerConnection | undefined {
@@ -423,6 +723,47 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 		return observedPeerConnection;
 	}
 
+	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;