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

package/src/ObservedClientEventMonitor.ts

@@ -0,0 +1,309 @@
+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<AppContext, ClientAppData extends Record<string, unknown> = Record<string, unknown>> {
+	public constructor(
+		public readonly observedClient: ObservedClient<ClientAppData>,
+		public readonly context: AppContext,
+	) {
+		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._onClientClosed = this._onClientClosed.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._onClientUpdated = this._onClientUpdated.bind(this);
+		this._onClientExtensionStats = this._onClientExtensionStats.bind(this);
+
+		this.observedClient.on('newpeerconnection', this._onPeerConnconnectionAdded);
+		this.observedClient.on('issue', this._onClientIssue);
+		this.observedClient.on('metaData', this._onClientMetadata);
+		this.observedClient.on('joined', this._onClientJoined);
+		this.observedClient.on('left', this._onClientLeft);
+		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 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);
+
+		this.observedClient.off('newpeerconnection', this._onPeerConnconnectionAdded);
+		this.observedClient.off('issue', this._onClientIssue);
+		this.observedClient.off('metaData', this._onClientMetadata);
+		this.observedClient.off('joined', this._onClientJoined);
+		this.observedClient.off('left', this._onClientLeft);
+		this.observedClient.off('rejoined', this._onClientJoined);
+		this.observedClient.off('usermediaerror', this._onUserMediaError);
+		this.observedClient.off('usingturn', this._onUsingTurn);
+
+	}
+
+	public onPeerConnectionAdded?: (peerConnection: ObservedPeerConnection, ctx: AppContext) => void;
+	private _onPeerConnconnectionAdded(peerConnection: ObservedPeerConnection) {
+		this.onPeerConnectionAdded?.(peerConnection, this.context);
+
+		peerConnection.once('close', () => this._onPeerConnectionRemoved(peerConnection));
+        
+		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);
+
+	}
+
+	public onPeerConnectionRemoved?: (peerConnection: ObservedPeerConnection, ctx: AppContext) => void;
+	private _onPeerConnectionRemoved(peerConnection: ObservedPeerConnection) {
+		this.onPeerConnectionRemoved?.(peerConnection, this.context);
+
+		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);
+
+	}
+    
+	public onCertificateAdded?: (certificate: ObservedCertificate, ctx: AppContext) => void;
+	private _onCertificateAdded(certificate: ObservedCertificate) {
+		this.onCertificateAdded?.(certificate, this.context);
+	}
+
+	public onCertificateRemoved?: (certificate: ObservedCertificate, ctx: AppContext) => void;
+	private _onCertificateRemoved(certificate: ObservedCertificate) {
+		this.onCertificateRemoved?.(certificate, this.context);
+	}
+
+	public onInboundTrackAdded?: (inboundTrack: ObservedInboundTrack, ctx: AppContext) => void;
+	private _onInboundTrackAdded(inboundTrack: ObservedInboundTrack) {
+		this.onInboundTrackAdded?.(inboundTrack, this.context);
+	}
+
+	public onInboundTrackRemoved?: (inboundTrack: ObservedInboundTrack, ctx: AppContext) => void;
+	private _onInboundTrackRemoved(inboundTrack: ObservedInboundTrack) {
+		this.onInboundTrackRemoved?.(inboundTrack, this.context);
+	}
+
+	public onOutboundTrackAdded?: (outboundTrack: ObservedOutboundTrack, ctx: AppContext) => void;
+	private _onOutboundTrackAdded(outboundTrack: ObservedOutboundTrack) {
+		this.onOutboundTrackAdded?.(outboundTrack, this.context);
+	}
+
+	public onOutboundTrackRemoved?: (outboundTrack: ObservedOutboundTrack, ctx: AppContext) => void;
+	private _onOutboundTrackRemoved(outboundTrack: ObservedOutboundTrack) {
+		this.onOutboundTrackRemoved?.(outboundTrack, this.context);
+	}
+
+	public onInboundRtpAdded?: (inboundRtp: ObservedInboundRtp, ctx: AppContext) => void;
+	private _onInboundRtpAdded(inboundRtp: ObservedInboundRtp) {
+		this.onInboundRtpAdded?.(inboundRtp, this.context);
+	}
+
+	public onInboundRtpRemoved?: (inboundRtp: ObservedInboundRtp, ctx: AppContext) => void;
+	private _onInboundRtpRemoved(inboundRtp: ObservedInboundRtp) {
+		this.onInboundRtpRemoved?.(inboundRtp, this.context);
+	}
+
+	public onOutboundRtpAdded?: (outboundRtp: ObservedOutboundRtp, ctx: AppContext) => void;
+	private _onOutboundRtpAdded(outboundRtp: ObservedOutboundRtp) {
+		this.onOutboundRtpAdded?.(outboundRtp, this.context);
+	}
+
+	public onOutboundRtpRemoved?: (outboundRtp: ObservedOutboundRtp, ctx: AppContext) => void;
+	private _onOutboundRtpRemoved(outboundRtp: ObservedOutboundRtp) {
+		this.onOutboundRtpRemoved?.(outboundRtp, this.context);
+	}
+
+	public onDataChannelAdded?: (dataChannel: ObservedDataChannel, ctx: AppContext) => void;
+	private _onDataChannelAdded(dataChannel: ObservedDataChannel) {
+		this.onDataChannelAdded?.(dataChannel, this.context);
+	}
+
+	public onDataChannelRemoved?: (dataChannel: ObservedDataChannel, ctx: AppContext) => void;
+	private _onDataChannelRemoved(dataChannel: ObservedDataChannel) {
+		this.onDataChannelRemoved?.(dataChannel, this.context);
+	}
+
+	public onAddedIceTransport?: (iceTransport: ObservedIceTransport, ctx: AppContext) => void;
+	private _onAddedIceTransport(iceTransport: ObservedIceTransport) {
+		this.onAddedIceTransport?.(iceTransport, this.context);
+	}
+
+	public onRemovedIceTransport?: (iceTransport: ObservedIceTransport, ctx: AppContext) => void;
+	private _onRemovedIceTransport(iceTransport: ObservedIceTransport) {
+		this.onRemovedIceTransport?.(iceTransport, this.context);
+	}
+
+	public onIceCandidateAdded?: (iceCandidate: ObservedIceCandidate, ctx: AppContext) => void;
+	private _onIceCandidateAdded(iceCandidate: ObservedIceCandidate) {
+		this.onIceCandidateAdded?.(iceCandidate, this.context);
+	}
+
+	public onIceCandidateRemoved?: (iceCandidate: ObservedIceCandidate, ctx: AppContext) => void;
+	private _onIceCandidateRemoved(iceCandidate: ObservedIceCandidate) {
+		this.onIceCandidateRemoved?.(iceCandidate, this.context);
+	}
+
+	public onAddedIceCandidatePair?: (candidatePair: ObservedIceCandidatePair, ctx: AppContext) => void;
+	private _onAddedIceCandidatePair(candidatePair: ObservedIceCandidatePair) {
+		this.onAddedIceCandidatePair?.(candidatePair, this.context);
+	}
+
+	public onRemovedIceCandidatePair?: (candidatePair: ObservedIceCandidatePair, ctx: AppContext) => void;
+	private _onRemovedIceCandidatePair(candidatePair: ObservedIceCandidatePair) {
+		this.onRemovedIceCandidatePair?.(candidatePair, this.context);
+	}
+
+	public onAddedMediaCodec?: (codec: ObservedCodec, ctx: AppContext) => void;
+	private _onAddedMediaCodec(codec: ObservedCodec) {
+		this.onAddedMediaCodec?.(codec, this.context);
+	}
+
+	public onRemovedMediaCodec?: (codec: ObservedCodec, ctx: AppContext) => void;
+	private _onRemovedMediaCodec(codec: ObservedCodec) {
+		this.onRemovedMediaCodec?.(codec, this.context);
+	}
+
+	public onAddedMediaPlayout?: (mediaPlayout: ObservedMediaPlayout, ctx: AppContext) => void;
+	private _onAddedMediaPlayout(mediaPlayout: ObservedMediaPlayout) {
+		this.onAddedMediaPlayout?.(mediaPlayout, this.context);
+	}
+
+	public onRemovedMediaPlayout?: (mediaPlayout: ObservedMediaPlayout, ctx: AppContext) => void;
+	private _onRemovedMediaPlayout(mediaPlayout: ObservedMediaPlayout) {
+		this.onRemovedMediaPlayout?.(mediaPlayout, this.context);
+	}
+
+	public onMediaSourceAdded?: (mediaSource: ObservedMediaSource, ctx: AppContext) => void;
+	private _onMediaSourceAdded(mediaSource: ObservedMediaSource) {
+		this.onMediaSourceAdded?.(mediaSource, this.context);
+	}
+
+	public onMediaSourceRemoved?: (mediaSource: ObservedMediaSource, ctx: AppContext) => void;
+	private _onMediaSourceRemoved(mediaSource: ObservedMediaSource) {
+		this.onMediaSourceRemoved?.(mediaSource, this.context);
+	}
+
+	public onClientIssue?: (issue: ClientIssue, ctx: AppContext) => void;
+	private _onClientIssue(issue: ClientIssue) {
+		this.onClientIssue?.(issue, this.context);
+	}
+
+	public onClientMetadata?: (metadata: ClientMetaData, ctx: AppContext) => void;
+	private _onClientMetadata(metadata: ClientMetaData) {
+		this.onClientMetadata?.(metadata, this.context);
+	}
+
+	public onClientExtensionStats?: (extensionStats: ExtensionStat, ctx: AppContext) => void;
+	private _onClientExtensionStats(extensionStats: ExtensionStat) {
+		this.onClientExtensionStats?.(extensionStats, this.context);
+	}
+
+	public onClientJoined?: (client: ObservedClient, ctx: AppContext) => void;
+	private _onClientJoined() {
+		this.onClientJoined?.(this.observedClient, this.context);
+	}
+
+	public onClientLeft?: (client: ObservedClient, ctx: AppContext) => void;
+	private _onClientLeft() {
+		this.onClientLeft?.(this.observedClient, this.context);
+	}
+
+	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: AppContext) => void;
+	private _onUsingTurn() {
+		this.onUsingTurn?.(this.observedClient, this.context);
+	}
+}

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/ObservedTURN.ts

