@gazzehamine/armada-watch-agent 1.4.3 → 1.4.4

package/dist/collector.js

@@ -10,6 +10,7 @@ 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"));
@@ -383,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

@@ -77,6 +77,7 @@ async function sendMetrics() {
         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;
@@ -97,6 +98,7 @@ async function sendMetrics() {
             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,
         };
@@ -105,7 +107,8 @@ async function sendMetrics() {
         });
         const pm2Info = pm2Processes.length > 0 ? ` | PM2: ${pm2Processes.length}` : '';
         const nginxInfo = nginxMetrics ? ` | Nginx: ${nginxMetrics.activeConnections} conn` : '';
-        console.log(`✓ Metrics sent successfully - CPU: ${metrics.cpuUsage.toFixed(1)}% | Memory: ${metrics.memoryUsage.toFixed(1)}%${pm2Info}${nginxInfo}`);
+        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.3",
-  "description": "Monitoring agent for Armada Watch - EC2 instance monitoring with SSL, PM2, and Nginx 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"