@observertc/observer-js 1.0.1-4daea92.0 → 1.0.1-5a1b94b.0

package/src/ObservedCall.ts

@@ -11,6 +11,9 @@ import { Updater } from './updaters/Updater';
 import { OnIntervalUpdater } from './updaters/OnIntervalUpdater';
 import { OnAnyClientCallUpdater } from './updaters/OnAnyClientCallUpdater';
 import { ObservedCallEventMonitor } from './ObservedCallEventMonitor';
+import { createLogger } from './common/logger';
+
+const logger = createLogger('ObservedCall');
 
 export type ObservedCallSettings<AppData extends Record<string, unknown> = Record<string, unknown>> = {
 	callId: string;
@@ -18,6 +21,7 @@ export type ObservedCallSettings<AppData extends Record<string, unknown> = Recor
 	remoteTrackResolvePolicy?: 'p2p' | 'mediasoup-sfu',
 	updatePolicy?: 'update-on-any-client-updated' | 'update-when-all-client-updated' | 'update-on-interval',
 	updateIntervalInMs?: number,
+	maxIdleIfEmptyMs?: number,
 };
 
 export type ObservedCallEvents = {
@@ -75,6 +79,20 @@ export class ObservedCall<AppData extends Record<string, unknown> = Record<strin
 	public maxNumberOfClients = 0;
 	public deltaNumberOfIssues = 0;
 
+	public deltaDataChannelBytesReceived = 0;
+	public deltaDataChannelBytesSent = 0;
+	public deltaDataChannelMessagesReceived = 0;
+	public deltaDataChannelMessagesSent = 0;
+	public deltaInboundPacketsLost = 0;
+	public deltaInboundPacketsReceived = 0;
+	public deltaOutboundPacketsSent = 0;
+	public deltaReceivedAudioBytes = 0;
+	public deltaReceivedVideoBytes = 0;
+	public deltaSentAudioBytes = 0;
+	public deltaSentVideoBytes = 0;
+	public deltaTransportReceivedBytes = 0;
+	public deltaTransportSentBytes = 0;
+
 	public deltaRttLt50Measurements = 0;
 	public deltaRttLt150Measurements = 0;
 	public deltaRttLt300Measurements = 0;
@@ -85,14 +103,10 @@ export class ObservedCall<AppData extends Record<string, unknown> = Record<strin
 	public startedAt?: number;
 	public endedAt?: number;
 	public closedAt?: number;
+	public lastClientTimestamp = 0;
 
-	private _callStartedEvent: {
-		emitted: boolean,
-		timer?: ReturnType<typeof setTimeout>,
-	};
-	private _callEndedEvent: {
-		emitted: boolean
-	};
+	public maxIdleIfEmptyMs?: number;
+	private _autoCloseTimer?: ReturnType<typeof setTimeout>;
 
 	public constructor(
 		settings: ObservedCallSettings<AppData>,
@@ -104,6 +118,7 @@ export class ObservedCall<AppData extends Record<string, unknown> = Record<strin
 		this.callId = settings.callId;
 		this.appData = settings.appData ?? {} as AppData;
 		this.scoreCalculator = new DefaultCallScoreCalculator(this);
+		this.maxIdleIfEmptyMs = settings.maxIdleIfEmptyMs;
 		this.detectors = new Detectors();
 		
 		if (settings.updateIntervalInMs) {
@@ -113,10 +128,10 @@ export class ObservedCall<AppData extends Record<string, unknown> = Record<strin
 		}
 		switch (settings.updatePolicy) {
 			case 'update-on-any-client-updated':
-				this.updater = new OnAllClientCallUpdater(this);	
+				this.updater = new OnAnyClientCallUpdater(this);	
 				break;
 			case 'update-when-all-client-updated':
-				this.updater = new OnAnyClientCallUpdater(this);	
+				this.updater = new OnAllClientCallUpdater(this);	
 				break;
 			case 'update-on-interval': 
 				if (!settings.updateIntervalInMs) {
@@ -133,13 +148,6 @@ export class ObservedCall<AppData extends Record<string, unknown> = Record<strin
 			case 'mediasoup-sfu':
 				break;
 		}
-
-		this._callStartedEvent = {
-			emitted: false,
-		};
-		this._callEndedEvent = {
-			emitted: false,
-		};
 	}
 
 	public get numberOfClients() {
@@ -157,7 +165,18 @@ export class ObservedCall<AppData extends Record<string, unknown> = Record<strin
 
 		this.updater?.close();
 
-		[ ...this.observedClients.values() ].forEach((client) => client.close());
+		let minSampleTimestamps: number | undefined;
+		let maxSampleTimestamps: number | undefined;
+
+		for (const client of this.observedClients.values()) {
+			client.close();
+
+			if (client.joinedAt) minSampleTimestamps = Math.min(minSampleTimestamps ?? client.joinedAt, client.joinedAt);
+			if (client.leftAt) maxSampleTimestamps = Math.max(maxSampleTimestamps ?? client.leftAt, client.leftAt);
+		}
+
+		if (this.startedAt === undefined) this.startedAt = minSampleTimestamps;
+		if (this.endedAt === undefined) this.endedAt = maxSampleTimestamps;
 
 		this.closedAt = Date.now();
 		this.emit('close');
@@ -187,6 +206,8 @@ export class ObservedCall<AppData extends Record<string, unknown> = Record<strin
 
 			if (this.observedClients.size === 0) {
 				this.emit('empty');
+
+				this._createAutoClose();
 			}
 			++this.totalRemovedClients;
 		});
@@ -202,6 +223,9 @@ export class ObservedCall<AppData extends Record<string, unknown> = Record<strin
 
 		if (wasEmpty) {
 			this.emit('not-empty');
+
+			clearTimeout(this._autoCloseTimer);
+			this._autoCloseTimer = undefined;
 		}
 		
 		return result;
@@ -229,6 +253,8 @@ export class ObservedCall<AppData extends Record<string, unknown> = Record<strin
 		this.detectors.update();
 		this.scoreCalculator.update();
 
+		this.lastClientTimestamp = Math.max(...Array.from(this.observedClients.values()).map((c) => c.lastSampleTimestamp ?? 0));
+
 		this.emit('update');
 
 		this.deltaNumberOfIssues = 0;
@@ -236,6 +262,20 @@ export class ObservedCall<AppData extends Record<string, unknown> = Record<strin
 		this.deltaRttLt150Measurements = 0;
 		this.deltaRttLt300Measurements = 0;
 		this.deltaRttGtOrEq300Measurements = 0;
+		
+		this.deltaDataChannelBytesReceived = 0;
+		this.deltaDataChannelBytesSent = 0;
+		this.deltaDataChannelMessagesReceived = 0;
+		this.deltaDataChannelMessagesSent = 0;
+		this.deltaInboundPacketsLost = 0;
+		this.deltaInboundPacketsReceived = 0;
+		this.deltaOutboundPacketsSent = 0;
+		this.deltaReceivedAudioBytes = 0;
+		this.deltaReceivedVideoBytes = 0;
+		this.deltaSentAudioBytes = 0;
+		this.deltaSentVideoBytes = 0;
+		this.deltaTransportReceivedBytes = 0;
+		this.deltaTransportSentBytes = 0;
 	}
 
 	private _onClientUpdate(client: ObservedClient) {
@@ -278,6 +318,19 @@ export class ObservedCall<AppData extends Record<string, unknown> = Record<strin
 		this.endedAt = Math.max(this.endedAt ?? client.leftAt, client.leftAt);
 	}
 
