asdf

Author: baileympearson

test/integration/node-specific/resource_tracking_script_builder.ts

@@ -3,6 +3,7 @@ import { on, once } from 'node:events';
 import { openSync } from 'node:fs';
 import { readFile, unlink, writeFile } from 'node:fs/promises';
 import * as path from 'node:path';
+import { inspect } from 'node:util';
 
 import { AssertionError, expect } from 'chai';
 import type * as timers from 'timers';
@@ -50,6 +51,7 @@ export async function testScriptFactory(
   uri: string,
   resourceScriptPath: string,
   func: ResourceTestFunction,
+  logFn: string,
   iterations?: number
 ) {
   let resourceScript = await readFile(resourceScriptPath, { encoding: 'utf8' });
@@ -59,6 +61,7 @@ export async function testScriptFactory(
   resourceScript = resourceScript.replace('SCRIPT_NAME_STRING', JSON.stringify(name));
   resourceScript = resourceScript.replace('URI_STRING', JSON.stringify(uri));
   resourceScript = resourceScript.replace('ITERATIONS_STRING', `${iterations}`);
+  resourceScript = resourceScript.replace('LOG_FN', `${logFn.toString()}`);
 
   return resourceScript;
 }
@@ -92,6 +95,9 @@ export async function runScriptAndReturnHeapInfo(
   func: HeapResourceTestFunction,
   { iterations = 100 } = {}
 ) {
+  const log = (...args) => process.stdout.write(`${args}\n`);
+
+  log('starting');
   const scriptName = `${name}.cjs`;
   const heapsnapshotFile = `${name}.heapsnapshot.json`;
 
@@ -100,36 +106,55 @@ export async function runScriptAndReturnHeapInfo(
     config.url(),
     HEAP_RESOURCE_SCRIPT_PATH,
     func,
+    `(...args) => process.stdout.write('(subprocess): ' + args)`,
     iterations
   );
   await writeFile(scriptName, scriptContent, { encoding: 'utf8' });
 
   const processDiedController = new AbortController();
-  const script = fork(scriptName, { execArgv: ['--expose-gc'] });
+  const script = fork(scriptName, { execArgv: ['--expose-gc'], stdio: 'inherit' });
   // Interrupt our awaiting of messages if the process crashed
   script.once('close', exitCode => {
     if (exitCode !== 0) {
+      log('process exited with non-zero: ', exitCode);
       processDiedController.abort(new Error(`process exited with: ${exitCode}`));
     }
   });
 
+  script.once('error', error => {
+    log(`processed errored: ${error}`);
+    processDiedController.abort(new Error(`process errored: `, { cause: error }));
+  });
+
+  script.once('spawn', () => log('script spawned successfully.'));
+
   const messages = on(script, 'message', { signal: processDiedController.signal });
   const willClose = once(script, 'close');
 
+  log('fetching messages 1...');
   const starting = await messages.next();
+  log('fetching messages 2: ', inspect(starting, { depth: Infinity }));
+
   const ending = await messages.next();
 
+  log('fetching messages 3: ', inspect(ending, { depth: Infinity }));
+
   const startingMemoryUsed = starting.value[0].startingMemoryUsed;
   const endingMemoryUsed = ending.value[0].endingMemoryUsed;
 
   // make sure the process ended
   const [exitCode] = await willClose;
+
+  log('child process closed.');
+
   expect(exitCode, 'process should have exited with zero').to.equal(0);
 
   const heap = await readFile(heapsnapshotFile, { encoding: 'utf8' }).then(c =>
     parseSnapshot(JSON.parse(c))
   );
 
+  log('done.');
+
   // If any of the above throws we won't reach these unlinks that clean up the created files.
   // This is intentional so that when debugging the file will still be present to check it for errors
   await unlink(scriptName);

test/tools/fixtures/heap_resource_script.in.js

@@ -7,36 +7,53 @@ const func = FUNCTION_STRING;
 const name = SCRIPT_NAME_STRING;
 const uri = URI_STRING;
 const iterations = ITERATIONS_STRING;
+const log = LOG_FN;
 
 const { MongoClient } = require(driverPath);
 const process = require('node:process');
 const v8 = require('node:v8');
 const util = require('node:util');
 const timers = require('node:timers');
 
+const now = performance.now.bind(performance);
 const sleep = util.promisify(timers.setTimeout);
 
 const run = func;
 
 const MB = (2 ** 10) ** 2;
 
 async function main() {
+  log('starting execution' + '\n');
   const startingMemoryUsed = process.memoryUsage().heapUsed / MB;
   process.send({ startingMemoryUsed });
 
+  log('sent first message' + '\n');
+
   for (let iteration = 0; iteration < iterations; iteration++) {
     await run({ MongoClient, uri, iteration });
+    iteration % 20 === 0 && log(`iteration ${iteration} complete\n`);
     global.gc();
   }
 
+  log('script executed' + '\n');
+
   global.gc();
   // Sleep b/c maybe gc will run
   await sleep(100);
   global.gc();
 
   const endingMemoryUsed = process.memoryUsage().heapUsed / MB;
+
+  log('sending second message' + '\n');
+
   process.send({ endingMemoryUsed });
+  log('second message sent.' + '\n');
+
+  const start = now();
   v8.writeHeapSnapshot(`${name}.heapsnapshot.json`);
+  const end = now();
+
+  log(`heap snapshot written in ${end - start}ms. script exiting` + '\n');
 }
 
 main()