@agoric/telemetry 0.6.3-upgrade-14-dev-c8f9e7b.0 → 0.6.3-upgrade-16-dev-8879538.0

package/CHANGELOG.md

@@ -3,39 +3,6 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
-### [0.6.3-u13.0](https://github.com/Agoric/agoric-sdk/compare/@agoric/telemetry@0.6.3-u12.0...@agoric/telemetry@0.6.3-u13.0) (2023-12-07)
-
-**Note:** Version bump only for package @agoric/telemetry
-
-
-
-
-
-### [0.6.3-u12.0](https://github.com/Agoric/agoric-sdk/compare/@agoric/telemetry@0.6.3-u11wf.0...@agoric/telemetry@0.6.3-u12.0) (2023-11-10)
-
-**Note:** Version bump only for package @agoric/telemetry
-
-
-
-
-
-### [0.6.3-u11wf.0](https://github.com/Agoric/agoric-sdk/compare/@agoric/telemetry@0.6.3-u11.0...@agoric/telemetry@0.6.3-u11wf.0) (2023-09-23)
-
-**Note:** Version bump only for package @agoric/telemetry
-
-
-
-
-
-### [0.6.3-u11.0](https://github.com/Agoric/agoric-sdk/compare/@agoric/telemetry@0.6.2...@agoric/telemetry@0.6.3-u11.0) (2023-08-24)
-
-
-### Features
-
-* **cosmic-swingset:** add JS upgrade plan handler stub ([7803d3d](https://github.com/Agoric/agoric-sdk/commit/7803d3de8e0cba681dfd27dacfc3577eed0bf2f8))
-
-
-
 ### [0.6.2](https://github.com/Agoric/agoric-sdk/compare/@agoric/telemetry@0.6.1...@agoric/telemetry@0.6.2) (2023-06-02)
 
 **Note:** Version bump only for package @agoric/telemetry

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/telemetry",
-  "version": "0.6.3-upgrade-14-dev-c8f9e7b.0+c8f9e7b",
+  "version": "0.6.3-upgrade-16-dev-8879538.0+8879538",
   "description": "Agoric's telemetry implementation",
   "type": "module",
   "repository": "https://github.com/Agoric/agoric-sdk",
@@ -12,7 +12,7 @@
     "test:xs": "exit 0",
     "lint-fix": "yarn lint:eslint --fix",
     "lint": "run-s --continue-on-error lint:*",
-    "lint:types": "tsc -p jsconfig.json",
+    "lint:types": "tsc",
     "lint:eslint": "eslint ."
   },
   "bin": {
@@ -22,12 +22,12 @@
   "author": "Agoric",
   "license": "Apache-2.0",
   "dependencies": {
-    "@agoric/assert": "0.6.1-upgrade-14-dev-c8f9e7b.0+c8f9e7b",
-    "@agoric/internal": "0.4.0-upgrade-14-dev-c8f9e7b.0+c8f9e7b",
-    "@agoric/store": "0.9.3-upgrade-14-dev-c8f9e7b.0+c8f9e7b",
-    "@endo/init": "0.5.56",
-    "@endo/marshal": "0.8.5",
-    "@endo/stream": "0.3.25",
+    "@agoric/assert": "0.6.1-upgrade-16-dev-8879538.0+8879538",
+    "@agoric/internal": "0.3.3-upgrade-16-dev-8879538.0+8879538",
+    "@agoric/store": "0.9.3-upgrade-16-dev-8879538.0+8879538",
+    "@endo/init": "^1.1.2",
+    "@endo/marshal": "^1.5.0",
+    "@endo/stream": "^1.2.2",
     "@opentelemetry/api": "~1.3.0",
     "@opentelemetry/exporter-prometheus": "~0.35.0",
     "@opentelemetry/exporter-trace-otlp-http": "~0.35.0",
@@ -36,29 +36,34 @@
     "@opentelemetry/sdk-trace-base": "~1.9.0",
     "@opentelemetry/semantic-conventions": "~1.9.0",
     "anylogger": "^0.21.0",
-    "better-sqlite3": "^8.2.0",
-    "bufferfromfile": "agoric-labs/BufferFromFile#Agoric-built",
+    "better-sqlite3": "^9.1.1",
     "tmp": "^0.2.1"
   },
   "devDependencies": {
-    "@endo/lockdown": "0.1.28",
-    "@endo/ses-ava": "0.2.40",
-    "ava": "^5.2.0",
-    "c8": "^7.13.0",
+    "@endo/lockdown": "^1.0.7",
+    "@endo/ses-ava": "^1.2.2",
+    "ava": "^5.3.0",
+    "c8": "^9.1.0",
     "tmp": "^0.2.1"
   },
   "publishConfig": {
     "access": "public"
   },
   "engines": {
-    "node": ">=14.15.0"
+    "node": "^18.12 || ^20.9"
   },
   "ava": {
     "files": [
-      "test/**/test-*.js"
+      "test/**/*.test.*"
+    ],
+    "require": [
+      "@endo/init/debug.js"
     ],
     "timeout": "20m",
     "workerThreads": false
   },
-  "gitHead": "c8f9e7be1645e0be23f47de197409a7d4874add5"
+  "typeCoverage": {
+    "atLeast": 87.03
+  },
+  "gitHead": "8879538cd1d125a08346f02dd5701d0d70c90bb8"
 }

package/scripts/ingest.sh

@@ -18,8 +18,8 @@ if [[ ! -s "$PROGRESS" ]]; then
   fi
   if [[ -n "$INGEST_START" ]]; then
     case "$1" in
-    *.Z | *.gz) firstline=$(zcat "$1" | head -1) ;;
-    *) firstline=$(head -1 "$1") ;;
+      *.Z | *.gz) firstline=$(zcat "$1" | head -1) ;;
+      *) firstline=$(head -1 "$1") ;;
     esac
     echo "$firstline" | jq --arg targetStart "$INGEST_START" \
       '{virtualTimeOffset: (($targetStart | fromdate) - .time), lastSlogTime: 0}' \

