@observertc/observer-js 0.40.3-beta → 0.40.5-beta

package/src/ObservedPeerConnection.ts

@@ -49,9 +49,9 @@ export class ObservedPeerConnection extends EventEmitter {
 	public totalReceivedAudioBytes = 0;
 	public totalReceivedVideoBytes = 0;
 
-	public deltaInboundLostPackets = 0;
-	public deltaInboundReceivedPackets = 0;
-	public deltaOutboundSentPackets = 0;
+	public deltaInboundPacketsLost = 0;
+	public deltaInboundPacketsReceived = 0;
+	public deltaOutboundPacketsSent = 0;
 	public deltaDataChannelBytesSent = 0;
 	public deltaDataChannelBytesReceived = 0;
 	public deltaInboundReceivedBytes = 0;
@@ -73,6 +73,7 @@ export class ObservedPeerConnection extends EventEmitter {
 	private _closed = false;
 	private _updated = Date.now();
 	private _sample?: ObservedPeerConnectionStats;
+	private _marker?: string;
 
 	public readonly ICE = ObservedICE.create(this);
 	private readonly _inboundAudioTracks = new Map<string, ObservedInboundTrack<'audio'>>();
@@ -170,6 +171,20 @@ export class ObservedPeerConnection extends EventEmitter {
 		return this._updated - this.created;
 	}
 
+	public get marker() {
+		return this._marker;
+	}
+
+	public set marker(value: string | undefined) {
+		this._marker = value;
+		this._inboundAudioTracks.forEach((track) => (track.marker = value));
+		this._inboundVideoTracks.forEach((track) => (track.marker = value));
+		this._outboundAudioTracks.forEach((track) => (track.marker = value));
+		this._outboundVideoTracks.forEach((track) => (track.marker = value));
+		this._dataChannels.forEach((channel) => (channel.marker = value));
+		this.ICE.marker = value;
+	}
+
 	public get closed() {
 		return this._closed;
 	}
@@ -191,9 +206,9 @@ export class ObservedPeerConnection extends EventEmitter {
 	}
 
 	public resetMetrics() {
-		this.deltaInboundLostPackets = 0;
-		this.deltaInboundReceivedPackets = 0;
-		this.deltaOutboundSentPackets = 0;
+		this.deltaInboundPacketsLost = 0;
+		this.deltaInboundPacketsReceived = 0;
+		this.deltaOutboundPacketsSent = 0;
 
 		this.deltaDataChannelBytesSent = 0;
 		this.deltaDataChannelBytesReceived = 0;
@@ -209,26 +224,26 @@ export class ObservedPeerConnection extends EventEmitter {
 	}
 
 	public updateMetrics() {
-		this.totalInboundPacketsLost = 0;
-		this.totalInboundPacketsReceived = 0;
-		this.totalOutboundPacketsSent = 0;
-		this.totalDataChannelBytesSent = 0;
-		this.totalDataChannelBytesReceived = 0;
+		// this.totalInboundPacketsLost = 0;
+		// this.totalInboundPacketsReceived = 0;
+		// this.totalOutboundPacketsSent = 0;
+		// this.totalDataChannelBytesSent = 0;
+		// this.totalDataChannelBytesReceived = 0;
 	
-		this.totalSentAudioBytes = 0;
-		this.totalSentVideoBytes = 0;
-		this.totalReceivedAudioBytes = 0;
-		this.totalReceivedVideoBytes = 0;
-		this.sendingAudioBitrate = 0;
-		this.sendingVideoBitrate = 0;
-		this.receivingAudioBitrate = 0;
-		this.receivingVideoBitrate = 0;
+		// this.totalSentAudioBytes = 0;
+		// this.totalSentVideoBytes = 0;
+		// this.totalReceivedAudioBytes = 0;
+		// this.totalReceivedVideoBytes = 0;
+		// this.sendingAudioBitrate = 0;
+		// this.sendingVideoBitrate = 0;
+		// this.receivingAudioBitrate = 0;
+		// this.receivingVideoBitrate = 0;
 
 		let sumRttInMs = 0;
 
 		this._inboundAudioTracks.forEach((track) => {
-			this.deltaInboundLostPackets += track.deltaLostPackets;
-			this.deltaInboundReceivedPackets += track.deltaReceivedPackets;
+			this.deltaInboundPacketsLost += track.deltaLostPackets;
+			this.deltaInboundPacketsReceived += track.deltaReceivedPackets;
 			this.deltaInboundReceivedBytes += track.deltaBytesReceived;
 			
 			this.deltaReceivedAudioBytes += track.deltaBytesReceived;
@@ -236,17 +251,12 @@ export class ObservedPeerConnection extends EventEmitter {
 			
 			this.receivingAudioBitrate += track.bitrate;
 
-			this.totalInboundPacketsLost += track.totalLostPackets;
-			this.totalInboundPacketsReceived += track.totalReceivedPackets;
-			this.totalReceivedAudioBytes += track.totalBytesReceived;
-			this.totalReceivedAudioPacktes += track.totalReceivedPackets;
-
 			sumRttInMs = (track.rttInMs ?? 0);
 		});
 
 		this._inboundVideoTracks.forEach((track) => {
-			this.deltaInboundLostPackets += track.deltaLostPackets;
-			this.deltaInboundReceivedPackets += track.deltaReceivedPackets;
+			this.deltaInboundPacketsLost += track.deltaLostPackets;
+			this.deltaInboundPacketsReceived += track.deltaReceivedPackets;
 			this.deltaInboundReceivedBytes += track.deltaBytesReceived;
 			
 			this.deltaReceivedVideoBytes += track.deltaBytesReceived;
@@ -254,16 +264,11 @@ export class ObservedPeerConnection extends EventEmitter {
 			
 			this.receivingVideoBitrate += track.bitrate;
 
-			this.totalInboundPacketsLost += track.totalLostPackets;
-			this.totalInboundPacketsReceived += track.totalReceivedPackets;
-			this.totalReceivedVideoBytes += track.totalBytesReceived;
-			this.totalReceivedVideoPackets += track.totalReceivedPackets;
-
 			sumRttInMs = (track.rttInMs ?? 0);
 		});
 
 		this._outboundAudioTracks.forEach((track) => {
-			this.deltaOutboundSentPackets += track.deltaSentPackets;
+			this.deltaOutboundPacketsSent += track.deltaSentPackets;
 			this.deltaOutboundSentBytes += track.deltaSentBytes;
 			
 			this.deltaSentAudioBytes += track.deltaSentBytes;
@@ -271,15 +276,11 @@ export class ObservedPeerConnection extends EventEmitter {
 			
 			this.sendingAudioBitrate += track.bitrate;
 
-			this.totalOutboundPacketsSent += track.totalSentPackets;
-			this.totalSentAudioBytes += track.totalSentBytes;
-			this.totalSentAudioPackets += track.totalSentPackets;
-
 			sumRttInMs = (track.rttInMs ?? 0);
 		});
 
 		this._outboundVideoTracks.forEach((track) => {
-			this.deltaOutboundSentPackets += track.deltaSentPackets;
+			this.deltaOutboundPacketsSent += track.deltaSentPackets;
 			this.deltaOutboundSentBytes += track.deltaSentBytes;
 			
 			this.deltaSentVideoBytes += track.deltaSentBytes;
@@ -287,18 +288,12 @@ export class ObservedPeerConnection extends EventEmitter {
 			
 			this.sendingVideoBitrate += track.bitrate;
 
-			this.totalOutboundPacketsSent += track.totalSentPackets;
-			this.totalSentVideoBytes += track.totalSentBytes;
-			this.totalSentVideoPackets += track.totalSentPackets;
-
 			sumRttInMs = (track.rttInMs ?? 0);
 		});
 
 		this._dataChannels.forEach((channel) => {
 			this.deltaDataChannelBytesSent += channel.deltaBytesSent;
 			this.deltaDataChannelBytesReceived += channel.deltaBytesReceived;
-			this.totalDataChannelBytesSent += channel.totalBytesSent;
-			this.totalDataChannelBytesReceived += channel.totalBytesReceived;
 		});
 
 		const iceRttInMs = this.ICE.stats?.currentRoundTripTime;
@@ -308,7 +303,22 @@ export class ObservedPeerConnection extends EventEmitter {
 			sumRttInMs += iceRttInMs;
 			nrOfBelongings += 1;
 		}
+
 		this.avgRttInMs = 0 < nrOfBelongings ? sumRttInMs / nrOfBelongings : undefined;
+		this.totalDataChannelBytesReceived += this.deltaDataChannelBytesReceived;
+		this.totalDataChannelBytesSent += this.deltaDataChannelBytesSent;
+		this.totalInboundPacketsLost += this.deltaInboundPacketsLost;
+		this.totalInboundPacketsReceived += this.deltaInboundPacketsReceived;
+		this.totalOutboundPacketsSent += this.deltaOutboundPacketsSent;
+		this.totalSentAudioBytes += this.deltaSentAudioBytes;
+		this.totalSentVideoBytes += this.deltaSentVideoBytes;
+		this.totalReceivedAudioBytes += this.deltaReceivedAudioBytes;
+		this.totalReceivedVideoBytes += this.deltaReceivedVideoBytes;
+		this.totalReceivedAudioPacktes += this.deltaReceivedAudioPackets;
+		this.totalReceivedVideoPackets += this.deltaReceivedVideoPackets;
+		this.totalSentAudioPackets += this.deltaSentAudioBytes;
+		this.totalSentVideoPackets += this.deltaSentVideoBytes;
+
 	}
 
 	public update(sample: PeerConnectionTransport, timestamp: number) {
@@ -330,6 +340,7 @@ export class ObservedPeerConnection extends EventEmitter {
 			...sample,
 			timestamp,
 			sampleSeq: -1, // deprecated
+			marker: this.marker,
 		};
 
 		this.reports.addPeerConnectionTransportReports(report);

package/src/ObservedSfu.ts

@@ -1,9 +1,12 @@
 import { EventEmitter } from 'events';
 import { Observer } from './Observer';
 import { SfuSample } from '@observertc/sample-schemas-js';
+import { ObservedSfuTransport, ObservedSfuTransportModel } from './ObservedSfuTransport';
+import { SfuEventReport, SfuExtensionReport } from '@observertc/report-schemas-js';
 
 export type ObservedSfuModel= {
 	serviceId: string;
+	mediaUnitId: string;
 	sfuId: string;
 	joined?: number;
 };
@@ -11,6 +14,7 @@ export type ObservedSfuModel= {
 export type ObservedSfuEvents = {
 	update: [],
 	close: [],
+	newtransport: [ObservedSfuTransport],
 };
 
 export declare interface ObservedSfu<AppData extends Record<string, unknown> = Record<string, unknown>> {
@@ -28,7 +32,12 @@ export class ObservedSfu<AppData extends Record<string, unknown> = Record<string
 
 	private _updated = Date.now();
 	private _closed = false;
-	
+	private _marker?: string;
+	private _timeZoneOffsetInHours?: number;
+	private _left?: number;
+
+	private readonly _transports = new Map<string, ObservedSfuTransport>();
+
 	public constructor(
 		private readonly _model: ObservedSfuModel,
 		public readonly observer: Observer,
@@ -38,11 +47,23 @@ export class ObservedSfu<AppData extends Record<string, unknown> = Record<string
 		this.setMaxListeners(Infinity);
 	}
 
+	public get marker() {
+		return this._marker;
+	}
+
+	public get reports() {
+		return this.observer.reports;
+	}
+
 	public get serviceId() {
 		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 		return this._model.serviceId!;
 	}
 
+	public get mediaUnitId() {
+		return this._model.mediaUnitId;
+	}
+
 	public get sfuId() {
 		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 		return this._model.sfuId!;
@@ -53,6 +74,10 @@ export class ObservedSfu<AppData extends Record<string, unknown> = Record<string
 		return Number(this._model.joined!);
 	}
 
+	public get transports(): ReadonlyMap<string, ObservedSfuTransport> {
+		return this._transports;
+	}
+
 	public get updated() {
 		return this._updated;
 	}
@@ -64,6 +89,9 @@ export class ObservedSfu<AppData extends Record<string, unknown> = Record<string
 	public close() {
 		if (this._closed) return;
 		this._closed = true;
+
+		[ ...this._transports.values() ].forEach((transport) => transport.close()); 
+
 		this.emit('close');
 	}
 
@@ -71,7 +99,95 @@ export class ObservedSfu<AppData extends Record<string, unknown> = Record<string
 		if (this._closed) throw new Error(`Sfu ${this.sfuId} is closed`);
 		if (sample.sfuId !== this.sfuId) throw new Error(`Sfu ${this.sfuId} is not the same as sample.sfuId`);
 
+		if (!this._timeZoneOffsetInHours && sample.timeZoneOffsetInHours) {
+			this._timeZoneOffsetInHours = sample.timeZoneOffsetInHours;
+		}
+
+		for (const customSfuEvents of sample.customSfuEvents ?? []) {
+			const report: SfuEventReport = {
+				serviceId: this.serviceId,
+				mediaUnitId: this.mediaUnitId,
+				sfuId: this.sfuId,
+				...customSfuEvents,
+				timestamp: sample.timestamp,
+				marker: this._marker,
+			};
+
+			this.reports.addSfuEventReport(report);
+		}
+
+		for (const extensionStats of sample.extensionStats ?? []) {
+
+			const report: SfuExtensionReport = {
+				serviceId: this.serviceId,
+				mediaUnitId: this.mediaUnitId,
+				sfuId: this.sfuId,
+				extensionType: extensionStats.type,
+				payload: extensionStats.payload,
+				timestamp: sample.timestamp,
+			};
+
+			this.reports.addSfuExtensionReport(report);
+		}
+
+		for (const transport of sample.transports ?? []) {
+			const observedSfuTransport = this._transports.get(transport.transportId) ?? this._createTransport({
+				sfuTransportId: transport.transportId,
+			});
+
+			observedSfuTransport.update(transport, sample.timestamp);
+		}
+
+		for (const inboundRtpPad of sample.inboundRtpPads ?? []) {
+			const transport = this._transports.get(inboundRtpPad.transportId) ?? this._createTransport({
+				sfuTransportId: inboundRtpPad.transportId,
+			});
+
+			const observedSfuInboundRtpPad = transport.inboundRtpPads.get(inboundRtpPad.padId) ?? transport.createSfuInboundRtpPad({
+				sfuInboundRtpPadId: inboundRtpPad.padId,
+			});
+
+			observedSfuInboundRtpPad.update(inboundRtpPad, sample.timestamp);
+		}
+
+		for (const outboundRtpPad of sample.outboundRtpPads ?? []) {
+			const transport = this._transports.get(outboundRtpPad.transportId) ?? this._createTransport({
+				sfuTransportId: outboundRtpPad.transportId,
+			});
+
+			const observedSfuOutboundRtpPad = transport.outboundRtpPads.get(outboundRtpPad.padId) ?? transport.createSfuOutboundRtpPad({
+				sfuOutboundRtpPadId: outboundRtpPad.padId,
+			});
+
+			observedSfuOutboundRtpPad.update(outboundRtpPad, sample.timestamp);
+		}
+
+		for (const sctpChannel of sample.sctpChannels ?? []) {
+			const transport = this._transports.get(sctpChannel.transportId) ?? this._createTransport({
+				sfuTransportId: sctpChannel.transportId,
+			});
+
+			const observedSfuSctpChannel = transport.sctpChannels.get(sctpChannel.channelId) ?? transport.createSfuSctpChannel({
+				sfuSctpChannelId: sctpChannel.channelId,
+			});
+
+			observedSfuSctpChannel.update(sctpChannel, sample.timestamp);
+		}
+
 		this._updated = Date.now();
 		this.emit('update');
 	}
-}
+
+	private _createTransport(model: ObservedSfuTransportModel) {
+		const result = new ObservedSfuTransport(model, this);
+
+		result.once('close', () => {
+			this._transports.delete(model.sfuTransportId);
+		});
+		this._transports.set(model.sfuTransportId, result);
+		
+		this.emit('newtransport', result);
+		
+		return result;
+	}
+}

package/src/ObservedSfuInboundRtpPad.ts

@@ -0,0 +1,100 @@
+import { EventEmitter } from 'events';
+import { SfuInboundRtpPad } from '@observertc/sample-schemas-js';
+import { ObservedSfuTransport } from './ObservedSfuTransport';
+import { SfuInboundRtpPadReport } from '@observertc/report-schemas-js';
+
+export type ObservedSfuInboundRtpPadModel= {
+	sfuInboundRtpPadId: string;
+};
+
+export type ObservedSfuInboundRtpPadEvents = {
+	update: [],
+	close: [],
+};
+
+export declare interface ObservedSfuInboundRtpPad {
+	on<U extends keyof ObservedSfuInboundRtpPadEvents>(event: U, listener: (...args: ObservedSfuInboundRtpPadEvents[U]) => void): this;
+	off<U extends keyof ObservedSfuInboundRtpPadEvents>(event: U, listener: (...args: ObservedSfuInboundRtpPadEvents[U]) => void): this;
+	once<U extends keyof ObservedSfuInboundRtpPadEvents>(event: U, listener: (...args: ObservedSfuInboundRtpPadEvents[U]) => void): this;
+	emit<U extends keyof ObservedSfuInboundRtpPadEvents>(event: U, ...args: ObservedSfuInboundRtpPadEvents[U]): boolean;
+
+	update(sample: SfuInboundRtpPad, timestamp: number): void;
+}
+
+export class ObservedSfuInboundRtpPad extends EventEmitter {
+	public readonly created = Date.now();
+
+	public stats?: SfuInboundRtpPad;
+	public marker?: string;
+	private _updated = Date.now();
+	private _closed = false;
+	
+	public constructor(
+		private readonly _model: ObservedSfuInboundRtpPadModel,
+		public readonly transport: ObservedSfuTransport,
+	) {
+		super();
+		this.setMaxListeners(Infinity);
+	}
+
+	public get reports() {
+		return this.transport.reports;
+	}
+
+	public get serviceId() {
+		return this.transport.serviceId;
+	}
+
+	public get mediaUnitId() {
+		return this.transport.mediaUnitId;
+	}
+
+	public get sfuId() {
+		return this.transport.sfuId;
+	}
+
+	public get sfuTransportId() {
+		return this.transport.sfuTransportId;
+	}
+
+	public get sfuRtpPadId() {
+		return this._model.sfuInboundRtpPadId;
+	}
+
+	public get updated() {
+		return this._updated;
+	}
+
+	public get closed() {
+		return this._closed;
+	}
+
+	public close() {
+		if (this._closed) return;
+		this._closed = true;
+		this.emit('close');
+	}
+
+	public update(sample: SfuInboundRtpPad, timestamp: number) {
+
+		const { streamId: sfuStreamId, padId: rtpPadId, ...reportData } = sample;
+
+		const report: SfuInboundRtpPadReport = {
+			serviceId: this.serviceId,
+			mediaUnitId: this.mediaUnitId,
+			sfuId: this.sfuId,
+			callId: undefined, // TODO: where to get this from?
+			sfuStreamId,
+			rtpPadId,
+			...reportData,
+			timestamp,
+			marker: this.marker,
+		};
+
+		this.reports.addSfuInboundRtpPadReport(report);
+		this.stats = sample;
+
+		this._updated = Date.now();
+		this.emit('update');
+	}
+}

package/src/ObservedSfuOutboundRtpPad.ts

@@ -0,0 +1,101 @@
+import { EventEmitter } from 'events';
+import { SfuOutboundRtpPad } from '@observertc/sample-schemas-js';
+import { SfuOutboundRtpPadReport } from '@observertc/report-schemas-js';
+import { ObservedSfuTransport } from './ObservedSfuTransport';
+
+export type ObservedSfuOutboundRtpPadModel= {
+	sfuOutboundRtpPadId: string;
+};
+
+export type ObservedSfuOutboundRtpPadEvents = {
+	update: [],
+	close: [],
+};
+
+export declare interface ObservedSfuOutboundRtpPad {
+	on<U extends keyof ObservedSfuOutboundRtpPadEvents>(event: U, listener: (...args: ObservedSfuOutboundRtpPadEvents[U]) => void): this;
+	off<U extends keyof ObservedSfuOutboundRtpPadEvents>(event: U, listener: (...args: ObservedSfuOutboundRtpPadEvents[U]) => void): this;
+	once<U extends keyof ObservedSfuOutboundRtpPadEvents>(event: U, listener: (...args: ObservedSfuOutboundRtpPadEvents[U]) => void): this;
+	emit<U extends keyof ObservedSfuOutboundRtpPadEvents>(event: U, ...args: ObservedSfuOutboundRtpPadEvents[U]): boolean;
+
+	update(sample: SfuOutboundRtpPad, timestamp: number): void;
+}
+
+export class ObservedSfuOutboundRtpPad extends EventEmitter {
+	public readonly created = Date.now();
+
+	public stats?: SfuOutboundRtpPad;
+	public marker?: string;
+	private _updated = Date.now();
+	private _closed = false;
+	
+	public constructor(
+		private readonly _model: ObservedSfuOutboundRtpPadModel,
+		public readonly transport: ObservedSfuTransport,
+	) {
+		super();
+		this.setMaxListeners(Infinity);
+	}
+
+	public get reports() {
+		return this.transport.reports;
+	}
+
+	public get serviceId() {
+		return this.transport.serviceId;
+	}
+
+	public get mediaUnitId() {
+		return this.transport.mediaUnitId;
+	}
+
+	public get sfuId() {
+		return this.transport.sfuId;
+	}
+
+	public get sfuTransportId() {
+		return this.transport.sfuTransportId;
+	}
+
+	public get sfuRtpPadId() {
+		return this._model.sfuOutboundRtpPadId;
+	}
+
+	public get updated() {
+		return this._updated;
+	}
+
+	public get closed() {
+		return this._closed;
+	}
+
+	public close() {
+		if (this._closed) return;
+		this._closed = true;
+		this.emit('close');
+	}
+
+	public update(sample: SfuOutboundRtpPad, timestamp: number) {
+
+		const { streamId: sfuStreamId, padId: rtpPadId, sinkId: sfuSinkId, ...reportData } = sample;
+
+		const report: SfuOutboundRtpPadReport = {
+			serviceId: this.serviceId,
+			mediaUnitId: this.mediaUnitId,
+			sfuId: this.sfuId,
+			callId: undefined, // TODO: where to get this from?
+			sfuStreamId,
+			sfuSinkId,
+			rtpPadId,
+			...reportData,
+			timestamp,
+			marker: this.marker,
+		};
+
+		this.reports.addSfuOutboundRtpPadReport(report);
+		this.stats = sample;
+
+		this._updated = Date.now();
+		this.emit('update');
+	}
+}

package/src/ObservedSfuSctpChannel.ts

@@ -0,0 +1,97 @@
+import { EventEmitter } from 'events';
+import { SfuSctpChannel } from '@observertc/sample-schemas-js';
+import { ObservedSfuTransport } from './ObservedSfuTransport';
+import { SfuSctpStreamReport } from '@observertc/report-schemas-js';
+
+export type ObservedSfuSctpChannelModel= {
+	sfuSctpChannelId: string;
+};
+
+export type ObservedSfuSctpChannelEvents = {
+	update: [],
+	close: [],
+};
+
+export declare interface ObservedSfuSctpChannel {
+	on<U extends keyof ObservedSfuSctpChannelEvents>(event: U, listener: (...args: ObservedSfuSctpChannelEvents[U]) => void): this;
+	off<U extends keyof ObservedSfuSctpChannelEvents>(event: U, listener: (...args: ObservedSfuSctpChannelEvents[U]) => void): this;
+	once<U extends keyof ObservedSfuSctpChannelEvents>(event: U, listener: (...args: ObservedSfuSctpChannelEvents[U]) => void): this;
+	emit<U extends keyof ObservedSfuSctpChannelEvents>(event: U, ...args: ObservedSfuSctpChannelEvents[U]): boolean;
+
+	update(sample: SfuSctpChannel, timestamp: number): void;
+}
+
+export class ObservedSfuSctpChannel extends EventEmitter {
+	public readonly created = Date.now();
+
+	public stats?: SfuSctpChannel;
+	public marker?: string;
+	private _updated = Date.now();
+	private _closed = false;
+	
+	public constructor(
+		private readonly _model: ObservedSfuSctpChannelModel,
+		public readonly transport: ObservedSfuTransport,
+	) {
+		super();
+		this.setMaxListeners(Infinity);
+	}
+
+	public get serviceId() {
+		return this.transport.serviceId;
+	}
+
+	public get sfuId() {
+		return this.transport.sfuId;
+	}
+
+	public get mediaUnitId() {
+		return this.transport.mediaUnitId;
+	}
+
+	public get sfuTransportId() {
+		return this.transport.sfuTransportId;
+	}
+
+	public get sfuSctpChannelId() {
+		return this._model.sfuSctpChannelId;
+	}
+
+	public get reports() {
+		return this.transport.reports;
+	}
+
+	public get updated() {
+		return this._updated;
+	}
+
+	public get closed() {
+		return this._closed;
+	}
+
+	public close() {
+		if (this._closed) return;
+		this._closed = true;
+		this.emit('close');
+	}
+
+	public update(sample: SfuSctpChannel, timestamp: number) {
+
+		const report: SfuSctpStreamReport = {
+			serviceId: this.serviceId,
+			mediaUnitId: this.mediaUnitId,
+			sfuId: this.sfuId,
+			callId: undefined, // TODO: where to get this from?
+			roomId: undefined, // TODO: where to get this from?
+			...sample,
+			timestamp,
+			marker: this.marker,
+		};
+
+		this.reports.addSfuTransportReport(report);
+		this.stats = sample;
+
+		this._updated = Date.now();
+		this.emit('update');
+	}
+}