@@ -0,0 +1,87 @@
+import { EventEmitter } from 'stream';
+import { ObservedPeerConnection } from './webrtc/ObservedPeerConnection';
+import { ObservedTurnServer } from './ObservedTurnServer';
+import { createLogger } from './common/logger';
+
+const logger = createLogger('ObservedTURN');
+
+export type ObservedTURNEventMap = {
+	'update': [ObservedTURN];
+	'close': [];
+}
+
+export declare interface ObservedTURN {
+	on<U extends keyof ObservedTURNEventMap>(event: U, listener: (...args: ObservedTURNEventMap[U]) => void): this;
+	off<U extends keyof ObservedTURNEventMap>(event: U, listener: (...args: ObservedTURNEventMap[U]) => void): this;
+	once<U extends keyof ObservedTURNEventMap>(event: U, listener: (...args: ObservedTURNEventMap[U]) => void): this;
+	emit<U extends keyof ObservedTURNEventMap>(event: U, ...args: ObservedTURNEventMap[U]): boolean;
+}
+
+export class ObservedTURN extends EventEmitter {
+	public totalBytesSent = 0;
+	public totalBytesReceived = 0;
+	public totalPacketsSent = 0;
+	public totalPacketsReceived = 0;
+
+	public packetsSentPerSecond = 0;
+	public packetsReceivedPerSecond = 0;
+	public outboundBitrate = 0;
+	public inboundBitrate = 0;
+	public numberOfClients = 0;
+    
+	public readonly servers = new Map<string, ObservedTurnServer>();
+
+	public constructor(
+	) {
+		super();
+		this.setMaxListeners(Infinity);
+	}
+
+	public update() {
+		const clientIds = new Set<string>();
+        
+		this.packetsReceivedPerSecond = 0;
+		this.packetsSentPerSecond = 0;
+		this.outboundBitrate = 0;
+		this.inboundBitrate = 0;
+
+		for (const server of this.servers.values()) {
+			server.update();
+			server.observedPeerConnections.forEach((pc) => clientIds.add(pc.client.clientId));
+		}
+
+		this.numberOfClients = clientIds.size;
+	}
+
+	public addPeerConnection(peerConnection: ObservedPeerConnection) {
+		const turnPairs = peerConnection.selectedIceCandidatePairs.filter((pair) => pair.getLocalCandidate()?.candidateType === 'relay' && pair.getRemoteCandidate()?.url?.startsWith('turn:'));
+
+		if (turnPairs.length !== 1) {
+			return (logger.warn(`Expected exactly one TURN pair, but found for peerconnection ${peerConnection.peerConnectionId}`, turnPairs.length), undefined);
+		}
+
+		const candidatePair = turnPairs[0];
+		const rawUrl = candidatePair.getRemoteCandidate()?.url;
+
+		if (!rawUrl) {
+			return (logger.warn(`No remote candidate URL found for peerconnection ${peerConnection.peerConnectionId}`), undefined);
+		}
+
+		const turnUrl = new URL(rawUrl);
+		const turnServerUrl = `${turnUrl.protocol}//${turnUrl.hostname}:${turnUrl.port}`;
+		let turnServer = this.servers.get(turnServerUrl);
+        
+		if (!turnServer) {
+			turnServer = new ObservedTurnServer(turnServerUrl, this);
+		}
+
+		return turnServer;
+	}
+
+	public removePeerConnection(peerConnection: ObservedPeerConnection) {
+		for (const turnServer of this.servers.values()) {
+			turnServer.observedPeerConnections.delete(peerConnection.peerConnectionId);
+		}
+	}
+
+}