+	private _createAutoClose() {
+		if (this.closed) return;
+		if (this.maxIdleIfEmptyMs === undefined || this.maxIdleIfEmptyMs < 1) return;
+
+		this._autoCloseTimer = setTimeout(() => {
+			if (this.closed) return;
+			if (this.observedClients.size > 0) return;
+
+			logger.debug(`Call ${this.callId} is empty for ${this.maxIdleIfEmptyMs}ms, closing...`);
+			this.close();
+		}, this.maxIdleIfEmptyMs);
+	}
+
 	// public resetSummaryMetrics() {
 	// 	this.totalAddedClients = 0;
 	// 	this.totalRemovedClients = 0;

package/src/ObservedCallEventMonitor.ts

@@ -1,18 +1,18 @@
 import { ObservedCall } from './ObservedCall';
-import { ObservedCertificate } from './ObservedCertificate';
+import { ObservedCertificate } from './webrtc/ObservedCertificate';
 import { ObservedClient, ObservedClientEvents } 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 { ObservedCodec } from './webrtc/ObservedCodec';
+import { ObservedDataChannel } from './webrtc/ObservedDataChannel';
+import { ObservedIceCandidate } from './webrtc/ObservedIceCandidate';
+import { ObservedIceCandidatePair } from './webrtc/ObservedIceCandidatePair';
+import { ObservedIceTransport } from './webrtc/ObservedIceTransport';
+import { ObservedInboundRtp } from './webrtc/ObservedInboundRtp';
+import { ObservedInboundTrack } from './webrtc/ObservedInboundTrack';
+import { ObservedMediaPlayout } from './webrtc/ObservedMediaPlayout';
+import { ObservedMediaSource } from './webrtc/ObservedMediaSource';
+import { ObservedOutboundRtp } from './webrtc/ObservedOutboundRtp';
+import { ObservedOutboundTrack } from './webrtc/ObservedOutboundTrack';
+import { ObservedPeerConnection } from './webrtc/ObservedPeerConnection';
 import { ClientEvent, ClientIssue, ClientMetaData, ClientSample, ExtensionStat } from './schema/ClientSample';
 
 export class ObservedCallEventMonitor<Context> {
@@ -61,6 +61,7 @@ export class ObservedCallEventMonitor<Context> {
 	}
 
 	// Public event handlers
+	public onCallClosed?: (call: ObservedCall, ctx: Context) => void;
 	public onCallEmpty?: (call: ObservedCall, ctx: Context) => void;
 	public onCallNotEmpty?: (call: ObservedCall, ctx: Context) => void;
 	public onCallUpdated?: (call: ObservedCall, ctx: Context) => void;
@@ -132,6 +133,8 @@ export class ObservedCallEventMonitor<Context> {
 			call.off('not-empty', onCallNotEmpty);
 			call.off('update', onCallUpdated);
 
+			this.onCallClosed?.(call, this.context);
+
 		});
 		call.on('newclient', this._onClientAdded);
 		call.on('empty', onCallEmpty);
