@stream-io/video-client 1.54.0 → 1.55.0

package/src/stats/SfuStatsReporter.ts

@@ -2,9 +2,11 @@ import { combineLatest } from 'rxjs';
 import { StreamSfuClient } from '../StreamSfuClient';
 import { OwnCapability, StatsOptions } from '../gen/coordinator';
 import { Publisher, Subscriber } from '../rtc';
-import { Tracer, TraceRecord } from './rtc';
+import { ComputedStats, PendingDelta, Tracer, TraceRecord } from './rtc';
 import { flatten, getSdkName, getSdkVersion } from './utils';
 import { getDeviceState, getWebRTCInfo } from '../helpers/client-details';
+import { hasPending, withoutConcurrency } from '../helpers/concurrency';
+import { timeboxed } from '../coordinator/connection/utils';
 import {
   ClientDetails,
   InputDevices,
@@ -51,6 +53,8 @@ export class SfuStatsReporter {
   private readonly sdkVersion: string;
   private readonly webRTCVersion: string;
   private readonly inputDevices = new Map<'mic' | 'camera', InputDevices>();
+  private readonly statsConcurrencyTag = Symbol('sfuStatsReporter');
+  private isStopped = false;
 
   constructor(
     sfuClient: StreamSfuClient,
@@ -158,69 +162,125 @@ export class SfuStatsReporter {
     });
   };
 
-  private run = async (telemetry?: Telemetry) => {
-    const [subscriberStats, publisherStats] = await Promise.all([
-      this.subscriber.stats.get(),
-      this.publisher?.stats.get(),
+  /**
+   * Samples both peer connections. Each `StatsTracer.takeSample()` is serialized
+   * internally, so this is safe even if it overlaps another sample (e.g. the
+   * connection-state-change handler). Kept separate from `send()` so an
+   * explicit flush can capture the sample from live peer connections before
+   * they are disposed, without waiting for an in-flight send.
+   */
+  private sample = (): Promise<[ComputedStats, ComputedStats | undefined]> =>
+    Promise.all([
+      this.subscriber.stats.takeSample(),
+      this.publisher?.stats.takeSample(),
     ]);
 
-    this.subscriber.tracer?.trace('getstats', subscriberStats.delta);
-    if (publisherStats) {
-      this.publisher?.tracer?.trace('getstats', publisherStats.delta);
-    }
+  private send = (
+    subscriberStats: ComputedStats,
+    publisherStats: ComputedStats | undefined,
+    telemetry?: Telemetry,
+  ) => {
+    // serialize sends so overlapping ones can't race on the trace buffers or
+    // deliver an older delta after a newer one already succeeded. Not gated by
+    // `isStopped`: an explicit final flush must still deliver after stop().
+    return withoutConcurrency(this.statsConcurrencyTag, async () => {
+      // The delta chain is delivered only when delta tracing is enabled
+      // (the peer-connection tracer exists). Otherwise we drop the chain so it
+      // can't grow unbounded.
+      const subTracer = this.subscriber.tracer;
+      const pubTracer = this.publisher?.tracer;
+      let subPending: PendingDelta[] = [];
+      if (subTracer) {
+        subPending = this.subscriber.stats.getPendingDeltas();
+      } else {
+        this.subscriber.stats.clearPendingDeltas();
+      }
+      let pubPending: PendingDelta[] = [];
+      if (pubTracer && publisherStats) {
+        pubPending = this.publisher?.stats.getPendingDeltas() ?? [];
+      } else {
+        this.publisher?.stats.clearPendingDeltas();
+      }
 
-    const subscriberTrace = this.subscriber.tracer?.take();
-    const publisherTrace = this.publisher?.tracer?.take();
-    const tracer = this.tracer.take();
-    const sfuTrace = this.sfuClient.getTrace();
-    const traces: TraceRecord[] = [
-      ...tracer.snapshot,
-      ...(sfuTrace?.snapshot ?? []),
-      ...(publisherTrace?.snapshot ?? []),
-      ...(subscriberTrace?.snapshot ?? []),
-    ];
+      const subscriberTrace = subTracer?.take();
+      const publisherTrace = pubTracer?.take();
+      const tracer = this.tracer.take();
+      const sfuTrace = this.sfuClient.getTrace();
+      const traces: TraceRecord[] = [
+        ...tracer.snapshot,
+        ...(sfuTrace?.snapshot ?? []),
+        ...(publisherTrace?.snapshot ?? []),
+        ...(subscriberTrace?.snapshot ?? []),
+        ...toGetStatsRecords(subPending, subTracer?.id),
+        ...toGetStatsRecords(pubPending, pubTracer?.id),
+      ];
 
-    try {
-      await this.sfuClient.sendStats({
-        sdk: this.sdkName,
-        sdkVersion: this.sdkVersion,
-        webrtcVersion: this.webRTCVersion,
-        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,
-      });
-    } catch (err) {
-      publisherTrace?.rollback();
-      subscriberTrace?.rollback();
-      tracer.rollback();
-      sfuTrace?.rollback();
-      throw err;
-    }
+      try {
+        const { response } = await this.sfuClient.sendStats({
+          sdk: this.sdkName,
+          sdkVersion: this.sdkVersion,
+          webrtcVersion: this.webRTCVersion,
+          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,
+        });
+        // An SFU application-layer error means the stats were not accepted.
+        // Treat it like a transport failure: retain the chain and roll back the
+        // RTC traces (handled by the catch below) instead of committing.
+        if (response?.error) {
+          throw new Error(`SFU rejected stats: ${response.error.message}`);
+        }
+        // delivery confirmed: advance the delivery baseline for each chain.
+        if (subTracer) this.subscriber.stats.commitDeltas(subPending);
+        if (pubTracer && publisherStats) {
+          this.publisher?.stats.commitDeltas(pubPending);
+        }
+      } catch (err) {
+        // keep the delta chains (re-sent next interval); only the append-only
+        // RTC event traces are rolled back so they aren't lost.
+        publisherTrace?.rollback();
+        subscriberTrace?.rollback();
+        tracer.rollback();
+        sfuTrace?.rollback();
+        throw err;
+      }
+    });
+  };
+
+  /**
+   * Samples and sends one report. Used by the scheduler and the telemetry path.
+   * Bails if the reporter has been stopped so it never samples disposed peer
+   * connections.
+   */
+  private run = async (telemetry?: Telemetry) => {
+    if (this.isStopped) return;
+    const [subscriberStats, publisherStats] = await this.sample();
+    await this.send(subscriberStats, publisherStats, telemetry);
   };
 
   private scheduleNextReport = () => {
     const intervals = [1500, 3000, 3000, 5000];
     if (this.reportCount < intervals.length) {
       this.timeoutId = setTimeout(() => {
-        this.flush();
+        this.scheduledFlush();
         this.reportCount++;
         this.scheduleNextReport();
       }, intervals[this.reportCount]);
     } else {
       clearInterval(this.intervalId);
       this.intervalId = setInterval(() => {
-        this.flush();
+        this.scheduledFlush();
       }, this.options.reporting_interval_ms);
     }
   };
@@ -231,6 +291,7 @@ export class SfuStatsReporter {
     this.observeDevice(this.microphone, 'mic');
     this.observeDevice(this.camera, 'camera');
 
+    this.isStopped = false;
     this.reportCount = 0;
     clearInterval(this.intervalId);
     clearTimeout(this.timeoutId);
@@ -239,6 +300,7 @@ export class SfuStatsReporter {
   };
 
   stop = () => {
+    this.isStopped = true;
     this.unsubscribeDevicePermissionsSubscription?.();
     this.unsubscribeDevicePermissionsSubscription = undefined;
     this.unsubscribeListDevicesSubscription?.();
@@ -252,9 +314,47 @@ export class SfuStatsReporter {
     this.reportCount = 0;
   };
 
-  flush = () => {
+  /**
+   * Explicit/final flush (leave, migration, re-init). Time-boxes the sampling
+   * step and swallows its failures, so a slow or failing `getStats()` on a
+   * degraded or closing peer connection can never block or reject call teardown
+   * or reconnect setup. On a successful sample it fires the send best-effort;
+   * the returned promise resolves once the sample is taken (or the time-box
+   * elapses / sampling fails), never when the sending completes. No-op once the
+   * reporter has been stopped.
+   */
+  flush = async (): Promise<void> => {
+    if (this.isStopped) return;
+    try {
+      const [sample] = await timeboxed([this.sample()], 2000);
+      const [subscriberStats, publisherStats] = sample;
+      this.send(subscriberStats, publisherStats).catch((err) => {
+        this.logger.warn('Failed to flush report stats', err);
+      });
+    } catch (err) {
+      this.logger.warn('Failed to sample stats for the final flush', err);
+    }
+  };
+
+  /**
+   * Flush entry for the periodic scheduler. Skips when the reporter is stopped
+   * or a send is already in flight so ticks can't pile up under slow sends (the
+   * next sample's delta spans the skipped interval).
+   */
+  private scheduledFlush = () => {
+    if (this.isStopped || hasPending(this.statsConcurrencyTag)) return;
     this.run().catch((err) => {
       this.logger.warn('Failed to flush report stats', err);
     });
   };
 }
+
+/**
+ * Wraps un-acked, delta-compressed samples into the legacy `getstats` trace
+ * record shape so the chain rides inside `rtcStats`, wire-compatible with the
+ * server's existing decoder.
+ */
+const toGetStatsRecords = (
+  pending: PendingDelta[],
+  id: string | null = null,
+): TraceRecord[] => pending.map(({ delta, ts }) => ['getstats', id, delta, ts]);

package/src/stats/__tests__/SfuStatsReporter.test.ts

@@ -0,0 +1,235 @@
+import { describe, expect, it, vi } from 'vitest';
+import { BehaviorSubject } from 'rxjs';
+import { SfuStatsReporter } from '../SfuStatsReporter';
+import { promiseWithResolvers } from '../../helpers/promise';
+
+// A FinishedUnaryCall-shaped success (no application-layer error).
+const okResponse = { response: {} };
+
+const makeSlice = () => ({ snapshot: [] as unknown[], rollback: vi.fn() });
+
+const makeStats = (pending: Array<{ delta: object; ts: number }>) => ({
+  takeSample: vi.fn().mockResolvedValue({
+    performanceStats: [],
+    stats: new Map(),
+  }),
+  getPendingDeltas: vi.fn(() => pending),
+  commitDeltas: vi.fn(),
+  clearPendingDeltas: vi.fn(),
+});
+
+const makeTracer = (id: string) => ({
+  take: vi.fn(makeSlice),
+  trace: vi.fn(),
+  id,
+});
+
+const build = (
+  opts: { withTracer?: boolean; withPublisher?: boolean } = {},
+) => {
+  const withTracer = opts.withTracer ?? true;
+  const subPending = [{ delta: { sub: 1 }, ts: 111 }];
+  const pubPending = [{ delta: { pub: 1 }, ts: 222 }];
+
+  const subStats = makeStats(subPending);
+  const subTracer = withTracer ? makeTracer('sub-id') : undefined;
+  const subscriber = { stats: subStats, tracer: subTracer };
+
+  let publisher: unknown;
+  let pubStats: ReturnType<typeof makeStats> | undefined;
+  if (opts.withPublisher) {
+    pubStats = makeStats(pubPending);
+    publisher = {
+      stats: pubStats,
+      tracer: withTracer ? makeTracer('pub-id') : undefined,
+    };
+  }
+
+  const sendStats = vi.fn().mockResolvedValue(okResponse);
+  const sfuClient = { sendStats, getTrace: vi.fn(() => undefined) };
+  const callTracer = { take: vi.fn(makeSlice), setEnabled: vi.fn() };
+
+  // device permission is 'denied' so observeDevice() doesn't reach listDevices()
+  const microphone = {
+    state: { browserPermissionState$: new BehaviorSubject('denied') },
+  };
+  const camera = {
+    state: { browserPermissionState$: new BehaviorSubject('denied') },
+  };
+  const state = { ownCapabilities$: new BehaviorSubject([]) };
+
+  const reporter = new SfuStatsReporter(sfuClient as never, {
+    options: { reporting_interval_ms: 1000, enable_rtc_stats: true } as never,
+    clientDetails: { sdk: undefined, browser: undefined } as never,
+    subscriber: subscriber as never,
+    publisher: publisher as never,
+    microphone: microphone as never,
+    camera: camera as never,
+    state: state as never,
+    tracer: callTracer as never,
+    unifiedSessionId: 'unified',
+  });
+
+  return {
+    reporter,
+    sendStats,
+    subStats,
+    subTracer,
+    pubStats,
+    callTracer,
+    subPending,
+    pubPending,
+  };
+};
+
+describe('SfuStatsReporter delta delivery', () => {
+  it('commits the un-acked chain after a successful send', async () => {
+    const t = build();
+    t.reporter.flush();
+    await vi.waitFor(() => expect(t.subStats.commitDeltas).toHaveBeenCalled());
+    expect(t.subStats.commitDeltas).toHaveBeenCalledWith(t.subPending);
+  });
+
+  it('does not re-trace the delta into the peer-connection tracer', async () => {
+    const t = build();
+    t.reporter.flush();
+    await vi.waitFor(() => expect(t.sendStats).toHaveBeenCalled());
+    expect(t.subTracer!.trace).not.toHaveBeenCalled();
+  });
+
+  it('ships the un-acked chain as getstats records inside rtcStats', async () => {
+    const t = build();
+    t.reporter.flush();
+    await vi.waitFor(() => expect(t.sendStats).toHaveBeenCalled());
+    const traces = JSON.parse(t.sendStats.mock.calls[0][0].rtcStats);
+    expect(traces).toContainEqual(['getstats', 'sub-id', { sub: 1 }, 111]);
+  });
+
+  it('retains the chain and rolls back generic traces on send failure', async () => {
+    const t = build();
+    const slice = makeSlice();
+    t.callTracer.take.mockReturnValue(slice);
+    t.sendStats.mockRejectedValue(new Error('network down'));
+
+    t.reporter.flush();
+    await vi.waitFor(() => expect(slice.rollback).toHaveBeenCalled());
+    expect(t.subStats.commitDeltas).not.toHaveBeenCalled();
+  });
+
+  it('treats an SFU application error as a failed send (no commit, rolls back)', async () => {
+    const t = build();
+    const slice = makeSlice();
+    t.callTracer.take.mockReturnValue(slice);
+    t.sendStats.mockResolvedValue({
+      response: { error: { code: 1, message: 'rejected', shouldRetry: false } },
+    });
+
+    t.reporter.flush();
+    await vi.waitFor(() => expect(slice.rollback).toHaveBeenCalled());
+    expect(t.subStats.commitDeltas).not.toHaveBeenCalled();
+  });
+
+  it('flush() resolves once the sample is taken, without awaiting the send', async () => {
+    const t = build();
+    const dGet = promiseWithResolvers<object>();
+    t.subStats.takeSample.mockReturnValue(dGet.promise); // sampling hangs
+    t.sendStats.mockReturnValue(promiseWithResolvers<object>().promise); // send would hang too
+
+    let resolved = false;
+    const flushed = Promise.resolve(t.reporter.flush()).then(() => {
+      resolved = true;
+    });
+
+    await Promise.resolve();
+    expect(resolved).toBe(false); // still sampling -> flush not resolved
+
+    dGet.resolve({ delta: {}, performanceStats: [], stats: new Map() });
+    await flushed;
+    expect(resolved).toBe(true); // resolves after the sample, not the send
+  });
+
+  it('does not reject (and skips the send) when the final sample fails', async () => {
+    const t = build();
+    t.subStats.takeSample.mockRejectedValue(new Error('getStats failed'));
+
+    await expect(t.reporter.flush()).resolves.toBeUndefined();
+    expect(t.sendStats).not.toHaveBeenCalled();
+  });
+
+  it('does not block teardown when the final sample hangs past the time-box', async () => {
+    vi.useFakeTimers();
+    try {
+      const t = build();
+      // sampling never settles (e.g. getStats() wedged on a closing connection)
+      t.subStats.takeSample.mockReturnValue(
+        promiseWithResolvers<object>().promise,
+      );
+
+      let settled = false;
+      const flushed = t.reporter.flush().then(() => {
+        settled = true;
+      });
+
+      await vi.advanceTimersByTimeAsync(2000); // time-box elapses
+      await flushed;
+
+      expect(settled).toBe(true);
+      expect(t.sendStats).not.toHaveBeenCalled();
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it('samples on an explicit flush even while a previous send is in flight', async () => {
+    const t = build();
+    const d = promiseWithResolvers<object>();
+    t.sendStats.mockReturnValueOnce(d.promise).mockResolvedValue(okResponse);
+
+    t.reporter.flush(); // flush #1: samples, fires the slow send
+    await vi.waitFor(() => expect(t.sendStats).toHaveBeenCalledTimes(1));
+
+    await t.reporter.flush(); // flush #2: must sample now, not wait for send #1
+    expect(t.subStats.takeSample).toHaveBeenCalledTimes(2);
+
+    d.resolve(okResponse);
+  });
+
+  it('does not sample after stop()', async () => {
+    const t = build();
+    t.reporter.stop();
+    await t.reporter.flush();
+    expect(t.subStats.takeSample).not.toHaveBeenCalled();
+  });
+
+  it('skips overlapping scheduled reports while a run is in flight', async () => {
+    vi.useFakeTimers();
+    try {
+      const t = build();
+      const d = promiseWithResolvers<object>();
+      t.sendStats.mockReturnValue(d.promise); // first scheduled send hangs
+
+      t.reporter.start();
+      await vi.advanceTimersByTimeAsync(1500); // first scheduled tick -> run in flight
+      expect(t.subStats.takeSample).toHaveBeenCalledTimes(1);
+
+      await vi.advanceTimersByTimeAsync(3000); // next tick must be skipped
+      expect(t.subStats.takeSample).toHaveBeenCalledTimes(1);
+
+      d.resolve(okResponse);
+      t.reporter.stop();
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it('clears the chain instead of sending it when delta tracing is disabled', async () => {
+    const t = build({ withTracer: false });
+    t.reporter.flush();
+    await vi.waitFor(() => expect(t.sendStats).toHaveBeenCalled());
+
+    expect(t.subStats.clearPendingDeltas).toHaveBeenCalled();
+    expect(t.subStats.commitDeltas).not.toHaveBeenCalled();
+    const traces = JSON.parse(t.sendStats.mock.calls[0][0].rtcStats);
+    expect(traces.some((r: unknown[]) => r[0] === 'getstats')).toBe(false);
+  });
+});

package/src/stats/rtc/StatsTracer.ts

@@ -5,7 +5,8 @@ import {
   TrackType,
 } from '../../gen/video/sfu/models/models';
 import type { RTCCodecStats, RTCMediaSourceStats } from '../types';
-import type { ComputedStats } from './types';
+import type { ComputedStats, PendingDelta } from './types';
+import { withoutConcurrency } from '../../helpers/concurrency';
 
 /**
  * StatsTracer is a class that collects and processes WebRTC stats.
@@ -20,13 +21,27 @@ export class StatsTracer {
   private readonly peerType: PeerType;
   private readonly trackIdToTrackType: Map<string, TrackType>;
   private readonly driftThresholdMs: number;
+  private readonly maxPendingDeltas: number;
+  // serializes takeSample() so overlapping callers (the reporter and the
+  // connection-state-change handler) can't interleave their getStats() and
+  // corrupt the previousSample/pendingDeltas read-modify-write.
+  private readonly sampleTag = Symbol('statsTracerSample');
 
   private costOverrides?: Map<TrackType, number>;
 
-  private previousStats: Record<string, RTCStats> = {};
+  private previousSample: Record<string, RTCStats> = {};
   private frameTimeHistory: number[] = [];
   private fpsHistory: number[] = [];
 
+  /**
+   * The un-acked, delta-compressed samples awaiting delivery confirmation.
+   * Each entry's delta is computed against the immediately preceding sample,
+   * so the list forms a chain the server applies in order. The delivery
+   * baseline advances only when the reporter calls `commitDeltas` after a
+   * successful send; until then the chain is re-sent in full.
+   */
+  private pendingDeltas: PendingDelta[] = [];
+
   /**
    * Creates a new StatsTracer instance.
    */
@@ -35,43 +50,86 @@ export class StatsTracer {
     peerType: PeerType,
     trackIdToTrackType: Map<string, TrackType>,
     statsTimestampDriftThresholdMs: number = 0,
+    maxPendingDeltas: number = 50,
   ) {
     this.pc = pc;
     this.peerType = peerType;
     this.trackIdToTrackType = trackIdToTrackType;
     this.driftThresholdMs = statsTimestampDriftThresholdMs;
+    this.maxPendingDeltas = maxPendingDeltas;
   }
 
   /**
-   * 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.
+   * Samples the RTCPeerConnection: returns the current stats report and the
+   * derived performance stats, and appends the delta-compressed sample to the
+   * un-acked delivery chain (retrieved via `getPendingDeltas`).
+   *
+   * @internal
+   */
+  takeSample = (): Promise<ComputedStats> => {
+    return withoutConcurrency(this.sampleTag, async () => {
+      const stats = await this.pc.getStats();
+      const now = Date.now();
+      const currentStats = toObjectWithCorrectedTimestamp(
+        stats,
+        now,
+        this.driftThresholdMs,
+      );
+
+      // Sustained delivery failure: drop the stale un-acked chain and re-anchor
+      // so the next delta is a full snapshot. A full snapshot overwrites the
+      // server's accumulator, re-syncing it, and keeps the payload bounded.
+      if (this.pendingDeltas.length >= this.maxPendingDeltas) {
+        this.pendingDeltas = [];
+        this.previousSample = {};
+      }
+
+      const performanceStats = this.withOverrides(
+        this.peerType === PeerType.SUBSCRIBER
+          ? this.getDecodeStats(currentStats)
+          : this.getEncodeStats(currentStats),
+      );
+
+      const delta = deltaCompression(this.previousSample, currentStats);
+
+      // store the current data for the next iteration
+      this.previousSample = currentStats;
+      this.pendingDeltas.push({ delta, ts: now });
+      this.frameTimeHistory = this.frameTimeHistory.slice(-2);
+      this.fpsHistory = this.fpsHistory.slice(-2);
+
+      return { performanceStats, stats };
+    });
+  };
+
+  /**
+   * Returns a stable copy of the un-acked delta chain to transmit, oldest first.
+   *
+   * @internal
+   */
+  getPendingDeltas = (): PendingDelta[] => this.pendingDeltas.slice();
+
+  /**
+   * Advances the delivery baseline by dropping exactly the deltas that were
+   * confirmed delivered. Matching is by object identity, so a stale commit
+   * that arrives after a re-anchor (which replaced the chain) is a safe no-op.
+   *
+   * @internal
+   */
+  commitDeltas = (sent: PendingDelta[]): void => {
+    if (sent.length === 0) return;
+    const committed = new Set(sent);
+    this.pendingDeltas = this.pendingDeltas.filter((d) => !committed.has(d));
+  };
+
+  /**
+   * Drops the un-acked chain without sending it. Used when delta reporting is
+   * disabled so the chain can't grow unbounded.
    *
    * @internal
    */
-  get = async (): Promise<ComputedStats> => {
-    const stats = await this.pc.getStats();
-    const currentStats = toObjectWithCorrectedTimestamp(
-      stats,
-      Date.now(),
-      this.driftThresholdMs,
-    );
-
-    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 };
+  clearPendingDeltas = (): void => {
+    this.pendingDeltas = [];
   };
 
   /**
@@ -97,8 +155,8 @@ export class StatsTracer {
         mediaSourceId,
       } = rtp as RTCOutboundRtpStreamStats;
 
-      if (kind === 'audio' || !this.previousStats[id]) continue;
-      const prevRtp = this.previousStats[id] as RTCOutboundRtpStreamStats;
+      if (kind === 'audio' || !this.previousSample[id]) continue;
+      const prevRtp = this.previousSample[id] as RTCOutboundRtpStreamStats;
 
       const deltaTotalEncodeTime =
         totalEncodeTime - (prevRtp.totalEncodeTime || 0);
@@ -150,8 +208,8 @@ export class StatsTracer {
       }
     }
 
-    if (!rtp || !this.previousStats[rtp.id]) return [];
-    const prevRtp = this.previousStats[rtp.id] as RTCInboundRtpStreamStats;
+    if (!rtp || !this.previousSample[rtp.id]) return [];
+    const prevRtp = this.previousSample[rtp.id] as RTCInboundRtpStreamStats;
 
     const {
       framesDecoded = 0,