badmfck-api-server 4.1.25 → 4.1.27

package/dist/apiServer/monitor/ProcessMonitor.js

@@ -0,0 +1,308 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessMonitor = void 0;
+const os_1 = __importDefault(require("os"));
+const v8_1 = __importDefault(require("v8"));
+const perf_hooks_1 = require("perf_hooks");
+const promises_1 = __importDefault(require("fs/promises"));
+class ProcessMonitor {
+    static _inited = false;
+    static _eld = null;
+    static _gcObserver = null;
+    static _gc = {
+        totalCount: 0,
+        totalTimeMs: 0,
+        maxPauseMs: 0,
+        byKind: {},
+        lastPauses: [],
+    };
+    static _prevCpu = process.cpuUsage();
+    static _prevCpuAt = Date.now();
+    static _cpuPct = { userPct: 0, systemPct: 0 };
+    static _eluPrev = perf_hooks_1.performance.eventLoopUtilization();
+    static _elu = { idle: 0, active: 0, utilizationPct: 0 };
+    static _processStartedAt = Date.now() - process.uptime() * 1000;
+    static init() {
+        if (this._inited)
+            return;
+        this._inited = true;
+        this._eld = (0, perf_hooks_1.monitorEventLoopDelay)({ resolution: 20 });
+        this._eld.enable();
+        this._gcObserver = new perf_hooks_1.PerformanceObserver((list) => {
+            for (const entry of list.getEntries()) {
+                const kind = this._mapGcKind(entry.detail?.kind ?? entry.kind);
+                this._gc.totalCount++;
+                this._gc.totalTimeMs += entry.duration;
+                if (entry.duration > this._gc.maxPauseMs)
+                    this._gc.maxPauseMs = entry.duration;
+                const bucket = this._gc.byKind[kind] ?? { count: 0, timeMs: 0 };
+                bucket.count++;
+                bucket.timeMs += entry.duration;
+                this._gc.byKind[kind] = bucket;
+                this._gc.lastPauses.push({ kind, ms: entry.duration, timestamp: Date.now() });
+                if (this._gc.lastPauses.length > 20)
+                    this._gc.lastPauses.shift();
+            }
+        });
+        try {
+            this._gcObserver.observe({ entryTypes: ["gc"], buffered: false });
+        }
+        catch {
+            try {
+                this._gcObserver.observe({ type: "gc" });
+            }
+            catch { }
+        }
+        const cpuTimer = setInterval(() => this._sampleCpu(), 5000);
+        if (cpuTimer.unref)
+            cpuTimer.unref();
+        const eluTimer = setInterval(() => this._sampleELU(), 5000);
+        if (eluTimer.unref)
+            eluTimer.unref();
+    }
+    static _sampleCpu() {
+        const now = process.cpuUsage();
+        const nowAt = Date.now();
+        const dtMs = nowAt - this._prevCpuAt;
+        if (dtMs <= 0)
+            return;
+        const userPct = (now.user - this._prevCpu.user) / (dtMs * 1000) * 100;
+        const systemPct = (now.system - this._prevCpu.system) / (dtMs * 1000) * 100;
+        this._cpuPct = {
+            userPct: Math.round(userPct * 10) / 10,
+            systemPct: Math.round(systemPct * 10) / 10,
+        };
+        this._prevCpu = now;
+        this._prevCpuAt = nowAt;
+    }
+    static _sampleELU() {
+        const cur = perf_hooks_1.performance.eventLoopUtilization();
+        const delta = perf_hooks_1.performance.eventLoopUtilization(cur, this._eluPrev);
+        this._elu = {
+            idle: delta.idle,
+            active: delta.active,
+            utilizationPct: Math.round(delta.utilization * 10000) / 100,
+        };
+        this._eluPrev = cur;
+    }
+    static _mapGcKind(kind) {
+        if (typeof kind === "string")
+            return kind;
+        switch (kind) {
+            case 1: return "minor";
+            case 2: return "major";
+            case 4: return "incremental";
+            case 8: return "weakcb";
+            case 15: return "all";
+            default: return "unknown";
+        }
+    }
+    static async getSnapshot() {
+        const tStart = process.hrtime.bigint();
+        await new Promise(r => setImmediate(() => r()));
+        const spotLagMs = Number(process.hrtime.bigint() - tStart) / 1e6;
+        const mem = process.memoryUsage();
+        const heap = v8_1.default.getHeapStatistics();
+        const heapSpaces = v8_1.default.getHeapSpaceStatistics().map(s => ({
+            name: s.space_name,
+            size: s.space_size,
+            used: s.space_used_size,
+            available: s.space_available_size,
+            physical: s.physical_space_size,
+        }));
+        const procStatus = await this._readProcStatus();
+        const io = await this._readProcIo();
+        const limitsParsed = await this._readProcLimits();
+        const cpuTotal = process.cpuUsage();
+        let resource = null;
+        try {
+            const r = process.resourceUsage();
+            resource = {
+                maxRSS: r.maxRSS,
+                voluntaryContextSwitches: r.voluntaryContextSwitches,
+                involuntaryContextSwitches: r.involuntaryContextSwitches,
+                fsRead: r.fsRead,
+                fsWrite: r.fsWrite,
+                signalsCount: r.signalsCount,
+                ipcSent: r.ipcSent,
+                ipcReceived: r.ipcReceived,
+                userCPUTimeMs: Math.round(r.userCPUTime / 1000),
+                systemCPUTimeMs: Math.round(r.systemCPUTime / 1000),
+            };
+        }
+        catch { }
+        const fdOpen = await this._countFds();
+        const fdSoft = limitsParsed?.["Max open files"]?.soft;
+        const fdHard = limitsParsed?.["Max open files"]?.hard;
+        const h = this._eld;
+        const eventLoop = h ? {
+            minMs: this._toMsFinite(h.min),
+            maxMs: this._toMsFinite(h.max),
+            meanMs: this._toMsFinite(h.mean),
+            stddevMs: this._toMsFinite(h.stddev),
+            p50Ms: this._safePercentileMs(h, 50),
+            p90Ms: this._safePercentileMs(h, 90),
+            p99Ms: this._safePercentileMs(h, 99),
+            utilizationPct: this._elu.utilizationPct,
+            activeHandles: this._safeCount(() => process._getActiveHandles?.()?.length),
+            activeRequests: this._safeCount(() => process._getActiveRequests?.()?.length),
+            spotLagMs: Math.round(spotLagMs * 100) / 100,
+        } : null;
+        return {
+            identity: {
+                pid: process.pid,
+                ppid: process.ppid,
+                title: process.title,
+                argv: process.argv,
+                execPath: process.execPath,
+                cwd: process.cwd(),
+                nodeVersion: process.version,
+                v8Version: process.versions.v8,
+                platform: process.platform,
+                arch: process.arch,
+                hostname: os_1.default.hostname(),
+                user: typeof process.getuid === "function"
+                    ? { uid: process.getuid(), gid: process.getgid?.() ?? -1 }
+                    : null,
+                startedAtUnix: this._processStartedAt,
+                uptimeSec: Math.round(process.uptime()),
+                availableParallelism: typeof os_1.default.availableParallelism === "function"
+                    ? os_1.default.availableParallelism()
+                    : os_1.default.cpus().length,
+            },
+            memory: {
+                rss: mem.rss,
+                heapTotal: mem.heapTotal,
+                heapUsed: mem.heapUsed,
+                external: mem.external,
+                arrayBuffers: mem.arrayBuffers ?? 0,
+                heap: {
+                    sizeLimit: heap.heap_size_limit,
+                    usedHeap: heap.used_heap_size,
+                    totalAvailable: heap.total_available_size,
+                    totalPhysical: heap.total_physical_size,
+                    mallocedMemory: heap.malloced_memory,
+                    peakMallocedMemory: heap.peak_malloced_memory,
+                    numberOfNativeContexts: heap.number_of_native_contexts,
+                    numberOfDetachedContexts: heap.number_of_detached_contexts,
+                },
+                heapSpaces,
+                procStatus,
+            },
+            cpu: {
+                userPct: this._cpuPct.userPct,
+                systemPct: this._cpuPct.systemPct,
+                userMicros: cpuTotal.user,
+                systemMicros: cpuTotal.system,
+                resource,
+            },
+            eventLoop,
+            gc: {
+                totalCount: this._gc.totalCount,
+                totalTimeMs: Math.round(this._gc.totalTimeMs * 100) / 100,
+                maxPauseMs: Math.round(this._gc.maxPauseMs * 100) / 100,
+                byKind: this._gc.byKind,
+                lastPauses: this._gc.lastPauses.slice(-20),
+            },
+            fileDescriptors: {
+                open: fdOpen,
+                limitSoft: fdSoft ? this._parseLimitValue(fdSoft) : null,
+                limitHard: fdHard ? this._parseLimitValue(fdHard) : null,
+            },
+            io,
+            limits: limitsParsed,
+        };
+    }
+    static async _readProcStatus() {
+        try {
+            const txt = await promises_1.default.readFile(`/proc/${process.pid}/status`, "utf-8");
+            const keys = ["VmPeak", "VmSize", "VmHWM", "VmRSS", "VmData", "VmStk", "VmExe", "VmSwap", "Threads"];
+            const result = {};
+            for (const line of txt.split("\n")) {
+                for (const k of keys) {
+                    if (line.startsWith(k + ":")) {
+                        const m = line.match(new RegExp(`${k}:\\s+(\\d+)`));
+                        if (m) {
+                            const v = parseInt(m[1], 10);
+                            result[k] = k === "Threads" ? v : v * 1024;
+                        }
+                    }
+                }
+            }
+            return result;
+        }
+        catch {
+            return null;
+        }
+    }
+    static async _readProcIo() {
+        try {
+            const txt = await promises_1.default.readFile(`/proc/${process.pid}/io`, "utf-8");
+            const result = {};
+            for (const line of txt.split("\n")) {
+                const m = line.match(/^(\w+):\s+(\d+)$/);
+                if (m)
+                    result[m[1]] = parseInt(m[2], 10);
+            }
+            return result;
+        }
+        catch {
+            return null;
+        }
+    }
+    static async _readProcLimits() {
+        try {
+            const txt = await promises_1.default.readFile(`/proc/${process.pid}/limits`, "utf-8");
+            const result = {};
+            const lines = txt.split("\n").slice(1);
+            for (const line of lines) {
+                const m = line.match(/^(.+?)\s{2,}(\S+)\s+(\S+)\s+(\S+)\s*$/);
+                if (m)
+                    result[m[1].trim()] = { soft: m[2], hard: m[3], unit: m[4] };
+            }
+            return result;
+        }
+        catch {
+            return null;
+        }
+    }
+    static async _countFds() {
+        try {
+            const entries = await promises_1.default.readdir(`/proc/${process.pid}/fd`);
+            return entries.length;
+        }
+        catch {
+            return null;
+        }
+    }
+    static _parseLimitValue(v) {
+        if (v === "unlimited")
+            return -1;
+        const n = parseInt(v, 10);
+        return Number.isFinite(n) ? n : null;
+    }
+    static _toMsFinite(ns) {
+        return Number.isFinite(ns) ? Math.round((ns / 1e6) * 100) / 100 : 0;
+    }
+    static _safePercentileMs(h, p) {
+        try {
+            return this._toMsFinite(h.percentile(p));
+        }
+        catch {
+            return 0;
+        }
+    }
+    static _safeCount(fn) {
+        try {
+            return fn() ?? 0;
+        }
+        catch {
+            return 0;
+        }
+    }
+}
+exports.ProcessMonitor = ProcessMonitor;
+ProcessMonitor.init();

