@daemonitor/plugins 1.1.15 → 1.1.17

package/dist/plugins/monitoring/DockerPlugin.js

@@ -5,6 +5,14 @@ import { hostname } from "os";
 const execAsync = promisify(exec);
 const EXEC_OPTS = { maxBuffer: 32 * 1024 * 1024 }; // containers.length can be large
 const HEALTH_RE = /\((healthy|unhealthy|health: starting|starting)\)/i;
+// Previous cumulative NetIO/BlockIO totals per container id, to derive a
+// per-second rate across polls. Module-level (one collect per host per cycle).
+const ioPrev = {};
+// docker stats renders "12MB / 7.02MB" (rx / tx, or read / write). Split + convert.
+function pairToBytes(value) {
+    const [x, y] = (value || "").split("/").map((p) => p.trim());
+    return { a: memToBytes(x), b: memToBytes(y) };
+}
 /** Convert docker's "83.86MiB" / "1.952GiB" memory strings to bytes. */
 function memToBytes(value) {
     if (!value)
@@ -52,13 +60,17 @@ async function collectContainers(bin) {
     }
     if (!containers.length)
         return containers;
-    // 2. live stats for running containers (one batched call, best-effort)
+    // 2. live stats for running containers (one batched call, best-effort).
+    // NetIO/BlockIO are CUMULATIVE since container start, so we derive a per-second
+    // rate from the delta vs the previous poll (first poll → no rate).
     try {
-        const { stdout: statsOut } = await execAsync(`${bin} stats --no-stream --format '{{.ID}}|{{.CPUPerc}}|{{.MemUsage}}|{{.MemPerc}}'`, EXEC_OPTS);
+        const { stdout: statsOut } = await execAsync(`${bin} stats --no-stream --format '{{.ID}}|{{.CPUPerc}}|{{.MemUsage}}|{{.MemPerc}}|{{.NetIO}}|{{.BlockIO}}'`, EXEC_OPTS);
+        const now = Date.now();
+        const seen = new Set();
         for (const line of statsOut.split("\n")) {
             if (!line.trim())
                 continue;
-            const [id, cpuPerc, memUsage, memPerc] = line.split("|");
+            const [id, cpuPerc, memUsage, memPerc, netIO, blkIO] = line.split("|");
             const c = byId.get(id);
             if (!c)
                 continue;
@@ -67,7 +79,28 @@ async function collectContainers(bin) {
             c.mem = memToBytes(used);
             c.memLimit = memToBytes(limit);
             c.memPercent = parseFloat((memPerc || "").replace("%", "")) || 0;
+            const net = pairToBytes(netIO); // { a: rx, b: tx }
+            const blk = pairToBytes(blkIO); // { a: read, b: write }
+            seen.add(id);
+            const prev = ioPrev[id];
+            if (prev && now > prev.ts) {
+                const dt = (now - prev.ts) / 1000;
+                // Guard counter resets (container restart): negative delta → skip that field.
+                if (net.a >= prev.rx)
+                    c.netIn = Math.round((net.a - prev.rx) / dt);
+                if (net.b >= prev.tx)
+                    c.netOut = Math.round((net.b - prev.tx) / dt);
+                if (blk.a >= prev.rd)
+                    c.blkRead = Math.round((blk.a - prev.rd) / dt);
+                if (blk.b >= prev.wr)
+                    c.blkWrite = Math.round((blk.b - prev.wr) / dt);
+            }
+            ioPrev[id] = { rx: net.a, tx: net.b, rd: blk.a, wr: blk.b, ts: now };
         }
+        // Drop prev samples for containers no longer present.
+        for (const k of Object.keys(ioPrev))
+            if (!seen.has(k))
+                delete ioPrev[k];
     }
     catch (err) {
         console.error("docker: stats collection failed:", err.message);

package/dist/plugins/monitoring/OSPlugin.js

@@ -98,6 +98,27 @@ function availableMem() {
             // fall through to freemem()
         }
     }
+    if (platform() === "darwin") {
+        // macOS keeps `freemem()` near zero by design (RAM held as cache/compressed).
+        // Reclaimable memory ≈ free + inactive + speculative + purgeable pages —
+        // this tracks the kernel's own "available" (memory_pressure free %), so a
+        // healthy Mac doesn't read as 100% used.
+        try {
+            const out = execSync("vm_stat", { encoding: "utf8", timeout: 4000 });
+            const page = parseInt(out.match(/page size of (\d+) bytes/)?.[1] || "16384", 10);
+            const pages = (re) => parseInt(out.match(re)?.[1] || "0", 10);
+            const free = pages(/Pages free:\s+(\d+)/);
+            const inactive = pages(/Pages inactive:\s+(\d+)/);
+            const speculative = pages(/Pages speculative:\s+(\d+)/);
+            const purgeable = pages(/Pages purgeable:\s+(\d+)/);
+            const avail = (free + inactive + speculative + purgeable) * page;
+            if (avail > 0)
+                return avail;
+        }
+        catch {
+            // fall through to freemem()
+        }
+    }
     return freemem();
 }
 // Cumulative rx/tx byte counters summed across real interfaces (Linux
@@ -105,27 +126,55 @@ function availableMem() {
 // so the figure reflects actual host network traffic, not container-to-host
 // chatter. Returns null off Linux (rate is then omitted, not faked).
 function readNetTotals() {
-    if (platform() !== "linux")
-        return null;
-    try {
-        const data = readFileSync("/proc/net/dev", "utf8");
-        let rx = 0, tx = 0;
-        for (const line of data.split("\n")) {
-            const m = line.match(/^\s*([^:]+):\s*(.*)$/);
-            if (!m)
-                continue;
-            const iface = m[1].trim();
-            if (iface === "lo" || /^(veth|docker|br-|lxcbr|virbr|tap|tun)/.test(iface))
-                continue;
-            const cols = m[2].trim().split(/\s+/).map(Number);
-            rx += cols[0] || 0; // column 1 = rx bytes
-            tx += cols[8] || 0; // column 9 = tx bytes
+    if (platform() === "linux") {
+        try {
+            const data = readFileSync("/proc/net/dev", "utf8");
+            let rx = 0, tx = 0;
+            for (const line of data.split("\n")) {
+                const m = line.match(/^\s*([^:]+):\s*(.*)$/);
+                if (!m)
+                    continue;
+                const iface = m[1].trim();
+                if (iface === "lo" || /^(veth|docker|br-|lxcbr|virbr|tap|tun)/.test(iface))
+                    continue;
+                const cols = m[2].trim().split(/\s+/).map(Number);
+                rx += cols[0] || 0; // column 1 = rx bytes
+                tx += cols[8] || 0; // column 9 = tx bytes
+            }
+            return { rx, tx };
+        }
+        catch {
+            return null;
         }
-        return { rx, tx };
     }
-    catch {
-        return null;
+    if (platform() === "darwin") {
+        // `netstat -ibn`: Name Mtu Network Address Ipkts Ierrs Ibytes Opkts Oerrs Obytes Coll.
+        // Per-interface byte counters repeat across a NIC's address rows, so take one
+        // row per interface; skip loopback and virtual (bridge/utun/awdl/llw/gif/stf/ap).
+        try {
+            const out = execSync("netstat -ibn", { encoding: "utf8", timeout: 4000 });
+            let rx = 0, tx = 0;
+            const seen = new Set();
+            for (const line of out.split("\n").slice(1)) {
+                const c = line.trim().split(/\s+/);
+                if (c.length < 10)
+                    continue;
+                const name = c[0];
+                if (!name || name === "lo0" || /^(bridge|utun|llw|awdl|gif|stf|ap\d|anpi|en\d*_)/.test(name))
+                    continue;
+                if (seen.has(name))
+                    continue;
+                seen.add(name);
+                rx += Number(c[6]) || 0; // Ibytes
+                tx += Number(c[9]) || 0; // Obytes
+            }
+            return { rx, tx };
+        }
+        catch {
+            return null;
+        }
     }
+    return null;
 }
 // Host OS metrics: cpu (from cpus().times), memory, disk, load, uptime,
 // addresses, and network throughput. Matches the frontend `os` fleetAdapter case.

package/package.json

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