@observertc/observer-js 1.0.1-72a904d.0 → 1.0.1-9341fcd.0

package/src/ObservedClient.ts

@@ -7,10 +7,9 @@ import * as MetaData from './schema/ClientMetaTypes';
 import { ClientEventTypes } from './schema/ClientEventTypes';
 import { ObservedCall } from './ObservedCall';
 import { ClientMetaTypes } from './schema/ClientMetaTypes';
-import { getMedian, parseJsonAs } from './common/utils';
+import { parseJsonAs } from './common/utils';
 import { CalculatedScore } from './scores/CalculatedScore';
 import { Detectors } from './detectors/Detectors';
-import { ObservedClientSummary } from './ObservedClientSummary';
 
 const logger = createLogger('ObservedClient');
 
@@ -34,8 +33,9 @@ export type ObservedClientEvents = {
 	left: [];
 	usingturn: [boolean];
 	usermediaerror: [string];
+	extensionStats: [ExtensionStat];
+	clientEvent: [ClientEvent];
 
-	// do we need this?
 	newpeerconnection: [ObservedPeerConnection];
 };
 
@@ -65,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;
@@ -73,8 +74,10 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 	public mediaConstraints: string[] = [];
 
 	public usingTURN = false;
+	public usingTCP = false;
 	public availableOutgoingBitrate = 0;
 	public availableIncomingBitrate = 0;
+
 	public totalInboundPacketsLost = 0;
 	public totalInboundPacketsReceived = 0;
 	public totalOutboundPacketsSent = 0;
@@ -100,7 +103,6 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 	public deltaInboundPacketsLost = 0;
 	public deltaInboundPacketsReceived = 0;
 	public deltaOutboundPacketsSent = 0;
-	public deltaRttInMsMeasurements: number[] = [];
 	public deltaTransportSentBytes = 0;
 	public deltaTransportReceivedBytes = 0;
 	public deltaRttLt50Measurements = 0;
@@ -108,7 +110,10 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 	public deltaRttLt300Measurements = 0;
 	public deltaRttGtOrEq300Measurements = 0;
 
-	public currentRttInMs?: number;
+	public currentMaxRttInMs?: number;
+	public currentMinRttInMs?: number;
+	public currentAvgRttInMs?: number;
+
 	public sendingAudioBitrate = 0;
 	public sendingVideoBitrate = 0;
 	public receivingAudioBitrate = 0;
@@ -128,11 +133,13 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 
 	public totalScoreSum = 0;
 	public numberOfScoreMeasurements = 0;
-	public numberOfIssues = 0;
+	public totalNumberOfIssues = 0;
 
 	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);
@@ -157,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');
 	}
 
@@ -166,7 +175,9 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 		const now = Date.now();
 		const elapsedInMs = now - this.updated;
 		const elapsedInSeconds = elapsedInMs / 1000;
-
+		let sumOfRtts = 0;
+		let numberOfRttMeasurements = 0;
+		
 		++this.acceptedSamples;
 		
 		this.availableIncomingBitrate = 0;
@@ -184,7 +195,6 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 		this.deltaSentVideoBytes = 0;
 		this.deltaTransportReceivedBytes = 0;
 		this.deltaTransportSentBytes = 0;
-		this.deltaRttInMsMeasurements = [];
 		this.deltaRttLt50Measurements = 0;
 		this.deltaRttLt150Measurements = 0;
 		this.deltaRttLt300Measurements = 0;
@@ -196,14 +206,95 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 		this.numberOfInbundTracks = 0;
 		this.numberOfOutboundRtpStreams = 0;
 		this.numberOfOutboundTracks = 0;
-		
-		sample.clientEvents?.forEach(this._processClientEvent.bind(this));
-		sample.clientMetaItems?.forEach(this.addMetadata.bind(this));
-		sample.clientIssues?.forEach(this.addIssue.bind(this));
-		sample.peerConnections?.forEach(this._updatePeerConnection.bind(this));
-		sample.extensionStats?.forEach(this.addExtensionStats.bind(this));
+		this.usingTURN = false;
+		this.usingTCP = false;
+		this.currentMinRttInMs = undefined;
+		this.currentMaxRttInMs = undefined;
+
+		this._mergeInjections(sample);
 
