@gazzehamine/armada-watch-agent 1.4.2 → 1.4.4

package/dist/collector.js

@@ -7,8 +7,10 @@ exports.getSystemInfo = getSystemInfo;
 exports.collectMetrics = collectMetrics;
 exports.collectProcesses = collectProcesses;
 exports.collectDockerContainers = collectDockerContainers;
+exports.collectNginxMetrics = collectNginxMetrics;
 exports.collectPM2Processes = collectPM2Processes;
 exports.collectSSLCertificates = collectSSLCertificates;
+exports.collectSystemdServices = collectSystemdServices;
 const systeminformation_1 = __importDefault(require("systeminformation"));
 const os_1 = __importDefault(require("os"));
 const fs_1 = __importDefault(require("fs"));
@@ -263,6 +265,62 @@ async function getCertificateInfo(certPath, domain) {
         return null;
     }
 }
+/**
+ * Collect Nginx metrics from stub_status
+ */
+async function collectNginxMetrics() {
+    try {
+        // Try common nginx stub_status URLs
+        const urls = [
+            'http://localhost/nginx_status',
+            'http://localhost:80/nginx_status',
+            'http://127.0.0.1/nginx_status',
+            'http://localhost/status',
+        ];
+        for (const url of urls) {
+            try {
+                const { stdout } = await execAsync(`curl -s ${url} --max-time 2`, { timeout: 3000 });
+                if (stdout && stdout.includes('Active connections')) {
+                    // Parse nginx stub_status output
+                    // Example:
+                    // Active connections: 2
+                    // server accepts handled requests
+                    //  123 123 456
+                    // Reading: 0 Writing: 1 Waiting: 1
+                    const activeMatch = stdout.match(/Active connections:\s+(\d+)/);
+                    const serverMatch = stdout.match(/\s+(\d+)\s+(\d+)\s+(\d+)/);
+                    const rwwMatch = stdout.match(/Reading:\s+(\d+)\s+Writing:\s+(\d+)\s+Waiting:\s+(\d+)/);
+                    if (activeMatch && serverMatch && rwwMatch) {
+                        const accepts = parseInt(serverMatch[1]);
+                        const handled = parseInt(serverMatch[2]);
+                        const requests = parseInt(serverMatch[3]);
+                        // Calculate per-second rates (will be calculated from deltas in the backend)
+                        return {
+                            activeConnections: parseInt(activeMatch[1]),
+                            accepts,
+                            handled,
+                            requests,
+                            reading: parseInt(rwwMatch[1]),
+                            writing: parseInt(rwwMatch[2]),
+                            waiting: parseInt(rwwMatch[3]),
+                            requestsPerSecond: 0, // Will be calculated from deltas
+                            connectionsPerSecond: 0, // Will be calculated from deltas
+                        };
+                    }
+                }
+            }
+            catch (error) {
+                // Try next URL
+                continue;
+            }
+        }
+        // Nginx not available or stub_status not configured
+        return null;
+    }
+    catch (error) {
+        return null;
+    }
+}
 /**
  * Collect PM2 process information
  */
@@ -326,3 +384,149 @@ async function collectSSLCertificates() {
         return certificates;
     }
 }
