@rtcstats/rtcstats-shared 2.2.0 → 2.3.0

package/LICENSE.md

@@ -0,0 +1,24 @@
+The MIT License
+
+Copyright (c) 2025 rtcstats.com
+
+Permission is hereby granted, free of charge, 
+to any person obtaining a copy of this software and 
+associated documentation files (the "Software"), to 
+deal in the Software without restriction, including 
+without limitation the rights to use, copy, modify, 
+merge, publish, distribute, sublicense, and/or sell 
+copies of the Software, and to permit persons to whom 
+the Software is furnished to do so, 
+subject to the following conditions:
+
+The above copyright notice and this permission notice 
+shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR 
+ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/address-obfuscator.js

@@ -7,7 +7,7 @@ import SDPUtils from 'sdp';
 // Based on libWebRTCs IPAddress::ToSensitiveString
 // https://source.chromium.org/chromium/chromium/src/+/main:third_party/webrtc/rtc_base/ip_address.cc;l=149;drc=0dc30698370bcde67dda4f48b7ca19bf4c1dbc17
 export function obfuscateIpOrAddress(ipOrAddress) {
-    if (['::1', '127.0.0.1'].includes(ipOrAddress)) {
+    if (['::1', '127.0.0.1', '0.0.0.0'].includes(ipOrAddress)) {
         return ipOrAddress;
     }
     if (ipOrAddress.indexOf(':') !== -1) { // IPv6

package/compression.js

@@ -719,6 +719,15 @@ const statsPropertyTableDecompression = {
     // https://w3c.github.io/webrtc-stats/#dom-rtcoutboundrtpstreamstats-psnrsum
     167: 'psnrMeasurements',
     168: 'psnrSum',
+    // L4S stats, https://github.com/w3c/webrtc-stats/pull/792/
+    169: 'packetsReceivedWithEct1',
+    170: 'packetsReceivedWithCe',
+    171: 'packetsReportedAsLost',
+    172: 'packetsReportedAsLostButRecovered',
+    173: 'packetsWithBleachedEct1Marking',
+    174: 'packetsSentWithEct1',
+    175: 'ccfbMessagesSent',
+    176: 'ccfbMessagesReceived',
 };
 const reverseStatsPropertyTable = Object.keys(statsPropertyTable).reduce((table, property) => {
     table[statsPropertyTable[property]] = property;

package/dump.js

@@ -3,6 +3,7 @@ import {
     descriptionDecompression,
     statsDecompression,
 } from './compression.js';
+import {createInternalsTimeSeries} from './timeseries.js';
 import {parseTrackWithStreams} from './utils.js';
 
 export async function detectRTCStatsDump(blob) {
@@ -122,6 +123,106 @@ export async function readWebRTCInternalsDump(blob) {
     return JSON.parse(textBlob);
 }
 
+// Convert a webrtc-internals dump into the same shape readRTCStatsDump returns
+// so the existing feature extractors (mostly) work.
+export function internalsToRtcstats(data) {
+    const peerConnections = {};
+    const startTimestamp = data.timestamp || 0;
+
+    const clientTrace = [{
+        type: 'create',
+        value: {
+            cpuPerformance: data.cpuPerformance,
+            deviceMemory: data.deviceMemory,
+            hardwareConcurrency: data.hardwareConcurrency,
+            userAgent: data.UserAgent,
+            userAgentData: data.UserAgentData,
+        },
+        timestamp: startTimestamp,
+        extra: [],
+    }];
+
+    for (const gum of (data.getUserMedia || [])) {
+        const baseType = 'navigator.mediaDevices.' + gum.request_type;
+        if (gum.error !== undefined) {
+            clientTrace.push({type: baseType + 'OnFailure', value: gum.error, timestamp: gum.timestamp, extra: []});
+        } else if (gum.audio_track_info !== undefined || gum.video_track_info !== undefined) {
+            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 (gum.video_track_info) {
+                const t = JSON.parse(gum.video_track_info);
+                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) {
+            const value = {};
+            if (gum.audio !== undefined) value.audio = gum.audio === '' ? true : gum.audio;
+            if (gum.video !== undefined) value.video = gum.video === '' ? true : gum.video;
+            clientTrace.push({type: baseType, value, timestamp: gum.timestamp, extra: []});
+        }
+    }
+    clientTrace.sort((a, b) => a.timestamp - b.timestamp);
+    peerConnections['null'] = clientTrace;
+
+    for (const id of Object.keys(data.PeerConnections || {})) {
+        const pc = data.PeerConnections[id];
+        const trace = [{
+            type: 'create',
+            value: pc.rtcConfiguration,
+            timestamp: pc.updateLog?.[0]?.timestamp || startTimestamp,
+            extra: [],
+        }];
+        for (const ev of (pc.updateLog || [])) {
+            let value = ev.value;
+            if (typeof value === 'string' && value.length > 0) {
+                try { value = JSON.parse(value); } catch (_) { /* keep as string */ }
+            }
+            trace.push({
+                type: ev.type,
+                value,
+                timestamp: ev.timestamp || (ev.time ? new Date(ev.time).getTime() : 0),
+                extra: [],
+            });
+        }
+        // Convert the per-property stats timeseries back into per-tick getStats events.
+        const series = createInternalsTimeSeries(pc);
+        if (series) {
+            const byTimestamp = new Map();
+            for (const statsId of Object.keys(series)) {
+                const statsType = series[statsId].type;
+                for (const property of Object.keys(series[statsId])) {
+                    if (['type', 'timestamp', 'id'].includes(property)) continue;
+                    for (const [ts, value] of series[statsId][property]) {
+                        if (!byTimestamp.has(ts)) byTimestamp.set(ts, {});
+                        const report = byTimestamp.get(ts);
+                        if (!report[statsId]) {
+                            report[statsId] = {id: statsId, timestamp: ts, type: statsType};
+                        }
+                        report[statsId][property] = value;
+                    }
+                }
+            }
+            for (const ts of byTimestamp.keys()) {
+                trace.push({type: 'getStats', value: byTimestamp.get(ts), timestamp: ts, extra: []});
+            }
+        }
+        trace.sort((a, b) => a.timestamp - b.timestamp);
+        peerConnections[id] = trace;
+    }
+    return {peerConnections, eventSizes: {}};
+}
+
+// Auto-detect the dump format and dispatch.
+export async function readDump(blob) {
+    if (await detectRTCStatsDump(blob)) {
+        return readRTCStatsDump(blob);
+    }
+    return internalsToRtcstats(await readWebRTCInternalsDump(blob));
+}
+
 export async function extractTracks(peerConnectionTrace) {
     const tracks = [];
     for (const traceEvent of peerConnectionTrace) {
@@ -183,6 +284,30 @@ export async function extractTracks(peerConnectionTrace) {
                 }
                 associatedTrack.statsId = id;
             });
+        } else if (traceEvent.type === 'transceiverAdded') {
+            // chrome://webrtc-internals non-spec event.
+            const {value} = traceEvent;
+            if (['addTrack', 'addTransceiver'].includes(traceEvent.value?.reason)) {
+                const trackInformation = {
+                    startTime: traceEvent.timestamp,
+                    direction: 'outbound',
+                    kind: value.kind,
+                    id: value.sender.track,
+                    label: value.sender.track,
+                    streams: value.sender.streams,
+                };
+                tracks.push(trackInformation);
+            } else if (traceEvent.value?.reason === 'setRemoteDescription') {
+                const trackInformation = {
+                    startTime: traceEvent.timestamp,
+                    direction: 'inbound',
+                    kind: value.kind,
+                    id: value.receiver.track,
+                    label: value.receiver.track,
+                    streams: value.receiver.streams,
+                };
+                tracks.push(trackInformation);
+            }
         }
     }
     return tracks;

package/package.json

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

package/timeseries.js

@@ -33,8 +33,15 @@ export function createInternalsTimeSeries(connection) {
             return;
         }
         const timestamps = JSON.parse(connection.stats[statsId + '-timestamp'].values);
-        series[statsId][statsProperty] = JSON.parse(stats.values).map((currentValue, index) => {
-            return [timestamps[index], currentValue];
+        // Note: this does not work if a property only shows up on a stat "late".
+        // Observed e.g. with targetBitrate when the encoding is initially disabled.
+        // Then stats exist (and create a timestamp) but targetBitrate does not.
+        // Taking this from the end does not always work either, e.g. for remote rtcp-based
+        // reports.
+        const values = JSON.parse(stats.values);
+        const offset = timestamps.length - values.length;
+        series[statsId][statsProperty] = values.map((currentValue, index) => {
+            return [timestamps[index + offset], currentValue];
         });
     }
     return series;