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

package/CHANGELOG.md

@@ -3,45 +3,39 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
-### [0.6.3-u19.2](https://github.com/Agoric/agoric-sdk/compare/@agoric/telemetry@0.6.3-u19.1...@agoric/telemetry@0.6.3-u19.2) (2025-03-13)
-
-**Note:** Version bump only for package @agoric/telemetry
-
-
-
-
-
-### [0.6.3-u19.1](https://github.com/Agoric/agoric-sdk/compare/@agoric/telemetry@0.6.3-u19.0...@agoric/telemetry@0.6.3-u19.1) (2025-03-03)
-
-
-### Bug Fixes
-
-* Properly synchronize slog sender termination ([2fc342c](https://github.com/Agoric/agoric-sdk/commit/2fc342c180e296208d077a1d4799da139d3b7848))
-
-
-
-### [0.6.3-u19.0](https://github.com/Agoric/agoric-sdk/compare/@agoric/telemetry@0.6.2...@agoric/telemetry@0.6.3-u19.0) (2025-02-24)
+### [0.6.3-u21.0](https://github.com/Agoric/agoric-sdk/compare/@agoric/telemetry@0.6.2...@agoric/telemetry@0.6.3-u21.0) (2025-06-19)
 
 
 ### Features
 
+* Add the Prometheus slog sender module and load it per OTEL_EXPORTER_PROMETHEUS_PORT ([1dc1827](https://github.com/Agoric/agoric-sdk/commit/1dc182783ce191f0ba2131cb1f7b3042f287737a)), closes [#11045](https://github.com/Agoric/agoric-sdk/issues/11045)
 * **cosmic-swingset:** add JS upgrade plan handler stub ([655133e](https://github.com/Agoric/agoric-sdk/commit/655133ed909b5d632dc033e992214a7b6a1b5ab1))
+* **internal:** Add helper `unprefixedProperties` for environment variable consumption ([878fecf](https://github.com/Agoric/agoric-sdk/commit/878fecf4f5153fa80f48a27a8b79e67943b2d199))
 * simple CircularBuffer with fs offsets ([8d9cb7a](https://github.com/Agoric/agoric-sdk/commit/8d9cb7abe96e8905f5aaa0927e02914ef09279c4))
 * **telemetry:** context aware slog support new triggers ([03965d9](https://github.com/Agoric/agoric-sdk/commit/03965d90b86cf75ce7f6677861e3a0aa8ac70710))
 * **telemetry:** ingest-slog explicitly supports `-` for stdin ([63367c4](https://github.com/Agoric/agoric-sdk/commit/63367c4aaf9bafbd6553a1f4cb808c96bc90845a))
 * **telemetry:** ingest-slog throttle and flush per block ([2134944](https://github.com/Agoric/agoric-sdk/commit/21349448b3b9379a9da43218a59a7e7eaf4f5a9e))
+* **telemetry:** Update slog sender JSON serialization of error instances ([5db996d](https://github.com/Agoric/agoric-sdk/commit/5db996d99830e61fad6eed373e2fb2dc810d662e))
 * use writeSync slogSender ([47a2add](https://github.com/Agoric/agoric-sdk/commit/47a2adda72a5377eda181a425130cdc5a7fd7ff5))
 
 
 ### Bug Fixes
 
 * ensure script main rejections exit with error ([abdab87](https://github.com/Agoric/agoric-sdk/commit/abdab879014a5c3124ebd0e9246995ac6b1ce6e5))
+* Properly synchronize slog sender termination ([f83c01d](https://github.com/Agoric/agoric-sdk/commit/f83c01d89d80798e0922acdb498fcc7250560977))
 * **telemetry:** add missing slog type ([1aec8d0](https://github.com/Agoric/agoric-sdk/commit/1aec8d05036f6b3c3e3730339d1829da6b4a9051))
+* **telemetry:** async flight recorder read ([b7a19dd](https://github.com/Agoric/agoric-sdk/commit/b7a19dd9c106d9b31e6f9188f5d4df0bbb5132bf))
 * **telemetry:** avoid polluting stdout in ingest-slog ([d4b8dfa](https://github.com/Agoric/agoric-sdk/commit/d4b8dfa91155789f7ceda5cc3cef06019b9527e7))
 * **telemetry:** Empty context persisted when remaining beans are negative after run finish ([#10635](https://github.com/Agoric/agoric-sdk/issues/10635)) ([ad4e83e](https://github.com/Agoric/agoric-sdk/commit/ad4e83e0b6dff9716da91fd65d367d3acad1772e))
 * **telemetry:** event name typo ([9e19321](https://github.com/Agoric/agoric-sdk/commit/9e19321ea8fed32d445d44169b32f5d94a93d61e))
+* **telemetry:** Extend shutdown logic for slog-sender-pipe and otel-metrics ([7b8ccc8](https://github.com/Agoric/agoric-sdk/commit/7b8ccc82e641e5d11ccc6b8aebe524f75af829fe)), closes [#11175](https://github.com/Agoric/agoric-sdk/issues/11175)
+* **telemetry:** flight recorder flush does sync ([d270202](https://github.com/Agoric/agoric-sdk/commit/d2702028d77c06f3b4de91ca711a3c45c685a477))
+* **telemetry:** flight-recorder check second read size ([bfbacb2](https://github.com/Agoric/agoric-sdk/commit/bfbacb2b9f8de36f8f66b8cba8a88603fb7225e2))
+* **telemetry:** flight-recorder ignores write after shutdown ([3d2bcb3](https://github.com/Agoric/agoric-sdk/commit/3d2bcb3c56ac24a0f991200b223e6af8514dc5b8))
 * **telemetry:** handle new trigger slog events ([d32cb7e](https://github.com/Agoric/agoric-sdk/commit/d32cb7e9f406c25399321dc32e827b5018c38b69))
 * **telemetry:** ingest-slog avoid writing progress file for stdin ([62589ca](https://github.com/Agoric/agoric-sdk/commit/62589ca7b6d4aaa9eb7042f95ec7aec633db27f9))
+* **telemetry:** initialize empty flight-recorders ([0908258](https://github.com/Agoric/agoric-sdk/commit/0908258c159a18f2bace0f76fa25c485c0460d15))
+* **telemetry:** Launch a slog sender subprocess with the correct environment ([1a60955](https://github.com/Agoric/agoric-sdk/commit/1a60955181f4e8b02b3b0d5a2f213d4cb051d7d3))
 * **telemetry:** otel correctly pop upgrade span ([0ffdf00](https://github.com/Agoric/agoric-sdk/commit/0ffdf001bc8cbdc94081fedfeb4d2376902f4ffc)), closes [#8272](https://github.com/Agoric/agoric-sdk/issues/8272) [#9569](https://github.com/Agoric/agoric-sdk/issues/9569)
 * **telemetry:** silence slogfile write errors ([91089d7](https://github.com/Agoric/agoric-sdk/commit/91089d7273ef3d41555b34d84471120d45602497))
 * **telemetry:** timer-poll run.id ([#10672](https://github.com/Agoric/agoric-sdk/issues/10672)) ([3b478fb](https://github.com/Agoric/agoric-sdk/commit/3b478fb9e3fe7ded8dec1e83bab68760571f9071)), closes [#10357](https://github.com/Agoric/agoric-sdk/issues/10357) [#10357](https://github.com/Agoric/agoric-sdk/issues/10357)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/telemetry",
-  "version": "0.6.3-u19.2",
+  "version": "0.6.3-u21.0",
   "description": "Agoric's telemetry implementation",
   "type": "module",
   "repository": "https://github.com/Agoric/agoric-sdk",
@@ -11,9 +11,9 @@
     "test:c8": "c8 --all $C8_OPTIONS ava",
     "test:xs": "exit 0",
     "lint-fix": "yarn lint:eslint --fix",
-    "lint": "run-s --continue-on-error lint:*",
-    "lint:types": "tsc",
-    "lint:eslint": "eslint ."
+    "lint": "yarn run -T run-s --continue-on-error 'lint:*'",
+    "lint:types": "yarn run -T tsc",
+    "lint:eslint": "yarn run -T eslint ."
   },
   "bin": {
     "frcat": "./src/frcat-entrypoint.js"
@@ -22,12 +22,13 @@
   "author": "Agoric",
   "license": "Apache-2.0",
   "dependencies": {
-    "@agoric/internal": "^0.4.0-u19.2",
-    "@agoric/store": "^0.9.3-u19.0",
-    "@endo/errors": "^1.2.9",
-    "@endo/init": "^1.1.8",
-    "@endo/marshal": "^1.6.3",
-    "@endo/stream": "^1.2.9",
+    "@agoric/internal": "workspace:*",
+    "@agoric/store": "workspace:*",
+    "@endo/errors": "^1.2.10",
+    "@endo/init": "^1.1.9",
+    "@endo/marshal": "^1.6.4",
+    "@endo/promise-kit": "^1.1.10",
+    "@endo/stream": "^1.2.10",
     "@opentelemetry/api": "~1.9.0",
     "@opentelemetry/api-logs": "0.57.1",
     "@opentelemetry/exporter-logs-otlp-http": "0.57.1",
@@ -39,21 +40,21 @@
     "@opentelemetry/sdk-trace-base": "~1.30.1",
     "@opentelemetry/semantic-conventions": "~1.28.0",
     "anylogger": "^0.21.0",
-    "better-sqlite3": "^9.1.1",
+    "better-sqlite3": "^10.1.0",
     "tmp": "^0.2.1"
   },
   "devDependencies": {
-    "@endo/lockdown": "^1.0.14",
-    "@endo/ses-ava": "^1.2.9",
+    "@endo/lockdown": "^1.0.15",
+    "@endo/ses-ava": "^1.2.10",
     "ava": "^5.3.0",
-    "c8": "^10.1.2",
+    "c8": "^10.1.3",
     "tmp": "^0.2.1"
   },
   "publishConfig": {
     "access": "public"
   },
   "engines": {
-    "node": "^18.12 || ^20.9"
+    "node": "^20.9 || ^22.11"
   },
   "ava": {
     "files": [
@@ -66,7 +67,7 @@
     "workerThreads": false
   },
   "typeCoverage": {
-    "atLeast": 88.88
+    "atLeast": 88.83
   },
-  "gitHead": "f0ae74b84cb6de3724bfdcd18b4bea7e8199dee1"
+  "gitHead": "e4dd46857133403d584bcf822a81817b355532f9"
 }

package/src/flight-recorder.js

@@ -2,7 +2,6 @@
 /* eslint-env node */
 /// <reference types="ses" />
 
-import fs from 'node:fs';
 import fsp from 'node:fs/promises';
 import path from 'node:path';
 import { Fail } from '@endo/errors';
@@ -39,6 +38,9 @@ const initializeCircularBuffer = async (bufferFile, circularBufferSize) => {
     }
     throw e;
   });
+
+  // Use the default size if not provided and file doesn't exist.
+  circularBufferSize = circularBufferSize || stbuf?.size || DEFAULT_CBUF_SIZE;
   const arenaSize = BigInt(circularBufferSize - I_ARENA_START);
 
   if (stbuf && stbuf.size >= I_ARENA_START) {
@@ -77,7 +79,7 @@ const initializeCircularBuffer = async (bufferFile, circularBufferSize) => {
  * @param {(record: Uint8Array, firstWriteLength: number, circEnd: bigint) => Promise<void>} writeRecord
  */
 function makeCircBufMethods(arenaSize, header, readRecord, writeRecord) {
-  const readCircBuf = (outbuf, offset = 0) => {
+  const readCircBuf = async (outbuf, offset = 0) => {
     offset + outbuf.byteLength <= arenaSize ||
       Fail`Reading past end of circular buffer`;
 
@@ -99,7 +101,7 @@ function makeCircBufMethods(arenaSize, header, readRecord, writeRecord) {
       // The data is contiguous, like ---AAABBB---
       return { done: true, value: undefined };
     }
-    readRecord(outbuf, readStart, firstReadLength);
+    await readRecord(outbuf, readStart, firstReadLength);
     return { done: false, value: outbuf };
   };
 
@@ -143,9 +145,10 @@ function makeCircBufMethods(arenaSize, header, readRecord, writeRecord) {
 
     // Advance the start pointer until we have space to write the record.
     let overlap = BigInt(record.byteLength) - capacity;
+    await null;
     while (overlap > 0n) {
       const startRecordLength = new Uint8Array(RECORD_HEADER_SIZE);
-      const { done } = readCircBuf(startRecordLength);
+      const { done } = await readCircBuf(startRecordLength);
       if (done) {
         break;
       }
@@ -221,20 +224,22 @@ export const makeSimpleCircularBuffer = async ({
   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, {
+  /** @type {(outbuf: Uint8Array, readStart: number, firstReadLength: number) => Promise<void>} */
+  const readRecord = async (outbuf, readStart, firstReadLength) => {
+    const { bytesRead } = await file.read(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, {
+      const length = outbuf.byteLength - firstReadLength;
+      const { bytesRead: bytesRead2 } = await file.read(outbuf, {
         offset: firstReadLength,
-        length: outbuf.byteLength - firstReadLength,
+        length,
         position: I_ARENA_START,
       });
+      assert.equal(bytesRead2, length, 'Too few bytes read');
     }
   };
 
@@ -280,20 +285,23 @@ export const makeSimpleCircularBuffer = async ({
  * @param {Pick<CircularBuffer, 'fileHandle' | 'writeCircBuf'>} circBuf
  */
 export const makeSlogSenderFromBuffer = ({ fileHandle, writeCircBuf }) => {
-  /** @type {Promise<void>} */
+  /** @type {Promise<void> | undefined} */
   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));
+    toWrite = toWrite?.then(() => writeCircBuf(data));
   };
   return Object.assign(writeJSON, {
     forceFlush: async () => {
       await toWrite;
+      await fileHandle.datasync();
     },
     shutdown: async () => {
-      await toWrite;
+      const lastWritten = toWrite;
+      toWrite = undefined;
+      await lastWritten;
       await fileHandle.close();
     },
     usesJsonObject: true,

package/src/frcat-entrypoint.js

@@ -22,7 +22,7 @@ const main = async () => {
     let offset = 0;
     for (;;) {
       const lenBuf = new Uint8Array(BigUint64Array.BYTES_PER_ELEMENT);
-      const { done } = readCircBuf(lenBuf, offset);
+      const { done } = await readCircBuf(lenBuf, offset);
       if (done) {
         break;
       }
@@ -30,7 +30,7 @@ const main = async () => {
       const dv = new DataView(lenBuf.buffer);
       const len = Number(dv.getBigUint64(0));
 
-      const { done: done2, value: buf } = readCircBuf(
+      const { done: done2, value: buf } = await readCircBuf(
         new Uint8Array(len),
         offset,
       );

package/src/index.js

@@ -84,44 +84,37 @@ export const getResourceAttributes = ({
 
 /**
  * @typedef {object} Powers
- * @property {{ warn: Console['warn'] }} console
+ * @property {Pick<Console, 'warn'>} console
  * @property {NodeJS.ProcessEnv} env
  * @property {import('@opentelemetry/sdk-metrics').View[]} views
  * @property {string} [serviceName]
  */
 
 /**
- * @param {Partial<Powers>} param0
+ * @param {Partial<Powers>} powers
  */
-const getPrometheusMeterProvider = ({
+export const getPrometheusMeterProvider = ({
   console = globalThis.console,
   env = process.env,
   views,
   ...rest
 } = {}) => {
-  const { OTEL_EXPORTER_PROMETHEUS_PORT } = env;
-  if (!OTEL_EXPORTER_PROMETHEUS_PORT) {
-    // No Prometheus config, so don't install.
-    return undefined;
-  }
+  const { OTEL_EXPORTER_PROMETHEUS_HOST, OTEL_EXPORTER_PROMETHEUS_PORT } = env;
+
+  // The opt-in signal is a non-empty OTEL_EXPORTER_PROMETHEUS_PORT.
+  if (!OTEL_EXPORTER_PROMETHEUS_PORT) return;
 
   const resource = new Resource(getResourceAttributes({ env, ...rest }));
 
-  const port =
-    parseInt(OTEL_EXPORTER_PROMETHEUS_PORT || '', 10) ||
-    PrometheusExporter.DEFAULT_OPTIONS.port;
+  const { DEFAULT_OPTIONS } = PrometheusExporter;
+  const host = OTEL_EXPORTER_PROMETHEUS_HOST || DEFAULT_OPTIONS.host;
+  const port = +OTEL_EXPORTER_PROMETHEUS_PORT || DEFAULT_OPTIONS.port;
+  const url = `http://${host || '0.0.0.0'}:${port}${DEFAULT_OPTIONS.endpoint}`;
 
-  const exporter = new PrometheusExporter(
-    {
-      port,
-      appendTimestamp: true,
-    },
-    () => {
-      console.warn(
-        `Prometheus scrape endpoint: http://0.0.0.0:${port}${PrometheusExporter.DEFAULT_OPTIONS.endpoint}`,
-      );
-    },
-  );
+  const options = { host, port, appendTimestamp: true };
+  const exporter = new PrometheusExporter(options, () => {
+    console.warn(`Prometheus scrape endpoint: ${url}`);
+  });
 
   const provider = new MeterProvider({ resource, views });
   provider.addMetricReader(exporter);

package/src/make-slog-sender.js

@@ -1,13 +1,13 @@
 import path from 'path';
 import tmp from 'tmp';
-import { PromiseAllOrErrors } from '@agoric/internal';
+import { PromiseAllOrErrors, unprefixedProperties } from '@agoric/internal';
 import { serializeSlogObj } from './serialize-slog-obj.js';
 
+export const DEFAULT_SLOGSENDER_AGENT = 'self';
 export const DEFAULT_SLOGSENDER_MODULE =
   '@agoric/telemetry/src/flight-recorder.js';
 export const SLOGFILE_SENDER_MODULE = '@agoric/telemetry/src/slog-file.js';
-
-export const DEFAULT_SLOGSENDER_AGENT = 'self';
+export const PROMETHEUS_SENDER_MODULE = '@agoric/telemetry/src/prometheus.js';
 
 /** @import {SlogSender} from './index.js' */
 
@@ -19,6 +19,23 @@ export const DEFAULT_SLOGSENDER_AGENT = 'self';
 const filterTruthy = arr => /** @type {any[]} */ (arr.filter(Boolean));
 
 /**
+ * Create an aggregate slog sender that fans out inbound slog entries to modules
+ * as indicated by variables in the supplied `env` option. The SLOGSENDER value
+ * (or a default DEFAULT_SLOGSENDER_MODULE defined above) is split on commas
+ * into a list of module identifiers and adjusted by automatic insertions (a
+ * non-empty SLOGFILE value inserts DEFAULT_SLOGSENDER_AGENT defined above), and
+ * then each identifier is dynamically `import`ed for its own `makeSlogSender`
+ * export, which is invoked with a non-empty `stateDir` option and a modified
+ * `env` in which SLOGSENDER_AGENT_* variables have overridden their unprefixed
+ * equivalents to produce a subordinate slog sender.
+ * Subordinate slog senders remain isolated from each other, and any errors from
+ * them are caught and held until the next `forceFlush()` without disrupting
+ * any remaining slog entry fanout.
+ * If SLOGSENDER_AGENT is 'process', 'slog-sender-pipe.js' is used to load the
+ * subordinates in a child process rather than the main process.
+ * When there are no subordinates, the return value will be `undefined` rather
+ * than a slog sender function.
+ *
  * @type {import('./index.js').MakeSlogSender}
  */
 export const makeSlogSender = async (opts = {}) => {
@@ -26,95 +43,95 @@ export const makeSlogSender = async (opts = {}) => {
   const {
     SLOGSENDER = DEFAULT_SLOGSENDER_MODULE,
     SLOGSENDER_AGENT = DEFAULT_SLOGSENDER_AGENT,
+    // While cosmic-swingset/kernel code includes its own Prometheus metrics
+    // export, that trumps a slog sender module doing so.
+    // This extraction can be removed when that changes, but in the meantime,
+    // opt-in is only by SLOGSENDER_AGENT_OTEL_EXPORTER_PROMETHEUS_PORT.
+    OTEL_EXPORTER_PROMETHEUS_PORT: _prometheusExportPort,
     ...otherEnv
   } = env;
 
   const agentEnv = {
     ...otherEnv,
-    ...Object.fromEntries(
-      Object.entries(otherEnv)
-        .filter(([k]) => k.match(/^(?:SLOGSENDER_AGENT_)+/)) // narrow to SLOGSENDER_AGENT_ prefixes.
-        .map(([k, v]) => [k.replace(/^(?:SLOGSENDER_AGENT_)+/, ''), v]), // Rewrite SLOGSENDER_AGENT_ to un-prefixed version.
-    ),
+    ...unprefixedProperties(otherEnv, 'SLOGSENDER_AGENT_'),
   };
 
-  const slogSenderModules = [
-    ...new Set([
-      ...(agentEnv.SLOGFILE ? [SLOGFILE_SENDER_MODULE] : []),
-      ...SLOGSENDER.split(',')
-        .filter(Boolean)
-        .map(modulePath =>
-          modulePath.startsWith('.')
-            ? // Resolve relative to the current working directory.
-              path.resolve(modulePath)
-            : modulePath,
-        ),
-    ]),
-  ];
-
-  if (!slogSenderModules.length) {
+  const slogSenderModules = new Set();
+  if (agentEnv.OTEL_EXPORTER_PROMETHEUS_PORT) {
+    slogSenderModules.add(PROMETHEUS_SENDER_MODULE);
+  }
+  if (agentEnv.SLOGFILE) {
+    slogSenderModules.add(SLOGFILE_SENDER_MODULE);
+  }
+  for (const moduleIdentifier of filterTruthy(SLOGSENDER.split(','))) {
+    if (moduleIdentifier.startsWith('-')) {
+      // Opt out of an automatically-included sender.
+      slogSenderModules.delete(moduleIdentifier.slice(1));
+    } else if (moduleIdentifier.startsWith('.')) {
+      // Resolve relative to the current working directory.
+      slogSenderModules.add(path.resolve(moduleIdentifier));
+    } else {
+      slogSenderModules.add(moduleIdentifier);
+    }
+  }
+
+  if (!slogSenderModules.size) {
     return undefined;
   }
 
-  switch (SLOGSENDER_AGENT) {
-    case '':
-    case 'self':
-      break;
-    case 'process': {
-      console.warn('Loading slog sender in subprocess');
-      return import('./slog-sender-pipe.js').then(
-        async ({ makeSlogSender: makeSogSenderPipe }) =>
-          makeSogSenderPipe({
-            env: {
-              ...agentEnv,
-              SLOGSENDER,
-              SLOGSENDER_AGENT: 'self',
-            },
-            stateDir: stateDirOption,
-            ...otherOpts,
-          }),
-      );
-    }
-    case 'worker':
-    default:
-      console.warn(`Unknown SLOGSENDER_AGENT=${SLOGSENDER_AGENT}`);
+  if (SLOGSENDER_AGENT === 'process') {
+    console.warn('Loading slog sender in subprocess');
+    return import('./slog-sender-pipe.js').then(async module =>
+      module.makeSlogSender({
+        env: {
+          ...agentEnv,
+          SLOGSENDER,
+          SLOGSENDER_AGENT: 'self',
+        },
+        stateDir: stateDirOption,
+        ...otherOpts,
+      }),
+    );
+  } else if (SLOGSENDER_AGENT && SLOGSENDER_AGENT !== 'self') {
+    console.warn(
+      `Unknown SLOGSENDER_AGENT=${SLOGSENDER_AGENT}; defaulting to 'self'`,
+    );
   }
 
   if (SLOGSENDER) {
     console.warn('Loading slog sender modules:', ...slogSenderModules);
   }
 
-  const makersInfo = await Promise.all(
-    slogSenderModules.map(async moduleIdentifier =>
-      import(moduleIdentifier)
-        .then(
-          /** @param {{makeSlogSender: import('./index.js').MakeSlogSender}} module */ ({
-            makeSlogSender: maker,
-          }) => {
-            if (typeof maker !== 'function') {
-              return Promise.reject(
-                Error(`No 'makeSlogSender' function exported by module`),
-              );
-            } else if (maker === makeSlogSender) {
-              return Promise.reject(
-                Error(`Cannot recursively load 'makeSlogSender' aggregator`),
-              );
-            }
-
-            return /** @type {const} */ ([maker, moduleIdentifier]);
-          },
-        )
-        .catch(err => {
+  /** @type {Map<import('./index.js').MakeSlogSender, string>} */
+  const makerMap = new Map();
+  await Promise.all(
+    [...slogSenderModules].map(async moduleIdentifier => {
+      await null;
+      try {
+        const module = await import(moduleIdentifier);
+        const { makeSlogSender: maker } = module;
+        if (typeof maker !== 'function') {
+          throw Error(`No 'makeSlogSender' function exported by module`);
+        } else if (maker === makeSlogSender) {
+          throw Error(`Cannot recursively load 'makeSlogSender' aggregator`);
+        }
+        const isReplacing = makerMap.get(maker);
+        if (isReplacing) {
           console.warn(
-            `Failed to load slog sender from ${moduleIdentifier}.`,
-            err,
+            `The slog sender from ${moduleIdentifier} matches the one from ${isReplacing}.`,
           );
-          return undefined;
-        }),
-    ),
-  ).then(makerEntries => [...new Map(filterTruthy(makerEntries)).entries()]);
+        }
+        makerMap.set(maker, moduleIdentifier);
+      } catch (err) {
+        console.warn(
+          `Failed to load slog sender from ${moduleIdentifier}.`,
+          err,
+        );
+      }
+    }),
+  );
 
-  if (!makersInfo.length) {
+  if (!makerMap.size) {
     return undefined;
   }
 
@@ -122,11 +139,11 @@ export const makeSlogSender = async (opts = {}) => {
 
   if (stateDir === undefined) {
     stateDir = tmp.dirSync().name;
-    console.warn(`Using ${stateDir} for stateDir`);
+    console.warn(`Using ${stateDir} for slog sender stateDir`);
   }
 
   const senders = await Promise.all(
-    makersInfo.map(async ([maker, moduleIdentifier]) =>
+    [...makerMap.entries()].map(async ([maker, moduleIdentifier]) =>
       maker({
         ...otherOpts,
         stateDir,
@@ -137,37 +154,37 @@ export const makeSlogSender = async (opts = {}) => {
 
   if (!senders.length) {
     return undefined;
-  } else {
-    // Optimize creating a JSON serialization only if needed
-    // by any of the sender modules
-    const hasSenderUsingJsonObj = senders.some(
-      ({ usesJsonObject = true }) => usesJsonObject,
-    );
-    const getJsonObj = hasSenderUsingJsonObj
-      ? serializeSlogObj
-      : () => undefined;
-    const sendErrors = [];
-    /** @type {SlogSender} */
-    const slogSender = (slogObj, jsonObj = getJsonObj(slogObj)) => {
-      for (const sender of senders) {
-        try {
-          sender(slogObj, jsonObj);
-        } catch (err) {
-          sendErrors.push(err);
-        }
-      }
-    };
-    return Object.assign(slogSender, {
-      forceFlush: async () => {
-        await PromiseAllOrErrors([
-          ...senders.map(sender => sender.forceFlush?.()),
-          ...sendErrors.splice(0).map(err => Promise.reject(err)),
-        ]);
-      },
-      shutdown: async () => {
-        await PromiseAllOrErrors(senders.map(sender => sender.shutdown?.()));
-      },
-      usesJsonObject: hasSenderUsingJsonObj,
-    });
   }
+
+  // Optimize creating a JSON serialization only if needed
+  // by at least one of the senders.
+  const hasSenderUsingJsonObj = senders.some(
+    ({ usesJsonObject = true }) => usesJsonObject,
+  );
+  const getJsonObj = hasSenderUsingJsonObj ? serializeSlogObj : () => undefined;
+
+  const sendErrors = [];
+
+  /** @type {SlogSender} */
+  const slogSender = (slogObj, jsonObj = getJsonObj(slogObj)) => {
+    for (const sender of senders) {
+      try {
+        sender(slogObj, jsonObj);
+      } catch (err) {
+        sendErrors.push(err);
+      }
+    }
+  };
+  return Object.assign(slogSender, {
+    forceFlush: async () => {
+      await PromiseAllOrErrors([
+        ...senders.map(sender => sender.forceFlush?.()),
+        ...sendErrors.splice(0).map(err => Promise.reject(err)),
+      ]);
+    },
+    shutdown: async () => {
+      await PromiseAllOrErrors(senders.map(sender => sender.shutdown?.()));
+    },
+    usesJsonObject: hasSenderUsingJsonObj,
+  });
 };