@observertc/observer-js 1.0.1-c3edea3.0 → 1.0.1-c665f5a.0

package/lib/ObservedCall.js

@@ -5,38 +5,83 @@ const events_1 = require("events");
 const ObservedClient_1 = require("./ObservedClient");
 const DefaultCallScoreCalculator_1 = require("./scores/DefaultCallScoreCalculator");
 const Detectors_1 = require("./detectors/Detectors");
-const OnAllClientCallUpdater_1 = require("./utils/OnAllClientCallUpdater");
-const onAnyClientCallUpdater_1 = require("./utils/onAnyClientCallUpdater");
+const OnAllClientCallUpdater_1 = require("./updaters/OnAllClientCallUpdater");
+const OnIntervalUpdater_1 = require("./updaters/OnIntervalUpdater");
+const OnAnyClientCallUpdater_1 = require("./updaters/OnAnyClientCallUpdater");
+const ObservedCallEventMonitor_1 = require("./ObservedCallEventMonitor");
+const logger_1 = require("./common/logger");
+const logger = (0, logger_1.createLogger)('ObservedCall');
 class ObservedCall extends events_1.EventEmitter {
     observer;
     detectors;
+    updater;
+    scoreCalculator;
     callId;
     observedClients = new Map();
+    clientsUsedTurn = new Set();
     calculatedScore = {
         weight: 1,
         value: undefined,
     };
     remoteTrackResolver;
-    callUpdater;
+    totalAddedClients = 0;
+    totalRemovedClients = 0;
+    totalClientsReceivedAudioBytes = 0;
+    totalClientsReceivedVideoBytes = 0;
+    totalClientsReceivedDataChannelBytes = 0;
+    totalClientsReceivedBytes = 0;
+    totalClientsSentAudioBytes = 0;
+    totalClientsSentDataChannelBytes = 0;
+    totalClientsSentVideoBytes = 0;
+    totalClientsSentBytes = 0;
+    totalRttLt50Measurements = 0;
+    totalRttLt150Measurements = 0;
+    totalRttLt300Measurements = 0;
+    totalRttGtOrEq300Measurements = 0;
+    numberOfIssues = 0;
+    numberOfPeerConnections = 0;
+    numberOfInboundRtpStreams = 0;
+    numberOfOutboundRtpStreams = 0;
+    numberOfDataChannels = 0;
+    maxNumberOfClients = 0;
+    deltaNumberOfIssues = 0;
+    deltaRttLt50Measurements = 0;
+    deltaRttLt150Measurements = 0;
+    deltaRttLt300Measurements = 0;
+    deltaRttGtOrEq300Measurements = 0;
     appData;
     closed = false;
-    started;
-    ended;
-    scoreCalculator;
+    startedAt;
+    endedAt;
+    closedAt;
+    maxIdleIfEmptyMs;
+    _autoCloseTimer;
     constructor(settings, observer) {
         super();
         this.observer = observer;
         this.setMaxListeners(Infinity);
         this.callId = settings.callId;
-        this.appData = settings.appData;
+        this.appData = settings.appData ?? {};
         this.scoreCalculator = new DefaultCallScoreCalculator_1.DefaultCallScoreCalculator(this);
+        this.maxIdleIfEmptyMs = settings.maxIdleIfEmptyMs;
         this.detectors = new Detectors_1.Detectors();
-        switch (settings.callUpdaterPolicy) {
-            case 'onAllClientsUpdate':
-                this.callUpdater = new OnAllClientCallUpdater_1.OnAllClientCallUpdater(this);
+        if (settings.updateIntervalInMs) {
+            if (settings.updatePolicy !== 'update-on-interval') {
+                throw new Error('updatePolicy must be update-on-interval if updateIntervalInMs is set in config');
+            }
+        }
+        switch (settings.updatePolicy) {
+            case 'update-on-any-client-updated':
+                this.updater = new OnAnyClientCallUpdater_1.OnAnyClientCallUpdater(this);
+                break;
+            case 'update-when-all-client-updated':
+                this.updater = new OnAllClientCallUpdater_1.OnAllClientCallUpdater(this);
                 break;
-            case 'onAnyClientUpdate':
-                this.callUpdater = new onAnyClientCallUpdater_1.OnAnyClientCallUpdater(this);
+            case 'update-on-interval':
+                if (!settings.updateIntervalInMs) {
+                    throw new Error('updateIntervalInMs setting in config must be set if updatePolicy is update-on-interval');
+                }
+                this.updater = new OnIntervalUpdater_1.OnIntervalUpdater(settings.updateIntervalInMs, this.update.bind(this));
                 break;
         }
         switch (settings.remoteTrackResolvePolicy) {
@@ -44,14 +89,32 @@ class ObservedCall extends events_1.EventEmitter {
                 break;
         }
     }
+    get numberOfClients() {
+        return this.observedClients.size;
+    }
     get score() {
         return this.calculatedScore.value;
     }
     close() {
         if (this.closed)
             return;
+        this.update(); // last update before closing
         this.closed = true;
-        [...this.observedClients.values()].forEach((client) => client.close());
+        this.updater?.close();
+        let minSampleTimestamps;
+        let maxSampleTimestamps;
+        for (const client of this.observedClients.values()) {
+            client.close();
+            if (client.joinedAt)
+                minSampleTimestamps = Math.min(minSampleTimestamps ?? client.joinedAt, client.joinedAt);
+            if (client.leftAt)
+                maxSampleTimestamps = Math.max(maxSampleTimestamps ?? client.leftAt, client.leftAt);
+        }
+        if (this.startedAt === undefined)
+            this.startedAt = minSampleTimestamps;
+        if (this.endedAt === undefined)
+            this.endedAt = maxSampleTimestamps;
+        this.closedAt = Date.now();
         this.emit('close');
     }
     getObservedClient(clientId) {
@@ -66,26 +129,105 @@ class ObservedCall extends events_1.EventEmitter {
             throw new Error(`Client with id ${settings.clientId} already exists`);
         const result = new ObservedClient_1.ObservedClient(settings, this);
         const wasEmpty = this.observedClients.size === 0;
-        const onUpdate = () => this.callUpdater?.onClientUpdate(result);
+        const onUpdate = () => this._onClientUpdate(result);
+        const joined = () => this._clientJoined(result);
+        const left = () => this._clientLeft(result);
         result.once('close', () => {
             result.off('update', onUpdate);
+            result.off('joined', joined);
+            result.off('left', left);
             this.observedClients.delete(settings.clientId);
             if (this.observedClients.size === 0) {
                 this.emit('empty');
+                this._createAutoClose();
             }
+            ++this.totalRemovedClients;
         });
         result.on('update', onUpdate);
+        result.on('joined', joined);
+        result.on('left', left);
+        ++this.totalAddedClients;
         this.observedClients.set(settings.clientId, result);
+        this.maxNumberOfClients = Math.max(this.maxNumberOfClients, this.observedClients.size);
         this.emit('newclient', result);
         if (wasEmpty) {
             this.emit('not-empty');
+            clearTimeout(this._autoCloseTimer);
+            this._autoCloseTimer = undefined;
         }
         return result;
     }
+    createEventMonitor(context) {
+        return new ObservedCallEventMonitor_1.ObservedCallEventMonitor(this, context);
+    }
     update() {
+        if (this.closed)
+            return;
+        this.numberOfInboundRtpStreams = 0;
+        this.numberOfOutboundRtpStreams = 0;
+        this.numberOfPeerConnections = 0;
+        this.numberOfDataChannels = 0;
+        for (const client of this.observedClients.values()) {
+            this.numberOfInboundRtpStreams += client.numberOfInboundRtpStreams;
+            this.numberOfOutboundRtpStreams += client.numberOfOutboundRtpStreams;
+            this.numberOfPeerConnections += client.numberOfPeerConnections;
+            this.numberOfDataChannels += client.numberOfDataChannels;
+        }
         this.detectors.update();
         this.scoreCalculator.update();
         this.emit('update');
+        this.deltaNumberOfIssues = 0;
+        this.deltaRttLt50Measurements = 0;
+        this.deltaRttLt150Measurements = 0;
+        this.deltaRttLt300Measurements = 0;
+        this.deltaRttGtOrEq300Measurements = 0;
+    }
+    _onClientUpdate(client) {
+        this.totalClientsReceivedAudioBytes += client.deltaReceivedAudioBytes;
+        this.totalClientsReceivedVideoBytes += client.deltaReceivedVideoBytes;
+        this.totalClientsReceivedDataChannelBytes += client.deltaDataChannelBytesReceived;
+        this.totalClientsReceivedBytes += client.deltaTransportReceivedBytes;
+        this.totalClientsSentAudioBytes += client.deltaSentAudioBytes;
+        this.totalClientsSentVideoBytes += client.deltaSentVideoBytes;
+        this.totalClientsSentDataChannelBytes += client.deltaDataChannelBytesSent;
+        this.totalClientsSentBytes += client.deltaTransportSentBytes;
+        this.deltaRttLt50Measurements += client.deltaRttLt50Measurements;
+        this.deltaRttLt150Measurements += client.deltaRttLt150Measurements;
+        this.deltaRttLt300Measurements += client.deltaRttLt300Measurements;
+        this.deltaRttGtOrEq300Measurements += client.deltaRttGtOrEq300Measurements;
+        this.totalRttLt50Measurements += client.deltaRttLt50Measurements;
+        this.totalRttLt150Measurements += client.deltaRttLt150Measurements;
+        this.totalRttLt300Measurements += client.deltaRttLt300Measurements;
+        this.totalRttGtOrEq300Measurements += client.deltaRttGtOrEq300Measurements;
+        this.deltaNumberOfIssues += client.deltaNumberOfIssues;
+        this.numberOfIssues += client.deltaNumberOfIssues;
+        if (client.usingTURN) {
+            this.clientsUsedTurn.add(client.clientId);
+        }
+    }
+    _clientJoined(client) {
+        if (!client.joinedAt)
+            return;
+        this.startedAt = Math.min(this.startedAt ?? client.joinedAt, client.joinedAt);
+    }
+    _clientLeft(client) {
+        if (!client.leftAt)
+            return;
+        this.endedAt = Math.max(this.endedAt ?? client.leftAt, client.leftAt);
+    }
+    _createAutoClose() {
+        if (this.closed)
+            return;
+        if (this.maxIdleIfEmptyMs === undefined || this.maxIdleIfEmptyMs < 1)
+            return;
+        this._autoCloseTimer = setTimeout(() => {
+            if (this.closed)
+                return;
+            if (this.observedClients.size > 0)
+                return;
+            logger.debug(`Call ${this.callId} is empty for ${this.maxIdleIfEmptyMs}ms, closing...`);
+            this.close();
+        }, this.maxIdleIfEmptyMs);
     }
 }
 exports.ObservedCall = ObservedCall;

package/lib/ObservedCallEventMonitor.d.ts

@@ -0,0 +1,104 @@
+import { ObservedCall } from './ObservedCall';
+import { ObservedCertificate } from './webrtc/ObservedCertificate';
+import { ObservedClient } 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 { ClientEvent, ClientIssue, ClientMetaData, ClientSample, ExtensionStat } from './schema/ClientSample';
+export declare class ObservedCallEventMonitor<Context> {
+    readonly call: ObservedCall;
+    readonly context: Context;
+    constructor(call: ObservedCall, context: Context);
+    onCallClosed?: (call: ObservedCall, ctx: Context) => void;
+    onCallEmpty?: (call: ObservedCall, ctx: Context) => void;
+    onCallNotEmpty?: (call: ObservedCall, ctx: Context) => void;
+    onCallUpdated?: (call: ObservedCall, ctx: Context) => void;
+    onClientAdded?: (client: ObservedClient, ctx: Context) => void;
+    onClientClosed?: (client: ObservedClient, ctx: Context) => void;
+    onClientRejoined?: (client: ObservedClient, ctx: Context) => void;
+    onClientIssue?: (observedClent: ObservedClient, issue: ClientIssue, ctx: Context) => void;
+    onClientMetadata?: (observedClient: ObservedClient, metadata: ClientMetaData, ctx: Context) => void;
+    onClientExtensionStats?: (observedClient: ObservedClient, extensionStats: ExtensionStat, ctx: Context) => void;
+    onClientJoined?: (client: ObservedClient, ctx: Context) => void;
+    onClientLeft?: (client: ObservedClient, ctx: Context) => void;
+    onClientUserMediaError?: (observedClient: ObservedClient, error: string, ctx: Context) => void;
+    onClientUsingTurn?: (client: ObservedClient, usingTurn: boolean, ctx: Context) => void;
+    onClientUpdated?: (client: ObservedClient, sample: ClientSample, ctx: Context) => void;
+    onClientEvent?: (client: ObservedClient, event: ClientEvent, ctx: Context) => void;
+    onPeerConnectionAdded?: (peerConnection: ObservedPeerConnection, ctx: Context) => void;
+    onPeerConnectionRemoved?: (peerConnection: ObservedPeerConnection, ctx: Context) => void;
+    onSelectedCandidatePairChanged?: (peerConnection: ObservedPeerConnection, ctx: Context) => void;
+    onIceGatheringStateChange?: (peerConnection: ObservedPeerConnection, ctx: Context) => void;
+    onIceConnectionStateChange?: (peerConnection: ObservedPeerConnection, ctx: Context) => void;
+    onConnectionStateChange?: (peerConnection: ObservedPeerConnection, ctx: Context) => void;
+    onCertificateAdded?: (certificate: ObservedCertificate, ctx: Context) => void;
+    onCertificateRemoved?: (certificate: ObservedCertificate, ctx: Context) => void;
+    onInboundTrackAdded?: (inboundTrack: ObservedInboundTrack, ctx: Context) => void;
+    onInboundTrackRemoved?: (inboundTrack: ObservedInboundTrack, ctx: Context) => void;
+    onOutboundTrackAdded?: (outboundTrack: ObservedOutboundTrack, ctx: Context) => void;
+    onOutboundTrackRemoved?: (outboundTrack: ObservedOutboundTrack, ctx: Context) => void;
+    onInboundRtpAdded?: (inboundRtp: ObservedInboundRtp, ctx: Context) => void;
+    onInboundRtpRemoved?: (inboundRtp: ObservedInboundRtp, ctx: Context) => void;
+    onOutboundRtpAdded?: (outboundRtp: ObservedOutboundRtp, ctx: Context) => void;
+    onOutboundRtpRemoved?: (outboundRtp: ObservedOutboundRtp, ctx: Context) => void;
+    onDataChannelAdded?: (dataChannel: ObservedDataChannel, ctx: Context) => void;
+    onDataChannelRemoved?: (dataChannel: ObservedDataChannel, ctx: Context) => void;
+    onAddedIceTransport?: (iceTransport: ObservedIceTransport, ctx: Context) => void;
+    onRemovedIceTransport?: (iceTransport: ObservedIceTransport, ctx: Context) => void;
+    onIceCandidateAdded?: (iceCandidate: ObservedIceCandidate, ctx: Context) => void;
+    onIceCandidateRemoved?: (iceCandidate: ObservedIceCandidate, ctx: Context) => void;
+    onAddedIceCandidatePair?: (candidatePair: ObservedIceCandidatePair, ctx: Context) => void;
+    onRemovedIceCandidatePair?: (candidatePair: ObservedIceCandidatePair, ctx: Context) => void;
+    onAddedMediaCodec?: (codec: ObservedCodec, ctx: Context) => void;
+    onRemovedMediaCodec?: (codec: ObservedCodec, ctx: Context) => void;
+    onAddedMediaPlayout?: (mediaPlayout: ObservedMediaPlayout, ctx: Context) => void;
+    onRemovedMediaPlayout?: (mediaPlayout: ObservedMediaPlayout, ctx: Context) => void;
+    onMediaSourceAdded?: (mediaSource: ObservedMediaSource, ctx: Context) => void;
+    onMediaSourceRemoved?: (mediaSource: ObservedMediaSource, ctx: Context) => void;
+    private _onCallAdded;
+    private _onClientAdded;
+    private _onClientRejoined;
+    private _onPeerConnconnectionAdded;
+    private _onPeerConnectionRemoved;
+    private _onCertificateAdded;
+    private _onCertificateRemoved;
+    private _onInboundTrackAdded;
+    private _onInboundTrackRemoved;
+    private _onOutboundTrackAdded;
+    private _onOutboundTrackRemoved;
+    private _onInboundRtpAdded;
+    private _onInboundRtpRemoved;
+    private _onOutboundRtpAdded;
+    private _onOutboundRtpRemoved;
+    private _onDataChannelAdded;
+    private _onDataChannelRemoved;
+    private _onAddedIceTransport;
+    private _onRemovedIceTransport;
+    private _onIceCandidateAdded;
+    private _onIceCandidateRemoved;
+    private _onAddedIceCandidatePair;
+    private _onRemovedIceCandidatePair;
+    private _onAddedMediaCodec;
+    private _onRemovedMediaCodec;
+    private _onAddedMediaPlayout;
+    private _onRemovedMediaPlayout;
+    private _onMediaSourceAdded;
+    private _onMediaSourceRemoved;
+    private _onClientIssue;
+    private _onClientMetadata;
+    private _onClientExtensionStats;
+    private _onClientJoined;
+    private _onClientLeft;
+    private _onUserMediaError;
+    private _onUsingTurn;
+}
+//# sourceMappingURL=ObservedCallEventMonitor.d.ts.map

package/lib/ObservedCallEventMonitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObservedCallEventMonitor.d.ts","sourceRoot":"","sources":["../src/ObservedCallEventMonitor.ts"],"names":[],"mappings":"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"}

package/lib/ObservedCallEventMonitor.js

@@ -0,0 +1,314 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObservedCallEventMonitor = void 0;
+class ObservedCallEventMonitor {
+    call;
+    context;
+    constructor(call, context) {
+        this.call = call;
+        this.context = context;
+        this._onPeerConnconnectionAdded = this._onPeerConnconnectionAdded.bind(this);
+        this._onPeerConnectionRemoved = this._onPeerConnectionRemoved.bind(this);
+        this._onCertificateAdded = this._onCertificateAdded.bind(this);
+        this._onCertificateRemoved = this._onCertificateRemoved.bind(this);
+        this._onInboundTrackAdded = this._onInboundTrackAdded.bind(this);
+        this._onInboundTrackRemoved = this._onInboundTrackRemoved.bind(this);
+        this._onOutboundTrackAdded = this._onOutboundTrackAdded.bind(this);
+        this._onOutboundTrackRemoved = this._onOutboundTrackRemoved.bind(this);
+        this._onInboundRtpAdded = this._onInboundRtpAdded.bind(this);
+        this._onInboundRtpRemoved = this._onInboundRtpRemoved.bind(this);
+        this._onOutboundRtpAdded = this._onOutboundRtpAdded.bind(this);
+        this._onOutboundRtpRemoved = this._onOutboundRtpRemoved.bind(this);
+        this._onDataChannelAdded = this._onDataChannelAdded.bind(this);
+        this._onDataChannelRemoved = this._onDataChannelRemoved.bind(this);
+        this._onAddedIceTransport = this._onAddedIceTransport.bind(this);
+        this._onRemovedIceTransport = this._onRemovedIceTransport.bind(this);
+        this._onIceCandidateAdded = this._onIceCandidateAdded.bind(this);
+        this._onIceCandidateRemoved = this._onIceCandidateRemoved.bind(this);
+        this._onAddedIceCandidatePair = this._onAddedIceCandidatePair.bind(this);
+        this._onRemovedIceCandidatePair = this._onRemovedIceCandidatePair.bind(this);
+        this._onAddedMediaCodec = this._onAddedMediaCodec.bind(this);
+        this._onRemovedMediaCodec = this._onRemovedMediaCodec.bind(this);
+        this._onAddedMediaPlayout = this._onAddedMediaPlayout.bind(this);
+        this._onRemovedMediaPlayout = this._onRemovedMediaPlayout.bind(this);
+        this._onMediaSourceAdded = this._onMediaSourceAdded.bind(this);
+        this._onMediaSourceRemoved = this._onMediaSourceRemoved.bind(this);
+        this._onClientIssue = this._onClientIssue.bind(this);
+        this._onClientMetadata = this._onClientMetadata.bind(this);
+        this._onClientJoined = this._onClientJoined.bind(this);
+        this._onClientLeft = this._onClientLeft.bind(this);
+        this._onUserMediaError = this._onUserMediaError.bind(this);
+        this._onUsingTurn = this._onUsingTurn.bind(this);
+        this._onClientAdded = this._onClientAdded.bind(this);
+        this._onCallAdded = this._onCallAdded.bind(this);
+        this._onClientRejoined = this._onClientRejoined.bind(this);
+        this._onClientExtensionStats = this._onClientExtensionStats.bind(this);
+        this._onCallAdded(call);
+    }
+    // Public event handlers
+    onCallClosed;
+    onCallEmpty;
+    onCallNotEmpty;
+    onCallUpdated;
+    onClientAdded;
+    onClientClosed;
+    onClientRejoined;
+    onClientIssue;
+    onClientMetadata;
+    onClientExtensionStats;
+    onClientJoined;
+    onClientLeft;
+    onClientUserMediaError;
+    onClientUsingTurn;
+    onClientUpdated;
+    onClientEvent;
+    onPeerConnectionAdded;
+    onPeerConnectionRemoved;
+    onSelectedCandidatePairChanged;
+    onIceGatheringStateChange;
+    onIceConnectionStateChange;
+    onConnectionStateChange;
+    onCertificateAdded;
+    onCertificateRemoved;
+    onInboundTrackAdded;
+    onInboundTrackRemoved;
+    onOutboundTrackAdded;
+    onOutboundTrackRemoved;
+    onInboundRtpAdded;
+    onInboundRtpRemoved;
+    onOutboundRtpAdded;
+    onOutboundRtpRemoved;
+    onDataChannelAdded;
+    onDataChannelRemoved;
+    onAddedIceTransport;
+    onRemovedIceTransport;
+    onIceCandidateAdded;
+    onIceCandidateRemoved;
+    onAddedIceCandidatePair;
+    onRemovedIceCandidatePair;
+    onAddedMediaCodec;
+    onRemovedMediaCodec;
+    onAddedMediaPlayout;
+    onRemovedMediaPlayout;
+    onMediaSourceAdded;
+    onMediaSourceRemoved;
+    _onCallAdded(call) {
+        const onCallEmpty = () => this.onCallEmpty?.(call, this.context);
+        const onCallNotEmpty = () => this.onCallNotEmpty?.(call, this.context);
+        const onCallUpdated = () => this.onCallUpdated?.(call, this.context);
+        call.once('close', () => {
+            call.off('newclient', this._onClientAdded);
+            call.off('empty', onCallEmpty);
+            call.off('not-empty', onCallNotEmpty);
+            call.off('update', onCallUpdated);
+            this.onCallClosed?.(call, this.context);
+        });
+        call.on('newclient', this._onClientAdded);
+        call.on('empty', onCallEmpty);
+        call.on('not-empty', onCallNotEmpty);
+        call.on('update', onCallUpdated);
+    }
+    _onClientAdded(observedClient) {
+        const onClientIssue = (issue) => this._onClientIssue(observedClient, issue);
+        const onClientMetadata = (metaData) => this._onClientMetadata(observedClient, metaData);
+        const onClientJoined = () => this._onClientJoined(observedClient);
+        const onClientLeft = () => this._onClientLeft(observedClient);
+        const onClientRejoined = () => this._onClientRejoined(observedClient);
+        const onClientExtensionStats = (extensionStats) => this._onClientExtensionStats(observedClient, extensionStats);
+        const onUsingTurn = (usingTurn) => this._onUsingTurn(observedClient, usingTurn);
+        const onUserMediaError = (error) => this._onUserMediaError(observedClient, error);
+        const onClientUpdated = (...args) => this.onClientUpdated?.(observedClient, args[0], this.context);
+        const onClientEvent = (event) => this.onClientEvent?.(observedClient, event, this.context);
+        observedClient.once('close', () => {
+            observedClient.off('newpeerconnection', this._onPeerConnconnectionAdded);
+            observedClient.off('issue', onClientIssue);
+            observedClient.off('metaData', onClientMetadata);
+            observedClient.off('joined', onClientJoined);
+            observedClient.off('left', onClientLeft);
+            observedClient.off('rejoined', onClientJoined);
+            observedClient.off('usermediaerror', onUserMediaError);
+            observedClient.off('usingturn', onUsingTurn);
+            observedClient.off('update', onClientUpdated);
+            observedClient.off('clientEvent', onClientEvent);
+            this.onClientClosed?.(observedClient, this.context);
+        });
+        observedClient.on('newpeerconnection', this._onPeerConnconnectionAdded);
+        observedClient.on('issue', onClientIssue);
+        observedClient.on('metaData', onClientMetadata);
+        observedClient.on('joined', onClientJoined);
+        observedClient.on('left', onClientLeft);
+        observedClient.on('rejoined', onClientRejoined);
+        observedClient.on('usermediaerror', onUserMediaError);
+        observedClient.on('usingturn', onUsingTurn);
+        observedClient.on('extensionStats', onClientExtensionStats);
+        observedClient.on('update', onClientUpdated);
+        observedClient.on('clientEvent', onClientEvent);
+        this.onClientAdded?.(observedClient, this.context);
+    }
+    _onClientRejoined(observedClient) {
+        this.onClientRejoined?.(observedClient, this.context);
+    }
+    _onPeerConnconnectionAdded(peerConnection) {
+        const onSelectedCandidatePairChanged = () => this.onSelectedCandidatePairChanged?.(peerConnection, this.context);
+        const onIceGatheringStateChange = () => this.onIceGatheringStateChange?.(peerConnection, this.context);
+        const onIceConnectionStateChange = () => this.onIceConnectionStateChange?.(peerConnection, this.context);
+        const onConnectionStateChange = () => this.onConnectionStateChange?.(peerConnection, this.context);
+        peerConnection.once('close', () => {
+            peerConnection.off('added-certificate', this._onCertificateAdded);
+            peerConnection.off('removed-certificate', this._onCertificateRemoved);
+            peerConnection.off('added-inbound-track', this._onInboundTrackAdded);
+            peerConnection.off('removed-inbound-track', this._onInboundTrackRemoved);
+            peerConnection.off('added-outbound-track', this._onOutboundTrackAdded);
+            peerConnection.off('removed-outbound-track', this._onOutboundTrackRemoved);
+            peerConnection.off('added-inbound-rtp', this._onInboundRtpAdded);
+            peerConnection.off('removed-inbound-rtp', this._onInboundRtpRemoved);
+            peerConnection.off('added-outbound-rtp', this._onOutboundRtpAdded);
+            peerConnection.off('removed-outbound-rtp', this._onOutboundRtpRemoved);
+            peerConnection.off('added-data-channel', this._onDataChannelAdded);
+            peerConnection.off('removed-data-channel', this._onDataChannelRemoved);
+            peerConnection.off('added-ice-transport', this._onAddedIceTransport);
+            peerConnection.off('removed-ice-transport', this._onRemovedIceTransport);
+            peerConnection.off('added-ice-candidate', this._onIceCandidateAdded);
+            peerConnection.off('removed-ice-candidate', this._onIceCandidateRemoved);
+            peerConnection.off('added-ice-candidate-pair', this._onAddedIceCandidatePair);
+            peerConnection.off('removed-ice-candidate-pair', this._onRemovedIceCandidatePair);
+            peerConnection.off('added-codec', this._onAddedMediaCodec);
+            peerConnection.off('removed-codec', this._onRemovedMediaCodec);
+            peerConnection.off('added-media-playout', this._onAddedMediaPlayout);
+            peerConnection.off('removed-media-playout', this._onRemovedMediaPlayout);
+            peerConnection.off('added-media-source', this._onMediaSourceAdded);
+            peerConnection.off('removed-media-source', this._onMediaSourceRemoved);
+            peerConnection.off('selectedcandidatepair', onSelectedCandidatePairChanged);
+            peerConnection.off('icegatheringstatechange', onIceGatheringStateChange);
+            peerConnection.off('iceconnectionstatechange', onIceConnectionStateChange);
+            peerConnection.off('connectionstatechange', onConnectionStateChange);
+            this.onPeerConnectionRemoved?.(peerConnection, this.context);
+        });
+        peerConnection.on('added-certificate', this._onCertificateAdded);
+        peerConnection.on('removed-certificate', this._onCertificateRemoved);
+        peerConnection.on('added-inbound-track', this._onInboundTrackAdded);
+        peerConnection.on('removed-inbound-track', this._onInboundTrackRemoved);
+        peerConnection.on('added-outbound-track', this._onOutboundTrackAdded);
+        peerConnection.on('removed-outbound-track', this._onOutboundTrackRemoved);
+        peerConnection.on('added-inbound-rtp', this._onInboundRtpAdded);
+        peerConnection.on('removed-inbound-rtp', this._onInboundRtpRemoved);
+        peerConnection.on('added-outbound-rtp', this._onOutboundRtpAdded);
+        peerConnection.on('removed-outbound-rtp', this._onOutboundRtpRemoved);
+        peerConnection.on('added-data-channel', this._onDataChannelAdded);
+        peerConnection.on('removed-data-channel', this._onDataChannelRemoved);
+        peerConnection.on('added-ice-transport', this._onAddedIceTransport);
+        peerConnection.on('removed-ice-transport', this._onRemovedIceTransport);
+        peerConnection.on('added-ice-candidate', this._onIceCandidateAdded);
+        peerConnection.on('removed-ice-candidate', this._onIceCandidateRemoved);
+        peerConnection.on('added-ice-candidate-pair', this._onAddedIceCandidatePair);
+        peerConnection.on('removed-ice-candidate-pair', this._onRemovedIceCandidatePair);
+        peerConnection.on('added-codec', this._onAddedMediaCodec);
+        peerConnection.on('removed-codec', this._onRemovedMediaCodec);
+        peerConnection.on('added-media-playout', this._onAddedMediaPlayout);
+        peerConnection.on('removed-media-playout', this._onRemovedMediaPlayout);
+        peerConnection.on('added-media-source', this._onMediaSourceAdded);
+        peerConnection.on('removed-media-source', this._onMediaSourceRemoved);
+        peerConnection.on('selectedcandidatepair', onSelectedCandidatePairChanged);
+        peerConnection.on('icegatheringstatechange', onIceGatheringStateChange);
+        peerConnection.on('iceconnectionstatechange', onIceConnectionStateChange);
+        peerConnection.on('connectionstatechange', onConnectionStateChange);
+        this.onPeerConnectionAdded?.(peerConnection, this.context);
+    }
+    _onPeerConnectionRemoved(peerConnection) {
+        this.onPeerConnectionRemoved?.(peerConnection, this.context);
+    }
+    _onCertificateAdded(certificate) {
+        this.onCertificateAdded?.(certificate, this.context);
+    }
+    _onCertificateRemoved(certificate) {
+        this.onCertificateRemoved?.(certificate, this.context);
+    }
+    _onInboundTrackAdded(inboundTrack) {
+        this.onInboundTrackAdded?.(inboundTrack, this.context);
+    }
+    _onInboundTrackRemoved(inboundTrack) {
+        this.onInboundTrackRemoved?.(inboundTrack, this.context);
+    }
+    _onOutboundTrackAdded(outboundTrack) {
+        this.onOutboundTrackAdded?.(outboundTrack, this.context);
+    }
+    _onOutboundTrackRemoved(outboundTrack) {
+        this.onOutboundTrackRemoved?.(outboundTrack, this.context);
+    }
+    _onInboundRtpAdded(inboundRtp) {
+        this.onInboundRtpAdded?.(inboundRtp, this.context);
+    }
+    _onInboundRtpRemoved(inboundRtp) {
+        this.onInboundRtpRemoved?.(inboundRtp, this.context);
+    }
+    _onOutboundRtpAdded(outboundRtp) {
+        this.onOutboundRtpAdded?.(outboundRtp, this.context);
+    }
+    _onOutboundRtpRemoved(outboundRtp) {
+        this.onOutboundRtpRemoved?.(outboundRtp, this.context);
+    }
+    _onDataChannelAdded(dataChannel) {
+        this.onDataChannelAdded?.(dataChannel, this.context);
+    }
+    _onDataChannelRemoved(dataChannel) {
+        this.onDataChannelRemoved?.(dataChannel, this.context);
+    }
+    _onAddedIceTransport(iceTransport) {
+        this.onAddedIceTransport?.(iceTransport, this.context);
+    }
+    _onRemovedIceTransport(iceTransport) {
+        this.onRemovedIceTransport?.(iceTransport, this.context);
+    }
+    _onIceCandidateAdded(iceCandidate) {
+        this.onIceCandidateAdded?.(iceCandidate, this.context);
+    }
+    _onIceCandidateRemoved(iceCandidate) {
+        this.onIceCandidateRemoved?.(iceCandidate, this.context);
+    }
+    _onAddedIceCandidatePair(candidatePair) {
+        this.onAddedIceCandidatePair?.(candidatePair, this.context);
+    }
+    _onRemovedIceCandidatePair(candidatePair) {
+        this.onRemovedIceCandidatePair?.(candidatePair, this.context);
+    }
+    _onAddedMediaCodec(codec) {
+        this.onAddedMediaCodec?.(codec, this.context);
+    }
+    _onRemovedMediaCodec(codec) {
+        this.onRemovedMediaCodec?.(codec, this.context);
+    }
+    _onAddedMediaPlayout(mediaPlayout) {
+        this.onAddedMediaPlayout?.(mediaPlayout, this.context);
+    }
+    _onRemovedMediaPlayout(mediaPlayout) {
+        this.onRemovedMediaPlayout?.(mediaPlayout, this.context);
+    }
+    _onMediaSourceAdded(mediaSource) {
+        this.onMediaSourceAdded?.(mediaSource, this.context);
+    }
+    _onMediaSourceRemoved(mediaSource) {
+        this.onMediaSourceRemoved?.(mediaSource, this.context);
+    }
+    _onClientIssue(observedClent, issue) {
+        this.onClientIssue?.(observedClent, issue, this.context);
+    }
+    _onClientMetadata(observedClient, metadata) {
+        this.onClientMetadata?.(observedClient, metadata, this.context);
+    }
+    _onClientExtensionStats(observedClient, extensionStats) {
+        this.onClientExtensionStats?.(observedClient, extensionStats, this.context);
+    }
+    _onClientJoined(observedClient) {
+        this.onClientJoined?.(observedClient, this.context);
+    }
+    _onClientLeft(observedClient) {
+        this.onClientLeft?.(observedClient, this.context);
+    }
+    _onUserMediaError(observedClient, error) {
+        this.onClientUserMediaError?.(observedClient, error, this.context);
+    }
+    _onUsingTurn(observedClient, usingTurn) {
+        this.onClientUsingTurn?.(observedClient, usingTurn, this.context);
+    }
+}
+exports.ObservedCallEventMonitor = ObservedCallEventMonitor;