@observertc/observer-js 1.0.1-b52220e.0 → 1.0.1-c2558cc.0

package/src/ObservedPeerConnection.ts

@@ -72,6 +72,26 @@ export type ObservedPeerConnectionEvents = {
 	'removed-peer-connection-transport': [ObservedPeerConnectionTransport];
 	'removed-remote-inbound-rtp': [ObservedRemoteInboundRtp];
 	'removed-remote-outbound-rtp': [ObservedRemoteOutboundRtp];
+	'updated-inbound-rtp': [ObservedInboundRtp];
+	'updated-outbound-rtp': [ObservedOutboundRtp];
+	'updated-inbound-track': [ObservedInboundTrack];
+	'updated-outbound-track': [ObservedOutboundTrack];
+	'updated-ice-candidate-pair': [ObservedIceCandidatePair];
+	'updated-ice-transport': [ObservedIceTransport];
+	'updated-peer-connection-transport': [ObservedPeerConnectionTransport];
+	'updated-media-source': [ObservedMediaSource];
+	'updated-media-playout': [ObservedMediaPlayout];
+	'updated-data-channel': [ObservedDataChannel];
+	'updated-ice-candidate': [ObservedIceCandidate];
+	'updated-certificate': [ObservedCertificate];
+	'updated-codec': [ObservedCodec];
+	'updated-remote-inbound-rtp': [ObservedRemoteInboundRtp];
+	'updated-remote-outbound-rtp': [ObservedRemoteOutboundRtp];
+	'muted-inbound-track': [ObservedInboundTrack];
+	'muted-outbound-track': [ObservedOutboundTrack];
+	'unmuted-inbound-track': [ObservedInboundTrack];
+	'unmuted-outbound-track': [ObservedOutboundTrack];
+
 	'update': [],
 	close: [];
 };
@@ -644,12 +664,15 @@ export class ObservedPeerConnection extends EventEmitter {
 
 			observedCertificate = new ObservedCertificate(stats.timestamp, stats.id, this);
 
+			observedCertificate.update(stats);
+
 			this.observedCertificates.set(stats.id, observedCertificate);
 			this.emit('added-certificate', observedCertificate);
+		} else {
+			observedCertificate.update(stats);
+			this.emit('updated-certificate', observedCertificate);
 		}
 
-		observedCertificate.update(stats);
-
 		return observedCertificate;
 	}
 
@@ -666,11 +689,14 @@ export class ObservedPeerConnection extends EventEmitter {
 
 			observedCodec = new ObservedCodec(stats.timestamp, stats.id, stats.mimeType, this);
 
+			observedCodec.update(stats);
+			
 			this.observedCodecs.set(stats.id, observedCodec);
 			this.emit('added-codec', observedCodec);
+		} else {
+			observedCodec.update(stats);
 		}
-
-		observedCodec.update(stats);
+		this.emit('updated-codec', observedCodec);
 
 		return observedCodec;
 	}
@@ -688,11 +714,14 @@ export class ObservedPeerConnection extends EventEmitter {
 
 			observedDataChannel = new ObservedDataChannel(stats.timestamp, stats.id, this);
 
+			observedDataChannel.update(stats);
+
 			this.observedDataChannels.set(stats.id, observedDataChannel);
 			this.emit('added-data-channel', observedDataChannel);
+		} else {
+			observedDataChannel.update(stats);
 		}
-
-		observedDataChannel.update(stats);
+		this.emit('updated-data-channel', observedDataChannel);
 
 		return observedDataChannel;
 	}
@@ -710,11 +739,14 @@ export class ObservedPeerConnection extends EventEmitter {
 
 			observedIceCandidate = new ObservedIceCandidate(stats.timestamp, stats.id, this);
 
+			observedIceCandidate.update(stats);
+
 			this.observedIceCandidates.set(stats.id, observedIceCandidate);
 			this.emit('added-ice-candidate', observedIceCandidate);
+		} else {
+			observedIceCandidate.update(stats);
 		}
-
-		observedIceCandidate.update(stats);
+		this.emit('updated-ice-candidate', observedIceCandidate);
 
 		return observedIceCandidate;
 	}
@@ -732,11 +764,14 @@ export class ObservedPeerConnection extends EventEmitter {
 
 			observedIceCandidatePair = new ObservedIceCandidatePair(stats.timestamp, stats.id, this);
 
+			observedIceCandidatePair.update(stats);
+			
 			this.observedIceCandidatesPair.set(stats.id, observedIceCandidatePair);
 			this.emit('added-ice-candidate-pair', observedIceCandidatePair);
+		} else {
+			observedIceCandidatePair.update(stats);
 		}
