@observertc/observer-js 1.0.0-beta.2 → 1.0.0-beta.3

package/src/ObservedClient.ts

@@ -10,6 +10,9 @@ import { ClientMetaTypes } from './schema/ClientMetaTypes';
 import { parseJsonAs } from './common/utils';
 import { CalculatedScore } from './scores/CalculatedScore';
 import { Detectors } from './detectors/Detectors';
+import { ClientReport, TrackReport } from './Reports';
+import { ObservedInboundTrack } from './ObservedInboundTrack';
+import { ObservedOutboundTrack } from './ObservedOutboundTrack';
 
 const logger = createLogger('ObservedClient');
 
@@ -33,6 +36,8 @@ export type ObservedClientEvents = {
 	clientEvent: [ClientEvent];
 
 	newpeerconnection: [ObservedPeerConnection];
+
+	trackreport: [TrackReport];
 };
 
 export declare interface ObservedClient {
@@ -77,20 +82,24 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 	public availableOutgoingBitrate = 0;
 	public availableIncomingBitrate = 0;
 
-	public totalInboundPacketsLost = 0;
-	public totalInboundPacketsReceived = 0;
-	public totalOutboundPacketsSent = 0;
-	public totalDataChannelBytesSent = 0;
-	public totalDataChannelBytesReceived = 0;
-	public totalDataChannelMessagesSent = 0;
-	public totalDataChannelMessagesReceived = 0;
-	public totalReceivedAudioBytes = 0;
-	public totalReceivedVideoBytes = 0;
-	public totalSentAudioBytes = 0;
-	public totalSentVideoBytes = 0;
-	public totalSentBytes = 0;
-	public totalReceivedBytes = 0;
-
+	// public totalInboundPacketsLost = 0;
+	// public totalInboundPacketsReceived = 0;
+	// public totalOutboundPacketsSent = 0;
+	// public totalDataChannelBytesSent = 0;
+	// public totalDataChannelBytesReceived = 0;
+	// public totalDataChannelMessagesSent = 0;
+	// public totalDataChannelMessagesReceived = 0;
+	// public totalReceivedAudioBytes = 0;
+	// public totalReceivedVideoBytes = 0;
+	// public totalSentAudioBytes = 0;
+	// public totalSentVideoBytes = 0;
+	// public totalSentBytes = 0;
+	// public totalReceivedBytes = 0;
+	// public totalRttLt50Measurements = 0;
+	// public totalRttLt150Measurements = 0;
+	// public totalRttLt300Measurements = 0;
+	// public totalRttGtOrEq300Measurements = 0;
+	
 	public deltaReceivedAudioBytes = 0;
 	public deltaReceivedVideoBytes = 0;
 	public deltaSentAudioBytes = 0;
@@ -124,15 +133,13 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 	public numberOfOutboundTracks = 0;
 	public numberOfDataChannels = 0;
 
-	public totalRttLt50Measurements = 0;
-	public totalRttLt150Measurements = 0;
-	public totalRttLt300Measurements = 0;
-	public totalRttGtOrEq300Measurements = 0;
 	public deltaNumberOfIssues = 0;
 
 	public totalScoreSum = 0;
 	public numberOfScoreMeasurements = 0;
-	public totalNumberOfIssues = 0;
+	// public totalNumberOfIssues = 0;
+
+	public readonly report: ClientReport;
 
 	public readonly mediaDevices: MetaData.MediaDeviceInfo[] = [];
 	public issues: ClientIssue[] = [];
@@ -152,6 +159,44 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 		this.settings = {
 			closeClientIfIdleForMs: settings.closeClientIfIdleForMs,
 		};
+
+		this.report = {
+			callId: this.call.callId,
+			clientId: this.clientId,
+			rttDistribution: {
+				gtOrEq300ms: 0,
+				lt50ms: 0,
+				lt150ms: 0,
+				lt300ms: 0,
+				count: 0,
+				sum: 0,
+			},
+			scoreDistribution: {
+				'0': 0,
+				'1': 0,
+				'2': 0,
+				'3': 0,
+				'4': 0,
+				'5': 0,
+				count: 0,
+				sum: 0,
+			},
+			issues: {},
+			totalAudioBytesReceived: 0,
+			totalVideoBytesReceived: 0,
+			totalAudioBytesSent: 0,
+			totalVideoBytesSent: 0,
+			totalDataChannelBytesReceived: 0,
+			totalDataChannelBytesSent: 0,
+			totalDataChannelMessagesReceived: 0,
+			totalDataChannelMessagesSent: 0,
+			totalInboundRtpBytesReceived: 0,
+			totalInboundRtpPacketsLost: 0,
+			totalInboundRtpPacketsReceived: 0,
+			totalOutboundRtpBytesSent: 0,
+			totalOutboundRtpPacketsSent: 0,
+			totalNumberOfIssues: 0,
+		};
 	}
 	
 	public get numberOfPeerConnections() {
@@ -299,13 +344,19 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 				}
 				if (observedPeerConnection.currentRttInMs < 50) {
 					this.deltaRttLt50Measurements += 1;
+					this.report.rttDistribution.lt50ms += 1;
 				} else if (observedPeerConnection.currentRttInMs < 150) {
 					this.deltaRttLt150Measurements += 1;
+					this.report.rttDistribution.lt150ms += 1;
 				} else if (observedPeerConnection.currentRttInMs < 300) {
 					this.deltaRttLt300Measurements += 1;
+					this.report.rttDistribution.lt300ms += 1;
 				} else if (300 <= observedPeerConnection.currentRttInMs) {
 					this.deltaRttGtOrEq300Measurements += 1;
+					this.report.rttDistribution.gtOrEq300ms += 1;
 				}
