@rtcstats/rtcstats-shared 2.4.0 → 2.6.0

package/compression.js

@@ -175,23 +175,29 @@ export function statsDecompression(baseStatsInput, delta) {
             delete newStats[id];
             return;
         }
+        // A timestamp carried explicitly in the delta differs from the
+        // collapsed top-level one and must not be overwritten below.
+        const hasOwnTimestamp = newStats[id] !== undefined &&
+            newStats[id].timestamp !== undefined;
         if (!newStats[id]) {
-            newStats[id] = baseStats[id];
+            // Copy the report so the timestamp assignment below does not
+            // modify the base stats.
+            newStats[id] = Object.assign({}, baseStats[id]);
         } else {
             const report = baseStats[id];
             Object.keys(report).forEach(name => {
-                if (!newStats[id][name]) {
+                if (newStats[id][name] === undefined) {
                     newStats[id][name] = report[name];
-                } else if (typeof(report[name]) === 'object') {
-                    const newObject = newStats[id][name];
-                    newStats[id][name] = report[name];
-                    Object.keys(newObject).forEach(key => {
-                        newStats[id][name][key] = newObject[key];
-                    });
+                } else if (typeof(report[name]) === 'object' &&
+                        !Array.isArray(newStats[id][name])) {
+                    // Merge into a copy so the nested object of the
+                    // base stats is not modified. Arrays are serialized
+                    // wholesale on change and take the new value.
+                    newStats[id][name] = Object.assign({}, report[name], newStats[id][name]);
                 } // Else: take the new value.
             });
         }
-        if (timestamp !== undefined) {
+        if (timestamp !== undefined && !hasOwnTimestamp) {
             newStats[id].timestamp = timestamp;
         }
     });