package/dist/apiServer/monitor/SystemInfo.d.ts

@@ -0,0 +1,71 @@
+/// <reference types="node" />
+export declare function collectSystemInfo(): Promise<{
+    cpu: {
+        usage: {
+            userPct: number;
+            systemPct: number;
+            idlePct: number;
+            iowaitPct: number;
+        } | null;
+        count: number;
+        models: Record<string, number>;
+        loadAvg: number[];
+        platform: NodeJS.Platform;
+        arch: NodeJS.Architecture;
+        uptimeSec: number;
+    };
+    memory: {
+        total: number;
+        free: number;
+        used: number;
+        usedPct: number;
+    };
+    disk: {
+        filesystem: string;
+        size: number;
+        used: number;
+        available: number;
+        usePct: string;
+        mount: string;
+    }[] | null;
+    connections: {
+        ports: number[];
+        total: number;
+        topRemote: {
+            ip: string;
+            count: number;
+        }[];
+    } | null;
+    nginx: {
+        installed: boolean;
+        version?: undefined;
+        status?: undefined;
+        listening?: undefined;
+        workerCount?: undefined;
+    } | {
+        installed: boolean;
+        version: string;
+        status: string;
+        listening: string[];
+        workerCount: number;
+    } | {
+        installed: boolean;
+        error: string;
+    };
+    pm2: {
+        installed: boolean;
+        error?: undefined;
+        processes?: undefined;
+    } | {
+        installed: boolean;
+        error: string;
+        processes?: undefined;
+    } | {
+        installed: boolean;
+        processes: any;
+        error?: undefined;
+    } | {
+        installed: boolean;
+        error: string;
+    };
+}>;

