chore(deploy): add server metrics collection feature

- 新增服务器性能指标采集功能，支持采集CPU/内存/磁盘/网络等实时指标
- 后端新增 collectServerMetrics 和 collectAllServerMetrics 方法
- 新增定时任务，每5分钟自动采集所有已启用服务器的性能指标
- 前端服务器管理页面新增单个和批量采集性能指标按钮
- 修复 CircularProgress 组件 Canvas 渲染时非有限值导致的错误
- 修复 Dashboard 页面 servers?.slice 非数组类型报错

Author: 谭策

README.md

@@ -15,7 +15,7 @@
 
 企业级 IT 运维多 Agent 自动化平台 — 基于大语言模型的智能运维解决方案。
 
-[项目愿景与社区共建](docs/项目愿景与社区共建.md)     [项目入门学习文档](docs/book/README.md)
+[项目愿景与社区共建](docs/项目愿景与社区共建.md) [项目入门学习文档](docs/book/README.md)
 
 [![CI](https://github.com/qinshihu/itops-agent-platform/actions/workflows/ci.yml/badge.svg)](https://github.com/qinshihu/itops-agent-platform/actions/workflows/ci.yml)
 [![Release](https://github.com/qinshihu/itops-agent-platform/actions/workflows/release.yml/badge.svg)](https://github.com/qinshihu/itops-agent-platform/actions/workflows/release.yml)

backend/src/routes/serverManagementRoutes.ts

@@ -26,6 +26,28 @@ router.post('/collect-all', async (_req, res) => {
   }
 });
 
+router.post('/:id/collect-metrics', async (req, res) => {
+  try {
+    const result = await serverInfoCollector.collectServerMetrics(req.params.id);
+    if (result.success) {
+      res.json({ success: true, data: result.data });
+    } else {
+      res.status(400).json({ success: false, error: result.error });
+    }
+  } catch (err) {
+    res.status(500).json({ success: false, error: err instanceof Error ? err.message : 'Unknown error' });
+  }
+});
+
+router.post('/collect-all-metrics', async (_req, res) => {
+  try {
+    const result = await serverInfoCollector.collectAllServerMetrics();
+    res.json({ success: true, data: result });
+  } catch (err) {
+    res.status(500).json({ success: false, error: err instanceof Error ? err.message : 'Unknown error' });
+  }
+});
+
 router.post('/import', async (req, res) => {
   try {
     const { servers, test_connection } = req.body as {

backend/src/services/schedulerService.ts

@@ -4,6 +4,7 @@ import db, { performMaintenance } from '../models/database';
 import { logger } from '../utils/logger';
 import { executeWorkflow } from './workflowExecutor';
 import { WorkflowParsed, WorkflowNode, WorkflowEdge } from '../types';
+import { serverInfoCollector } from './serverInfoCollector';
 
 interface ScheduledTaskRecord {
   id: string;
@@ -37,6 +38,9 @@ class SchedulerService {
       // 启动数据库定期维护任务
       this.initDatabaseMaintenance();
 
+      // 启动服务器性能指标定期采集任务（每5分钟）
+      this.initMetricsCollection();
+      
       this.initialized = true;
       logger.info(`✅ Scheduler initialized with ${tasks.length} tasks`);
     } catch (e) {
@@ -76,6 +80,28 @@ class SchedulerService {
     logger.info('✅ Database maintenance scheduled: daily at 3:00 AM');
   }
 
+  /**
+   * 初始化服务器性能指标定期采集任务（每 5 分钟）
+   */
+  private initMetricsCollection() {
+    const metricsJob = scheduleJob('*/5 * * * *', async () => {
+      logger.info('📊 Starting scheduled server metrics collection...');
+      
+      try {
+        const result = await serverInfoCollector.collectAllServerMetrics();
+        logger.info(`✅ Scheduled metrics collection completed: ${result.success} success, ${result.failed} failed`);
+        if (result.failed > 0) {
+          logger.warn(`️ Failed metrics collection: ${JSON.stringify(result.errors)}`);
+        }
+      } catch (error) {
+        logger.error('❌ Scheduled metrics collection failed', error as Error);
+      }
+    });
+    
+    this.jobs.set('metrics-collection', metricsJob);
+    logger.info('✅ Server metrics collection scheduled: every 5 minutes');
+  }
+
   scheduleTask(task: ScheduledTaskRecord) {
     // 先取消已存在的任务
     this.cancelTask(task.id);

backend/src/services/serverInfoCollector.ts

@@ -2,6 +2,7 @@ import { Client } from 'ssh2';
 import db from '../models/database';
 import { sshPool } from './sshService';
 import { logger } from '../utils/logger';
+import { v4 as uuidv4 } from 'uuid';
 
 interface ServerInfo {
   id: string;
@@ -28,6 +29,26 @@ interface ServerInfoResult {
   };
 }
 
+interface ServerMetricsResult {
+  success: boolean;
+  error?: string;
+  data?: {
+    cpu_usage: number;
+    memory_usage: number;
+    memory_total_gb: number;
+    memory_used_gb: number;
+    disk_usage: number;
+    disk_total_gb: number;
+    disk_used_gb: number;
+    network_in_mbps: number;
+    network_out_mbps: number;
+    load_1min: number;
+    load_5min: number;
+    load_15min: number;
+    uptime_seconds: number;
+  };
+}
+
 class ServerInfoCollector {
   private static readonly CONNECT_TIMEOUT = 10000;
 
@@ -146,6 +167,224 @@ class ServerInfoCollector {
 
     return { success, failed: errors.length, errors };
   }
+
+  async collectServerMetrics(serverId: string): Promise<ServerMetricsResult> {
+    const server = db.prepare('SELECT * FROM servers WHERE id = ?').get(serverId) as ServerInfo | undefined;
+
+    if (!server || !server.enabled) {
+      return { success: false, error: 'Server not found or disabled' };
+    }
+
+    let conn: Client | null = null;
+
+    return new Promise((resolve) => {
+      sshPool.acquire(serverId).then((connection) => {
+        conn = connection;
+      }).catch((error) => {
+        resolve({ success: false, error: error instanceof Error ? error.message : 'Failed to acquire SSH connection' });
+        return;
+      }).then(() => {
+        if (!conn) return;
+
+        let isResolved = false;
+
+        const safeResolve = (result: ServerMetricsResult) => {
+          if (!isResolved) {
+            isResolved = true;
+            if (conn) {
+              sshPool.release(conn, result.success);
+            }
+            resolve(result);
+          }
+        };
+
+        const commands = {
+          cpu_usage: `top -bn1 | grep "Cpu(s)" | awk '{print 100 - $8}' || cat /proc/stat | awk '/^cpu / {print ($2+$4)*100/($2+$4+$5)}'`,
+          memory: `free -m | awk '/^Mem:/{printf "%.1f %.1f %.1f", $2/1024, $3/1024, $3*100/$2}'`,
+          disk: `df -m --output=source,size,used,pcent / 2>/dev/null | tail -1 | awk '{print $2/1024, $3/1024, $4}' || df -BM / | tail -1 | awk '{print $2, $3, $5}'`,
+          network: `cat /proc/net/dev 2>/dev/null | grep -v lo: | awk 'NR>2 {rx+=$2; tx+=$10} END {printf "%.2f %.2f", rx/1024/1024, tx/1024/1024}' || echo "0 0"`,
+          load: `cat /proc/loadavg 2>/dev/null | awk '{print $1, $2, $3}' || uptime | awk -F'load average:' '{print $2}'`,
+          uptime: `cat /proc/uptime 2>/dev/null | awk '{print int($1)}' || echo "0"`
+        };
+
+        const results: Record<string, string> = {};
+        let completed = 0;
+        const total = Object.keys(commands).length;
+
+        const checkComplete = () => {
+          completed++;
+          if (completed === total) {
+            try {
+              const data = this.parseMetricsResults(results);
+
+              db.prepare(`
+                INSERT INTO server_metrics (
+                  id, server_id, cpu_usage, memory_usage, memory_total_gb, memory_used_gb,
+                  disk_usage, disk_total_gb, disk_used_gb, network_in_mbps, network_out_mbps,
+                  load_1min, load_5min, load_15min, uptime_seconds, collected_at
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+              `).run(
+                uuidv4(),
+                serverId,
+                data.cpu_usage,
+                data.memory_usage,
+                data.memory_total_gb,
+                data.memory_used_gb,
+                data.disk_usage,
+                data.disk_total_gb,
+                data.disk_used_gb,
+                data.network_in_mbps,
+                data.network_out_mbps,
+                data.load_1min,
+                data.load_5min,
+                data.load_15min,
+                data.uptime_seconds
+              );
+
+              logger.info(`Server metrics collected for ${server.name} (${serverId}): CPU=${data.cpu_usage?.toFixed(1)}%`);
+              safeResolve({ success: true, data });
+            } catch (error) {
+              logger.error(`Failed to save metrics for ${serverId}:`, error);
+              safeResolve({ success: false, error: error instanceof Error ? error.message : 'Failed to save metrics' });
+            }
+          }
+        };
+
+        for (const [key, cmd] of Object.entries(commands)) {
+          conn!.exec(cmd, (err, stream) => {
+            if (err) {
+              results[key] = '';
+              checkComplete();
+              return;
+            }
+
+            let output = '';
+            stream.on('data', (data: Buffer) => {
+              output += data.toString('utf-8');
+            });
+
+            stream.on('close', () => {
+              results[key] = output.trim();
+              checkComplete();
+            });
+
+            stream.stderr.on('data', () => { /* ignore stderr */ });
+          });
+        }
+      });
+    });
+  }
+
+  private parseMetricsResults(results: Record<string, string>): ServerMetricsResult['data'] {
+    let cpu_usage = 0;
+    try {
+      const cpuStr = results.cpu_usage.trim();
+      if (cpuStr) {
+        cpu_usage = parseFloat(cpuStr);
+        if (isNaN(cpu_usage) || cpu_usage < 0 || cpu_usage > 100) {
+          cpu_usage = 0;
+        }
+      }
+    } catch {
+      cpu_usage = 0;
+    }
+
+    let memory_usage = 0, memory_total_gb = 0, memory_used_gb = 0;
+    try {
+      const memParts = results.memory.trim().split(/\s+/);
+      if (memParts.length >= 3) {
+        memory_total_gb = parseFloat(memParts[0]);
+        memory_used_gb = parseFloat(memParts[1]);
+        memory_usage = parseFloat(memParts[2]);
+      }
+    } catch {
+      // defaults
+    }
+
+    let disk_usage = 0, disk_total_gb = 0, disk_used_gb = 0;
+    try {
+      const diskParts = results.disk.trim().split(/\s+/);
+      if (diskParts.length >= 3) {
+        const sizeStr = diskParts[0].replace(/[A-Za-z]/g, '');
+        const usedStr = diskParts[1].replace(/[A-Za-z]/g, '');
+        const pcentStr = diskParts[2].replace('%', '');
+        disk_total_gb = parseFloat(sizeStr);
+        disk_used_gb = parseFloat(usedStr);
+        disk_usage = parseFloat(pcentStr);
+      }
+    } catch {
+      // defaults
+    }
+
+    let network_in_mbps = 0, network_out_mbps = 0;
+    try {
+      const netParts = results.network.trim().split(/\s+/);
+      if (netParts.length >= 2) {
+        network_in_mbps = parseFloat(netParts[0]);
+        network_out_mbps = parseFloat(netParts[1]);
+      }
+    } catch {
+      // defaults
+    }
+
+    let load_1min = 0, load_5min = 0, load_15min = 0;
+    try {
+      const loadParts = results.load.trim().split(/[\s,]+/).filter(s => s);
+      if (loadParts.length >= 3) {
+        load_1min = parseFloat(loadParts[0]);
+        load_5min = parseFloat(loadParts[1]);
+        load_15min = parseFloat(loadParts[2]);
+      }
+    } catch {
+      // defaults
+    }
+
+    let uptime_seconds = 0;
+    try {
+      uptime_seconds = parseInt(results.uptime.trim(), 10) || 0;
+    } catch {
+      // defaults
+    }
+
+    return {
+      cpu_usage: isNaN(cpu_usage) ? 0 : cpu_usage,
+      memory_usage: isNaN(memory_usage) ? 0 : memory_usage,
+      memory_total_gb: isNaN(memory_total_gb) ? 0 : memory_total_gb,
+      memory_used_gb: isNaN(memory_used_gb) ? 0 : memory_used_gb,
+      disk_usage: isNaN(disk_usage) ? 0 : disk_usage,
+      disk_total_gb: isNaN(disk_total_gb) ? 0 : disk_total_gb,
+      disk_used_gb: isNaN(disk_used_gb) ? 0 : disk_used_gb,
+      network_in_mbps: isNaN(network_in_mbps) ? 0 : network_in_mbps,
+      network_out_mbps: isNaN(network_out_mbps) ? 0 : network_out_mbps,
+      load_1min: isNaN(load_1min) ? 0 : load_1min,
+      load_5min: isNaN(load_5min) ? 0 : load_5min,
+      load_15min: isNaN(load_15min) ? 0 : load_15min,
+      uptime_seconds: uptime_seconds
+    };
+  }
+
+  async collectAllServerMetrics(): Promise<{
+    success: number;
+    failed: number;
+    errors: Array<{ serverId: string; serverName: string; error: string }>;
+  }> {
+    const servers = db.prepare('SELECT id, name FROM servers WHERE enabled = 1').all() as { id: string; name: string }[];
+    
+    const errors: Array<{ serverId: string; serverName: string; error: string }> = [];
+    let success = 0;
+
+    for (const server of servers) {
+      const result = await this.collectServerMetrics(server.id);
+      if (result.success) {
+        success++;
+      } else {
+        errors.push({ serverId: server.id, serverName: server.name, error: result.error || 'Unknown error' });
+      }
+    }
+
+    logger.info(`Metrics collection completed: ${success} success, ${errors.length} failed`);
+    return { success, failed: errors.length, errors };
+  }
 }
 
 export const serverInfoCollector = new ServerInfoCollector();