@observertc/observer-js 1.0.1-4daea92.0 → 1.0.1-5a1b94b.0

package/src/ObservedClientEventMonitor.ts

@@ -1,23 +1,23 @@
-import { ObservedCertificate } from './ObservedCertificate';
-import { ObservedClient } from './ObservedClient';
-import { ObservedCodec } from './ObservedCodec';
-import { ObservedDataChannel } from './ObservedDataChannel';
-import { ObservedIceCandidate } from './ObservedIceCandidate';
-import { ObservedIceCandidatePair } from './ObservedIceCandidatePair';
-import { ObservedIceTransport } from './ObservedIceTransport';
-import { ObservedInboundRtp } from './ObservedInboundRtp';
-import { ObservedInboundTrack } from './ObservedInboundTrack';
-import { ObservedMediaPlayout } from './ObservedMediaPlayout';
-import { ObservedMediaSource } from './ObservedMediaSource';
-import { ObservedOutboundRtp } from './ObservedOutboundRtp';
-import { ObservedOutboundTrack } from './ObservedOutboundTrack';
-import { ObservedPeerConnection } from './ObservedPeerConnection';
+import { ObservedCertificate } from './webrtc/ObservedCertificate';
+import { ObservedClient, ObservedClientEvents } from './ObservedClient';
+import { ObservedCodec } from './webrtc/ObservedCodec';
+import { ObservedDataChannel } from './webrtc/ObservedDataChannel';
+import { ObservedIceCandidate } from './webrtc/ObservedIceCandidate';
+import { ObservedIceCandidatePair } from './webrtc/ObservedIceCandidatePair';
+import { ObservedIceTransport } from './webrtc/ObservedIceTransport';
+import { ObservedInboundRtp } from './webrtc/ObservedInboundRtp';
+import { ObservedInboundTrack } from './webrtc/ObservedInboundTrack';
+import { ObservedMediaPlayout } from './webrtc/ObservedMediaPlayout';
+import { ObservedMediaSource } from './webrtc/ObservedMediaSource';
+import { ObservedOutboundRtp } from './webrtc/ObservedOutboundRtp';
+import { ObservedOutboundTrack } from './webrtc/ObservedOutboundTrack';
+import { ObservedPeerConnection } from './webrtc/ObservedPeerConnection';
 import { ClientIssue, ClientMetaData, ExtensionStat } from './schema/ClientSample';
 