-		this._updateRttMeasurements();
+		const clientEventsPostBuffer: ClientEvent[] = [];
+
+		for (const clientEvent of sample.clientEvents ?? []) {
+			this._processClientEvent(clientEvent, clientEventsPostBuffer);
+
+			this.call.observer.emit('client-event', this, clientEvent);
+		}
+
+		for (const metaData of sample.clientMetaItems ?? []) {
+			this.addMetadata(metaData);
+		}
+
+		for (const issue of sample.clientIssues ?? []) {
+			this.addIssue(issue);
+
+			++this.deltaNumberOfIssues;
+		}
+
+		for (const extensionStat of sample.extensionStats ?? []) {
+			this.addExtensionStats(extensionStat);
+		}
+
+		for (const pcSample of sample.peerConnections ?? []) {
+			const observedPeerConnection = this._updatePeerConnection(pcSample);
+
+			if (!observedPeerConnection) continue;
+
+			this.deltaDataChannelBytesReceived += observedPeerConnection.deltaDataChannelBytesReceived;
+			this.deltaDataChannelBytesSent += observedPeerConnection.deltaDataChannelBytesSent;
+			this.deltaDataChannelMessagesReceived += observedPeerConnection.deltaDataChannelMessagesReceived;
+			this.deltaDataChannelMessagesSent += observedPeerConnection.deltaDataChannelMessagesSent;
+			this.deltaInboundPacketsLost += observedPeerConnection.deltaInboundPacketsLost;
+			this.deltaInboundPacketsReceived += observedPeerConnection.deltaInboundPacketsReceived;
+			this.deltaOutboundPacketsSent += observedPeerConnection.deltaOutboundPacketsSent;
+			this.deltaReceivedAudioBytes += observedPeerConnection.deltaReceivedAudioBytes;
+			this.deltaReceivedVideoBytes += observedPeerConnection.deltaReceivedVideoBytes;
+			this.deltaSentAudioBytes += observedPeerConnection.deltaSentAudioBytes;
+			this.deltaSentVideoBytes += observedPeerConnection.deltaSentVideoBytes;
+			this.deltaTransportReceivedBytes += observedPeerConnection.deltaTransportReceivedBytes;
+			this.deltaTransportSentBytes += observedPeerConnection.deltaTransportSentBytes;
+			
+			this.availableIncomingBitrate += observedPeerConnection.availableIncomingBitrate;
+			this.availableOutgoingBitrate += observedPeerConnection.availableOutgoingBitrate;
+
+			this.numberOfDataChannels += observedPeerConnection.observedDataChannels.size;
+			this.numberOfInbundTracks += observedPeerConnection.observedInboundTracks.size;
+			this.numberOfOutboundRtpStreams += observedPeerConnection.observedOutboundRtps.size;
+			this.numberOfOutboundTracks += observedPeerConnection.observedOutboundTracks.size;
+			this.numberOfInboundRtpStreams += observedPeerConnection.observedInboundRtps.size;
+
+			if (observedPeerConnection.usingTURN) {
+				this.usingTURN = true;
+			}
+			if (observedPeerConnection.usingTCP) {
+				this.usingTCP = true;
+			}
+
+			if (observedPeerConnection.currentRttInMs) {
+				if (this.currentMinRttInMs === undefined || observedPeerConnection.currentRttInMs < this.currentMinRttInMs) {
+					this.currentMinRttInMs = observedPeerConnection.currentRttInMs;
+				}
+				if (this.currentMaxRttInMs === undefined || observedPeerConnection.currentRttInMs > this.currentMaxRttInMs) {
+					this.currentMaxRttInMs = observedPeerConnection.currentRttInMs;
+				}
+				if (observedPeerConnection.currentRttInMs < 50) {
+					this.deltaRttLt50Measurements += 1;
+				} else if (observedPeerConnection.currentRttInMs < 150) {
+					this.deltaRttLt150Measurements += 1;
+				} else if (observedPeerConnection.currentRttInMs < 300) {
+					this.deltaRttLt300Measurements += 1;
+				} else if (300 <= observedPeerConnection.currentRttInMs) {
+					this.deltaRttGtOrEq300Measurements += 1;
+				}
+
+				sumOfRtts += observedPeerConnection.currentRttInMs;
+				++numberOfRttMeasurements;
+			}
+		}
+
+		for (const clientEvent of clientEventsPostBuffer) {
+			this._processClientEvent(clientEvent);
+		}
 
 		// emit new attachments?
 		this.attachments = sample.attachments;
