feat(alert-center): 添加飞书Webhook通知渠道 + 告警引擎实时通知

- 后端: NotifyChannel 模型新增 feishu 类型, FeishuWebhookConfig
- 后端: TestNotifyChannel 真实发送飞书测试消息(文本格式)
- 后端: 告警引擎触发/恢复时自动发送飞书通知(sendFeishuAlert/sendFeishuRecovery)
- 后端: AlertEngine 新增 tcp_time_wait/tcp_close_wait/service_process 指标检测
- 后端: NetworkStatModel 新增 TCPCloseWait 字段
- 后端: QuickSetupRules 一键创建6条告警规则(CPU/内存/磁盘/TIME_WAIT/CLOSE_WAIT/进程)
- 后端: 注册 /alerts/quick-setup 路由
- 前端: AlertChannelDialog 新增飞书类型选项
- 前端: helpers 新增 getChannelIcon/getChannelTypeLabel 支持 feishu/dingtalk/wechat
This commit is contained in:
attacker committed 2026-06-24 08:34:43 +00:00
1 parent 7bc5169e8f
commit 5333f6f04a
30 files changed
+2406 -1001

No files matched your search

+193 -49
View File
@@ -1,7 +1,13 @@
// Package main 是 AIOps Agent 的入口。
// Agent 定时采集 CPU、内存、磁盘及监听端口指标,并通过 HTTP 上报至 AIOps 后端。
// Agent 定时采集 CPU、内存、磁盘、端口、进程 TOP、Swap、FD、上下文切换等指标,
// 并通过 HTTP 上报至 AIOps 后端。
//
// 以下变量可在编译时通过 -ldflags "-X main.version=... -X main.buildTime=..." 注入。
// 优化要点(1000 台服务器规模):
// - 启动随机 Jitter 避免惊群效应
// - 连接池复用 HTTP Keep-Alive
// - 进程 TOP 限制为 3(可配置)
// - Agent 自检心跳(序列号丢包检测)
// - 端口变化率采集(增量检测,减少 payload)
//
// 署名 Logan.Li
package main
@@ -9,10 +15,13 @@ package main
import (
"context"
"flag"
"fmt"
"log"
"math/rand"
"net"
"os"
"os/signal"
"runtime"
"syscall"
"time"
@@ -22,23 +31,21 @@ import (
"ezops/agent/task"
)
// 编译时可注入的版本信息
var (
version = "dev"
buildTime = "unknown"
)
func main() {
server := flag.String("server", "http://localhost:8080", "AIOps 后端上报地址(含 scheme 与端口)")
server := flag.String("server", "http://localhost:8080", "AIOps 后端上报地址")
interval := flag.Int("interval", 10, "采集与上报间隔,单位:秒")
token := flag.String("token", "", "Bearer 鉴权令牌")
hostnameFlag := flag.String("hostname", "", "上报主机名,默认使用系统主机名")
topN := flag.Int("top-n", 3, "进程 TOP N 数量")
flag.Parse()
// 统一日志格式:带微秒时间戳,便于排查问题
logger := log.New(os.Stdout, "[aiops-agent] ", log.LstdFlags|log.Lmicroseconds)
// 解析主机名:优先使用 -hostname,否则回退到 os.Hostname()
hostname := *hostnameFlag
if hostname == "" {
if h, err := os.Hostname(); err == nil {
@@ -48,50 +55,52 @@ func main() {
}
}
// 参数校验
if *server == "" {
logger.Fatal("参数 -server 不能为空")
}
if *interval < 1 {
logger.Fatalf("参数 -interval 必须 >= 1,当前为 %d", *interval)
if *interval < 5 {
logger.Fatalf("参数 -interval 必须 >= 5,当前为 %d(1000 台规模推荐 30~60s)", *interval)
}
logger.Printf("AIOps Agent 启动: version=%s buildTime=%s", version, buildTime)
logger.Printf("配置: server=%s interval=%ds hostname=%q token=%s",
*server, *interval, hostname, maskToken(*token))
logger.Printf("AIOps Agent v%s (built %s) go=%s", version, buildTime, runtime.Version())
logger.Printf("配置: server=%s interval=%ds top-n=%d hostname=%q", *server, *interval, *topN, hostname)
// 初始化各采集器与上报器
// ═══ 初始化采集器 ═══
cpuCollector := collector.NewCPUCollector()
memCollector := collector.NewMemCollector()
diskCollector := collector.NewDiskCollector()
portCollector := collector.NewPortCollector()
netCollector := collector.NewNetworkCollector()
diskIOCollector := collector.NewDiskIOCollector()
procTopCollector := collector.NewProcessTopCollector()
swapCollector := collector.NewSwapCollector()
rep := reporter.New(*server, *token, logger)
// 采集系统静态信息(OS/内核),仅在启动时执行一次
// 系统静态信息(仅启动时一次)
sysInfo := collector.CollectSystem()
logger.Printf("系统信息: OS=%q Kernel=%q", sysInfo.OSVersion, sysInfo.Kernel)
// 探测本机主 IP(用于后端匹配 servers 表)
// 探测本机 IP
localIP := detectLocalIP()
logger.Printf("探测本机 IP: %s", localIP)
// 系统信息上报计数器:前 3 次上报携带系统信息,确保后端至少收到一次
sysReportCount := 0
sysReportCount := 0 // 前 3 次上报携带系统信息
// 初始化任务执行器与任务客户端(与 reporter 复用相同的 server/token/hostname)
// 任务执行器
taskExecutor := task.New(logger)
taskClient := task.NewClient(*server, *token, hostname, logger)
// 监听 SIGINT / SIGTERM,支持优雅退出
// ═══ 启动随机 Jitter:避免 1000 台同时上报 ═══
startupJitter := time.Duration(rand.Intn(*interval)) * time.Second
logger.Printf("启动 Jitter: %v(防止惊群效应)", startupJitter)
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
defer stop()
ticker := time.NewTicker(time.Duration(*interval) * time.Second)
defer ticker.Stop()
// Agent 自检序列号
var reportSeq uint64
// collectAndReport 执行单次采集并上报;各项采集独立进行,单项失败不影响整体上报
// collectAndReport 执行单次采集并上报
collectAndReport := func() {
report := &model.Report{
Hostname: hostname,
@@ -100,69 +109,140 @@ func main() {
AgentVersion: version,
}
// 前 3 次上报携带系统信息
// 系统信息(前 3 次)
if sysReportCount < 3 && (sysInfo.OSVersion != "" || sysInfo.Kernel != "") {
report.System = &model.SystemStat{
OSVersion: sysInfo.OSVersion,
Kernel: sysInfo.Kernel,
Uptime: sysInfo.UptimeSeconds,
OSVersion: sysInfo.OSVersion,
Kernel: sysInfo.Kernel,
Uptime: sysInfo.UptimeSeconds,
}
sysReportCount++
}
// CPU
if stat, err := cpuCollector.Collect(); err != nil {
logger.Printf("CPU 采集异常: %v", err)
} else {
report.CPU = stat
}
// 内存
if stat, err := memCollector.Collect(); err != nil {
logger.Printf("内存采集异常: %v", err)
} else {
report.Memory = stat
}
// Swap(仅当系统配置了 swap 才上报)
if swap, err := swapCollector.Collect(); err != nil {
logger.Printf("Swap 采集异常: %v", err)
} else if swap != nil {
report.Swap = swap
}
// 磁盘
if disks, err := diskCollector.Collect(); err != nil {
logger.Printf("磁盘采集异常: %v", err)
} else {
report.Disks = disks
}
// 监听端口
if ports, err := portCollector.Collect(); err != nil {
logger.Printf("端口采集异常: %v", err)
} else {
report.Ports = ports
}
// 网络
if netStat, err := netCollector.Collect(); err != nil {
logger.Printf("网络采集异常: %v", err)
} else {
report.Network = netStat
}
// 磁盘 IO
if dioStat, err := diskIOCollector.Collect(); err != nil {
logger.Printf("磁盘IO采集异常: %v", err)
} else {
report.DiskIO = dioStat
}
// 进程 TOP N
if procs, err := procTopCollector.Collect(*topN); err != nil {
logger.Printf("进程TOP采集异常: %v", err)
} else {
report.ProcessTop = procs
}
// 系统 FD 句柄
if fdStat, err := collectFD(); err != nil {
logger.Printf("FD采集异常: %v", err)
} else {
report.FD = fdStat
}
// 上下文切换
if csStat, err := collectContextSwitches(); err != nil {
// 静默跳过(某些内核/容器环境不可用)
} else {
report.ContextSwitches = csStat
}
// Agent 自检心跳
reportSeq++
var memStats runtime.MemStats
runtime.ReadMemStats(&memStats)
report.Heartbeat = model.AgentHeartbeat{
Version: version,
UptimeSec: sysInfo.UptimeSeconds,
SelfCPU: 0, // TODO: self-CPU via /proc/self/stat
SelfRSSMB: float64(memStats.Alloc) / 1024.0 / 1024.0,
ReportSeq: reportSeq,
}
// 上报
if err := rep.Send(ctx, report); err != nil {
logger.Printf("上报失败: %v", err)
return
}
logger.Printf("上报成功: cpu=%.2f%% mem=%.2f%% disks=%d ports=%d net=%dconn/%dwait netIO=%.0f/%.0fB/s diskIO=%.0f/%.0fB/s",
report.CPU.UsagePercent, report.Memory.UsagePercent, len(report.Disks), len(report.Ports),
report.Network.TCPEstablished, report.Network.TCPTimeWait,
report.Network.NetRxBPS, report.Network.NetTxBPS,
report.DiskIO.ReadBPS, report.DiskIO.WriteBPS)
logger.Printf("上报成功: cpu=%.1f%% mem=%.1f%% swap=%.1f%% disks=%d ports=%d procs=%d fd=%d/%d cs=%.0f/s",
report.CPU.UsagePercent,
report.Memory.UsagePercent,
func() float64 {
if report.Swap != nil {
return report.Swap.UsagePercent
}
return 0
}(),
len(report.Disks),
len(report.Ports),
len(report.ProcessTop),
func() int {
if report.FD != nil {
return report.FD.Allocated
}
return 0
}(),
func() int64 {
if report.FD != nil {
return report.FD.Max
}
return 0
}(),
func() float64 {
if report.ContextSwitches != nil {
return report.ContextSwitches.CTXPerSec
}
return 0
}(),
)
}
// pollAndExecute 执行单次任务轮询:拉取待执行任务 → 逐个执行 → 回传结果。
// 网络错误只记录日志,不 panic,下一个周期继续重试。
// pollAndExecute 任务轮询
pollAndExecute := func() {
tasks, err := taskClient.Poll(ctx)
if err != nil {
// 上下文已取消(Agent 退出中)属于正常情况,不输出告警
if ctx.Err() != nil {
return
}
@@ -170,12 +250,10 @@ func main() {
return
}
if len(tasks) == 0 {
return // 暂无任务,静默返回
return
}
logger.Printf("拉取到 %d 个待执行任务", len(tasks))
for _, t := range tasks {
// Agent 退出时跳过后续任务,避免退出延迟
if ctx.Err() != nil {
return
}
@@ -191,11 +269,9 @@ func main() {
}
}
// 启动任务轮询协程:每 5 秒轮询一次,与指标采集并行运行。
// 使用独立的 5 秒固定间隔,不受 -interval 影响。
// ═══ 任务轮询协程(5s 间隔,不受 -interval 影响)═══
const taskPollInterval = 5 * time.Second
go func() {
// 启动后立即轮询一次,再按固定周期执行
pollAndExecute()
ticker := time.NewTicker(taskPollInterval)
defer ticker.Stop()
@@ -209,20 +285,23 @@ func main() {
}
}()
// 主协程:启动后立即执行一次指标采集,再按 ticker 周期执行
// ═══ 主循环:启动先 sleep jitter,再按 interval 采集 ═══
time.Sleep(startupJitter)
collectAndReport()
ticker := time.NewTicker(time.Duration(*interval) * time.Second)
defer ticker.Stop()
for {
select {
case <-ticker.C:
collectAndReport()
case <-ctx.Done():
logger.Println("收到退出信号,Agent 正在关闭...")
logger.Println("收到退出信号,Agent 正常关闭")
return
}
}
}
// maskToken 对令牌做脱敏处理,仅用于日志输出
// maskToken 对令牌做脱敏处理
func maskToken(token string) string {
if token == "" {
return "(empty)"
@@ -233,11 +312,8 @@ func maskToken(token string) string {
return token[:4] + "****"
}
// detectLocalIP 探测本机主 IP 地址。
// 通过 UDP 连接到公网地址(不实际发包),获取系统路由选择的本机 IP。
// 如果失败,回退到遍历网卡查找非 loopback 的 IPv4 地址。
// detectLocalIP 探测本机主 IP
func detectLocalIP() string {
// 方法1:通过 UDP "连接" 到公网 DNS 获取出口 IP
conn, err := net.Dial("udp", "8.8.8.8:53")
if err == nil {
defer conn.Close()
@@ -245,8 +321,6 @@ func detectLocalIP() string {
return addr.IP.String()
}
}
// 方法2:遍历网卡
ifaces, err := net.Interfaces()
if err == nil {
for _, iface := range ifaces {
@@ -263,3 +337,73 @@ func detectLocalIP() string {
}
return "unknown"
}
// ══════════════════════════════════════════════
// 补充采集器(内联简单实现,不单独建文件)
// ══════════════════════════════════════════════
// collectFD 读取 /proc/sys/fs/file-nr 和 /proc/sys/fs/file-max
func collectFD() (*model.SocketFDStat, error) {
alloc, err := os.ReadFile("/proc/sys/fs/file-nr")
if err != nil {
return nil, err
}
var allocated, _unused1, _unused2 int
fmt.Sscanf(string(alloc), "%d %d %d", &allocated, &_unused1, &_unused2)
max, err := os.ReadFile("/proc/sys/fs/file-max")
if err != nil {
return nil, err
}
var maxFD int64
fmt.Sscanf(string(max), "%d", &maxFD)
stat := &model.SocketFDStat{
Allocated: allocated,
Max: maxFD,
}
if maxFD > 0 {
stat.UsagePct = float64(allocated) / float64(maxFD) * 100.0
}
return stat, nil
}
// collectContextSwitches 读取 /proc/stat 中的 ctxt 和 intr 行
// 需要两次采样才能计算速率;这里使用简单的累计值(首次返回 0)
func collectContextSwitches() (*model.ContextSwitchStat, error) {
data, err := os.ReadFile("/proc/stat")
if err != nil {
return nil, err
}
stat := &model.ContextSwitchStat{}
lines := string(data)
for _, line := range splitLines(lines) {
if hasPrefix(line, "ctxt ") {
fmt.Sscanf(line, "ctxt %f", &stat.CTXPerSec)
}
if hasPrefix(line, "intr ") {
fmt.Sscanf(line, "intr %f", &stat.IRQPerSec)
}
}
// NOTE: 这里返回的是累计值而非速率;后端可用两次上报的差值计算速率
return stat, nil
}
func splitLines(s string) []string {
var result []string
start := 0
for i := 0; i < len(s); i++ {
if s[i] == '\n' {
result = append(result, s[start:i])
start = i + 1
}
}
if start < len(s) {
result = append(result, s[start:])
}
return result
}
func hasPrefix(s, prefix string) bool {
return len(s) >= len(prefix) && s[:len(prefix)] == prefix
}