@agoric/telemetry 0.6.3-u19.2 → 0.6.3-u21.0

package/src/slog-sender-pipe.js

@@ -1,7 +1,18 @@
+/**
+ * @file Export a `makeSlogSender` that spawns a
+ *   {@link ./slog-sender-pipe-entrypoint.js} child process to which it forwards
+ *   all slog entries via Node.js IPC with advanced (structured clone)
+ *   serialization.
+ *   https://nodejs.org/docs/latest/api/child_process.html#advanced-serialization
+ */
+
 import { fork } from 'child_process';
 import path from 'path';
+import { promisify } from 'util';
 import anylogger from 'anylogger';
 
+import { q, Fail } from '@endo/errors';
+import { makePromiseKit } from '@endo/promise-kit';
 import { makeQueue } from '@endo/stream';
 
 import { makeShutdown } from '@agoric/internal/src/node/shutdown.js';
@@ -10,6 +21,8 @@ const dirname = path.dirname(new URL(import.meta.url).pathname);
 
 const logger = anylogger('slog-sender-pipe');
 
+const sink = () => {};
+
 /**
  * @template {any[]} T
  * @template R
@@ -23,168 +36,131 @@ const withMutex = operation => {
   return async (...args) => {
     await mutex.get();
     const result = operation(...args);
-    mutex.put(
-      result.then(
-        () => {},
-        () => {},
-      ),
-    );
+    mutex.put(result.then(sink, sink));
     return result;
   };
 };
 
 /**
- * @typedef {object} SlogSenderInitReply
- * @property {'initReply'} type
- * @property {boolean} hasSender
- * @property {Error} [error]
+ * @template [P=unknown]
+ * @typedef {{ type: string, error?: Error } & P} PipeReply
  */
+
 /**
- * @typedef {object} SlogSenderFlushReply
- * @property {'flushReply'} type
- * @property {Error} [error]
+ * @typedef {{
+ *   init: {
+ *     message: import('./slog-sender-pipe-entrypoint.js').InitMessage;
+ *     reply: PipeReply<{ hasSender: boolean }>;
+ *   };
+ *   flush: {
+ *     message: import('./slog-sender-pipe-entrypoint.js').FlushMessage;
+ *     reply: PipeReply<{}>;
+ *   };
+ * }} SlogSenderPipeAPI
+ *
+ * @typedef {keyof SlogSenderPipeAPI} PipeAPICommand
+ * @typedef {SlogSenderPipeAPI[PipeAPICommand]["reply"]} PipeAPIReply
  */
-/** @typedef {SlogSenderInitReply | SlogSenderFlushReply} SlogSenderPipeWaitReplies */
 
