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

package/src/ObservedICE.ts

@@ -27,6 +27,8 @@ export class ObservedICE extends EventEmitter {
 		return new ObservedICE(peerConnection);
 	}
 
+	public marker?: string;
+
 	private readonly _localCandidates = new Map<string, IceLocalCandidate>();
 	private readonly _remoteCandidates = new Map<string, IceLocalCandidate>();
 	
@@ -141,6 +143,7 @@ export class ObservedICE extends EventEmitter {
 			timestamp,
 			...candidatePair,
 			sampleSeq: -1, // deprecated
+			marker: this.marker,
 		};
 
 		this.reports.addIceCandidatePairReport(report);

package/src/ObservedInboundTrack.ts

@@ -58,6 +58,7 @@ export class ObservedInboundTrack<Kind extends MediaKind> extends EventEmitter	{
 	public bitrate = 0;
 	public rttInMs?: number;
 	public fractionLoss = 0;
+	public marker?: string;
 
 	public totalLostPackets = 0;
 	public totalReceivedPackets = 0;
@@ -197,6 +198,7 @@ export class ObservedInboundTrack<Kind extends MediaKind> extends EventEmitter	{
 			remoteUserId: this.remoteOutboundTrack?.peerConnection.client.userId,
 			remoteTrackId: this.remoteOutboundTrack?.trackId,
 			remotePeerConnectionId: this.remoteOutboundTrack?.peerConnection.peerConnectionId,
+			marker: this.marker,
 		};
 
 		if (this.kind === 'audio') this.reports.addInboundAudioTrackReport(report);

package/src/ObservedOutboundTrack.ts

@@ -47,6 +47,7 @@ export class ObservedOutboundTrack<Kind extends MediaKind> extends EventEmitter
 
 	public bitrate = 0;
 	public rttInMs?: number;
+	public marker?: string;
 
 	public totalLostPackets = 0;
 	public totalSentPackets = 0;
@@ -162,6 +163,7 @@ export class ObservedOutboundTrack<Kind extends MediaKind> extends EventEmitter
 			...sample,
 			timestamp,
 			sampleSeq: -1,
+			marker: this.marker,
 		};
 
 		if (this.kind === 'audio') this.reports.addOutboundAudioTrackReport(report);

package/src/ObservedPeerConnection.ts

@@ -14,6 +14,7 @@ export type ObservedPeerConnectionEvents = {
 	newinboudvideotrack: [ObservedInboundTrack<'video'>],
 	newoutboundaudiotrack: [ObservedOutboundTrack<'audio'>],
 	newoutboundvideotrack: [ObservedOutboundTrack<'video'>],
+	newdatachannel: [ObservedDataChannel],
 };
 
 export type ObservedPeerConnectionModel = {
@@ -72,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'>>();
@@ -169,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;
 	}
@@ -329,6 +345,7 @@ export class ObservedPeerConnection extends EventEmitter {
 			...sample,
 			timestamp,
 			sampleSeq: -1, // deprecated
+			marker: this.marker,
 		};
 
 		this.reports.addPeerConnectionTransportReports(report);
@@ -421,6 +438,8 @@ export class ObservedPeerConnection extends EventEmitter {
 		});
 		this._dataChannels.set(result.channelId, result);
 
+		this.emit('newdatachannel', result);
+
 		return result;
 	}
 }

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,13 +14,17 @@ export type ObservedSfuModel= {
 export type ObservedSfuEvents = {
 	update: [],
 	close: [],
+	newtransport: [ObservedSfuTransport],
 };
 
-export declare interface ObservedSfu {
+export declare interface ObservedSfu<AppData extends Record<string, unknown> = Record<string, unknown>> {
 	on<U extends keyof ObservedSfuEvents>(event: U, listener: (...args: ObservedSfuEvents[U]) => void): this;
 	off<U extends keyof ObservedSfuEvents>(event: U, listener: (...args: ObservedSfuEvents[U]) => void): this;
 	once<U extends keyof ObservedSfuEvents>(event: U, listener: (...args: ObservedSfuEvents[U]) => void): this;
 	emit<U extends keyof ObservedSfuEvents>(event: U, ...args: ObservedSfuEvents[U]): boolean;
+
+	readonly appData: AppData;
+	update(sample: SfuSample): void;
 }
 
 export class ObservedSfu<AppData extends Record<string, unknown> = Record<string, unknown>> extends EventEmitter {
@@ -25,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,
@@ -35,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!;
@@ -50,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;
 	}
@@ -61,14 +89,105 @@ 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');
 	}
 
 	public update(sample: SfuSample) {
 		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');
+	}
+}