-
-		observedIceCandidatePair.update(stats);
+		this.emit('updated-ice-candidate-pair', observedIceCandidatePair);
 
 		return observedIceCandidatePair;
 	}
@@ -754,11 +789,14 @@ export class ObservedPeerConnection extends EventEmitter {
 
 			observedIceTransport = new ObservedIceTransport(stats.timestamp, stats.id, this);
 
+			observedIceTransport.update(stats);
+			
 			this.observedIceTransports.set(stats.id, observedIceTransport);
 			this.emit('added-ice-transport', observedIceTransport);
+		} else {
+			observedIceTransport.update(stats);
 		}
-
-		observedIceTransport.update(stats);
+		this.emit('updated-ice-transport', observedIceTransport);
 
 		return observedIceTransport;
 	}
@@ -782,12 +820,15 @@ export class ObservedPeerConnection extends EventEmitter {
 				stats.trackIdentifier,
 				this
 			);
+			
+			observedInboundRtp.update(stats);
 
 			this.observedInboundRtps.set(stats.ssrc, observedInboundRtp);
 			this.emit('added-inbound-rtp', observedInboundRtp);
+		} else {
+			observedInboundRtp.update(stats);
 		}
-
-		observedInboundRtp.update(stats);
+		this.emit('updated-inbound-rtp', observedInboundRtp);
 
 		return observedInboundRtp;
 	}
@@ -816,11 +857,14 @@ export class ObservedPeerConnection extends EventEmitter {
 				mediaPlayout,
 			);
 
+			observedInboundTrack.update(stats);
+			
 			this.observedInboundTracks.set(stats.id, observedInboundTrack);
 			this.emit('added-inbound-track', observedInboundTrack);
+		} else {
+			observedInboundTrack.update(stats);
 		}
-
-		observedInboundTrack.update(stats);
+		this.emit('updated-inbound-track', observedInboundTrack);
 
 		return observedInboundTrack;
 	}
@@ -843,11 +887,14 @@ export class ObservedPeerConnection extends EventEmitter {
 				this
 			);
 
+			observedMediaPlayout.update(stats);
+
 			this.observedMediaPlayouts.set(stats.id, observedMediaPlayout);
 			this.emit('added-media-playout', observedMediaPlayout);
+		} else {
+			observedMediaPlayout.update(stats);
 		}
-
-		observedMediaPlayout.update(stats);
+		this.emit('updated-media-playout', observedMediaPlayout);
 
 		return observedMediaPlayout;
 	}
@@ -870,11 +917,14 @@ export class ObservedPeerConnection extends EventEmitter {
 				this
 			);
 
+			observedMediaSource.update(stats);
+
 			this.observedMediaSources.set(stats.id, observedMediaSource);
 			this.emit('added-media-source', observedMediaSource);
+		} else {
+			observedMediaSource.update(stats);
 		}
-
-		observedMediaSource.update(stats);
+		this.emit('updated-media-source', observedMediaSource);
 
 		return observedMediaSource;
 	}
@@ -898,11 +948,14 @@ export class ObservedPeerConnection extends EventEmitter {
 				this
 			);
 
+			observedOutboundRtp.update(stats);
+
 			this.observedOutboundRtps.set(stats.ssrc, observedOutboundRtp);
 			this.emit('added-outbound-rtp', observedOutboundRtp);
+		} else {
+			observedOutboundRtp.update(stats);
 		}
-
-		observedOutboundRtp.update(stats);
+		this.emit('updated-outbound-rtp', observedOutboundRtp);
 		
 		return observedOutboundRtp;
 	}
@@ -930,11 +983,14 @@ export class ObservedPeerConnection extends EventEmitter {
 				observedMediaSource,
 			);
 
+			observedOutboundTrack.update(stats);
+
 			this.observedOutboundTracks.set(stats.id, observedOutboundTrack);
 			this.emit('added-outbound-track', observedOutboundTrack);
+		} else {
+			observedOutboundTrack.update(stats);
 		}
-
-		observedOutboundTrack.update(stats);
+		this.emit('updated-outbound-track', observedOutboundTrack);
 
 		return observedOutboundTrack;
 	}
