@rtcstats/rtcstats-shared 2.0.1 → 2.1.0

package/address-obfuscator.js

@@ -1,10 +1,12 @@
 // Obfuscate ip addresses which should not be stored long-term.
+import {compressStatsProperty} from './compression.js';
+
 import SDPUtils from 'sdp';
 
 // Obfuscate an IP address, keeping address family intact.
 // 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
-function obfuscateIpOrAddress(ipOrAddress) {
+export function obfuscateIpOrAddress(ipOrAddress) {
     if (['::1', '127.0.0.1'].includes(ipOrAddress)) {
         return ipOrAddress;
     }
@@ -50,6 +52,10 @@ function obfuscateSDP(sdp) {
     }).join('\r\n').trim() + '\r\n';
 }
 
+const compressedAddressProperty = compressStatsProperty('address');
+const compressedRelatedAddressProperty = compressStatsProperty('relatedAddress');
+const compressedCandidateTypeProperty = compressStatsProperty('candidateType');
+const compressedIpProperty = compressStatsProperty('ip');
 function obfuscateStats(stats) {
     Object.keys(stats).forEach((id) => {
         const report = stats[id];
@@ -60,9 +66,17 @@ function obfuscateStats(stats) {
             report.address = obfuscateIpOrAddress(report.address);
             delete report.ip;
         }
+        if (report[compressedAddressProperty] && report[compressedCandidateTypeProperty] !== 'relay') {
+            report[compressedAddressProperty] = obfuscateIpOrAddress(report[compressedAddressProperty]);
+            delete report.ip;
+            delete report[compressedIpProperty];
+        }
         if (report.relatedAddress) {
             report.relatedAddress = obfuscateIpOrAddress(report.relatedAddress);
         }
+        if (report[compressedRelatedAddressProperty]) {
+            report[compressedRelatedAddressProperty] = obfuscateIpOrAddress(report[compressedRelatedAddressProperty]);
+        }
     });
 }
 

package/compression.js

@@ -736,3 +736,10 @@ export function decompressStatsProperty(property) {
     return reverseStatsPropertyTable[property] || property;
 }
 
+// Mapping from compute pressure names to numerical values.
+export const computePressureTable = {
+    nominal: 4,
+    fair: 3,
+    serious: 2,
+    critical: 1,
+};

package/dump.js

@@ -3,6 +3,7 @@ import {
     descriptionDecompression,
     statsDecompression,
 } from './compression.js';
