@observertc/observer-js 0.42.9 → 1.0.1-28c6425.0

package/src/ObservedClientSummary.ts

@@ -0,0 +1,24 @@
+export type ObservedClientSummary = {
+	totalInboundPacketsLost: number,
+	totalInboundPacketsReceived: number,
+	totalOutboundPacketsSent: number,
+	totalDataChannelBytesSent: number,
+	totalDataChannelBytesReceived: number,
+	totalDataChannelMessagesSent: number,
+	totalDataChannelMessagesReceived: number,
+	totalSentBytes: number,
+	totalReceivedBytes: number,
+	totalReceivedAudioBytes: number,
+	totalReceivedVideoBytes: number,
+	totalSentAudioBytes: number,
+	totalSentVideoBytes: number,
+
+	totalRttLt50Measurements: number,
+	totalRttLt150Measurements: number,
+	totalRttLt300Measurements: number,
+	totalRttGtOrEq300Measurements: number,
+	totalScoreSum: number,
+	numberOfScoreMeasurements: number,
+    
+	numberOfIssues: number,
+}

package/src/ObservedCodec.ts

@@ -0,0 +1,49 @@
+import { ObservedPeerConnection } from './ObservedPeerConnection';
+import { CodecStats } from './schema/ClientSample';
+
+export class ObservedCodec implements CodecStats {
+	private _visited = false;
+	public appData?: Record<string, unknown>;
+
+	payloadType?: number | undefined;
+	transportId?: string | undefined;
+	clockRate?: number | undefined;
+	channels?: number | undefined;
+	sdpFmtpLine?: string | undefined;
+	attachments?: Record<string, unknown> | undefined;
+
+	public constructor(
+		public timestamp: number,
+		public id: string,
+		public mimeType: string,
+		private readonly _peerConnection: ObservedPeerConnection
+	) {}
+
+	public get visited() {
+		const visited = this._visited;
+
+		this._visited = false;
+
+		return visited;
+	}
+
+	public getPeerConnection() {
+		return this._peerConnection;
+	}
+
+	public getIceTransport() {
+		return this._peerConnection.observedIceTransports.get(this.transportId ?? '');
+	}
+
+	public update(stats: CodecStats) {
+		this._visited = true;
+
+		this.timestamp = stats.timestamp;
+		this.payloadType = stats.payloadType;
+		this.transportId = stats.transportId;
+		this.clockRate = stats.clockRate;
+		this.channels = stats.channels;
+		this.sdpFmtpLine = stats.sdpFmtpLine;
+		this.attachments = stats.attachments;
+	}
+}

package/src/ObservedDataChannel.ts

@@ -1,195 +1,82 @@
-import { EventEmitter } from 'events';
 import { ObservedPeerConnection } from './ObservedPeerConnection';
-import { DataChannel } from '@observertc/sample-schemas-js';
-import { ClientDataChannelReport } from '@observertc/report-schemas-js';
+import { DataChannelStats } from './schema/ClientSample';
 
 export type ObservedDataChannelState = 'connecting' | 'open' | 'closing' | 'closed';
 