@@ -952,11 +1008,14 @@ export class ObservedPeerConnection extends EventEmitter {
 
 			observedPeerConnectionTransport = new ObservedPeerConnectionTransport(stats.timestamp, stats.id, this);
 
+			observedPeerConnectionTransport.update(stats);
+
 			this.observedPeerConnectionTransports.set(stats.id, observedPeerConnectionTransport);
 			this.emit('added-peer-connection-transport', observedPeerConnectionTransport);
+		} else {
+			observedPeerConnectionTransport.update(stats);
 		}
-
-		observedPeerConnectionTransport.update(stats);
+		this.emit('updated-peer-connection-transport', observedPeerConnectionTransport);
 
 		return observedPeerConnectionTransport;
 	}
@@ -980,11 +1039,14 @@ export class ObservedPeerConnection extends EventEmitter {
 				this
 			);
 
+			observedRemoteInboundRtp.update(stats);
+
 			this.observedRemoteInboundRtps.set(stats.ssrc, observedRemoteInboundRtp);
 			this.emit('added-remote-inbound-rtp', observedRemoteInboundRtp);
+		} else {
+			observedRemoteInboundRtp.update(stats);
 		}
-
-		observedRemoteInboundRtp.update(stats);
+		this.emit('updated-remote-inbound-rtp', observedRemoteInboundRtp);
 
 		return observedRemoteInboundRtp;
 	}
@@ -1008,11 +1070,14 @@ export class ObservedPeerConnection extends EventEmitter {
 				this
 			);
 
+			observedRemoteOutboundRtp.update(stats);
+
 			this.observedRemoteOutboundRtps.set(stats.ssrc, observedRemoteOutboundRtp);
 			this.emit('added-remote-outbound-rtp', observedRemoteOutboundRtp);
+		} else {
+			observedRemoteOutboundRtp.update(stats);
 		}
-
-		observedRemoteOutboundRtp.update(stats);
+		this.emit('updated-remote-outbound-rtp', observedRemoteOutboundRtp);
 
 		return observedRemoteOutboundRtp;
 	}

package/src/Observer.ts

@@ -7,8 +7,10 @@ import { ObservedTURN } from './ObservedTURN';
 import { Detectors } from './detectors/Detectors';
 import { Updater } from './updaters/Updater';
 import { OnIntervalUpdater } from './updaters/OnIntervalUpdater';
-import { OnAllCallObserverUpdater } from './updaters/OnAllCallObserverUpdater_';
-import { OnAnyCallObserverUpdater } from './updaters/OnAnyCallObserverUpdater_';
+import { OnAllCallObserverUpdater } from './updaters/OnAllCallObserverUpdater';
+import { OnAnyCallObserverUpdater } from './updaters/OnAnyCallObserverUpdater';
+import { ObserverEventMonitor } from './ObserverEventMonitor';
+import { MediasoupRemoteTrackResolver } from './utils/MediasoupRemoteTrackResolver';
 
 const logger = createLogger('Observer');
 
@@ -23,11 +25,12 @@ export type ObserverEvents = {
 	'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 {
@@ -37,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,9 +70,10 @@ export class Observer extends EventEmitter {
 
 	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);
@@ -108,6 +112,10 @@ export class Observer extends EventEmitter {
 		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;
 		
@@ -124,12 +132,15 @@ export class Observer extends EventEmitter {
 			settings.updatePolicy = this.config.defaultCallUpdatePolicy;
 			settings.updateIntervalInMs = this.config.defaultCallUpdateIntervalInMs;
 		}
-
 		const observedCall = new ObservedCall(settings, this);
 		const onCallUpdated = () => this._onObservedCallUpdated(observedCall);
 
 		if (this.observedCalls.has(observedCall.callId)) throw new Error(`Observed Call with id ${observedCall.callId} already exists`);
 
+		if (settings.remoteTrackResolvePolicy === 'mediasoup-sfu') {
+			observedCall.remoteTrackResolver = new MediasoupRemoteTrackResolver(observedCall);
+		}
+
 		observedCall.once('close', () => {
 			this.observedCalls.delete(observedCall.callId);
 			observedCall.off('update', onCallUpdated);
@@ -210,6 +221,10 @@ export class Observer extends EventEmitter {
 		this.totalClientIssues += call.deltaNumberOfIssues;
 	}
 
+	public createEventMonitor<CTX = unknown>(ctx?: CTX): ObserverEventMonitor<CTX> {
+		return new ObserverEventMonitor<CTX>(this, ctx ?? {} as CTX);
+	}
+
 	// public resetSummaryMetrics() {
 	// 	this.totalAddedCall = 0;
 	// 	this.totalRemovedCall = 0;