+				this.report.rttDistribution.count += 1;
+				this.report.rttDistribution.sum += observedPeerConnection.currentRttInMs;
 
 				sumOfRtts += observedPeerConnection.currentRttInMs;
 				++numberOfRttMeasurements;
@@ -319,32 +370,37 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 		// emit new attachments?
 		this.attachments = sample.attachments;
 
-		this.totalDataChannelBytesReceived += this.deltaDataChannelBytesReceived;
-		this.totalDataChannelBytesSent += this.deltaDataChannelBytesSent;
-		this.totalDataChannelMessagesReceived += this.deltaDataChannelMessagesReceived;
-		this.totalDataChannelMessagesSent += this.deltaDataChannelMessagesSent;
-		this.totalInboundPacketsLost += this.deltaInboundPacketsLost;
-		this.totalInboundPacketsReceived += this.deltaInboundPacketsReceived;
-		this.totalOutboundPacketsSent += this.deltaOutboundPacketsSent;
-		this.totalReceivedAudioBytes += this.deltaReceivedAudioBytes;
-		this.totalReceivedVideoBytes += this.deltaReceivedVideoBytes;
-		this.totalSentAudioBytes += this.deltaSentAudioBytes;
-		this.totalSentVideoBytes += this.deltaSentVideoBytes;
-		this.totalReceivedBytes += this.deltaTransportReceivedBytes;
-		this.totalSentBytes += this.deltaTransportSentBytes;
-		this.totalRttLt50Measurements += this.deltaRttLt50Measurements;
-		this.totalRttLt150Measurements += this.deltaRttLt150Measurements;
-		this.totalRttLt300Measurements += this.deltaRttLt300Measurements;
-		this.totalRttGtOrEq300Measurements += this.deltaRttGtOrEq300Measurements;
-		this.totalNumberOfIssues += this.deltaNumberOfIssues;
+		this.report.totalDataChannelBytesReceived += this.deltaDataChannelBytesReceived;
+		this.report.totalDataChannelBytesSent += this.deltaDataChannelBytesSent;
+		this.report.totalDataChannelMessagesReceived += this.deltaDataChannelMessagesReceived;
+		this.report.totalDataChannelMessagesSent += this.deltaDataChannelMessagesSent;
+		this.report.totalInboundRtpPacketsLost += this.deltaInboundPacketsLost;
+		this.report.totalInboundRtpPacketsReceived += this.deltaInboundPacketsReceived;
+		this.report.totalOutboundRtpPacketsSent += this.deltaOutboundPacketsSent;
+		this.report.totalAudioBytesReceived += this.deltaReceivedAudioBytes;
+		this.report.totalVideoBytesReceived += this.deltaReceivedVideoBytes;
+		this.report.totalAudioBytesSent += this.deltaSentAudioBytes;
+		this.report.totalVideoBytesSent += this.deltaSentVideoBytes;
+		this.report.totalInboundRtpBytesReceived += this.deltaTransportReceivedBytes;
+		this.report.totalOutboundRtpBytesSent += this.deltaTransportSentBytes;
+		this.report.totalNumberOfIssues += this.deltaNumberOfIssues;
 
 		this.receivingAudioBitrate = (this.deltaReceivedAudioBytes * 8) / (elapsedInSeconds);
