@jsenv/test 2.1.3 → 3.0.1

package/src/runtime_node/execute_using_dynamic_import.js

@@ -1,53 +1,100 @@
 import { writeFileSync } from "node:fs";
+import { memoryUsage } from "node:process";
 
 import { startJsCoverage } from "./profiler_v8_coverage.js";
 import { startObservingPerformances } from "./node_execution_performance.js";
+import { createException } from "../execution/exception.js";
 
 export const executeUsingDynamicImport = async ({
   rootDirectoryUrl,
   fileUrl,
+  measureMemoryUsage,
   collectPerformance,
   coverageEnabled,
-  coverageConfig,
+  coverageInclude,
   coverageMethodForNodeJs,
   coverageFileUrl,
 }) => {
-  const result = {};
-  const afterImportCallbacks = [];
+  const result = {
+    timings: {
+      start: null,
+      end: null,
+    },
+    errors: [],
+    namespace: null,
+    memoryUsage: null,
+    performance: null,
+  };
+
+  let finalizePerformance;
+  if (collectPerformance) {
+    const getPerformance = startObservingPerformances();
+    finalizePerformance = async () => {
+      const performance = await getPerformance();
+      result.performance = performance;
+    };
+  }
+
+  let finalizeCoverage;
   if (coverageEnabled && coverageMethodForNodeJs === "Profiler") {
-    const { filterV8Coverage } = await import("../coverage/v8_coverage.js");
     const { stopJsCoverage } = await startJsCoverage();
-    afterImportCallbacks.push(async () => {
-      const coverage = await stopJsCoverage();
+    finalizeCoverage = async () => {
+      const [coverage, { filterV8Coverage }] = await Promise.all([
+        stopJsCoverage(),
+        import("../coverage/v8_coverage.js"),
+      ]);
       const coverageLight = await filterV8Coverage(coverage, {
         rootDirectoryUrl,
-        coverageConfig,
+        coverageInclude,
       });
       writeFileSync(
         new URL(coverageFileUrl),
         JSON.stringify(coverageLight, null, "  "),
       );
-    });
+    };
   }
-  if (collectPerformance) {
-    const getPerformance = startObservingPerformances();
-    afterImportCallbacks.push(async () => {
-      const performance = await getPerformance();
-      result.performance = performance;
-    });
+
+  let finalizeMemoryUsage;
+  if (measureMemoryUsage) {
+    global.gc();
+    const memoryHeapUsedBeforeExecution = memoryUsage().heapUsed;
+    finalizeMemoryUsage = () => {
+      global.gc();
+      const memoryHeapUsedAfterExecution = memoryUsage().heapUsed;
+      result.memoryUsage =
+        memoryHeapUsedAfterExecution - memoryHeapUsedBeforeExecution;
+    };
+  }
+
+  result.timings.start = Date.now();
+  try {
+    const namespace = await import(fileUrl);
+    const namespaceResolved = {};
+    await Promise.all(
+      Object.keys(namespace).map(async (key) => {
+        const value = await namespace[key];
+        namespaceResolved[key] = value;
+      }),
+    );
+    result.status = "completed";
+    result.namespace = namespaceResolved;
+  } catch (e) {
+    result.status = "failed";
+    result.errors.push(createException(e, { rootDirectoryUrl }));
+  } finally {
+    result.timings.end = Date.now();
+    if (finalizeCoverage) {
+      await finalizeCoverage();
+      finalizeCoverage = null;
+    }
+    if (finalizePerformance) {
+      await finalizePerformance();
+      finalizePerformance = null;
+    }
+    if (finalizeMemoryUsage) {
+      finalizeMemoryUsage();
+      finalizeMemoryUsage = null;
+    }
+    return result;
   }
-  const namespace = await import(fileUrl);
-  const namespaceResolved = {};
-  await Promise.all(
-    Object.keys(namespace).map(async (key) => {
-      const value = await namespace[key];
-      namespaceResolved[key] = value;
-    }),
-  );
-  result.namespace = namespaceResolved;
-  await afterImportCallbacks.reduce(async (previous, afterImportCallback) => {
-    await previous;
-    await afterImportCallback();
-  }, Promise.resolve());
-  return result;
 };

package/src/runtime_node/node_child_process.js

@@ -1,10 +1,6 @@
 import { fork } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import {
-  Abort,
-  raceCallbacks,
-  createCallbackListNotifiedOnce,
-} from "@jsenv/abort";
+import { Abort, raceCallbacks } from "@jsenv/abort";
 import { createDetailedMessage } from "@jsenv/log";
 import { memoize } from "@jsenv/utils/src/memoize/memoize.js";
 
@@ -56,12 +52,17 @@ export const nodeChildProcess = ({
       keepRunning,
       stopSignal,
       onConsole,
+      onRuntimeStarted,
+      onRuntimeStopped,
 
+      measureMemoryUsage,
+      onMeasureMemoryAvailable,
+      collectConsole = false,
+      collectPerformance,
       coverageEnabled = false,
-      coverageConfig,
+      coverageInclude,
       coverageMethodForNodeJs,
       coverageFileUrl,
-      collectPerformance,
     }) => {
       if (coverageMethodForNodeJs !== "NODE_V8_COVERAGE") {
         env.NODE_V8_COVERAGE = "";
@@ -70,7 +71,14 @@ export const nodeChildProcess = ({
         "--experimental-import-meta-resolve",
         ...commandLineOptions,
       ];
-
+      if (onMeasureMemoryAvailable) {
+        env.MEASURE_MEMORY_AT_START = "1";
+      }
+      if (measureMemoryUsage || onMeasureMemoryAvailable) {
+        if (!commandLineOptions.includes("--expose-gc")) {
+          commandLineOptions.push("--expose-gc");
+        }
+      }
       if (importMap) {
         env.IMPORT_MAP = JSON.stringify(importMap);
         env.IMPORT_MAP_BASE_URL = rootDirectoryUrl;
@@ -82,9 +90,14 @@ export const nodeChildProcess = ({
         );
       }
 
-      const cleanupCallbackList = createCallbackListNotifiedOnce();
+      const cleanupCallbackSet = new Set();
       const cleanup = async (reason) => {
-        await cleanupCallbackList.notify({ reason });
+        const promises = [];
+        for (const cleanupCallback of cleanupCallbackSet) {
+          promises.push(cleanupCallback({ reason }));
+        }
+        cleanupCallbackSet.clear();
+        await Promise.all(promises);
       };
 
       const childExecOptions = await createChildExecOptions({
@@ -106,9 +119,11 @@ export const nodeChildProcess = ({
           CONTROLLED_CHILD_PROCESS_URL,
         )}`,
       );
+      const actionOperation = Abort.startOperation();
+      actionOperation.addAbortSignal(signal);
       const childProcess = fork(fileURLToPath(CONTROLLED_CHILD_PROCESS_URL), {
         execArgv,
-        // silent: true
+        // silent: true,
         stdio: ["pipe", "pipe", "pipe", "ipc"],
         env: envForChildProcess,
       });
@@ -131,15 +146,48 @@ export const nodeChildProcess = ({
         childProcess.stderr.pipe(stderr);
       }
       const childProcessReadyPromise = new Promise((resolve) => {
-        onceChildProcessMessage(childProcess, "ready", resolve);
+        const removeReadyListener = onChildProcessMessage(
+          childProcess,
+          "ready",
+          () => {
+            removeReadyListener();
+            onRuntimeStarted();
+            resolve();
+          },
+        );
       });
+      cleanupCallbackSet.add(
+        onceChildProcessEvent(childProcess, "exit", () => {
+          onRuntimeStopped();
+        }),
+      );
+
       const removeOutputListener = installChildProcessOutputListener(
         childProcess,
         ({ type, text }) => {
+          if (type === "error" && text.startsWith("Debugger attached.")) {
+            return;
+          }
+          if (
+            type === "error" &&
+            text.startsWith("Waiting for the debugger to disconnect...")
+          ) {
+            return;
+          }
+
           onConsole({ type, text });
         },
       );
       const stop = memoize(async ({ gracefulStopAllocatedMs } = {}) => {
+        // read all stdout before terminating
+        // (no need for stderr because it's sync)
+        if (collectConsole || onConsole) {
+          while (childProcess.stdout.read() !== null) {}
+          await new Promise((resolve) => {
+            setTimeout(resolve, 50);
+          });
+        }
+
         // all libraries are facing problem on windows when trying
         // to kill a process spawning other processes.
         // "killProcessTree" is theorically correct but sometimes keep process handing forever.
@@ -174,159 +222,214 @@ export const nodeChildProcess = ({
         return;
       });
 
-      const actionOperation = Abort.startOperation();
-      actionOperation.addAbortSignal(signal);
-      const winnerPromise = new Promise((resolve) => {
-        raceCallbacks(
-          {
-            aborted: (cb) => {
-              return actionOperation.addAbortCallback(cb);
-            },
-            // https://nodejs.org/api/child_process.html#child_process_event_disconnect
-            // disconnect: (cb) => {
-            //   return onceProcessEvent(childProcess, "disconnect", cb)
-            // },
-            // https://nodejs.org/api/child_process.html#child_process_event_error
-            error: (cb) => {
-              return onceChildProcessEvent(childProcess, "error", cb);
-            },
-            exit: (cb) => {
-              return onceChildProcessEvent(
-                childProcess,
-                "exit",
-                (code, signal) => {
-                  cb({ code, signal });
-                },
-              );
-            },
-            response: (cb) => {
-              return onceChildProcessMessage(childProcess, "action-result", cb);
-            },
-          },
-          resolve,
-        );
-      });
       const result = {
         status: "executing",
         errors: [],
         namespace: null,
+        timings: {},
+        memoryUsage: null,
+        performance: null,
       };
 
-      const writeResult = async () => {
+      try {
+        let executionInternalErrorCallback;
+        let executionCompletedCallback;
+        const winnerPromise = new Promise((resolve) => {
+          raceCallbacks(
+            {
+              aborted: (cb) => {
+                return actionOperation.addAbortCallback(cb);
+              },
+              // https://nodejs.org/api/child_process.html#child_process_event_disconnect
+              // disconnect: (cb) => {
+              //   return onceProcessEvent(childProcess, "disconnect", cb)
+              // },
+              // https://nodejs.org/api/child_process.html#child_process_event_error
+              error: (cb) => {
+                return onceChildProcessEvent(childProcess, "error", cb);
+              },
+              exit: (cb) => {
+                return onceChildProcessEvent(
+                  childProcess,
+                  "exit",
+                  (code, signal) => {
+                    cb({ code, signal });
+                  },
+                );
+              },
+              execution_internal_error: (cb) => {
+                executionInternalErrorCallback = cb;
+              },
+              execution_completed: (cb) => {
+                executionCompletedCallback = cb;
+              },
+            },
+            resolve,
+          );
+        });
+        const raceHandlers = {
+          aborted: () => {
+            result.status = "aborted";
+          },
+          error: (error) => {
+            removeOutputListener();
+            result.status = "failed";
+            result.errors.push(error);
+          },
+          exit: ({ code }) => {
+            onRuntimeStopped();
+            if (code === 12) {
+              result.status = "failed";
+              result.errors.push(
+                new Error(
+                  `node process exited with 12 (the forked child process wanted to use a non-available port for debug)`,
+                ),
+              );
+              return;
+            }
+            if (code === null || code === 0) {
+              result.status = "completed";
+              result.namespace = {};
+              return;
+            }
+            if (
+              code === EXIT_CODES.SIGINT ||
+              code === EXIT_CODES.SIGTERM ||
+              code === EXIT_CODES.SIGABORT
+            ) {
+              result.status = "failed";
+              result.errors.push(
+                new Error(`node process exited during execution`),
+              );
+              return;
+            }
+            // process.exit(1) in child process or process.exitCode = 1 + process.exit()
+            // means there was an error even if we don't know exactly what.
+            result.status = "failed";
+            result.errors.push(
+              new Error(
+                `node process exited with code ${code} during execution`,
+              ),
+            );
+          },
+          execution_internal_error: (error) => {
+            result.status = "failed";
+            result.errors.push(error);
+          },
+          execution_completed: ({
+            status,
+            errors,
+            namespace,
+            timings,
+            memoryUsage,
+            performance,
+            coverage,
+          }) => {
+            result.status = status;
+            result.errors = errors;
+            result.namespace = namespace;
+            result.timings = timings;
+            result.memoryUsage = memoryUsage;
+            result.performance = performance;
+            result.coverage = coverage;
+          },
+        };
         actionOperation.throwIfAborted();
         await childProcessReadyPromise;
         actionOperation.throwIfAborted();
-        await sendToChildProcess(childProcess, {
-          type: "action",
-          data: {
-            actionType: "execute-using-dynamic-import",
-            actionParams: {
+        if (onMeasureMemoryAvailable) {
+          onMeasureMemoryAvailable(async () => {
+            let _resolve;
+            const memoryUsagePromise = new Promise((resolve) => {
+              _resolve = resolve;
+            });
+            await requestActionOnChildProcess(
+              childProcess,
+              {
+                type: "measure-memory-usage",
+              },
+              ({ value }) => {
+                _resolve(value);
+              },
+            );
+            return memoryUsagePromise;
+          });
+        }
+        await requestActionOnChildProcess(
+          childProcess,
+          {
+            type: "execute-using-dynamic-import",
+            params: {
               rootDirectoryUrl,
               fileUrl: new URL(fileRelativeUrl, rootDirectoryUrl).href,
+              measureMemoryUsage,
               collectPerformance,
               coverageEnabled,
-              coverageConfig,
+              coverageInclude,
               coverageMethodForNodeJs,
               coverageFileUrl,
               exitAfterAction: true,
             },
           },
-        });
+          ({ status, value }) => {
+            if (status === "error") {
+              executionInternalErrorCallback(value);
+            } else {
+              executionCompletedCallback(value);
+            }
+          },
+        );
         const winner = await winnerPromise;
-        if (winner.name === "aborted") {
-          result.status = "aborted";
-          return;
-        }
-        if (winner.name === "error") {
-          const error = winner.data;
-          removeOutputListener();
-          result.status = "failed";
-          result.errors.push(error);
-          return;
-        }
-        if (winner.name === "exit") {
-          const { code } = winner.data;
-          await cleanup("process exit");
-          if (code === 12) {
-            result.status = "failed";
-            result.errors.push(
-              new Error(
-                `node process exited with 12 (the forked child process wanted to use a non-available port for debug)`,
-              ),
-            );
-            return;
-          }
-          if (code === null || code === 0) {
-            result.status = "completed";
-            result.namespace = {};
-            return;
-          }
-          if (
-            code === EXIT_CODES.SIGINT ||
-            code === EXIT_CODES.SIGTERM ||
-            code === EXIT_CODES.SIGABORT
-          ) {
-            result.status = "failed";
-            result.errors.push(
-              new Error(`node process exited during execution`),
-            );
-            return;
-          }
-          // process.exit(1) in child process or process.exitCode = 1 + process.exit()
-          // means there was an error even if we don't know exactly what.
-          result.status = "failed";
-          result.errors.push(
-            new Error(`node process exited with code ${code} during execution`),
-          );
-          return;
-        }
-        const { status, value } = winner.data;
-        if (status === "action-failed") {
-          result.status = "failed";
-          result.errors.push(value);
-          return;
-        }
-        const { namespace, performance, coverage } = value;
-        result.status = "completed";
-        result.namespace = namespace;
-        result.performance = performance;
-        result.coverage = coverage;
-      };
-
-      try {
-        await writeResult();
+        raceHandlers[winner.name](winner.data);
       } catch (e) {
         result.status = "failed";
         result.errors.push(e);
+      } finally {
+        if (keepRunning) {
+          stopSignal.notify = stop;
+        } else {
+          await stop({
+            gracefulStopAllocatedMs,
+          });
+          onRuntimeStopped();
+        }
+        await actionOperation.end();
+        await cleanup();
+        return result;
       }
-      if (keepRunning) {
-        stopSignal.notify = stop;
-      } else {
-        await stop({
-          gracefulStopAllocatedMs,
-        });
-      }
-      await actionOperation.end();
-      return result;
     },
   };
 };
 
-// http://man7.org/linux/man-pages/man7/signal.7.html
-// https:// github.com/nodejs/node/blob/1d9511127c419ec116b3ddf5fc7a59e8f0f1c1e4/lib/internal/child_process.js#L472
-const GRACEFUL_STOP_SIGNAL = "SIGTERM";
-const STOP_SIGNAL = "SIGKILL";
-// it would be more correct if GRACEFUL_STOP_FAILED_SIGNAL was SIGHUP instead of SIGKILL.
-// but I'm not sure and it changes nothing so just use SIGKILL
-const GRACEFUL_STOP_FAILED_SIGNAL = "SIGKILL";
+let previousId = 0;
+const requestActionOnChildProcess = async (
+  childProcess,
+  { type, params },
+  onResponse,
+) => {
+  const actionId = previousId + 1;
+  previousId = actionId;
 
-const sendToChildProcess = async (childProcess, { type, data }) => {
-  return new Promise((resolve, reject) => {
+  const removeMessageListener = onChildProcessMessage(
+    childProcess,
+    "action-result",
+    ({ id, ...payload }) => {
+      if (id === actionId) {
+        removeMessageListener();
+        onResponse(payload);
+      }
+    },
+  );
+
+  const sendPromise = new Promise((resolve, reject) => {
     childProcess.send(
       {
-        jsenv: true,
-        type,
-        data,
+        __jsenv__: "action",
+        data: {
+          id: actionId,
+          type,
+          params,
+        },
       },
       (error) => {
         if (error) {
@@ -337,8 +440,17 @@ const sendToChildProcess = async (childProcess, { type, data }) => {
       },
     );
   });
+  await sendPromise;
 };
 
+// http://man7.org/linux/man-pages/man7/signal.7.html
+// https:// github.com/nodejs/node/blob/1d9511127c419ec116b3ddf5fc7a59e8f0f1c1e4/lib/internal/child_process.js#L472
+const GRACEFUL_STOP_SIGNAL = "SIGTERM";
+const STOP_SIGNAL = "SIGKILL";
+// it would be more correct if GRACEFUL_STOP_FAILED_SIGNAL was SIGHUP instead of SIGKILL.
+// but I'm not sure and it changes nothing so just use SIGKILL
+const GRACEFUL_STOP_FAILED_SIGNAL = "SIGKILL";
+
 const installChildProcessOutputListener = (childProcess, callback) => {
   // beware that we may receive ansi output here, should not be a problem but keep that in mind
   const stdoutDataCallback = (chunk) => {
@@ -351,14 +463,13 @@ const installChildProcessOutputListener = (childProcess, callback) => {
   childProcess.stderr.on("data", stdErrorDataCallback);
   return () => {
     childProcess.stdout.removeListener("data", stdoutDataCallback);
-    childProcess.stderr.removeListener("data", stdoutDataCallback);
+    childProcess.stderr.removeListener("data", stdErrorDataCallback);
   };
 };
 
-const onceChildProcessMessage = (childProcess, type, callback) => {
+const onChildProcessMessage = (childProcess, type, callback) => {
   const onmessage = (message) => {
-    if (message && message.jsenv && message.type === type) {
-      childProcess.removeListener("message", onmessage);
+    if (message && message.__jsenv__ === type) {
       callback(message.data ? JSON.parse(message.data) : "");
     }
   };