@volter/supercode-health 0.1.14 → 0.1.15

package/lib/drift.mjs

@@ -71,7 +71,18 @@ export async function staleSupercode({ rows = null } = {}) {
     } else if (Number.isNaN(started) || installed <= started + 1000) continue; // ps says a start to the second
     stale.push({ pid: Number(pid), command: command.slice(0, 200), file, startedAt: new Date(started).toISOString(), installedAt: new Date(installed).toISOString() });
   }
-  return stale.sort((a, b) => b.installedAt.localeCompare(a.installedAt));
+  return moved(stale).sort((a, b) => b.installedAt.localeCompare(a.installedAt));
+}
+
+/** Less the processes that answer through the release on disk: an MCP server's pump says so in `<home>/run/mcp/<pid>`
+ *  once a child of the release an install put there answers for it (lib/mcp.mjs), at or after that install. */
+function moved(stale) {
+  const home = process.env.SUPERCODE_HOME || (process.env.XDG_CONFIG_HOME ? join(process.env.XDG_CONFIG_HOME, 'supercode') : join(homedir(), '.config', 'supercode'));
+  return stale.filter((row) => {
+    let said = null;
+    try { said = JSON.parse(readFileSync(join(home, 'run', 'mcp', String(row.pid)), 'utf8')); } catch { return true; }
+    return !(said?.pid === row.pid && Date.parse(said.at) >= Date.parse(row.installedAt));
+  });
 }
 
 /**

package/lib/probe.mjs

@@ -51,6 +51,9 @@ export class Probe {
     this.f = healthFiles(dir);
     this.machine = machineName(machine || env.SUPERCODE_HEALTH_MACHINE || hostname());
     this.state = {};
+    // what the last mail said of each alarm (key → its level, summary, detail): a mail says what changed since, never each
+    // flip in between (t_be880329: disk and memory flapping mailed the maintainer ~1,200 times a day on yuerans)
+    this.said = new Map(); this.changesMailAt = 0; this.raisedLastAt = new Map(); // key → when it was last seen raised
     this.unknowns = {}; this.unknownMailAt = {}; // unknownMailAt: a kind of unknown (unknownKind: its key's prefix) → last mailed
     this.lastHistory = 0;
     this.sampleMs = null;
@@ -99,6 +102,7 @@ export class Probe {
     // A raised alarm whose reading was unknown keeps its unknown since across the restart, as its unknowns entry does.
     for (const a of (previous?.alarms ?? []).filter((x) => !x.detail?.pid || alive(x.detail.pid))) this.state[a.key] = { key: a.key, family: a.family, level: a.level, warnSince: null, critSince: null, raisedAt: a.since ? Date.parse(a.since) : Date.now(), lastMailAt: this.droppedOutbox ? 0 : Date.now(), restoredUntil: Date.now() + 2 * 60_000, value: a.value, unit: a.unit, summary: a.summary, detail: a.detail,
       ...(a.unknown?.since ? { unread: a.unknown.why, unreadAt: Date.parse(a.unknown.since) } : {}) };
+    for (const a of (previous?.alarms ?? [])) this.said.set(a.key, { level: a.level, summary: a.summary, detail: a.detail ?? null });
   }
 
   /** Remove an earlier pack's outbox; answers how many mails it held, logged by recipient. */
