@rtcstats/rtcstats-js 2.2.1 → 2.2.3

package/README.md

@@ -5,6 +5,9 @@ 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.
 
+For a complete reference of every getStats() metric rtcstats collects and analyzes, see
+the [WebRTC Stats Reference](https://rtcstats.com/kb/webrtc-stats-reference-page).
+
 # rtcstats-js: A Javascript client SDK for monitoring WebRTC
 
 The Javascript SDK provides low-level logging on peerconnection API calls and periodic getStats calls for analytics/debugging purposes.
@@ -71,6 +74,7 @@ trace(method name, e.g. `:userRating`,
 * The trace function will internally add a timestamp to the event.
 * rtcstats-server will not process such events by default.
 * A dump-importer should still display a generic rendering of the event.
+* Compression should not be used for custom methods.
 
 ### Using a JWT to connect to rtcstats-server
 See [the server README](https://github.com/rtcstats/rtcstats/blob/main/packages/rtcstats-server/README.md) for how to
@@ -111,6 +115,7 @@ Note that RTCStats is not keeping track of whether all RTCPeerConnections have b
 have been stopped.
 
 ### See also
-See also the [end-to-end example](/example/) in `example/` directory and
-the (internal) API docs [here](docs/index.md).
+* the [end-to-end example](/example/) in `example/` directory and
+* the (internal) API docs [here](docs/index.md) - note that these may not be fully up-to-date.
+* the [WebRTC Stats Reference](https://rtcstats.com/kb/webrtc-stats-reference-page) which tells you what each getStats() metric means, expected values, and common issues.
 

package/package.json

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

package/peerconnection.js

@@ -13,7 +13,7 @@ import {map2obj, dumpTrackWithStreams, copyAndSanitizeConfig} from '@rtcstats/rt
  *
  * @protected
  * @param {function} trace - RTCStats trace callback
- * @param {object} window - window object from which to take the RTCRtpTransceiver protoype.
+ * @param {object} window - window object from which to take the RTCRtpTransceiver prototype.
  */
 function wrapRTCRtpTransceiver(trace, window) {
     if (!window.RTCRtpTransceiver) {
@@ -31,13 +31,13 @@ function wrapRTCRtpTransceiver(trace, window) {
 }
 
 /**
- * Wraps a RTCRtpSenderfor RTCStats. Currently applied to these methods:
+ * Wraps a RTCRtpSender for RTCStats. Currently applied to these methods:
  * * setParameters
- * * replaceTrack 
+ * * replaceTrack
  *
  * @protected
  * @param {function} trace - RTCStats trace callback
- * @param {object} window - window object from which to take the RTCRtpSender protoype.
+ * @param {object} window - window object from which to take the RTCRtpSender prototype.
  */
 function wrapRTCRtpSender(trace, window) {
     if (!window.RTCRtpSender) {
@@ -77,7 +77,7 @@ function wrapRTCRtpSender(trace, window) {
  * Legacy methods and events are not wrapped.
  *
  * @param {function} trace - RTCStats trace callback
- * @param {object} window - window object from which to take the RTCPeerConnection protoype.
+ * @param {object} window - window object from which to take the RTCPeerConnection prototype.
  * @param {object} configuration - various configurable properties. Currently:
  * * getStatsInterval {number} - interval at which getStats will be polled.
  */
@@ -90,7 +90,7 @@ export function wrapRTCPeerConnection(trace, window, {getStatsInterval}) {
         return;
     }
     let lastComputePressureRecord;
-    if (window.PressureObserver) {
+    if (window.PressureObserver && getStatsInterval) {
         const observer = new PressureObserver((records) => {
             const lastRecord = records[records.length - 1]; // Usually only one record.
             lastComputePressureRecord = [Date.now(), lastRecord];
@@ -279,7 +279,7 @@ export function wrapRTCPeerConnection(trace, window, {getStatsInterval}) {
             }
             trace(method, this.__rtcStatsId, serializedArgs);
             const transceiver = nativeMethod.apply(this, [trackOrKind, ...args]);
-            transceiver.__rtcStatsId =  this.__rtcStatsId;
+            transceiver.__rtcStatsId = this.__rtcStatsId;
             transceiver.sender.__rtcStatsId = this.__rtcStatsId;
             transceiver.sender.__rtcStatsSenderId = transceiver.receiver.track.id;
             trace(method + 'OnSuccess', this.__rtcStatsId, null, transceiver.receiver.track.id);
@@ -393,10 +393,9 @@ export function wrapRTCPeerConnection(trace, window, {getStatsInterval}) {
             const trackingId = compressMethod(method) + '-' + (counters[method]++);
             trace(method, this.__rtcStatsId, args[0], trackingId);
             return nativeMethod.apply(this, args)
-                .then((description) => {
+                .then(() => {
                     trace(method + 'OnSuccess', this.__rtcStatsId, undefined,
                         trackingId);
-                    return description;
                 }, (err) => {
                     trace(method + 'OnFailure', this.__rtcStatsId, err.toString(),
                         trackingId);
@@ -417,13 +416,7 @@ export function wrapRTCPeerConnection(trace, window, {getStatsInterval}) {
 
     // wrap static methods. Currently just generateCertificate.
     if (OrigPeerConnection.generateCertificate) {
-        Object.defineProperty(RTCStatsPeerConnection, 'generateCertificate', {
-            get(...args) {
-                return args.length ?
-                    OrigPeerConnection.generateCertificate.apply(null, args)
-                    : OrigPeerConnection.generateCertificate;
-            },
-        });
+        RTCStatsPeerConnection.generateCertificate = OrigPeerConnection.generateCertificate;
     }
     window.RTCPeerConnection = RTCStatsPeerConnection;
     window.RTCPeerConnection.prototype = OrigPeerConnection.prototype;

package/trace-websocket.js

@@ -6,20 +6,16 @@ const RELOAD_COUNT_KEY = 'rtcstatsReloadCount';
 export function WebSocketTrace(config = {}) {
     let buffer = [];
     let connection;
-    let lastTime = Date.now();
+    let lastTime = 0;
     let connectionStartTime = 0;
-    const createTime = Date.now();
 
     // This counts the number of times the trace itself has been initialized.
     // Typically this is done once per session and counting (re)loads based
     // on that does not require listening for onload etc.
     let reloadCount = undefined;
     if (window.sessionStorage && config.countReloads) {
-        reloadCount =  window.sessionStorage.getItem(RELOAD_COUNT_KEY);
-        if (reloadCount === null || isNaN(reloadCount)) {
-            reloadCount = -1;
-        }
-        reloadCount = parseInt(reloadCount, 10) + 1;
+        const stored = parseInt(window.sessionStorage.getItem(RELOAD_COUNT_KEY), 10);
+        reloadCount = Number.isNaN(stored) ? 0 : stored + 1;
         window.sessionStorage.setItem(RELOAD_COUNT_KEY, reloadCount);
     }
     const trace = function(...args) {
@@ -56,16 +52,38 @@ export function WebSocketTrace(config = {}) {
         }
         if (connection) {
             connection.close();
+            connection = null;
+            // New traces need to get an absolute timestamp.
+            lastTime = 0;
         }
     };
     trace.connect = (wsURL) => {
         if (connection) {
             connection.close();
+            lastTime = 0;
+            connection = null;
         }
+        trace('create', null, {
+            hardwareConcurrency: navigator.hardwareConcurrency,
+            userAgentData: navigator.userAgentData,
+            deviceMemory: navigator.deviceMemory,
+            screen: {
+                width: window.screen.availWidth,
+                height: window.screen.availHeight,
+                devicePixelRatio: window.devicePixelRatio,
+            },
+            window: {
+                width: window.innerWidth,
+                height: window.innerHeight,
+            },
+            reloadCount,
+        });
         connectionStartTime = Date.now();
         connection = new WebSocket(wsURL, 'rtcstats#' + PROTOCOL_VERSION);
         connection.addEventListener('error', (e) => {
-            // console.error('WS ERROR', e);
+            if (config.log) {
+                config.log('rtcstats websocket connection error', e, connection.readyState);
+            }
         });
 
         connection.addEventListener('close', (e) => {
@@ -80,23 +98,6 @@ export function WebSocketTrace(config = {}) {
             // Note: open is called while the socket is still authenticating.
             // This can lead to messages being send and dropped when the token
             // is not valid.
-
-            // Note: this does not use trace so avoids the buffer.
-            connection.send(JSON.stringify([compressMethod('create'), null, {
-                hardwareConcurrency: navigator.hardwareConcurrency,
-                userAgentData: navigator.userAgentData,
-                deviceMemory: navigator.deviceMemory,
-                screen: {
-                    width: window.screen.availWidth,
-                    height: window.screen.availHeight,
-                    devicePixelRatio: window.devicePixelRatio,
-                },
-                window: {
-                    width: window.innerWidth,
-                    height: window.innerHeight,
-                },
-                reloadCount,
-            }, createTime]));
             const connectionTime = Date.now() - connectionStartTime;
             setTimeout(function flush() {
                 if (!buffer.length) {