package/src/flight-recorder.js

@@ -1,20 +1,10 @@
+// @ts-check
+/* global Buffer */
 /// <reference types="ses" />
 
-// https://github.com/Agoric/agoric-sdk/issues/3742#issuecomment-1028451575
-// I'd mmap() a 100MB file, reserve a few bytes for offsets, then use the rest
-// as a circular buffer to hold length-prefixed records. The agd process would
-// keep writing new events into the RAM window and updating the start/end
-// pointers, with some sequencing to make sure the record gets written before
-// the pointer is updated. Then, no mattter how abruptly the process is
-// terminated, as long as the host computer itself is still running, the on-disk
-// file would contain the most recent state, and anybody who reads the file will
-// get the most recent state. The host kernel (linux) is under no obligation to
-// flush it to disk any particular time, but knows when reads happen, so there's
-// no coherency problem, and the speed is unaffected by disk write speeds.
-
-import BufferFromFile from 'bufferfromfile';
-import { promises as fsPromises } from 'fs';
-import path from 'path';
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
 import { serializeSlogObj } from './serialize-slog-obj.js';
 
 const { Fail } = assert;
@@ -31,12 +21,16 @@ const I_ARENA_START = 4 * BigUint64Array.BYTES_PER_ELEMENT;
 
 const RECORD_HEADER_SIZE = BigUint64Array.BYTES_PER_ELEMENT;
 
