@rtcstats/rtcstats-shared 2.5.0 → 2.6.1

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,6 +106,8 @@ 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);
@@ -116,6 +163,9 @@ export async function readRTCStatsDump(blob) {
             method,
         });
     }
+    if (!data.peerConnections['null'].length) {
+        delete data.peerConnections['null'];
+    }
     return data;
 }
 
@@ -151,11 +201,11 @@ export function internalsToRtcstats(data) {
             const tracks = [];
             if (gum.audio_track_info) {
                 const t = JSON.parse(gum.audio_track_info);
-                tracks.push(['audio', t.id, t.label, gum.stream_id]);
+                if (t) tracks.push(['audio', t.id, t.label, gum.stream_id]);
             }
             if (gum.video_track_info) {
                 const t = JSON.parse(gum.video_track_info);
-                tracks.push(['video', t.id, t.label, gum.stream_id]);
+                if (t) tracks.push(['video', t.id, t.label, gum.stream_id]);
             }
             clientTrace.push({type: baseType + 'OnSuccess', value: tracks, timestamp: gum.timestamp, extra: []});
         } else if (gum.audio !== undefined || gum.video !== undefined) {
@@ -216,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) {
@@ -236,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?
@@ -307,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.5.0",
+  "version": "2.6.1",
   "main": "index.js",
   "description": "gather WebRTC API traces and statistics",
   "type": "module",