-export type ObservedDataChannelModel = {
-	channelId: number;
-}
-
-export type ObservedDataChannelEvents = {
-	update: [{
-		elapsedTimeInMs: number;
-	}],
-	close: [],
-};
-
-export type ObservedInboundTrackStats = {
-	ssrc: number;
-	bitrate: number;
-	fractionLost: number;
-	rttInMs?: number;
-	lostPackets?: number;
-	receivedPackets?: number;
-	receivedFrames?: number;
-	decodedFrames?: number;
-	droppedFrames?: number;
-	receivedSamples?: number;
-	silentConcealedSamples?: number;
-	fractionLoss?: number;
-};
-
-// {
-// 	[Property in keyof ObservedInboundTrackStats<K>]: ObservedInboundTrackStats<K>[Property];
-// }
-
-export declare interface ObservedDataChannel {
-	on<U extends keyof ObservedDataChannelEvents>(event: U, listener: (...args: ObservedDataChannelEvents[U]) => void): this;
-	off<U extends keyof ObservedDataChannelEvents>(event: U, listener: (...args: ObservedDataChannelEvents[U]) => void): this;
-	once<U extends keyof ObservedDataChannelEvents>(event: U, listener: (...args: ObservedDataChannelEvents[U]) => void): this;
-	emit<U extends keyof ObservedDataChannelEvents>(event: U, ...args: ObservedDataChannelEvents[U]): boolean;
-	update(sample: DataChannel, timestamp: number): void;
-}
-
-export class ObservedDataChannel extends EventEmitter	{
-	public readonly created = Date.now();
-	public visited = false;
-
-	private _stats?: DataChannel;
+export class ObservedDataChannel implements DataChannelStats	{
+	private _visited = false;
 	
-	private _closed = false;
-	private _updated = Date.now();
-	public bitrate = 0;
-	public marker?: string;
+	label?: string | undefined;
+	protocol?: string | undefined;
+	dataChannelIdentifier?: number | undefined;
+	state?: string | undefined;
+	messagesSent?: number | undefined;
+	bytesSent?: number | undefined;
+	messagesReceived?: number | undefined;
+	bytesReceived?: number | undefined;
+	attachments?: Record<string, unknown> | undefined;
 
-	public totalReceivedMessages = 0;
-	public totalSentMessages = 0;
-	public totalBytesReceived = 0;
-	public totalBytesSent = 0;
-	
-	public deltaReceivedMessages = 0;
-	public deltaSentMessages = 0;
-	public deltaBytesReceived = 0;
 	public deltaBytesSent = 0;
+	public deltaBytesReceived = 0;
+	public deltaMessagesSent = 0;
+	public deltaMessagesReceived = 0;
+
+	public appData?: Record<string, unknown>;
 
 	public constructor(
-		private readonly _model: ObservedDataChannelModel,
-		public readonly peerConnection: ObservedPeerConnection,
+		public timestamp: number,
+		public id: string,
+		private readonly _peerConnection: ObservedPeerConnection,
 	) {
-		super();
-		this.setMaxListeners(Infinity);
-	}
-
-	public get serviceId() {
-		return this.peerConnection.serviceId;
-	}
-
-	public get roomId() {
-		return this.peerConnection.roomId;
-	}
-
-	public get callId() {
-		return this.peerConnection.callId;
-	}
-
-	public get clientId() {
-		return this.peerConnection.clientId;
-	}
-
-	public get mediaUnitId() {
-		return this.peerConnection.mediaUnitId;
-	}
-
-	public get peerConnectionId() {
-		return this.peerConnection.peerConnectionId;
-	}
-
-	public get channelId() {
-		return this._model.channelId;
-	}
-
-	public get updated() {
-		return this._updated;
-	}
-
-	public get state(): ObservedDataChannelState | undefined {
-		return this._stats?.state as ObservedDataChannelState | undefined;
-	}
-
-	public get label() {
-		return this._stats?.label;
-	}
-
-	public get protocol() {
-		return this._stats?.protocol;
 	}
 
-	public get reports() {
-		return this.peerConnection.reports;
-	}
-
-	public get stats() {
-		return this._stats;
-	}
-
-	public get closed() {
-		return this._closed;
-	}
-
-	public close() {
-		if (this._closed) return;
-
-		this._closed = true;
-
-		this.emit('close');
-	}
-
-	public resetMetrics() {
-		this.bitrate = 0;
-		this.totalReceivedMessages = 0;
-		this.totalSentMessages = 0;
-		this.totalBytesReceived = 0;
-		this.totalBytesSent = 0;
-		this.deltaReceivedMessages = 0;
-		this.deltaSentMessages = 0;
-		this.deltaBytesReceived = 0;
-	}
-
-	public update(sample: DataChannel, timestamp: number) {
-		if (this._closed) return;
-		
-		const now = Date.now();
-
-		const report: ClientDataChannelReport = {
-			serviceId: this.peerConnection.client.call.serviceId,
-			roomId: this.peerConnection.client.call.roomId,
-			callId: this.peerConnection.client.call.callId,
-			clientId: this.peerConnection.client.clientId,
-			userId: this.peerConnection.client.userId,
-			mediaUnitId: this.peerConnection.client.mediaUnitId,
-			...sample,
-			timestamp,
-			sampleSeq: -1,
-			marker: this.marker,
-		};
-
-		this.reports.addClientDataChannelReport(report);
-
-		sample.bytesReceived;
-		sample.bytesSent;
-		sample.messageReceived;
-		sample.messageSent;
-		
-		const elapsedTimeInMs = Math.max(1, now - this._updated);
-
-		this.bitrate = ((sample.bytesReceived ?? 0) - (this._stats?.bytesReceived ?? 0)) * 8 / (elapsedTimeInMs / 1000);
-		this.deltaSentMessages = (sample.messageSent ?? 0) - (this._stats?.messageSent ?? 0);
-		this.deltaReceivedMessages = (sample.messageReceived ?? 0) - (this._stats?.messageReceived ?? 0);
-		this.deltaBytesSent = (sample.bytesSent ?? 0) - (this._stats?.bytesSent ?? 0);
-		this.deltaBytesReceived = (sample.bytesReceived ?? 0) - (this._stats?.bytesReceived ?? 0);
-
-		this.totalBytesReceived = sample.bytesReceived ?? 0;
-		this.totalBytesSent = sample.bytesSent ?? 0;
-		this.totalReceivedMessages = sample.messageReceived ?? 0;
-		this.totalSentMessages = sample.messageSent ?? 0;
-
-		this.visited = true;
-		this._stats = sample;
-		this._updated = timestamp;
-		this.emit('update', {
-			elapsedTimeInMs,
-		});
+	public get visited() {
+		const visited = this._visited;
+	
+		this._visited = false;
+	
+		return visited;
+	}
+
+	public getPeerConnection() {
+		return this._peerConnection;
+	}
+
+	public update(stats: DataChannelStats) {
+		this._visited = true;
+
+		if (this.messagesSent && stats.messagesSent && stats.messagesSent >= this.messagesSent) {
+			this.deltaMessagesSent = stats.messagesSent - this.messagesSent;
+		} else {
+			this.deltaMessagesSent = 0;
+		}
+
+		if (this.messagesReceived && stats.messagesReceived && stats.messagesReceived >= this.messagesReceived) {
+			this.deltaMessagesReceived = stats.messagesReceived - this.messagesReceived;
+		} else {
+			this.deltaMessagesReceived = 0;
+		}
+
+		if (this.bytesSent && stats.bytesSent && stats.bytesSent >= this.bytesSent) {
+			this.deltaBytesSent = stats.bytesSent - this.bytesSent;
+		} else {
+			this.deltaBytesSent = 0;
+		}
+
+		if (this.bytesReceived && stats.bytesReceived && stats.bytesReceived >= this.bytesReceived) {
+			this.deltaBytesReceived = stats.bytesReceived - this.bytesReceived;
+		} else {
+			this.deltaBytesReceived = 0;
+		}
+
+		this.label = stats.label;
+		this.protocol = stats.protocol;
+		this.dataChannelIdentifier = stats.dataChannelIdentifier;
+		this.state = stats.state;
+		this.messagesSent = stats.messagesSent;
+		this.bytesSent = stats.bytesSent;
+		this.messagesReceived = stats.messagesReceived;
+		this.bytesReceived = stats.bytesReceived;
+		this.attachments = stats.attachments;
 	}
 }

package/src/ObservedIceCandidate.ts

@@ -0,0 +1,64 @@
+import { ObservedPeerConnection } from './ObservedPeerConnection';
+import { IceCandidateStats } from './schema/ClientSample';
+
+export class ObservedIceCandidate implements IceCandidateStats {
+	private _visited = false;
+	public appData?: Record<string, unknown>;
+
+	transportId?: string | undefined;
+	address?: string | undefined;
+	port?: number | undefined;
+	protocol?: string | undefined;
+	candidateType?: string | undefined;
+	priority?: number | undefined;
+	url?: string | undefined;
+	relayProtocol?: string | undefined;
+	foundation?: string | undefined;
+	relatedAddress?: string | undefined;
+	relatedPort?: number | undefined;
+	usernameFragment?: string | undefined;
+	tcpType?: string | undefined;
+	attachments?: Record<string, unknown> | undefined;
+
+	public constructor(
+		public timestamp: number,
+		public id: string,
+		private readonly _peerConnection: ObservedPeerConnection
+	) {}
+
+	public get visited() {
+		const visited = this._visited;
+
+		this._visited = false;
+
+		return visited;
+	}
+
+	public getPeerConnection() {
+		return this._peerConnection;
+	}
+
+	public getIceTransport() {
+		return this._peerConnection.observedIceTransports.get(this.transportId ?? '');
+	}
+
+	public update(stats: IceCandidateStats) {
+		this._visited = true;
+
+		this.timestamp = stats.timestamp;
+		this.transportId = stats.transportId;
+		this.address = stats.address;
+		this.port = stats.port;
+		this.protocol = stats.protocol;
+		this.candidateType = stats.candidateType;
+		this.priority = stats.priority;
+		this.url = stats.url;
+		this.relayProtocol = stats.relayProtocol;
+		this.foundation = stats.foundation;
+		this.relatedAddress = stats.relatedAddress;
+		this.relatedPort = stats.relatedPort;
+		this.usernameFragment = stats.usernameFragment;
+		this.tcpType = stats.tcpType;
+		this.attachments = stats.attachments;
+	}
+}

package/src/ObservedIceCandidatePair.ts

@@ -0,0 +1,118 @@
+import { ObservedPeerConnection } from './ObservedPeerConnection';
+import { IceCandidatePairStats } from './schema/ClientSample';
+
+export class ObservedIceCandidatePair implements IceCandidatePairStats {
+	private _visited = false;
+	public appData?: Record<string, unknown>;
+
+	transportId?: string | undefined;
+	localCandidateId?: string | undefined;
+	remoteCandidateId?: string | undefined;
+	state?: 'new' | 'inProgress' | 'failed' | 'succeeded' | undefined;
+	nominated?: boolean | undefined;
+	packetsSent?: number | undefined;
+	packetsReceived?: number | undefined;
+	bytesSent?: number | undefined;
+	bytesReceived?: number | undefined;
+	lastPacketSentTimestamp?: number | undefined;
+	lastPacketReceivedTimestamp?: number | undefined;
+	totalRoundTripTime?: number | undefined;
+	currentRoundTripTime?: number | undefined;
+	availableOutgoingBitrate?: number | undefined;
+	availableIncomingBitrate?: number | undefined;
+	requestsReceived?: number | undefined;
+	requestsSent?: number | undefined;
+	responsesReceived?: number | undefined;
+	responsesSent?: number | undefined;
+	consentRequestsSent?: number | undefined;
+	packetsDiscardedOnSend?: number | undefined;
+	bytesDiscardedOnSend?: number | undefined;
+	attachments?: Record<string, unknown> | undefined;
+
+	public deltaBytesSent = 0;
+	public deltaBytesReceived = 0;
+	public deltaPacketsSent = 0;
+	public deltaPacketsReceived = 0;
+
+	public constructor(
+		public timestamp: number,
+		public id: string,
+		private readonly _peerConnection: ObservedPeerConnection,
+	) {
+	}
+
+	public get visited() {
+		const visited = this._visited;
+	
+		this._visited = false;
+	
+		return visited;
+	}
+
+	public getPeerConnection() {
+		return this._peerConnection;
+	}
+
+	public getIceTransport() {
+		return this._peerConnection.observedIceTransports.get(this.transportId ?? '');
+	}
+
+	public getLocalCandidate() {
+		return this._peerConnection.observedIceCandidates.get(this.localCandidateId ?? '');
+	}
+
+	public getRemoteCandidate() {
+		return this._peerConnection.observedIceCandidates.get(this.remoteCandidateId ?? '');
+	}
+
+	public update(stats: IceCandidatePairStats) {
+		this._visited = true;
+
+		if (this.packetsSent && stats.packetsSent && stats.packetsSent >= this.packetsSent) {
+			this.deltaPacketsSent = stats.packetsSent - this.packetsSent;
+		} else {
+			this.deltaPacketsSent = 0;
+		}
+		if (this.packetsReceived && stats.packetsReceived && stats.packetsReceived >= this.packetsReceived) {
+			this.deltaPacketsReceived = stats.packetsReceived - this.packetsReceived;
+		} else {
+			this.deltaPacketsReceived = 0;
+		}
+		if (this.bytesSent && stats.bytesSent && stats.bytesSent >= this.bytesSent) {
+			this.deltaBytesSent = stats.bytesSent - this.bytesSent;
+		} else {
+			this.deltaBytesSent = 0;
+		}
+		if (this.bytesReceived && stats.bytesReceived && stats.bytesReceived >= this.bytesReceived) {
+			this.deltaBytesReceived = stats.bytesReceived - this.bytesReceived;
+		} else {
+			this.deltaBytesReceived = 0;
+		}
+
+		this.timestamp = stats.timestamp;
+		this.transportId = stats.transportId;
+		this.localCandidateId = stats.localCandidateId;
+		this.remoteCandidateId = stats.remoteCandidateId;
+		this.state = stats.state;
+		this.nominated = stats.nominated;
+		this.packetsSent = stats.packetsSent;
+		this.packetsReceived = stats.packetsReceived;
+		this.bytesSent = stats.bytesSent;
+		this.bytesReceived = stats.bytesReceived;
+		this.lastPacketSentTimestamp = stats.lastPacketSentTimestamp;
+		this.lastPacketReceivedTimestamp = stats.lastPacketReceivedTimestamp;
+		this.totalRoundTripTime = stats.totalRoundTripTime;
+		this.currentRoundTripTime = stats.currentRoundTripTime;
+		this.availableOutgoingBitrate = stats.availableOutgoingBitrate;
+		this.availableIncomingBitrate = stats.availableIncomingBitrate;
+		this.requestsReceived = stats.requestsReceived;
+		this.requestsSent = stats.requestsSent;
+		this.responsesReceived = stats.responsesReceived;
+		this.responsesSent = stats.responsesSent;
+		this.consentRequestsSent = stats.consentRequestsSent;
+		this.packetsDiscardedOnSend = stats.packetsDiscardedOnSend;
+		this.bytesDiscardedOnSend = stats.bytesDiscardedOnSend;
+		this.attachments = stats.attachments;
+	}
+
+}

package/src/ObservedIceTransport.ts

@@ -0,0 +1,99 @@
+import { ObservedPeerConnection } from './ObservedPeerConnection';
+import { IceTransportStats } from './schema/ClientSample';
+
+export class ObservedIceTransport implements IceTransportStats {
+	private _visited = false;
+	public appData?: Record<string, unknown>;
+
+	packetsSent?: number | undefined;
+	packetsReceived?: number | undefined;
+	bytesSent?: number | undefined;
+	bytesReceived?: number | undefined;
+	iceRole?: string | undefined;
+	iceLocalUsernameFragment?: string | undefined;
+	dtlsState?: string | undefined;
+	iceState?: string | undefined;
+	selectedCandidatePairId?: string | undefined;
+	localCertificateId?: string | undefined;
+	remoteCertificateId?: string | undefined;
+	tlsVersion?: string | undefined;
+	dtlsCipher?: string | undefined;
+	dtlsRole?: string | undefined;
+	srtpCipher?: string | undefined;
+	selectedCandidatePairChanges?: number | undefined;
+	attachments?: Record<string, unknown> | undefined;
+
+	public deltaPacketsReceived = 0;
+	public deltaPacketsSent = 0;
+	public deltaBytesReceived = 0;
+	public deltaBytesSent = 0;
+
+	public constructor(
+		public timestamp: number,
+		public id: string,
+		private readonly _peerConnection: ObservedPeerConnection
+	) {}
+
+	public get visited() {
+		const visited = this._visited;
+
+		this._visited = false;
+
+		return visited;
+	}
+
+	public getPeerConnection() {
+		return this._peerConnection;
+	}
+
+	public getSelectedCandidatePair() {
+		return this._peerConnection.observedIceCandidatesPair.get(this.selectedCandidatePairId ?? '');
+	}
+
+	public update(stats: IceTransportStats) {
+		this._visited = true;
+
+		if (this.bytesReceived !== undefined && stats.bytesReceived !== undefined && this.bytesReceived <= stats.bytesReceived) {
+			this.deltaBytesReceived = stats.bytesReceived - this.bytesReceived;
+		} else {
+			this.deltaBytesReceived = 0;
+		}
+		
+		if (this.bytesSent !== undefined && stats.bytesSent !== undefined && this.bytesSent <= stats.bytesSent) {
+			this.deltaBytesSent = stats.bytesSent - this.bytesSent;
+		} else {
+			this.deltaBytesSent = 0;
+		}
+
+		if (this.packetsReceived !== undefined && stats.packetsReceived !== undefined && this.packetsReceived <= stats.packetsReceived) {
+			this.deltaPacketsReceived = stats.packetsReceived - this.packetsReceived;
+		} else {
+			this.deltaPacketsReceived = 0;
+		}
+		
+		if (this.packetsSent !== undefined && stats.packetsSent !== undefined && this.packetsSent <= stats.packetsSent) {
+			this.deltaPacketsSent = stats.packetsSent - this.packetsSent;
+		} else {
+			this.deltaPacketsSent = 0;
+		}
+
+		this.timestamp = stats.timestamp;
+		this.packetsSent = stats.packetsSent;
+		this.packetsReceived = stats.packetsReceived;
+		this.bytesSent = stats.bytesSent;
+		this.bytesReceived = stats.bytesReceived;
+		this.iceRole = stats.iceRole;
+		this.iceLocalUsernameFragment = stats.iceLocalUsernameFragment;
+		this.dtlsState = stats.dtlsState;
+		this.iceState = stats.iceState;
+		this.selectedCandidatePairId = stats.selectedCandidatePairId;
+		this.localCertificateId = stats.localCertificateId;
+		this.remoteCertificateId = stats.remoteCertificateId;
+		this.tlsVersion = stats.tlsVersion;
+		this.dtlsCipher = stats.dtlsCipher;
+		this.dtlsRole = stats.dtlsRole;
+		this.srtpCipher = stats.srtpCipher;
+		this.selectedCandidatePairChanges = stats.selectedCandidatePairChanges;
+		this.attachments = stats.attachments;
+	}
+}