+/**
+ * Collect systemd service information with auto-discovery
+ */
+async function collectSystemdServices() {
+    try {
+        // Check if systemd is available
+        try {
+            await execAsync('which systemctl');
+        }
+        catch (error) {
+            // systemd not available (e.g., not a Linux system or using a different init system)
+            return [];
+        }
+        const services = [];
+        // Common services to monitor
+        const COMMON_SERVICES = [
+            'nginx', 'apache2', 'httpd', // Web servers
+            'docker', 'containerd', // Containers
+            'postgresql', 'mysql', 'mariadb', // Databases
+            'mongodb', 'redis', 'memcached',
+            'ssh', 'sshd', // System services
+        ];
+        // Get all PM2 services (pm2-*)
+        let pm2Services = [];
+        try {
+            const { stdout } = await execAsync('systemctl list-units --type=service --all --no-pager --no-legend | grep "pm2-"');
+            if (stdout) {
+                pm2Services = stdout
+                    .split('\n')
+                    .filter(line => line.trim())
+                    .map(line => line.split(/\s+/)[0].replace('.service', ''));
+            }
+        }
+        catch (error) {
+            // No PM2 services or error listing them
+        }
+        // Get all failed services
+        let failedServices = [];
+        try {
+            const { stdout } = await execAsync('systemctl list-units --type=service --state=failed --no-pager --no-legend');
+            if (stdout) {
+                failedServices = stdout
+                    .split('\n')
+                    .filter(line => line.trim())
+                    .map(line => line.split(/\s+/)[0].replace('.service', ''));
+            }
+        }
+        catch (error) {
+            // No failed services or error listing them
+        }
+        // Combine all services to monitor (remove duplicates)
+        const servicesToMonitor = Array.from(new Set([...COMMON_SERVICES, ...pm2Services, ...failedServices]));
+        // Collect info for each service
+        for (const serviceName of servicesToMonitor) {
+            try {
+                const serviceInfo = await getServiceInfo(serviceName);
+                if (serviceInfo) {
+                    services.push(serviceInfo);
+                }
+            }
+            catch (error) {
+                // Service doesn't exist or error getting info, skip it
+                continue;
+            }
+        }
+        return services;
+    }
+    catch (error) {
+        console.error('Error collecting systemd services:', error);
+        return [];
+    }
+}
+/**
+ * Get detailed information for a single systemd service
+ */
+async function getServiceInfo(serviceName) {
+    try {
+        // Get detailed service properties
+        const { stdout } = await execAsync(`systemctl show ${serviceName}.service --no-pager`, { timeout: 5000 });
+        // Parse the output into key-value pairs
+        const props = {};
+        stdout.split('\n').forEach(line => {
+            const [key, ...valueParts] = line.split('=');
+            if (key && valueParts.length > 0) {
+                props[key.trim()] = valueParts.join('=').trim();
+            }
+        });
+        // Check if service exists
+        if (props.LoadState === 'not-found') {
+            return null;
+        }
+        // Extract service information
+        const activeState = props.ActiveState || 'unknown';
+        const subState = props.SubState || 'unknown';
+        const unitFileState = props.UnitFileState || 'unknown';
+        const enabled = ['enabled', 'enabled-runtime', 'static'].includes(unitFileState);
+        // Parse timestamps
+        const activeEnterTimestamp = props.ActiveEnterTimestamp ? new Date(props.ActiveEnterTimestamp).getTime() : 0;
+        const now = Date.now();
+        // Calculate uptime (in seconds)
+        let uptime = 0;
+        if (activeState === 'active' && activeEnterTimestamp > 0) {
+            uptime = Math.floor((now - activeEnterTimestamp) / 1000);
+        }
+        // Get restart count
+        const restartCount = parseInt(props.NRestarts || '0', 10);
+        // Get main PID
+        const mainPID = parseInt(props.MainPID || '0', 10);
+        // Get CPU and Memory usage
+        let cpuPercent = 0;
+        let memoryBytes = 0;
+        if (mainPID > 0) {
+            try {
+                // Use ps to get CPU and memory for the main PID
+                const { stdout: psOutput } = await execAsync(`ps -p ${mainPID} -o %cpu=,%mem=,rss= --no-headers`, { timeout: 2000 });
+                if (psOutput) {
+                    const parts = psOutput.trim().split(/\s+/);
+                    if (parts.length >= 3) {
+                        cpuPercent = parseFloat(parts[0]) || 0;
+                        // RSS is in KB, convert to bytes
+                        memoryBytes = (parseInt(parts[2], 10) || 0) * 1024;
+                    }
+                }
+            }
+            catch (error) {
+                // Process might have ended, use 0 values
+            }
+        }
+        return {
+            name: serviceName,
+            status: activeState,
+            subState: subState,
+            enabled: enabled,
+            uptime: uptime,
+            startedAt: activeEnterTimestamp,
+            restartCount: restartCount,
+            cpuPercent: cpuPercent,
+            memoryBytes: memoryBytes,
+            pid: mainPID,
+        };
+    }
+    catch (error) {
+        // Service doesn't exist or error getting info
+        return null;
+    }
+}

package/dist/index.js

@@ -76,6 +76,8 @@ async function sendMetrics() {
         const processes = await (0, collector_1.collectProcesses)();
         const dockerContainers = await (0, collector_1.collectDockerContainers)();
         const pm2Processes = await (0, collector_1.collectPM2Processes)();
+        const nginxMetrics = await (0, collector_1.collectNginxMetrics)();
+        const systemdServices = await (0, collector_1.collectSystemdServices)();
         // Check if it's time to refresh SSL certificates (every 5 minutes)
         const now = Date.now();
         const shouldCheckSSL = (now - lastSSLCheckTime) >= SSL_CHECK_INTERVAL;
@@ -95,14 +97,18 @@ async function sendMetrics() {
             processes,
             dockerContainers,
             pm2Processes: pm2Processes.length > 0 ? pm2Processes : undefined,
+            nginxMetrics: nginxMetrics || undefined,
+            systemdServices: systemdServices.length > 0 ? systemdServices : undefined,
             // Always send SSL certificates if we have them (from startup or last check)
             sslCertificates: lastSSLCertificates.length > 0 ? lastSSLCertificates : undefined,
         };
         await axios_1.default.post(`${SERVER_URL}/api/metrics`, payload, {
             timeout: 5000,
         });
-        const pm2Info = pm2Processes.length > 0 ? ` | PM2: ${pm2Processes.length} processes` : '';
-        console.log(`✓ Metrics sent successfully - CPU: ${metrics.cpuUsage.toFixed(1)}% | Memory: ${metrics.memoryUsage.toFixed(1)}%${pm2Info}`);
+        const pm2Info = pm2Processes.length > 0 ? ` | PM2: ${pm2Processes.length}` : '';
+        const nginxInfo = nginxMetrics ? ` | Nginx: ${nginxMetrics.activeConnections} conn` : '';
+        const systemdInfo = systemdServices.length > 0 ? ` | Services: ${systemdServices.length}` : '';
+        console.log(`✓ Metrics sent successfully - CPU: ${metrics.cpuUsage.toFixed(1)}% | Memory: ${metrics.memoryUsage.toFixed(1)}%${pm2Info}${nginxInfo}${systemdInfo}`);
     }
     catch (error) {
         if (axios_1.default.isAxiosError(error)) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gazzehamine/armada-watch-agent",
-  "version": "1.4.2",
-  "description": "Monitoring agent for Armada Watch - EC2 instance monitoring with SSL certificate tracking and PM2 process monitoring",
+  "version": "1.4.4",
+  "description": "Monitoring agent for Armada Watch - EC2 instance monitoring with SSL, PM2, Nginx, and Systemd monitoring",
   "main": "dist/index.js",
   "bin": {
     "armada-watch-agent": "dist/index.js"