@@ -225,12 +316,13 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 		this.totalRttLt150Measurements += this.deltaRttLt150Measurements;
 		this.totalRttLt300Measurements += this.deltaRttLt300Measurements;
 		this.totalRttGtOrEq300Measurements += this.deltaRttGtOrEq300Measurements;
-		this.numberOfIssues += this.deltaNumberOfIssues;
+		this.totalNumberOfIssues += this.deltaNumberOfIssues;
 
 		this.receivingAudioBitrate = (this.deltaReceivedAudioBytes * 8) / (elapsedInSeconds);
 		this.receivingVideoBitrate = (this.totalReceivedVideoBytes * 8) / (elapsedInSeconds);
 		this.sendingAudioBitrate = (this.deltaSentAudioBytes * 8) / (elapsedInSeconds);
 		this.sendingVideoBitrate = (this.deltaSentVideoBytes * 8) / (elapsedInSeconds);
+		this.currentAvgRttInMs = 0 < numberOfRttMeasurements ? sumOfRtts / numberOfRttMeasurements : undefined;
 
 		this.calculatedScore.value = sample.score;
 		this.detectors.update();
@@ -249,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) {
@@ -278,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;
+			}
 		}
+		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._injections.clientEvents.push(event);
+	}
+
+	public injectIssue(issue: ClientIssue) {
+		if (this.closed) return;
+
+		if (!this._injections.clientIssues) this._injections.clientIssues = [];
+
+		this._injections.clientIssues.push(issue);
+	}
 
