@observertc/observer-js 0.9.1-beta → 0.9.2-beta

package/src/middlewares/VisitObservedSfusMiddleware.ts

@@ -0,0 +1,202 @@
+import { Middleware } from './Middleware';
+import { TransactionContext } from './TransactionContext';
+import { ReportsCollector } from '../common/ReportsCollector';
+import { createLogger } from '../common/logger';
+import { visitSfu } from './visitors/visitSfu';
+import { visitSfuTransport } from './visitors/visitSfuTransport';
+import { visitSfuInboundRtpPad } from './visitors/visitSfuInboundRtpPad';
+import { visitSfuOutboundRtpPad } from './visitors/visitSfuOutboundRtpPad';
+import { visitSfuSctpChannel } from './visitors/visitSfuSctpChannel';
+
+export const logger = createLogger('VisitObservedCallsMiddleware');
+
+export function createVisitObservedSfusMiddleware(
+	reports: ReportsCollector,
+	fetchSamples: boolean
+): Middleware<TransactionContext> {
+	const process = async (transaction: TransactionContext) => {
+		const {
+			observedSfus,
+			updatedSfus,
+			deletedSfus,
+
+			updatedSfuTransports,
+			deletedSfuTransports,
+
+			updatedSfuInboundRtpPads,
+			deletedSfuInboundRtpPads,
+
+			updatedSfuOutboundRtpPads,
+			deletedSfuOutboundRtpPads,
+
+			updatedSfuSctpChannels,
+			deletedSfuSctpChannels
+
+		} = transaction;
+
+		const visitedSfuIds = new Set<string>();
+		const visitedSfuTransportIds = new Set<string>();
+		const visitedSfuInboundRtpPadIds = new Set<string>();
+		const visitedSfuOutboundRtpPadIds = new Set<string>();
+		const visitedSfuSctpChannels = new Set<string>();
+
+		for (const observedSfu of observedSfus.observedSfus()) {
+			const { sfuId } = observedSfu;
+
+			visitSfu(observedSfu, updatedSfus, reports, fetchSamples);
+			
+			visitedSfuIds.add(sfuId);
+			const storedSfu = updatedSfus.get(sfuId);
+
+			if (!storedSfu) {
+				continue;
+			}
+
+			for (const observedSfuTransport of observedSfu.observedSfuTransports()) {
+				const { transportId } = observedSfuTransport;
+
+				visitSfuTransport(observedSfuTransport, storedSfu, updatedSfuTransports, reports, fetchSamples);
+
+				visitedSfuTransportIds.add(transportId);
+				const storedSfuTransport = updatedSfuTransports.get(transportId);
+
+				if (!storedSfuTransport) {
+					continue;
+				}
+
+				for (const sfuInboundRtpPad of observedSfuTransport.inboundRtpPads()) {
+					visitSfuInboundRtpPad(sfuInboundRtpPad, storedSfuTransport, updatedSfuInboundRtpPads, reports, fetchSamples);
+
+					visitedSfuInboundRtpPadIds.add(sfuInboundRtpPad.padId);
+				}
+
+				for (const sfuOutboundRtpPad of observedSfuTransport.outboundRtpPads()) {
+					visitSfuOutboundRtpPad(sfuOutboundRtpPad, storedSfuTransport, updatedSfuOutboundRtpPads, reports, fetchSamples);
+
+					visitedSfuInboundRtpPadIds.add(sfuOutboundRtpPad.padId);
+				}
+
+				for (const sfuSctpChannel of observedSfuTransport.sfuSctpChannels()) {
+					visitSfuSctpChannel(sfuSctpChannel, storedSfuTransport, updatedSfuSctpChannels, reports, fetchSamples);
+
+					visitedSfuSctpChannels.add(sfuSctpChannel.channelId);
+				}
+			}
+		}
+
+		for (const [sfuId, sfu] of Array.from(updatedSfus.entries())) {
+
+			if (visitedSfuIds.has(sfuId)) {
+				continue;
+			}
+			deletedSfus.add(sfuId);
+
+			if (sfu.serviceId && sfu.mediaUnitId) {
+				reports.addSfuEventReport({
+					serviceId: sfu.serviceId,
+					mediaUnitId: sfu.mediaUnitId,
+					name: "SFU_LEFT",
+					sfuId,
+					timestamp: Date.now(),
+					marker: sfu.marker,
+					message: 'SFU is detached',
+				});
+			}
+		}
+
+		for (const [sfuTransportId, sfuTransport] of Array.from(updatedSfuTransports.entries())) {
+			if (visitedSfuTransportIds.has(sfuTransportId)) {
+				continue;
+			}
+			// delete PeerConnection
+			const { serviceId, sfuId, transportId } = sfuTransport;
+
+			if (!serviceId || !sfuId || !transportId) {
+				continue;
+			}
+
+			const storedSfu = updatedSfus.get(sfuId);
+
+			updatedSfuTransports.delete(transportId);
+			deletedSfuTransports.add(transportId);
+
+			// also update the peer connection model
+			if (storedSfu) {
+				storedSfu.sfuTransportIds = storedSfu.sfuTransportIds.filter((tId) => tId !== transportId);
+			}
+		}
+
+		for (const [padId, sfuInboundRtpPad] of Array.from(updatedSfuInboundRtpPads.entries())) {
+			if (visitedSfuInboundRtpPadIds.has(padId)) {
+				continue;
+			}
+			// delete Sfu Inbound Rtp Pad
+			const { serviceId, rtpPadId, sfuTransportId } = sfuInboundRtpPad;
+
+			if (!serviceId || !sfuTransportId || !rtpPadId) {
+				continue;
+			}
+
+			const storedSfuTransport = updatedSfuTransports.get(sfuTransportId);
+
+			updatedSfuInboundRtpPads.delete(rtpPadId);
+			deletedSfuInboundRtpPads.add(rtpPadId);
+
+			// also update the sfu transport model
+			if (storedSfuTransport) {
+				storedSfuTransport.inboundRtpPadIds = storedSfuTransport.inboundRtpPadIds.filter((tId) => tId !== rtpPadId);
+			}
+		}
+
+		for (const [padId, sfuOutboundRtpPad] of Array.from(updatedSfuOutboundRtpPads.entries())) {
+			if (visitedSfuOutboundRtpPadIds.has(padId)) {
+				continue;
+			}
+
+			// delete Sfu Outbound Rtp Pad
+			const { serviceId, rtpPadId, sfuTransportId } = sfuOutboundRtpPad;
+
+			if (!serviceId || !sfuTransportId || !rtpPadId) {
+				continue;
+			}
+
+			const storedSfuTransport = updatedSfuTransports.get(sfuTransportId);
+
+			updatedSfuOutboundRtpPads.delete(rtpPadId);
+			deletedSfuOutboundRtpPads.add(rtpPadId);
+
+			// also update the sfu transport model
+			if (storedSfuTransport) {
+				storedSfuTransport.outboundRtpPadIds = storedSfuTransport.outboundRtpPadIds.filter((tId) => tId !== rtpPadId);
+			}
+		}
+
+		for (const [channelId, sfuSctpChannel] of Array.from(updatedSfuSctpChannels.entries())) {
+			if (visitedSfuSctpChannels.has(channelId)) {
+				continue;
+			}
+
+			// delete Sfu Outbound Rtp Pad
+			const { serviceId, sfuSctpChannelId, sfuTransportId } = sfuSctpChannel;
+
+			if (!serviceId || !sfuTransportId || !sfuSctpChannelId) {
+				continue;
+			}
+
+			const storedSfuTransport = updatedSfuTransports.get(sfuTransportId);
+
+			updatedSfuSctpChannels.delete(sfuSctpChannelId);
+			deletedSfuSctpChannels.add(sfuSctpChannelId);
+
+			// also update the sfu transport model
+			if (storedSfuTransport) {
+				storedSfuTransport.sctpChannelIds = storedSfuTransport.sctpChannelIds.filter((tId) => tId !== sfuSctpChannelId);
+			}
+		}
+	};
+	const result = async (context: TransactionContext, next?: Middleware<TransactionContext>) => {
+		await process(context);
+		if (next) await next(context);
+	};
+	return result;
+}

