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

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');
+	}
+}

package/src/ObservedSfuTransport.ts

@@ -0,0 +1,179 @@
+import { EventEmitter } from 'events';
+import { SfuTransport } from '@observertc/sample-schemas-js';
+import { ObservedSfu } from './ObservedSfu';
+import { SFUTransportReport } from '@observertc/report-schemas-js';
+import { ObservedSfuInboundRtpPad, ObservedSfuInboundRtpPadModel } from './ObservedSfuInboundRtpPad';
+import { ObservedSfuOutboundRtpPad, ObservedSfuOutboundRtpPadModel } from './ObservedSfuOutboundRtpPad';
+import { ObservedSfuSctpChannel, ObservedSfuSctpChannelModel } from './ObservedSfuSctpChannel';
+
+export type ObservedSfuTransportModel= {
+	sfuTransportId: string;
+};
+
+export type ObservedSfuTransportEvents = {
+	update: [],
+	close: [],
+	newsfuoutboundrtppad: [ObservedSfuOutboundRtpPad],
+	newsfuinboundrtppad: [ObservedSfuInboundRtpPad],
+	newsfusctpchannel: [ObservedSfuSctpChannel],
+};
+
+export declare interface ObservedSfuTransport {
+	on<U extends keyof ObservedSfuTransportEvents>(event: U, listener: (...args: ObservedSfuTransportEvents[U]) => void): this;
+	off<U extends keyof ObservedSfuTransportEvents>(event: U, listener: (...args: ObservedSfuTransportEvents[U]) => void): this;
+	once<U extends keyof ObservedSfuTransportEvents>(event: U, listener: (...args: ObservedSfuTransportEvents[U]) => void): this;
+	emit<U extends keyof ObservedSfuTransportEvents>(event: U, ...args: ObservedSfuTransportEvents[U]): boolean;
+
+	update(sample: SfuTransport, timestamp: number): void;
+}
+
+export class ObservedSfuTransport extends EventEmitter {
+	public readonly created = Date.now();
+
+	public stats?: SfuTransport;
+	private _updated = Date.now();
+	private _closed = false;
+	private _marker?: string;
+	
+	private readonly _inboundRtpPads = new Map<string, ObservedSfuInboundRtpPad>();
+	private readonly _outboundRtpPads = new Map<string, ObservedSfuOutboundRtpPad>();
+	private readonly _sctpChannels = new Map<string, ObservedSfuSctpChannel>();
+
+	public constructor(
+		private readonly _model: ObservedSfuTransportModel,
+		public readonly sfu: ObservedSfu,
+	) {
+		super();
+		this.setMaxListeners(Infinity);
+	}
+
+	public get inboundRtpPads(): ReadonlyMap<string, ObservedSfuInboundRtpPad> {
+		return this._inboundRtpPads;
+	}
+
+	public get outboundRtpPads(): ReadonlyMap<string, ObservedSfuOutboundRtpPad> {
+		return this._outboundRtpPads;
+	}
+
+	public get sctpChannels(): ReadonlyMap<string, ObservedSfuSctpChannel> {
+		return this._sctpChannels;
+	}
+
+	public get serviceId() {
+		return this.sfu.serviceId;
+	}
+
+	public get mediaUnitId() {
+		return this.sfu.mediaUnitId;
+	}
+
+	public get sfuId() {
+		return this.sfu.sfuId;
+	}
+
+	public get sfuTransportId() {
+		return this._model.sfuTransportId;
+	}
+
+	public get reports() {
+		return this.sfu.reports;
+	}
+
+	public get updated() {
+		return this._updated;
+	}
+
+	public get marker() {
+		return this._marker;
+	}
+
+	public set marker(value: string | undefined) {
+		this._marker = value;
+		this._inboundRtpPads.forEach((pad) => (pad.marker = value));
+		this._outboundRtpPads.forEach((pad) => (pad.marker = value));
+		this._sctpChannels.forEach((channel) => (channel.marker = value));
+	}
+
+	public get closed() {
+		return this._closed;
+	}
+
+	public close() {
+		if (this._closed) return;
+		this._closed = true;
+
+		[ ...this._inboundRtpPads.values() ].forEach((pad) => pad.close());
+		[ ...this._outboundRtpPads.values() ].forEach((pad) => pad.close());
+		[ ...this._sctpChannels.values() ].forEach((channel) => channel.close());
+
+		this.emit('close');
+	}
+
+	public update(sample: SfuTransport, timestamp: number) {
+		
+		const report: SFUTransportReport = {
+			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');
+	}
+
+	public createSfuOutboundRtpPad(model: ObservedSfuOutboundRtpPadModel) {
+		if (this._closed) throw new Error('Cannot create SfuOutboundRtpPad on closed SfuTransport');
+		if (this._inboundRtpPads.has(model.sfuOutboundRtpPadId)) throw new Error(`SfuOutboundRtpPad with id ${model.sfuOutboundRtpPadId} already exists`);
+
+		const result = new ObservedSfuOutboundRtpPad(model, this);
+
+		result.once('close', () => {
+			this._outboundRtpPads.delete(model.sfuOutboundRtpPadId);
+		});
+		this._outboundRtpPads.set(model.sfuOutboundRtpPadId, result);
+
+		this.emit('newsfuoutboundrtppad', result);
+
+		return result;
+	}
+
+	public createSfuInboundRtpPad(model: ObservedSfuInboundRtpPadModel) {
+		if (this._closed) throw new Error('Cannot create SfuInboundRtpPad on closed SfuTransport');
+		if (this._inboundRtpPads.has(model.sfuInboundRtpPadId)) throw new Error(`SfuInboundRtpPad with id ${model.sfuInboundRtpPadId} already exists`);
+
+		const result = new ObservedSfuInboundRtpPad(model, this);
+
+		result.once('close', () => {
+			this._inboundRtpPads.delete(model.sfuInboundRtpPadId);
+		});
+		this._inboundRtpPads.set(model.sfuInboundRtpPadId, result);
+
+		this.emit('newsfuinboundrtppad', result);
+
+		return result;
+	}
+
+	public createSfuSctpChannel(model: ObservedSfuSctpChannelModel) {
+		if (this._closed) throw new Error('Cannot create SfuSctpChannel on closed SfuTransport');
+		if (this._sctpChannels.has(model.sfuSctpChannelId)) throw new Error(`SfuSctpChannel with id ${model.sfuSctpChannelId} already exists`);
+
+		const result = new ObservedSfuSctpChannel(model, this);
+
+		result.once('close', () => {
+			this._sctpChannels.delete(model.sfuSctpChannelId);
+		});
+		this._sctpChannels.set(model.sfuSctpChannelId, result);
+
+		this.emit('newsfusctpchannel', result);
+
+		return result;
+	}
+}

package/src/Observer.ts

@@ -5,12 +5,13 @@ import { EventEmitter } from 'events';
 import { PartialBy } from './common/utils';
 import { createCallEndedEventReport, createCallStartedEventReport } from './common/callEventReports';
 import { ObserverSinkContext } from './common/types';
+import { ObservedSfu, ObservedSfuModel } from './ObservedSfu';
 
 const logger = createLogger('Observer');
 
 export type ObserverEvents = {
 	'newcall': [ObservedCall],
-	// 'newsfu': [ObservedSfu],
+	'newsfu': [ObservedSfu],
 	'reports': [ObserverSinkContext],
 	'close': [],
 }
@@ -67,6 +68,8 @@ export class Observer extends EventEmitter {
 
 	public readonly reports = new ReportsCollector();
 	private readonly _observedCalls = new Map<string, ObservedCall>();
+	private readonly _observedSfus = new Map<string, ObservedSfu>();
+
 	private _reportTimer?: ReturnType<typeof setTimeout>;
 	private _closed = false;
 	public constructor(
@@ -135,10 +138,37 @@ export class Observer extends EventEmitter {
 		return call;
 	}
 
+	public createObservedSfu<AppData extends Record<string, unknown> = Record<string, unknown>>(
+		model: ObservedSfuModel,
+		appData: AppData,
+	): ObservedSfu<AppData> {
+		if (this._closed) {
+			throw new Error('Attempted to create an sfu source on a closed observer');
+		}
+
+		const sfu = new ObservedSfu<AppData>(model, this, appData);
+
+		if (this._closed) throw new Error('Cannot create an observed sfu on a closed observer');
+		if (this._observedSfus.has(sfu.sfuId)) throw new Error(`Observed SFU with id ${sfu.sfuId} already exists`);
+
+		sfu.once('close', () => {
+			this._observedSfus.delete(sfu.sfuId);
+		});
+
+		this._observedSfus.set(sfu.sfuId, sfu);
+		this.emit('newsfu', sfu);
+		
+		return sfu;
+	}
+
 	public get observedCalls(): ReadonlyMap<string, ObservedCall> {
 		return this._observedCalls;
 	}
 
+	public get observedSfus(): ReadonlyMap<string, ObservedSfu> {
+		return this._observedSfus;
+	}
+
 	public get closed() {
 		return this._closed;
 	}