@stream-io/video-client 1.20.2 → 1.21.0

package/dist/index.es.js

@@ -61,16 +61,17 @@ if (typeof navigator !== 'undefined' &&
         const original = target[method];
         if (!original)
             continue;
+        let mark = 0;
         target[method] = async function tracedMethod(constraints) {
-            const tag = `navigator.mediaDevices.${method}`;
+            const tag = `navigator.mediaDevices.${method}.${mark++}`;
             trace(tag, constraints);
             try {
                 const stream = await original.call(target, constraints);
-                trace(`${tag}OnSuccess`, dumpStream(stream));
+                trace(`${tag}.OnSuccess`, dumpStream(stream));
                 return stream;
             }
             catch (err) {
-                trace(`${tag}OnFailure`, err.name);
+                trace(`${tag}.OnFailure`, err.name);
                 throw err;
             }
         };
@@ -1795,6 +1796,47 @@ class AppleState$Type extends MessageType {
  * @generated MessageType for protobuf message stream.video.sfu.models.AppleState
  */
 const AppleState = new AppleState$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class PerformanceStats$Type extends MessageType {
+    constructor() {
+        super('stream.video.sfu.models.PerformanceStats', [
+            {
+                no: 1,
+                name: 'track_type',
+                kind: 'enum',
+                T: () => [
+                    'stream.video.sfu.models.TrackType',
+                    TrackType,
+                    'TRACK_TYPE_',
+                ],
+            },
+            { no: 2, name: 'codec', kind: 'message', T: () => Codec },
+            {
+                no: 3,
+                name: 'avg_frame_time_ms',
+                kind: 'scalar',
+                T: 2 /*ScalarType.FLOAT*/,
+            },
+            { no: 4, name: 'avg_fps', kind: 'scalar', T: 2 /*ScalarType.FLOAT*/ },
+            {
+                no: 5,
+                name: 'video_dimension',
+                kind: 'message',
+                T: () => VideoDimension,
+            },
+            {
+                no: 6,
+                name: 'target_bitrate',
+                kind: 'scalar',
+                T: 5 /*ScalarType.INT32*/,
+            },
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.models.PerformanceStats
+ */
+const PerformanceStats = new PerformanceStats$Type();
 
 var models = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -1820,6 +1862,7 @@ var models = /*#__PURE__*/Object.freeze({
     Participant: Participant,
     ParticipantCount: ParticipantCount,
     get PeerType () { return PeerType; },
+    PerformanceStats: PerformanceStats,
     Pin: Pin,
     PublishOption: PublishOption,
     RTMPIngress: RTMPIngress,
@@ -1999,6 +2042,27 @@ class SendStatsRequest$Type extends MessageType {
                 kind: 'scalar',
                 T: 9 /*ScalarType.STRING*/,
             },
+            { no: 15, name: 'rtc_stats', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
+            {
+                no: 16,
+                name: 'encode_stats',
+                kind: 'message',
+                repeat: 1 /*RepeatType.PACKED*/,
+                T: () => PerformanceStats,
+            },
+            {
+                no: 17,
+                name: 'decode_stats',
+                kind: 'message',
+                repeat: 1 /*RepeatType.PACKED*/,
+                T: () => PerformanceStats,
+            },
+            {
+                no: 18,
+                name: 'unified_session_id',
+                kind: 'scalar',
+                T: 9 /*ScalarType.STRING*/,
+            },
         ]);
     }
 }
@@ -5470,30 +5534,17 @@ const createStatsReporter = ({ subscriber, publisher, state, datacenter, polling
                 }
             }
         }
-        const [subscriberStats, publisherStats] = await Promise.all([
-            subscriber
-                .getStats()
-                .then((report) => transform(report, {
-                kind: 'subscriber',
-                trackKind: 'video',
-                publisher,
-            }))
-                .then(aggregate),
-            publisher
-                ? publisher
-                    .getStats()
-                    .then((report) => transform(report, {
-                    kind: 'publisher',
-                    trackKind: 'video',
-                    publisher,
-                }))
-                    .then(aggregate)
-                : getEmptyStats(),
-        ]);
         const [subscriberRawStats, publisherRawStats] = await Promise.all([
             getRawStatsForTrack('subscriber'),
             publisher ? getRawStatsForTrack('publisher') : undefined,
         ]);
+        const process = (report, kind) => aggregate(transform(report, { kind, trackKind: 'video', publisher }));
+        const subscriberStats = subscriberRawStats
+            ? process(subscriberRawStats, 'subscriber')
+            : getEmptyStats();
+        const publisherStats = publisherRawStats
+            ? process(publisherRawStats, 'publisher')
+            : getEmptyStats();
         state.setCallStatsReport({
             datacenter,
             publisherStats,
@@ -5651,7 +5702,7 @@ const aggregate = (stats) => {
     return report;
 };
 
-const version = "1.20.2";
+const version = "1.21.0";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -5788,7 +5839,7 @@ const getClientDetails = async () => {
 };
 
 class SfuStatsReporter {
-    constructor(sfuClient, { options, clientDetails, subscriber, publisher, microphone, camera, state, }) {
+    constructor(sfuClient, { options, clientDetails, subscriber, publisher, microphone, camera, state, unifiedSessionId, }) {
         this.logger = getLogger(['SfuStatsReporter']);
         this.inputDevices = new Map();
         this.observeDevice = (device, kind) => {
@@ -5845,31 +5896,40 @@ class SfuStatsReporter {
         };
         this.run = async (telemetry) => {
             const [subscriberStats, publisherStats] = await Promise.all([
-                this.subscriber.getStats().then(flatten).then(JSON.stringify),
-                this.publisher?.getStats().then(flatten).then(JSON.stringify) ?? '[]',
+                this.subscriber.stats.get(),
+                this.publisher?.stats.get(),
             ]);
-            const subscriberTrace = this.subscriber.getTrace();
-            const publisherTrace = this.publisher?.getTrace();
+            this.subscriber.tracer?.trace('getstats', subscriberStats.delta);
+            if (publisherStats) {
+                this.publisher?.tracer?.trace('getstats', publisherStats.delta);
+            }
+            const subscriberTrace = this.subscriber.tracer?.take();
+            const publisherTrace = this.publisher?.tracer?.take();
             const mediaTrace = tracer.take();
             const sfuTrace = this.sfuClient.getTrace();
-            const publisherTraces = [
+            const traces = [
                 ...mediaTrace.snapshot,
                 ...(sfuTrace?.snapshot ?? []),
                 ...(publisherTrace?.snapshot ?? []),
+                ...(subscriberTrace?.snapshot ?? []),
             ];
             try {
                 await this.sfuClient.sendStats({
                     sdk: this.sdkName,
                     sdkVersion: this.sdkVersion,
                     webrtcVersion: this.webRTCVersion,
-                    subscriberStats,
-                    subscriberRtcStats: subscriberTrace
-                        ? JSON.stringify(subscriberTrace.snapshot)
-                        : '',
-                    publisherStats,
-                    publisherRtcStats: publisherTraces.length > 0 ? JSON.stringify(publisherTraces) : '',
+                    subscriberStats: JSON.stringify(flatten(subscriberStats.stats)),
+                    publisherStats: publisherStats
+                        ? JSON.stringify(flatten(publisherStats.stats))
+                        : '[]',
+                    subscriberRtcStats: '',
+                    publisherRtcStats: '',
+                    rtcStats: JSON.stringify(traces),
+                    encodeStats: publisherStats?.performanceStats ?? [],
+                    decodeStats: subscriberStats.performanceStats,
                     audioDevices: this.inputDevices.get('mic'),
                     videoDevices: this.inputDevices.get('camera'),
+                    unifiedSessionId: this.unifiedSessionId,
                     deviceState: getDeviceState(),
                     telemetry,
                 });
@@ -5902,6 +5962,16 @@ class SfuStatsReporter {
             this.inputDevices.clear();
             clearInterval(this.intervalId);
             this.intervalId = undefined;
+            clearTimeout(this.timeoutId);
+            this.timeoutId = undefined;
+        };
+        this.scheduleOne = (timeout) => {
+            clearTimeout(this.timeoutId);
+            this.timeoutId = setTimeout(() => {
+                this.run().catch((err) => {
+                    this.logger('warn', 'Failed to report stats', err);
+                });
+            }, timeout);
         };
         this.sfuClient = sfuClient;
         this.options = options;
@@ -5910,6 +5980,7 @@ class SfuStatsReporter {
         this.microphone = microphone;
         this.camera = camera;
         this.state = state;
+        this.unifiedSessionId = unifiedSessionId;
         const { sdk, browser } = clientDetails;
         this.sdkName = getSdkName(sdk);
         this.sdkVersion = getSdkVersion(sdk);
@@ -5932,47 +6003,25 @@ const traceRTCPeerConnection = (pc, trace) => {
         trace('ontrack', `${e.track.kind}:${e.track.id} ${streams}`);
     });
     pc.addEventListener('signalingstatechange', () => {
-        trace('onsignalingstatechange', pc.signalingState);
+        trace('signalingstatechange', pc.signalingState);
     });
     pc.addEventListener('iceconnectionstatechange', () => {
-        trace('oniceconnectionstatechange', pc.iceConnectionState);
+        trace('iceconnectionstatechange', pc.iceConnectionState);
     });
     pc.addEventListener('icegatheringstatechange', () => {
-        trace('onicegatheringstatechange', pc.iceGatheringState);
+        trace('icegatheringstatechange', pc.iceGatheringState);
     });
     pc.addEventListener('connectionstatechange', () => {
-        trace('onconnectionstatechange', pc.connectionState);
+        trace('connectionstatechange', pc.connectionState);
     });
     pc.addEventListener('negotiationneeded', () => {
-        trace('onnegotiationneeded', undefined);
+        trace('negotiationneeded', undefined);
     });
     pc.addEventListener('datachannel', ({ channel }) => {
-        trace('ondatachannel', [channel.id, channel.label]);
-    });
-    let prev = {};
-    const getStats = () => {
-        pc.getStats(null)
-            .then((stats) => {
-            const now = toObject(stats);
-            trace('getstats', deltaCompression(prev, now));
-            prev = now;
-        })
-            .catch((err) => {
-            trace('getstatsOnFailure', err.toString());
-        });
-    };
-    const interval = setInterval(() => {
-        getStats();
-    }, 8000);
-    pc.addEventListener('connectionstatechange', () => {
-        const state = pc.connectionState;
-        if (state === 'connected' || state === 'failed') {
-            getStats();
-        }
+        trace('datachannel', [channel.id, channel.label]);
     });
     const origClose = pc.close;
     pc.close = function tracedClose() {
-        clearInterval(interval);
         trace('close', undefined);
         return origClose.call(this);
     };
@@ -6002,9 +6051,162 @@ const traceRTCPeerConnection = (pc, trace) => {
         };
     }
 };
-const toObject = (s) => {
+
+/**
+ * StatsTracer is a class that collects and processes WebRTC stats.
+ * It is used to track the performance of the WebRTC connection
+ * and to provide information about the media streams.
+ * It is used by both the Publisher and Subscriber classes.
+ *
+ * @internal
+ */
+class StatsTracer {
+    /**
+     * Creates a new StatsTracer instance.
+     */
+    constructor(pc, peerType, trackIdToTrackType) {
+        this.previousStats = {};
+        this.frameTimeHistory = [];
+        this.fpsHistory = [];
+        /**
+         * Get the stats from the RTCPeerConnection.
+         * When called, it will return the stats for the current connection.
+         * It will also return the delta between the current stats and the previous stats.
+         * This is used to track the performance of the connection.
+         *
+         * @internal
+         */
+        this.get = async () => {
+            const stats = await this.pc.getStats();
+            const currentStats = toObject(stats);
+            const performanceStats = this.withOverrides(this.peerType === PeerType.SUBSCRIBER
+                ? this.getDecodeStats(currentStats)
+                : this.getEncodeStats(currentStats));
+            const delta = deltaCompression(this.previousStats, currentStats);
+            // store the current data for the next iteration
+            this.previousStats = currentStats;
+            this.frameTimeHistory = this.frameTimeHistory.slice(-2);
+            this.fpsHistory = this.fpsHistory.slice(-2);
+            return { performanceStats, delta, stats };
+        };
+        /**
+         * Collects encode stats from the RTCPeerConnection.
+         */
+        this.getEncodeStats = (currentStats) => {
+            const encodeStats = [];
+            for (const rtp of Object.values(currentStats)) {
+                if (rtp.type !== 'outbound-rtp')
+                    continue;
+                const { codecId, framesSent = 0, kind, id, totalEncodeTime = 0, framesPerSecond = 0, frameHeight = 0, frameWidth = 0, targetBitrate = 0, mediaSourceId, } = rtp;
+                if (kind === 'audio' || !this.previousStats[id])
+                    continue;
+                const prevRtp = this.previousStats[id];
+                const deltaTotalEncodeTime = totalEncodeTime - (prevRtp.totalEncodeTime || 0);
+                const deltaFramesSent = framesSent - (prevRtp.framesSent || 0);
+                const framesEncodeTime = deltaFramesSent > 0
+                    ? (deltaTotalEncodeTime / deltaFramesSent) * 1000
+                    : 0;
+                this.frameTimeHistory.push(framesEncodeTime);
+                this.fpsHistory.push(framesPerSecond);
+                let trackType = TrackType.VIDEO;
+                if (mediaSourceId && currentStats[mediaSourceId]) {
+                    const mediaSource = currentStats[mediaSourceId];
+                    trackType =
+                        this.trackIdToTrackType.get(mediaSource.trackIdentifier) || trackType;
+                }
+                encodeStats.push({
+                    trackType,
+                    codec: getCodecFromStats(currentStats, codecId),
+                    avgFrameTimeMs: average(this.frameTimeHistory),
+                    avgFps: average(this.fpsHistory),
+                    targetBitrate: Math.round(targetBitrate),
+                    videoDimension: { width: frameWidth, height: frameHeight },
+                });
+            }
+            return encodeStats;
+        };
+        /**
+         * Collects decode stats from the RTCPeerConnection.
+         */
+        this.getDecodeStats = (currentStats) => {
+            let rtp = undefined;
+            let max = 0;
+            for (const item of Object.values(currentStats)) {
+                if (item.type !== 'inbound-rtp')
+                    continue;
+                const rtpItem = item;
+                const { kind, frameWidth = 0, frameHeight = 0 } = rtpItem;
+                const area = frameWidth * frameHeight;
+                if (kind === 'video' && area > max) {
+                    rtp = rtpItem;
+                    max = area;
+                }
+            }
+            if (!rtp || !this.previousStats[rtp.id])
+                return [];
+            const prevRtp = this.previousStats[rtp.id];
+            const { framesDecoded = 0, framesPerSecond = 0, totalDecodeTime = 0, trackIdentifier, } = rtp;
+            const deltaTotalDecodeTime = totalDecodeTime - (prevRtp.totalDecodeTime || 0);
+            const deltaFramesDecoded = framesDecoded - (prevRtp.framesDecoded || 0);
+            const framesDecodeTime = deltaFramesDecoded > 0
+                ? (deltaTotalDecodeTime / deltaFramesDecoded) * 1000
+                : 0;
+            this.frameTimeHistory.push(framesDecodeTime);
+            this.fpsHistory.push(framesPerSecond);
+            const trackType = this.trackIdToTrackType.get(trackIdentifier) || TrackType.VIDEO;
+            return [
+                PerformanceStats.create({
+                    trackType,
+                    codec: getCodecFromStats(currentStats, rtp.codecId),
+                    avgFrameTimeMs: average(this.frameTimeHistory),
+                    avgFps: average(this.fpsHistory),
+                    videoDimension: { width: rtp.frameWidth, height: rtp.frameHeight },
+                }),
+            ];
+        };
+        /**
+         * Applies cost overrides to the performance stats.
+         * This is used to override the default encode/decode times with custom values.
+         * This is useful for testing and debugging purposes, and it shouldn't be used in production.
+         */
+        this.withOverrides = (performanceStats) => {
+            if (this.costOverrides) {
+                for (const s of performanceStats) {
+                    const override = this.costOverrides.get(s.trackType);
+                    if (override !== undefined) {
+                        // override the average encode/decode time with the provided cost.
+                        // format: [override].[original-frame-time]
+                        s.avgFrameTimeMs = override + (s.avgFrameTimeMs || 0) / 1000;
+                    }
+                }
+            }
+            return performanceStats;
+        };
+        /**
+         * Set the encode/decode cost for a specific track type.
+         * This is used to override the default encode/decode times with custom values.
+         * This is useful for testing and debugging purposes, and it shouldn't be used in production.
+         *
+         * @internal
+         */
+        this.setCost = (cost, trackType = TrackType.VIDEO) => {
+            if (!this.costOverrides)
+                this.costOverrides = new Map();
+            this.costOverrides.set(trackType, cost);
+        };
+        this.pc = pc;
+        this.peerType = peerType;
+        this.trackIdToTrackType = trackIdToTrackType;
+    }
+}
+/**
+ * Convert the stat report to an object.
+ *
+ * @param report the stat report to convert.
+ */
+const toObject = (report) => {
     const obj = {};
-    s.forEach((v, k) => {
+    report.forEach((v, k) => {
         obj[k] = v;
     });
     return obj;
@@ -6027,12 +6229,13 @@ const deltaCompression = (oldStats, newStats) => {
         }
     }
     let timestamp = -Infinity;
-    for (const report of Object.values(newStats)) {
+    const values = Object.values(newStats);
+    for (const report of values) {
         if (report.timestamp > timestamp) {
             timestamp = report.timestamp;
         }
     }
-    for (const report of Object.values(newStats)) {
+    for (const report of values) {
         if (report.timestamp === timestamp) {
             report.timestamp = 0;
         }
@@ -6040,6 +6243,27 @@ const deltaCompression = (oldStats, newStats) => {
     newStats.timestamp = timestamp;
     return newStats;
 };
+/**
+ * Calculates an average value.
+ */
+const average = (arr) => arr.reduce((a, b) => a + b, 0) / arr.length;
+/**
+ * Create a Codec object from the codec stats.
+ *
+ * @param stats the stats report.
+ * @param codecId the codec ID to look for.
+ */
+const getCodecFromStats = (stats, codecId) => {
+    if (!codecId || !stats[codecId])
+        return;
+    const codecStats = stats[codecId];
+    return Codec.create({
+        name: codecStats.mimeType.split('/').pop(), // video/av1 -> av1
+        clockRate: codecStats.clockRate,
+        payloadType: codecStats.payloadType,
+        fmtp: codecStats.sdpFmtpLine,
+    });
+};
 
 /**
  * A base class for the `Publisher` and `Subscriber` classes.
@@ -6049,9 +6273,10 @@ class BasePeerConnection {
     /**
      * Constructs a new `BasePeerConnection` instance.
      */
-    constructor(peerType, { sfuClient, connectionConfig, state, dispatcher, onUnrecoverableError, logTag, clientDetails, enableTracing, }) {
+    constructor(peerType, { sfuClient, connectionConfig, state, dispatcher, onUnrecoverableError, logTag, enableTracing, }) {
         this.isIceRestarting = false;
         this.isDisposed = false;
+        this.trackIdToTrackType = new Map();
         this.subscriptions = [];
         /**
          * Handles events synchronously.
@@ -6099,10 +6324,10 @@ class BasePeerConnection {
             return this.pc.getStats(selector);
         };
         /**
-         * Returns the current tracing buffer.
+         * Maps the given track ID to the corresponding track type.
          */
-        this.getTrace = () => {
-            return this.tracer?.take();
+        this.getTrackType = (trackId) => {
+            return this.trackIdToTrackType.get(trackId);
         };
         /**
          * Handles the ICECandidate event and
@@ -6136,6 +6361,24 @@ class BasePeerConnection {
             }
             return JSON.stringify(candidate.toJSON());
         };
+        /**
+         * Handles the ConnectionStateChange event.
+         */
+        this.onConnectionStateChange = async () => {
+            const state = this.pc.connectionState;
+            this.logger('debug', `Connection state changed`, state);
+            if (!this.tracer)
+                return;
+            if (state === 'connected' || state === 'failed') {
+                try {
+                    const stats = await this.stats.get();
+                    this.tracer.trace('getstats', stats.delta);
+                }
+                catch (err) {
+                    this.tracer.trace('getstatsOnFailure', err.toString());
+                }
+            }
+        };
         /**
          * Handles the ICE connection state change event.
          */
@@ -6192,18 +6435,19 @@ class BasePeerConnection {
             logTag,
         ]);
         this.pc = new RTCPeerConnection(connectionConfig);
-        if (enableTracing) {
-            const tag = `${logTag}-${peerType === PeerType.SUBSCRIBER ? 'sub' : 'pub'}`;
-            this.tracer = new Tracer(tag);
-            this.tracer.trace('clientDetails', clientDetails);
-            this.tracer.trace('create', connectionConfig);
-            traceRTCPeerConnection(this.pc, this.tracer.trace);
-        }
         this.pc.addEventListener('icecandidate', this.onIceCandidate);
         this.pc.addEventListener('icecandidateerror', this.onIceCandidateError);
         this.pc.addEventListener('iceconnectionstatechange', this.onIceConnectionStateChange);
         this.pc.addEventListener('icegatheringstatechange', this.onIceGatherChange);
         this.pc.addEventListener('signalingstatechange', this.onSignalingChange);
+        this.pc.addEventListener('connectionstatechange', this.onConnectionStateChange);
+        this.stats = new StatsTracer(this.pc, peerType, this.trackIdToTrackType);
+        if (enableTracing) {
+            const tag = `${logTag}-${peerType === PeerType.SUBSCRIBER ? 'sub' : 'pub'}-${sfuClient.edgeName}`;
+            this.tracer = new Tracer(tag);
+            this.tracer.trace('create', connectionConfig);
+            traceRTCPeerConnection(this.pc, this.tracer.trace);
+        }
     }
     /**
      * Disposes the `RTCPeerConnection` instance.
@@ -6569,7 +6813,7 @@ class Publisher extends BasePeerConnection {
                 }
                 else {
                     const previousTrack = transceiver.sender.track;
-                    await transceiver.sender.replaceTrack(trackToPublish);
+                    await this.updateTransceiver(transceiver, trackToPublish, trackType);
                     if (!isReactNative()) {
                         this.stopTrack(previousTrack);
                     }
@@ -6591,8 +6835,20 @@ class Publisher extends BasePeerConnection {
             const trackType = publishOption.trackType;
             this.logger('debug', `Added ${TrackType[trackType]} transceiver`);
             this.transceiverCache.add(publishOption, transceiver);
+            this.trackIdToTrackType.set(track.id, trackType);
             await this.negotiate();
         };
+        /**
+         * Updates the transceiver with the given track and track type.
+         */
+        this.updateTransceiver = async (transceiver, track, trackType) => {
+            const sender = transceiver.sender;
+            if (sender.track)
+                this.trackIdToTrackType.delete(sender.track.id);
+            await sender.replaceTrack(track);
+            if (track)
+                this.trackIdToTrackType.set(track.id, trackType);
+        };
         /**
          * Synchronizes the current Publisher state with the provided publish options.
          */
@@ -6622,7 +6878,7 @@ class Publisher extends BasePeerConnection {
                     continue;
                 // it is safe to stop the track here, it is a clone
                 this.stopTrack(transceiver.sender.track);
-                await transceiver.sender.replaceTrack(null);
+                await this.updateTransceiver(transceiver, null, publishOption.trackType);
             }
         };
         /**
@@ -6642,18 +6898,6 @@ class Publisher extends BasePeerConnection {
             }
             return false;
         };
-        /**
-         * Maps the given track ID to the corresponding track type.
-         */
-        this.getTrackType = (trackId) => {
-            for (const transceiverId of this.transceiverCache.items()) {
-                const { publishOption, transceiver } = transceiverId;
-                if (transceiver.sender.track?.id === trackId) {
-                    return publishOption.trackType;
-                }
-            }
-            return undefined;
-        };
         /**
          * Stops the cloned track that is being published to the SFU.
          */
@@ -6947,6 +7191,7 @@ class Subscriber extends BasePeerConnection {
             if (!trackType) {
                 return this.logger('error', `Unknown track type: ${rawTrackType}`);
             }
+            this.trackIdToTrackType.set(e.track.id, trackType);
             if (!participantToUpdate) {
                 this.logger('warn', `[onTrack]: Received track for unknown participant: ${trackId}`, e);
                 this.state.registerOrphanedTrack({
@@ -7290,12 +7535,22 @@ class StreamSfuClient {
          */
         this.abortController = new AbortController();
         this.createWebSocket = () => {
+            const eventsToTrace = {
+                callEnded: true,
+                changePublishQuality: true,
+                error: true,
+                goAway: true,
+            };
             this.signalWs = createWebSocketSignalChannel({
                 logTag: this.logTag,
                 endpoint: `${this.credentials.server.ws_endpoint}?tag=${this.logTag}`,
                 onMessage: (message) => {
                     this.lastMessageTimestamp = new Date();
                     this.scheduleConnectionCheck();
+                    const eventKind = message.eventPayload.oneofKind;
+                    if (eventsToTrace[eventKind]) {
+                        this.tracer?.trace(eventKind, message);
+                    }
                     this.dispatcher.dispatch(message, this.logTag);
                 },
             });
@@ -7388,7 +7643,8 @@ class StreamSfuClient {
         };
         this.sendStats = async (stats) => {
             await this.joinTask;
-            return retryable(() => this.rpc.sendStats({ ...stats, sessionId: this.sessionId }), this.abortController.signal);
+            // NOTE: we don't retry sending stats
+            return this.rpc.sendStats({ ...stats, sessionId: this.sessionId });
         };
         this.startNoiseCancellation = async () => {
             await this.joinTask;
@@ -7440,7 +7696,7 @@ class StreamSfuClient {
                 unsubscribe();
                 current.reject(new Error('Waiting for "joinResponse" has timed out'));
             }, this.joinResponseTimeout);
-            await this.send(SfuRequest.create({
+            const joinRequest = SfuRequest.create({
                 requestPayload: {
                     oneofKind: 'joinRequest',
                     joinRequest: JoinRequest.create({
@@ -7449,7 +7705,9 @@ class StreamSfuClient {
                         token: this.credentials.token,
                     }),
                 },
-            }));
+            });
+            this.tracer?.trace('joinRequest', joinRequest);
+            await this.send(joinRequest);
             return current.promise;
         };
         this.ping = async () => {
@@ -7510,7 +7768,9 @@ class StreamSfuClient {
         this.joinResponseTimeout = joinResponseTimeout;
         this.logTag = logTag;
         this.logger = getLogger(['SfuClient', logTag]);
-        this.tracer = enableTracing ? new Tracer(logTag) : undefined;
+        this.tracer = enableTracing
+            ? new Tracer(`${logTag}-${this.edgeName}`)
+            : undefined;
         this.rpc = createSignalClient({
             baseUrl: server.url,
             interceptors: [
@@ -8410,7 +8670,6 @@ class DynascaleManager {
                         const { selectedDevice } = this.speaker.state;
                         if (selectedDevice && 'setSinkId' in audioElement) {
                             audioElement.setSinkId(selectedDevice);
-                            tracer.trace('navigator.mediaDevices.setSinkId', selectedDevice);
                         }
                     }
                 });
@@ -8420,7 +8679,6 @@ class DynascaleManager {
                 : this.speaker.state.selectedDevice$.subscribe((deviceId) => {
                     if (deviceId) {
                         audioElement.setSinkId(deviceId);
-                        tracer.trace('navigator.mediaDevices.setSinkId', deviceId);
                     }
                 });
             const volumeSubscription = combineLatest([
@@ -9492,25 +9750,6 @@ class InputMediaDeviceManagerState {
          * The default constraints for the device.
          */
         this.defaultConstraints$ = this.defaultConstraintsSubject.asObservable();
-        /**
-         * Gets the current value of an observable, or undefined if the observable has
-         * not emitted a value yet.
-         *
-         * @param observable$ the observable to get the value from.
-         */
-        this.getCurrentValue = getCurrentValue;
-        /**
-         * Updates the value of the provided Subject.
-         * An `update` can either be a new value or a function which takes
-         * the current value and returns a new value.
-         *
-         * @internal
-         *
-         * @param subject the subject to update.
-         * @param update the update to apply to the subject.
-         * @return the updated value.
-         */
-        this.setCurrentValue = setCurrentValue;
         this.hasBrowserPermission$ = permission
             ? permission.asObservable().pipe(shareReplay(1))
             : of(true);
@@ -9525,39 +9764,39 @@ class InputMediaDeviceManagerState {
      * The device status
      */
     get status() {
-        return this.getCurrentValue(this.status$);
+        return getCurrentValue(this.status$);
     }
     /**
      * The requested device status. Useful for optimistic UIs
      */
     get optimisticStatus() {
-        return this.getCurrentValue(this.optimisticStatus$);
+        return getCurrentValue(this.optimisticStatus$);
     }
     /**
      * The currently selected device
      */
     get selectedDevice() {
-        return this.getCurrentValue(this.selectedDevice$);
+        return getCurrentValue(this.selectedDevice$);
     }
     /**
      * The current media stream, or `undefined` if the device is currently disabled.
      */
     get mediaStream() {
-        return this.getCurrentValue(this.mediaStream$);
+        return getCurrentValue(this.mediaStream$);
     }
     /**
      * @internal
      * @param status
      */
     setStatus(status) {
-        this.setCurrentValue(this.statusSubject, status);
+        setCurrentValue(this.statusSubject, status);
     }
     /**
      * @internal
      * @param pendingStatus
      */
     setPendingStatus(pendingStatus) {
-        this.setCurrentValue(this.optimisticStatusSubject, pendingStatus);
+        setCurrentValue(this.optimisticStatusSubject, pendingStatus);
     }
     /**
      * Updates the `mediaStream` state variable.
@@ -9568,7 +9807,7 @@ class InputMediaDeviceManagerState {
      * as this is the stream that holds the actual deviceId information.
      */
     setMediaStream(stream, rootStream) {
-        this.setCurrentValue(this.mediaStreamSubject, stream);
+        setCurrentValue(this.mediaStreamSubject, stream);
         if (rootStream) {
             this.setDevice(this.getDeviceIdFromStream(rootStream));
         }
@@ -9578,13 +9817,13 @@ class InputMediaDeviceManagerState {
      * @param deviceId the device id to set.
      */
     setDevice(deviceId) {
-        this.setCurrentValue(this.selectedDeviceSubject, deviceId);
+        setCurrentValue(this.selectedDeviceSubject, deviceId);
     }
     /**
      * Gets the default constraints for the device.
      */
     get defaultConstraints() {
-        return this.getCurrentValue(this.defaultConstraints$);
+        return getCurrentValue(this.defaultConstraints$);
     }
     /**
      * Sets the default constraints for the device.
@@ -9593,7 +9832,7 @@ class InputMediaDeviceManagerState {
      * @param constraints the constraints to set.
      */
     setDefaultConstraints(constraints) {
-        this.setCurrentValue(this.defaultConstraintsSubject, constraints);
+        setCurrentValue(this.defaultConstraintsSubject, constraints);
     }
 }
 
@@ -9611,13 +9850,13 @@ class CameraManagerState extends InputMediaDeviceManagerState {
      * back - means the camera facing the environment
      */
     get direction() {
-        return this.getCurrentValue(this.direction$);
+        return getCurrentValue(this.direction$);
     }
     /**
      * @internal
      */
     setDirection(direction) {
-        this.setCurrentValue(this.directionSubject, direction);
+        setCurrentValue(this.directionSubject, direction);
     }
     /**
      * @internal
@@ -9790,13 +10029,13 @@ class MicrophoneManagerState extends InputMediaDeviceManagerState {
      * This feature is not available in the React Native SDK.
      */
     get speakingWhileMuted() {
-        return this.getCurrentValue(this.speakingWhileMuted$);
+        return getCurrentValue(this.speakingWhileMuted$);
     }
     /**
      * @internal
      */
     setSpeakingWhileMuted(isSpeaking) {
-        this.setCurrentValue(this.speakingWhileMutedSubject, isSpeaking);
+        setCurrentValue(this.speakingWhileMutedSubject, isSpeaking);
     }
     getDeviceIdFromStream(stream) {
         const [track] = stream.getAudioTracks();
@@ -10248,19 +10487,19 @@ class ScreenShareState extends InputMediaDeviceManagerState {
      * The current screen share audio status.
      */
     get audioEnabled() {
-        return this.getCurrentValue(this.audioEnabled$);
+        return getCurrentValue(this.audioEnabled$);
     }
     /**
      * Set the current screen share audio status.
      */
     setAudioEnabled(isEnabled) {
-        this.setCurrentValue(this.audioEnabledSubject, isEnabled);
+        setCurrentValue(this.audioEnabledSubject, isEnabled);
     }
     /**
      * The current screen share settings.
      */
     get settings() {
-        return this.getCurrentValue(this.settings$);
+        return getCurrentValue(this.settings$);
     }
     /**
      * Set the current screen share settings.
@@ -10268,7 +10507,7 @@ class ScreenShareState extends InputMediaDeviceManagerState {
      * @param settings the screen share settings to set.
      */
     setSettings(settings) {
-        this.setCurrentValue(this.settingsSubject, settings);
+        setCurrentValue(this.settingsSubject, settings);
     }
 }
 
@@ -10347,25 +10586,6 @@ class SpeakerState {
          * [Tells if the browser supports audio output change on 'audio' elements](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/setSinkId).
          */
         this.isDeviceSelectionSupported = checkIfAudioOutputChangeSupported();
-        /**
-         * Gets the current value of an observable, or undefined if the observable has
-         * not emitted a value yet.
-         *
-         * @param observable$ the observable to get the value from.
-         */
-        this.getCurrentValue = getCurrentValue;
-        /**
-         * Updates the value of the provided Subject.
-         * An `update` can either be a new value or a function which takes
-         * the current value and returns a new value.
-         *
-         * @internal
-         *
-         * @param subject the subject to update.
-         * @param update the update to apply to the subject.
-         * @return the updated value.
-         */
-        this.setCurrentValue = setCurrentValue;
         this.selectedDevice$ = this.selectedDeviceSubject
             .asObservable()
             .pipe(distinctUntilChanged());
@@ -10379,7 +10599,7 @@ class SpeakerState {
      * Note: this feature is not supported in React Native
      */
     get selectedDevice() {
-        return this.getCurrentValue(this.selectedDevice$);
+        return getCurrentValue(this.selectedDevice$);
     }
     /**
      * The currently selected volume
@@ -10387,21 +10607,22 @@ class SpeakerState {
      * Note: this feature is not supported in React Native
      */
     get volume() {
-        return this.getCurrentValue(this.volume$);
+        return getCurrentValue(this.volume$);
     }
     /**
      * @internal
      * @param deviceId
      */
     setDevice(deviceId) {
-        this.setCurrentValue(this.selectedDeviceSubject, deviceId);
+        setCurrentValue(this.selectedDeviceSubject, deviceId);
+        tracer.trace('navigator.mediaDevices.setSinkId', deviceId);
     }
     /**
      * @internal
      * @param volume
      */
     setVolume(volume) {
-        this.setCurrentValue(this.volumeSubject, volume);
+        setCurrentValue(this.volumeSubject, volume);
     }
 }
 
@@ -10782,6 +11003,7 @@ class Call {
                 this.leaveCallHooks.forEach((hook) => hook());
                 this.initialized = false;
                 this.hasJoinedOnce = false;
+                this.unifiedSessionId = undefined;
                 this.ringingSubject.next(false);
                 this.cancelAutoDrop();
                 this.clientStore.unregisterCall(this);
@@ -11209,7 +11431,6 @@ class Call {
                 state: this.state,
                 connectionConfig,
                 logTag: String(this.sfuClientTag),
-                clientDetails,
                 enableTracing,
                 onUnrecoverableError: (reason) => {
                     this.reconnect(WebsocketReconnectStrategy.REJOIN, reason).catch((err) => {
@@ -11231,7 +11452,6 @@ class Call {
                     connectionConfig,
                     publishOptions,
                     logTag: String(this.sfuClientTag),
-                    clientDetails,
                     enableTracing,
                     onUnrecoverableError: (reason) => {
                         this.reconnect(WebsocketReconnectStrategy.REJOIN, reason).catch((err) => {
@@ -11250,6 +11470,7 @@ class Call {
             });
             this.sfuStatsReporter?.stop();
             if (statsOptions?.reporting_interval_ms > 0) {
+                this.unifiedSessionId ?? (this.unifiedSessionId = sfuClient.sessionId);
                 this.sfuStatsReporter = new SfuStatsReporter(sfuClient, {
                     clientDetails,
                     options: statsOptions,
@@ -11258,6 +11479,7 @@ class Call {
                     microphone: this.microphone,
                     camera: this.camera,
                     state: this.state,
+                    unifiedSessionId: this.unifiedSessionId,
                 });
                 this.sfuStatsReporter.start();
             }
@@ -11627,6 +11849,11 @@ class Call {
                     trackTypes.push(TrackType.SCREEN_SHARE_AUDIO);
                 }
             }
+            if (track.kind === 'video') {
+                // schedules calibration report - the SFU will use the performance stats
+                // to adjust the quality thresholds as early as possible
+                this.sfuStatsReporter?.scheduleOne(3000);
+            }
             await this.updateLocalStreamState(mediaStream, ...trackTypes);
         };
         /**
@@ -13486,7 +13713,7 @@ class StreamClient {
         this.getUserAgent = () => {
             if (!this.cachedUserAgent) {
                 const { clientAppIdentifier = {} } = this.options;
-                const { sdkName = 'js', sdkVersion = "1.20.2", ...extras } = clientAppIdentifier;
+                const { sdkName = 'js', sdkVersion = "1.21.0", ...extras } = clientAppIdentifier;
                 this.cachedUserAgent = [
                     `stream-video-${sdkName}-v${sdkVersion}`,
                     ...Object.entries(extras).map(([key, value]) => `${key}=${value}`),