package/src/ObservedTurnServer.ts

@@ -0,0 +1,72 @@
+import { ObservedIceCandidatePair } from './webrtc/ObservedIceCandidatePair';
+import { ObservedPeerConnection } from './webrtc/ObservedPeerConnection';
+import { ObservedTURN } from './ObservedTURN';
+
+export class ObservedTurnServer {
+	public totalBytesSent = 0;
+	public totalBytesReceived = 0;
+	public totalPacketsSent = 0;
+	public totalPacketsReceived = 0;
+
+	public packetsSentPerSecond = 0;
+	public packetsReceivedPerSecond = 0;
+	public outboundBitrate = 0;
+	public inboundBitrate = 0;
+
+	public deltaBytesSent = 0;
+	public deltaBytesReceived = 0;
+	public deltaPacketsSent = 0;
+	public deltaPacketsReceived = 0;
+    
+	public readonly observedPeerConnections = new Map<string, ObservedPeerConnection>(); 
+
+	public updated = Date.now();
+
+	public constructor(
+		public readonly url: string,
+		public readonly observedTURN: ObservedTURN,
+	) {
+
+	}
+
+	public updateTurnUsage(...selectedcandidatepairs: ObservedIceCandidatePair[]) {
+		for (const selectedcandidatepair of selectedcandidatepairs) {
+			this.deltaBytesReceived += selectedcandidatepair.deltaBytesReceived;
+			this.deltaBytesSent += selectedcandidatepair.deltaBytesSent;
+			this.deltaPacketsReceived += selectedcandidatepair.deltaPacketsReceived;
+			this.deltaPacketsSent += selectedcandidatepair.deltaPacketsSent;
+		}
+	}
+
+	public update() {
+		const now = Date.now();
+		const deltaInS = (now - this.updated) / 1000;
+        
+		this.packetsSentPerSecond = this.deltaPacketsSent / deltaInS;
+		this.packetsReceivedPerSecond = this.deltaPacketsReceived / deltaInS;   
+		this.outboundBitrate = (this.deltaBytesReceived * 8) / deltaInS;
+		this.inboundBitrate = (this.deltaBytesSent * 8) / deltaInS;
+        
+		this.totalBytesSent += this.deltaBytesSent;
+		this.totalBytesReceived += this.deltaBytesReceived;
+		this.totalPacketsSent += this.deltaPacketsSent;
+		this.totalPacketsReceived += this.deltaPacketsReceived;
+		
+		this.observedTURN.totalBytesSent += this.deltaBytesSent;
+		this.observedTURN.totalBytesReceived += this.deltaBytesReceived;
+		this.observedTURN.totalPacketsSent += this.deltaPacketsSent;
+		this.observedTURN.totalPacketsReceived += this.deltaPacketsReceived;
+        
+		this.observedTURN.inboundBitrate += this.inboundBitrate;
+		this.observedTURN.outboundBitrate += this.outboundBitrate;
+		this.observedTURN.packetsReceivedPerSecond += this.packetsReceivedPerSecond;
+		this.observedTURN.packetsSentPerSecond += this.packetsSentPerSecond;
+        
+		this.deltaBytesSent = 0;
+		this.deltaBytesReceived = 0;
+		this.deltaPacketsSent = 0;
+		this.deltaPacketsReceived = 0;
+
+		this.updated = now;
+	}
+}