+import {parseTrackWithStreams} from './utils.js';
 
 export async function detectRTCStatsDump(blob) {
     const magic = await blob.slice(0, 13).text();
@@ -62,7 +63,9 @@ export async function readRTCStatsDump(blob) {
         if (method === 'getStats') { // delta-compressed stats
             value = statsDecompression(baseStats[connection_id], value);
             baseStats[connection_id] = JSON.parse(JSON.stringify(value));
-        } else if (method === 'setLocalDescription' && value) {
+        } else if (method === 'setLocalDescription' && value &&
+            // Workaround for Chrome <145 bug: https://source.chromium.org/chromium/chromium/src/+/4a2a384e43ea163127219548087e949fb00fa562
+            connection_id !== 'undefined-undefined') {
             // Implicit SLD has no value to decompress.
             let createCall;
             for (let previousIndex = data.peerConnections[connection_id].length - 1; previousIndex >= 0; previousIndex--) {
@@ -118,3 +121,69 @@ export async function readWebRTCInternalsDump(blob) {
     const textBlob = await blob.text();
     return JSON.parse(textBlob);
 }
+
+export async function extractTracks(peerConnectionTrace) {
+    const tracks = [];
+    for (const traceEvent of peerConnectionTrace) {
+        if (traceEvent.type === 'addTrack') {
+            const trackInformation = parseTrackWithStreams(traceEvent.value);
+            trackInformation.startTime = traceEvent.timestamp;
+            trackInformation.direction = 'outbound';
+            tracks.push(trackInformation);
+        } else if (traceEvent.type === 'ontrack') {
+            const trackInformation = parseTrackWithStreams(traceEvent.value);
+            trackInformation.startTime = traceEvent.timestamp;
+            trackInformation.direction = 'inbound';
+            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?
+                // libWebRTC seems to generate a random one for the SDP.
+            } else {
+                const trackInformation = parseTrackWithStreams(traceEvent.value[0]);
+                if (traceEvent.value[1]?.streams) {
+                    trackInformation.streams = traceEvent.value[1].streams;
+                }
+                trackInformation.startTime = traceEvent.timestamp;
+                trackInformation.direction = 'outbound';
+                tracks.push(trackInformation);
+            }
+        } else if (traceEvent.type === 'replaceTrack') {
+            // This handles tracks that are added with addTransceiver(kind) and replaceTrack.
+            const [_, newTrack] = traceEvent.value;
+            if (newTrack) {
+                const trackInformation = parseTrackWithStreams(newTrack);
+                trackInformation.startTime = traceEvent.timestamp;
+                trackInformation.direction = 'outbound';
+                if (tracks.find(info => info.id === trackInformation.id) === undefined) {
+                    tracks.push(trackInformation);
+                }
+            }
+        } else if (traceEvent.type === 'getStats') {
+            const report = traceEvent.value;
+            Object.keys(report).forEach(id => {
+                const stats = report[id];
+                if (!['inbound-rtp', 'outbound-rtp' /* TODO: media-source */].includes(stats.type)) {
+                    return;
+                }
+                const associatedTrack = tracks.find(trackInformation => {
+                    // Tracks remain associated when replaceTrack is used.
+                    if (trackInformation.statsId !== undefined) {
+                        return trackInformation.statsId === id;
+                    }
+                    if (stats.type === 'inbound-rtp') {
+                        return trackInformation.id === stats.trackIdentifier;
+                    }
+                    return trackInformation.id === (stats.mediaSourceId &&
+                        report[stats.mediaSourceId] &&
+                        report[stats.mediaSourceId].trackIdentifier);
+                });
+                if (!associatedTrack) {
+                    return;
+                }
+                associatedTrack.statsId = id;
+            });
+        }
+    }
+    return tracks;
+}

package/index.d.ts

@@ -1,5 +1,27 @@
-// Minimal .d.ts
-export async function detectWebRTCInternalsDump(blob: Blob): boolean;
-export async function readWebRTCInternalsDump(blob: Blob): object;
-export async function detectRTCStatsDump(blob: Blob): boolean;
-export async function readRTCStatsDump(blob: Blob): object;
+// Type definitions for @rtcstats/rtcstats-shared
+
+export async function detectWebRTCInternalsDump(blob: Blob): Promise<boolean>;
+export async function readWebRTCInternalsDump(blob: Blob): Promise<object>;
+export async function detectRTCStatsDump(blob: Blob): Promise<boolean>;
+export async function readRTCStatsDump(blob: Blob): Promise<object>;
+export async function extractTracks(peerConnectionTrace: any[]): Promise<any[]>;
+
+export function statsCompression(baseStatsInput: object | RTCStatsReport, newStatsInput: object | RTCStatsReport, statsIdMap: object): object;
+export function statsDecompression(baseStatsInput: object, delta: object): object;
+export function descriptionCompression(baseDescription: RTCSessionDescription, newDescription: RTCSessionDescription): RTCSessionDescriptionInit;
+export function descriptionDecompression(baseDescription: RTCSessionDescription, newDescription: RTCSessionDescription): RTCSessionDescriptionInit;
+export function compressMethod(method: string): string | number;
+export function decompressMethod(methodKey: string | number): string;
+export function compressStatsType(type: string): string | number;
+export function decompressStatsType(typeKey: string | number): string;
+export function compressStatsProperty(property: string): string | number;
+export function decompressStatsProperty(property: string | number): string;
+
+export function createInternalsTimeSeries(connection: any): object;
+export function createRtcStatsTimeSeries(trace: any[]): object;
+export function insertNullForGapsIntoTimeSeries(timeSeries: any[], gapSizeMs?: number): any[];
+
+export function map2obj(m: Map<any, any> | object): object;
+export function dumpTrackWithStreams(track: MediaStreamTrack, ...streams: MediaStream[]): string[];
+export function parseTrackWithStreams(serialized: any[]): object;
+export function copyAndSanitizeConfig(config: RTCConfiguration): object;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rtcstats/rtcstats-shared",
-  "version": "2.0.1",
+  "version": "2.1.0",
   "main": "index.js",
   "description": "gather WebRTC API traces and statistics",
   "type": "module",
@@ -17,8 +17,5 @@
   "license": "MIT",
   "publishConfig": {
     "access": "public"
-  },
-  "dependencies": {
-    "sdp": "^3.2.1"
   }
 }

package/timeseries.js

@@ -42,7 +42,7 @@ export function createInternalsTimeSeries(connection) {
 
 /**
  * Creates a timeseries from rtcstats.
- * Returns an object with stats by id and an object of property=> [[ts, value], ...].
+ * Returns an object with stats by id and an object of property => [[ts, value], ...].
  */
 export function createRtcStatsTimeSeries(trace) {
     const series = {};

package/utils.js

@@ -28,6 +28,20 @@ export function dumpTrackWithStreams(track, ...streams) {
     return [track.kind, track.id, track.label, ...streams.map(s => s.id)];
 }
 
+/**
+ * Parses the serialized track and returns an object (which is not a track).
+ *
+ * @returns {Object} - representation of the track with streams.
+ */
+export function parseTrackWithStreams(serialized) {
+    return {
+        kind: serialized[0],
+        id: serialized[1],
+        label: serialized[2],
+        streams: serialized.slice(3),
+    };
+}
+
 /**
  * Sanitizes a RTCConfiguration by hiding the TURN server credentials and
  * making the certificates serializable.