@@ -149,7 +152,7 @@ export class ObservedCallEventMonitor<Context> {
 		const onClientExtensionStats = (extensionStats: ExtensionStat) => this._onClientExtensionStats(observedClient, extensionStats);
 		const onUsingTurn = (usingTurn: boolean) => this._onUsingTurn(observedClient, usingTurn);
 		const onUserMediaError = (error: string) => this._onUserMediaError(observedClient, error);
-		const onClientUpdated = (...args: ObservedClientEvents['update']) => this.onClientUpdated?.(observedClient, args[0].sample, this.context);
+		const onClientUpdated = (...args: ObservedClientEvents['update']) => this.onClientUpdated?.(observedClient, args[0], this.context);
 		const onClientEvent = (event: ClientEvent) => this.onClientEvent?.(observedClient, event, this.context);
 
 		observedClient.once('close', () => {

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,19 @@ import { ClientMetaTypes } from './schema/ClientMetaTypes';
 import { parseJsonAs } from './common/utils';
 import { CalculatedScore } from './scores/CalculatedScore';
 import { Detectors } from './detectors/Detectors';
+import { clear } from 'console';
+import { ParsedUserAgent } from './common/types';
 
 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];
@@ -49,14 +47,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();
@@ -66,6 +62,7 @@ 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;
@@ -139,16 +136,26 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 	public issues: ClientIssue[] = [];
 
 	private _injections: Pick<ClientSample, 'clientEvents' | 'clientIssues' | 'extensionStats' | 'attachments' | 'clientMetaItems'> = {};
+	private _autoCloseTimer?: ReturnType<typeof setTimeout>;
 
-	public constructor(settings: ObservedClientSettings<AppData>, public readonly call: ObservedCall) {
+	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;
@@ -162,15 +169,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;
@@ -327,11 +361,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
@@ -357,6 +392,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: {
@@ -367,7 +403,9 @@ 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: {
@@ -381,7 +419,7 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 					} else if (postBuffer) {
 						postBuffer.push(event);
 					} else {
-						logger.warn('Received PEER_CONNECTION_OPENED event without a corresponding observedPeerConnection', event);
+						logger.warn('Received PEER_CONNECTION_OPENED event without a corresponding observedPeerConnection: %o', event);
 					}
 					
 				}
@@ -398,7 +436,7 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 					} else if (postBuffer) {
 						postBuffer.push(event);
 					} else {
-						logger.warn('Received PEER_CONNECTION_CLOSED event without a corresponding observedPeerConnection', event);
+						logger.warn('Received PEER_CONNECTION_CLOSED event without a corresponding observedPeerConnection: %o', event);
 					}
 				}
 				break;
@@ -415,7 +453,7 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 					} else if (postBuffer) {
 						postBuffer.push(event);
 					} else {
-						logger.warn('Received MEDIA_TRACK_ADDED event without a corresponding observedPeerConnection or observedTrack', event);
+						logger.warn('Received MEDIA_TRACK_ADDED event without a corresponding observedPeerConnection or observedTrack: %o', event);
 					}
 				}
 				break;
