@daemonitor/plugins 1.1.18 → 1.1.20

package/dist/plugins/monitoring/SnmpPlugin.js

@@ -28,6 +28,7 @@ const SYS = {
     name: "1.3.6.1.2.1.1.5.0", // sysName
     ifOper: "1.3.6.1.2.1.2.2.1.8", // ifOperStatus (walk): 1=up 2=down
     ifAdmin: "1.3.6.1.2.1.2.2.1.7", // ifAdminStatus (walk): 1=up (enabled)
+    ifName: "1.3.6.1.2.1.31.1.1.1.1", // ifName (walk) — eth0/eth1/itf0/...
     ifHCIn: "1.3.6.1.2.1.31.1.1.1.6", // ifHCInOctets (walk, Counter64)
     ifHCOut: "1.3.6.1.2.1.31.1.1.1.10", // ifHCOutOctets (walk, Counter64)
 };
@@ -45,9 +46,9 @@ const UCD = {
     memCached: "1.3.6.1.4.1.2021.4.15.0", // memCached (KB)
     hrProcLoad: "1.3.6.1.2.1.25.3.3.1.2", // hrProcessorLoad (walk, per-core %) — CPU fallback
 };
-// Per-target previous interface-octet sample, for throughput (bps) rate calc
-// across polls. Module-level: one collectDevice call per target per cycle.
-const netPrev = {};
+// Previous cumulative octet counters PER INTERFACE (target ip -> ifIndex), for
+// per-link throughput rates across polls.
+const netPrevIf = {};
 // QNAP enterprise MIB (NAS-MIB, 1.3.6.1.4.1.24681.1.2). A full walk of this
 // subtree times out on QTS, so everything here is fetched by exact OID.
 const QNAP = {
@@ -167,20 +168,30 @@ async function collectDevice(t) {
         snmpGet(t, SYS.descr),
         snmpGet(t, SYS.name),
         snmpGet(t, SYS.uptime),
-        snmpWalk(t, SYS.ifOper),
-        snmpWalk(t, SYS.ifAdmin),
+        snmpWalkIndexed(t, SYS.ifOper),
+        snmpWalkIndexed(t, SYS.ifAdmin),
     ]);
     if (descr == null && name == null && !oper.length) {
         return { name: t.name, ip: t.ip, kind: t.kind || "device", reachable: false };
     }
+    // Index the link-state walks by ifIndex so each interface can carry its own
+    // up/down (positional zipping breaks whenever the two walks differ in length).
+    const byIndex = (rows) => {
+        const m = {};
+        for (const r of rows)
+            m[r.idx] = r.val;
+        return m;
+    };
+    const operByIdx = byIndex(oper);
+    const adminByIdx = byIndex(admin);
     // Only count ADMIN-enabled ports; an enabled port that's operationally down is
     // a real link-down (ignore the many disabled ports on a big switch).
     let portsTotal = 0;
     let portsUp = 0;