@@ -367,12 +373,20 @@ const methodTable = {
     // getUserMedia and friends.
     'navigator.mediaDevices.getUserMedia': 60,
     'navigator.mediaDevices.getUserMediaOnSuccess': 61,
-    'navigator.mediaDevices.getUserMediaOnFailure': 62,
+    // 62 is not usable. It was originally assigned to
+    // getUserMediaOnFailure but a copy-paste bug duplicated the
+    // key onto 65, which was intended for getDisplayMediaOnFailure.
+    // The last duplicate key wins in an object literal, so released clients
+    // have always compressed getUserMediaOnFailure to 65.
+    'navigator.mediaDevices.getUserMediaOnFailure': 65,
     'navigator.mediaDevices.getDisplayMedia': 63,
     'navigator.mediaDevices.getDisplayMediaOnSuccess': 64,
-    'navigator.mediaDevices.getUserMediaOnFailure': 65,
     'navigator.mediaDevices.enumerateDevices': 66,
     'navigator.mediaDevices.ondevicechange': 67,
+    // Decompression-only until the next major version bump, see below.
+    // This method is therefore not compressed.
+    // 'navigator.mediaDevices.getDisplayMediaOnFailure': 68,
+    // Next free method id: 69.
     // MediaStreamTrack methods and events.
     'MediaStreamTrack.stop':  70,
     'MediaStreamTrack.applyConstraints':  71,
@@ -386,6 +400,7 @@ const methodTable = {
 // These should be moved to the compression table at major version bumps.
 const methodTableDecompression = {
     1: 'getStats',
+    68: 'navigator.mediaDevices.getDisplayMediaOnFailure',
 };
 const reverseMethodTable = Object.keys(methodTable).reduce((table, method) => {
     table[methodTable[method]] = method;

package/dump.js

@@ -6,13 +6,57 @@ import {
 import {createInternalsTimeSeries} from './timeseries.js';
 import {parseTrackWithStreams} from './utils.js';
 
+// Chrome JSON-encodes the state in these events, rtcstats-js writes it bare.
+// https://chromium-review.googlesource.com/c/chromium/src/+/6917903
+const STATE_VALUES = {
+    onsignalingstatechange: {
+        '"stable"': 'stable',
+        '"have-local-offer"': 'have-local-offer',
+        '"have-remote-offer"': 'have-remote-offer',
+        '"have-local-pranswer"': 'have-local-pranswer',
+        '"have-remote-pranswer"': 'have-remote-pranswer',
+        '"closed"': 'closed',
+    },
+    oniceconnectionstatechange: {
+        '"new"': 'new',
+        '"checking"': 'checking',
+        '"connected"': 'connected',
+        '"completed"': 'completed',
+        '"failed"': 'failed',
+        '"disconnected"': 'disconnected',
+        '"closed"': 'closed',
+    },
+    onconnectionstatechange: {
+        '"new"': 'new',
+        '"connecting"': 'connecting',
+        '"connected"': 'connected',
+        '"disconnected"': 'disconnected',
+        '"failed"': 'failed',
+        '"closed"': 'closed',
+    },
+    onicegatheringstatechange: {
+        '"new"': 'new',
+        '"gathering"': 'gathering',
+        '"complete"': 'complete',
+    },
+};
+
+// Call before format detection, dumps are frequently stored gzipped.
+export async function maybeUncompressDump(blob) {
+    const magic = new Uint8Array(await blob.slice(0, 2).arrayBuffer());
+    if (magic[0] !== 0x1f || magic[1] !== 0x8b) {
+        return blob;
+    }
+    return new Response(blob.stream().pipeThrough(new DecompressionStream('gzip'))).blob();
+}
+
 export async function detectRTCStatsDump(blob) {
     const magic = await blob.slice(0, 13).text();
     return magic.startsWith('RTCStatsDump\n');
 }
 
 export async function detectWebRTCInternalsDump(blob) {
-    return (await blob.text()).startsWith('{');
+    return (await blob.slice(0, 1).text()) === '{';
 }
 
 export async function readRTCStatsDump(blob) {
@@ -36,7 +80,8 @@ export async function readRTCStatsDump(blob) {
         console.error('Second line must be an object');
         return;
     }
-    data.peerConnections = {};
+    // Ensure the client-level connection is listed before the peer connections.
+    data.peerConnections = {null: []};
     data.eventSizes = {};
 
     const baseStats = {};
@@ -61,9 +106,12 @@ export async function readRTCStatsDump(blob) {
         lastTime = extra.pop() + lastTime;
         const time = new Date(lastTime);
 
+        value = STATE_VALUES[method]?.[value] || value;
+
         if (method === 'getStats') { // delta-compressed stats
+            // statsDecompression does not modify its base stats argument.
             value = statsDecompression(baseStats[connection_id], value);
-            baseStats[connection_id] = JSON.parse(JSON.stringify(value));
+            baseStats[connection_id] = value;
         } else if (method === 'setLocalDescription' && value &&
             // Workaround for Chrome <145 bug: https://source.chromium.org/chromium/chromium/src/+/4a2a384e43ea163127219548087e949fb00fa562
             connection_id !== 'undefined-undefined') {
@@ -115,6 +163,9 @@ export async function readRTCStatsDump(blob) {
             method,
         });
     }
+    if (!data.peerConnections['null'].length) {
+        delete data.peerConnections['null'];
+    }
     return data;
 }
 
@@ -215,12 +266,16 @@ export function internalsToRtcstats(data) {
     return {peerConnections, eventSizes: {}};
 }
 
-// Auto-detect the dump format and dispatch.
+// Uncompress if needed, auto-detect the dump format and dispatch.
 export async function readDump(blob) {
-    if (await detectRTCStatsDump(blob)) {
-        return readRTCStatsDump(blob);
+    const dump = await maybeUncompressDump(blob);
+    if (await detectRTCStatsDump(dump)) {
+        return readRTCStatsDump(dump);
+    }
+    if (!await detectWebRTCInternalsDump(dump)) {
+        throw new Error('Unrecognized dump format');
     }
-    return internalsToRtcstats(await readWebRTCInternalsDump(blob));
+    return internalsToRtcstats(await readWebRTCInternalsDump(dump));
 }
 
 export async function extractTracks(peerConnectionTrace) {
@@ -235,7 +290,10 @@ export async function extractTracks(peerConnectionTrace) {
             const trackInformation = parseTrackWithStreams(traceEvent.value);
             trackInformation.startTime = traceEvent.timestamp;
             trackInformation.direction = 'inbound';
-            tracks.push(trackInformation);
+            if (tracks.find(info => info.direction === 'inbound' &&
+                    info.id === trackInformation.id) === undefined) {
+                tracks.push(trackInformation);
+            }
         } else if (traceEvent.type === 'addTransceiver') {
             if (typeof traceEvent.value[0] === 'string') {
                 // TODO: if we pass a kind here, how do we determine the track id?
@@ -306,7 +364,27 @@ export async function extractTracks(peerConnectionTrace) {
                     label: value.receiver.track,
                     streams: value.receiver.streams,
                 };
-                tracks.push(trackInformation);
+                if (tracks.find(info => info.id === trackInformation.id) === undefined) {
+                    tracks.push(trackInformation);
+                }
+            }
+        } else if (traceEvent.type === 'transceiverModified') {
+            // A transceiver created locally only starts receiving once the
+            // negotiation is done, which is the only signal for inbound tracks
+            // in dumps from Chrome versions without the ontrack event.
+            const {value} = traceEvent;
+            if (value.currentDirection?.includes('recv') && value.receiver?.track) {
+                const trackInformation = {
+                    startTime: traceEvent.timestamp,
+                    direction: 'inbound',
+                    kind: value.kind,
+                    id: value.receiver.track,
+                    label: value.receiver.track,
+                    streams: value.receiver.streams,
+                };
+                if (tracks.find(info => info.id === trackInformation.id) === undefined) {
+                    tracks.push(trackInformation);
+                }
             }
         }
     }

package/index.d.ts

@@ -1,5 +1,6 @@
 // Type definitions for @rtcstats/rtcstats-shared
 
+export async function maybeUncompressDump(blob: Blob): Promise<Blob>;
 export async function detectWebRTCInternalsDump(blob: Blob): Promise<boolean>;
 export async function readWebRTCInternalsDump(blob: Blob): Promise<object>;
 export async function detectRTCStatsDump(blob: Blob): Promise<boolean>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rtcstats/rtcstats-shared",
-  "version": "2.4.0",
+  "version": "2.6.0",
   "main": "index.js",
   "description": "gather WebRTC API traces and statistics",
   "type": "module",