browsertime 16.16.0 → 17.0.0-beta.0

package/lib/support/pathToFolder.js

@@ -1,26 +1,24 @@
-'use strict';
-
-const isEmpty = require('lodash.isempty');
-const crypto = require('crypto');
-const log = require('intel').getLogger('browsertime');
-const urlParser = require('url');
+import { parse } from 'node:url';
+import { createHash } from 'node:crypto';
+import isEmpty from 'lodash.isempty';
+import intel from 'intel';
+const log = intel.getLogger('browsertime');
 
 function toSafeKey(key) {
   // U+2013 : EN DASH – as used on https://en.wikipedia.org/wiki/2019–20_coronavirus_pandemic
-  return key.replace(/[.~ /+|,:?&%–)(]|%7C/g, '-');
+  return key.replace(/[ %&()+,./:?|~–]|%7C/g, '-');
 }
 
-module.exports = function (url, options) {
+export default function (url, options) {
   if (options.useSameDir) {
     return '';
   } else {
     const useHash = options.useHash;
-    const parsedUrl = urlParser.parse(decodeURIComponent(url));
+    const parsedUrl = parse(decodeURIComponent(url));
 
     const pathSegments = [];
     const urlSegments = [];
-    pathSegments.push('pages');
-    pathSegments.push(parsedUrl.hostname.split('.').join('_'));
+    pathSegments.push('pages', parsedUrl.hostname.split('.').join('_'));
 
     if (options.urlMetaData && options.urlMetaData[url]) {
       pathSegments.push(options.urlMetaData[url]);
@@ -30,14 +28,14 @@ module.exports = function (url, options) {
       }
 
       if (useHash && !isEmpty(parsedUrl.hash)) {
-        const md5 = crypto.createHash('md5'),
-          hash = md5.update(parsedUrl.hash).digest('hex').substring(0, 8);
+        const md5 = createHash('md5'),
+          hash = md5.update(parsedUrl.hash).digest('hex').slice(0, 8);
         urlSegments.push('hash-' + hash);
       }
 
       if (!isEmpty(parsedUrl.search)) {
-        const md5 = crypto.createHash('md5'),
-          hash = md5.update(parsedUrl.search).digest('hex').substring(0, 8);
+        const md5 = createHash('md5'),
+          hash = md5.update(parsedUrl.search).digest('hex').slice(0, 8);
         urlSegments.push('query-' + hash);
       }
 
@@ -50,7 +48,7 @@ module.exports = function (url, options) {
           log.info(
             `The URL ${url} hit the 255 character limit used when stored on disk, you may want to give your URL an alias to make sure it will not collide with other URLs.`
           );
-          pathSegments.push(folder.substr(0, 254));
+          pathSegments.push(folder.slice(0, 254));
         } else {
           pathSegments.push(folder);
         }
@@ -59,15 +57,12 @@ module.exports = function (url, options) {
 
     pathSegments.push('data');
 
-    pathSegments.forEach(function (segment, index) {
+    for (const [index, segment] of pathSegments.entries()) {
       if (segment) {
-        pathSegments[index] = segment.replace(
-          /[^-a-z0-9_.\u0621-\u064A]/gi,
-          '-'
-        );
+        pathSegments[index] = segment.replace(/[^\w.\u0621-\u064A-]/gi, '-');
       }
-    });
+    }
 
     return pathSegments.join('/').concat('/');
   }
-};
+}

package/lib/support/preURL.js

@@ -1,9 +1,8 @@
-'use strict';
-
-const log = require('intel').getLogger('browsertime');
+import intel from 'intel';
+const log = intel.getLogger('browsertime');
 const delay = ms => new Promise(res => setTimeout(res, ms));
 
-module.exports = async function (browser, options) {
+export default async function (browser, options) {
   log.info('Accessing preURL %s', options.preURL);
   await browser.loadAndWait(options.preURL);
   if (!options.preURLDisableWhiteBackground) {
@@ -13,5 +12,5 @@ module.exports = async function (browser, options) {
     );
   }
 
-  return delay(options.preURLDelay ? options.preURLDelay : 1500);
-};
+  return delay(options.preURLDelay ?? 1500);
+}

package/lib/support/processes.js

@@ -1,7 +1,5 @@
-'use strict';
-
-const execa = require('execa');
-module.exports = async function () {
-  const { stdout } = await execa.command('ps aux | wc -l', { shell: true });
+import { execaCommand as command } from 'execa';
+export default async function () {
+  const { stdout } = await command('ps aux | wc -l', { shell: true });
   return stdout;
-};
+}

package/lib/support/setResourceTimingBufferSize.js

@@ -1,8 +1,6 @@
-'use strict';
-
-module.exports = async function (startURL, driver, size) {
+export default async function (startURL, driver, size) {
   await driver.get(startURL);
   await driver.executeScript(
     `window.performance.setResourceTimingBufferSize(${size});`
   );
-};
+}

package/lib/support/statistics.js

@@ -1,12 +1,8 @@
-'use strict';
-/*
- * Utility functions for managing statistics of collected metrics and timings.
- */
-
-const get = require('lodash.get');
-const set = require('lodash.set');
-const Stats = require('fast-stats').Stats;
-const log = require('intel').getLogger('browsertime');
+import get from 'lodash.get';
+import set from 'lodash.set';
+import { Stats } from 'fast-stats';
+import intel from 'intel';
+const log = intel.getLogger('browsertime');
 
 function validateType(value, type, message) {
   if (typeof value !== type) {
@@ -24,7 +20,17 @@ function percentileName(percentile) {
   }
 }
 
-class Statistics {
+function isNumeric(n) {
+  return !Number.isNaN(Number.parseFloat(n)) && Number.isFinite(n);
+}
+
+function addNumber(target, key, value) {
+  let stats = get(target, key, new Stats());
+  stats.push(value);
+  set(target, key, stats);
+}
+
+export class Statistics {
   constructor() {
     this.data = {};
   }
@@ -32,7 +38,7 @@ class Statistics {
   add(key, value) {
     validateType(key, 'string', 'key (' + key + ') must be a string');
     validateType(value, 'number', 'value (' + value + ') must be a number');
-    if (!isFinite(value)) {
+    if (!Number.isFinite(value)) {
       throw new RangeError("value can't be infinite");
     }
 
@@ -43,28 +49,18 @@ class Statistics {
   addAll(data) {
     let samples = Array.isArray(data) ? data : [data];
 
-    samples.forEach(sample => {
-      Object.keys(sample).forEach(key => {
+    for (const sample of samples) {
+      for (const key of Object.keys(sample)) {
         let value = sample[key];
         // TODO check type of value, to see if it should be included. Possibly via optional transform function
         this.add(key, value);
-      });
-    });
+      }
+    }
 
     return this;
   }
 
   addDeep(data, tranformFunction) {
-    function isNumeric(n) {
-      return !isNaN(parseFloat(n)) && isFinite(n);
-    }
-
-    function addNumber(target, key, value) {
-      let stats = get(target, key, new Stats());
-      stats.push(value);
-      set(target, key, stats);
-    }
-
     function addRecursive(target, keyPrefix, value) {
       if (tranformFunction && keyPrefix.length > 0) {
         value = tranformFunction(keyPrefix, value);
@@ -72,43 +68,48 @@ class Statistics {
       const valueType = typeof value;
 
       switch (valueType) {
-        case 'number':
+        case 'number': {
           {
             addNumber(target, keyPrefix, value);
           }
           break;
+        }
 
-        case 'object':
+        case 'object': {
           {
             if (value === null) {
               break;
             }
-            Object.keys(value).forEach(key => {
-              const path = keyPrefix.concat([key]);
+            for (const key of Object.keys(value)) {
+              const path = [...keyPrefix, key];
               addRecursive(target, path, value[key]);
-            });
+            }
           }
           break;
+        }
 
-        case 'string':
+        case 'string': {
           {
             if (isNumeric(value)) {
-              addNumber(target, keyPrefix, parseFloat(value));
+              addNumber(target, keyPrefix, Number.parseFloat(value));
             }
           }
           break;
-        case 'boolean':
+        }
+        case 'boolean': {
           {
             //  skip
           }
           break;
+        }
 
-        default:
+        default: {
           log.error(
             'Unhandled value type %s found when adding data for %s ',
             valueType,
             keyPrefix
           );
+        }
       }
     }
 
@@ -120,6 +121,7 @@ class Statistics {
     options = options || {};
     let percentiles = options.percentiles || [0, 10, 90, 99, 100];
 
+    // eslint-disable-next-line unicorn/no-array-reduce
     return Object.keys(this.data).reduce((results, key) => {
       let decimals = options.decimals || 0;
       let stats = get(this.data, [key]);
@@ -131,16 +133,16 @@ class Statistics {
         decimals = 4;
       }
       const node = {
-        median: parseFloat(stats.median().toFixed(decimals)),
-        mean: parseFloat(stats.amean().toFixed(decimals)),
-        mdev: parseFloat(
+        median: Number.parseFloat(stats.median().toFixed(decimals)),
+        mean: Number.parseFloat(stats.amean().toFixed(decimals)),
+        mdev: Number.parseFloat(
           stats.stddev() / Math.sqrt(stats.length).toFixed(decimals)
         ) // "standard deviation of the mean"
       };
-      percentiles.forEach(function (p) {
+      for (const p of percentiles) {
         let name = percentileName(p);
-        node[name] = parseFloat(stats.percentile(p).toFixed(decimals));
-      });
+        node[name] = Number.parseFloat(stats.percentile(p).toFixed(decimals));
+      }
       set(results, [key], node);
 
       return results;
@@ -165,19 +167,23 @@ class Statistics {
         decimals = 4;
       }
       const results = {
-        median: parseFloat(stats.median().toFixed(decimals)),
-        mean: parseFloat(stats.amean().toFixed(decimals)),
-        mdev: parseFloat((stats.stddev() / Math.sqrt(stats.length)).toFixed(4)), // "standard deviation of the mean"
+        median: Number.parseFloat(stats.median().toFixed(decimals)),
+        mean: Number.parseFloat(stats.amean().toFixed(decimals)),
+        mdev: Number.parseFloat(
+          (stats.stddev() / Math.sqrt(stats.length)).toFixed(4)
+        ), // "standard deviation of the mean"
         rsd:
           stats.stddev() > 0
-            ? parseFloat((100 * stats.stddev()) / stats.amean())
+            ? Number.parseFloat((100 * stats.stddev()) / stats.amean())
             : 0, // Relative standard deviation
-        stddev: parseFloat(stats.stddev().toFixed(decimals))
+        stddev: Number.parseFloat(stats.stddev().toFixed(decimals))
       };
-      percentiles.forEach(p => {
+      for (const p of percentiles) {
         let name = percentileName(p);
-        results[name] = parseFloat(stats.percentile(p).toFixed(decimals));
-      });
+        results[name] = Number.parseFloat(
+          stats.percentile(p).toFixed(decimals)
+        );
+      }
       return results;
     }
 
@@ -185,12 +191,12 @@ class Statistics {
       if (data instanceof Stats) {
         set(target, keyPrefix, summarize(data));
       } else if (typeof data === 'object') {
-        Object.keys(data).forEach(key => {
-          const path = keyPrefix.concat([key]);
+        for (const key of Object.keys(data)) {
+          const path = [...keyPrefix, key];
           summarizeRecursive(target, path, data[key]);
-        });
+        }
       } else {
-        throw new Error(
+        throw new TypeError(
           'Unhandled data type ' + typeof data + ' found when summarizing data'
         );
       }
@@ -201,7 +207,3 @@ class Statistics {
     return result;
   }
 }
-
-module.exports = {
-  Statistics: Statistics
-};

package/lib/support/stop.js

@@ -1,12 +1,11 @@
-'use strict';
+import { execa } from 'execa';
+import intel from 'intel';
+const log = intel.getLogger('browsertime');
 
-const execa = require('execa');
-const log = require('intel').getLogger('browsertime');
-
-module.exports = async function (processName) {
-  const scriptArgs = ['-9', processName];
+export default async function (processName) {
+  const scriptArguments = ['-9', processName];
 
   log.debug('Kill all processes ' + processName);
 
-  return execa('pkill', scriptArgs, { reject: false });
-};
+  return execa('pkill', scriptArguments, { reject: false });
+}

package/lib/support/storageManager.js

@@ -1,33 +1,39 @@
-'use strict';
-
-const log = require('intel').getLogger('browsertime');
-const fs = require('fs');
-const isEmpty = require('lodash.isempty');
-const path = require('path');
-const crypto = require('crypto');
-const zlib = require('zlib');
-const urlParser = require('url');
-const dayjs = require('dayjs');
-const { promisify } = require('util');
-const gunzip = promisify(zlib.gunzip);
-const writeFile = promisify(fs.writeFile);
-const readFile = promisify(fs.readFile);
-const gzip = promisify(zlib.gzip);
-const unlink = promisify(fs.unlink);
-const mkdir = promisify(fs.mkdir);
+import { resolve as _resolve, join } from 'node:path';
+import { createHash } from 'node:crypto';
+import { gunzip as _gunzip, gzip as _gzip, createGzip } from 'node:zlib';
+import { parse } from 'node:url';
+import { promisify } from 'node:util';
+import {
+  writeFile as _writeFile,
+  readFile as _readFile,
+  unlink as _unlink,
+  mkdir as _mkdir,
+  createReadStream,
+  createWriteStream
+} from 'node:fs';
+import isEmpty from 'lodash.isempty';
+import intel from 'intel';
+import dayjs from 'dayjs';
+const gunzip = promisify(_gunzip);
+const writeFile = promisify(_writeFile);
+const readFile = promisify(_readFile);
+const gzip = promisify(_gzip);
+const unlink = promisify(_unlink);
+const mkdir = promisify(_mkdir);
+const log = intel.getLogger('browsertime');
 
 const defaultDir = 'browsertime-results';
 let timestamp = dayjs().format().replace(/:/g, '');
 
 function pathNameFromUrl(url) {
-  const parsedUrl = urlParser.parse(url),
+  const parsedUrl = parse(url),
     pathSegments = parsedUrl.pathname.split('/');
 
   pathSegments.unshift(parsedUrl.hostname);
 
   if (!isEmpty(parsedUrl.search)) {
-    const md5 = crypto.createHash('md5'),
-      hash = md5.update(parsedUrl.search).digest('hex').substring(0, 8);
+    const md5 = createHash('md5'),
+      hash = md5.update(parsedUrl.search).digest('hex').slice(0, 8);
     pathSegments.push('query-' + hash);
   }
 
@@ -45,11 +51,9 @@ async function streamToString(stream) {
 
 class StorageManager {
   constructor(url, { resultDir, prettyPrint = false } = {}) {
-    if (resultDir) {
-      this.baseDir = path.resolve(resultDir);
-    } else {
-      this.baseDir = path.resolve(defaultDir, pathNameFromUrl(url), timestamp);
-    }
+    this.baseDir = resultDir
+      ? _resolve(resultDir)
+      : _resolve(defaultDir, pathNameFromUrl(url), timestamp);
     this.jsonIndentation = prettyPrint ? 2 : 0;
   }
 
@@ -59,23 +63,21 @@ class StorageManager {
   }
 
   async createSubDataDir(...name) {
-    const dir = path.join(this.baseDir, ...name);
+    const dir = join(this.baseDir, ...name);
     await mkdir(dir, { recursive: true });
     return dir;
   }
 
   async rm(filename) {
-    return unlink(path.join(this.baseDir, filename));
+    return unlink(join(this.baseDir, filename));
   }
 
   async writeData(filename, data, subdir) {
     let dirPath;
-    if (subdir) {
-      dirPath = await this.createSubDataDir(subdir);
-    } else {
-      dirPath = await this.createDataDir();
-    }
-    const fullPath = path.join(dirPath, filename);
+    dirPath = await (subdir
+      ? this.createSubDataDir(subdir)
+      : this.createDataDir());
+    const fullPath = join(dirPath, filename);
     return writeFile(fullPath, data).then(() => {
       return fullPath;
     });
@@ -86,21 +88,19 @@ class StorageManager {
       const data = await gzip(Buffer.from(JSON.stringify(json)), { level: 1 });
       return this.writeData(`${filename}.gz`, data);
     } else {
-      const data = JSON.stringify(json, null, this.jsonIndentation);
+      const data = JSON.stringify(json, undefined, this.jsonIndentation);
       return this.writeData(filename, data);
     }
   }
 
   async readData(filename, subdir) {
     let filepath;
-    if (subdir) {
-      filepath = path.join(this.baseDir, subdir, filename);
-    } else {
-      filepath = path.join(this.baseDir, filename);
-    }
+    filepath = subdir
+      ? join(this.baseDir, subdir, filename)
+      : join(this.baseDir, filename);
 
     if (filename.endsWith('.gz')) {
-      const readStream = fs.createReadStream(filepath);
+      const readStream = createReadStream(filepath);
       const text = await streamToString(readStream);
       const unzipped = await gunzip(text);
       return unzipped.toString();
@@ -111,9 +111,9 @@ class StorageManager {
 
   async gzip(inputFile, outputFile, removeInput) {
     const promise = new Promise(function (resolve, reject) {
-      const gzip = zlib.createGzip();
-      const input = fs.createReadStream(inputFile);
-      const out = fs.createWriteStream(outputFile);
+      const gzip = createGzip();
+      const input = createReadStream(inputFile);
+      const out = createWriteStream(outputFile);
       out.on('finish', function () {
         if (removeInput) {
           unlink(inputFile).then(() => resolve());
@@ -135,4 +135,4 @@ class StorageManager {
   }
 }
 
-module.exports = StorageManager;
+export default StorageManager;

package/lib/support/tcpdump.js

@@ -1,41 +1,47 @@
-'use strict';
-const execa = require('execa');
-const path = require('path');
-const pathToFolder = require('./pathToFolder');
-const fileUtil = require('./fileUtil');
+import { join } from 'node:path';
+import { execa } from 'execa';
+import pathToFolder from './pathToFolder.js';
+import { rename } from './fileUtil.js';
 
-class TCPDump {
+export default class TCPDump {
   constructor(directory, options) {
     this.baseDir = directory;
     this.options = options;
   }
   async start(iteration) {
-    const captureFile = path.join(this.baseDir, iteration + '.pcap');
-    const params = ['tcpdump', '-i', 'any', '-s', '0', '-p', '-w', captureFile];
+    const captureFile = join(this.baseDir, iteration + '.pcap');
+    const parameters = [
+      'tcpdump',
+      '-i',
+      'any',
+      '-s',
+      '0',
+      '-p',
+      '-w',
+      captureFile
+    ];
     if (this.options.tcpdumpPacketBuffered) {
-      params.push('-U');
+      parameters.push('-U');
     }
     if (this.options.tcpDumpParams) {
       const extras = Array.isArray(this.options.tcpDumpParams)
         ? this.options.tcpDumpParams
         : [this.options.tcpDumpParams];
-      params.push(...extras);
+      parameters.push(...extras);
     }
-    this.tcpdumpProcess = execa('sudo', params);
+    this.tcpdumpProcess = execa('sudo', parameters);
   }
   async stop() {
     return execa('sudo', ['pkill', '-9', 'tcpdump'], { reject: false });
   }
 
   async mv(url, iteration) {
-    const oldLocation = path.join(this.baseDir, iteration + '.pcap');
-    const newLocation = path.join(
+    const oldLocation = join(this.baseDir, iteration + '.pcap');
+    const newLocation = join(
       this.baseDir,
       pathToFolder(url, this.options),
       iteration + '.pcap'
     );
-    return fileUtil.rename(oldLocation, newLocation);
+    return rename(oldLocation, newLocation);
   }
 }
-
-module.exports = TCPDump;

package/lib/support/userTiming.js

@@ -1,13 +1,7 @@
-'use strict';
-
-module.exports = {
-  filterWhitelisted(userTimings, whitelistRegex) {
-    const allowed = new RegExp(whitelistRegex);
-    userTimings.marks = userTimings.marks.filter(mark =>
-      allowed.test(mark.name)
-    );
-    userTimings.measures = userTimings.measures.filter(measure =>
-      allowed.test(measure.name)
-    );
-  }
-};
+export function filterWhitelisted(userTimings, whitelistRegex) {
+  const allowed = new RegExp(whitelistRegex);
+  userTimings.marks = userTimings.marks.filter(mark => allowed.test(mark.name));
+  userTimings.measures = userTimings.measures.filter(measure =>
+    allowed.test(measure.name)
+  );
+}