analytics-node-agent 1.0.0

package/.vscode/settings.json

@@ -0,0 +1,4 @@
+{
+    "java.configuration.updateBuildConfiguration": "interactive",
+    "window.title": "Assessment Analytics Node Agent"
+}

package/index.js

@@ -0,0 +1,241 @@
+import express from 'express'
+import si from 'systeminformation'
+
+const app = express()
+const PORT = process.env.PORT || 9100
+
+// Force every response to be plain JSON — avoids Content-Type issues on Linux
+app.use((req, res, next) => {
+    res.setHeader('Content-Type', 'application/json')
+    next()
+})
+
+// Strips systeminformation's non-plain objects → guaranteed POJO for axios / Mongoose
+const toPlain = obj => JSON.parse(JSON.stringify(obj ?? null))
+
+// ── Cache static CPU info at startup (never changes) ──────────────────────────
+let cpuStaticCache = null
+let memLayoutCache = null   // also static — physical DIMM slots never change
+
+async function getCpuStatic() {
+    if (cpuStaticCache) return cpuStaticCache
+    try {
+        const [cpu, cpuCache] = await Promise.all([
+            si.cpu(),
+            si.cpuCache(),
+        ])
+        cpuStaticCache = toPlain({
+            manufacturer: cpu.manufacturer ?? null,
+            brand: cpu.brand ?? null,
+            vendor: cpu.vendor ?? null,
+            family: cpu.family ?? null,
+            model: cpu.model ?? null,
+            stepping: cpu.stepping ?? null,
+            revision: cpu.revision ?? null,
+            speed: cpu.speed ?? null,
+            speedMin: cpu.speedMin ?? null,
+            speedMax: cpu.speedMax ?? null,
+            cores: cpu.cores ?? null,
+            physicalCores: cpu.physicalCores ?? null,
+            processors: cpu.processors ?? null,
+            socket: cpu.socket ?? null,
+            flags: cpu.flags ?? null,
+            virtualization: cpu.virtualization ?? false,
+            cache: {
+                l1d: cpuCache.l1d ?? null,
+                l1i: cpuCache.l1i ?? null,
+                l2: cpuCache.l2 ?? null,
+                l3: cpuCache.l3 ?? null,
+            },
+        })
+    } catch (err) {
+        console.warn('[agent] CPU static info failed:', err.message)
+        cpuStaticCache = null
+    }
+    return cpuStaticCache
+}
+
+async function getMemLayout() {
+    if (memLayoutCache) return memLayoutCache
+    try {
+        const layout = await si.memLayout()
+        memLayoutCache = toPlain(
+            (Array.isArray(layout) ? layout : []).map(slot => ({
+                size: slot.size ?? null,
+                bank: slot.bank ?? null,
+                type: slot.type ?? null,
+                clockSpeed: slot.clockSpeed ?? null,
+                formFactor: slot.formFactor ?? null,
+                manufacturer: slot.manufacturer ?? null,
+                partNum: slot.partNum ?? null,
+                serialNum: slot.serialNum ?? null,
+                voltageConfigured: slot.voltageConfigured ?? null,
+            }))
+        )
+    } catch (err) {
+        console.warn('[agent] memLayout failed:', err.message)
+        memLayoutCache = []
+    }
+    return memLayoutCache
+}
+
+// Warm up caches on startup
+getCpuStatic()
+getMemLayout()
+
+// ── Health ────────────────────────────────────────────────────────────────────
+app.get('/health', (req, res) => {
+    res.end(JSON.stringify({ status: 'ok', timestamp: new Date().toISOString() }))
+})
+
+// ── CPU Static Info ───────────────────────────────────────────────────────────
+app.get('/cpu-info', async (req, res) => {
+    try {
+        const info = await getCpuStatic()
+        if (!info) return res.status(503).end(JSON.stringify({ error: 'CPU info unavailable' }))
+        res.end(JSON.stringify({ cpuInfo: info }))
+    } catch (err) {
+        res.status(500).end(JSON.stringify({ error: err.message }))
+    }
+})
+
+// ── System (CPU load + RAM + Network) ────────────────────────────────────────
+app.get('/system', async (req, res) => {
+    try {
+        const [cpuLoad, mem, net] = await Promise.all([
+            si.currentLoad(),
+            si.mem(),
+            si.networkStats(),
+        ])
+
+        // memLayout is cached — no extra I/O on every poll
+        const layout = await getMemLayout()
+
+        const cpu = toPlain({
+            currentLoad: parseFloat((cpuLoad.currentLoad ?? 0).toFixed(2)),
+            avgLoad: parseFloat((cpuLoad.avgLoad ?? 0).toFixed(2)),
+            currentLoadUser: parseFloat((cpuLoad.currentLoadUser ?? 0).toFixed(2)),
+            currentLoadSystem: parseFloat((cpuLoad.currentLoadSystem ?? 0).toFixed(2)),
+            currentLoadIdle: parseFloat((cpuLoad.currentLoadIdle ?? 0).toFixed(2)),
+            currentLoadIrq: parseFloat((cpuLoad.currentLoadIrq ?? 0).toFixed(2)),
+            cores: (cpuLoad.cpus ?? []).map((core, i) => ({
+                core: i,
+                currentLoad: parseFloat((core.load ?? 0).toFixed(2)),
+                currentLoadUser: parseFloat((core.loadUser ?? 0).toFixed(2)),
+                currentLoadSystem: parseFloat((core.loadSystem ?? 0).toFixed(2)),
+                currentLoadIdle: parseFloat((core.loadIdle ?? 0).toFixed(2)),
+                currentLoadIrq: parseFloat((core.loadIrq ?? 0).toFixed(2)),
+            })),
+        })
+
+        const ram = toPlain({
+            total: mem.total ?? null,
+            used: mem.active ?? null,
+            free: mem.available ?? null,
+            buffcache: mem.buffcache ?? null,
+            usedPercent: parseFloat(((mem.active / mem.total) * 100).toFixed(2)),
+            swapTotal: mem.swaptotal ?? null,
+            swapUsed: mem.swapused ?? null,
+            swapFree: mem.swapfree ?? null,
+            swapPercent: mem.swaptotal > 0
+                ? parseFloat(((mem.swapused / mem.swaptotal) * 100).toFixed(2))
+                : 0,
+            layout,   // already a plain array from cache
+        })
+
+        const network = toPlain(
+            (Array.isArray(net) ? net : []).map(n => ({
+                iface: n.iface ?? null,
+                operstate: n.operstate ?? null,
+                rx_bytes: n.rx_bytes ?? null,
+                tx_bytes: n.tx_bytes ?? null,
+                rx_sec: Math.max(0, n.rx_sec ?? 0),
+                tx_sec: Math.max(0, n.tx_sec ?? 0),
+                rx_dropped: n.rx_dropped ?? null,
+                tx_dropped: n.tx_dropped ?? null,
+                rx_errors: n.rx_errors ?? null,
+                tx_errors: n.tx_errors ?? null,
+                ms: n.ms ?? null,
+            }))
+        )
+
+        res.end(JSON.stringify({ cpu, ram, network }))
+    } catch (err) {
+        res.status(500).end(JSON.stringify({ error: err.message }))
+    }
+})
+
+// ── Disk (filesystem + block devices + I/O stats) ────────────────────────────
+app.get('/disk', async (req, res) => {
+    try {
+        const [fsSizes, fsStats, blockDevices, diskIO] = await Promise.all([
+            si.fsSize(),
+            si.fsStats(),
+            si.blockDevices(),
+            si.disksIO(),
+        ])
+
+        // Normalise fsStats → always an array
+        const fsStatsArray = Array.isArray(fsStats)
+            ? fsStats
+            : (fsStats && typeof fsStats === 'object' ? [fsStats] : [])
+
+        const disk = toPlain(
+            (Array.isArray(fsSizes) ? fsSizes : [])
+                .filter(d => d.size > 0)
+                .map(d => {
+                    const stat = fsStatsArray.find(s => s.fs === d.fs) ?? null
+                    return {
+                        fs: d.fs ?? null,
+                        mount: d.mount ?? null,
+                        type: d.type ?? null,
+                        size: d.size ?? null,
+                        used: d.used ?? null,
+                        available: d.available ?? null,
+                        usePercent: parseFloat((d.use ?? 0).toFixed(2)),
+                        rx_sec: stat ? Math.max(0, stat.rx_sec ?? 0) : null,
+                        wx_sec: stat ? Math.max(0, stat.wx_sec ?? 0) : null,
+                        tx_sec: stat ? Math.max(0, stat.tx_sec ?? 0) : null,
+                    }
+                })
+        )
+
+        const blockDevs = toPlain(
+            (Array.isArray(blockDevices) ? blockDevices : [])
+                .filter(d => d.type === 'disk' || d.type === 'part')
+                .map(d => ({
+                    name: d.name ?? null,
+                    type: d.type ?? null,
+                    fstype: d.fstype ?? null,
+                    mount: d.mount ?? null,
+                    size: d.size ?? null,
+                    physical: d.physical ?? null,
+                    removable: d.removable ?? false,
+                    protocol: d.protocol ?? null,
+                    label: d.label ?? null,
+                }))
+        )
+
+        const ioStats = toPlain([{
+            rIO: diskIO?.rIO ?? null,
+            wIO: diskIO?.wIO ?? null,
+            tIO: diskIO?.tIO ?? null,
+            rIO_sec: diskIO?.rIO_sec ?? null,
+            wIO_sec: diskIO?.wIO_sec ?? null,
+            tIO_sec: diskIO?.tIO_sec ?? null,
+            rBytesPerSec: diskIO?.rBytesPerSec ?? null,
+            wBytesPerSec: diskIO?.wBytesPerSec ?? null,
+            tBytesPerSec: diskIO?.tBytesPerSec ?? null,
+            ms: diskIO?.ms ?? null,
+        }])
+
+        res.end(JSON.stringify({ disk, blockDevices: blockDevs, diskIO: ioStats }))
+    } catch (err) {
+        res.status(500).end(JSON.stringify({ error: err.message }))
+    }
+})
+
+// ── Start ─────────────────────────────────────────────────────────────────────
+app.listen(PORT, () => {
+    console.log(`✅ node-agent running on port ${PORT}`)
+})

package/nodemon.json

@@ -0,0 +1,9 @@
+{
+    "watch": [
+        "index.js"
+    ],
+    "ext": "js",
+    "ignore": [
+        "node_modules/"
+    ]
+}

package/package.json

@@ -0,0 +1,18 @@
+
+{
+  "name": "analytics-node-agent",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "index.js",
+  "scripts": {
+    "start": "node index.js",
+    "dev": "nodemon index.js"
+  },
+  "dependencies": {
+    "express": "^4.18.2",
+    "systeminformation": "^5.22.0"
+  },
+  "devDependencies": {
+    "nodemon": "^3.0.0"
+  }
+}