-		this.receivingVideoBitrate = (this.totalReceivedVideoBytes * 8) / (elapsedInSeconds);
+		this.receivingVideoBitrate = (this.deltaReceivedVideoBytes * 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;
+
+		if (sample.score !== undefined) {
+			const bucket = Math.floor(sample.score).toString() as '0' | '1' | '2' | '3' | '4' | '5';
+
+			this.report.scoreDistribution[bucket] = (this.report.scoreDistribution[bucket] ?? 0) + 1;
+			this.report.scoreDistribution.count += 1;
+			this.report.scoreDistribution.sum += sample.score;
+		}
+		
 		this.detectors.update();
 
 		this.lastSampleTimestamp = sample.timestamp;
@@ -557,7 +613,7 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 					const observedPeerConnection = this.observedPeerConnections.get(payload.peerConnectionId);
 
 					if (observedPeerConnection) {
-						observedPeerConnection.iceConnectionState = payload.iceConnectionState;
+						observedPeerConnection.iceConnectionState = payload.iceConnectionState as 'new' | 'checking' | 'connected' | 'completed' | 'failed' | 'disconnected' | 'closed';
 						observedPeerConnection.emit('iceconnectionstatechange', {
 							state: payload.iceConnectionState,
 						});
@@ -576,7 +632,7 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 					const observedPeerConnection = this.observedPeerConnections.get(payload.peerConnectionId);
 
 					if (observedPeerConnection) {
-						observedPeerConnection.iceGatheringState = payload.iceGatheringState;
+						observedPeerConnection.iceGatheringState = payload.iceGatheringState as 'new' | 'gathering' | 'complete';
 						observedPeerConnection.emit('icegatheringstatechange', {
 							state: payload.iceGatheringState,
 						});
@@ -595,7 +651,7 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 					const observedPeerConnection = this.observedPeerConnections.get(payload.peerConnectionId);
 
 					if (observedPeerConnection) {
-						observedPeerConnection.connectionState = payload.peerConnectionState;
+						observedPeerConnection.connectionState = payload.peerConnectionState as 'new' | 'connecting' | 'connected' | 'disconnected' | 'failed' | 'closed'; 
 						observedPeerConnection.emit('connectionstatechange', {
 							state: payload.peerConnectionState,
 						});
@@ -681,6 +737,8 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 	public addIssue(issue: ClientIssue) {
 		if (this.closed) return;
 
+		this.report.issues[issue.type] = (this.report.issues[issue.type] ?? 0) + 1;
+
 		this.emit('issue', issue);
 		this.call.observer.emit('client-issue', this, issue);
 	}
@@ -701,14 +759,32 @@ export class ObservedClient<AppData extends Record<string, unknown> = Record<str
 				), void 0);
 			}
 
-			observedPeerConnection = new ObservedPeerConnection(sample.peerConnectionId, this);
-
-			observedPeerConnection.once('close', () => {
+			const newObservedPeerConnection = new ObservedPeerConnection(sample.peerConnectionId, this);
+			const onInboundTrackRemoved = (track: ObservedInboundTrack) => {
+				this.emit('trackreport', {
+					direction: 'inbound',
+					...track.report,
+				});
+			};
+			const onOutboundTrackRemoved = (track: ObservedOutboundTrack) => {
+				this.emit('trackreport', {
+					direction: 'outbound',
+					...track.report,
+				});
+			};
+
+			newObservedPeerConnection.once('close', () => {
+				newObservedPeerConnection?.off('removed-inbound-track', onInboundTrackRemoved);
+				newObservedPeerConnection?.off('removed-outbound-track', onOutboundTrackRemoved);
 				this.observedPeerConnections.delete(sample.peerConnectionId);
 			});
-			this.observedPeerConnections.set(sample.peerConnectionId, observedPeerConnection);
+			newObservedPeerConnection.on('removed-inbound-track', onInboundTrackRemoved);
+			newObservedPeerConnection.on('removed-outbound-track', onOutboundTrackRemoved);
+			this.observedPeerConnections.set(sample.peerConnectionId, newObservedPeerConnection);
 			
-			this.emit('newpeerconnection', observedPeerConnection);
+			this.emit('newpeerconnection', newObservedPeerConnection);
+
+			observedPeerConnection = newObservedPeerConnection;
 		}
 
 		observedPeerConnection.accept(sample);

package/src/ObservedInboundTrack.ts

@@ -5,6 +5,7 @@ import { Detectors } from './detectors/Detectors';
 import { ObservedPeerConnection } from './ObservedPeerConnection';
 import { ObservedInboundRtp } from './ObservedInboundRtp';
 import { ObservedMediaPlayout } from './ObservedMediaPlayout';
+import { InboundTrackReport } from './Reports';
 
 export class ObservedInboundTrack implements InboundTrackSample {
 	public readonly detectors: Detectors;
@@ -13,6 +14,7 @@ export class ObservedInboundTrack implements InboundTrackSample {
 		value: undefined,
 	};
 	public appData?: Record<string, unknown>;
+	public report: InboundTrackReport;
 
 	private _visited = false;
 
@@ -32,6 +34,21 @@ export class ObservedInboundTrack implements InboundTrackSample {
 		private readonly _mediaPlayout?: ObservedMediaPlayout,
 	) {
 		this.detectors = new Detectors();
+
+		this.report = {
+			trackId: this.id,
+			kind: this.kind,
+			fractionLostDistribution: {
+				gtOrEq050: 0,
+				lt001: 0,
+				lt005: 0,
+				lt010: 0,
+				lt020: 0,
+				lt050: 0,
+				count: 0,
+				sum: 0,
+			},
+		};
 	}
 
 	public get score() { 
@@ -68,8 +85,21 @@ export class ObservedInboundTrack implements InboundTrackSample {
 		this.timestamp = stats.timestamp;
 		this.calculatedScore.value = stats.score;
 		this.attachments = stats.attachments;
-	
+
+		const fl = this._inboundRtp?.fractionLost;
+
+		if (fl !== undefined) {
+			if (fl < 0.01) this.report.fractionLostDistribution.lt001 += 1;
+			else if (fl < 0.05) this.report.fractionLostDistribution.lt005 += 1;
+			else if (fl < 0.1) this.report.fractionLostDistribution.lt010 += 1;
+			else if (fl < 0.2) this.report.fractionLostDistribution.lt020 += 1;
+			else if (fl < 0.5) this.report.fractionLostDistribution.lt050 += 1;
+			else this.report.fractionLostDistribution.gtOrEq050 += 1;
+
+			this.report.fractionLostDistribution.count += 1;
+			this.report.fractionLostDistribution.sum += fl;
+		}
+
 		this.detectors.update();
 	}
-	
 }

package/src/ObservedOutboundTrack.ts

@@ -5,11 +5,14 @@ import { Detectors } from './detectors/Detectors';
 import { ObservedPeerConnection } from './ObservedPeerConnection';
 import { ObservedOutboundRtp } from './ObservedOutboundRtp';
 import { ObservedMediaSource } from './ObservedMediaSource';
+import { OutboundTrackReport } from './Reports';
 
 export class ObservedOutboundTrack implements OutboundTrackSample {
 	public readonly detectors: Detectors;
 	private _visited = false;
 	public appData?: Record<string, unknown>;
+	public readonly report: OutboundTrackReport;
+
 	public readonly calculatedScore: CalculatedScore = {
 		weight: 1,
 		value: undefined,
@@ -30,6 +33,11 @@ export class ObservedOutboundTrack implements OutboundTrackSample {
 		private readonly _outboundRtps?: ObservedOutboundRtp[],
 		private readonly _mediaSource?: ObservedMediaSource,
 	) {
+		this.report = {
+			trackId: this.id,
+			kind: this.kind as 'audio' | 'video',
+		};
+
 		this.detectors = new Detectors();
 	}
 

package/src/ObservedPeerConnection.ts

@@ -128,9 +128,9 @@ export class ObservedPeerConnection extends EventEmitter {
 	public closedAt?: number;
 	public updated = Date.now();
 
-	public connectionState?: string;
-	public iceConnectionState?: string;
-	public iceGatheringState?: string;
+	public connectionState?: 'new' | 'connecting' | 'connected' | 'disconnected' | 'failed' | 'closed'; 
+	public iceConnectionState?: 'new' | 'checking' | 'connected' | 'completed' | 'failed' | 'disconnected' | 'closed';
+	public iceGatheringState?: 'new' | 'gathering' | 'complete';
 
 	public availableIncomingBitrate = 0;
 	public availableOutgoingBitrate = 0;
@@ -286,6 +286,22 @@ export class ObservedPeerConnection extends EventEmitter {
 		if (this.closed) return;
 		this.closed = true;
 
+		this.observedCertificates.forEach((cert) => this.emit('removed-certificate', cert));
+		this.observedCodecs.forEach((codec) => this.emit('removed-codec', codec));
+		this.observedDataChannels.forEach((dc) => this.emit('removed-data-channel', dc));
+		this.observedIceCandidates.forEach((candidate) => this.emit('removed-ice-candidate', candidate));
+		this.observedIceCandidatesPair.forEach((pair) => this.emit('removed-ice-candidate-pair', pair));
+		this.observedIceTransports.forEach((transport) => this.emit('removed-ice-transport', transport));
+		this.observedInboundRtps.forEach((rtp) => this.emit('removed-inbound-rtp', rtp));
+		this.observedInboundTracks.forEach((track) => this.emit('removed-inbound-track', track));
+		this.observedMediaPlayouts.forEach((playout) => this.emit('removed-media-playout', playout));
+		this.observedMediaSources.forEach((source) => this.emit('removed-media-source', source));
+		this.observedOutboundRtps.forEach((rtp) => this.emit('removed-outbound-rtp', rtp));
+		this.observedOutboundTracks.forEach((track) => this.emit('removed-outbound-track', track));
+		this.observedPeerConnectionTransports.forEach((transport) => this.emit('removed-peer-connection-transport', transport));
+		this.observedRemoteInboundRtps.forEach((rtp) => this.emit('removed-remote-inbound-rtp', rtp));
+		this.observedRemoteOutboundRtps.forEach((rtp) => this.emit('removed-remote-outbound-rtp', rtp));
+
 		this.observedCertificates.clear();
 		this.observedCodecs.clear();
 		this.observedDataChannels.clear();

package/src/Observer.ts

@@ -31,6 +31,8 @@ export type ObserverConfig<AppData extends Record<string, unknown> = Record<stri
 	defaultCallUpdatePolicy?: ObservedCallSettings['updatePolicy'],
 	defaultCallUpdateIntervalInMs?: number,
 	appData?: AppData,
+	closeClientIfIdleForMs?: number,
+	closeCallIfEmptyForMs?: number,
 }
 
 export declare interface Observer {
@@ -51,11 +53,6 @@ export class Observer<AppData extends Record<string, unknown> = Record<string, u
 
 	public totalAddedCall = 0;
 	public totalRemovedCall = 0;
-	public totalRttLt50Measurements = 0;
-	public totalRttLt150Measurements = 0;
-	public totalRttLt300Measurements = 0;
-	public totalRttGtOrEq300Measurements = 0;
-	public totalClientIssues = 0;
 
 	public numberOfClientsUsingTurn = 0;
 	public numberOfClients = 0;
@@ -125,6 +122,10 @@ export class Observer<AppData extends Record<string, unknown> = Record<string, u
 			settings.updatePolicy = this.config.defaultCallUpdatePolicy;
 			settings.updateIntervalInMs = this.config.defaultCallUpdateIntervalInMs;
 		}
+		if (!settings.closeCallIfEmptyForMs) {
+			settings.closeCallIfEmptyForMs = this.config.closeCallIfEmptyForMs;
+		}
+		
 		const observedCall = new ObservedCall(settings, this);
 		const onCallUpdated = () => this._onObservedCallUpdated(observedCall);
 
@@ -211,11 +212,7 @@ export class Observer<AppData extends Record<string, unknown> = Record<string, u
 	}
 
 	private _onObservedCallUpdated(call: ObservedCall) {
-		this.totalRttLt50Measurements += call.deltaRttLt50Measurements;
-		this.totalRttLt150Measurements += call.deltaRttLt150Measurements;
-		this.totalRttLt300Measurements += call.deltaRttLt300Measurements;
-		this.totalRttGtOrEq300Measurements += call.deltaRttGtOrEq300Measurements;
-		this.totalClientIssues += call.deltaNumberOfIssues;
+		call;
 	}
 
 	public createEventMonitor<CTX = unknown>(ctx?: CTX): ObserverEventMonitor<CTX> {

package/src/ObserverEventMonitor.ts

@@ -14,6 +14,7 @@ import { ObservedOutboundRtp } from './ObservedOutboundRtp';
 import { ObservedOutboundTrack } from './ObservedOutboundTrack';
 import { ObservedPeerConnection } from './ObservedPeerConnection';
 import { Observer } from './Observer';
+import { TrackReport } from './Reports';
 import { ClientEvent, ClientIssue, ClientMetaData, ClientSample, ExtensionStat } from './schema/ClientSample';
 
 export class ObserverEventMonitor<Context> {
@@ -160,6 +161,8 @@ export class ObserverEventMonitor<Context> {
 	public onMediaSourceRemoved?: (mediaSource: ObservedMediaSource, ctx: Context) => void;
 	public onMediaSourceUpdated?: (mediaSource: ObservedMediaSource, ctx: Context) => void;
 
+	public onTrackReport?: (report: TrackReport, observedClient: ObservedClient, ctx: Context) => void;
+
 	private _onCallAdded(call: ObservedCall) {
 		const onCallEmpty = () => this.onCallEmpty?.(call, this.context);
 		const onCallNotEmpty = () => this.onCallNotEmpty?.(call, this.context);
@@ -192,6 +195,7 @@ export class ObserverEventMonitor<Context> {
 		const onUserMediaError = (error: string) => this._onUserMediaError(observedClient, error);
 		const onClientUpdated = (...args: ObservedClientEvents['update']) => this.onClientUpdated?.(observedClient, args[0], this.context);
 		const onClientEvent = (event: ClientEvent) => this.onClientEvent?.(observedClient, event, this.context);
+		const onTrackReport = (report: TrackReport) => this._onTrackReport(report, observedClient);
 
 		observedClient.once('close', () => {
 			observedClient.off('newpeerconnection', this._onPeerConnconnectionAdded);
@@ -205,6 +209,7 @@ export class ObserverEventMonitor<Context> {
 			observedClient.off('extensionStats', onClientExtensionStats);
 			observedClient.off('update', onClientUpdated);
 			observedClient.off('clientEvent', onClientEvent);
+			observedClient.off('trackreport', onTrackReport);
 		
 			this.onClientClosed?.(observedClient, this.context);
 		});
@@ -220,6 +225,7 @@ export class ObserverEventMonitor<Context> {
 		observedClient.on('extensionStats', onClientExtensionStats);
 		observedClient.on('update', onClientUpdated);
 		observedClient.on('clientEvent', onClientEvent);
+		observedClient.on('trackreport', onTrackReport);
 
 		this.onClientAdded?.(observedClient, this.context);
 	}
@@ -548,4 +554,8 @@ export class ObserverEventMonitor<Context> {
 	private _onUsingTurn(observedClient: ObservedClient, usingTurn: boolean) {
 		this.onClientUsingTurn?.(observedClient, usingTurn, this.context);
 	}
+
+	private _onTrackReport(report: TrackReport, observedClient: ObservedClient) {
+		this.onTrackReport?.(report, observedClient, this.context);
+	}
 }

package/src/Reports.ts

@@ -0,0 +1,87 @@
+export type InboundAudioTrackReport = {
+	trackId: string,
+	fractionLostDistribution: {
+		lt001: number;
+		lt005: number;
+		lt010: number;
+		lt020: number;
+		lt050: number;
+		gtOrEq050: number;
+		count: number;
+		sum: number;
+	},
+};
+
+export type InboundVideoTrackReport = {
+	trackId: string,
+	fractionLostDistribution: {
+		lt001: number;
+		lt005: number;
+		lt010: number;
+		lt020: number;
+		lt050: number;
+		gtOrEq050: number;
+		count: number;
+		sum: number;
+	},
+};
+
+export type OutboundAudioTrackReport = {
+	trackId: string,
+};
+
+export type OutboundVideoTrackReport = {
+	trackId: string,
+};
+
+export type InboundTrackReport = ({ kind: 'audio' } & InboundAudioTrackReport) 
+| ({ kind: 'video' } & InboundVideoTrackReport);
+
+export type OutboundTrackReport = ({ kind: 'audio' } & OutboundAudioTrackReport) 
+| ({ kind: 'video' } & OutboundVideoTrackReport);
+
+export type TrackReport = ({ direction: 'inbound' } & InboundTrackReport)
+| ({ direction: 'outbound' } & OutboundTrackReport);
+
+export type ClientReport = {
+	callId: string;
+	clientId: string;
+
+	totalDataChannelBytesReceived: number;
+	totalDataChannelBytesSent: number;
+	totalDataChannelMessagesReceived: number;
+	totalDataChannelMessagesSent: number;
+	totalInboundRtpPacketsReceived: number;
+	totalInboundRtpPacketsLost: number;
+	totalInboundRtpBytesReceived: number;
+	totalOutboundRtpPacketsSent: number;
+	totalOutboundRtpBytesSent: number;
+	totalAudioBytesReceived: number;
+	totalVideoBytesReceived: number;
+	totalAudioBytesSent: number;
+	totalVideoBytesSent: number;
+	totalNumberOfIssues: number;
+	
+	issues: Record<string, number>;
+
+	rttDistribution: {
+		lt50ms: number;
+		lt150ms: number;
+		lt300ms: number;
+		gtOrEq300ms: number;
+		count: number;
+		sum: number;
+	},
+
+	scoreDistribution: {
+		'0': number;
+		'1': number;
+		'2': number;
+		'3': number;
+		'4': number;
+		'5': number;
+		
+		count: number;
+		sum: number;
+	}
+}

package/src/index.ts

@@ -26,3 +26,7 @@ export { ScoreCalculator } from './scores/ScoreCalculator';
 export { ObservedClientEventMonitor } from './ObservedClientEventMonitor';
 export { ObserverEventMonitor } from './ObserverEventMonitor';
 export { Middleware } from './common/Middleware';
+export type {
+	TrackReport,
+	ClientReport,
+} from './Reports';