@daemonitor/plugins 1.1.33 → 1.1.34

package/dist/plugins/index.js

@@ -13,6 +13,8 @@ import { createTplinkPlugin } from "./monitoring/TplinkPlugin.js";
 import { createPatroniPlugin } from "./monitoring/PatroniPlugin.js";
 import { createAdsensePlugin } from "./monitoring/AdsensePlugin.js";
 import { createGa4Plugin } from "./monitoring/Ga4Plugin.js";
+import { createNagiosPlugin } from "./monitoring/NagiosPlugin.js";
+import { createTplinkSwitchPlugin } from "./monitoring/TplinkSwitchPlugin.js";
 // In future, implement other plugin factory functions using the same pattern
 // import { createOSPlugin } from "./monitoring/OSPlugin.js"
 // import { createMongoDBPlugin } from "./monitoring/MongoDBPlugin.js"
@@ -37,6 +39,8 @@ export default {
     Patroni: createPatroniPlugin,
     Adsense: createAdsensePlugin,
     Ga4: createGa4Plugin,
+    Nagios: createNagiosPlugin,
+    TplinkSwitch: createTplinkSwitchPlugin,
     // CloudflarePlugin: createCloudflarePlugin,
     // EwelinkPlugin: createEwelinkPlugin,
     // MongoDBPlugin: createMongoDBPlugin,

package/dist/plugins/monitoring/NagiosPlugin.js

@@ -0,0 +1,138 @@
+import { execFile } from "node:child_process";
+import { createMonitoringPlugin } from "../../lib/MonitoringPlugin.js";
+const STATES = ["ok", "warning", "critical", "unknown"];
+// Output is capped: a check printing a megabyte would otherwise be sent every
+// minute and stored in history.
+const MAX_OUTPUT = 4000;
+export function stateOf(exitCode) {
+    return exitCode != null && exitCode >= 0 && exitCode <= 3 ? STATES[exitCode] : "unknown";
+}
+const num = (s) => (s == null || s === "" || Number.isNaN(Number(s)) ? undefined : Number(s));
+/**
+ * Parse performance data: space-separated `'label'=value[UOM];[warn];[crit];[min];[max]`.
+ * Labels may be quoted to contain spaces, with '' standing for a literal quote.
+ * Malformed items are skipped rather than failing the whole check.
+ */
+export function parsePerfdata(raw) {
+    const out = [];
+    const re = /\s*('(?:[^']|'')+'|[^\s=']+)=(\S+)/g;
+    let m;
+    while ((m = re.exec(raw))) {
+        const label = m[1].startsWith("'") ? m[1].slice(1, -1).replace(/''/g, "'") : m[1];
+        const [valueUom, warn, crit, min, max] = m[2].split(";");
+        const vm = valueUom.match(/^(-?[\d.]+(?:[eE][-+]?\d+)?)([a-zA-Z%]*)$/);
+        if (!vm)
+            continue; // "U" (undetermined) or garbage
+        out.push({
+            label,
+            value: Number(vm[1]),
+            ...(vm[2] ? { uom: vm[2] } : {}),
+            ...(warn ? { warn } : {}),
+            ...(crit ? { crit } : {}),
+            ...(num(min) != null ? { min: num(min) } : {}),
+            ...(num(max) != null ? { max: num(max) } : {}),
+        });
+    }
+    return out;
+}
+/**
+ * Split plugin output into the status line, the long output and perfdata.
+ * Perfdata can follow "|" on the first line and on any long-output line after
+ * a "|" there (the Nagios 3 multi-line form).
+ */
+export function parseOutput(stdout) {
+    const lines = stdout.replace(/\r/g, "").replace(/\n+$/, "").split("\n");
+    const [first = "", ...rest] = lines;
+    const [output, firstPerf = ""] = splitPipe(first);
+    let perf = firstPerf;
+    const long = [];
+    let inPerf = false;
+    for (const line of rest) {
+        if (inPerf) {
+            perf += " " + line;
+            continue;
+        }
+        const [text, more] = splitPipe(line);
+        if (text.trim())
+            long.push(text.trimEnd());
+        if (more != null) {
+            perf += " " + more;
+            inPerf = true;
+        }
+    }
+    return {
+        output: output.trim(),
+        ...(long.length ? { longOutput: long.join("\n").slice(0, MAX_OUTPUT) } : {}),
+        perfdata: parsePerfdata(perf),
+    };
+}
+function splitPipe(line) {
+    const i = line.indexOf("|");
+    return i < 0 ? [line] : [line.slice(0, i), line.slice(i + 1)];
+}
+export async function runCheck(check, defaults = {}) {
+    const [bin, ...args] = check.command;
+    const resolved = defaults.pluginDir && !bin.includes("/") ? `${defaults.pluginDir.replace(/\/$/, "")}/${bin}` : bin;
+    const timeoutMs = (check.timeout ?? defaults.timeout ?? 30) * 1000;
+    const started = Date.now();
+    return new Promise((resolve) => {
+        execFile(resolved, args, { timeout: timeoutMs, maxBuffer: 256 * 1024, env: { ...process.env, ...(check.env || {}) }, killSignal: "SIGKILL" }, (err, stdout, stderr) => {
+            const durationMs = Date.now() - started;
+            const base = { name: check.name, command: bin.split("/").pop() || bin, durationMs };
+            // A non-zero exit is the plugin reporting a state, not a failure to run.
+            const exitCode = err ? (typeof err.code === "number" ? err.code : null) : 0;
+            if (err && err.killed) {
+                return resolve({ ...base, state: "unknown", exitCode: null, output: `Check timed out after ${timeoutMs / 1000}s`, perfdata: [], timedOut: true });
+            }
+            if (err && exitCode == null) {
+                // Couldn't start it at all: ENOENT, EACCES and so on.
+                return resolve({ ...base, state: "unknown", exitCode: null, output: `Could not run ${base.command}: ${err.code || err.message}`, perfdata: [], error: String(err.message || err).slice(0, 300) });
+            }
+            const parsed = parseOutput(String(stdout || stderr || "").slice(0, MAX_OUTPUT));
+            resolve({ ...base, state: stateOf(exitCode), exitCode, ...parsed, output: parsed.output || "(no output)" });
+        });
+    });
+}
+function slug(s) {
+    return s.toLowerCase().replace(/[^a-z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+export function createNagiosPlugin() {
+    let refreshTimer = null;
+    let running = false;
+    const checksOf = (plugin) => {
+        const cfg = (plugin.config || {});
+        return (Array.isArray(cfg.checks) ? cfg.checks : []).filter((c) => c?.name && Array.isArray(c.command) && c.command.length && c.command.every((a) => typeof a === "string"));
+    };
+    const refreshFn = async (plugin) => {
+        // A slow check must not pile up overlapping runs of itself.
+        if (running)
+            return;
+        running = true;
+        try {
+            const cfg = (plugin.config || {});
+            await Promise.all(checksOf(plugin).map(async (check) => {
+                const result = await runCheck(check, cfg);
+                // The interval tells the dashboard how long silence is normal, so a
+                // check that runs every 10 minutes doesn't read OFFLINE in between.
+                await plugin.send({ ...result, intervalMs: cfg.refreshInterval || 60000 }, `nagios-${slug(check.name)}`);
+            }));
+        }
+        finally {
+            running = false;
+        }
+    };
+    const monitorFn = async (plugin) => {
+        const n = checksOf(plugin).length;
+        if (!n)
+            console.warn("nagios: no valid checks configured (each needs a name and a command array)");
+        await refreshFn(plugin);
+        refreshTimer = setInterval(() => refreshFn(plugin), plugin.config?.refreshInterval || 60000);
+    };
+    const teardownFn = async () => {
+        if (refreshTimer)
+            clearInterval(refreshTimer);
+        refreshTimer = null;
+    };
+    return createMonitoringPlugin("nagios", "nagios", "Nagios-compatible check commands", async () => { }, monitorFn, refreshFn, teardownFn);
+}
+export default createNagiosPlugin;

package/dist/plugins/monitoring/TplinkSwitchPlugin.js

@@ -0,0 +1,161 @@
+import { createHash } from "node:crypto";
+import { createMonitoringPlugin } from "../../lib/MonitoringPlugin.js";
+const HEADERS = { "Content-Type": "application/json;charset=utf-8", "X-Requested-With": "XMLHttpRequest", SourceType: "switch_web" };
+const LOOP = { "0": "normal", "1": "blocked", "2": "loop" };
+export const md5Upper = (s) => createHash("md5").update(s).digest("hex").toUpperCase();
+/** Build the report from the raw API results. Pure, so the check can drive it. */
+export function buildReport(target, raw, rates) {
+    const info = raw.info || {};
+    const trafficById = new Map((raw.traffic?.port_list || []).map((p) => [p.port_id, p]));
+    const loopById = new Map((raw.loops?.port_list || []).map((p) => [p.port_id, p]));
+    const interfaces = (raw.ports?.port_list || []).map((p) => {
+        const speed = String(p.port_speed_actual || "");
+        const up = !!speed && speed !== "Link Down";
+        const t = trafficById.get(p.port_id);
+        const r = rates.get(p.port_id) || {};
+        return {
+            name: `port ${p.port_id}`,
+            up,
+            adminUp: p.port_state_cfg !== "0",
+            ...(up ? { speed, duplex: p.port_duplex_actual } : {}),
+            ...(t ? { rxBytes: t.rx_bytes, txBytes: t.tx_bytes } : {}),
+            ...(r.inBps != null ? { inBps: r.inBps, outBps: r.outBps } : {}),
+            loop: LOOP[String(loopById.get(p.port_id)?.port_state ?? "0")] || "normal",
+        };
+    });
+    const portIds = (raw.ports?.port_list || []).map((p) => p.port_id);
+    const downUplinks = (target.uplinkPorts || []).filter((id) => {
+        const i = portIds.indexOf(id);
+        return i < 0 || !interfaces[i].up;
+    });
+    return {
+        ip: target.host,
+        name: target.name || info.des || target.host,
+        kind: "switch",
+        model: info.hw_ver || info.des,
+        serial: info.serial_number,
+        mac: info.sys_mac_addr,
+        firmware: info.fw_ver,
+        sysDescr: [info.hw_ver || info.des, info.fw_ver && `firmware ${info.fw_ver}`].filter(Boolean).join(", "),
+        reachable: true,
+        portsUp: interfaces.filter((i) => i.up).length,
+        portsTotal: interfaces.length,
+        interfaces,
+        loops: interfaces.filter((i) => i.loop === "loop").map((i) => i.name),
+        blocked: interfaces.filter((i) => i.loop === "blocked").map((i) => i.name),
+        downUplinks: downUplinks.map((id) => `port ${id}`),
+    };
+}
+/** Byte rates from two counter readings. A counter that went backwards (reboot, clear) gives no rate. */
+export function ratesBetween(prev, now) {
+    const out = new Map();
+    if (!prev)
+        return out;
+    const dt = (now.at - prev.at) / 1000;
+    if (dt <= 0)
+        return out;
+    for (const [id, c] of now.ports) {
+        const p = prev.ports.get(id);
+        if (!p || c.rx < p.rx || c.tx < p.tx)
+            continue;
+        out.set(id, { inBps: Math.round((c.rx - p.rx) / dt), outBps: Math.round((c.tx - p.tx) / dt) });
+    }
+    return out;
+}
+export class LoginRefused extends Error {
+}
+async function call(host, path, opts) {
+    const res = await fetch(`http://${host}${path}`, {
+        method: opts.body !== undefined ? "POST" : "GET",
+        headers: opts.token ? { ...HEADERS, Authorization: opts.token } : HEADERS,
+        ...(opts.body !== undefined ? { body: JSON.stringify(opts.body) } : {}),
+        signal: AbortSignal.timeout(opts.timeoutMs),
+    });
+    if (!res.ok)
+        throw new Error(`${path} returned HTTP ${res.status}`);
+    const json = await res.json();
+    if (json?.error_code)
+        throw Object.assign(new Error(`${path} error_code ${json.error_code}`), { code: json.error_code });
+    return json?.result || {};
+}
+export const newSwitchState = () => ({ counters: new Map(), refusedUntil: new Map() });
+/** Log in, read one switch, log out. Throws LoginRefused or a network error. */
+export async function readSwitch(target, cfg, state) {
+    const { counters, refusedUntil } = state;
+    const timeoutMs = cfg.timeoutMs || 8000;
+    const wait = refusedUntil.get(target.host);
+    if (wait && Date.now() < wait) {
+        throw new LoginRefused(`login refused earlier; not retrying until ${new Date(wait).toISOString()} so the switch doesn't lock the account`);
+    }
+    let login;
+    try {
+        login = await call(target.host, "/login/status", { body: { login_user: target.username, login_pwd: md5Upper(target.password) }, timeoutMs });
+    }
+    catch (e) {
+        if (e?.code) {
+            refusedUntil.set(target.host, Date.now() + (cfg.loginBackoffMs || 30 * 60 * 1000));
+            throw new LoginRefused(`login refused (error_code ${e.code}); check the username and password`);
+        }
+        throw e;
+    }
+    refusedUntil.delete(target.host);
+    const token = login.token;
+    try {
+        const [info, ports, traffic, loops] = await Promise.all([
+            call(target.host, "/system_summary/system_information_status", { token, timeoutMs }),
+            call(target.host, "/switching/port_settings_status", { token, timeoutMs }),
+            call(target.host, "/traffic_summary/traffic_summary_port_status", { token, timeoutMs }),
+            call(target.host, "/loop_detection/loop_detection_status", { token, timeoutMs }).catch(() => ({})),
+        ]);
+        const now = {
+            at: Date.now(),
+            ports: new Map((traffic.port_list || []).map((p) => [p.port_id, { rx: Number(p.rx_bytes) || 0, tx: Number(p.tx_bytes) || 0 }])),
+        };
+        const rates = ratesBetween(counters.get(target.host), now);
+        counters.set(target.host, now);
+        return buildReport(target, { info, ports, traffic, loops }, rates);
+    }
+    finally {
+        // Log out every time: these switches allow few admin sessions, and an
+        // idle one held by the agent could lock someone out of the web UI.
+        await call(target.host, "/show_up/logout_status", { token, body: {}, timeoutMs }).catch(() => { });
+    }
+}
+export function createTplinkSwitchPlugin() {
+    let refreshTimer = null;
+    const state = newSwitchState();
+    const refreshFn = async (plugin) => {
+        const cfg = (plugin.config || {});
+        const targets = (cfg.switches || []).filter((s) => s?.host && s.username && s.password);
+        await Promise.all(targets.map(async (target) => {
+            let report;
+            try {
+                report = await readSwitch(target, cfg, state);
+            }
+            catch (e) {
+                report = {
+                    ip: target.host,
+                    name: target.name || target.host,
+                    kind: "switch",
+                    reachable: e instanceof LoginRefused,
+                    error: String(e?.message || e).slice(0, 200),
+                };
+            }
+            await plugin.send(report, `tplinkswitch-${target.host.replace(/[^0-9a-zA-Z]+/g, "-")}`);
+        }));
+    };
+    const monitorFn = async (plugin) => {
+        const cfg = (plugin.config || {});
+        if (!(cfg.switches || []).length)
+            console.warn("tplinkswitch: no switches configured");
+        await refreshFn(plugin);
+        refreshTimer = setInterval(() => refreshFn(plugin), cfg.refreshInterval || 60000);
+    };
+    const teardownFn = async () => {
+        if (refreshTimer)
+            clearInterval(refreshTimer);
+        refreshTimer = null;
+    };
+    return createMonitoringPlugin("tplinkswitch", "tplinkswitch", "TP-Link Omada Easy Managed switch (web API)", async () => { }, monitorFn, refreshFn, teardownFn);
+}
+export default createTplinkSwitchPlugin;

package/package.json

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