@gazzehamine/armada-watch-agent 1.0.1 → 1.3.0

package/dist/collector.js

@@ -6,9 +6,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSystemInfo = getSystemInfo;
 exports.collectMetrics = collectMetrics;
 exports.collectProcesses = collectProcesses;
+exports.collectDockerContainers = collectDockerContainers;
 const systeminformation_1 = __importDefault(require("systeminformation"));
 const os_1 = __importDefault(require("os"));
 let lastNetworkStats = null;
+let lastDiskStats = null;
 async function getSystemInfo() {
     const cpu = await systeminformation_1.default.cpu();
     return {
@@ -53,6 +55,57 @@ async function collectMetrics() {
     }
     // Uptime
     const uptime = os_1.default.uptime();
+    // Load Average (1, 5, 15 minutes)
+    const loadAvg = os_1.default.loadavg();
+    const loadAverage = [loadAvg[0], loadAvg[1], loadAvg[2]];
+    // Swap Usage
+    const swapTotal = mem.swaptotal;
+    const swapUsed = mem.swapused;
+    const swapUsage = swapTotal > 0 ? (swapUsed / swapTotal) * 100 : 0;
+    // Process Count
+    const processes = await systeminformation_1.default.processes();
+    const processCount = processes.all;
+    // Disk I/O (reads/writes per second)
+    const diskIO = await systeminformation_1.default.disksIO();
+    let diskReadPs = 0;
+    let diskWritePs = 0;
+    if (lastDiskStats) {
+        const timeDiff = (Date.now() - lastDiskStats.timestamp) / 1000; // seconds
+        diskReadPs = (diskIO.rIO - lastDiskStats.rIO) / timeDiff;
+        diskWritePs = (diskIO.wIO - lastDiskStats.wIO) / timeDiff;
+    }
+    lastDiskStats = {
+        rIO: diskIO.rIO,
+        wIO: diskIO.wIO,
+        timestamp: Date.now(),
+    };
+    // Phase 2: TCP Connections
+    const networkConnections = await systeminformation_1.default.networkConnections();
+    const tcpConnections = networkConnections.filter(c => c.protocol === 'tcp').length;
+    const tcpEstablished = networkConnections.filter(c => c.protocol === 'tcp' && c.state === 'ESTABLISHED').length;
+    const tcpTimeWait = networkConnections.filter(c => c.protocol === 'tcp' && c.state === 'TIME_WAIT').length;
+    // Phase 2: Network Errors and Drops
+    const networkErrorsRaw = mainInterface ? (mainInterface.rx_errors + mainInterface.tx_errors) : 0;
+    const networkDroppedRaw = mainInterface ? (mainInterface.rx_dropped + mainInterface.tx_dropped) : 0;
+    // Return totals (can be used to calculate rates if needed)
+    const networkErrors = networkErrorsRaw;
+    const networkDropped = networkDroppedRaw;
+    // Phase 2: Docker Containers (if Docker is available)
+    let dockerContainersRunning = 0;
+    let dockerContainersStopped = 0;
+    let dockerContainersTotal = 0;
+    try {
+        const dockerContainers = await systeminformation_1.default.dockerContainers();
+        dockerContainersTotal = dockerContainers.length;
+        dockerContainersRunning = dockerContainers.filter(c => c.state === 'running').length;
+        dockerContainersStopped = dockerContainers.filter(c => c.state !== 'running').length;
+    }
+    catch (error) {
+        // Docker not available or not running
+        dockerContainersTotal = 0;
+        dockerContainersRunning = 0;
+        dockerContainersStopped = 0;
+    }
     return {
         cpuUsage,
         memoryUsage,
@@ -64,6 +117,21 @@ async function collectMetrics() {
         networkRx,
         networkTx,
         uptime,
+        loadAverage,
+        swapUsage,
+        swapTotal,
+        swapUsed,
+        processCount,
+        diskReadPs,
+        diskWritePs,
+        tcpConnections,
+        tcpEstablished,
+        tcpTimeWait,
+        networkErrors,
+        networkDropped,
+        dockerContainersRunning,
+        dockerContainersStopped,
+        dockerContainersTotal,
     };
 }
 async function collectProcesses() {
@@ -79,3 +147,33 @@ async function collectProcesses() {
         memory: p.mem,
     }));
 }
+async function collectDockerContainers() {
+    try {
+        const dockerContainers = await systeminformation_1.default.dockerContainers();
+        return dockerContainers.map((container) => ({
+            id: container.id || '',
+            name: container.name || '',
+            image: container.image || '',
+            state: container.state || 'unknown',
+            status: container.state || 'unknown',
+            created: container.created || 0,
+            started: container.started || 0,
+            cpuPercent: container.cpuPercent || 0,
+            memoryPercent: container.memPercent || 0,
+            memoryUsage: container.memUsage || 0,
+            memoryLimit: container.memLimit || 0,
+            netIO: {
+                rx: container.netIO?.rx || 0,
+                wx: container.netIO?.wx || 0,
+            },
+            blockIO: {
+                r: container.blockIO?.r || 0,
+                w: container.blockIO?.w || 0,
+            },
+        }));
+    }
+    catch (error) {
+        // Docker not available or not running
+        return [];
+    }
+}

package/dist/index.js

@@ -48,6 +48,7 @@ async function sendMetrics() {
     try {
         const metrics = await (0, collector_1.collectMetrics)();
         const processes = await (0, collector_1.collectProcesses)();
+        const dockerContainers = await (0, collector_1.collectDockerContainers)();
         const payload = {
             instanceInfo,
             metrics: {
@@ -55,6 +56,7 @@ async function sendMetrics() {
                 ...metrics,
             },
             processes,
+            dockerContainers,
         };
         await axios_1.default.post(`${SERVER_URL}/api/metrics`, payload, {
             timeout: 5000,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gazzehamine/armada-watch-agent",
-  "version": "1.0.1",
+  "version": "1.3.0",
   "description": "Monitoring agent for Armada Watch - EC2 instance monitoring",
   "main": "dist/index.js",
   "bin": {