package/dist/apiServer/monitor/SystemInfo.js

@@ -0,0 +1,218 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectSystemInfo = void 0;
+const os_1 = __importDefault(require("os"));
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const promises_1 = __importDefault(require("fs/promises"));
+const execP = (0, util_1.promisify)(child_process_1.exec);
+async function safeExec(cmd, timeoutMs = 3000) {
+    try {
+        const { stdout, stderr } = await execP(cmd, {
+            timeout: timeoutMs,
+            maxBuffer: 4 * 1024 * 1024,
+            shell: "/bin/sh",
+        });
+        return { ok: true, stdout: String(stdout ?? ""), stderr: String(stderr ?? ""), code: 0 };
+    }
+    catch (e) {
+        return {
+            ok: false,
+            stdout: e?.stdout != null ? String(e.stdout) : "",
+            stderr: e?.stderr != null ? String(e.stderr) : String(e?.message ?? e),
+            code: typeof e?.code === "number" ? e.code : -1,
+        };
+    }
+}
+async function commandExists(cmd) {
+    const r = await safeExec(`command -v ${cmd}`, 1000);
+    return r.ok && r.stdout.trim().length > 0;
+}
+function cpuStatic() {
+    const cpus = os_1.default.cpus();
+    const models = {};
+    for (const c of cpus)
+        models[c.model] = (models[c.model] ?? 0) + 1;
+    return {
+        count: cpus.length,
+        models,
+        loadAvg: os_1.default.loadavg(),
+        platform: process.platform,
+        arch: process.arch,
+        uptimeSec: os_1.default.uptime(),
+    };
+}
+async function cpuUsage(sampleMs = 200) {
+    if (process.platform !== "linux")
+        return null;
+    const read = async () => {
+        try {
+            const txt = await promises_1.default.readFile("/proc/stat", "utf-8");
+            const line = txt.split("\n", 1)[0];
+            const parts = line.split(/\s+/).slice(1).map(s => parseInt(s, 10) || 0);
+            return {
+                user: parts[0] ?? 0,
+                nice: parts[1] ?? 0,
+                system: parts[2] ?? 0,
+                idle: parts[3] ?? 0,
+                iowait: parts[4] ?? 0,
+                irq: parts[5] ?? 0,
+                softirq: parts[6] ?? 0,
+                steal: parts[7] ?? 0,
+            };
+        }
+        catch {
+            return null;
+        }
+    };
+    const a = await read();
+    if (!a)
+        return null;
+    await new Promise(r => setTimeout(r, sampleMs));
+    const b = await read();
+    if (!b)
+        return null;
+    const sum = (x) => x.user + x.nice + x.system + x.idle + x.iowait + x.irq + x.softirq + x.steal;
+    const total = sum(b) - sum(a);
+    if (total <= 0)
+        return null;
+    const pct = (delta) => Math.round((delta / total) * 1000) / 10;
+    return {
+        userPct: pct(b.user + b.nice - a.user - a.nice),
+        systemPct: pct(b.system - a.system),
+        idlePct: pct(b.idle - a.idle),
+        iowaitPct: pct(b.iowait - a.iowait),
+    };
+}
+function memory() {
+    const total = os_1.default.totalmem();
+    const free = os_1.default.freemem();
+    return {
+        total,
+        free,
+        used: total - free,
+        usedPct: Math.round(((total - free) / total) * 1000) / 10,
+    };
+}
+async function disk() {
+    const r = await safeExec("df -kP");
+    if (!r.ok)
+        return null;
+    const lines = r.stdout.split("\n").slice(1).filter(l => l.trim().length > 0);
+    return lines
+        .map(line => {
+        const parts = line.trim().split(/\s+/);
+        if (parts.length < 6)
+            return null;
+        const sizeKB = parseInt(parts[1], 10) || 0;
+        const usedKB = parseInt(parts[2], 10) || 0;
+        const availKB = parseInt(parts[3], 10) || 0;
+        return {
+            filesystem: parts[0],
+            size: sizeKB * 1024,
+            used: usedKB * 1024,
+            available: availKB * 1024,
+            usePct: parts[4],
+            mount: parts.slice(5).join(" "),
+        };
+    })
+        .filter((d) => d !== null)
+        .filter(d => !/^(tmpfs|devtmpfs|squashfs|overlay|udev|none|run)/.test(d.filesystem));
+}
+async function httpConnections(ports = [80, 443]) {
+    const portList = ports.join("|");
+    const ssCmd = `ss -tnH 2>/dev/null | awk '$1=="ESTAB" && $4 ~ /:(${portList})$/ {print $4, $5}'`;
+    let r = await safeExec(ssCmd);
+    if (!r.ok || r.stdout.trim().length === 0) {
+        const nsCmd = `netstat -tn 2>/dev/null | awk '$6=="ESTABLISHED" && $4 ~ /:(${portList})$/ {print $4, $5}'`;
+        r = await safeExec(nsCmd);
+        if (!r.ok)
+            return null;
+    }
+    const lines = r.stdout.split("\n").filter(l => l.trim().length > 0);
+    const byRemote = {};
+    for (const line of lines) {
+        const parts = line.split(/\s+/);
+        const remote = parts[1] ?? "";
+        const ipMatch = remote.match(/^\[?([^\]]+)\]?:\d+$/);
+        const ip = ipMatch ? ipMatch[1] : remote;
+        byRemote[ip] = (byRemote[ip] ?? 0) + 1;
+    }
+    const topRemote = Object.entries(byRemote)
+        .sort(([, a], [, b]) => b - a)
+        .slice(0, 20)
+        .map(([ip, count]) => ({ ip, count }));
+    return { ports, total: lines.length, topRemote };
+}
+async function nginx() {
+    const installed = await commandExists("nginx");
+    if (!installed)
+        return { installed: false };
+    const [version, status, listening, workers] = await Promise.all([
+        safeExec("nginx -v 2>&1", 1000),
+        safeExec("systemctl is-active nginx 2>/dev/null", 1000),
+        safeExec("ss -tlnH 2>/dev/null | awk '{print $4}'", 1000),
+        safeExec("pgrep -c nginx 2>/dev/null", 1000),
+    ]);
+    return {
+        installed: true,
+        version: (version.stdout || version.stderr).trim(),
+        status: status.stdout.trim() || "unknown",
+        listening: listening.stdout.split("\n").filter(l => l.trim().length > 0),
+        workerCount: parseInt(workers.stdout.trim(), 10) || 0,
+    };
+}
+async function pm2() {
+    const installed = await commandExists("pm2");
+    if (!installed)
+        return { installed: false };
+    const r = await safeExec("pm2 jlist 2>/dev/null", 3000);
+    if (!r.ok)
+        return { installed: true, error: r.stderr.slice(0, 500) };
+    const text = r.stdout;
+    const start = text.indexOf("[");
+    const end = text.lastIndexOf("]");
+    if (start === -1 || end === -1)
+        return { installed: true, error: "no JSON in pm2 jlist output" };
+    try {
+        const arr = JSON.parse(text.slice(start, end + 1));
+        const processes = arr.map((p) => ({
+            name: p.name,
+            pid: p.pid,
+            pm_id: p.pm_id,
+            status: p.pm2_env?.status,
+            uptime: p.pm2_env?.pm_uptime,
+            restarts: p.pm2_env?.restart_time,
+            cpu: p.monit?.cpu,
+            memory: p.monit?.memory,
+            exec_mode: p.pm2_env?.exec_mode,
+            instances: p.pm2_env?.instances,
+            node_version: p.pm2_env?.node_version,
+        }));
+        return { installed: true, processes };
+    }
+    catch {
+        return { installed: true, error: "Failed to parse pm2 jlist output" };
+    }
+}
+async function collectSystemInfo() {
+    const [cpuUsageData, diskData, connectionsData, nginxData, pm2Data] = await Promise.all([
+        cpuUsage().catch(() => null),
+        disk().catch(() => null),
+        httpConnections().catch(() => null),
+        nginx().catch(() => ({ installed: false, error: "probe failed" })),
+        pm2().catch(() => ({ installed: false, error: "probe failed" })),
+    ]);
+    return {
+        cpu: { ...cpuStatic(), usage: cpuUsageData },
+        memory: memory(),
+        disk: diskData,
+        connections: connectionsData,
+        nginx: nginxData,
+        pm2: pm2Data,
+    };
+}
+exports.collectSystemInfo = collectSystemInfo;