+/**
+ * Initializes a circular buffer with the given size, creating the buffer file if it doesn't exist or is not large enough.
+ *
+ * @param {string} bufferFile - the file path for the circular buffer
+ * @param {number} circularBufferSize - the size of the circular buffer
+ * @returns {Promise<bigint>} the size of the initialized circular buffer
+ */
 const initializeCircularBuffer = async (bufferFile, circularBufferSize) => {
-  if (!circularBufferSize) {
-    return undefined;
-  }
   // If the file doesn't exist, or is not large enough, create it.
-  const stbuf = await fsPromises.stat(bufferFile).catch(e => {
+  const stbuf = await fsp.stat(bufferFile).catch(e => {
     if (e.code === 'ENOENT') {
       return undefined;
     }
@@ -57,8 +51,8 @@ const initializeCircularBuffer = async (bufferFile, circularBufferSize) => {
   header.setBigUint64(I_CIRC_START, 0n);
   header.setBigUint64(I_CIRC_END, 0n);
 
-  await fsPromises.mkdir(path.dirname(bufferFile), { recursive: true });
-  await fsPromises.writeFile(bufferFile, headerBuf);
+  await fsp.mkdir(path.dirname(bufferFile), { recursive: true });
+  await fsp.writeFile(bufferFile, headerBuf);
 
   if (stbuf && stbuf.size >= circularBufferSize) {
     // File is big enough.
@@ -66,50 +60,20 @@ const initializeCircularBuffer = async (bufferFile, circularBufferSize) => {
   }
 
   // Increase the file size.
-  await fsPromises.truncate(bufferFile, circularBufferSize);
+  await fsp.truncate(bufferFile, circularBufferSize);
   return arenaSize;
 };
 
-export const makeMemoryMappedCircularBuffer = async ({
-  circularBufferSize = DEFAULT_CBUF_SIZE,
-  stateDir = '/tmp',
-  circularBufferFilename,
-}) => {
-  const filename = circularBufferFilename || `${stateDir}/${DEFAULT_CBUF_FILE}`;
-  // console.log({ circularBufferFilename, filename });
-
-  const newArenaSize = await initializeCircularBuffer(
-    filename,
-    circularBufferSize,
-  );
+/** @typedef {Awaited<ReturnType<typeof makeSimpleCircularBuffer>>} CircularBuffer */
 
-  /**
-   * @type {Uint8Array}
-   * BufferFromFile mmap()s the file into the process address space.
-   */
-  const fileBuf = BufferFromFile(filename).Uint8Array();
-  const header = new DataView(fileBuf.buffer, 0, I_ARENA_START);
-
-  // Detect the arena size from the header, if not initialized.
-  const hdrArenaSize = header.getBigUint64(I_ARENA_SIZE);
-  const arenaSize = newArenaSize || hdrArenaSize;
-
-  const hdrMagic = header.getBigUint64(I_MAGIC);
-  SLOG_MAGIC === hdrMagic ||
-    Fail`${filename} is not a slog buffer; wanted magic ${SLOG_MAGIC}, got ${hdrMagic}`;
-  arenaSize === hdrArenaSize ||
-    Fail`${filename} arena size mismatch; wanted ${arenaSize}, got ${hdrArenaSize}`;
-  const arena = new Uint8Array(
-    fileBuf.buffer,
-    header.byteLength,
-    Number(arenaSize),
-  );
-
-  /**
-   * @param {Uint8Array} outbuf
-   * @param {number} [offset] offset relative to the current trailing edge (circStart) of the data
-   * @returns {IteratorResult<Uint8Array, void>}
-   */
+/**
+ *
+ * @param {bigint} arenaSize
+ * @param {DataView} header
+ * @param {(outbuf: Uint8Array, readStart: number, firstReadLength: number) => void} readRecord
+ * @param {(record: Uint8Array, firstWriteLength: number, circEnd: bigint) => Promise<void>} writeRecord
+ */
+function finishCircularBuffer(arenaSize, header, readRecord, writeRecord) {
   const readCircBuf = (outbuf, offset = 0) => {
     offset + outbuf.byteLength <= arenaSize ||
       Fail`Reading past end of circular buffer`;
@@ -132,19 +96,13 @@ export const makeMemoryMappedCircularBuffer = async ({
       // The data is contiguous, like ---AAABBB---
       return { done: true, value: undefined };
     }
-    outbuf.set(arena.subarray(readStart, readStart + firstReadLength));
-    if (firstReadLength < outbuf.byteLength) {
-      outbuf.set(
-        arena.subarray(0, outbuf.byteLength - firstReadLength),
-        firstReadLength,
-      );
-    }
+    readRecord(outbuf, readStart, firstReadLength);
     return { done: false, value: outbuf };
   };
 
-  /** @param {Uint8Array} data */
-  const writeCircBuf = data => {
-    if (RECORD_HEADER_SIZE + data.byteLength > arena.byteLength) {
+  /** @type {(data: Uint8Array) => Promise<void>} */
+  const writeCircBuf = async data => {
+    if (RECORD_HEADER_SIZE + data.byteLength > arenaSize) {
       // The data is too big to fit in the arena, so skip it.
       const tooBigRecord = JSON.stringify({
         type: 'slog-record-too-big',
@@ -153,14 +111,17 @@ export const makeMemoryMappedCircularBuffer = async ({
       data = new TextEncoder().encode(tooBigRecord);
     }
 
-    if (RECORD_HEADER_SIZE + data.byteLength > arena.byteLength) {
+    if (RECORD_HEADER_SIZE + data.byteLength > arenaSize) {
       // Silently drop, it just doesn't fit.
       return;
     }
 
+    // Allocate for the data and a header
     const record = new Uint8Array(RECORD_HEADER_SIZE + data.byteLength);
+    // Set the data, after the header
     record.set(data, RECORD_HEADER_SIZE);
 
+    // Set the size in the header
     const lengthPrefix = new DataView(record.buffer);
     lengthPrefix.setBigUint64(0, BigInt(data.byteLength));
 
@@ -206,31 +167,135 @@ export const makeMemoryMappedCircularBuffer = async ({
       );
     }
 
-    arena.set(record.subarray(0, firstWriteLength), Number(circEnd));
-    if (firstWriteLength < record.byteLength) {
-      // Write to the beginning of the arena.
-      arena.set(record.subarray(firstWriteLength, record.byteLength), 0);
-    }
     header.setBigUint64(
       I_CIRC_END,
       (circEnd + BigInt(record.byteLength)) % arenaSize,
     );
+
+    return writeRecord(record, firstWriteLength, circEnd);
   };
 
-  const writeJSON = (obj, jsonObj = serializeSlogObj(obj)) => {
-    // Prepend a newline so that the file can be more easily manipulated.
-    const data = new TextEncoder().encode(`\n${jsonObj}`);
-    // console.log('have obj', obj, data);
-    writeCircBuf(data);
+  return { readCircBuf, writeCircBuf };
+}
+
+/**
+ * @param {{
+ *   circularBufferSize?: number,
+ *   stateDir?: string,
+ *   circularBufferFilename?: string
+ * }} opts
+ */
+export const makeSimpleCircularBuffer = async ({
+  circularBufferSize = DEFAULT_CBUF_SIZE,
+  stateDir = '/tmp',
+  circularBufferFilename,
+}) => {
+  const filename = circularBufferFilename || `${stateDir}/${DEFAULT_CBUF_FILE}`;
+
+  const newArenaSize = await initializeCircularBuffer(
+    filename,
+    circularBufferSize,
+  );
+
+  const file = await fsp.open(filename, 'r+');
+
+  const headerBuffer = Buffer.alloc(I_ARENA_START);
+
+  await file.read({
+    buffer: headerBuffer,
+    length: I_ARENA_START,
+    position: 0,
+  });
+  const header = new DataView(headerBuffer.buffer);
+
+  // Detect the arena size from the header, if not initialized.
+  const hdrArenaSize = header.getBigUint64(I_ARENA_SIZE);
+  const arenaSize = newArenaSize || hdrArenaSize;
+
+  const hdrMagic = header.getBigUint64(I_MAGIC);
+  SLOG_MAGIC === hdrMagic ||
+    Fail`${filename} is not a slog buffer; wanted magic ${SLOG_MAGIC}, got ${hdrMagic}`;
+  arenaSize === hdrArenaSize ||
+    Fail`${filename} arena size mismatch; wanted ${arenaSize}, got ${hdrArenaSize}`;
+
+  /** @type {(outbuf: Uint8Array, readStart: number, firstReadLength: number) => void} */
+  const readRecord = (outbuf, readStart, firstReadLength) => {
+    const bytesRead = fs.readSync(file.fd, outbuf, {
+      length: firstReadLength,
+      position: Number(readStart) + I_ARENA_START,
+    });
+    assert.equal(bytesRead, firstReadLength, 'Too few bytes read');
+
+    if (bytesRead < outbuf.byteLength) {
+      fs.readSync(file.fd, outbuf, {
+        offset: firstReadLength,
+        length: outbuf.byteLength - firstReadLength,
+        position: I_ARENA_START,
+      });
+    }
+  };
+
+  /**
+   * Writes to the file, offset by the header size. Also updates the file header.
+   *
+   * @param {Uint8Array} record
+   * @param {number} firstWriteLength
+   * @param {bigint} circEnd
+   */
+  const writeRecord = async (record, firstWriteLength, circEnd) => {
+    await file.write(
+      record,
+      // TS saying options bag not available
+      0,
+      firstWriteLength,
+      I_ARENA_START + Number(circEnd),
+    );
+    if (firstWriteLength < record.byteLength) {
+      // Write to the beginning of the arena.
+      await file.write(
+        record,
+        firstWriteLength,
+        record.byteLength - firstWriteLength,
+        I_ARENA_START,
+      );
+    }
+
+    // Write out the updated file header.
+    // This is somewhat independent of writing the record itself, but it needs
+    // updating each time a record is written.
+    await file.write(headerBuffer, undefined, undefined, 0);
   };
 
-  return { readCircBuf, writeCircBuf, writeJSON };
+  return finishCircularBuffer(arenaSize, header, readRecord, writeRecord);
 };
 
-export const makeSlogSender = async opts => {
-  const { writeJSON } = await makeMemoryMappedCircularBuffer(opts);
+/**
+ *
+ * @param {Pick<Awaited<ReturnType<typeof makeSimpleCircularBuffer>>, 'writeCircBuf'>} circBuf
+ */
+export const makeSlogSenderFromBuffer = ({ writeCircBuf }) => {
+  /** @type {Promise<void>} */
+  let toWrite = Promise.resolve();
+  const writeJSON = (obj, serialized = serializeSlogObj(obj)) => {
+    // Prepend a newline so that the file can be more easily manipulated.
+    const data = new TextEncoder().encode(`\n${serialized}`);
+    // console.log('have obj', obj, data);
+    toWrite = toWrite.then(() => writeCircBuf(data));
+  };
   return Object.assign(writeJSON, {
-    forceFlush: async () => {},
+    forceFlush: async () => {
+      await toWrite;
+    },
     usesJsonObject: true,
   });
 };
+
+/**
+ * Loaded dynamically by makeSlogSender()
+ *
+ * @type {import('./index.js').MakeSlogSender}
+ */
+export const makeSlogSender = async opts => {
+  const { writeCircBuf } = await makeSimpleCircularBuffer(opts);
+  return makeSlogSenderFromBuffer({ writeCircBuf });
+};

package/src/frcat-entrypoint.js

@@ -5,7 +5,7 @@
 
 import '@endo/init';
 
-import { makeMemoryMappedCircularBuffer } from './flight-recorder.js';
+import { makeSimpleCircularBuffer } from './flight-recorder.js';
 
 const main = async () => {
   const files = process.argv.slice(2);
@@ -14,8 +14,7 @@ const main = async () => {
   }
 
   for await (const file of files) {
-    // eslint-disable-next-line @jessie.js/no-nested-await
-    const { readCircBuf } = await makeMemoryMappedCircularBuffer({
+    const { readCircBuf } = await makeSimpleCircularBuffer({
       circularBufferFilename: file,
       circularBufferSize: 0,
     });
@@ -50,13 +49,18 @@ const main = async () => {
       }
 
       // If the buffer is full, wait for stdout to drain.
-      // eslint-disable-next-line no-await-in-loop, @jessie.js/no-nested-await
       await new Promise(resolve => process.stdout.once('drain', resolve));
     }
   }
 };
 
-main().catch(err => {
-  console.error(err);
-  process.exitCode = 1;
-});
+process.exitCode = 1;
+main().then(
+  () => {
+    process.exitCode = 0;
+  },
+  err => {
+    console.error('Failed with', err);
+    process.exit(process.exitCode || 1);
+  },
+);

package/src/index.js

@@ -13,6 +13,9 @@ export * from './make-slog-sender.js';
  *  shutdown?: () => Promise<void>;
  * }} SlogSender
  */
+/**
+ * @typedef {(opts: import('./index.js').MakeSlogSenderOptions) => SlogSender | undefined} MakeSlogSender
+ */
 /**
  * @typedef {MakeSlogSenderCommonOptions & Record<string, unknown>} MakeSlogSenderOptions
  * @typedef {object} MakeSlogSenderCommonOptions
@@ -34,9 +37,9 @@ export const tryFlushSlogSender = async (
   await Promise.resolve(slogSender?.forceFlush?.()).catch(err => {
     log?.('Failed to flush slog sender', err);
     if (err.errors) {
-      err.errors.forEach(error => {
+      for (const error of err.errors) {
         log?.('nested error:', error);
-      });
+      }
     }
     if (env.SLOGSENDER_FAIL_ON_ERROR) {
       throw err;
@@ -58,21 +61,20 @@ export const getResourceAttributes = ({
       SDK_REVISION;
   }
   if (!resourceAttributes[SemanticResourceAttributes.SERVICE_INSTANCE_ID]) {
-    resourceAttributes[
-      SemanticResourceAttributes.SERVICE_INSTANCE_ID
-    ] = `${Math.random()}`;
+    resourceAttributes[SemanticResourceAttributes.SERVICE_INSTANCE_ID] =
+      `${Math.random()}`;
   }
   if (serviceName) {
     resourceAttributes[SemanticResourceAttributes.SERVICE_NAME] = serviceName;
   }
   if (OTEL_RESOURCE_ATTRIBUTES) {
     // Allow overriding resource attributes.
-    OTEL_RESOURCE_ATTRIBUTES.split(',').forEach(kv => {
+    for (const kv of OTEL_RESOURCE_ATTRIBUTES.split(',')) {
       const match = kv.match(/^([^=]*)=(.*)$/);
       if (match) {
         resourceAttributes[match[1]] = match[2];
       }
-    });
+    }
   }
   return resourceAttributes;
 };

package/src/ingest-slog-entrypoint.js

@@ -74,7 +74,7 @@ async function run() {
     if (!flush) {
       return;
     }
-    await slogSender.forceFlush();
+    await slogSender.forceFlush?.();
     fs.writeFileSync(progressFileName, JSON.stringify(progress));
   };
 
@@ -143,4 +143,13 @@ async function run() {
   );
 }
 
-run().catch(err => console.log('err', err));
+process.exitCode = 1;
+run().then(
+  () => {
+    process.exitCode = 0;
+  },
+  err => {
+    console.error('Failed with', err);
+    process.exit(process.exitCode || 1);
+  },
+);

package/src/make-slog-sender.js

@@ -9,7 +9,7 @@ export const SLOGFILE_SENDER_MODULE = '@agoric/telemetry/src/slog-file.js';
 
 export const DEFAULT_SLOGSENDER_AGENT = 'self';
 
-/** @typedef {import('./index.js').SlogSender} SlogSender */
+/** @import {SlogSender} from './index.js' */
 
 /**
  * @template T
@@ -19,7 +19,7 @@ export const DEFAULT_SLOGSENDER_AGENT = 'self';
 const filterTruthy = arr => /** @type {any[]} */ (arr.filter(Boolean));
 
 /**
- * @param {import('./index.js').MakeSlogSenderOptions} opts
+ * @type {import('./index.js').MakeSlogSender}
  */
 export const makeSlogSender = async (opts = {}) => {
   const { env = {}, stateDir: stateDirOption, ...otherOpts } = opts;
@@ -88,7 +88,7 @@ export const makeSlogSender = async (opts = {}) => {
     slogSenderModules.map(async moduleIdentifier =>
       import(moduleIdentifier)
         .then(
-          /** @param {{makeSlogSender: (opts: {}) => Promise<SlogSender | undefined>}} module */ ({
+          /** @param {{makeSlogSender: import('./index.js').MakeSlogSender}} module */ ({
             makeSlogSender: maker,
           }) => {
             if (typeof maker !== 'function') {

package/src/otel-and-flight-recorder.js

@@ -1,6 +1,9 @@
 import { NonNullish } from '@agoric/assert';
 import { makeSlogSender as makeSlogSenderFromEnv } from './make-slog-sender.js';
 
+/**
+ * @param {import('./index.js').MakeSlogSenderOptions} opts
+ */
 export const makeSlogSender = async opts => {
   const { SLOGFILE: _1, SLOGSENDER: _2, ...otherEnv } = opts.env || {};
 

package/src/slog-sender-pipe-entrypoint.js

@@ -1,7 +1,6 @@
 /* global process */
 import '@endo/init';
 
-import { makeAggregateError } from '@agoric/internal';
 import anylogger from 'anylogger';
 import { makeShutdown } from '@agoric/internal/src/node/shutdown.js';
 
@@ -75,7 +74,7 @@ const main = async () => {
       sendErrors.unshift(actualFlushError);
     }
 
-    return makeAggregateError(sendErrors.splice(0));
+    return AggregateError(sendErrors.splice(0));
   };
 
   process.on(
@@ -130,7 +129,13 @@ const main = async () => {
   );
 };
 
-main().catch(e => {
-  logger.error(e);
-  process.exitCode = 1;
-});
+process.exitCode = 1;
+main().then(
+  () => {
+    process.exitCode = 0;
+  },
+  err => {
+    logger.error('Failed with', err);
+    process.exit(process.exitCode || 1);
+  },
+);

package/src/slog-sender-pipe.js

@@ -6,8 +6,7 @@ import { makeQueue } from '@endo/stream';
 
 import { makeShutdown } from '@agoric/internal/src/node/shutdown.js';
 
-const filename = new URL(import.meta.url).pathname;
-const dirname = path.dirname(filename);
+const dirname = path.dirname(new URL(import.meta.url).pathname);
 
 const logger = anylogger('slog-sender-pipe');
 
@@ -78,11 +77,11 @@ export const makeSlogSender = async opts => {
   /**
    * @typedef {{
    *   init: {
-   *     message: import('./slog-sender-pipe-entrypoint').InitMessage;
+   *     message: import('./slog-sender-pipe-entrypoint.js').InitMessage;
    *     reply: SlogSenderInitReply;
    *   };
    *   flush: {
-   *     message: import('./slog-sender-pipe-entrypoint').FlushMessage;
+   *     message: import('./slog-sender-pipe-entrypoint.js').FlushMessage;
    *     reply: SlogSenderFlushReply;
    *   };
    * }} SlogSenderWaitMessagesAndReplies

package/src/slog-to-otel.js

@@ -14,11 +14,8 @@ import {
 
 // diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.VERBOSE);
 
-/** @typedef {import('@opentelemetry/api').Span} Span */
-/** @typedef {import('@opentelemetry/api').Link} SpanLink */
-/** @typedef {import('@opentelemetry/api').SpanContext} SpanContext */
-/** @typedef {import('@opentelemetry/api').SpanOptions} SpanOptions */
-/** @typedef {import('@opentelemetry/api').SpanAttributes} SpanAttributes */
+/** @import {Span, Link as SpanLink} from '@opentelemetry/api' */
+/** @import {SpanContext, SpanOptions} from '@opentelemetry/api' */
 
 const { assign } = Object;
 
@@ -54,9 +51,9 @@ const serializeInto = (value, prefix, target = {}, depth = 3) => {
       } else {
         const proto = Object.getPrototypeOf(value);
         if (proto == null || proto === Object.prototype) {
-          Object.entries(value).forEach(([key, nested]) =>
-            serializeInto(nested, `${prefix}.${key}`, target, depth),
-          );
+          for (const [key, nested] of Object.entries(value)) {
+            serializeInto(nested, `${prefix}.${key}`, target, depth);
+          }
           return target;
         }
       }
@@ -142,7 +139,10 @@ export const makeSlogToOtelKit = (tracer, overrideAttrs = {}) => {
     serializeBodyFormat: 'smallcaps',
   });
 
-  /** @param {import('@agoric/swingset-vat').SwingSetCapData} data */
+  /**
+   * @param {import('@agoric/swingset-vat').SwingSetCapData} data
+   * @returns {any}
+   */
   const unserialize = data => {
     try {
       const body = rawUnserialize(data);

package/test/flight-recorder.test.js

@@ -0,0 +1,83 @@
+import fs from 'node:fs';
+import tmp from 'tmp';
+import { test } from './prepare-test-env-ava.js';
+
+import {
+  makeSimpleCircularBuffer,
+  makeSlogSenderFromBuffer,
+} from '../src/flight-recorder.js';
+
+// Factored this way to support multiple implementations, which at one point there were
+const bufferTests = test.macro(
+  /**
+   *
+   * @param {*} t
+   * @param {{makeBuffer: Function}} input
+   */
+  async (t, input) => {
+    const BUFFER_SIZE = 512;
+
+    const { name: tmpFile, removeCallback } = tmp.fileSync();
+    const { readCircBuf, writeCircBuf } = await input.makeBuffer({
+      circularBufferSize: BUFFER_SIZE,
+      circularBufferFilename: tmpFile,
+    });
+    const slogSender = makeSlogSenderFromBuffer({ writeCircBuf });
+    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);
+    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);
+    t.false(done0b, 'readCircBuf should not be done');
+    const buf0Str = new TextDecoder().decode(buf0);
+    t.is(buf0Str, `\n{"type":"start"}`, `start compare failed`);
+
+    const last = 500;
+    for (let i = 0; i < last; i += 1) {
+      slogSender({ type: 'iteration', iteration: i });
+      await slogSender.forceFlush();
+      t.is(
+        fs.readFileSync(tmpFile, { encoding: 'utf8' }).length,
+        BUFFER_SIZE,
+        `iteration ${i} length mismatch`,
+      );
+    }
+
+    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);
+      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);
+      offset += buf1.byteLength;
+      t.false(done1b, `readCircBuf ${i} should not be done`);
+      const buf1Str = new TextDecoder().decode(buf1);
+      t.is(
+        buf1Str,
+        `\n{"type":"iteration","iteration":${i}}`,
+        `iteration ${i} compare failed`,
+      );
+    }
+
+    const { done: done2 } = 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'));
+    // console.log({ tmpFile });
+    removeCallback();
+  },
+);
+
+test('simple', bufferTests, {
+  makeBuffer: makeSimpleCircularBuffer,
+});

package/test/prepare-test-env-ava.js

@@ -1,5 +1,3 @@
-import '@endo/init';
-
 import { wrapTest } from '@endo/ses-ava';
 import rawTest from 'ava';
 

package/{jsconfig.json → tsconfig.json}

@@ -1,6 +1,7 @@
 // This file can contain .js-specific Typescript compiler config.
 {
   "extends": "../../tsconfig.json",
+  "compilerOptions": {},
   "include": [
     "*.js",
     "scripts",

package/test/test-flight-recorder.js

@@ -1,53 +0,0 @@
-import tmp from 'tmp';
-import { test } from './prepare-test-env-ava.js';
-
-import { makeMemoryMappedCircularBuffer } from '../src/flight-recorder.js';
-
-test('flight-recorder sanity', async t => {
-  const { name: tmpFile, removeCallback } = tmp.fileSync();
-  const { writeJSON: slogSender, readCircBuf } =
-    await makeMemoryMappedCircularBuffer({
-      circularBufferSize: 512,
-      circularBufferFilename: tmpFile,
-    });
-  slogSender({ type: 'start' });
-
-  const len0 = new Uint8Array(BigUint64Array.BYTES_PER_ELEMENT);
-  const { done: done0 } = 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);
-  t.false(done0b, 'readCircBuf should not be done');
-  const buf0Str = new TextDecoder().decode(buf0);
-  t.is(buf0Str, `\n{"type":"start"}`, `start compare failed`);
-
-  const last = 500;
-  for (let i = 0; i < last; i += 1) {
-    slogSender({ type: 'iteration', iteration: i });
-  }
-
-  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);
-    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);
-    offset += buf1.byteLength;
-    t.false(done1b, `readCircBuf ${i} should not be done`);
-    const buf1Str = new TextDecoder().decode(buf1);
-    t.is(
-      buf1Str,
-      `\n{"type":"iteration","iteration":${i}}`,
-      `iteration ${i} compare failed`,
-    );
-  }
-
-  const { done: done2 } = readCircBuf(len1, offset);
-  t.assert(done2, `readCircBuf ${last} should be done`);
-  // console.log({ tmpFile });
-  removeCallback();
-});