@daemonitor/plugins 1.1.37 → 1.1.39

package/dist/lib/processes.js

@@ -1,7 +1,10 @@
-// Aggregate named service processes (nginx, php-fpm, db, …) from `ps` output.
-// Used for host processes (OSPlugin) and per-container processes (LxcPlugin via
-// `lxc exec … ps`). MEM (rss) is exact; CPU is `ps` %cpu, which is the average
-// over each process's lifetime — a rough indicator for long-running daemons.
+// Aggregate named service processes (nginx, php-fpm, db, …). A Linux host's
+// come from /proc (sampleProcesses), with CPU measured over the time since
+// the last sample, so a graph of it moves. Everywhere else, and a container's
+// (LxcPlugin via `lxc exec … ps`), from `ps` output, whose %cpu is the average
+// over each process's lifetime: for a daemon up for months it never moves.
+import { execSync } from "node:child_process";
+import { readdirSync, readFileSync } from "node:fs";
 // The command whose output parseProcesses() expects (headerless: comm rss pcpu).
 export const PS_CMD = "ps -eo comm=,rss=,pcpu=";
 const WATCH = [
@@ -12,6 +15,106 @@ const WATCH = [
     { key: "redis", test: (c) => c.startsWith("redis-server") || c.startsWith("redis") },
     { key: "node", test: (c) => c.startsWith("node") },
 ];
+/**
+ * Parse /proc/<pid>/stat. Its comm is in parentheses and may hold spaces or
+ * a ')' of its own, so the fields are counted from after the last ')': the
+ * first one there is field 3 (state), so utime (14) is index 11.
+ */
+export function parseStat(pid, text) {
+    const open = text.indexOf("("), close = text.lastIndexOf(")");
+    if (open < 0 || close < open)
+        return null;
+    const f = text.slice(close + 2).trim().split(/\s+/);
+    const utime = Number(f[11]), stime = Number(f[12]), start = Number(f[19]), rss = Number(f[21]);
+    if (![utime, stime, start, rss].every(Number.isFinite))
+        return null;
+    return { pid, comm: text.slice(open + 1, close), ticks: utime + stime, rss, start };
+}
+/**
+ * Group processes by WATCH, each group's cpu as a percent of one core. With
+ * `prev` (each pid's ticks at the last sample, `dt` seconds ago), over that
+ * interval; a pid that wasn't there then started since, so all its ticks are
+ * the interval's. Without (the first sample), over each one's life so far,
+ * as ps reports it.
+ */
+export function groupStats(now, prev, o) {
+    const agg = new Map();
+    for (const p of now) {
+        const w = WATCH.find((x) => x.test(p.comm));
+        if (!w)
+            continue;
+        const cur = agg.get(w.key) || { name: w.key, count: 0, cpu: 0, mem: 0 };
+        cur.count++;
+        cur.mem += p.rss * o.page;
+        if (prev && o.dt > 0) {
+            const before = prev.get(p.pid);
+            // Fewer ticks than before is a reused pid: a new process.
+            const used = before != null && p.ticks >= before ? p.ticks - before : p.ticks;
+            cur.cpu += (used / o.hz / o.dt) * 100;
+        }
+        else {
+            const life = o.uptime - p.start / o.hz;
+            if (life > 0)
+                cur.cpu += (p.ticks / o.hz / life) * 100;
+        }
+        agg.set(w.key, cur);
+    }
+    return Array.from(agg.values())
+        .map((p) => ({ ...p, cpu: Math.round(p.cpu * 10) / 10 }))
+        .sort((a, b) => b.mem - a.mem);
+}
+/** Every process's stat, or null where there's no /proc (macOS). */
+export function readProcStats() {
+    let pids;
+    try {
+        pids = readdirSync("/proc").filter((d) => /^\d+$/.test(d));
+    }
+    catch {
+        return null;
+    }
+    const out = [];
+    for (const d of pids) {
+        try {
+            const s = parseStat(Number(d), readFileSync(`/proc/${d}/stat`, "utf8"));
+            if (s)
+                out.push(s);
+        }
+        catch {
+            // It exited between the listing and the read.
+        }
+    }
+    return out;
+}
+// The last sample's ticks per pid, and when it was taken.
+let last = null;
+let hz = 0, page = 0;
+const conf = (name, fallback) => {
+    try {
+        return Number(execSync(`getconf ${name}`, { encoding: "utf8", timeout: 2000 }).trim()) || fallback;
+    }
+    catch {
+        return fallback;
+    }
+};
+/** A Linux host's named processes from /proc, cpu since the last call; null where there's no /proc. */
+export function sampleProcesses() {
+    const stats = readProcStats();
+    if (!stats)
+        return null;
+    if (!hz) {
+        hz = conf("CLK_TCK", 100);
+        page = conf("PAGESIZE", 4096);
+    }
+    let uptime = 0;
+    try {
+        uptime = Number(readFileSync("/proc/uptime", "utf8").split(" ")[0]) || 0;
+    }
+    catch { /* lifetime cpu reads 0 */ }
+    const at = Date.now();
+    const groups = groupStats(stats, last?.ticks ?? null, { dt: last ? (at - last.at) / 1000 : 0, hz, page, uptime });
+    last = { at, ticks: new Map(stats.map((s) => [s.pid, s.ticks])) };
+    return groups;
+}
 export function parseProcesses(out) {
     const agg = new Map();
     for (const line of String(out || "").split("\n")) {

package/dist/plugins/monitoring/OSPlugin.js

@@ -2,11 +2,12 @@ import { createMonitoringPlugin } from "../../lib/MonitoringPlugin.js";
 import { arch, cpus, freemem, hostname, loadavg, networkInterfaces, platform, release, totalmem, type, uptime, } from "os";
 import { readFileSync } from "fs";
 import { execSync } from "child_process";
-import { parseProcesses, PS_CMD } from "../../lib/processes.js";
+import { parseProcesses, PS_CMD, sampleProcesses } from "../../lib/processes.js";
 // Named service processes (nginx / php-fpm / db / …) running on the host.
+// From /proc on Linux, cpu over the time since the last report; ps elsewhere.
 function collectProcesses() {
     try {
-        return parseProcesses(execSync(PS_CMD, { encoding: "utf8", timeout: 5000 }));
+        return sampleProcesses() ?? parseProcesses(execSync(PS_CMD, { encoding: "utf8", timeout: 5000 }));
     }
     catch {
         return [];
@@ -25,8 +26,11 @@ function collectDisks() {
     try {
         const darwin = platform() === "darwin";
         // Linux: `-T` gives the fstype column; bytes via --block-size=1.
-        // macOS: no fstype flag, `-l` restricts to local filesystems.
-        const cmd = darwin ? "df -kl" : "df -PT --block-size=1";
+        // `-l` on both: local filesystems only, which is all this reports, and
+        // df skips network mounts without touching them. Without it a dead NFS
+        // server hung every call past the timeout, so the Patroni nodes
+        // reported no disks at all for seven weeks.
+        const cmd = darwin ? "df -kl" : "df -lPT --block-size=1";
         const out = execSync(cmd, { encoding: "utf8", timeout: 5000 });
         const raw = [];
         for (const line of out.split("\n").slice(1)) {

package/dist/plugins/monitoring/WordpressPlugin.js

@@ -193,6 +193,49 @@ async function collectSite(site) {
     catch (e) {
         out.cronError = String(e?.stderr || e?.message || e).slice(0, 160);
     }
+    // 6. Plugins: how many are active, which sit inactive (code on disk that
+    // nobody uses, still reachable by a request), and which have an update
+    // waiting. The update flags come from WordPress's own cached check.
+    try {
+        const raw = await wp(site, ["plugin", "list", "--fields=name,status,update,version", "--format=json"]);
+        const list = parseJsonSafe(raw, []).filter((p) => p.status === "active" || p.status === "active-network" || p.status === "inactive");
+        out.plugins = {
+            active: list.filter((p) => p.status !== "inactive").length,
+            inactive: list.filter((p) => p.status === "inactive").map((p) => String(p.name)),
+            updates: list.filter((p) => p.update === "available").map((p) => String(p.name)),
+        };
+    }
+    catch (e) {
+        out.pluginsError = String(e?.message || e).slice(0, 160);
+    }
+    // 7. Themes with an update waiting, from the same cached check.
+    try {
+        const raw = await wp(site, ["theme", "list", "--fields=name,update", "--format=json"]);
+        out.themeUpdates = parseJsonSafe(raw, []).filter((t) => t.update === "available").map((t) => String(t.name));
+    }
+    catch (e) {
+        out.themesError = String(e?.message || e).slice(0, 160);
+    }
+    // 8. A core release newer than the one installed (asks api.wordpress.org;
+    // an empty list is up to date).
+    try {
+        const raw = await wp(site, ["core", "check-update", "--format=json"], 30000);
+        const ups = parseJsonSafe(raw, []);
+        out.coreUpdate = ups.length ? String(ups[0].version) : null;
+    }
+    catch (e) {
+        out.coreUpdateError = String(e?.message || e).slice(0, 160);
+    }
+    // 9. The PHP that WP-CLI, and so the site, runs on. `wp cli info` doesn't
+    // load WordPress.
+    try {
+        const info = parseJsonSafe(await wp(site, ["cli", "info", "--format=json"]), {});
+        if (info.php_version)
+            out.phpVersion = String(info.php_version);
+    }
+    catch (e) {
+        out.phpVersionError = String(e?.message || e).slice(0, 160);
+    }
     return out;
 }
 export function createWordpressPlugin() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daemonitor/plugins",
-  "version": "1.1.37",
+  "version": "1.1.39",
   "description": "daemonitor plugins",
   "types": "types/index.d.ts",
   "main": "dist/index.js",