-		this.call.observer.emit('client-event', this, event);
+	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) {
@@ -311,24 +544,24 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 	public addIssue(issue: ClientIssue) {
 		if (this.closed) return;
 
-		++this.deltaNumberOfIssues;
 		this.emit('issue', issue);
 		this.call.observer.emit('client-issue', this, issue);
 	}
 
 	public addExtensionStats(stats: ExtensionStat) {
 		this.call.observer.emit('client-extension-stats', this, stats);
+		this.emit('extensionStats', stats);
 	}
 
-	private _updatePeerConnection(sample: PeerConnectionSample) {
+	private _updatePeerConnection(sample: PeerConnectionSample): ObservedPeerConnection | undefined {
 		let observedPeerConnection = this.observedPeerConnections.get(sample.peerConnectionId);
 
 		if (!observedPeerConnection) {
 			if (!sample.peerConnectionId) {
-				return logger.warn(
+				return (logger.warn(
 					`ObservedClient received an invalid PeerConnectionSample (missing peerConnectionId field). ClientId: ${this.clientId}, CallId: ${this.call.callId}`,
 					sample
-				);
+				), void 0);
 			}
 
 			observedPeerConnection = new ObservedPeerConnection(sample.peerConnectionId, this);
@@ -343,107 +576,95 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 
 		observedPeerConnection.accept(sample);
 
-		observedPeerConnection.currentRttInMs;
-
-		this.deltaDataChannelBytesReceived += observedPeerConnection.deltaDataChannelBytesReceived;
-		this.deltaDataChannelBytesSent += observedPeerConnection.deltaDataChannelBytesSent;
-		this.deltaDataChannelMessagesReceived += observedPeerConnection.deltaDataChannelMessagesReceived;
-		this.deltaDataChannelMessagesSent += observedPeerConnection.deltaDataChannelMessagesSent;
-		this.deltaInboundPacketsLost += observedPeerConnection.deltaInboundPacketsLost;
-		this.deltaInboundPacketsReceived += observedPeerConnection.deltaInboundPacketsReceived;
-		this.deltaOutboundPacketsSent += observedPeerConnection.deltaOutboundPacketsSent;
-		this.deltaReceivedAudioBytes += observedPeerConnection.deltaReceivedAudioBytes;
-		this.deltaReceivedVideoBytes += observedPeerConnection.deltaReceivedVideoBytes;
-		this.deltaSentAudioBytes += observedPeerConnection.deltaSentAudioBytes;
-		this.deltaSentVideoBytes += observedPeerConnection.deltaSentVideoBytes;
-		this.deltaTransportReceivedBytes += observedPeerConnection.deltaTransportReceivedBytes;
-		this.deltaTransportSentBytes += observedPeerConnection.deltaTransportSentBytes;
-
-		this.availableIncomingBitrate += observedPeerConnection.availableIncomingBitrate;
-		this.availableOutgoingBitrate += observedPeerConnection.availableOutgoingBitrate;
-
-		this.numberOfDataChannels += observedPeerConnection.observedDataChannels.size;
-		this.numberOfInbundTracks += observedPeerConnection.observedInboundTracks.size;
-		this.numberOfOutboundRtpStreams += observedPeerConnection.observedOutboundRtps.size;
-		this.numberOfOutboundTracks += observedPeerConnection.observedOutboundTracks.size;
-		this.numberOfInboundRtpStreams += observedPeerConnection.observedInboundRtps.size;
-
-		if (observedPeerConnection.currentRttInMs) {
-			this.deltaRttInMsMeasurements.push(observedPeerConnection.currentRttInMs);
-		}
+		return observedPeerConnection;
 	}
 
-	public resetSummaryMetrics() {
-		this.totalDataChannelBytesReceived = 0;
-		this.totalDataChannelBytesSent = 0;
-		this.totalDataChannelMessagesReceived = 0;
-		this.totalDataChannelMessagesSent = 0;
-		this.totalInboundPacketsLost = 0;
-		this.totalInboundPacketsReceived = 0;
-		this.totalOutboundPacketsSent = 0;
-		this.totalReceivedAudioBytes = 0;
-		this.totalReceivedVideoBytes = 0;
-		this.totalSentAudioBytes = 0;
-		this.totalSentVideoBytes = 0;
-		this.totalSentBytes = 0;
-		this.totalReceivedBytes = 0;
-		
-		this.numberOfIssues = 0;
-		
-		this.totalScoreSum = 0;
-		this.numberOfScoreMeasurements = 0;
-	}
+	private _mergeInjections(sample: ClientSample): ClientSample {
+		if (this.closed) return sample;
 
-	public createSummary(): ObservedClientSummary {
-		return {
-			totalRttLt50Measurements: this.totalRttLt50Measurements,
-			totalRttLt150Measurements: this.totalRttLt150Measurements,
-			totalRttLt300Measurements: this.totalRttLt300Measurements,
-			totalRttGtOrEq300Measurements: this.totalRttGtOrEq300Measurements,
-			totalDataChannelBytesReceived: this.totalDataChannelBytesReceived,
-			totalDataChannelBytesSent: this.totalDataChannelBytesSent,
-			totalDataChannelMessagesReceived: this.totalDataChannelMessagesReceived,
-			totalDataChannelMessagesSent: this.totalDataChannelMessagesSent,
-			totalInboundPacketsLost: this.totalInboundPacketsLost,
-			totalInboundPacketsReceived: this.totalInboundPacketsReceived,
-			totalOutboundPacketsSent: this.totalOutboundPacketsSent,
-			totalReceivedAudioBytes: this.totalReceivedAudioBytes,
-			totalReceivedVideoBytes: this.totalReceivedVideoBytes,
-			totalSentAudioBytes: this.totalSentAudioBytes,
-			totalSentVideoBytes: this.totalSentVideoBytes,
-			totalSentBytes: this.totalSentBytes,
-			totalReceivedBytes: this.totalReceivedBytes,
+		if (this._injections.clientEvents) {
+			if (!sample.clientEvents) sample.clientEvents = [];
+			sample.clientEvents.push(...this._injections.clientEvents);
 			
-			numberOfIssues: this.numberOfIssues,
-
-			totalScoreSum: this.totalScoreSum,
-			numberOfScoreMeasurements: this.numberOfScoreMeasurements,
-		};
-	}
-
-	private _updateRttMeasurements() {
-		if (this.deltaRttInMsMeasurements.length < 1) {
-			this.currentRttInMs = undefined;
+			this._injections.clientEvents = undefined;
+		}
 
-			return;
+		if (this._injections.clientIssues) {
+			if (!sample.clientIssues) sample.clientIssues = [];
+			sample.clientIssues.push(...this._injections.clientIssues);
+			
+			this._injections.clientIssues = undefined;
 		}
-		this.currentRttInMs = getMedian(this.deltaRttInMsMeasurements, false);
 
-		if (this.currentRttInMs < 0) {
-			logger.warn(`Current Rtt for client ${this.clientId} is smaller than 0`);
-			this.currentRttInMs = undefined;
+		if (this._injections.extensionStats) {
+			if (!sample.extensionStats) sample.extensionStats = [];
+			sample.extensionStats.push(...this._injections.extensionStats);
+			
+			this._injections.extensionStats = undefined;
+		}
 
-			return;
+		if (this._injections.attachments) {
+			if (!sample.attachments) sample.attachments = {};
+			Object.assign(sample.attachments, this._injections.attachments);
+			
+			this._injections.attachments = undefined;
 		}
-		
-		if (this.currentRttInMs < 50) {
-			this.deltaRttLt50Measurements += 1;
-		} else if (this.currentRttInMs < 150) {
-			this.deltaRttLt150Measurements += 1;
-		} else if (this.currentRttInMs < 300) {
-			this.deltaRttLt300Measurements += 1;
-		} else if (300 <= this.currentRttInMs) {
-			this.deltaRttGtOrEq300Measurements += 1;
+
+		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;
+	// 	this.totalDataChannelMessagesReceived = 0;
+	// 	this.totalDataChannelMessagesSent = 0;
+	// 	this.totalInboundPacketsLost = 0;
+	// 	this.totalInboundPacketsReceived = 0;
+	// 	this.totalOutboundPacketsSent = 0;
+	// 	this.totalReceivedAudioBytes = 0;
+	// 	this.totalReceivedVideoBytes = 0;
+	// 	this.totalSentAudioBytes = 0;
+	// 	this.totalSentVideoBytes = 0;
+	// 	this.totalSentBytes = 0;
+	// 	this.totalReceivedBytes = 0;
+		
+	// 	this.totalNumberOfIssues = 0;
+		
+	// 	this.totalScoreSum = 0;
+	// 	this.numberOfScoreMeasurements = 0;
+	// }
+
+	// public createSummary(): ObservedClientSummary {
+	// 	return {
+	// 		totalRttLt50Measurements: this.totalRttLt50Measurements,
+	// 		totalRttLt150Measurements: this.totalRttLt150Measurements,
+	// 		totalRttLt300Measurements: this.totalRttLt300Measurements,
+	// 		totalRttGtOrEq300Measurements: this.totalRttGtOrEq300Measurements,
+	// 		totalDataChannelBytesReceived: this.totalDataChannelBytesReceived,
+	// 		totalDataChannelBytesSent: this.totalDataChannelBytesSent,
+	// 		totalDataChannelMessagesReceived: this.totalDataChannelMessagesReceived,
+	// 		totalDataChannelMessagesSent: this.totalDataChannelMessagesSent,
+	// 		totalInboundPacketsLost: this.totalInboundPacketsLost,
+	// 		totalInboundPacketsReceived: this.totalInboundPacketsReceived,
+	// 		totalOutboundPacketsSent: this.totalOutboundPacketsSent,
+	// 		totalReceivedAudioBytes: this.totalReceivedAudioBytes,
+	// 		totalReceivedVideoBytes: this.totalReceivedVideoBytes,
+	// 		totalSentAudioBytes: this.totalSentAudioBytes,
+	// 		totalSentVideoBytes: this.totalSentVideoBytes,
+	// 		totalSentBytes: this.totalSentBytes,
+	// 		totalReceivedBytes: this.totalReceivedBytes,
+			
+	// 		numberOfIssues: this.totalNumberOfIssues,
+
+	// 		totalScoreSum: this.totalScoreSum,
+	// 		numberOfScoreMeasurements: this.numberOfScoreMeasurements,
+	// 	};
+	// }
 }