@rtcstats/rtcstats-shared 1.0.0 → 2.0.0

package/README.md

@@ -1,3 +1,10 @@
+This is part of the [monorepo](https://github.com/rtcstats/rtcstats) for rtcstats-js
+(clientside monitoring), rtcstats-server (serverside dump collection) and the updated
+dump-importer (supporting rtcstats and webrtc-internals formats).
+
+It is part of a bigger offering that includes [rtcstats.com](https://rtcstats.com),
+an online service for debugging and troubleshooting WebRTC statistics.
+
 ## rtcstats shared code
 
 Internal package with shared code used by rtcstats-js and rtcstats-server.

package/compression.js

@@ -79,9 +79,8 @@ export function statsCompression(baseStatsInput, newStatsInput, statsIdMap) {
         delta[compressStatsProperty('timestamp')] = timestamp;
     }
 
-    // Remove mostly useless things like certificate and codec stats.
+    // Remove mostly useless things like certificate stats.
     removeCertificateStats(delta);
-    removeCodecStats(delta);
     removeObsoleteProperties(delta);
 
     // Replace the semi-structured ids with numerically increasing ones.
@@ -229,23 +228,6 @@ function removeCertificateStats(stats) {
     });
 }
 
-/**
- * Removes codec stats and references to them.
- * @protected
- * @param stats {stats} - JSON stats object.
- */
-function removeCodecStats(stats) {
-    Object.keys(stats).forEach((id) => {
-        const report = stats[id];
-        if (report.type === 'codec') {
-            delete stats[id];
-        }
-        if (report.codecId !== undefined) {
-            delete report.codecId;
-        }
-    });
-}
-
 /**
  * Removes obsolete properties.
  * @protected
@@ -396,6 +378,8 @@ const methodTable = {
     'MediaStreamTrack.onended': 72,
     'MediaStreamTrack.onmute': 73,
     'MediaStreamTrack.onunmute': 74,
+    // HTMLMediaElement
+    'HTMLMediaElement.resize': 80,
 };
 const reverseMethodTable = Object.keys(methodTable).reduce((table, method) => {
     table[methodTable[method]] = method;

package/dump.js

@@ -0,0 +1,119 @@
+import {
+    decompressMethod,
+    descriptionDecompression,
+    statsDecompression,
+} from './compression.js';
+
+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('{');
+}
+
+export async function readRTCStatsDump(blob) {
+    const textBlob = await blob.text();
+    const firstLine = await textBlob.slice(0, 13);
+    if (firstLine !== 'RTCStatsDump\n') {
+        console.error('Not an RTCStatsDump');
+        return;
+    }
+    const lines = (await textBlob.slice(13)).split('\n');
+
+    // The second line must be a JSON object with metadata.
+    let data;
+    try {
+        data = JSON.parse(lines.shift());
+    } catch(e) {
+        console.error('Second line is not JSON data');
+        return;
+    }
+    if (typeof data !== 'object' || Array.isArray(data)) {
+        console.error('Second line must be an object');
+        return;
+    }
+    data.peerConnections = {};
+    data.eventSizes = {};
+
+    const baseStats = {};
+    let lastTime = 0;
+    for (let line of lines) {
+        if (!line.length) {
+            continue; // Ignore empty lines.
+        }
+        let jsonData;
+        try {
+            jsonData = JSON.parse(line);
+        } catch(e) {
+            console.error('Parsing line as JSON failed');
+            return;
+        }
+        if (!Array.isArray(jsonData)) {
+            continue; // Ignore non-array lines.
+        }
+        let [method, connection_id, value, ...extra] = jsonData;
+        method = decompressMethod(method);
+
+        lastTime = extra.pop() + lastTime;
+        const time = new Date(lastTime);
+
+        if (method === 'getStats') { // delta-compressed stats
+            value = statsDecompression(baseStats[connection_id], value);
+            baseStats[connection_id] = JSON.parse(JSON.stringify(value));
+        } else if (method === 'setLocalDescription') {
+            let createCall;
+            for (let previousIndex = data.peerConnections[connection_id].length - 1; previousIndex >= 0; previousIndex--) {
+                if ((value.type === 'offer' && data.peerConnections[connection_id][previousIndex].type === 'createOfferOnSuccess') ||
+                    (value.type === 'answer' && data.peerConnections[connection_id][previousIndex].type === 'createAnswerOnSuccess')) {
+                    createCall = data.peerConnections[connection_id][previousIndex];
+                    break;
+                }
+            }
+            if (createCall) {
+                value = descriptionDecompression(createCall.value, value);
+            }
+        } else if (['createOfferOnSuccess', 'createAnswerOnSuccess'].includes(method)) {
+            let sldCall;
+            for (let previousIndex = data.peerConnections[connection_id].length - 1; previousIndex >= 0; previousIndex--) {
+                if ((value.type === 'offer' && data.peerConnections[connection_id][previousIndex].type === 'setLocalDescription') ||
+                    (value.type === 'answer' && data.peerConnections[connection_id][previousIndex].type === 'setLocalDescription')) {
+                    sldCall = data.peerConnections[connection_id][previousIndex];
+                    break;
+                }
+            }
+            if (sldCall) {
+                value = descriptionDecompression(sldCall.value, value);
+            }
+        }
+
+        // TODO: more explicit handling via create and close?
+        if (!data.peerConnections[connection_id]) {
+            data.peerConnections[connection_id] = [];
+            baseStats[connection_id] = {};
+        }
+        data.peerConnections[connection_id].push({
+            time, // deprecated, prefer timestamp.
+            timestamp: lastTime,
+            type: method,
+            value,
+            extra,
+        });
+
+        if (!data.eventSizes[connection_id]) {
+            data.eventSizes[connection_id] = [];
+        }
+        data.eventSizes[connection_id].push({
+            x: lastTime,
+            y: line.length,
+            method,
+        });
+    }
+    return data;
+}
+
+export async function readWebRTCInternalsDump(blob) {
+    const textBlob = await blob.text();
+    return JSON.parse(textBlob);
+}

package/index.d.ts

@@ -0,0 +1,5 @@
+// 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;

package/index.js

@@ -1,4 +1,6 @@
 export * from './compression.js';
+export * from './dump.js';
+export * from './timeseries.js';
 export * from './utils.js';
 // Not exported since the dump-importer would pull the sdp dependency.
 // export * from './address-obfuscator.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rtcstats/rtcstats-shared",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "main": "index.js",
   "description": "gather WebRTC API traces and statistics",
   "type": "module",
@@ -10,12 +10,15 @@
   },
   "scripts": {
     "lint": "eslint *.js test/",
-    "coverage": "c8 --reporter html mocha test",
+    "coverage": "c8 --reporter html --reporter lcov mocha test",
     "test": "npm run lint && npm run coverage"
   },
   "author": "rtcstats.com",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "sdp": "^3.2.1"
   }
 }

package/timeseries.js

@@ -0,0 +1,86 @@
+/**
+ * Creates a timeseries from webrtc-internals.
+ * Returns an object with stats by id and an object of property=> [[ts, value], ...].
+ */
+export function createInternalsTimeSeries(connection) {
+    const series = {};
+    for (const reportname in connection.stats) {
+        // special casing of computed stats, in particular [a-b]
+        let statsId;
+        let statsProperty;
+        if (reportname.indexOf('[') !== -1) {
+            const t = reportname.split('[');
+            statsProperty = '[' + t.pop();
+            statsId = t.join('');
+            statsId = statsId.substr(0, statsId.length - 1);
+        } else {
+            const t = reportname.split('-');
+            statsProperty = t.pop();
+            statsId = t.join('-');
+        }
+        if (statsProperty === 'type') continue;
+        const stats = connection.stats[reportname];
+
+        if (!series.hasOwnProperty(statsId)) {
+            series[statsId] = {
+                type: stats.statsType,
+            };
+        }
+        if (!connection.stats[statsId + '-timestamp']) {
+            // Individual timestamps were added in crbug.com/1462567 in M117.
+            // This version is not supported anymore.
+            console.error('webrtc-internals dump missing timestamps for stats added in M117.');
+            return;
+        }
+        const timestamps = JSON.parse(connection.stats[statsId + '-timestamp'].values);
+        series[statsId][statsProperty] = JSON.parse(stats.values).map((currentValue, index) => {
+            return [timestamps[index], currentValue];
+        });
+    }
+    return series;
+}
+
+/**
+ * Creates a timeseries from rtcstats.
+ * Returns an object with stats by id and an object of property=> [[ts, value], ...].
+ */
+export function createRtcStatsTimeSeries(trace) {
+    const series = {};
+    for (const traceEvent of trace) {
+        if (traceEvent.type !== 'getStats') {
+            continue;
+        }
+        const stats = traceEvent.value;
+        for (const id in stats) {
+            const report = stats[id];
+            if (!series[id]) {
+                series[id] = {};
+                series[id].type = stats[id].type;
+            }
+            for (const statsProperty in report) {
+                if (['timestamp', 'type', 'id'].includes(statsProperty)) continue;
+                const timeSeries = series[id];
+                if (!timeSeries[statsProperty]) {
+                    timeSeries[statsProperty] = [];
+                }
+                timeSeries[statsProperty].push([report.timestamp, report[statsProperty]]);
+            }
+        }
+    }
+    return series;
+}
+
+// Inserts null values for gaps in timeseries which creates a gap in Highcharts plots.
+// TODO: figure out how to show the markers for this point.
+// Possibly using https://api.highcharts.com/highcharts/plotOptions.series.zones
+export function insertNullForGapsIntoTimeSeries(timeSeries, gapSizeMs = 5000) {
+    const newSeries = [timeSeries[0]];;
+    for (let i = 1; i < timeSeries.length; i++) {
+        const delta = timeSeries[i][0] - timeSeries[i - 1][0];
+        if (delta > gapSizeMs) {
+            newSeries.push([timeSeries[i][0], null]);
+        }
+        newSeries.push([timeSeries[i][0], timeSeries[i][1]]);
+    }
+    return newSeries;
+}

package/utils.js

@@ -10,11 +10,9 @@ export function map2obj(m) {
     if (!m.entries) {
         return m;
     }
-    const o = {};
-    m.forEach((v, k) => {
-        o[k] = v;
-    });
-    return o;
+    return [...m.entries()].reduce((o, [k, v]) => {
+        o[k] = v; return o;
+    }, {});
 }
 
 /**
@@ -27,7 +25,7 @@ export function map2obj(m) {
  * @returns {String[]} - serialized representation.
  */
 export function dumpTrackWithStreams(track, ...streams) {
-    return [track.kind, track.id, ...streams.map(s => s.id)];
+    return [track.kind, track.id, track.label, ...streams.map(s => s.id)];
 }
 
 /**