@@ -138,7 +142,26 @@ export class Probe {
     const repeatMs = this.config.repeatMin * 60_000;
     // A raised alarm is reminded each repeatMin after it was last said: in a mail of its own transition or reminder, never
     // pushed back by a mail about something else.
-    const raisedNow = new Set(transitions.filter((t) => t.to !== 'none').map((t) => t.key));
+    // What changed since the last mail said it (net of every raise and clear between): said at most once each quietMin,
+    // a new crit at once, and with any mail going anyway (a reminder, an unknown due). A key that raised and cleared
+    // between two mails is never said.
+    const quietMs = (this.config.quietMin ?? 15) * 60_000;
+    const levels = new Map(alarms.map((a) => [a.key, a]));
+    const lastTransition = new Map(transitions.map((t) => [t.key, t]));
+    const net = [];
+    for (const a of alarms) {
+      const was = this.said.get(a.key)?.level ?? 'none';
+      if (was !== a.level) net.push({ key: a.key, from: was, to: a.level, value: a.value, unit: a.unit ?? null, summary: a.summary, detail: a.detail ?? null });
+    }
+    for (const a of alarms) this.raisedLastAt.set(a.key, now);
+    for (const [key, was] of this.said) {
+      if (levels.has(key)) continue;
+      // a clear is said once it has held a whole quiet window: an alarm that flaps is said raised once, never each clear
+      if (now - (this.raisedLastAt.get(key) ?? 0) < quietMs) continue;
+      const t = lastTransition.get(key);
+      net.push({ key, from: was.level, to: 'none', value: null, summary: t?.to === 'none' ? t.summary : `${was.summary} — cleared`, detail: t?.detail ?? was.detail });
+    }
+    const raisedNow = new Set(net.filter((t) => t.to !== 'none').map((t) => t.key));
     const reminders = alarms.filter((a) => !raisedNow.has(a.key) && now - (this.state[a.key].lastMailAt ?? 0) >= repeatMs);
     // A reading unknown for unknownMin is the maintainers' to know (raised or not), and again each repeatMin until read.
     // Timed per kind (a key's prefix; a family's whole key): a kind is due once its earliest key has been unknown
@@ -159,14 +182,25 @@ export class Probe {
     const to = subscribers(this.f, this.config);
     // after dropping an earlier pack's undelivered mail, the first mail states the whole current state, clears included
     const composedState = Boolean(this.droppedOutbox && to.length);
-    const mail = composedState ? composeState({ machine: this.machine, raised: alarms }) : compose({ machine: this.machine, transitions, reminders, raised: alarms, unknowns: unknownsDue });
+    const changesDue = net.length > 0 && (now - this.changesMailAt >= quietMs || net.some((t) => t.to === 'crit' && t.from !== 'crit') || reminders.length > 0 || unknownsDue.length > 0);
+    const changes = changesDue ? net : [];
+    const mail = composedState ? composeState({ machine: this.machine, raised: alarms }) : compose({ machine: this.machine, transitions: changes, reminders: reminders.filter((a) => !changes.some((t) => t.key === a.key)), raised: alarms, unknowns: unknownsDue });
     if (composedState) this.droppedOutbox = 0;
     if (mail) {
       // the kinds of unknown this mail said (the whole-state mail says none: they stay due)
       if (!composedState) for (const [kind] of dueKinds) this.unknownMailAt[kind] = now;
       // only the alarms this mail said: raised by it, or reminded (the whole-state mail says every one)
-      const said = composedState ? alarms : alarms.filter((a) => raisedNow.has(a.key) || reminders.includes(a));
+      const said = composedState ? alarms : alarms.filter((a) => (changes.length && raisedNow.has(a.key)) || reminders.includes(a));
       for (const a of said) this.state[a.key].lastMailAt = now;
+      // the state this mail said is what the next mail is measured from: the whole state, or the last one said with this
+      // mail's changes applied. A clear still in its hold was not said, so its alarm stays said raised until a mail
+      // says the clear (#1268 review P1: replacing it with the alarms raised now lost that clear for good)
+      if (composedState) this.said = new Map(alarms.map((a) => [a.key, { level: a.level, summary: a.summary, detail: a.detail ?? null }]));
+      else for (const t of changes) {
+        if (t.to === 'none') this.said.delete(t.key);
+        else this.said.set(t.key, { level: t.to, summary: t.summary, detail: t.detail ?? null });
+      }
+      if (composedState || changes.length) this.changesMailAt = now;
       this.log(`${mail.subject}${to.length ? '' : ' (no maintainer subscribed)'}\n${mail.body}`);
     }
     const snapshot = {

package/lib/thresholds.mjs

@@ -5,6 +5,7 @@ export const DEFAULTS = {
   slowIntervalSec: 60,      // disk space, services, the connector, tabs
   footprintTopEverySec: 300, // macOS: every user's largest footprints through top (about 2 s of top per run)
   repeatMin: 60,            // a raised alarm mails again this often (netdata's repeat cap)
+  quietMin: 15,             // what changed is mailed at most this often (a new crit at once): a flapping alarm is no stream
   unknownMin: 15,           // a reading unknown this long (raised or not) is mailed to the maintainers, and again each repeatMin
   historyHours: 24,
   daemons: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-health",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "type": "module",
   "description": "Optional machine pack: a cheap, deterministic probe of a machine's vitals that mails the machine's maintainer when a threshold is crossed. Each feature sits behind its own permission barrier.",
   "license": "MIT",