-export class ObservedClientEventMonitor<Context> {
+export class ObservedClientEventMonitor<AppContext, ClientAppData extends Record<string, unknown> = Record<string, unknown>> {
 	public constructor(
-		public readonly observedClient: ObservedClient,
-		public readonly context: Context,
+		public readonly observedClient: ObservedClient<ClientAppData>,
+		public readonly context: AppContext,
 	) {
 		this._onPeerConnconnectionAdded = this._onPeerConnconnectionAdded.bind(this);
 		this._onPeerConnectionRemoved = this._onPeerConnectionRemoved.bind(this);
@@ -52,6 +52,8 @@ export class ObservedClientEventMonitor<Context> {
 		this._onClientLeft = this._onClientLeft.bind(this);
 		this._onUserMediaError = this._onUserMediaError.bind(this);
 		this._onUsingTurn = this._onUsingTurn.bind(this);
+		this._onClientUpdated = this._onClientUpdated.bind(this);
+		this._onClientExtensionStats = this._onClientExtensionStats.bind(this);
 
 		this.observedClient.on('newpeerconnection', this._onPeerConnconnectionAdded);
 		this.observedClient.on('issue', this._onClientIssue);
@@ -61,11 +63,17 @@ export class ObservedClientEventMonitor<Context> {
 		this.observedClient.on('rejoined', this._onClientJoined);
 		this.observedClient.on('usermediaerror', this._onUserMediaError);
 		this.observedClient.on('usingturn', this._onUsingTurn);
+		this.observedClient.on('update', this._onClientUpdated);
 		
 		this.observedClient.once('close', this._onClientClosed);
 	}
 
-	public onClientClosed?: (client: ObservedClient, ctx: Context) => void;
+	public onClientUpdated?: (client: ObservedClient, event: ObservedClientEvents['update'][0], ctx: AppContext) => void;
+	private _onClientUpdated(...args: ObservedClientEvents['update']) {
+		this.onClientUpdated?.(this.observedClient, args[0], this.context);
+	}
+
+	public onClientClosed?: (client: ObservedClient, ctx: AppContext) => void;
 	private _onClientClosed() {
 		this.onClientClosed?.(this.observedClient, this.context);
 
@@ -80,7 +88,7 @@ export class ObservedClientEventMonitor<Context> {
 
 	}
 
-	public onPeerConnectionAdded?: (peerConnection: ObservedPeerConnection, ctx: Context) => void;
+	public onPeerConnectionAdded?: (peerConnection: ObservedPeerConnection, ctx: AppContext) => void;
 	private _onPeerConnconnectionAdded(peerConnection: ObservedPeerConnection) {
 		this.onPeerConnectionAdded?.(peerConnection, this.context);
 
@@ -113,7 +121,7 @@ export class ObservedClientEventMonitor<Context> {
 
 	}
 
-	public onPeerConnectionRemoved?: (peerConnection: ObservedPeerConnection, ctx: Context) => void;
+	public onPeerConnectionRemoved?: (peerConnection: ObservedPeerConnection, ctx: AppContext) => void;
 	private _onPeerConnectionRemoved(peerConnection: ObservedPeerConnection) {
 		this.onPeerConnectionRemoved?.(peerConnection, this.context);
 
@@ -144,157 +152,157 @@ export class ObservedClientEventMonitor<Context> {
 
 	}
     
-	public onCertificateAdded?: (certificate: ObservedCertificate, ctx: Context) => void;
+	public onCertificateAdded?: (certificate: ObservedCertificate, ctx: AppContext) => void;
 	private _onCertificateAdded(certificate: ObservedCertificate) {
 		this.onCertificateAdded?.(certificate, this.context);
 	}
 
-	public onCertificateRemoved?: (certificate: ObservedCertificate, ctx: Context) => void;
+	public onCertificateRemoved?: (certificate: ObservedCertificate, ctx: AppContext) => void;
 	private _onCertificateRemoved(certificate: ObservedCertificate) {
 		this.onCertificateRemoved?.(certificate, this.context);
 	}
 
-	public onInboundTrackAdded?: (inboundTrack: ObservedInboundTrack, ctx: Context) => void;
+	public onInboundTrackAdded?: (inboundTrack: ObservedInboundTrack, ctx: AppContext) => void;
 	private _onInboundTrackAdded(inboundTrack: ObservedInboundTrack) {
 		this.onInboundTrackAdded?.(inboundTrack, this.context);
 	}
 
-	public onInboundTrackRemoved?: (inboundTrack: ObservedInboundTrack, ctx: Context) => void;
+	public onInboundTrackRemoved?: (inboundTrack: ObservedInboundTrack, ctx: AppContext) => void;
 	private _onInboundTrackRemoved(inboundTrack: ObservedInboundTrack) {
 		this.onInboundTrackRemoved?.(inboundTrack, this.context);
 	}
 
-	public onOutboundTrackAdded?: (outboundTrack: ObservedOutboundTrack, ctx: Context) => void;
+	public onOutboundTrackAdded?: (outboundTrack: ObservedOutboundTrack, ctx: AppContext) => void;
 	private _onOutboundTrackAdded(outboundTrack: ObservedOutboundTrack) {
 		this.onOutboundTrackAdded?.(outboundTrack, this.context);
 	}
 
-	public onOutboundTrackRemoved?: (outboundTrack: ObservedOutboundTrack, ctx: Context) => void;
+	public onOutboundTrackRemoved?: (outboundTrack: ObservedOutboundTrack, ctx: AppContext) => void;
 	private _onOutboundTrackRemoved(outboundTrack: ObservedOutboundTrack) {
 		this.onOutboundTrackRemoved?.(outboundTrack, this.context);
 	}
 
-	public onInboundRtpAdded?: (inboundRtp: ObservedInboundRtp, ctx: Context) => void;
+	public onInboundRtpAdded?: (inboundRtp: ObservedInboundRtp, ctx: AppContext) => void;
 	private _onInboundRtpAdded(inboundRtp: ObservedInboundRtp) {
 		this.onInboundRtpAdded?.(inboundRtp, this.context);
 	}
 
-	public onInboundRtpRemoved?: (inboundRtp: ObservedInboundRtp, ctx: Context) => void;
+	public onInboundRtpRemoved?: (inboundRtp: ObservedInboundRtp, ctx: AppContext) => void;
 	private _onInboundRtpRemoved(inboundRtp: ObservedInboundRtp) {
 		this.onInboundRtpRemoved?.(inboundRtp, this.context);
 	}
 
-	public onOutboundRtpAdded?: (outboundRtp: ObservedOutboundRtp, ctx: Context) => void;
+	public onOutboundRtpAdded?: (outboundRtp: ObservedOutboundRtp, ctx: AppContext) => void;
 	private _onOutboundRtpAdded(outboundRtp: ObservedOutboundRtp) {
 		this.onOutboundRtpAdded?.(outboundRtp, this.context);
 	}
 
-	public onOutboundRtpRemoved?: (outboundRtp: ObservedOutboundRtp, ctx: Context) => void;
+	public onOutboundRtpRemoved?: (outboundRtp: ObservedOutboundRtp, ctx: AppContext) => void;
 	private _onOutboundRtpRemoved(outboundRtp: ObservedOutboundRtp) {
 		this.onOutboundRtpRemoved?.(outboundRtp, this.context);
 	}
 
-	public onDataChannelAdded?: (dataChannel: ObservedDataChannel, ctx: Context) => void;
+	public onDataChannelAdded?: (dataChannel: ObservedDataChannel, ctx: AppContext) => void;
 	private _onDataChannelAdded(dataChannel: ObservedDataChannel) {
 		this.onDataChannelAdded?.(dataChannel, this.context);
 	}
 
-	public onDataChannelRemoved?: (dataChannel: ObservedDataChannel, ctx: Context) => void;
+	public onDataChannelRemoved?: (dataChannel: ObservedDataChannel, ctx: AppContext) => void;
 	private _onDataChannelRemoved(dataChannel: ObservedDataChannel) {
 		this.onDataChannelRemoved?.(dataChannel, this.context);
 	}
 
-	public onAddedIceTransport?: (iceTransport: ObservedIceTransport, ctx: Context) => void;
+	public onAddedIceTransport?: (iceTransport: ObservedIceTransport, ctx: AppContext) => void;
 	private _onAddedIceTransport(iceTransport: ObservedIceTransport) {
 		this.onAddedIceTransport?.(iceTransport, this.context);
 	}
 
-	public onRemovedIceTransport?: (iceTransport: ObservedIceTransport, ctx: Context) => void;
+	public onRemovedIceTransport?: (iceTransport: ObservedIceTransport, ctx: AppContext) => void;
 	private _onRemovedIceTransport(iceTransport: ObservedIceTransport) {
 		this.onRemovedIceTransport?.(iceTransport, this.context);
 	}
 
-	public onIceCandidateAdded?: (iceCandidate: ObservedIceCandidate, ctx: Context) => void;
+	public onIceCandidateAdded?: (iceCandidate: ObservedIceCandidate, ctx: AppContext) => void;
 	private _onIceCandidateAdded(iceCandidate: ObservedIceCandidate) {
 		this.onIceCandidateAdded?.(iceCandidate, this.context);
 	}
 
-	public onIceCandidateRemoved?: (iceCandidate: ObservedIceCandidate, ctx: Context) => void;
+	public onIceCandidateRemoved?: (iceCandidate: ObservedIceCandidate, ctx: AppContext) => void;
 	private _onIceCandidateRemoved(iceCandidate: ObservedIceCandidate) {
 		this.onIceCandidateRemoved?.(iceCandidate, this.context);
 	}
 
-	public onAddedIceCandidatePair?: (candidatePair: ObservedIceCandidatePair, ctx: Context) => void;
+	public onAddedIceCandidatePair?: (candidatePair: ObservedIceCandidatePair, ctx: AppContext) => void;
 	private _onAddedIceCandidatePair(candidatePair: ObservedIceCandidatePair) {
 		this.onAddedIceCandidatePair?.(candidatePair, this.context);
 	}
 
-	public onRemovedIceCandidatePair?: (candidatePair: ObservedIceCandidatePair, ctx: Context) => void;
+	public onRemovedIceCandidatePair?: (candidatePair: ObservedIceCandidatePair, ctx: AppContext) => void;
 	private _onRemovedIceCandidatePair(candidatePair: ObservedIceCandidatePair) {
 		this.onRemovedIceCandidatePair?.(candidatePair, this.context);
 	}
 
-	public onAddedMediaCodec?: (codec: ObservedCodec, ctx: Context) => void;
+	public onAddedMediaCodec?: (codec: ObservedCodec, ctx: AppContext) => void;
 	private _onAddedMediaCodec(codec: ObservedCodec) {
 		this.onAddedMediaCodec?.(codec, this.context);
 	}
 
-	public onRemovedMediaCodec?: (codec: ObservedCodec, ctx: Context) => void;
+	public onRemovedMediaCodec?: (codec: ObservedCodec, ctx: AppContext) => void;
 	private _onRemovedMediaCodec(codec: ObservedCodec) {
 		this.onRemovedMediaCodec?.(codec, this.context);
 	}
 
-	public onAddedMediaPlayout?: (mediaPlayout: ObservedMediaPlayout, ctx: Context) => void;
+	public onAddedMediaPlayout?: (mediaPlayout: ObservedMediaPlayout, ctx: AppContext) => void;
 	private _onAddedMediaPlayout(mediaPlayout: ObservedMediaPlayout) {
 		this.onAddedMediaPlayout?.(mediaPlayout, this.context);
 	}
 
-	public onRemovedMediaPlayout?: (mediaPlayout: ObservedMediaPlayout, ctx: Context) => void;
+	public onRemovedMediaPlayout?: (mediaPlayout: ObservedMediaPlayout, ctx: AppContext) => void;
 	private _onRemovedMediaPlayout(mediaPlayout: ObservedMediaPlayout) {
 		this.onRemovedMediaPlayout?.(mediaPlayout, this.context);
 	}
 
-	public onMediaSourceAdded?: (mediaSource: ObservedMediaSource, ctx: Context) => void;
+	public onMediaSourceAdded?: (mediaSource: ObservedMediaSource, ctx: AppContext) => void;
 	private _onMediaSourceAdded(mediaSource: ObservedMediaSource) {
 		this.onMediaSourceAdded?.(mediaSource, this.context);
 	}
 
-	public onMediaSourceRemoved?: (mediaSource: ObservedMediaSource, ctx: Context) => void;
+	public onMediaSourceRemoved?: (mediaSource: ObservedMediaSource, ctx: AppContext) => void;
 	private _onMediaSourceRemoved(mediaSource: ObservedMediaSource) {
 		this.onMediaSourceRemoved?.(mediaSource, this.context);
 	}
 
-	public onClientIssue?: (issue: ClientIssue, ctx: Context) => void;
+	public onClientIssue?: (issue: ClientIssue, ctx: AppContext) => void;
 	private _onClientIssue(issue: ClientIssue) {
 		this.onClientIssue?.(issue, this.context);
 	}
 
-	public onClientMetadata?: (metadata: ClientMetaData, ctx: Context) => void;
+	public onClientMetadata?: (metadata: ClientMetaData, ctx: AppContext) => void;
 	private _onClientMetadata(metadata: ClientMetaData) {
 		this.onClientMetadata?.(metadata, this.context);
 	}
 
-	public onClientExtensionStats?: (extensionStats: ExtensionStat, ctx: Context) => void;
+	public onClientExtensionStats?: (extensionStats: ExtensionStat, ctx: AppContext) => void;
 	private _onClientExtensionStats(extensionStats: ExtensionStat) {
 		this.onClientExtensionStats?.(extensionStats, this.context);
 	}
 
-	public onClientJoined?: (client: ObservedClient, ctx: Context) => void;
+	public onClientJoined?: (client: ObservedClient, ctx: AppContext) => void;
 	private _onClientJoined() {
 		this.onClientJoined?.(this.observedClient, this.context);
 	}
 
-	public onClientLeft?: (client: ObservedClient, ctx: Context) => void;
+	public onClientLeft?: (client: ObservedClient, ctx: AppContext) => void;
 	private _onClientLeft() {
 		this.onClientLeft?.(this.observedClient, this.context);
 	}
 
-	public onUserMediaError?: (error: string, observedClient: ObservedClient, ctx: Context) => void;
+	public onUserMediaError?: (error: string, observedClient: ObservedClient, ctx: AppContext) => void;
 	private _onUserMediaError(error: string) {
 		this.onUserMediaError?.(error, this.observedClient, this.context);
 	}
 
-	public onUsingTurn?: (client: ObservedClient, ctx: Context) => void;
+	public onUsingTurn?: (client: ObservedClient, ctx: AppContext) => void;
 	private _onUsingTurn() {
 		this.onUsingTurn?.(this.observedClient, this.context);
 	}

package/src/ObservedTURN.ts

@@ -1,5 +1,5 @@
 import { EventEmitter } from 'stream';
-import { ObservedPeerConnection } from './ObservedPeerConnection';
+import { ObservedPeerConnection } from './webrtc/ObservedPeerConnection';
 import { ObservedTurnServer } from './ObservedTurnServer';
 import { createLogger } from './common/logger';
 
@@ -34,6 +34,7 @@ export class ObservedTURN extends EventEmitter {
 	public constructor(
 	) {
 		super();
+		this.setMaxListeners(Infinity);
 	}
 
 	public update() {

package/src/ObservedTurnServer.ts

@@ -1,5 +1,5 @@
-import { ObservedIceCandidatePair } from './ObservedIceCandidatePair';
-import { ObservedPeerConnection } from './ObservedPeerConnection';
+import { ObservedIceCandidatePair } from './webrtc/ObservedIceCandidatePair';
+import { ObservedPeerConnection } from './webrtc/ObservedPeerConnection';
 import { ObservedTURN } from './ObservedTURN';
 
 export class ObservedTurnServer {

package/src/Observer.ts

@@ -17,19 +17,20 @@ const logger = createLogger('Observer');
 export type ObserverEvents = {
 	'client-event': [ObservedClient, ClientEvent];
 	'call-updated': [ObservedCall],
-	'client-issue': [ObservedClient, ClientIssue],
-	'client-metadata': [ObservedClient, ClientMetaData],
-	'client-extension-stats': [ObservedClient, ExtensionStat],
+	'client-issue': [ObservedClient, ClientIssue];
+	'client-metadata': [ObservedClient, ClientMetaData];
+	'client-extension-stats': [ObservedClient, ExtensionStat];
 	'newcall': [ObservedCall],
 	'update': [],
 	'close': [],
 }
 
-export type ObserverConfig = {
+export type ObserverConfig<AppData extends Record<string, unknown> = Record<string, unknown>> = {
 	updatePolicy?: 'update-on-any-call-updated' | 'update-when-all-call-updated' | 'update-on-interval',
 	updateIntervalInMs?: number,
 	defaultCallUpdatePolicy?: ObservedCallSettings['updatePolicy'],
 	defaultCallUpdateIntervalInMs?: number,
+	appData?: AppData,
 }
 
 export declare interface Observer {
@@ -39,7 +40,7 @@ export declare interface Observer {
 	emit<U extends keyof ObserverEvents>(event: U, ...args: ObserverEvents[U]): boolean;
 }
 
-export class Observer extends EventEmitter {
+export class Observer<AppData extends Record<string, unknown> = Record<string, unknown>> extends EventEmitter {
 	public readonly detectors: Detectors;
 
 	public readonly observedTURN = new ObservedTURN();
@@ -67,49 +68,45 @@ export class Observer extends EventEmitter {
 		return this.observedCalls.size;
 	}
 
-	private _timer?: ReturnType<typeof setInterval>;
-
-	public constructor(public readonly config: ObserverConfig = {
+	public constructor(public readonly config: ObserverConfig<AppData> = {
 		updatePolicy: 'update-when-all-call-updated',
 		updateIntervalInMs: undefined,
+		appData: {} as AppData,
 	}) {
 		super();
 		this.setMaxListeners(Infinity);
 		this.update = this.update.bind(this);
 
-		if (this.config.updateIntervalInMs) {
-			if (this.config.updatePolicy && this.config.updatePolicy !== 'update-on-interval') {
-				throw new Error('update policy must be update-on-interval if updateIntervalInMs is set in config');
-			}
-			this._timer = setInterval(this.update.bind(this), this.config.updateIntervalInMs);
-		}
+		const currentUpdatePolicy = (config?.updatePolicy) ?? 'update-when-all-call-updated';
 
-		if (this.config.updateIntervalInMs) {
-			if (this.config.updatePolicy !== 'update-on-interval') {
-				throw new Error('updatePolicy must be update-on-interval if updateIntervalInMs is set in config');
-			}
-		}
-		switch (this.config.updatePolicy) {
+		switch (currentUpdatePolicy) {
 			case 'update-on-any-call-updated':
-				this.updater = new OnAllCallObserverUpdater(this);	
+				this.updater = new OnAnyCallObserverUpdater(this);
 				break;
 			case 'update-when-all-call-updated':
-				this.updater = new OnAnyCallObserverUpdater(this);	
+				this.updater = new OnAllCallObserverUpdater(this);
 				break;
-			case 'update-on-interval': 
-				if (!this.config.updateIntervalInMs) {
+			case 'update-on-interval': {
+				const interval = config?.updateIntervalInMs;
+
+				if (!interval) {
 					throw new Error('updateIntervalInMs setting in config must be set if updatePolicy is update-on-interval');
 				}
 				this.updater = new OnIntervalUpdater(
-					this.config.updateIntervalInMs,
+					interval,
 					this.update.bind(this),
 				);
 				break;
+			}
 		}
 		
 		this.detectors = new Detectors();
 	}
 
+	public get appData() {
+		return this.config.appData;
+	}
+
 	public getObservedCall<T extends Record<string, unknown> = Record<string, unknown>>(callId: string): ObservedCall<T> | undefined {
 		if (this.closed || !this.observedCalls.has(callId)) return;
 		
@@ -155,8 +152,6 @@ export class Observer extends EventEmitter {
 			return logger.debug('Attempted to close twice');
 		}
 		this.closed = true;
-		clearInterval(this._timer);
-		this._timer = undefined;
 
 		this.observedCalls.forEach((call) => call.close());