@@ -432,7 +470,7 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 					} else if (postBuffer) {
 						postBuffer.push(event);
 					} else {
-						logger.warn('Received MEDIA_TRACK_REMOVED event without a corresponding observedPeerConnection or observedTrack', event);
+						logger.warn('Received MEDIA_TRACK_REMOVED event without a corresponding observedPeerConnection or observedTrack: %o', event);
 					}
 				}
 				break;
@@ -449,7 +487,7 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 					} else if (postBuffer) {
 						postBuffer.push(event);
 					} else {
-						logger.warn('Received DATA_CHANNEL_OPENED event without a corresponding observedPeerConnection or observedDataChannel', event);
+						logger.warn('Received DATA_CHANNEL_OPENED event without a corresponding observedPeerConnection or observedDataChannel: %o', event);
 					}
 				}
 				break;
@@ -466,12 +504,119 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 					} else if (postBuffer) {
 						postBuffer.push(event);
 					} else {
-						logger.warn('Received DATA_CHANNEL_CLOSE event without a corresponding observedPeerConnection or observedDataChannel', event);
+						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);
 	}
 
@@ -536,6 +681,34 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 				this.operationSystem = parseJsonAs(metadata.payload);
 				break;
 			}
+			case 'USER_AGENT_DATA': {
+				try {
+					const userAgentData = parseJsonAs<ParsedUserAgent>(metadata.payload);
+					if (userAgentData) {
+						if (this.operationSystem === undefined) {
+							this.operationSystem = {
+								name: userAgentData.os.name.toLowerCase(),
+								version: userAgentData.os.version,
+							};
+						}
+						if (this.engine === undefined) {
+							this.engine = {
+								name: userAgentData.engine.name.toLowerCase(),
+								version: userAgentData.engine.version,
+							};
+						}
+						if (this.browser === undefined) {
+							this.browser = {
+								name: userAgentData.browser.name.toLowerCase(),
+								version: userAgentData.browser.version,
+							};
+						}
+					}
+					
+				} catch (error) {
+					logger.warn('Failed to parse USER_AGENT_DATA metadata: %o', error);
+				}
+			}
 		}
 
 		this.call.observer.emit('client-metadata', this, metadata);