package/src/middlewares/visitors/visitClient.ts

@@ -85,6 +85,7 @@ export function visitClient(
 				reports.addCallMetaReport(callMetaReport);
 			}
 		}
+		
 
 		if (clientSample.localSDPs && 0 < clientSample.localSDPs.length) {
 			for (const localSDP of clientSample.localSDPs) {
@@ -111,6 +112,20 @@ export function visitClient(
 			}
 		}
 
+		if (clientSample.customCallEvents && 0 < clientSample.customCallEvents.length) {
+			for (const callEvent of clientSample.customCallEvents) {
+				reports.addCallEventReport({
+					serviceId,
+					mediaUnitId,
+					roomId,
+					callId,
+					clientId,
+					timestamp: Date.now(),
+					...callEvent,
+				});
+			}
+		}
+
 		if (clientSample.userMediaErrors && 0 < clientSample.userMediaErrors.length) {
 			for (const userMediaError of clientSample.userMediaErrors) {
 				const callMetaReport = createCallMetaReport(serviceId, mediaUnitId, roomId, callId, clientId, {

package/src/middlewares/visitors/visitSfu.ts

@@ -0,0 +1,64 @@
+import * as Models from '../../models/Models';
+import { ReportsCollector } from '../../common/ReportsCollector';
+import { ObservedSfu } from '../../samples/ObservedSfu';
+
+export function visitSfu(
+	observedSfu: ObservedSfu,
+	storedSfus: Map<string, Models.Sfu>,
+	reports: ReportsCollector,
+	fetchSamples: boolean
+) {
+	const { mediaUnitId, serviceId, sfuId, timeZoneId, marker } = observedSfu;
+	let storedSfu = storedSfus.get(sfuId);
+	if (!storedSfu) {
+		const timestamp = Date.now();
+		storedSfu = new Models.Sfu({
+			serviceId,
+			sfuId,
+			joined: BigInt(timestamp),
+			mediaUnitId,
+			timeZoneId,
+			marker,
+			sfuTransportIds: [],
+		});
+		storedSfus.set(sfuId, storedSfu);
+
+		reports.addSfuEventReport({
+			serviceId,
+			mediaUnitId,
+			name: "SFU_JOINED",
+			sfuId,
+			timestamp,
+			marker,
+			message: 'SFU is joined',
+		});
+	}
+
+	for (const sfuSample of observedSfu.samples()) {
+
+		if (sfuSample.customSfuEvents) {
+			for (const sfuEvent of sfuSample.customSfuEvents) {
+				reports.addSfuEventReport({
+					serviceId,
+					mediaUnitId,
+					sfuId,
+					timestamp: Date.now(),
+					...sfuEvent,
+				});
+			}
+		}
+
+		if (sfuSample.extensionStats) {
+			for (const extensionStats of sfuSample.extensionStats) {
+				reports.addSfuExtensionReport({
+					serviceId,
+					mediaUnitId,
+					sfuId,
+					timestamp: Date.now(),
+					payload: extensionStats.payload,
+					extensionType: extensionStats.type,
+				});
+			}
+		}
+	}
+}

package/src/middlewares/visitors/visitSfuInboundRtpPad.ts

@@ -0,0 +1,50 @@
+import * as Models from '../../models/Models';
+import { ReportsCollector } from '../../common/ReportsCollector';
+import { SfuInboundRtpPadReport } from '@observertc/report-schemas-js';
+import { ObservedSfuInboundRtpPad } from '../../samples/ObservedSfuInboundRtpPad';
+
+export function visitSfuInboundRtpPad(
+	observedSfuInboundRtpPad: ObservedSfuInboundRtpPad,
+	storedSfuTransport: Models.SfuTransport,
+	storedSfuInboundRtpPads: Map<string, Models.SfuInboundRtpPad>,
+	reports: ReportsCollector,
+	fetchSamples: boolean
+) {
+	const { padId: rtpPadId } = observedSfuInboundRtpPad;
+
+	const { transportId: sfuTransportId } = observedSfuInboundRtpPad.sfuTransport;
+
+	const { serviceId, sfuId, mediaUnitId,  marker, minTimestamp: timestamp } = observedSfuInboundRtpPad.sfuTransport.sfu;
+
+
+	let storedSfuInboundRtpPad = storedSfuInboundRtpPads.get(rtpPadId);
+	if (!storedSfuInboundRtpPad) {
+		storedSfuInboundRtpPad = new Models.SfuInboundRtpPad({
+			serviceId,
+			sfuId,
+			mediaUnitId,
+			sfuTransportId,
+			added: BigInt(Date.now()),
+			marker,
+		});
+		storedSfuInboundRtpPads.set(rtpPadId, storedSfuInboundRtpPad);
+
+		storedSfuTransport.inboundRtpPadIds.push(rtpPadId);
+	}
+
+	for (const sfuInboundRtpPad of observedSfuInboundRtpPad.samples()) {
+		const report: SfuInboundRtpPadReport = {
+			serviceId,
+			sfuId,
+			mediaUnitId,
+			rtpPadId,
+			...sfuInboundRtpPad,
+			sfuStreamId: sfuInboundRtpPad.streamId,
+			timestamp,
+		};
+		reports.addSfuTransportReport(report);
+	}
+
+	if (fetchSamples) {
+	}
+}

package/src/middlewares/visitors/visitSfuOutboundRtpPad.ts

@@ -0,0 +1,51 @@
+import * as Models from '../../models/Models';
+import { ReportsCollector } from '../../common/ReportsCollector';
+import { SfuOutboundRtpPadReport } from '@observertc/report-schemas-js';
+import { ObservedSfuTransport } from '../../samples/ObservedSfuTransport';
+import { ObservedSfuOutboundRtpPad } from '../../samples/ObservedSfuOutboundRtpPad';
+
+export function visitSfuOutboundRtpPad(
+	observedSfuOutboundRtpPad: ObservedSfuOutboundRtpPad,
+	storedSfuTransport: Models.SfuTransport,
+	storedSfuOutboundRtpPads: Map<string, Models.SfuOutboundRtpPad>,
+	reports: ReportsCollector,
+	fetchSamples: boolean
+) {
+	const { padId: rtpPadId } = observedSfuOutboundRtpPad;
+
+	const { transportId: sfuTransportId } = observedSfuOutboundRtpPad.sfuTransport;
+
+	const { serviceId, sfuId, mediaUnitId, marker, minTimestamp: timestamp } = observedSfuOutboundRtpPad.sfuTransport.sfu;
+
+	let storedSfuOutboundRtpPad = storedSfuOutboundRtpPads.get(rtpPadId);
+	if (!storedSfuOutboundRtpPad) {
+		storedSfuOutboundRtpPad = new Models.SfuOutboundRtpPad({
+			serviceId,
+			sfuId,
+			mediaUnitId,
+			sfuTransportId,
+			added: BigInt(Date.now()),
+			marker,
+		});
+		storedSfuOutboundRtpPads.set(rtpPadId, storedSfuOutboundRtpPad);
+
+		storedSfuTransport.outboundRtpPadIds.push(rtpPadId);
+	}
+
+	for (const sfuOutboundRtpPad of observedSfuOutboundRtpPad.samples()) {
+		const report: SfuOutboundRtpPadReport = {
+			serviceId,
+			sfuId,
+			mediaUnitId,
+			rtpPadId,
+			...sfuOutboundRtpPad,
+			sfuStreamId: sfuOutboundRtpPad.streamId,
+			sfuSinkId: sfuOutboundRtpPad.sinkId,
+			timestamp,
+		};
+		reports.addSfuTransportReport(report);
+	}
+
+	if (fetchSamples) {
+	}
+}

package/src/middlewares/visitors/visitSfuSctpChannel.ts

@@ -0,0 +1,48 @@
+import * as Models from '../../models/Models';
+import { ReportsCollector } from '../../common/ReportsCollector';
+import { SfuSctpStreamReport } from '@observertc/report-schemas-js';
+import { ObservedSfuSctpChannel } from '../../samples/ObservedSfuSctpChannel';
+
+export function visitSfuSctpChannel(
+	observedSfuSctpChannel: ObservedSfuSctpChannel,
+	storedSfuTransport: Models.SfuTransport,
+	storedSfuSctpChannels: Map<string, Models.SfuSctpChannel>,
+	reports: ReportsCollector,
+	fetchSamples: boolean
+  ) {
+	const { channelId } = observedSfuSctpChannel;
+  
+	const { transportId: sfuTransportId } = observedSfuSctpChannel.sfuTransport;
+  
+	const { serviceId, sfuId, mediaUnitId, marker, minTimestamp: timestamp } = observedSfuSctpChannel.sfuTransport.sfu;
+  
+	let storedSfuSctpChannel = storedSfuSctpChannels.get(channelId);
+	if (!storedSfuSctpChannel) {
+	  storedSfuSctpChannel = new Models.SfuSctpChannel({
+		serviceId,
+		sfuId,
+		mediaUnitId,
+		sfuTransportId,
+		opened: BigInt(Date.now()),
+		marker,
+	  });
+	  storedSfuSctpChannels.set(channelId, storedSfuSctpChannel);
+  
+	  storedSfuTransport.sctpChannelIds.push(channelId);
+	}
+  
+	for (const sfuSctpChannel of observedSfuSctpChannel.samples()) {
+	  const report: SfuSctpStreamReport = {
+		serviceId,
+		sfuId,
+		mediaUnitId,
+		...sfuSctpChannel,
+		timestamp,
+	  };
+	  reports.addSfuTransportReport(report);
+	}
+  
+	if (fetchSamples) {
+	}
+  }
+  

package/src/middlewares/visitors/visitSfuTransport.ts

@@ -0,0 +1,48 @@
+import * as Models from '../../models/Models';
+import { ReportsCollector } from '../../common/ReportsCollector';
+import { SFUTransportReport } from '@observertc/report-schemas-js';
+import { ObservedSfuTransport } from '../../samples/ObservedSfuTransport';
+
+export function visitSfuTransport(
+	observedSfuTransport: ObservedSfuTransport,
+	storedSfu: Models.Sfu,
+	storedSfuTransports: Map<string, Models.SfuTransport>,
+	reports: ReportsCollector,
+	fetchSamples: boolean
+) {
+	const { transportId } = observedSfuTransport;
+
+	const { serviceId, sfuId, mediaUnitId, marker, minTimestamp: timestamp } = observedSfuTransport.sfu;
+
+
+	let storedSfuTransport = storedSfuTransports.get(transportId);
+	if (!storedSfuTransport) {
+		storedSfuTransport = new Models.SfuTransport({
+			serviceId,
+			sfuId,
+			mediaUnitId,
+			transportId,
+			opened: BigInt(Date.now()),
+			marker,
+			inboundRtpPadIds: [],
+			outboundRtpPadIds: [],
+		});
+		storedSfuTransports.set(transportId, storedSfuTransport);
+
+		storedSfu.sfuTransportIds.push(transportId);
+	}
+
+	for (const sfuTransport of observedSfuTransport.transportSamples()) {
+		const report: SFUTransportReport = {
+			serviceId,
+			sfuId,
+			mediaUnitId,
+			...sfuTransport,
+			timestamp,
+		};
+		reports.addSfuTransportReport(report);
+	}
+
+	if (fetchSamples) {
+	}
+}

package/src/samples/ObservedSfu.ts

@@ -0,0 +1,108 @@
+import { ClientSample, SfuSample } from '@observertc/sample-schemas-js';
+import { ObservedPeerConnection, ObservedPeerConnectionBuilder } from './ObservedPeerConnection';
+import { ObservedCall } from './ObservedCall';
+import { ObservedSfuTransport, ObservedSfuTransportBuilder } from './ObservedSfuTransport';
+
+export interface ObservedSfu {
+	readonly serviceId: string;
+	readonly sfuId: string;
+	readonly mediaUnitId: string;
+
+	observedSfuTransports(): IterableIterator<ObservedSfuTransport>;
+	getObservedSfuTransport(sfuId: string): ObservedSfuTransport | undefined;
+	samples(): IterableIterator<SfuSample>;
+
+	readonly marker?: string;
+	readonly timeZoneId?: string;
+
+	minTimestamp: number;
+	maxTimestamp: number;
+}
+
+export class ObservedSfuBuilder {
+	private _minTimestamp?: number;
+	private _maxTimestamp?: number;
+	private _sfuTransports = new Map<string, ObservedSfuTransportBuilder>();
+	private _sfuSamples: SfuSample[] = [];
+	public constructor(
+		private _config: Omit<
+			ObservedSfu,
+			| keyof IterableIterator<ObservedPeerConnection>
+			| 'samples'
+			| 'observedSfuTransports'
+			| 'getObservedSfuTransport'
+			| 'minTimestamp'
+			| 'maxTimestamp'
+		>
+	) {}
+
+	public addSfuSample(sfuSample: SfuSample) {
+		this._sfuSamples.push(sfuSample);
+
+		if (sfuSample.transports) {
+			for (const sfuTransport of sfuSample.transports) {
+				const builder = this._getOrCreateSfuTransportBuilder(sfuTransport.transportId);
+				builder.addTransportSample(sfuTransport);
+			}
+		}
+		
+		if (sfuSample.inboundRtpPads) {
+			for (const inboundRtpPad of sfuSample.inboundRtpPads) {
+				const builder = this._getOrCreateSfuTransportBuilder(inboundRtpPad.transportId);
+				builder.addSfuInboundRtpPad(inboundRtpPad);
+			}
+		}
+
+		if (sfuSample.outboundRtpPads) {
+			for (const outboundRtpPad of sfuSample.outboundRtpPads) {
+				const builder = this._getOrCreateSfuTransportBuilder(outboundRtpPad.transportId);
+				builder.addSfuOutboundRtpPad(outboundRtpPad);
+			}
+		}
+
+		if (sfuSample.sctpChannels) {
+			for (const sctpChannel of sfuSample.sctpChannels) {
+				const builder = this._getOrCreateSfuTransportBuilder(sctpChannel.transportId);
+				builder.addSfuSctpChannel(sctpChannel);
+			}
+		}
+
+		if (this._minTimestamp === undefined || sfuSample.timestamp < this._minTimestamp) {
+			this._minTimestamp = sfuSample.timestamp;
+		}
+
+		if (this._maxTimestamp === undefined || this._maxTimestamp < sfuSample.timestamp) {
+			this._maxTimestamp = sfuSample.timestamp;
+		}
+	}
+
+	private _getOrCreateSfuTransportBuilder(transportId: string): ObservedSfuTransportBuilder {
+		let result = this._sfuTransports.get(transportId);
+		if (!result) {
+			result = new ObservedSfuTransportBuilder({
+				transportId,
+			});
+			this._sfuTransports.set(transportId, result);
+		}
+		return result;
+	}
+
+	public build(): ObservedSfu {
+		const observedSfuTransports = new Map<string, ObservedSfuTransport>();
+
+		const result: ObservedSfu = {
+			...this._config,
+			minTimestamp: this._minTimestamp ?? Date.now(),
+			maxTimestamp: this._maxTimestamp ?? Date.now(),
+			samples: () => this._sfuSamples.values(),
+			observedSfuTransports: () => observedSfuTransports.values(),
+			getObservedSfuTransport: (transportId: string) => observedSfuTransports.get(transportId),
+		};
+
+		for (const builder of this._sfuTransports.values()) {
+			const observedSfuTransport = builder.build(result);
+			observedSfuTransports.set(observedSfuTransport.transportId, observedSfuTransport);
+		}
+		return result;
+	}
+}

package/src/samples/ObservedSfuInboundRtpPad.ts

@@ -0,0 +1,34 @@
+import { SfuInboundRtpPad } from '@observertc/sample-schemas-js';
+import { ObservedSfuTransport } from './ObservedSfuTransport';
+
+export interface ObservedSfuInboundRtpPad {
+	readonly sfuTransport: ObservedSfuTransport;
+	readonly padId: string;
+
+	samples(): IterableIterator<SfuInboundRtpPad>;
+}
+
+export class ObservedSfuInboundRtpPadBuilder {
+	private _samples: SfuInboundRtpPad[] = [];
+	public constructor(
+		private _config: Omit<
+			ObservedSfuInboundRtpPad,
+			| keyof IterableIterator<SfuInboundRtpPad> 
+			| 'sfuTransport' 
+			| 'samples'
+		>
+	) {}
+
+	public addSample(sfuInboundRtpPad: SfuInboundRtpPad) {
+		this._samples.push(sfuInboundRtpPad);
+	}
+
+	public build(sfuTransport: ObservedSfuTransport): ObservedSfuInboundRtpPad {
+		const result: ObservedSfuInboundRtpPad = {
+			sfuTransport,
+			...this._config,
+			samples: () => this._samples.values(),
+		};
+		return result;
+	}
+}

package/src/samples/ObservedSfuOutboundRtpPad.ts

@@ -0,0 +1,34 @@
+import { SfuOutboundRtpPad } from '@observertc/sample-schemas-js';
+import { ObservedSfuTransport } from './ObservedSfuTransport';
+
+export interface ObservedSfuOutboundRtpPad {
+	readonly sfuTransport: ObservedSfuTransport;
+	readonly padId: string;
+
+	samples(): IterableIterator<SfuOutboundRtpPad>;
+}
+
+export class ObservedSfuOutboundRtpPadBuilder {
+	private _samples: SfuOutboundRtpPad[] = [];
+	public constructor(
+		private _config: Omit<
+			ObservedSfuOutboundRtpPad,
+			| keyof IterableIterator<SfuOutboundRtpPad> 
+			| 'sfuTransport' 
+			| 'samples'
+		>
+	) {}
+
+	public addSample(sfuInboundRtpPad: SfuOutboundRtpPad) {
+		this._samples.push(sfuInboundRtpPad);
+	}
+
+	public build(sfuTransport: ObservedSfuTransport): ObservedSfuOutboundRtpPad {
+		const result: ObservedSfuOutboundRtpPad = {
+			sfuTransport,
+			...this._config,
+			samples: () => this._samples.values(),
+		};
+		return result;
+	}
+}