@jsenv/test 3.0.9 → 3.0.11

package/dist/jsenv_test.js

@@ -1,10 +1,10 @@
-import os, { cpus, totalmem, freemem, availableParallelism } from "node:os";
+import os, { cpus, release, totalmem, availableParallelism, freemem } from "node:os";
+import process$1, { cpuUsage, memoryUsage } from "node:process";
 import { readdir, chmod, stat, lstat, promises, readFile as readFile$1, writeFileSync as writeFileSync$1, mkdirSync, unlink, openSync, closeSync, rmdir, chmodSync, statSync, lstatSync, unlinkSync, readdirSync, rmdirSync, readFileSync, existsSync } from "node:fs";
 import { takeCoverage } from "node:v8";
 import stripAnsi from "strip-ansi";
 import { URL_META, createException } from "./js/exception.js";
 import stringWidth from "string-width";
-import process$1, { memoryUsage } from "node:process";
 import tty from "node:tty";
 import { pathToFileURL, fileURLToPath } from "node:url";
 import { dirname } from "node:path";
@@ -1456,7 +1456,7 @@ const humanizeFileSize = (numberOfBytes, { decimals, short } = {}) => {
   return inspectBytes(numberOfBytes, { decimals, short });
 };
 
-const humanizeMemoryUsage = (metricValue, { decimals, short } = {}) => {
+const humanizeMemory = (metricValue, { decimals, short } = {}) => {
   return inspectBytes(metricValue, { decimals, fixedDecimals: true, short });
 };
 
@@ -3292,9 +3292,10 @@ process.platform === "linux";
 // https://gist.github.com/GaetanoPiazzolla/c40e1ebb9f709d091208e89baf9f4e00
 
 
-const startMeasuringCpuUsage = () => {
+const startMeasuringTotalCpuUsage = () => {
   let previousCpuArray = cpus();
   let previousMs = Date.now();
+  let previousCpuUsage = cpuUsage();
 
   const overall = {
     inactive: 100,
@@ -3302,6 +3303,12 @@ const startMeasuringCpuUsage = () => {
     system: 0,
     user: 0,
   };
+
+  const thisProcess = {
+    active: 0,
+    system: 0,
+    user: 0,
+  };
   const details = previousCpuArray.map(() => {
     return {
       inactive: 100,
@@ -3358,6 +3365,19 @@ const startMeasuringCpuUsage = () => {
       overallUsageSample,
     });
 
+    const processCpuUsage = cpuUsage();
+    const thisProcessSystemMs = Math.round(
+      (processCpuUsage.system - previousCpuUsage.system) / 1000,
+    );
+    const thisProcessUserMs = Math.round(
+      (processCpuUsage.user - previousCpuUsage.user) / 1000,
+    );
+    previousCpuUsage = processCpuUsage;
+    const thisProcessActiveMs = thisProcessSystemMs + thisProcessUserMs;
+    thisProcess.active = thisProcessActiveMs / overallMsEllapsed;
+    thisProcess.system = thisProcessSystemMs / overallMsEllapsed;
+    thisProcess.user = thisProcessUserMs / overallMsEllapsed;
+
     if (samples.length === 10) {
       let index = 0;
       for (const detail of details) {
@@ -3407,6 +3427,7 @@ const startMeasuringCpuUsage = () => {
 
   return {
     overall,
+    thisProcess,
     details,
     stop: () => {
       clearInterval(interval);
@@ -4946,7 +4967,9 @@ const replaceUrls = (source, replace) => {
 const reporterList = ({
   animated = true,
   mockFluctuatingValues, // used for snapshot testing logs
-  showMemoryUsage = true,
+  platformInfo,
+  memoryUsage: memoryUsage$1,
+  cpuUsage,
   spy = () => {
     return {
       write: (log) => {
@@ -4967,7 +4990,9 @@ const reporterList = ({
     process.exitCode !== 1;
 
   const logOptions = {
-    showMemoryUsage,
+    platformInfo,
+    memoryUsage: memoryUsage$1,
+    cpuUsage,
     mockFluctuatingValues,
     group: false,
     intermediateSummary: !animatedLogEnabled,
@@ -5028,7 +5053,7 @@ const reporterList = ({
           });
           infos.push(ANSI.color(duration, ANSI.GREY));
           const memoryHeapUsed = memoryUsage().heapUsed;
-          const memoryHeapUsedFormatted = humanizeMemoryUsage(memoryHeapUsed, {
+          const memoryHeapUsedFormatted = humanizeMemory(memoryHeapUsed, {
             short: true,
             decimals: 0,
           });
@@ -5079,8 +5104,10 @@ const reporterList = ({
     reporters.push(
       reporterList({
         animated: false,
+        platformInfo,
+        memoryUsage: memoryUsage$1,
+        cpuUsage,
         mockFluctuatingValues, // used for snapshot testing logs
-        showMemoryUsage,
         spy: () => {
           let rawOutput = "";
 
@@ -5100,58 +5127,59 @@ const reporterList = ({
 };
 
 const renderIntro = (testPlanResult, logOptions) => {
-  const { counters } = testPlanResult;
-  const planified = counters.planified;
-  const { groups } = testPlanResult;
-  const groupNames = Object.keys(groups);
-
-  if (planified === 0) {
-    return `${renderBigSection({
-      title: "nothing to execute",
-      content: "",
-    })}\n\n`;
-  }
-  if (planified === 1) {
-    const groupName = groupNames[0];
-    const groupInfo = groups[groupName];
-    return `${renderBigSection({
-      title: "1 execution to run",
-      content: `${groupName} (${getGroupRenderedName(groupInfo, logOptions)})`,
-    })}\n\n`;
-  }
-  if (groupNames.length === 1) {
-    const groupName = groupNames[0];
-    const groupInfo = groups[groupName];
-    return `${renderBigSection({
-      title: `${planified} executions to run`,
-      content: `${groupName} (${getGroupRenderedName(groupInfo, logOptions)})`,
-    })}\n\n`;
-  }
-
-  let introLines = [];
-  for (const groupName of groupNames) {
-    const groupInfo = groups[groupName];
-    introLines.push(
-      `${groupInfo.count} with ${groupName} (${getGroupRenderedName(
-        groupInfo,
-        logOptions,
-      )})`,
-    );
+  const lines = [];
+  if (logOptions.platformInfo) {
+    {
+      let osLine = `os: `;
+      if (logOptions.mockFluctuatingValues) {
+        osLine += `os@<mock>`;
+      } else {
+        osLine += `${testPlanResult.os.name}@${testPlanResult.os.version}`;
+      }
+      osLine += renderDetails({
+        cpu: logOptions.mockFluctuatingValues
+          ? "<mock>"
+          : testPlanResult.os.availableCpu,
+        memory: logOptions.mockFluctuatingValues
+          ? "<mock>GB"
+          : humanizeMemory(testPlanResult.os.availableMemory, {
+              short: true,
+              decimals: 0,
+            }),
+      });
+      lines.push(osLine);
+    }
+    {
+      const process = logOptions.mockFluctuatingValues
+        ? `node@mock`
+        : `${testPlanResult.process.name}@${testPlanResult.process.version}`;
+      let processLine = `process: ${process}`;
+      lines.push(processLine);
+    }
+  }
+
+  const directory = logOptions.mockFluctuatingValues
+    ? "/mock/"
+    : urlToFileSystemPath(testPlanResult.rootDirectoryUrl);
+  const numberOfFiles = Object.keys(testPlanResult.results).length;
+  let fileFoundLine = "";
+  if (numberOfFiles === 0) {
+    fileFoundLine += `no file matching "testPlan" in ${directory}:
+${testPlanResult.patterns.join("\n")}`;
+  } else if (numberOfFiles === 1) {
+    fileFoundLine += `1 file matching "testPlan" in ${directory}`;
+  } else {
+    fileFoundLine += `${numberOfFiles} files matching "testPlan" in ${directory}`;
   }
+
+  lines.push(fileFoundLine);
+
   return `${renderBigSection({
-    title: `${planified} executions to run`,
-    content: introLines.join("\n"),
+    title: "execution start",
+    content: lines.join("\n"),
   })}\n\n`;
 };
 
-const getGroupRenderedName = (groupInfo, logOptions) => {
-  let { runtimeName, runtimeVersion } = groupInfo;
-  if (logOptions.mockFluctuatingValues && groupInfo.runtimeType === "node") {
-    runtimeVersion = "<mock>";
-  }
-  return `${runtimeName}@${runtimeVersion}`;
-};
-
 const renderExecutionLog = (execution, logOptions) => {
   let log = "";
   // label
@@ -5206,10 +5234,10 @@ const renderExecutionLabel = (execution, logOptions) => {
         : humanizeDuration(duration, { short: true });
       infos.push(ANSI.color(durationFormatted, ANSI.GREY));
     }
-    if (logOptions.showMemoryUsage && typeof memoryUsage === "number") {
+    if (logOptions.memoryUsage && typeof memoryUsage === "number") {
       const memoryUsageFormatted = logOptions.mockFluctuatingValues
         ? `<mock>MB`
-        : humanizeMemoryUsage(memoryUsage, { short: true });
+        : humanizeMemory(memoryUsage, { short: true });
       infos.push(ANSI.color(memoryUsageFormatted, ANSI.GREY));
     }
     if (infos.length) {
@@ -5471,55 +5499,88 @@ const renderErrors = (execution, logOptions) => {
 };
 
 const renderOutro = (testPlanResult, logOptions = {}) => {
-  let finalSummary = "";
+  const lines = [];
   const { counters } = testPlanResult;
   const { planified } = counters;
 
-  if (planified === 1) {
-    finalSummary += `1 execution: `;
+  let executionLine = "";
+  if (planified === 0) {
+    executionLine += `no execution`;
+  } else if (planified === 1) {
+    executionLine += `1 execution: `;
   } else {
-    finalSummary += `${planified} executions: `;
+    executionLine += `${planified} executions: `;
   }
-  finalSummary += renderStatusRepartition(counters);
+  executionLine += renderStatusRepartition(counters);
+  lines.push(executionLine);
 
-  let durationLog = ``;
+  let durationLine = `duration: `;
   const { timings } = testPlanResult;
   if (logOptions.mockFluctuatingValues) {
-    durationLog += "<mock>s";
+    durationLine += "<mock>s";
   } else {
-    durationLog += humanizeDuration(timings.end, { short: true });
+    durationLine += humanizeDuration(timings.end, { short: true });
     const namedTimings = {
-      setup: timings.executionStart,
-      execution: timings.executionEnd,
-      teardown: timings.teardownEnd - timings.executionEnd,
+      setup: humanizeTiming(timings.executionStart),
+      execution: humanizeTiming(timings.executionEnd),
+      teardown: humanizeTiming(timings.teardownEnd - timings.executionEnd),
       ...(testPlanResult.coverage
-        ? { coverage: timings.coverageTeardownEnd - timings.teardownEnd }
+        ? {
+            coverage: humanizeTiming(
+              timings.coverageTeardownEnd - timings.teardownEnd,
+            ),
+          }
         : {}),
     };
-    const timingDetails = [];
-    for (const key of Object.keys(namedTimings)) {
-      const value = namedTimings[key];
-      const timingDuration = humanizeDuration(value, { short: true });
-      const timingString = `${ANSI.color(`${key}:`, ANSI.GREY)} ${ANSI.color(
-        timingDuration,
-        ANSI.GREY,
-      )}`;
-      timingDetails.push(ANSI.color(timingString, ANSI.GREY));
-    }
-    if (timingDetails.length) {
-      durationLog += ` ${ANSI.color("(", ANSI.GREY)}${timingDetails.join(
-        ANSI.color(", ", ANSI.GREY),
-      )}${ANSI.color(")", ANSI.GREY)}`;
-    }
+    durationLine += renderDetails(namedTimings);
+  }
+  lines.push(durationLine);
+
+  if (logOptions.cpuUsage) {
+    const processCpuUsage = testPlanResult.cpuUsage.process;
+    let cpuUsageLine = "cpu: ";
+    cpuUsageLine += `${humanizeProcessCpuUsage(processCpuUsage.end)}`;
+    cpuUsageLine += renderDetails({
+      med: humanizeProcessCpuUsage(processCpuUsage.median),
+      min: humanizeProcessCpuUsage(processCpuUsage.min),
+      max: humanizeProcessCpuUsage(processCpuUsage.max),
+    });
+    lines.push(cpuUsageLine);
+  }
+  if (logOptions.memoryUsage) {
+    const processMemoryUsage = testPlanResult.memoryUsage.process;
+    let memoryUsageLine = "memory: ";
+    memoryUsageLine += `${humanizeProcessMemoryUsage(processMemoryUsage.end)}`;
+    debugger;
+    memoryUsageLine += renderDetails({
+      med: humanizeProcessMemoryUsage(processMemoryUsage.median),
+      min: humanizeProcessMemoryUsage(processMemoryUsage.min),
+      max: humanizeProcessMemoryUsage(processMemoryUsage.max),
+    });
+    lines.push(memoryUsageLine);
   }
-  finalSummary += `\nduration: ${durationLog}`;
 
-  return `\n${renderBigSection({ title: "summary", content: finalSummary })}\n`;
+  return `\n${renderBigSection({ title: "summary", content: lines.join("\n") })}\n`;
+};
+
+const humanizeTiming = (value) => {
+  return humanizeDuration(value, { short: true });
+};
+
+const humanizeProcessCpuUsage = (ratio) => {
+  const percentageAsNumber = ratio * 100;
+  const percentageAsNumberRounded = Math.round(percentageAsNumber);
+  const percentage = `${percentageAsNumberRounded}%`;
+  return percentage;
+};
+
+const humanizeProcessMemoryUsage = (value) => {
+  return humanizeMemory(value, { short: true, decimals: 0 });
 };
 
 const renderStatusRepartition = (counters, { showProgression } = {}) => {
   if (counters.planified === 0) {
-    return `nothing to run`;
+    return ``;
   }
   if (counters.aborted === counters.planified) {
     return `all ${ANSI.color(`aborted`, COLOR_ABORTED)}`;
@@ -5606,6 +5667,29 @@ const renderSection = ({
   return section;
 };
 
+const renderDetails = (data) => {
+  const details = [];
+  for (const key of Object.keys(data)) {
+    const value = data[key];
+    let valueString = "";
+    valueString += ANSI.color(`${key}:`, ANSI.GREY);
+    const useNonGreyAnsiColor =
+      typeof value === "string" && value.includes("\x1b");
+    valueString += " ";
+    valueString += useNonGreyAnsiColor ? value : ANSI.color(value, ANSI.GREY);
+    details.push(valueString);
+  }
+  if (details.length === 0) {
+    return "";
+  }
+
+  let string = "";
+  string += ` ${ANSI.color("(", ANSI.GREY)}`;
+  string += details.join(ANSI.color(", ", ANSI.GREY));
+  string += ANSI.color(")", ANSI.GREY);
+  return string;
+};
+
 /*
  *
  */
@@ -5627,6 +5711,9 @@ const logsDefault = {
   level: "info",
   type: "list",
   animated: true,
+  platformInfo: false,
+  memoryUsage: false,
+  cpuUsage: false,
   fileUrl: undefined,
 };
 const githubCheckDefault = {
@@ -5671,8 +5758,8 @@ const coverageDefault = {
 };
 const parallelDefault = {
   max: "80%", // percentage resolved against the available cpus
-  maxCpu: "100%",
-  maxMemory: "100%",
+  maxCpu: "80%",
+  maxMemory: "50%",
 };
 
 const executeTestPlan = async ({
@@ -5723,12 +5810,63 @@ const executeTestPlan = async ({
     });
   }
 
-  const timingOrigin = Date.now();
+  const cpuUsage = startMeasuringTotalCpuUsage();
+  operation.addEndCallback(cpuUsage.stop);
+  const processCpuUsageMonitoring = startMonitoringMetric(() => {
+    return cpuUsage.thisProcess.active;
+  });
+  const osCpuUsageMonitoring = startMonitoringMetric(() => {
+    return cpuUsage.overall.active;
+  });
+  const processMemoryUsageMonitoring = startMonitoringMetric(() => {
+    return memoryUsage().rss;
+  });
+  const osMemoryUsageMonitoring = startMonitoringMetric(() => {
+    const total = totalmem();
+    const free = freemem();
+    return total - free;
+  });
+
+  const timingsOrigin = Date.now();
   const takeTiming = () => {
-    return Date.now() - timingOrigin;
+    return Date.now() - timingsOrigin;
   };
   const testPlanResult = {
+    os: {
+      name:
+        process.platform === "darwin"
+          ? "mac"
+          : process.platform === "win32" || process.platform === "win64"
+            ? "windows"
+            : process.platform === "linux"
+              ? "linux"
+              : "other",
+      version: release(),
+      availableCpu: countAvailableCpus(),
+      availableMemory: totalmem(),
+    },
+    process: {
+      name: "node",
+      version: process.version.slice(1),
+    },
+    memoryUsage: {
+      os: osMemoryUsageMonitoring.info,
+      process: processMemoryUsageMonitoring.info,
+    },
+    cpuUsage: {
+      os: osCpuUsageMonitoring.info,
+      process: processCpuUsageMonitoring.info,
+    },
+    timings: {
+      origin: timingsOrigin,
+      executionStart: null,
+      executionEnd: null,
+      teardownEnd: null,
+      coverageTeardownEnd: null,
+      end: null,
+    },
     rootDirectoryUrl: String(rootDirectoryUrl),
+    patterns: Object.keys(testPlan),
     groups: {},
     counters: {
       planified: 0,
@@ -5745,14 +5883,6 @@ const executeTestPlan = async ({
     },
     aborted: false,
     failed: false,
-    timings: {
-      origin: timingOrigin,
-      executionStart: null,
-      executionEnd: null,
-      teardownEnd: null,
-      coverageTeardownEnd: null,
-      end: null,
-    },
     coverage: null,
     results: {},
   };
@@ -5780,9 +5910,6 @@ const executeTestPlan = async ({
   let finalizeCoverage;
 
   try {
-    const cpuUsage = startMeasuringCpuUsage();
-    operation.addEndCallback(cpuUsage.stop);
-
     let logger;
     const runtimeInfo = {
       someNeedsServer: false,
@@ -5813,6 +5940,10 @@ const executeTestPlan = async ({
 
         if (logs.type === "list" && logger.levels.info) {
           const listReporterOptions = {
+            mockFluctuatingValues: logs.mockFluctuatingValues,
+            platformInfo: logs.platformInfo,
+            memoryUsage: logs.memoryUsage,
+            cpuUsage: logs.cpuUsage,
             animated: logger.levels.debug ? false : logs.animated,
             fileUrl:
               logs.fileUrl === undefined
@@ -5871,8 +6002,8 @@ const executeTestPlan = async ({
         const max = parallel.max;
         if (typeof max === "string") {
           const maxAsRatio = assertPercentageAndConvertToRatio(max);
-          const availableCpus = countAvailableCpus();
-          parallel.max = Math.round(maxAsRatio * availableCpus) || 1;
+          parallel.max =
+            Math.round(maxAsRatio * testPlanResult.os.availableCpu) || 1;
         } else if (typeof max === "number") {
           if (max < 1) {
             parallel.max = 1;
@@ -5886,8 +6017,9 @@ const executeTestPlan = async ({
         const maxMemory = parallel.maxMemory;
         if (typeof maxMemory === "string") {
           const maxMemoryAsRatio = assertPercentageAndConvertToRatio(maxMemory);
-          const totalMemory = totalmem();
-          parallel.maxMemory = Math.round(maxMemoryAsRatio * totalMemory);
+          parallel.maxMemory = Math.round(
+            maxMemoryAsRatio * testPlanResult.os.availableMemory,
+          );
         } else if (typeof maxMemory !== "number") {
           throw new TypeError(
             `parallel.maxMemory must be a number or a percentage, got ${maxMemory}`,
@@ -6425,18 +6557,22 @@ To fix this warning:
             // if nothing is executing these limitations don't apply
             executionExecutingSet.size > 0
           ) {
-            const freeMemory = freemem();
-            const totalMemory = totalmem();
-            const usedMemory = totalMemory - freeMemory;
-            if (usedMemory > parallel.maxMemory) {
+            if (processMemoryUsageMonitoring.measure() > parallel.maxMemory) {
               // retry after Xms in case memory usage decreases
-              const promise = operation.wait(200);
+              const promise = (async () => {
+                await operation.wait(200);
+                await startAsMuchAsPossible();
+              })();
               promises.push(promise);
               break;
             }
-            if (cpuUsage.overall.active > parallel.maxCpu) {
+
+            if (processCpuUsageMonitoring.measure() > parallel.maxCpu) {
               // retry after Xms in case cpu usage decreases
-              const promise = operation.wait(200);
+              const promise = (async () => {
+                await operation.wait(200);
+                await startAsMuchAsPossible();
+              })();
               promises.push(promise);
               break;
             }
@@ -6460,7 +6596,6 @@ To fix this warning:
         if (promises.length) {
           await Promise.all(promises);
           promises.length = 0;
-          await startAsMuchAsPossible();
         }
       };
 
@@ -6539,6 +6674,11 @@ To fix this warning:
     timings.coverageTeardownEnd = takeTiming();
     timings.end = takeTiming();
 
+    osMemoryUsageMonitoring.end();
+    processMemoryUsageMonitoring.end();
+    osCpuUsageMonitoring.end();
+    processCpuUsageMonitoring.end();
+
     afterEachCallbackSet.clear();
     afterEachInOrderCallbackSet.clear();
     for (const afterAllCallback of afterAllCallbackSet) {
@@ -6551,6 +6691,51 @@ To fix this warning:
   return testPlanResult;
 };
 
+const startMonitoringMetric = (measure) => {
+  const metrics = [];
+  const takeMeasure = () => {
+    const value = measure();
+    metrics.push(value);
+    return value;
+  };
+
+  const info = {
+    start: takeMeasure(),
+    min: null,
+    max: null,
+    median: null,
+    end: null,
+  };
+  return {
+    info,
+    measure: takeMeasure,
+    end: () => {
+      info.end = takeMeasure();
+      metrics.sort((a, b) => a - b);
+      info.min = metrics[0];
+      info.max = metrics[metrics.length - 1];
+      info.median = medianFromSortedArray(metrics);
+      metrics.length = 0;
+    },
+  };
+};
+
+const medianFromSortedArray = (array) => {
+  const length = array.length;
+  const isOdd = length % 2 === 1;
+  if (isOdd) {
+    const medianNumberIndex = (length - 1) / 2;
+    const medianNumber = array[medianNumberIndex];
+    return medianNumber;
+  }
+  const rightMiddleNumberIndex = length / 2;
+  const leftMiddleNumberIndex = rightMiddleNumberIndex - 1;
+  const leftMiddleNumber = array[leftMiddleNumberIndex];
+  const rightMiddleNumber = array[rightMiddleNumberIndex];
+  const medianNumber = (leftMiddleNumber + rightMiddleNumber) / 2;
+  return medianNumber;
+};
+
 const countAvailableCpus = () => {
   if (typeof availableParallelism === "function") {
     return availableParallelism();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/test",
-  "version": "3.0.9",
+  "version": "3.0.11",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/execution/execute_test_plan.js

@@ -2,7 +2,14 @@
  *
  */
 
-import { cpus, availableParallelism, freemem, totalmem } from "node:os";
+import {
+  release,
+  cpus,
+  availableParallelism,
+  totalmem,
+  freemem,
+} from "node:os";
+import { memoryUsage } from "node:process";
 import { existsSync } from "node:fs";
 import { takeCoverage } from "node:v8";
 import stripAnsi from "strip-ansi";
@@ -19,7 +26,7 @@ import {
   readGitHubWorkflowEnv,
 } from "@jsenv/github-check-run";
 
-import { startMeasuringCpuUsage } from "../helpers/cpu_usage.js";
+import { startMeasuringTotalCpuUsage } from "../helpers/cpu_usage.js";
 import { createCallOrderer } from "../helpers/call_orderer.js";
 import { generateCoverage } from "../coverage/generate_coverage.js";
 import { assertAndNormalizeWebServer } from "./web_server_param.js";
@@ -43,6 +50,9 @@ const logsDefault = {
   level: "info",
   type: "list",
   animated: true,
+  platformInfo: false,
+  memoryUsage: false,
+  cpuUsage: false,
   fileUrl: undefined,
 };
 const githubCheckDefault = {
@@ -87,8 +97,8 @@ const coverageDefault = {
 };
 const parallelDefault = {
   max: "80%", // percentage resolved against the available cpus
-  maxCpu: "100%",
-  maxMemory: "100%",
+  maxCpu: "80%",
+  maxMemory: "50%",
 };
 
 export const executeTestPlan = async ({
@@ -139,12 +149,63 @@ export const executeTestPlan = async ({
     });
   }
 
-  const timingOrigin = Date.now();
+  const cpuUsage = startMeasuringTotalCpuUsage();
+  operation.addEndCallback(cpuUsage.stop);
+  const processCpuUsageMonitoring = startMonitoringMetric(() => {
+    return cpuUsage.thisProcess.active;
+  });
+  const osCpuUsageMonitoring = startMonitoringMetric(() => {
+    return cpuUsage.overall.active;
+  });
+  const processMemoryUsageMonitoring = startMonitoringMetric(() => {
+    return memoryUsage().rss;
+  });
+  const osMemoryUsageMonitoring = startMonitoringMetric(() => {
+    const total = totalmem();
+    const free = freemem();
+    return total - free;
+  });
+
+  const timingsOrigin = Date.now();
   const takeTiming = () => {
-    return Date.now() - timingOrigin;
+    return Date.now() - timingsOrigin;
   };
   const testPlanResult = {
+    os: {
+      name:
+        process.platform === "darwin"
+          ? "mac"
+          : process.platform === "win32" || process.platform === "win64"
+            ? "windows"
+            : process.platform === "linux"
+              ? "linux"
+              : "other",
+      version: release(),
+      availableCpu: countAvailableCpus(),
+      availableMemory: totalmem(),
+    },
+    process: {
+      name: "node",
+      version: process.version.slice(1),
+    },
+    memoryUsage: {
+      os: osMemoryUsageMonitoring.info,
+      process: processMemoryUsageMonitoring.info,
+    },
+    cpuUsage: {
+      os: osCpuUsageMonitoring.info,
+      process: processCpuUsageMonitoring.info,
+    },
+    timings: {
+      origin: timingsOrigin,
+      executionStart: null,
+      executionEnd: null,
+      teardownEnd: null,
+      coverageTeardownEnd: null,
+      end: null,
+    },
     rootDirectoryUrl: String(rootDirectoryUrl),
+    patterns: Object.keys(testPlan),
     groups: {},
     counters: {
       planified: 0,
@@ -161,14 +222,6 @@ export const executeTestPlan = async ({
     },
     aborted: false,
     failed: false,
-    timings: {
-      origin: timingOrigin,
-      executionStart: null,
-      executionEnd: null,
-      teardownEnd: null,
-      coverageTeardownEnd: null,
-      end: null,
-    },
     coverage: null,
     results: {},
   };
@@ -196,9 +249,6 @@ export const executeTestPlan = async ({
   let finalizeCoverage;
 
   try {
-    const cpuUsage = startMeasuringCpuUsage();
-    operation.addEndCallback(cpuUsage.stop);
-
     let logger;
     const runtimeInfo = {
       someNeedsServer: false,
@@ -229,6 +279,10 @@ export const executeTestPlan = async ({
 
         if (logs.type === "list" && logger.levels.info) {
           const listReporterOptions = {
+            mockFluctuatingValues: logs.mockFluctuatingValues,
+            platformInfo: logs.platformInfo,
+            memoryUsage: logs.memoryUsage,
+            cpuUsage: logs.cpuUsage,
             animated: logger.levels.debug ? false : logs.animated,
             fileUrl:
               logs.fileUrl === undefined
@@ -287,8 +341,8 @@ export const executeTestPlan = async ({
         const max = parallel.max;
         if (typeof max === "string") {
           const maxAsRatio = assertPercentageAndConvertToRatio(max);
-          const availableCpus = countAvailableCpus();
-          parallel.max = Math.round(maxAsRatio * availableCpus) || 1;
+          parallel.max =
+            Math.round(maxAsRatio * testPlanResult.os.availableCpu) || 1;
         } else if (typeof max === "number") {
           if (max < 1) {
             parallel.max = 1;
@@ -302,8 +356,9 @@ export const executeTestPlan = async ({
         const maxMemory = parallel.maxMemory;
         if (typeof maxMemory === "string") {
           const maxMemoryAsRatio = assertPercentageAndConvertToRatio(maxMemory);
-          const totalMemory = totalmem();
-          parallel.maxMemory = Math.round(maxMemoryAsRatio * totalMemory);
+          parallel.maxMemory = Math.round(
+            maxMemoryAsRatio * testPlanResult.os.availableMemory,
+          );
         } else if (typeof maxMemory !== "number") {
           throw new TypeError(
             `parallel.maxMemory must be a number or a percentage, got ${maxMemory}`,
@@ -841,18 +896,22 @@ To fix this warning:
             // if nothing is executing these limitations don't apply
             executionExecutingSet.size > 0
           ) {
-            const freeMemory = freemem();
-            const totalMemory = totalmem();
-            const usedMemory = totalMemory - freeMemory;
-            if (usedMemory > parallel.maxMemory) {
+            if (processMemoryUsageMonitoring.measure() > parallel.maxMemory) {
               // retry after Xms in case memory usage decreases
-              const promise = operation.wait(200);
+              const promise = (async () => {
+                await operation.wait(200);
+                await startAsMuchAsPossible();
+              })();
               promises.push(promise);
               break;
             }
-            if (cpuUsage.overall.active > parallel.maxCpu) {
+
+            if (processCpuUsageMonitoring.measure() > parallel.maxCpu) {
               // retry after Xms in case cpu usage decreases
-              const promise = operation.wait(200);
+              const promise = (async () => {
+                await operation.wait(200);
+                await startAsMuchAsPossible();
+              })();
               promises.push(promise);
               break;
             }
@@ -876,7 +935,6 @@ To fix this warning:
         if (promises.length) {
           await Promise.all(promises);
           promises.length = 0;
-          await startAsMuchAsPossible();
         }
       };
 
@@ -956,6 +1014,11 @@ To fix this warning:
     timings.coverageTeardownEnd = takeTiming();
     timings.end = takeTiming();
 
+    osMemoryUsageMonitoring.end();
+    processMemoryUsageMonitoring.end();
+    osCpuUsageMonitoring.end();
+    processCpuUsageMonitoring.end();
+
     afterEachCallbackSet.clear();
     afterEachInOrderCallbackSet.clear();
     for (const afterAllCallback of afterAllCallbackSet) {
@@ -968,6 +1031,51 @@ To fix this warning:
   return testPlanResult;
 };
 
+const startMonitoringMetric = (measure) => {
+  const metrics = [];
+  const takeMeasure = () => {
+    const value = measure();
+    metrics.push(value);
+    return value;
+  };
+
+  const info = {
+    start: takeMeasure(),
+    min: null,
+    max: null,
+    median: null,
+    end: null,
+  };
+  return {
+    info,
+    measure: takeMeasure,
+    end: () => {
+      info.end = takeMeasure();
+      metrics.sort((a, b) => a - b);
+      info.min = metrics[0];
+      info.max = metrics[metrics.length - 1];
+      info.median = medianFromSortedArray(metrics);
+      metrics.length = 0;
+    },
+  };
+};
+
+const medianFromSortedArray = (array) => {
+  const length = array.length;
+  const isOdd = length % 2 === 1;
+  if (isOdd) {
+    const medianNumberIndex = (length - 1) / 2;
+    const medianNumber = array[medianNumberIndex];
+    return medianNumber;
+  }
+  const rightMiddleNumberIndex = length / 2;
+  const leftMiddleNumberIndex = rightMiddleNumberIndex - 1;
+  const leftMiddleNumber = array[leftMiddleNumberIndex];
+  const rightMiddleNumber = array[rightMiddleNumberIndex];
+  const medianNumber = (leftMiddleNumber + rightMiddleNumber) / 2;
+  return medianNumber;
+};
+
 const countAvailableCpus = () => {
   if (typeof availableParallelism === "function") {
     return availableParallelism();

package/src/execution/reporters/reporter_list.js

@@ -1,13 +1,14 @@
-import { memoryUsage } from "node:process";
+import { memoryUsage as processMemoryUsage } from "node:process";
 import stripAnsi from "strip-ansi";
 import { writeFileSync } from "@jsenv/filesystem";
 import {
   createDynamicLog,
   humanizeDuration,
-  humanizeMemoryUsage,
+  humanizeMemory,
   ANSI,
   UNICODE,
 } from "@jsenv/humanize";
+import { urlToFileSystemPath } from "@jsenv/urls";
 
 import { formatErrorForTerminal } from "../format_error_for_terminal.js";
 
@@ -36,7 +37,9 @@ import { formatErrorForTerminal } from "../format_error_for_terminal.js";
 export const reporterList = ({
   animated = true,
   mockFluctuatingValues, // used for snapshot testing logs
-  showMemoryUsage = true,
+  platformInfo,
+  memoryUsage,
+  cpuUsage,
   spy = () => {
     return {
       write: (log) => {
@@ -57,7 +60,9 @@ export const reporterList = ({
     process.exitCode !== 1;
 
   const logOptions = {
-    showMemoryUsage,
+    platformInfo,
+    memoryUsage,
+    cpuUsage,
     mockFluctuatingValues,
     group: false,
     intermediateSummary: !animatedLogEnabled,
@@ -117,8 +122,8 @@ export const reporterList = ({
             rounded: false,
           });
           infos.push(ANSI.color(duration, ANSI.GREY));
-          const memoryHeapUsed = memoryUsage().heapUsed;
-          const memoryHeapUsedFormatted = humanizeMemoryUsage(memoryHeapUsed, {
+          const memoryHeapUsed = processMemoryUsage().heapUsed;
+          const memoryHeapUsedFormatted = humanizeMemory(memoryHeapUsed, {
             short: true,
             decimals: 0,
           });
@@ -169,8 +174,10 @@ export const reporterList = ({
     reporters.push(
       reporterList({
         animated: false,
+        platformInfo,
+        memoryUsage,
+        cpuUsage,
         mockFluctuatingValues, // used for snapshot testing logs
-        showMemoryUsage,
         spy: () => {
           let rawOutput = "";
 
@@ -190,58 +197,59 @@ export const reporterList = ({
 };
 
 const renderIntro = (testPlanResult, logOptions) => {
-  const { counters } = testPlanResult;
-  const planified = counters.planified;
-  const { groups } = testPlanResult;
-  const groupNames = Object.keys(groups);
+  const lines = [];
+  if (logOptions.platformInfo) {
+    os_line: {
+      let osLine = `os: `;
+      if (logOptions.mockFluctuatingValues) {
+        osLine += `os@<mock>`;
+      } else {
+        osLine += `${testPlanResult.os.name}@${testPlanResult.os.version}`;
+      }
+      osLine += renderDetails({
+        cpu: logOptions.mockFluctuatingValues
+          ? "<mock>"
+          : testPlanResult.os.availableCpu,
+        memory: logOptions.mockFluctuatingValues
+          ? "<mock>GB"
+          : humanizeMemory(testPlanResult.os.availableMemory, {
+              short: true,
+              decimals: 0,
+            }),
+      });
+      lines.push(osLine);
+    }
+    process_line: {
+      const process = logOptions.mockFluctuatingValues
+        ? `node@mock`
+        : `${testPlanResult.process.name}@${testPlanResult.process.version}`;
+      let processLine = `process: ${process}`;
+      lines.push(processLine);
+    }
+  }
 
-  if (planified === 0) {
-    return `${renderBigSection({
-      title: "nothing to execute",
-      content: "",
-    })}\n\n`;
-  }
-  if (planified === 1) {
-    const groupName = groupNames[0];
-    const groupInfo = groups[groupName];
-    return `${renderBigSection({
-      title: "1 execution to run",
-      content: `${groupName} (${getGroupRenderedName(groupInfo, logOptions)})`,
-    })}\n\n`;
-  }
-  if (groupNames.length === 1) {
-    const groupName = groupNames[0];
-    const groupInfo = groups[groupName];
-    return `${renderBigSection({
-      title: `${planified} executions to run`,
-      content: `${groupName} (${getGroupRenderedName(groupInfo, logOptions)})`,
-    })}\n\n`;
-  }
-
-  let introLines = [];
-  for (const groupName of groupNames) {
-    const groupInfo = groups[groupName];
-    introLines.push(
-      `${groupInfo.count} with ${groupName} (${getGroupRenderedName(
-        groupInfo,
-        logOptions,
-      )})`,
-    );
+  const directory = logOptions.mockFluctuatingValues
+    ? "/mock/"
+    : urlToFileSystemPath(testPlanResult.rootDirectoryUrl);
+  const numberOfFiles = Object.keys(testPlanResult.results).length;
+  let fileFoundLine = "";
+  if (numberOfFiles === 0) {
+    fileFoundLine += `no file matching "testPlan" in ${directory}:
+${testPlanResult.patterns.join("\n")}`;
+  } else if (numberOfFiles === 1) {
+    fileFoundLine += `1 file matching "testPlan" in ${directory}`;
+  } else {
+    fileFoundLine += `${numberOfFiles} files matching "testPlan" in ${directory}`;
   }
+
+  lines.push(fileFoundLine);
+
   return `${renderBigSection({
-    title: `${planified} executions to run`,
-    content: introLines.join("\n"),
+    title: "execution start",
+    content: lines.join("\n"),
   })}\n\n`;
 };
 
-const getGroupRenderedName = (groupInfo, logOptions) => {
-  let { runtimeName, runtimeVersion } = groupInfo;
-  if (logOptions.mockFluctuatingValues && groupInfo.runtimeType === "node") {
-    runtimeVersion = "<mock>";
-  }
-  return `${runtimeName}@${runtimeVersion}`;
-};
-
 const renderExecutionLog = (execution, logOptions) => {
   let log = "";
   // label
@@ -296,10 +304,10 @@ const renderExecutionLabel = (execution, logOptions) => {
         : humanizeDuration(duration, { short: true });
       infos.push(ANSI.color(durationFormatted, ANSI.GREY));
     }
-    if (logOptions.showMemoryUsage && typeof memoryUsage === "number") {
+    if (logOptions.memoryUsage && typeof memoryUsage === "number") {
       const memoryUsageFormatted = logOptions.mockFluctuatingValues
         ? `<mock>MB`
-        : humanizeMemoryUsage(memoryUsage, { short: true });
+        : humanizeMemory(memoryUsage, { short: true });
       infos.push(ANSI.color(memoryUsageFormatted, ANSI.GREY));
     }
     if (infos.length) {
@@ -561,55 +569,88 @@ const renderErrors = (execution, logOptions) => {
 };
 
 export const renderOutro = (testPlanResult, logOptions = {}) => {
-  let finalSummary = "";
+  const lines = [];
   const { counters } = testPlanResult;
   const { planified } = counters;
 
-  if (planified === 1) {
-    finalSummary += `1 execution: `;
+  let executionLine = "";
+  if (planified === 0) {
+    executionLine += `no execution`;
+  } else if (planified === 1) {
+    executionLine += `1 execution: `;
   } else {
-    finalSummary += `${planified} executions: `;
+    executionLine += `${planified} executions: `;
   }
-  finalSummary += renderStatusRepartition(counters);
+  executionLine += renderStatusRepartition(counters);
+  lines.push(executionLine);
 
-  let durationLog = ``;
+  let durationLine = `duration: `;
   const { timings } = testPlanResult;
   if (logOptions.mockFluctuatingValues) {
-    durationLog += "<mock>s";
+    durationLine += "<mock>s";
   } else {
-    durationLog += humanizeDuration(timings.end, { short: true });
+    durationLine += humanizeDuration(timings.end, { short: true });
     const namedTimings = {
-      setup: timings.executionStart,
-      execution: timings.executionEnd,
-      teardown: timings.teardownEnd - timings.executionEnd,
+      setup: humanizeTiming(timings.executionStart),
+      execution: humanizeTiming(timings.executionEnd),
+      teardown: humanizeTiming(timings.teardownEnd - timings.executionEnd),
       ...(testPlanResult.coverage
-        ? { coverage: timings.coverageTeardownEnd - timings.teardownEnd }
+        ? {
+            coverage: humanizeTiming(
+              timings.coverageTeardownEnd - timings.teardownEnd,
+            ),
+          }
         : {}),
     };
-    const timingDetails = [];
-    for (const key of Object.keys(namedTimings)) {
-      const value = namedTimings[key];
-      const timingDuration = humanizeDuration(value, { short: true });
-      const timingString = `${ANSI.color(`${key}:`, ANSI.GREY)} ${ANSI.color(
-        timingDuration,
-        ANSI.GREY,
-      )}`;
-      timingDetails.push(ANSI.color(timingString, ANSI.GREY));
-    }
-    if (timingDetails.length) {
-      durationLog += ` ${ANSI.color("(", ANSI.GREY)}${timingDetails.join(
-        ANSI.color(", ", ANSI.GREY),
-      )}${ANSI.color(")", ANSI.GREY)}`;
-    }
+    durationLine += renderDetails(namedTimings);
+  }
+  lines.push(durationLine);
+
+  if (logOptions.cpuUsage) {
+    const processCpuUsage = testPlanResult.cpuUsage.process;
+    let cpuUsageLine = "cpu: ";
+    cpuUsageLine += `${humanizeProcessCpuUsage(processCpuUsage.end)}`;
+    cpuUsageLine += renderDetails({
+      med: humanizeProcessCpuUsage(processCpuUsage.median),
+      min: humanizeProcessCpuUsage(processCpuUsage.min),
+      max: humanizeProcessCpuUsage(processCpuUsage.max),
+    });
+    lines.push(cpuUsageLine);
+  }
+  if (logOptions.memoryUsage) {
+    const processMemoryUsage = testPlanResult.memoryUsage.process;
+    let memoryUsageLine = "memory: ";
+    memoryUsageLine += `${humanizeProcessMemoryUsage(processMemoryUsage.end)}`;
+    debugger;
+    memoryUsageLine += renderDetails({
+      med: humanizeProcessMemoryUsage(processMemoryUsage.median),
+      min: humanizeProcessMemoryUsage(processMemoryUsage.min),
+      max: humanizeProcessMemoryUsage(processMemoryUsage.max),
+    });
+    lines.push(memoryUsageLine);
   }
-  finalSummary += `\nduration: ${durationLog}`;
 
-  return `\n${renderBigSection({ title: "summary", content: finalSummary })}\n`;
+  return `\n${renderBigSection({ title: "summary", content: lines.join("\n") })}\n`;
+};
+
+const humanizeTiming = (value) => {
+  return humanizeDuration(value, { short: true });
+};
+
+const humanizeProcessCpuUsage = (ratio) => {
+  const percentageAsNumber = ratio * 100;
+  const percentageAsNumberRounded = Math.round(percentageAsNumber);
+  const percentage = `${percentageAsNumberRounded}%`;
+  return percentage;
+};
+
+const humanizeProcessMemoryUsage = (value) => {
+  return humanizeMemory(value, { short: true, decimals: 0 });
 };
 
 const renderStatusRepartition = (counters, { showProgression } = {}) => {
   if (counters.planified === 0) {
-    return `nothing to run`;
+    return ``;
   }
   if (counters.aborted === counters.planified) {
     return `all ${ANSI.color(`aborted`, COLOR_ABORTED)}`;
@@ -695,3 +736,26 @@ const renderSection = ({
   section += bottomDashes;
   return section;
 };
+
+const renderDetails = (data) => {
+  const details = [];
+  for (const key of Object.keys(data)) {
+    const value = data[key];
+    let valueString = "";
+    valueString += ANSI.color(`${key}:`, ANSI.GREY);
+    const useNonGreyAnsiColor =
+      typeof value === "string" && value.includes("\x1b");
+    valueString += " ";
+    valueString += useNonGreyAnsiColor ? value : ANSI.color(value, ANSI.GREY);
+    details.push(valueString);
+  }
+  if (details.length === 0) {
+    return "";
+  }
+
+  let string = "";
+  string += ` ${ANSI.color("(", ANSI.GREY)}`;
+  string += details.join(ANSI.color(", ", ANSI.GREY));
+  string += ANSI.color(")", ANSI.GREY);
+  return string;
+};

package/src/helpers/cpu_usage.js

@@ -1,10 +1,12 @@
 // https://gist.github.com/GaetanoPiazzolla/c40e1ebb9f709d091208e89baf9f4e00
 
 import { cpus } from "node:os";
+import { cpuUsage } from "node:process";
 
-export const startMeasuringCpuUsage = () => {
+export const startMeasuringTotalCpuUsage = () => {
   let previousCpuArray = cpus();
   let previousMs = Date.now();
+  let previousCpuUsage = cpuUsage();
 
   const overall = {
     inactive: 100,
@@ -12,6 +14,12 @@ export const startMeasuringCpuUsage = () => {
     system: 0,
     user: 0,
   };
+
+  const thisProcess = {
+    active: 0,
+    system: 0,
+    user: 0,
+  };
   const details = previousCpuArray.map(() => {
     return {
       inactive: 100,
@@ -68,6 +76,19 @@ export const startMeasuringCpuUsage = () => {
       overallUsageSample,
     });
 
+    const processCpuUsage = cpuUsage();
+    const thisProcessSystemMs = Math.round(
+      (processCpuUsage.system - previousCpuUsage.system) / 1000,
+    );
+    const thisProcessUserMs = Math.round(
+      (processCpuUsage.user - previousCpuUsage.user) / 1000,
+    );
+    previousCpuUsage = processCpuUsage;
+    const thisProcessActiveMs = thisProcessSystemMs + thisProcessUserMs;
+    thisProcess.active = thisProcessActiveMs / overallMsEllapsed;
+    thisProcess.system = thisProcessSystemMs / overallMsEllapsed;
+    thisProcess.user = thisProcessUserMs / overallMsEllapsed;
+
     if (samples.length === 10) {
       let index = 0;
       for (const detail of details) {
@@ -117,6 +138,7 @@ export const startMeasuringCpuUsage = () => {
 
   return {
     overall,
+    thisProcess,
     details,
     stop: () => {
       clearInterval(interval);
@@ -140,3 +162,35 @@ export const ratioAsPercentage = (ratio) => {
   const percentage = `${percentageAsNumberRounded}%`;
   return percentage;
 };
+
+export const startMeasuringCpuUsage = () => {
+  let previousHrtime = process.hrtime();
+  let previousCpuUsage = process.cpuUsage();
+
+  const info = {
+    used: 0,
+  };
+
+  const interval = setInterval(() => {
+    const hrtime = process.hrtime(previousHrtime);
+    previousHrtime = hrtime;
+    const cpuUsage = process.cpuUsage(previousCpuUsage);
+    previousCpuUsage = cpuUsage;
+
+    const ellapsedMs = hrtime[0] * 1000 + hrtime[1] / 1000000;
+    const userMs = Math.round(cpuUsage.user / 1000);
+    const systemMs = Math.round(cpuUsage.system / 1000);
+    const activeMs = userMs + systemMs;
+    const usedRatio = activeMs / ellapsedMs;
+    const used = Math.round(usedRatio * 100) / 100;
+    info.used = used;
+  }, 15);
+  interval.unref();
+
+  return {
+    info,
+    stop: () => {
+      clearInterval(interval);
+    },
+  };
+};

package/src/helpers/cpu_usage.test_manual.js

@@ -1,7 +1,15 @@
-import { startMeasuringCpuUsage, formatUsage } from "./cpu_usage.js";
+import {
+  startMeasuringCpuUsage,
+  startMeasuringTotalCpuUsage,
+  formatUsage,
+} from "./cpu_usage.js";
 
 const cpuUsage = startMeasuringCpuUsage();
+setInterval(() => {
+  console.log(cpuUsage.info.used);
+}, 400);
 
+const totalCpuUsage = startMeasuringTotalCpuUsage();
 setInterval(() => {
-  console.log(formatUsage(cpuUsage.overall));
+  console.log(formatUsage(totalCpuUsage.overall));
 }, 400);