-    for (let i = 0; i < oper.length; i++) {
-        if (Number(admin[i]) === 1) {
+    for (const idx of Object.keys(adminByIdx)) {
+        if (Number(adminByIdx[idx]) === 1) {
             portsTotal++;
-            if (Number(oper[i]) === 1)
+            if (Number(operByIdx[idx]) === 1)
                 portsUp++;
         }
     }
@@ -189,10 +200,11 @@ async function collectDevice(t) {
     // CPU / RAM / load / network — best-effort UCD-SNMP + IF-MIB counters. Absent
     // on gear without the UCD MIB (returns "No Such Object" fast → null), so every
     // field is optional and simply omitted when unsupported.
-    const [cpuIdle, load1, load5, load15, memTotal, memAvail, memBuffer, memCached, procLoads, hcIn, hcOut] = await Promise.all([
+    const [cpuIdle, load1, load5, load15, memTotal, memAvail, memBuffer, memCached, procLoads, ifNames, hcInIdx, hcOutIdx] = await Promise.all([
         snmpGet(t, UCD.cpuIdle), snmpGet(t, UCD.load1), snmpGet(t, UCD.load5), snmpGet(t, UCD.load15),
         snmpGet(t, UCD.memTotal), snmpGet(t, UCD.memAvail), snmpGet(t, UCD.memBuffer), snmpGet(t, UCD.memCached),
-        snmpWalk(t, UCD.hrProcLoad), snmpWalk(t, SYS.ifHCIn), snmpWalk(t, SYS.ifHCOut),
+        snmpWalk(t, UCD.hrProcLoad), snmpWalkIndexed(t, SYS.ifName),
+        snmpWalkIndexed(t, SYS.ifHCIn), snmpWalkIndexed(t, SYS.ifHCOut),
     ]);
     // CPU %: prefer ssCpuIdle (100 - idle); fall back to avg per-core hrProcessorLoad.
     let cpuPct;
@@ -216,24 +228,55 @@ async function collectDevice(t) {
         memPct = Math.round((usedKb / mTot) * 100);
         memTotalMB = Math.round(mTot / 1024);
     }
-    // Network throughput (aggregate bytes/sec, to match the OS plugin's NET
-    // metric): delta of summed HC octets vs the prior poll. First poll (or a
-    // counter reset) yields no rate.
-    let netIn, netOut;
-    const sumIn = hcIn.map(Number).filter((n) => !isNaN(n)).reduce((a, b) => a + b, 0);
-    const sumOut = hcOut.map(Number).filter((n) => !isNaN(n)).reduce((a, b) => a + b, 0);
-    if (hcIn.length || hcOut.length) {
-        const now = Date.now();
-        const prev = netPrev[t.ip];
-        if (prev && sumIn >= prev.in && sumOut >= prev.out && now > prev.ts) {
-            const dt = (now - prev.ts) / 1000;
+    // Network throughput, PER INTERFACE (bytes/sec).
+    //
+    // Summing every interface is meaningless on a router: a transiting packet is
+    // counted once arriving on the WAN and again leaving on the LAN, so
+    // sum(in) === sum(out) by construction — and vendors add aggregate pseudo
+    // interfaces (EdgeOS `itf0`) that mirror the whole load a second time. The
+    // observed effect was ~5x inflation with in/out identical to the eye.
+    //
+    // So: rate each interface separately, skip loopback/pseudo, and let the target
+    // name its WAN (`wanInterface`) to headline the figure that actually means
+    // "internet traffic". Without one, the headline is left undefined rather than
+    // reporting a number we know to be wrong.
+    const PSEUDO = /^(lo|imq\d*|itf\d*|ifb\d*|sit\d*|gre\d*|teql\d*|tunl\d*)$/i;
+    const nameByIdx = byIndex(ifNames);
+    const inByIdx = byIndex(hcInIdx);
+    const outByIdx = byIndex(hcOutIdx);
+    const now = Date.now();
+    const prevIf = netPrevIf[t.ip] || {};
+    const nextIf = {};
+    const interfaces = [];
+    for (const idx of Object.keys(inByIdx)) {
+        const name = (nameByIdx[idx] || `if${idx}`).replace(/^"|"$/g, "");
+        const cin = Number(inByIdx[idx]), cout = Number(outByIdx[idx]);
+        if (isNaN(cin) || isNaN(cout))
+            continue;
+        nextIf[idx] = { in: cin, out: cout, ts: now };
+        if (PSEUDO.test(name))
+            continue;
+        const p = prevIf[idx];
+        let inBps, outBps;
+        if (p && cin >= p.in && cout >= p.out && now > p.ts) {
+            const dt = (now - p.ts) / 1000;
             if (dt > 0) {
-                netIn = Math.round((sumIn - prev.in) / dt);
-                netOut = Math.round((sumOut - prev.out) / dt);
+                inBps = Math.round((cin - p.in) / dt);
+                outBps = Math.round((cout - p.out) / dt);
             }
         }
-        netPrev[t.ip] = { in: sumIn, out: sumOut, ts: now };
+        // ifOperStatus 1=up, ifAdminStatus 1=enabled. A link that's admin-enabled but
+        // operationally down is a real fault; an admin-disabled port is just off.
+        const adminUp = adminByIdx[idx] != null ? Number(adminByIdx[idx]) === 1 : undefined;
+        const linkUp = operByIdx[idx] != null ? Number(operByIdx[idx]) === 1 : undefined;
+        interfaces.push({ name, inBps, outBps, up: linkUp, adminUp });
     }
+    netPrevIf[t.ip] = nextIf;
+    // Headline = the WAN link when the target names one.
+    const wanName = t.wanInterface;
+    const wan = wanName ? interfaces.find((i) => i.name === wanName) : undefined;
+    const netIn = wan?.inBps;
+    const netOut = wan?.outBps;
     return {
         name: t.name,
         ip: t.ip,
@@ -252,6 +295,11 @@ async function collectDevice(t) {
         memTotalMB,
         netIn,
         netOut,
+        wanInterface: wanName,
+        // Per-link rates (loopback/pseudo excluded), busiest first.
+        interfaces: interfaces
+            .slice()
+            .sort((a, b) => ((b.inBps || 0) + (b.outBps || 0)) - ((a.inBps || 0) + (a.outBps || 0))),
     };
 }
 // Walk that keeps each row's index (numeric OID suffix) — needed to resolve the

package/package.json

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