-/** @param {import('.').MakeSlogSenderOptions} opts */
-export const makeSlogSender = async opts => {
+/** @param {import('.').MakeSlogSenderOptions} options */
+export const makeSlogSender = async options => {
+  const { env = {} } = options;
   const { registerShutdown } = makeShutdown();
+
   const cp = fork(path.join(dirname, 'slog-sender-pipe-entrypoint.js'), [], {
-    stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+    stdio: ['ignore', 'inherit', 'inherit', 'ipc'],
     serialization: 'advanced',
+    env,
   });
   // logger.log('done fork');
 
-  const pipeSend = withMutex(
-    /**
-     * @template {{type: string}} T
-     * @param {T} msg
-     */
-    msg =>
-      /** @type {Promise<void>} */ (
-        new Promise((resolve, reject) => {
-          cp.send(msg, err => {
-            if (err) {
-              reject(err);
-            } else {
-              resolve();
-            }
-          });
-        })
-      ),
-  );
+  const exitKit = makePromiseKit();
+  cp.on('error', error => {
+    // An exit event *might* be coming, so wait a tick.
+    setImmediate(() => exitKit.resolve({ error }));
+  });
+  cp.on('exit', (exitCode, signal) => {
+    exitKit.resolve({ exitCode, signal });
+  });
+
+  /** @type {(msg: Record<string, unknown> & {type: string}) => Promise<void>} */
+  const rawSend = promisify(cp.send.bind(cp));
+  const pipeSend = withMutex(rawSend);
 
-  /**
-   * @typedef {{
-   *   init: {
-   *     message: import('./slog-sender-pipe-entrypoint.js').InitMessage;
-   *     reply: SlogSenderInitReply;
-   *   };
-   *   flush: {
-   *     message: import('./slog-sender-pipe-entrypoint.js').FlushMessage;
-   *     reply: SlogSenderFlushReply;
-   *   };
-   * }} SlogSenderWaitMessagesAndReplies
-   */
-
-  /** @typedef {keyof SlogSenderWaitMessagesAndReplies} SendWaitCommands */
-  /**
-   * @template {SlogSenderPipeWaitReplies} T
-   * @typedef {Omit<T, 'type' | 'error'>} ReplyPayload
-   */
-
-  /** @type {import('@endo/stream').AsyncQueue<SlogSenderPipeWaitReplies>} */
+  /** @type {import('@endo/stream').AsyncQueue<PipeAPIReply>} */
   const sendWaitQueue = makeQueue();
-  /** @type {SendWaitCommands | undefined} */
+  /** @type {PipeAPICommand | undefined} */
   let sendWaitType;
 
   const sendWaitReply = withMutex(
     /**
-     * @template {SendWaitCommands} T
+     * @template {PipeAPICommand} T
      * @param {T} type
-     * @param {Omit<SlogSenderWaitMessagesAndReplies[T]["message"], 'type'>} payload
-     * @returns {Promise<ReplyPayload<SlogSenderWaitMessagesAndReplies[T]["reply"]>>}
+     * @param {Omit<SlogSenderPipeAPI[T]["message"], 'type'>} payload
+     * @returns {Promise<Omit<SlogSenderPipeAPI[T]["reply"], keyof PipeReply>>}
      */
     async (type, payload) => {
-      !sendWaitType || assert.fail('Invalid mutex state');
+      !sendWaitType || Fail`Invalid mutex state`;
 
       const msg = { ...payload, type };
 
       sendWaitType = type;
-      return pipeSend(msg)
-        .then(async () => sendWaitQueue.get())
-        .then(
-          /** @param {SlogSenderWaitMessagesAndReplies[T]["reply"]} reply */ ({
-            type: replyType,
-            error,
-            ...rest
-          }) => {
-            replyType === `${type}Reply` ||
-              assert.fail(`Unexpected reply ${replyType}`);
-            if (error) {
-              throw error;
-            }
-            return rest;
-          },
-        )
-        .finally(() => {
-          sendWaitType = undefined;
-        });
-    },
-  );
-
-  cp.on(
-    'message',
-    /** @param { SlogSenderPipeWaitReplies } msg */
-    msg => {
-      // logger.log('received', msg);
-      if (
-        !msg ||
-        typeof msg !== 'object' ||
-        msg.type !== `${sendWaitType}Reply`
-      ) {
-        logger.warn('Received unexpected message', msg);
-        return;
+      await null;
+      try {
+        await pipeSend(msg);
+        /** @type {SlogSenderPipeAPI[T]["reply"]} */
+        const reply = await sendWaitQueue.get();
+        const { type: replyType, error, ...rest } = reply;
+        replyType === `${type}Reply` ||
+          Fail`Unexpected reply type ${q(replyType)}`;
+        if (error) throw error;
+        return rest;
+      } finally {
+        sendWaitType = undefined;
       }
-
-      sendWaitQueue.put(msg);
     },
   );
 
-  const flush = async () => sendWaitReply('flush', {});
-  /** @param {import('./index.js').MakeSlogSenderOptions} options */
-  const init = async options => sendWaitReply('init', { options });
+  /** @param {PipeReply} msg */
+  const onMessage = msg => {
+    // logger.log('received', msg);
+    if (!msg || msg.type !== `${sendWaitType}Reply`) {
+      logger.warn('Received unexpected message', msg);
+      return;
+    }
+
+    sendWaitQueue.put(msg);
+  };
+  cp.on('message', onMessage);
 
-  const send = obj => {
-    void pipeSend({ type: 'send', obj }).catch(() => {});
+  const flush = async () => {
+    await sendWaitReply('flush', {});
   };
 
   const shutdown = async () => {
     // logger.log('shutdown');
-    if (!cp.connected) {
-      return;
-    }
+    if (!cp.connected) return;
 
     await flush();
     cp.disconnect();
+    await exitKit.promise;
   };
   registerShutdown(shutdown);
 
-  const { hasSender } = await init(opts).catch(err => {
+  const { hasSender } = await sendWaitReply('init', { options }).catch(err => {
     cp.disconnect();
     throw err;
   });
-
   if (!hasSender) {
     cp.disconnect();
     return undefined;
   }
 
-  const slogSender = send;
+  const slogSender = obj => {
+    void pipeSend({ type: 'send', obj }).catch(sink);
+  };
   return Object.assign(slogSender, {
-    forceFlush: async () => {
-      await flush();
-    },
+    forceFlush: flush,
     shutdown,
     usesJsonObject: false,
   });

package/test/flight-recorder.test.js

@@ -1,5 +1,4 @@
 import fs from 'node:fs';
-import { promisify } from 'node:util';
 import tmp from 'tmp';
 import { test } from './prepare-test-env-ava.js';
 
@@ -13,36 +12,48 @@ const bufferTests = test.macro(
   /**
    *
    * @param {*} t
-   * @param {{makeBuffer: Function}} input
+   * @param {{makeBuffer: typeof makeSimpleCircularBuffer}} input
    */
   async (t, input) => {
     const BUFFER_SIZE = 512;
 
-    const {
-      name: tmpFile,
-      fd,
-      removeCallback,
-    } = tmp.fileSync({ detachDescriptor: true });
-    t.teardown(removeCallback);
-    const fileHandle = /** @type {import('fs/promises').FileHandle} */ ({
-      close: promisify(fs.close.bind(fs, fd)),
+    const { name: tmpFile, removeCallback } = tmp.fileSync({
+      discardDescriptor: true,
     });
-    const { readCircBuf, writeCircBuf } = await input.makeBuffer({
+    t.teardown(removeCallback);
+    const { fileHandle, readCircBuf, writeCircBuf } = await input.makeBuffer({
       circularBufferSize: BUFFER_SIZE,
       circularBufferFilename: tmpFile,
     });
-    const slogSender = makeSlogSenderFromBuffer({ fileHandle, writeCircBuf });
-    t.teardown(slogSender.shutdown);
+    const realSlogSender = makeSlogSenderFromBuffer({
+      fileHandle,
+      writeCircBuf,
+    });
+    let wasShutdown = false;
+    const shutdown = () => {
+      if (wasShutdown) return;
+      wasShutdown = true;
+
+      return realSlogSender.shutdown();
+    };
+    t.teardown(shutdown);
+    // To verify lack of attempted mutation by the consumer, send only hardened
+    // entries.
+    /** @type {typeof realSlogSender} */
+    const slogSender = Object.assign(
+      (obj, serialized) => realSlogSender(harden(obj), serialized),
+      realSlogSender,
+    );
     slogSender({ type: 'start' });
     await slogSender.forceFlush();
     t.is(fs.readFileSync(tmpFile, { encoding: 'utf8' }).length, BUFFER_SIZE);
 
     const len0 = new Uint8Array(BigUint64Array.BYTES_PER_ELEMENT);
-    const { done: done0 } = readCircBuf(len0);
+    const { done: done0 } = await readCircBuf(len0);
     t.false(done0, 'readCircBuf should not be done');
     const dv0 = new DataView(len0.buffer);
     const buf0 = new Uint8Array(Number(dv0.getBigUint64(0)));
-    const { done: done0b } = readCircBuf(buf0, len0.byteLength);
+    const { done: done0b } = await readCircBuf(buf0, len0.byteLength);
     t.false(done0b, 'readCircBuf should not be done');
     const buf0Str = new TextDecoder().decode(buf0);
     t.is(buf0Str, `\n{"type":"start"}`, `start compare failed`);
@@ -61,12 +72,12 @@ const bufferTests = test.macro(
     let offset = 0;
     const len1 = new Uint8Array(BigUint64Array.BYTES_PER_ELEMENT);
     for (let i = 490; i < last; i += 1) {
-      const { done: done1 } = readCircBuf(len1, offset);
+      const { done: done1 } = await readCircBuf(len1, offset);
       offset += len1.byteLength;
       t.false(done1, `readCircBuf ${i} should not be done`);
       const dv1 = new DataView(len1.buffer);
       const buf1 = new Uint8Array(Number(dv1.getBigUint64(0)));
-      const { done: done1b } = readCircBuf(buf1, offset);
+      const { done: done1b } = await readCircBuf(buf1, offset);
       offset += buf1.byteLength;
       t.false(done1b, `readCircBuf ${i} should not be done`);
       const buf1Str = new TextDecoder().decode(buf1);
@@ -77,12 +88,24 @@ const bufferTests = test.macro(
       );
     }
 
-    const { done: done2 } = readCircBuf(len1, offset);
+    const { done: done2 } = await readCircBuf(len1, offset);
     t.assert(done2, `readCircBuf ${last} should be done`);
 
     slogSender(null, 'PRE-SERIALIZED');
     await slogSender.forceFlush();
     t.truthy(fs.readFileSync(tmpFile).includes('PRE-SERIALIZED'));
+
+    slogSender(null, 'PRE_SHUTDOWN');
+    const shutdownP = shutdown();
+    slogSender(null, 'POST_SHUTDOWN');
+    await shutdownP;
+    slogSender(null, 'SHUTDOWN_COMPLETED');
+
+    const finalContent = fs.readFileSync(tmpFile);
+
+    t.truthy(finalContent.includes('PRE_SHUTDOWN'));
+    t.falsy(finalContent.includes('POST_SHUTDOWN'));
+    t.falsy(finalContent.includes('SHUTDOWN_COMPLETED'));
   },
 );