@agoric/swingset-vat 0.33.0-u19.2 → 0.33.0-u20.0

package/src/controller/startNodeSubprocess.js

@@ -13,6 +13,12 @@ export function makeStartSubprocessWorkerNode(
     ).pathname;
     const args = nodeOptions ? [...nodeOptions] : [];
     if (profileVats.includes(vatID)) {
+      // Enable profiling with a 1 microsecond sampling interval,
+      // saving results to a file in the working directory
+      // with a portable name derived from the vat name
+      // and in particular replacing any colons with dashes.
+      // cf. ../kernel/vat-loader/manager-subprocess-node.js
+      // https://github.com/Agoric/agoric-sdk/blob/18d561f1b95755e58ca691b26938fc249618018d/packages/SwingSet/src/kernel/vat-loader/manager-subprocess-node.js#L32-L34
       args.push('--cpu-prof');
       args.push('--cpu-prof-interval');
       args.push('1');

package/src/kernel/kernel.js

@@ -99,6 +99,7 @@ export default function buildKernel(
     startSubprocessWorkerNode,
     startXSnap,
     writeSlogObject,
+    slogDuration,
     WeakRef,
     FinalizationRegistry,
     gcAndFinalize,
@@ -111,11 +112,12 @@ export default function buildKernel(
     overrideVatManagerOptions = {},
   } = kernelRuntimeOptions;
   const logStartup = verbose ? console.debug : () => {};
+  if (verbose) kdebugEnable(true);
 
   const vatAdminRootKref = kernelStorage.kvStore.get('vatAdminRootKref');
 
   const kernelSlog = writeSlogObject
-    ? makeSlogger(slogCallbacks, writeSlogObject)
+    ? makeSlogger(slogCallbacks, writeSlogObject, slogDuration)
     : makeDummySlogger(slogCallbacks, makeConsole('disabled slogger'));
 
   const kernelKeeper = makeKernelKeeper(
@@ -559,6 +561,10 @@ export default function buildKernel(
    */
   async function processSend(vatID, target, msg) {
     insistMessage(msg);
+    // DEPRECATED: These counts are available as "crank-start"/"crank-finish"
+    // slog entries with crankType "delivery" (the latter count filtered on
+    // messageType "send") and "deliver"/"deliver-result" slog entries (the
+    // latter count filtered on dispatch "message").
     kernelKeeper.incStat('dispatches');
     kernelKeeper.incStat('dispatchDeliver');
 
@@ -589,6 +595,8 @@ export default function buildKernel(
     const { vatID, kpid } = message;
     insistVatID(vatID);
     insistKernelType('promise', kpid);
+    // DEPRECATED: This count is available as "crank-start"/"crank-finish"
+    // slog entries with crankType "delivery".
     kernelKeeper.incStat('dispatches');
     const vatInfo = vatWarehouse.lookup(vatID);
     if (!vatInfo) {
@@ -598,6 +606,8 @@ export default function buildKernel(
     const { meterID } = vatInfo;
 
     const p = kernelKeeper.getKernelPromise(kpid);
+    // DEPRECATED: This count is available as "deliver"/"deliver-result" slog
+    // entries with dispatch "notify".
     kernelKeeper.incStat('dispatchNotify');
     const vatKeeper = kernelKeeper.provideVatKeeper(vatID);
     if (p.state === 'unresolved') {
@@ -1342,14 +1352,15 @@ export default function buildKernel(
    * @returns {Promise<PolicyInput>}
    */
   async function processDeliveryMessage(message) {
+    const messageType = message.type;
     kdebug('');
     // prettier-ignore
     kdebug(`processQ crank ${kernelKeeper.getCrankNumber()} ${JSON.stringify(message)}`);
     kdebug(legibilizeMessage(message));
-    kernelSlog.write({
-      type: 'crank-start',
+    const finish = kernelSlog.startDuration(['crank-start', 'crank-finish'], {
       crankType: 'delivery',
       crankNum: kernelKeeper.getCrankNumber(),
+      messageType,
       message,
     });
     /** @type { PolicyInput } */
@@ -1451,12 +1462,8 @@ export default function buildKernel(
     const crankNum = kernelKeeper.getCrankNumber();
     kernelKeeper.incrementCrankNumber();
     const { crankhash, activityhash } = kernelKeeper.emitCrankHashes();
-    // kernelSlog.write({
-    //   type: 'kernel-stats',
-    //   stats: kernelKeeper.getStats(),
-    // });
-    kernelSlog.write({
-      type: 'crank-finish',
+    finish({
+      message: undefined,
       crankNum,
       crankhash,
       activityhash,
@@ -1494,14 +1501,15 @@ export default function buildKernel(
    * @returns {Promise<PolicyInput>}
    */
   async function processAcceptanceMessage(message) {
+    const messageType = message.type;
     kdebug('');
     // prettier-ignore
-    kdebug(`processAcceptanceQ crank ${kernelKeeper.getCrankNumber()} ${message.type}`);
+    kdebug(`processAcceptanceQ crank ${kernelKeeper.getCrankNumber()} ${messageType}`);
     // kdebug(legibilizeMessage(message));
-    kernelSlog.write({
-      type: 'crank-start',
+    const finish = kernelSlog.startDuration(['crank-start', 'crank-finish'], {
       crankType: 'routing',
       crankNum: kernelKeeper.getCrankNumber(),
+      messageType,
       message,
     });
     /** @type { PolicyInput } */
@@ -1538,8 +1546,8 @@ export default function buildKernel(
     const crankNum = kernelKeeper.getCrankNumber();
     kernelKeeper.incrementCrankNumber();
     const { crankhash, activityhash } = kernelKeeper.emitCrankHashes();
-    kernelSlog.write({
-      type: 'crank-finish',
+    finish({
+      message: undefined,
       crankNum,
       crankhash,
       activityhash,
@@ -2161,6 +2169,11 @@ export default function buildKernel(
       ephemeral.log.push(`${str}`);
     },
 
+    /**
+     * Return a fresh stats snapshot.
+     *
+     * @returns {Record<string, number>}
+     */
     getStats() {
       return kernelKeeper.getStats();
     },

package/src/kernel/slogger.js

@@ -1,9 +1,12 @@
-import { q } from '@endo/errors';
+import { q, Fail } from '@endo/errors';
+import { makePromiseKit } from '@endo/promise-kit';
 import { objectMap } from '@agoric/internal';
+import { defineName } from '@agoric/internal/src/js-utils.js';
 import { makeLimitedConsole } from '@agoric/internal/src/ses-utils.js';
 
 /** @import {Callable} from '@agoric/internal'; */
 /** @import {LimitedConsole} from '@agoric/internal/src/js-utils.js'; */
+/** @import {SlogProps, SlogDurationProps, SwingsetController} from '../controller/controller.js'; */
 
 const IDLE = 'idle';
 const STARTUP = 'startup';
@@ -12,7 +15,7 @@ const DELIVERY = 'delivery';
 const noopFinisher = harden(() => {});
 
 /** @typedef {(...finishArgs: unknown[]) => unknown} AnyFinisher */
-/** @typedef {Partial<Record<Exclude<keyof KernelSlog, 'write'>, (methodName: string, args: unknown[], finisher: AnyFinisher) => unknown>>} SlogWrappers */
+/** @typedef {Partial<Record<Exclude<keyof KernelSlog, 'write' | 'startDuration'>, (methodName: string, args: unknown[], finisher: AnyFinisher) => unknown>>} SlogWrappers */
 
 /**
  * Support asynchronous slog callbacks that are invoked at the start
@@ -96,24 +99,81 @@ export function makeDummySlogger(slogCallbacks, dummyConsole = badConsole) {
     changeCList: () => noopFinisher,
     terminateVat: () => noopFinisher,
   });
-  return harden({ ...wrappedMethods, write: noopFinisher });
+  return harden({
+    ...wrappedMethods,
+    write: noopFinisher,
+    startDuration: () => noopFinisher,
+  });
 }
 
+/**
+ * @callback StartDuration
+ * Capture an extended process, writing an entry with `type` $startLabel and
+ * then later (when the returned finish function is called) another entry with
+ * `type` $endLabel and `seconds` reporting the intervening duration.
+ *
+ * @param {readonly [startLabel: string, endLabel: string]} labels
+ * @param {SlogDurationProps} startProps
+ * @returns {import('../types-external').FinishSlogDuration}
+ */
+
 /**
  * @param {SlogWrappers} slogCallbacks
- * @param {(obj: object) => void} [writeObj]
+ * @param {SwingsetController['writeSlogObject']} [writeSlogObject]
+ * @param {SwingsetController['slogDuration']} [slogDuration] required when writeSlogObject is provided
  * @returns {KernelSlog}
  */
-export function makeSlogger(slogCallbacks, writeObj) {
-  const safeWrite = writeObj
-    ? obj => {
-        try {
-          writeObj(obj);
-        } catch (err) {
-          console.error('WARNING: slogger write error', err);
+export function makeSlogger(slogCallbacks, writeSlogObject, slogDuration) {
+  if (writeSlogObject && !slogDuration) {
+    throw Fail`slogDuration is required with writeSlogObject`;
+  }
+  const { safeWrite, startDuration } = (() => {
+    if (!writeSlogObject) {
+      const dummySafeWrite = () => {};
+      /** @type {StartDuration} */
+      const dummyStartDuration = () => defineName('dummyFinish', () => {});
+      return { safeWrite: dummySafeWrite, startDuration: dummyStartDuration };
+    }
+    /** @type {(obj: SlogProps) => void} */
+    // eslint-disable-next-line no-shadow
+    const safeWrite = obj => {
+      try {
+        writeSlogObject(obj);
+      } catch (err) {
+        console.error('WARNING: slogger write error', err);
+      }
+    };
+    /** @type {StartDuration} */
+    // eslint-disable-next-line no-shadow
+    const startDuration = (labels, startProps) => {
+      try {
+        /** @type {(extraProps?: SlogDurationProps) => void} */
+        let closeSpan;
+        // @ts-expect-error TS2722 slogDuration is not undefined here
+        void slogDuration(labels, startProps, async finish => {
+          const doneKit = makePromiseKit();
+          closeSpan = props => {
+            try {
+              finish(props);
+            } finally {
+              doneKit.resolve(undefined);
+            }
+          };
+          // Hold the span open until `finish` is called.
+          await doneKit.promise;
+        });
+        // @ts-expect-error TS2454 closeSpan must have been assigned above
+        if (typeof closeSpan !== 'function') {
+          throw Fail`slogDuration did not synchronously provide a finisher`;
         }
+        return closeSpan;
+      } catch (err) {
+        console.error('WARNING: slogger write error', err);
+        return defineName('dummyFinish', () => {});
       }
-    : () => {};
+    };
+    return { safeWrite, startDuration };
+  })();
 
   const vatSlogs = new Map(); // vatID -> vatSlog
 
@@ -149,15 +209,17 @@ export function makeSlogger(slogCallbacks, writeObj) {
 
     function startup() {
       // provide a context for console calls during startup
-      checkOldState(IDLE, 'did startup get called twice?');
+      checkOldState(IDLE, 'vat-startup called twice?');
       state = STARTUP;
-      safeWrite({ type: 'vat-startup-start', vatID });
-      function finish() {
-        checkOldState(STARTUP, 'startup-finish called twice?');
+      const finish = startDuration(
+        ['vat-startup-start', 'vat-startup-finish'],
+        { vatID },
+      );
+      return harden(() => {
+        checkOldState(STARTUP, 'vat-startup-finish called twice?');
         state = IDLE;
-        safeWrite({ type: 'vat-startup-finish', vatID });
-      }
-      return harden(finish);
+        finish();
+      });
     }
 
     // kd: kernelDelivery, vd: vatDelivery
@@ -167,32 +229,44 @@ export function makeSlogger(slogCallbacks, writeObj) {
       crankNum = newCrankNum;
       deliveryNum = newDeliveryNum;
       replay = inReplay;
-      const when = { crankNum, vatID, deliveryNum, replay };
-      safeWrite({ type: 'deliver', ...when, kd, vd });
       syscallNum = 0;
-
+      const dispatch = vd?.[0]; // using vd because kd is undefined in replay
+      const finish = startDuration(['deliver', 'deliver-result'], {
+        crankNum,
+        vatID,
+        deliveryNum,
+        replay,
+        dispatch,
+        kd,
+        vd,
+      });
       // dr: deliveryResult
-      function finish(dr) {
-        checkOldState(DELIVERY, 'delivery-finish called twice?');
-        safeWrite({ type: 'deliver-result', ...when, dr });
+      return harden(dr => {
+        checkOldState(DELIVERY, 'deliver-result called twice?');
         state = IDLE;
-      }
-      return harden(finish);
+        finish({ kd: undefined, vd: undefined, dr });
+      });
     }
 
     // ksc: kernelSyscallObject, vsc: vatSyscallObject
     function syscall(ksc, vsc) {
       checkOldState(DELIVERY, 'syscall invoked outside of delivery');
-      const when = { crankNum, vatID, deliveryNum, syscallNum, replay };
-      safeWrite({ type: 'syscall', ...when, ksc, vsc });
+      const finish = startDuration(['syscall', 'syscall-result'], {
+        crankNum,
+        vatID,
+        deliveryNum,
+        syscallNum,
+        replay,
+        syscall: vsc?.[0],
+        ksc,
+        vsc,
+      });
       syscallNum += 1;
-
       // ksr: kernelSyscallResult, vsr: vatSyscallResult
-      function finish(ksr, vsr) {
+      return harden((ksr, vsr) => {
         checkOldState(DELIVERY, 'syscall finished after delivery?');
-        safeWrite({ type: 'syscall-result', ...when, ksr, vsr });
-      }
-      return harden(finish);
+        finish({ ksc: undefined, vsc: undefined, ksr, vsr });
+      });
     }
 
     // mode: 'import' | 'export' | 'drop'
@@ -258,5 +332,5 @@ export function makeSlogger(slogCallbacks, writeObj) {
     terminateVat: (vatID, ...args) =>
       provideVatSlogger(vatID).vatSlog.terminateVat(...args),
   });
-  return harden({ ...wrappedMethods, write: safeWrite });
+  return harden({ ...wrappedMethods, write: safeWrite, startDuration });
 }

package/src/kernel/state/kernelKeeper.js

@@ -1,5 +1,6 @@
 import { Nat, isNat } from '@endo/nat';
 import { assert, Fail } from '@endo/errors';
+import { KERNEL_STATS_METRICS } from '@agoric/internal/src/metrics.js';
 import { naturalCompare } from '@agoric/internal/src/natural-sort.js';
 import { makeDummySlogger, noopConsole } from '../slogger.js';
 import {
@@ -25,7 +26,6 @@ import {
   makeUpgradeID,
 } from '../../lib/id.js';
 import { kdebug } from '../../lib/kdebug.js';
-import { KERNEL_STATS_METRICS } from '../metrics.js';
 import { makeKernelStats } from './stats.js';
 import {
   enumeratePrefixedKeys,

package/src/kernel/state/stats.js

@@ -70,10 +70,9 @@ export const makeKernelStats = kernelStatsMetrics => {
   Object.freeze(allStatsKeys);
 
   const pickStats = (stat, gauge = false) => {
-    assert(
-      kernelConsensusStats && kernelLocalStats,
-      'Kernel stats not initialized',
-    );
+    if (!kernelConsensusStats || !kernelLocalStats) {
+      throw Fail`Kernel stats not initialized`;
+    }
     const metricType = allStatsKeys[stat];
     if (gauge) {
       metricType === 'gauge' || Fail`Invalid kernel gauge stat ${stat}`;
@@ -116,7 +115,12 @@ export const makeKernelStats = kernelStatsMetrics => {
     kernelStats[downStat] += delta;
   };
 
-  /** @param {boolean | undefined} [consensusOnly] */
+  /**
+   * Return a fresh snapshot, with or without local stats.
+   *
+   * @param {boolean | undefined} [consensusOnly]
+   * @returns {Record<string, number>}
+   */
   const getStats = consensusOnly => {
     return {
       ...(consensusOnly ? {} : kernelLocalStats),
@@ -130,10 +134,9 @@ export const makeKernelStats = kernelStatsMetrics => {
   };
 
   const getSerializedStats = () => {
-    assert(
-      kernelConsensusStats && kernelLocalStats,
-      'Kernel stats not initialized',
-    );
+    if (!kernelConsensusStats || !kernelLocalStats) {
+      throw Fail`Kernel stats not initialized`;
+    }
 
     return {
       consensusStats: JSON.stringify(kernelConsensusStats),

package/src/kernel/state/storageHelper.js

@@ -2,6 +2,10 @@
 
 import { Fail } from '@endo/errors';
 
+/**
+ * @import {KVStore} from '@agoric/swing-store';
+ */
+
 /**
  * Iterate over keys with a given prefix, in lexicographic order,
  * excluding an exact match of the prefix.

package/src/kernel/vat-warehouse.js

@@ -299,7 +299,10 @@ export function makeVatWarehouse({
    */
   async function replayTranscript(vatID, vatKeeper, manager) {
     const total = vatKeeper.transcriptSize();
-    kernelSlog.write({ type: 'start-replay', vatID, deliveries: total });
+    const finish = kernelSlog.startDuration(['start-replay', 'finish-replay'], {
+      vatID,
+      deliveries: total,
+    });
     let first = true;
     for await (const [deliveryNum, te] of vatKeeper.getTranscript()) {
       // if (deliveryNum % 100 === 0) {
@@ -326,7 +329,7 @@ export function makeVatWarehouse({
       finishSlog(status);
       sim.finishSimulation(); // will throw if syscalls did not match
     }
-    kernelSlog.write({ type: 'finish-replay', vatID });
+    finish({ deliveries: undefined });
   }
 
   /**

package/src/lib/message.js

@@ -1,6 +1,10 @@
 import { assert, Fail } from '@endo/errors';
 import { insistCapData } from './capdata.js';
 
+/**
+ * @import {VatSyscallObject, VatSyscallResult, VatDeliveryResult} from '@agoric/swingset-liveslots';
+ */
+
 /**
  * Assert function to ensure that something expected to be a message object
  * actually is.  A message object should have a .method property that's a

package/src/types-external.js

@@ -5,6 +5,7 @@ export {};
  * @import {ERef} from '@endo/far';
  * @import {Passable, RemotableObject} from '@endo/pass-style';
  * @import {LimitedConsole} from '@agoric/internal/src/js-utils.js';
+ * @import {SlogProps, SlogDurationProps} from './controller/controller.js';
  */
 
 /* This file defines types that part of the external API of swingset. That
@@ -12,18 +13,23 @@ export {};
  * with, like VatAdminService. */
 
 /**
- * @typedef {'getExport' | 'nestedEvaluate' | 'endoZipBase64'} BundleFormat
+ * @typedef {(extraProps?: SlogDurationProps) => void} FinishSlogDuration
  */
 
 /**
  * @typedef {import('@endo/marshal').CapData<string>} SwingSetCapData
  */
 
+// TODO move Bundle types into Endo
 /**
+ * @typedef {'getExport' | 'nestedEvaluate' | 'endoZipBase64'} BundleFormat
  * @typedef { { moduleFormat: 'getExport', source: string, sourceMap?: string } } GetExportBundle
  * @typedef { { moduleFormat: 'nestedEvaluate', source: string, sourceMap?: string } } NestedEvaluateBundle
- * @typedef { EndoZipBase64Bundle | GetExportBundle | NestedEvaluateBundle } Bundle
- *
+ * @typedef { { moduleFormat: 'test' } } TestBundle
+ * @typedef { EndoZipBase64Bundle | GetExportBundle | NestedEvaluateBundle | TestBundle} Bundle
+ */
+
+/**
  * @typedef { 'local' | 'node-subprocess' | 'xsnap' | 'xs-worker' } ManagerType
  */
 
@@ -128,7 +134,9 @@ export {};
  * @typedef { Awaited<ReturnType<typeof import('@agoric/xsnap').xsnap>> } XSnap
  * @typedef { (dr: VatDeliveryResult) => void } SlogFinishDelivery
  * @typedef { (ksr: KernelSyscallResult, vsr: VatSyscallResult) => void } SlogFinishSyscall
- * @typedef { { write: ({}) => void,
+ * @typedef { { write: (obj: SlogProps) => void,
+ *              startDuration:     (labels: readonly [startLabel: string, endLabel: string],
+ *                                  startProps: SlogDurationProps) => FinishSlogDuration,
  *              provideVatSlogger: (vatID: string,
  *                                  dynamic?: boolean,
  *                                  description?: string,

package/src/vats/plugin-manager.js

@@ -6,8 +6,7 @@ import { Remotable } from '@endo/marshal';
 import { Far, E } from '@endo/far';
 
 /**
- * @template T
- * @typedef {T | PromiseLike<T>} ERef
+ * @import {ERef} from '@endo/far';
  */
 
 /** @type {{ onReset: (firstTime: Promise<boolean>) => void}} */

package/tools/run-utils.js

@@ -15,9 +15,10 @@ import { makeQueue } from '@endo/stream';
  */
 export const makeRunUtils = (controller, harness) => {
   const mutex = makeQueue();
+  mutex.put('dummy result'); // so the first `await mutex.get()` doesn't hang
+
   const logRunFailure = reason =>
     console.log('controller.run() failure', reason);
-  mutex.put(controller.run().catch(logRunFailure));
 
   /**
    * Wait for exclusive access to the controller, then before relinquishing that access,

package/src/kernel/metrics.js

@@ -1,152 +0,0 @@
-// All the kernel metrics we are prepared for.
-export const KERNEL_STATS_SUM_METRICS = /** @type {const} */ ([
-  {
-    key: 'syscalls',
-    name: 'swingset_all_syscall_total',
-    description: 'Total number of SwingSet kernel calls',
-  },
-  {
-    key: 'syscallSend',
-    name: 'swingset_syscall_total',
-    sub: { dimension: 'syscall', value: 'send' },
-    description: 'Total number of SwingSet message send kernel calls',
-  },
-  {
-    key: 'syscallCallNow',
-    name: 'swingset_syscall_total',
-    sub: { dimension: 'syscall', value: 'callNow' },
-    description: 'Total number of SwingSet synchronous device kernel calls',
-  },
-  {
-    key: 'syscallSubscribe',
-    name: 'swingset_syscall_total',
-    sub: { dimension: 'syscall', value: 'subscribe' },
-    description: 'Total number of SwingSet promise subscription kernel calls',
-  },
-  {
-    key: 'syscallResolve',
-    name: 'swingset_syscall_total',
-    sub: { dimension: 'syscall', value: 'resolve' },
-    description: 'Total number of SwingSet promise resolution kernel calls',
-  },
-  {
-    key: 'syscallExit',
-    name: 'swingset_syscall_total',
-    sub: { dimension: 'syscall', value: 'exit' },
-    description: 'Total number of SwingSet vat exit kernel calls',
-  },
-  {
-    key: 'syscallVatstoreGet',
-    name: 'swingset_syscall_total',
-    sub: { dimension: 'syscall', value: 'vatstoreGet' },
-    description: 'Total number of SwingSet vatstore get kernel calls',
-  },
-  {
-    key: 'syscallVatstoreSet',
-    name: 'swingset_syscall_total',
-    sub: { dimension: 'syscall', value: 'vatstoreSet' },
-    description: 'Total number of SwingSet vatstore set kernel calls',
-  },
-  {
-    key: 'syscallVatstoreGetNextKey',
-    name: 'swingset_syscall_total',
-    sub: { dimension: 'syscall', value: 'vatstoreGetNext' },
-    description: 'Total number of SwingSet vatstore getNextKey kernel calls',
-  },
-  {
-    key: 'syscallVatstoreDelete',
-    name: 'swingset_syscall_total',
-    sub: { dimension: 'syscall', value: 'vatstoreDelete' },
-    description: 'Total number of SwingSet vatstore delete kernel calls',
-  },
-  {
-    key: 'syscallDropImports',
-    name: 'swingset_syscall_total',
-    sub: { dimension: 'syscall', value: 'dropImports' },
-    description: 'Total number of SwingSet drop imports kernel calls',
-  },
-  {
-    key: 'dispatches',
-    name: 'swingset_dispatch_total',
-    description: 'Total number of SwingSet vat calls',
-  },
-  {
-    key: 'dispatchDeliver',
-    name: 'swingset_dispatch_deliver_total',
-    description: 'Total number of SwingSet vat message deliveries',
-  },
-  {
-    key: 'dispatchNotify',
-    name: 'swingset_dispatch_notify_total',
-    description: 'Total number of SwingSet vat promise notifications',
-  },
-]);
-
-export const KERNEL_STATS_UPDOWN_METRICS = /** @type {const} */ ([
-  {
-    key: 'kernelObjects',
-    name: 'swingset_kernel_objects',
-    description: 'Active kernel objects',
-  },
-  {
-    key: 'kernelDevices',
-    name: 'swingset_kernel_devices',
-    description: 'Active kernel devices',
-  },
-  {
-    key: 'kernelPromises',
-    name: 'swingset_kernel_promises',
-    description: 'Active kernel promises',
-  },
-  {
-    key: 'kpUnresolved',
-    name: 'swingset_unresolved_kernel_promises',
-    description: 'Unresolved kernel promises',
-  },
-  {
-    key: 'kpFulfilled',
-    name: 'swingset_fulfilled_kernel_promises',
-    description: 'Fulfilled kernel promises',
-  },
-  {
-    key: 'kpRejected',
-    name: 'swingset_rejected_kernel_promises',
-    description: 'Rejected kernel promises',
-  },
-  {
-    key: 'runQueueLength',
-    name: 'swingset_run_queue_length',
-    consensus: true,
-    description: 'Length of the kernel run queue',
-  },
-  {
-    key: 'acceptanceQueueLength',
-    name: 'swingset_acceptance_queue_length',
-    consensus: true,
-    description: 'Length of the kernel acceptance queue',
-  },
-  {
-    key: 'promiseQueuesLength',
-    name: 'swingset_promise_queues_length',
-    consensus: true,
-    description: 'Combined length of all kernel promise queues',
-  },
-  {
-    key: 'clistEntries',
-    name: 'swingset_clist_entries',
-    description: 'Number of entries in the kernel c-list',
-  },
-  {
-    key: 'vats',
-    name: 'swingset_vats',
-    description: 'Number of active vats',
-  },
-]);
-
-const COUNTER = /** @type {const} */ ('counter');
-const GAUGE = /** @type {const} */ ('gauge');
-
-export const KERNEL_STATS_METRICS = harden([
-  ...KERNEL_STATS_SUM_METRICS.map(m => ({ ...m, metricType: COUNTER })),
-  ...KERNEL_STATS_UPDOWN_METRICS.map(m => ({ ...m, metricType: GAUGE })),
-]);