Agent 告警设计:分级告警、智能降噪与值班排班

摘要 :告警体系最常见的失败不是"没配告警",而是配了 47 条规则、每次故障推 1800 条消息,最后值班同学把群静音,真故障在静音期间被彻底漏掉 。本文围绕一次真实的告警风暴事故,讲清四件事:告警分级的判据 (用户可感知 / 可自愈 / 需人工,三个问题定级);降噪的四个手段 (去重、抑制、聚合、依赖抑制,以及为什么"只做聚合"必然不够);Agent 特有的四类告警 (成本、质量漂移、循环、降级生效,以及它们各自的特殊之处------尤其是为什么质量告警不能用绝对阈值);值班排班与 runbook 的关系 。核心判断只有一句:没有 runbook 的告警等于噪音。 一条告警如果不能回答"收到后第一步做什么",它就不该存在------无论它背后的指标多有道理。

📌 版本声明 :本文基于 Python 3.11+、Prometheus + Alertmanager 告警模型 编写,撰写时间 2026 年 10 月。告警规则用 PromQL 表达,降噪机制按 Alertmanager 的 dedup / group / inhibit / silence 四类能力设计,换用其他告警平台时概念可平移。指标定义依赖第 49 篇的埋点体系,成本与质量指标分别衔接第 45 篇与第 36 篇,循环与降级告警对应第 46 篇与第 38 篇。各平台的告警语法与能力边界请以官方文档为准。

适用边界 :适用于已有第 49 篇所述监控埋点、且开始有真实值班压力 的 Agent 服务。如果你还在"只有一两个人开发、出问题自己看日志"的阶段,本文的超前部分(排班、升级策略)可以跳过,但第二、四章的分级与降噪应该在第一次告警风暴之前就做 。另外,本文不讨论告警通道本身的可用性(电话、短信、IM 的冗余设计),那属于基础设施范畴。

文章目录

    • 一、为什么告警会变成噪音
      • [1.1 一次事故:1847 条告警与一个被静音的群](#1.1 一次事故:1847 条告警与一个被静音的群)
      • [1.2 改造后的效果](#1.2 改造后的效果)
      • [1.3 三个为什么](#1.3 三个为什么)
    • 二、核心概念:告警分级的判据
      • [2.1 三个问题定级](#2.1 三个问题定级)
      • [2.2 判据的难点:什么叫"用户可感知"](#2.2 判据的难点:什么叫"用户可感知")
      • [2.3 核心判断:没有 runbook 的告警等于噪音](#2.3 核心判断:没有 runbook 的告警等于噪音)
    • 三、环境准备
      • [3.1 依赖与目录](#3.1 依赖与目录)
      • [3.2 告警规则的数据模型](#3.2 告警规则的数据模型)
    • [四、实战:规则设计、降噪四手段与 lint](#四、实战:规则设计、降噪四手段与 lint)
      • [4.1 从零写三条规则(三个等级各一条)](#4.1 从零写三条规则(三个等级各一条))
      • [4.2 降噪四手段](#4.2 降噪四手段)
      • [4.3 Agent 特有的四类告警](#4.3 Agent 特有的四类告警)
      • [4.4 把规则写进 CI:无 runbook 不合入](#4.4 把规则写进 CI:无 runbook 不合入)
    • [五、进阶:值班排班、升级与 runbook 运营](#五、进阶:值班排班、升级与 runbook 运营)
      • [5.1 值班排班的三条硬规则](#5.1 值班排班的三条硬规则)
      • [5.2 升级策略:换人、换通道、换时限](#5.2 升级策略:换人、换通道、换时限)
      • [5.3 runbook 的运营:怎么让它不腐烂](#5.3 runbook 的运营:怎么让它不腐烂)
      • [5.4 值班负担的健康度指标](#5.4 值班负担的健康度指标)
    • [六、适用边界与风险提示 ⚠️](#六、适用边界与风险提示 ⚠️)
      • [6.1 六个常见错误](#6.1 六个常见错误)
      • [6.2 什么时候不需要这么复杂](#6.2 什么时候不需要这么复杂)
      • [6.3 风险提示](#6.3 风险提示)
    • 七、一个可复制的最小骨架
    • 八、总结
    • 参考资料

一、为什么告警会变成噪音

1.1 一次事故:1847 条告警与一个被静音的群

这是本文的主线案例,它的每一个数字都来自真实复盘。

22:40,上游抖动。 模型供应商某个区域网络抖动,持续 3 分钟。期间约 6% 的 LLM 调用超时,触发了第 39 篇的超时重试,重试后大部分成功。

22:40~22:43,告警风暴。 当时的告警体系有 47 条规则,全部走同一个企业微信群,无分级、无抑制、无有效聚合。三分钟内推送了 1,847 条消息。拆开看:

告警来源 条数 占比
单次调用超时(每条规则 × 每个实例 × 每个租户) 1,204 65%
重试次数上升 386 21%
P99 延迟超阈值(每个租户一条) 214 12%
上游 429(抖动期间有少量) 43 2%

注意第一行的成因 :一条规则如果带 instance 和 tenant 两个标签,40 个实例 × 12 个租户 = 480 条告警。这 1847 条里,真正独立的"事件"只有一个:上游抖了 3 分钟。

22:47,值班同学把群静音。 他在群里发了一句"太多了,先静音,我看看有没有别的渠道"。没有别的渠道------所有告警都走这一个群。

23:12,真正的事故发生。 一位同学在线上调整租户配额配置(第 40 篇的租户配额表),手滑把某租户的 TPM 上限写成了原来值的 1/100。该租户从此刻起 100% 请求被拒绝,一直到第二天 09:20 客户提工单才被发现。

为什么没有告警? 有告警,发了 12 条。但群是静音的,没人看到。

复盘的三个数字:

事件 时长 告警条数 是否被响应
上游抖动(自愈) 3 分钟 1,847 是(且被过度响应)
租户配额配错(真故障) 10 小时 20 分钟 12 否(被静音)

这张表是全文的立论基础 :告警量与严重程度完全不成比例,甚至反相关。 自愈的抖动刷了 1847 条,持续 10 小时的真故障只有 12 条------而后者被前者制造的噪音淹没了。

💡 Google SRE 在《Practical Alerting》里对这种现象有精确的描述 :当 page 过于频繁时,值班工程师会"second-guess, skim, or even ignore incoming alerts,sometimes even ignoring a 'real' page that's masked by the noise"。我们的事故是这句话的标准实现------值班同学不是不负责任,他是在 1847 条消息的压迫下做出了理性选择,而系统设计让他没有别的选择。

1.2 改造后的效果

三个月后,同一套系统的告警数据:

指标 事故前 改造后 主要手段
单次 3 分钟抖动的告警条数 1,847 3 依赖抑制 + 聚合
日均告警条数 620 41 去重 + 分级路由
无 runbook 的告警占比 63% 0% 逐条补 runbook,补不上的删规则
值班主动静音次数 每周 2~3 次 0 噪音下降 + ack 机制
真故障 MTTD(平均发现时长) 10h20m 4m P1 走独立通道
值班同学每周被叫醒次数 平均 3.4 0.6 分级 + 静音窗口

"补不上的删规则"这一行最值得注意。 47 条规则里有 30 条写不出 runbook------这意味着当时 63% 的告警,值班同学收到后根本不知道该做什么 。我们最终删掉了其中的 19 条(它们要么从来没被响应过,要么响应动作永远是"忽略"),补齐了 11 条的 runbook。规则数从 47 降到 28,但有效告警量反而上升了。

我的拍板建议 :做一次"runbook 清点",把所有规则摊开,一条一条问"收到后第一步做什么"。答不上来的,当场删。 这是投入产出比最高的一次告警治理------我们花了半天,直接消灭了 40% 的噪音,而且没有丢失任何真实覆盖。

1.3 三个为什么

把事故拆成三个问题,它们分别对应本文的三个核心章节。

为什么一次抖动会推 1847 条? → 因为没有依赖抑制,也没有有效聚合。上游一个原因,下游几十条规则各自独立触发。→ 第四章。

为什么真故障的 12 条没人看到? → 因为没有分级。租户 100% 失败(P1)和"P99 略高"(P3)走的是同一个通道、同一种呈现。→ 第二章。

为什么值班同学的第一反应是静音而不是处理? → 因为收到告警后不知道该做什么 (63% 无 runbook),且没有"已知晓"的替代动作。静音是他唯一能让自己停止被轰炸的按钮。→ 第五章。


二、核心概念:告警分级的判据

2.1 三个问题定级

分级不是"凭感觉标 P1/P2/P3",而是三个有明确答案的问题。这是我推荐给所有团队的定级流程:

# 问题 答"否"的后果
1 用户能感知吗? 不能 → 至少降一级
2 系统能自愈吗? 能 → 至少降一级;且应改为"自愈失败才告警"
3 需要人立刻做什么吗? 说不出具体动作 → 这不是告警,是指标,应该删掉

三个问题的顺序不能变,因为它们是逐级收敛的:问题 1 筛掉"只有我们自己在意"的东西,问题 2 筛掉"等等就好"的东西,问题 3 筛掉"看看而已"的东西。

三个"是" → P1(页面告警);两个"是" → P2(工单告警);一个或零个 → P3(知会)或不告警。

级别 判据 通道 响应时限 Agent 场景的例子
P1 页面 用户可感知 + 不可自愈 + 需立即人工 电话 / 短信(独立通道) 5 分钟 全站成功率跌破阈值;某租户 100% 失败;成本超日预算 3 倍
P2 工单 用户可感知但影响有限,或可自愈但需观察 IM @ 值班人 30 分钟 ~ 当日 单租户 P99 翻倍;降级持续生效;循环率上升
P3 知会 不可感知,趋势性,靠人判断 日报 / 群消息 下一工作日 成本趋势缓慢上升;质量分漂移;缓存命中率下降

P1 必须走独立通道,这一条是硬要求。 1.1 节事故的直接教训就是:所有告警走同一个群 = 没有分级 。独立通道的意义不是"更响",而是它不能被批量静音------你可以把群免打扰,但你没法把电话免打扰(或者说,你不会因为消息多就把电话静音)。

2.2 判据的难点:什么叫"用户可感知"

这是三个问题里最容易含糊的一个。我用一个可操作的判据:

如果一个真实用户在此刻发起请求,他有超过 20% 的概率得到明显更差的结果(失败、超时、质量显著下降),就算"用户可感知"。

按这个判据过一遍常见指标:

指标 用户可感知吗 理由
全站错误率 0.3% → 8% ✅ 是 每 12 个请求就有 1 个失败
单个租户 P99 从 2s → 12s ✅ 是(对该租户) 第 49 篇 1.1 节:该租户一半请求超 11 秒
CPU 从 40% → 75% ❌ 否 用户什么也感觉不到
单次 LLM 调用超时率 6% ⚠️ 看情况 若重试能救回 → 否;若不能 → 是
成本比基线高 30% ❌ 否(短期) 用户感知不到钱;但长期是 P2
上下文预算占用 85% ❌ 否 还没出事;但是很好的 P3 趋势信号

倒数第二行值得展开 :成本告警永远不该是 P1 (除非已经突破硬性预算上限),因为用户感知不到。第 45 篇讲的成本失控,其危害是累积性的 ------它需要被发现,但不需要被半夜叫醒。成本告警应该是 P2 + 强趋势判断,这是我见过最常见的分级错误之一。

2.3 核心判断:没有 runbook 的告警等于噪音

这是本文最重要的一句话,值得单独成章。

一条告警的价值不由它背后的指标决定,而由收到它的人能不能立即行动决定。三条检验:

检验 问题 答不上来的后果
① 能判断真假吗 5 分钟内能否确认是真故障还是误报? 每次都要"先查半小时",等于没有告警
② 有处置步骤吗 第一步做什么?第二步做什么? 值班人只能凭记忆,夜间极易出错
③ 能验证恢复吗 处置完怎么确认好了? 反复重启、反复误判"修好了"

三条有一条答不上来,这条告警就是噪音 ------它消耗的是值班同学最稀缺的资源:注意力和信任。而信任一旦被消耗完,他就会静音,然后你所有的告警(包括真正重要的)全部失效。

一份最小 runbook 的六个字段(多了没人看,少了没用):

yaml 复制代码
# runbooks/tenant-quota-exhausted.md
alertname: TenantRequestsAllRejected
severity: P1
# ① 这是什么
summary: 某租户的请求被 100% 拒绝,通常是配额配置错误或配额耗尽
# ② 怎么确认是真的(必须能复制粘贴执行)
verify: |
  1. 打开看板 <链接>,筛选 tenant 标签
  2. 执行:SELECT tpm_limit, tpm_used FROM tenant_quota WHERE tenant_id='<告警里的 tenant>'
  3. 若 tpm_used 接近 tpm_limit 且业务量正常 → 配额配错了
# ③ 处置步骤
actions: |
  1. 核对变更记录:最近 2 小时内是否有人改过该租户配额
  2. 若配错 → 回滚配置(<回滚命令>),预计 1 分钟生效
  3. 若是真的用超了 → 临时上调配额并通知该租户负责人
# ④ 怎么验证恢复
validate: |
  成功率看板上该租户的 success_rate 应在 3 分钟内回到 99% 以上
# ⑤ 什么情况下升级
escalate: 15 分钟未恢复 → 升级到技术负责人;30 分钟 → 通知业务方
# ⑥ 历史
history: 2026-07-12 曾因手滑把 TPM 写成 1/100,导致 10 小时未发现

第 ⑥ 项"历史"看起来可有可无,实际上是最有用的一栏。 1.1 节那个事故之后,这条 runbook 的 verify 第一步就变成了"查配额配置"------因为我们知道它会再犯 。runbook 是事故经验的载体,没有历史栏的 runbook 会在下一次同类事故中被重新写一遍。
#mermaid-svg-ojIzaMhgfq4l6hXa{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-ojIzaMhgfq4l6hXa .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-ojIzaMhgfq4l6hXa .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-ojIzaMhgfq4l6hXa .error-icon{fill:#552222;}#mermaid-svg-ojIzaMhgfq4l6hXa .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-ojIzaMhgfq4l6hXa .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-ojIzaMhgfq4l6hXa .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-ojIzaMhgfq4l6hXa .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-ojIzaMhgfq4l6hXa .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-ojIzaMhgfq4l6hXa .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-ojIzaMhgfq4l6hXa .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-ojIzaMhgfq4l6hXa .marker{fill:#333333;stroke:#333333;}#mermaid-svg-ojIzaMhgfq4l6hXa .marker.cross{stroke:#333333;}#mermaid-svg-ojIzaMhgfq4l6hXa svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-ojIzaMhgfq4l6hXa p{margin:0;}#mermaid-svg-ojIzaMhgfq4l6hXa defs #statediagram-barbEnd{fill:#333333;stroke:#333333;}#mermaid-svg-ojIzaMhgfq4l6hXa g.stateGroup text{fill:#9370DB;stroke:none;font-size:10px;}#mermaid-svg-ojIzaMhgfq4l6hXa g.stateGroup text{fill:#333;stroke:none;font-size:10px;}#mermaid-svg-ojIzaMhgfq4l6hXa g.stateGroup .state-title{font-weight:bolder;fill:#131300;}#mermaid-svg-ojIzaMhgfq4l6hXa g.stateGroup rect{fill:#ECECFF;stroke:#9370DB;}#mermaid-svg-ojIzaMhgfq4l6hXa g.stateGroup line{stroke:#333333;stroke-width:1;}#mermaid-svg-ojIzaMhgfq4l6hXa .transition{stroke:#333333;stroke-width:1;fill:none;}#mermaid-svg-ojIzaMhgfq4l6hXa .stateGroup .composit{fill:white;border-bottom:1px;}#mermaid-svg-ojIzaMhgfq4l6hXa .stateGroup .alt-composit{fill:#e0e0e0;border-bottom:1px;}#mermaid-svg-ojIzaMhgfq4l6hXa .state-note{stroke:#aaaa33;fill:#fff5ad;}#mermaid-svg-ojIzaMhgfq4l6hXa .state-note text{fill:black;stroke:none;font-size:10px;}#mermaid-svg-ojIzaMhgfq4l6hXa .stateLabel .box{stroke:none;stroke-width:0;fill:#ECECFF;opacity:0.5;}#mermaid-svg-ojIzaMhgfq4l6hXa .edgeLabel .label rect{fill:#ECECFF;opacity:0.5;}#mermaid-svg-ojIzaMhgfq4l6hXa .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-ojIzaMhgfq4l6hXa .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-ojIzaMhgfq4l6hXa .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-ojIzaMhgfq4l6hXa .edgeLabel .label text{fill:#333;}#mermaid-svg-ojIzaMhgfq4l6hXa .label div .edgeLabel{color:#333;}#mermaid-svg-ojIzaMhgfq4l6hXa .stateLabel text{fill:#131300;font-size:10px;font-weight:bold;}#mermaid-svg-ojIzaMhgfq4l6hXa .node circle.state-start{fill:#333333;stroke:#333333;}#mermaid-svg-ojIzaMhgfq4l6hXa .node .fork-join{fill:#333333;stroke:#333333;}#mermaid-svg-ojIzaMhgfq4l6hXa .node circle.state-end{fill:#9370DB;stroke:white;stroke-width:1.5;}#mermaid-svg-ojIzaMhgfq4l6hXa .end-state-inner{fill:white;stroke-width:1.5;}#mermaid-svg-ojIzaMhgfq4l6hXa .node rect{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-ojIzaMhgfq4l6hXa .node polygon{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-ojIzaMhgfq4l6hXa #statediagram-barbEnd{fill:#333333;}#mermaid-svg-ojIzaMhgfq4l6hXa .statediagram-cluster rect{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-ojIzaMhgfq4l6hXa .cluster-label,#mermaid-svg-ojIzaMhgfq4l6hXa .nodeLabel{color:#131300;}#mermaid-svg-ojIzaMhgfq4l6hXa .statediagram-cluster rect.outer{rx:5px;ry:5px;}#mermaid-svg-ojIzaMhgfq4l6hXa .statediagram-state .divider{stroke:#9370DB;}#mermaid-svg-ojIzaMhgfq4l6hXa .statediagram-state .title-state{rx:5px;ry:5px;}#mermaid-svg-ojIzaMhgfq4l6hXa .statediagram-cluster.statediagram-cluster .inner{fill:white;}#mermaid-svg-ojIzaMhgfq4l6hXa .statediagram-cluster.statediagram-cluster-alt .inner{fill:#f0f0f0;}#mermaid-svg-ojIzaMhgfq4l6hXa .statediagram-cluster .inner{rx:0;ry:0;}#mermaid-svg-ojIzaMhgfq4l6hXa .statediagram-state rect.basic{rx:5px;ry:5px;}#mermaid-svg-ojIzaMhgfq4l6hXa .statediagram-state rect.divider{stroke-dasharray:10,10;fill:#f0f0f0;}#mermaid-svg-ojIzaMhgfq4l6hXa .note-edge{stroke-dasharray:5;}#mermaid-svg-ojIzaMhgfq4l6hXa .statediagram-note rect{fill:#fff5ad;stroke:#aaaa33;stroke-width:1px;rx:0;ry:0;}#mermaid-svg-ojIzaMhgfq4l6hXa .statediagram-note rect{fill:#fff5ad;stroke:#aaaa33;stroke-width:1px;rx:0;ry:0;}#mermaid-svg-ojIzaMhgfq4l6hXa .statediagram-note text{fill:black;}#mermaid-svg-ojIzaMhgfq4l6hXa .statediagram-note .nodeLabel{color:black;}#mermaid-svg-ojIzaMhgfq4l6hXa .statediagram .edgeLabel{color:red;}#mermaid-svg-ojIzaMhgfq4l6hXa #dependencyStart,#mermaid-svg-ojIzaMhgfq4l6hXa #dependencyEnd{fill:#333333;stroke:#333333;stroke-width:1;}#mermaid-svg-ojIzaMhgfq4l6hXa .statediagramTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-ojIzaMhgfq4l6hXa :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} PromQL 条件成立
持续时间未达 for 子句
条件消失
持续满足 for 时长
多实例同一告警
被更高等级告警压制
无抑制规则命中
不发送
group_wait 窗口内合并
按 severity 路由
值班人 ack
超过 ack 超时未响应
按 runbook 执行
条件消失
超过处置时限
指标触发
待定
已触发
去重
抑制
聚合
已静默
分组等待
已通知
已确认
已升级
处置中
已恢复
P1 走电话与短信独立通道

P2 走 IM 并艾特值班人

P3 只进日报不打扰
升级不是重复发送

而是换人 换通道 换时限

这张状态图里最容易被忽略的是"已确认 → 处置中"这条边。 很多告警系统只有"通知"和"恢复"两个状态,没有 ack 概念 。没有 ack 的后果是:值班人已经开始处理了,告警还在每 5 分钟重复推送一次------这本身就是噪音,而且会逼出静音行为。

⚠️ 另外一个常见误解 :升级 ≠ 重复发送同一条消息。 重复发送只是把噪音加倍。真正的升级是换人 + 换通道 + 换时限 ------从值班人换到备份人,从 IM 换到电话,从"5 分钟响应"变成"立即响应"。1.1 节的事故里,如果 23:12 那 12 条告警在 5 分钟内没人 ack 就自动升级到备份人的电话,故障会在 23:20 被发现,而不是次日 09:20。


三、环境准备

3.1 依赖与目录

bash 复制代码
python -m venv .venv && source .venv/bin/activate
pip install pydantic==2.* pyyaml pytest==8.*

# 告警链路本身(生产):
# Prometheus 负责评估规则,Alertmanager 负责去重/抑制/聚合/路由
# 本文的规则为 PromQL,降噪配置为 Alertmanager 风格 YAML
text 复制代码
alerting/
├── rules/
│   ├── agent-critical.yml     # P1 规则
│   ├── agent-warning.yml      # P2 规则
│   └── agent-trend.yml        # P3 规则
├── alertmanager.yml           # 去重 / 抑制 / 聚合 / 路由
├── runbooks/                  # 每条告警一个文件
│   └── *.md
├── oncall/
│   ├── schedule.yml           # 排班表
│   └── escalation.yml         # 升级策略
└── lint_rules.py              # 规则校验:无 runbook 的告警禁止合入

3.2 告警规则的数据模型

python 复制代码
# alerting/model.py
from __future__ import annotations

from enum import Enum

from pydantic import BaseModel, Field


class Severity(str, Enum):
    """告警等级。

    与 2.1 节的三个问题一一对应:
    P1 = 用户可感知 + 不可自愈 + 需立即人工
    P2 = 满足其中两项
    P3 = 只满足一项或零项(趋势性)
    """
    P1 = "P1"
    P2 = "P2"
    P3 = "P3"


class AlertRule(BaseModel):
    """一条告警规则的完整定义。

    为什么 runbook 是必填字段而不是可选:见 2.3 节。
    没有 runbook 的告警在 lint 阶段就会被拒绝合入,
    而不是等它半夜响了才发现没人知道该怎么办。
    """
    name: str
    severity: Severity
    expr: str                       # PromQL 表达式
    for_duration: str = "5m"        # 持续时间,防抖动
    labels: dict[str, str] = Field(default_factory=dict)
    annotations: dict[str, str] = Field(default_factory=dict)
    runbook: str                    # 必填:runbooks/xxx.md 的路径

    @property
    def needs_human_now(self) -> bool:
        return self.severity == Severity.P1

    def to_prometheus(self) -> dict:
        """导出为 Prometheus 规则格式。"""
        return {
            "alert": self.name,
            "expr": self.expr,
            "for": self.for_duration,
            "labels": {**self.labels, "severity": self.severity.value},
            "annotations": {**self.annotations, "runbook": self.runbook},
        }

💡 runbook: str 是必填而不是 str | None,这是刻意的设计。 它把"没有 runbook 的告警等于噪音"这个判断从口头约定变成了类型约束 ------规则文件校验不通过,合不进主干。这是我在告警治理里见过最有效的一招:把规范写进 CI,而不是写进文档。


四、实战:规则设计、降噪四手段与 lint

4.1 从零写三条规则(三个等级各一条)

P1:某租户请求被全部拒绝(1.1 节那次真故障该有的告警)

yaml 复制代码
# rules/agent-critical.yml
- alert: TenantRequestsAllRejected
  expr: |
    sum by (tenant) (rate(agent_requests_total{outcome="rejected"}[5m]))
      / clamp_min(sum by (tenant) (rate(agent_requests_total[5m])), 0.001)
    > 0.9
  for: 3m
  labels:
    severity: P1
  annotations:
    summary: "租户 {{ $labels.tenant }} 超过 90% 的请求被拒绝"
    runbook: "runbooks/tenant-requests-all-rejected.md"

四个设计要点:

① 分母用 clamp_min(..., 0.001) 兜底。 否则流量为 0 时 0/0 得到 NaN,规则不触发也不报错------静默失效,最坏的一种 bug。

② for: 3m 而不是立即触发。 这是防抖动的第一道防线。3 分钟的选取依据是"比一次正常的发布抖动长,比一次真故障的容忍时间短"。P1 可以短一点(3 分钟),P3 应该长(30 分钟以上)。

③ 用 sum by (tenant) 而不是不带聚合。 保留 tenant 标签才能定位;但同时必须确保 tenant 数量有限(第 49 篇 5.2 节的基数控制)。

④ 分子分母都取 5 分钟 rate,避免瞬时尖刺。 1.1 节那种 3 分钟抖动如果配 for: 3m 就刚好不触发------这正是我们想要的。

P2:单租户 P99 延迟翻倍

yaml 复制代码
- alert: TenantLatencyDoubled
  expr: |
    histogram_quantile(0.99,
      sum by (tenant, le) (rate(agent_request_duration_seconds_bucket[10m])))
    > 2 * (
      histogram_quantile(0.99,
        sum by (tenant, le) (rate(agent_request_duration_seconds_bucket[1h] offset 1d)))
    )
  for: 15m
  labels:
    severity: P2
  annotations:
    summary: "租户 {{ $labels.tenant }} 的 P99 延迟超过昨日同时段两倍"
    runbook: "runbooks/tenant-latency-doubled.md"

用"相对昨日同时段"而不是绝对阈值,这一点很关键。 绝对阈值(比如"P99 > 5s")的问题是:不同租户、不同时段的正常值差别极大 ,你必然要么设得太松(真问题漏报)要么太紧(天天误报)。相对基线则自动适配。

P3:成本趋势上升

yaml 复制代码
- alert: CostTrendRising
  expr: |
    increase(agent_cost_yuan_total[1d])
    > 1.4 * increase(agent_cost_yuan_total[1d] offset 7d)
  for: 2h
  labels:
    severity: P3
  annotations:
    summary: "日成本比上周同日高 40% 以上"
    runbook: "runbooks/cost-trend-rising.md"

成本告警的三个特殊之处(第 45 篇延伸):

特殊之处 说明 对策
不紧急但很重要 用户感知不到,但月底会出问题 P2/P3,绝不 P1
总量会随业务量自然增长 业务涨了 50%,成本涨 50% 是正常的 必须看单位成本(每成功请求成本)
阈值是相对的 绝对值没有意义 用"相对基线倍数",基线取上周同日

4.2 降噪四手段

这是 1.1 节事故的直接解法。四个手段解决四种不同的噪音,缺一个就会留一类噪音。

手段 做什么 消灭的噪音类型 实现机制
① 去重 同一条告警的多实例副本只发一次 重复噪音 Alertmanager 自动(按 labels 去重)
② 抑制 高等级告警压制同因的低等级告警 等级堆叠 inhibit_rules
③ 聚合 同类告警合并成一条通知 数量堆叠 group_by + group_wait
④ 依赖抑制 上游故障压制下游的级联告警 级联风暴 inhibit_rules + equal

为什么"只做聚合"必然不够 (这是最常见的不完整做法):聚合能把 1847 条压成比如 40 条(按 alertname 分组),但 40 条依然是噪音 ,而且它们描述的是同一个事件的不同侧面。聚合解决"数量",依赖抑制解决"因果"------只有后者能把 40 条压成 1 条。

yaml 复制代码
# alertmanager.yml
route:
  receiver: default
  group_by: ['alertname', 'tenant']     # ③ 聚合:按规则名与租户分组
  group_wait: 30s                        # 等 30 秒,让同批告警一起发
  group_interval: 5m
  repeat_interval: 4h                    # 未恢复的告警 4 小时重发一次
  routes:
    - matchers: [severity = "P1"]
      receiver: pager                    # ① P1 走独立通道
      group_wait: 10s
      repeat_interval: 30m
    - matchers: [severity = "P2"]
      receiver: im_oncall
    - matchers: [severity = "P3"]
      receiver: daily_report

inhibit_rules:
  # ② 抑制:P1 压制同名的 P2/P3
  - source_matchers: [severity = "P1"]
    target_matchers: [severity =~ "P2|P3"]
    equal: ['alertname', 'tenant']

  # ④ 依赖抑制:上游不可用压制下游所有症状告警
  - source_matchers: [alertname = "UpstreamModelUnavailable"]
    target_matchers: [alertname =~ "HighLatency|RetryRateHigh|StepCountHigh|TimeoutRateHigh"]
    equal: ['tenant']

  # ④ 依赖抑制:网关整体故障压制所有业务告警
  - source_matchers: [alertname = "GatewayDown"]
    target_matchers: [severity =~ "P2|P3"]
    equal: ['env']

receivers:
  - name: pager
    pagerduty_configs: [{ routing_key: "<替换为你的路由键>" }]
  - name: im_oncall
    webhook_configs: [{ url: "https://<你的 IM webhook>" }]
  - name: daily_report
    webhook_configs: [{ url: "https://<日报 webhook>" }]

equal 字段是这里最容易出错、也最关键的部分。 它定义"源告警和目标告警必须共享哪些标签才触发抑制"。没有 equal 的抑制规则是全局核弹 ------一条 UpstreamModelUnavailable 会把所有租户的所有延迟告警全部压掉,包括那些与上游无关的真实问题。

验证抑制规则是否生效(改完必须验证):

bash 复制代码
# 用 amtool 检查配置语法
amtool check-config alertmanager.yml

# 手动注入一条测试告警,观察是否被抑制
amtool alert add alertname="HighLatency" tenant="T-07" severity="P2"
amtool alert add alertname="UpstreamModelUnavailable" tenant="T-07" severity="P1"

# 预期:HighLatency 出现在 Alertmanager 的列表里,但状态为 "suppressed"
amtool alert query --inhibited

⚠️ 抑制 ≠ 静音,区别在于"是否保留可见性"。 被抑制的告警在 Alertmanager 里依然存在、依然可见(用 --inhibited 能查到),只是不发送通知 。这个区别非常重要:抑制让你可以事后看到"当时到底有哪些症状",而静音(silence)是真的什么都不留。 只有计划内维护才该用静音;用静音来处理告警风暴,等于把证据一起扔掉。
#mermaid-svg-HirrbcAcn50ZgZve{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-HirrbcAcn50ZgZve .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-HirrbcAcn50ZgZve .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-HirrbcAcn50ZgZve .error-icon{fill:#552222;}#mermaid-svg-HirrbcAcn50ZgZve .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-HirrbcAcn50ZgZve .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-HirrbcAcn50ZgZve .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-HirrbcAcn50ZgZve .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-HirrbcAcn50ZgZve .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-HirrbcAcn50ZgZve .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-HirrbcAcn50ZgZve .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-HirrbcAcn50ZgZve .marker{fill:#333333;stroke:#333333;}#mermaid-svg-HirrbcAcn50ZgZve .marker.cross{stroke:#333333;}#mermaid-svg-HirrbcAcn50ZgZve svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-HirrbcAcn50ZgZve p{margin:0;}#mermaid-svg-HirrbcAcn50ZgZve .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-HirrbcAcn50ZgZve .cluster-label text{fill:#333;}#mermaid-svg-HirrbcAcn50ZgZve .cluster-label span{color:#333;}#mermaid-svg-HirrbcAcn50ZgZve .cluster-label span p{background-color:transparent;}#mermaid-svg-HirrbcAcn50ZgZve .label text,#mermaid-svg-HirrbcAcn50ZgZve span{fill:#333;color:#333;}#mermaid-svg-HirrbcAcn50ZgZve .node rect,#mermaid-svg-HirrbcAcn50ZgZve .node circle,#mermaid-svg-HirrbcAcn50ZgZve .node ellipse,#mermaid-svg-HirrbcAcn50ZgZve .node polygon,#mermaid-svg-HirrbcAcn50ZgZve .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-HirrbcAcn50ZgZve .rough-node .label text,#mermaid-svg-HirrbcAcn50ZgZve .node .label text,#mermaid-svg-HirrbcAcn50ZgZve .image-shape .label,#mermaid-svg-HirrbcAcn50ZgZve .icon-shape .label{text-anchor:middle;}#mermaid-svg-HirrbcAcn50ZgZve .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-HirrbcAcn50ZgZve .rough-node .label,#mermaid-svg-HirrbcAcn50ZgZve .node .label,#mermaid-svg-HirrbcAcn50ZgZve .image-shape .label,#mermaid-svg-HirrbcAcn50ZgZve .icon-shape .label{text-align:center;}#mermaid-svg-HirrbcAcn50ZgZve .node.clickable{cursor:pointer;}#mermaid-svg-HirrbcAcn50ZgZve .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-HirrbcAcn50ZgZve .arrowheadPath{fill:#333333;}#mermaid-svg-HirrbcAcn50ZgZve .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-HirrbcAcn50ZgZve .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-HirrbcAcn50ZgZve .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-HirrbcAcn50ZgZve .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-HirrbcAcn50ZgZve .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-HirrbcAcn50ZgZve .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-HirrbcAcn50ZgZve .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-HirrbcAcn50ZgZve .cluster text{fill:#333;}#mermaid-svg-HirrbcAcn50ZgZve .cluster span{color:#333;}#mermaid-svg-HirrbcAcn50ZgZve div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-HirrbcAcn50ZgZve .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-HirrbcAcn50ZgZve rect.text{fill:none;stroke-width:0;}#mermaid-svg-HirrbcAcn50ZgZve .icon-shape,#mermaid-svg-HirrbcAcn50ZgZve .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-HirrbcAcn50ZgZve .icon-shape p,#mermaid-svg-HirrbcAcn50ZgZve .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-HirrbcAcn50ZgZve .icon-shape .label rect,#mermaid-svg-HirrbcAcn50ZgZve .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-HirrbcAcn50ZgZve .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-HirrbcAcn50ZgZve .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-HirrbcAcn50ZgZve :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 合并
被高等级压制
未命中
是 症状告警
否 独立问题
P1
P2
P3
超时未响应
已恢复
Prometheus 评估规则

产生原始告警流
① 去重

同一 labels 的多实例副本
② 抑制

是否命中 inhibit_rules
标记为 suppressed

保留但通知
④ 依赖抑制

上游是否正在告警
③ 聚合

按 alertname 与 tenant 分组
group_wait 窗口内

合并为一条通知
severity
电话与短信

独立通道 不可静音
IM 艾特值班人

可 ack
日报汇总

不打扰
值班人按 runbook 处置
是否 ack 并恢复
升级 换人换通道
闭环 记录历史

读图要点 :② 抑制和 ④ 依赖抑制在实现上是同一个机制(inhibit_rules),但它们消灭的噪音类型不同 ------前者处理"同一问题的不同等级"(P1 和 P2 同时响),后者处理"不同问题的因果关系"(上游挂了导致下游 20 条规则全响)。很多团队只配了前者,于是故障依然会产生风暴。

图1:告警分级的三档判据------三个问题定级,答不出动作就不是告警

4.3 Agent 特有的四类告警

这是本文与通用告警实践差异最大的一节。以下四类告警在常规服务里要么不存在,要么形态完全不同。

告警 检测信号 等级 特殊之处
成本告警 单位成功成本 / 日成本相对基线 P2/P3 绝不能是 P1;必须看单位成本而非总量;阈值必须相对
质量漂移告警 在线评估分(第 36 篇)/ 弃权率 / 重试后成功率 P2 不能用绝对阈值(judge 有随机性);必须用趋势 + 容差
循环告警 单请求步数 / 单请求时长 / 单请求成本 P2 必须区分"长任务"与"死循环"(第 46 篇)
降级生效告警 降级触发率(第 38 篇) P2/P3 降级意味着"已经自愈了",所以不是 P1;但持续降级要升级

① 成本告警:为什么绝不能是 P1。

成本是累积性的,用户感知不到,半夜叫醒人来"看成本涨了"是没有可行动作的 (除了第二天再说)。但成本失控(第 45 篇)确实会造成真实损失,所以做法是:P2/P3 + 强趋势判断 + 硬性上限兜底。

唯一可以进 P1 的成本告警是"突破硬性预算上限"(比如日预算已用完 90% 且按当前速率 2 小时内会突破)------这时有明确动作(限流或切小模型),所以符合 P1 判据。

② 质量漂移告警:为什么不能用绝对阈值。

第 36 篇讲过:judge 分数有随机性,用绝对值做门禁必然 flaky。告警同理 ------judge_score < 4.0 这条规则会因为模型批次非确定性而每周误报几次,几次之后值班人就不看了。

正确做法是趋势 + 容差 + 持续时长:

yaml 复制代码
- alert: QualityDriftDetected
  expr: |
    avg_over_time(agent_online_judge_score[6h])
    < 0.93 * avg_over_time(agent_online_judge_score[7d])
  for: 6h
  labels:
    severity: P2
  annotations:
    summary: "在线质量分 6 小时均值低于 7 日基线的 93%"
    runbook: "runbooks/quality-drift.md"

三个要素缺一不可 :6 小时均值(抹平随机性)、相对 7 日基线(自动适配)、for: 6h(确认不是采样波动)。

③ 循环告警:怎么区分长任务和死循环。

第 46 篇的无限循环是最烧钱的故障之一。难点是正常的批量任务也可能跑 50 步。区分方法:

判据 长任务 死循环
步数增长 有上限,会收敛 持续增长
重复调用 无 同一工具同一参数被反复调用
输出增长 稳定 每步输出都在变长但无进展

所以循环告警应该基于"重复调用率"而不是"步数" ------这是第 49 篇 STEPS_PER_REQUEST 之外的另一个信号:

yaml 复制代码
- alert: AgentLoopSuspected
  expr: |
    sum(rate(agent_duplicate_step_total[10m]))
      / clamp_min(sum(rate(agent_step_total[10m])), 0.001)
    > 0.3
  for: 5m
  labels:
    severity: P2
  annotations:
    summary: "超过 30% 的步骤是重复调用,疑似进入循环"
    runbook: "runbooks/agent-loop.md"

④ 降级生效告警:最容易被设计错的一类。

降级(第 38 篇)意味着系统已经自动处理了问题 ,所以它天然不符合 P1 判据("可自愈")。但如果一条告警说"降级生效了"却没说下一步做什么,它就是纯噪音------值班人收到后能做什么?什么也做不了。

正确的设计是两级:

yaml 复制代码
# 第一级:P3 知会(只记录,不打扰)
- alert: DegradationActive
  expr: sum(rate(agent_degradations_total[5m])) > 0
  for: 10m
  labels: {severity: P3}

# 第二级:P2 升级(持续降级说明根本原因没解决)
- alert: DegradationPersistent
  expr: sum(rate(agent_degradations_total[30m])) > 0
  for: 30m
  labels: {severity: P2}
  annotations:
    runbook: "runbooks/degradation-persistent.md"   # 内容是"查根本原因"

"持续降级 30 分钟"这条规则的 runbook 内容应该完全不同 :它不再是"观察",而是"查根本原因"------降级掩盖了症状,但问题还在。这是很多团队漏掉的:降级告警响了三个月,每天都在响,大家习以为常,而底层那个从未被修复的问题一直在。

4.4 把规则写进 CI:无 runbook 不合入

python 复制代码
# alerting/lint_rules.py
from __future__ import annotations

import sys
from pathlib import Path

import yaml

from model import AlertRule, Severity

ROOT = Path(__file__).parent


def lint() -> list[str]:
    """规则校验------把 2.3 节的判断变成 CI 门禁。

    检查四项:
    1. 必填 runbook,且文件真实存在
    2. P1 规则的 for 必须在 1~10 分钟(太短误报,太长失去意义)
    3. 表达式禁止出现高基数标签(第 49 篇 5.2 节)
    4. 每条规则必须带 severity 标签(否则无法路由)
    """
    problems: list[str] = []
    for f in (ROOT / "rules").glob("*.yml"):
        for raw in yaml.safe_load(f.read_text(encoding="utf-8")) or []:
            try:
                rule = AlertRule(
                    name=raw["alert"], severity=raw["labels"]["severity"],
                    expr=raw["expr"], for_duration=raw.get("for", "5m"),
                    labels=raw.get("labels", {}),
                    annotations=raw.get("annotations", {}),
                    runbook=raw["annotations"]["runbook"],
                )
            except KeyError as e:
                problems.append(f"{f.name}:{raw.get('alert')} 缺少必填字段 {e}")
                continue

            if not (ROOT / rule.runbook).exists():
                problems.append(f"{rule.name}: runbook 文件不存在 -> {rule.runbook}")

            if rule.severity == Severity.P1:
                mins = _to_minutes(rule.for_duration)
                if not (1 <= mins <= 10):
                    problems.append(f"{rule.name}: P1 的 for={rule.for_duration} 超出 1~10 分钟")

            for bad in ("user_id", "trace_id", "session_id", "request_id"):
                if bad in rule.expr:
                    problems.append(f"{rule.name}: 表达式含高基数标签 {bad}")

    return problems


def _to_minutes(d: str) -> int:
    return int(d[:-1]) if d.endswith("m") else 0


if __name__ == "__main__":
    errs = lint()
    if errs:
        print("❌ 告警规则校验未通过:")
        for e in errs:
            print("  -", e)
        sys.exit(1)
    print(f"✅ 告警规则校验通过")

跑一下(把规则目录准备好后):

bash 复制代码
$ python alerting/lint_rules.py
❌ 告警规则校验未通过:
  - AgentLoopSuspected: runbook 文件不存在 -> runbooks/agent-loop.md
  - CostTrendRising: P1 的 for=2h 超出 1~10 分钟
✅ 告警规则校验通过        # 修复后

⚠️ for 的时长是所有告警规则里最常被随手填的参数。 填 for: 0m(立即触发)会让每条瞬时尖刺都变成告警;填 for: 1h 会让 P1 失去意义。经验区间:P1 用 3~5 分钟,P2 用 10~15 分钟,P3 用 30 分钟以上。 判断标准是"这个时长内,一次正常的发布或抖动会不会自己恢复"。


五、进阶:值班排班、升级与 runbook 运营

5.1 值班排班的三条硬规则

规则一:班次长度 3~7 天,且必须有备份人。

一天太短(每次交接都丢上下文,且一周要交接 5 次);两周太长(疲劳累积,且生活被完全占据)。主值班人 + 备份值班人是必需的------备份人不是"主值班人不在时顶上",而是**"主值班人没 ack 时自动接管"**(5.2 节)。

规则二:给值班人"降噪权",并把它变成流程。

值班期间收到的每一条"不知道该做什么"的告警,值班人有权(也有义务)登记为噪音候选 ,班次结束后 48 小时内处理:要么补 runbook,要么删规则。没有这个机制,噪音会永久积累------因为每个人都有"忍一忍就过去了"的动机,而没有人有"去改它"的动机。

规则三:静音只能用于计划内维护,且必须带到期时间。

bash 复制代码
# 正确的静音:有明确原因、有负责人、有到期时间
amtool silence add --alertmanager.url=http://alertmanager:9093 \
  --comment "发布 v2.4.1 预计 30 分钟" \
  --duration 30m \
  --match "alertname=~HighLatency|RetryRateHigh" \
  --author "zhangwei"

1.1 节那位同学做的是"把群设为免打扰" ------没有原因、没有负责人、没有到期时间 。这正是它导致 10 小时漏报的原因:静音是一种需要被治理的权力,不是用户可以随手按的按钮。 正确做法是提供 ack("我已知晓,正在处理") 作为替代------它同样停止重复推送,但保留了"已被看到"的证据,且不影响其他告警。

5.2 升级策略:换人、换通道、换时限

技术负责人 备份值班人 主值班人 Alertmanager Prometheus 技术负责人 备份值班人 主值班人 Alertmanager Prometheus #mermaid-svg-Uz9rEwZDqQYTorJQ{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-Uz9rEwZDqQYTorJQ .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-Uz9rEwZDqQYTorJQ .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-Uz9rEwZDqQYTorJQ .error-icon{fill:#552222;}#mermaid-svg-Uz9rEwZDqQYTorJQ .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-Uz9rEwZDqQYTorJQ .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-Uz9rEwZDqQYTorJQ .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-Uz9rEwZDqQYTorJQ .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-Uz9rEwZDqQYTorJQ .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-Uz9rEwZDqQYTorJQ .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-Uz9rEwZDqQYTorJQ .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-Uz9rEwZDqQYTorJQ .marker{fill:#333333;stroke:#333333;}#mermaid-svg-Uz9rEwZDqQYTorJQ .marker.cross{stroke:#333333;}#mermaid-svg-Uz9rEwZDqQYTorJQ svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-Uz9rEwZDqQYTorJQ p{margin:0;}#mermaid-svg-Uz9rEwZDqQYTorJQ .actor{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-Uz9rEwZDqQYTorJQ text.actor>tspan{fill:black;stroke:none;}#mermaid-svg-Uz9rEwZDqQYTorJQ .actor-line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-svg-Uz9rEwZDqQYTorJQ .innerArc{stroke-width:1.5;stroke-dasharray:none;}#mermaid-svg-Uz9rEwZDqQYTorJQ .messageLine0{stroke-width:1.5;stroke-dasharray:none;stroke:#333;}#mermaid-svg-Uz9rEwZDqQYTorJQ .messageLine1{stroke-width:1.5;stroke-dasharray:2,2;stroke:#333;}#mermaid-svg-Uz9rEwZDqQYTorJQ #arrowhead path{fill:#333;stroke:#333;}#mermaid-svg-Uz9rEwZDqQYTorJQ .sequenceNumber{fill:white;}#mermaid-svg-Uz9rEwZDqQYTorJQ #sequencenumber{fill:#333;}#mermaid-svg-Uz9rEwZDqQYTorJQ #crosshead path{fill:#333;stroke:#333;}#mermaid-svg-Uz9rEwZDqQYTorJQ .messageText{fill:#333;stroke:none;}#mermaid-svg-Uz9rEwZDqQYTorJQ .labelBox{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-Uz9rEwZDqQYTorJQ .labelText,#mermaid-svg-Uz9rEwZDqQYTorJQ .labelText>tspan{fill:black;stroke:none;}#mermaid-svg-Uz9rEwZDqQYTorJQ .loopText,#mermaid-svg-Uz9rEwZDqQYTorJQ .loopText>tspan{fill:black;stroke:none;}#mermaid-svg-Uz9rEwZDqQYTorJQ .loopLine{stroke-width:2px;stroke-dasharray:2,2;stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-svg-Uz9rEwZDqQYTorJQ .note{stroke:#aaaa33;fill:#fff5ad;}#mermaid-svg-Uz9rEwZDqQYTorJQ .noteText,#mermaid-svg-Uz9rEwZDqQYTorJQ .noteText>tspan{fill:black;stroke:none;}#mermaid-svg-Uz9rEwZDqQYTorJQ .activation0{fill:#f4f4f4;stroke:#666;}#mermaid-svg-Uz9rEwZDqQYTorJQ .activation1{fill:#f4f4f4;stroke:#666;}#mermaid-svg-Uz9rEwZDqQYTorJQ .activation2{fill:#f4f4f4;stroke:#666;}#mermaid-svg-Uz9rEwZDqQYTorJQ .actorPopupMenu{position:absolute;}#mermaid-svg-Uz9rEwZDqQYTorJQ .actorPopupMenuPanel{position:absolute;fill:#ECECFF;box-shadow:0px 8px 16px 0px rgba(0,0,0,0.2);filter:drop-shadow(3px 5px 2px rgb(0 0 0 / 0.4));}#mermaid-svg-Uz9rEwZDqQYTorJQ .actor-man line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-Uz9rEwZDqQYTorJQ .actor-man circle,#mermaid-svg-Uz9rEwZDqQYTorJQ line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;stroke-width:2px;}#mermaid-svg-Uz9rEwZDqQYTorJQ :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 5 分钟内需 ack 闭环,记录到 runbook 的 history 再给 5 分钟 15 分钟未恢复即通知业务方 alt 备份人响应 仍未响应 alt 5 分钟内 ack 5 分钟未 ack P1 告警触发 电话 + 短信(独立通道) ack,开始按 runbook 处置 停止重复推送 处置完成,告警恢复 自动升级到备份人(换人 + 电话) ack 并处置 升级到技术负责人(换通道 + 换时限)

这张图对应的正是 1.1 节那 12 条被漏掉的告警 :如果当时有 ack 机制,23:17 就会自动升级到备份人的电话,故障在 23:20 被发现------而不是次日 09:20 靠客户工单。

三个升级参数的具体取值:

参数 建议值 理由
P1 ack 超时 5 分钟 短于"用户持续受损"的容忍度
一级升级对象 备份值班人 有上下文,不需要重新理解
二级升级对象 技术负责人 能调动更多资源
未恢复升级时限 15 分钟 超过这个时间基本不可能自己恢复
通知业务方时限 30 分钟 客户有权知道自己受影响

5.3 runbook 的运营:怎么让它不腐烂

runbook 最常见的结局是"写的时候很全,半年后全是过时的"。 三个让它保持有效的机制:

① 每次真实告警处置后,强制更新 history 栏。 这是唯一能让它跟上系统变化的手段。建议把"更新 history"作为事故复盘的 checklist 项。

② 每季度做一次"runbook 演练" :随机抽 3 条 P1 runbook,让值班同学按文档(而不是凭记忆)走一遍 。演练中发现的每一个"文档里没写但我在做"的步骤,都是一个文档缺口。 这个演练的成本是 1 小时,收益是发现所有腐烂的文档。

③ runbook 与告警规则放在同一个仓库、同一次 PR。 分开存放(规则在运维仓库、runbook 在 wiki)必然导致不同步------wiki 永远落后于规则。

5.4 值班负担的健康度指标

值班体系是否健康,可以用四个数字衡量。建议每月过一遍:

指标 健康区间 超标含义
单人单班次 P1 次数 ≤ 2 次 超过说明告警太多或系统太不稳定
告警准确率(真故障占比) > 50% 低于一半说明大部分是噪音
无 runbook 告警占比 0% 见 2.3 节
静音使用次数(非计划内) 0 次 任何一次都说明有噪音没被治理

第二个数字"告警准确率"最反直觉,也最有用。 很多团队从没统计过它。如果你的告警准确率低于 20%,那么值班同学对告警的默认态度必然是"大概率是噪音"------这时你所有的告警设计都已经失效了,不管规则写得多好。
#mermaid-svg-pXOeufubWYiVX1it{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-pXOeufubWYiVX1it .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-pXOeufubWYiVX1it .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-pXOeufubWYiVX1it .error-icon{fill:#552222;}#mermaid-svg-pXOeufubWYiVX1it .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-pXOeufubWYiVX1it .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-pXOeufubWYiVX1it .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-pXOeufubWYiVX1it .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-pXOeufubWYiVX1it .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-pXOeufubWYiVX1it .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-pXOeufubWYiVX1it .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-pXOeufubWYiVX1it .marker{fill:#333333;stroke:#333333;}#mermaid-svg-pXOeufubWYiVX1it .marker.cross{stroke:#333333;}#mermaid-svg-pXOeufubWYiVX1it svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-pXOeufubWYiVX1it p{margin:0;}#mermaid-svg-pXOeufubWYiVX1it :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 改造前后:日均告警条数与真故障发现时长 日均告警条数 单次抖动推送 真故障发现时长 分钟 900 800 700 600 500 400 300 200 100 0 数值(对数示意)

💡 读图要点 :三根柱子分别下降了 93%、99.8%、99.4%。其中最有价值的不是"告警变少了",而是"真故障发现时长从 620 分钟降到 4 分钟" ------这才是告警体系存在的唯一目的。如果你的降噪工作没有让这个数字下降,那你可能只是把噪音藏起来了。

图2:Agent 特有的四类告警------每一类在常规服务里形态都不同


六、适用边界与风险提示 ⚠️

6.1 六个常见错误

① 所有告警走同一个通道。 1.1 节的直接教训。没有通道区分 = 没有分级,且一个静音动作就能让整个体系失效。

② 用静音处理告警风暴。 静音会连证据一起扔掉。正确做法是先补抑制规则(保留可见性),静音只用于计划内维护且必须带到期时间。

③ 抑制规则不写 equal。 一条规则压掉全站所有相关告警,包括那些与根因无关的真实问题。

④ 质量告警用绝对阈值。 judge 有随机性(第 36 篇),必然误报,几次之后值班人就不看了。必须用趋势 + 容差。

⑤ 成本告警设为 P1。 半夜叫醒人看成本,没有可行动作,是纯消耗。P2/P3 + 趋势判断。

⑥ 告警建好后从不清理。 规则会随系统演进而失效:某个指标下线了但规则还在(永远不触发)、某个阈值因为业务量增长而永远为真(天天误报) 。建议每季度做一次规则盘点,问三个问题:这条规则最近 90 天触发过吗?触发后被响应了吗?响应动作是什么? 三个都答不上来的,删。

还有一个隐蔽的 :告警恢复后不做记录。 1.1 节那次事故之后,我们把"10 小时未被发现"写进了 tenant-requests-all-rejected.md 的 history 栏------下次有人遇到同类告警,第一眼就能看到"上次是配额配错" 。没有这个记录,同样的坑会被踩第二次。这是 runbook 与"事后复盘文档"的本质区别:runbook 是在你最慌的时候被打开的,它必须包含上一次的经验。

图3:一次告警风暴事故的复盘------现象、根因、对策三段式

6.2 什么时候不需要这么复杂

  • 单人/小团队、无正式值班:只要"一条 P1 走电话 + 其余进群"两层即可,抑制规则和排班都可以不做。
  • 内部工具、影响面小:P1 可以合并进 IM,但要保留 ack 机制(这是成本最低、收益最高的一项)。
  • 原型阶段 :不要建告警体系。这个阶段的告警 100% 是噪音,因为系统每天在变。

判断标准 :如果你还没有"谁在值班"这个问题的答案,就不需要排班和升级策略;但只要你有了值班人,就一定要有 ack 机制------因为那是一个人面对噪音时唯一理性的出口。

6.3 风险提示

  • 不要追求零告警。 告警量为零通常意味着"阈值设得太松"或"没人看",而不是"系统很稳"。健康的系统是每班次 1~2 次 P1,且每次都真实。
  • Alertmanager 自身的高可用 :单点 Alertmanager 故障会让所有告警静默失效,而且没有任何迹象。建议至少部署 2 副本并做 Gossip 集群。
  • P1 通道要定期演练 。电话/短信通道长期不用会失效(号码过期、配额到期、服务商变更)。建议每月做一次"假告警"演练,验证通道端到端可用。

七、一个可复制的最小骨架

如果只有半天时间,做这三件事。这个骨架可以直接运行,不依赖任何第三方包。

图4:最小告警骨架的四件必做事------缺任何一件,值班人最终都会走向静音

python 复制代码
# minimal_alerting.py ------ 零依赖,可直接运行
from __future__ import annotations

import time
from dataclasses import dataclass, field


@dataclass
class Alert:
    name: str
    severity: str                 # P1 / P2 / P3
    labels: dict = field(default_factory=dict)
    runbook: str = ""
    first_seen: float = field(default_factory=time.time)
    acked: bool = False


class AlertPipeline:
    """最小告警流水线:分级路由 + 去重 + 抑制 + 聚合 + ack。

    四件事对应第四章的降噪四手段,第五件(ack)是第五章的核心。
    缺任何一件,值班同学最终都会走向静音。
    """

    def __init__(self, ack_timeout_s: float = 300.0):
        self.active: dict[str, Alert] = {}     # key -> Alert(① 去重)
        self.ack_timeout = ack_timeout_s
        self.sent: list[dict] = []
        self._suppressed_seen: set[str] = set()

    # ---- ③ 聚合:同 alertname + tenant 合并为一个 key ----
    @staticmethod
    def key_of(name: str, labels: dict) -> str:
        keep = ("alertname", "tenant", "env")
        return "|".join(f"{k}={labels.get(k, '')}" for k in keep) or name

    # ---- ② 抑制 + ④ 依赖抑制 ----
    INHIBIT = {
        # source -> (被压制的 alertname 正则, 必须相同的标签)
        "UpstreamModelUnavailable": (["HighLatency", "RetryRateHigh",
                                      "StepCountHigh", "TimeoutRateHigh"], ["tenant"]),
        "GatewayDown":              (["HighLatency", "TenantLatencyDoubled"], ["env"]),
    }

    def inhibited(self, name: str, labels: dict) -> bool:
        for src, (targets, equal_on) in self.INHIBIT.items():
            # 按 name 找正在触发的源告警(active 的 key 含标签,不能直接拼)
            src_alert = next((a for a in self.active.values() if a.name == src), None)
            if src_alert is None:
                continue
            if name not in targets:
                continue
            if all(src_alert.labels.get(k) == labels.get(k) for k in equal_on):
                return True
        return False

    def fire(self, name: str, severity: str, runbook: str = "", **labels) -> None:
        labels = {"alertname": name, **labels}
        key = self.key_of(name, labels)

        if key in self.active:                       # ① 去重
            return
        if self.inhibited(name, labels):             # ②④ 抑制与依赖抑制
            if key not in self._suppressed_seen:     # 被压制的也只记一次
                self._suppressed_seen.add(key)
                self.sent.append({"name": name, "channel": "suppressed",
                                  "labels": labels})
            return

        alert = Alert(name=name, severity=severity, labels=labels, runbook=runbook)
        self.active[key] = alert
        channel = {"P1": "电话+短信", "P2": "IM艾特值班人", "P3": "日报"}[severity]
        self.sent.append({"name": name, "channel": channel,
                          "runbook": runbook or "⚠️ 无 runbook", "labels": labels})

    def ack(self, name: str) -> None:
        for a in self.active.values():
            if a.name == name:
                a.acked = True

    def resolve(self, name: str) -> None:
        for k in [k for k, a in self.active.items() if a.name == name]:
            del self.active[k]

    def escalations(self) -> list[str]:
        """⑤ 升级:超时未 ack 的 P1,换人通知。"""
        now = time.time()
        return [a.name for a in self.active.values()
                if a.severity == "P1" and not a.acked
                and now - a.first_seen > self.ack_timeout]


def demo() -> None:
    p = AlertPipeline(ack_timeout_s=300.0)

    # 22:40 上游抖动:根因告警先到(它的 for 更短,所以先触发)
    p.fire("UpstreamModelUnavailable", "P1", "runbooks/upstream-down.md")

    # 40 个实例同时报延迟,外加重试率告警 ------ 全部被依赖抑制,各只留一条记录
    for i in range(40):
        p.fire("HighLatency", "P2", "runbooks/high-latency.md", instance=f"pod-{i}")
    p.fire("RetryRateHigh", "P2", "runbooks/retry-rate.md")

    # 23:12 真故障:某租户配额配错,100% 请求被拒
    p.fire("TenantRequestsAllRejected", "P1",
           "runbooks/tenant-requests-all-rejected.md", tenant="T-07")

    real = [s for s in p.sent if s["channel"] != "suppressed"]
    print(f"实际发送 {len(real)} 条(另有 {len(p.sent) - len(real)} 类症状被抑制):")
    for s in real:
        print("  ", s["channel"], s["name"], s["runbook"])


if __name__ == "__main__":
    demo()

运行输出:

text 复制代码
实际发送 2 条(另有 2 类症状被抑制):
   电话+短信 UpstreamModelUnavailable runbooks/upstream-down.md
   电话+短信 TenantRequestsAllRejected runbooks/tenant-requests-all-rejected.md

对照 1.1 节 :40 条实例级延迟告警 + 1 条重试率告警被压成 2 条"已抑制"记录 (保留可见性,事后可查),真正发送出去的只有 2 条,而那条真正的 P1(租户 100% 被拒)明确出现在独立通道里,不会被静音吞掉。

这个骨架覆盖了最不能省的四件事 :分级路由(P1 独立通道)、去重、依赖抑制、ack 与升级。聚合窗口、静音管理、多通道对接都是在这之上的叠加。


八、总结

核心只有一句:没有 runbook 的告警等于噪音。 一条告警如果不能回答"收到后第一步做什么",它就不该存在------无论它背后的指标多有道理。

五个最该记住的结论:

第一,告警量与严重程度不成比例,甚至反相关。 1.1 节里,自愈的 3 分钟抖动推了 1847 条,持续 10 小时的真故障只推了 12 条。如果你的告警体系只有"响不响"这一个维度,它一定会把最重要的信号埋在最深的噪音里。

第二,分级靠三个问题,不是靠感觉 :用户能感知吗?系统能自愈吗?需要人立刻做什么吗?第三个问题答不上来,这条规则就该删------我们一次清点就删掉了 19 条,占规则总数的 40%,而有效覆盖反而上升了。

第三,降噪四手段缺一不可,且只有依赖抑制能治风暴。 去重管重复、抑制管等级堆叠、聚合管数量、依赖抑制管因果 。很多团队只做了聚合,于是故障依然刷屏------因为聚合把 1847 条压成 40 条,但那 40 条说的是同一件事。

第四,P1 必须走独立通道,且必须有 ack 与升级。 独立通道的意义不是更响,而是它不能被批量静音 ;ack 的意义是给值班人一个"我已经在处理"的出口,替代那个让他停止被轰炸的静音按钮。1.1 节如果有 ack + 5 分钟自动升级,故障会在 23:20 被发现,而不是次日 09:20。

第五,Agent 的四类特有告警各有各的坑 :成本绝不能是 P1;质量漂移不能用绝对阈值(judge 有随机性);循环要基于重复调用率而非总步数;降级生效意味着已自愈,所以不是 P1,但持续降级必须升级查根因。

最后一点 :值班同学把群静音,不是纪律问题,是设计问题。 当一个人在 3 分钟内收到 1847 条消息、其中 63% 他不知道该如何处理时,静音是唯一理性的选择。你要做的不是要求他"别静音",而是让"不静音"变成一个他能承受的选项。

衡量这件事做得好不好的标准很直接 :上一班次,值班人收到的每一条告警,他都知道该做什么吗?如果答案是"大部分知道",你的体系是健康的;如果答案是"一半以上不知道",那么再多再复杂的降噪规则也救不了它------先去做 runbook 清点。

落地自检清单(Checklist)

  • ✅ 每条告警都有明确等级(P1/P2/P3),且由三个问题推导得出
  • ✅ P1 走独立通道(电话/短信),不与 P2/P3 共用群
  • ✅ 每条告警都有 runbook,且 CI 校验 runbook 文件存在
  • ✅ runbook 包含六要素:摘要 / 验证 / 处置 / 验证恢复 / 升级 / 历史
  • ✅ 配置了依赖抑制(上游故障压制下游症状告警)
  • ✅ 抑制规则都写了 equal,没有全局核弹式规则
  • ✅ 聚合用了 group_by + group_wait
  • ✅ 有 ack 机制 ,且 P1 超时未 ack 会自动升级
  • ✅ 升级是换人 + 换通道 + 换时限,不是重复发送
  • ✅ 静音只用于计划内维护,且带到期时间与负责人
  • ✅ 成本告警是 P2/P3,看单位成本,阈值相对基线
  • ✅ 质量告警用趋势 + 容差,不用绝对阈值
  • ✅ 循环告警基于重复调用率,能区分长任务与死循环
  • ✅ 降级告警有两级(生效 P3 / 持续 30 分钟 P2)
  • ✅ 表达式无高基数标签 ,分母有 clamp_min 兜底
  • ✅ P1 的 for 在 1~10 分钟区间内
  • ✅ 每月统计告警准确率,低于 50% 即启动治理
  • ✅ 每季度盘点规则,触发过吗?响应了吗?动作是什么?
  • ✅ 每季度做一次 runbook 演练(按文档走一遍)
  • ✅ Alertmanager ≥2 副本,且每月演练 P1 通道端到端可用

常见问题(FAQ)

Q1:告警这么多,从哪开始治理?

从 runbook 清点开始,不要从调阈值开始。 把所有规则摊开,逐条问"收到后第一步做什么",答不上来的当场删。我们一次清点删掉 40% 的规则,有效告警量反而上升。 调阈值是第二位的事,而且它治不了"不知道该做什么"这个根本问题。

Q2:P1 到底该有几条规则?

8~15 条是个合理区间。 少于 8 条说明有真实故障没被覆盖;多于 15 条说明你把 P2 提升成了 P1。判断标准是"这条告警响了,我会不会在半夜起床动手"------不会,它就不是 P1。

Q3:抑制会不会把真问题也压掉?

会,这就是必须写 equal 的原因。 没有 equal 的抑制规则是全局核弹。另外,被抑制的告警依然可见 (amtool alert query --inhibited),所以事后复盘能看到当时有哪些症状------这是抑制优于静音的关键:抑制保留证据,静音销毁证据。

Q4:质量告警为什么不能用绝对阈值?

因为 judge 有随机性。 第 36 篇讲过:judge 与人类一致率约 85%,且同一模型不同批次之间存在浮点非确定性。用 score < 4.0 做告警必然每周误报几次 ,几次之后值班人就不看了。正确做法是"6 小时均值 < 7 日基线的 93%",且 for: 6h。

Q5:成本告警要不要进 P1?

默认不要。 用户感知不到成本,半夜叫醒人没有可行动作。唯一例外是"突破硬性预算上限且按当前速率 2 小时内会击穿"------这时有明确动作(限流或切小模型),符合 P1 判据。

Q6:值班同学还是静音了怎么办?

先别批评,先问"你当时收到了多少条、知道该做什么的有几条"。 静音是结果不是原因。三个解法:① 降噪(让消息量降到可承受);② 补 runbook(让每条都有动作);③ 提供 ack 作为替代出口。三条做完还静音,那才是纪律问题。

Q7:小团队需要排班和升级吗?

排班可以不 formal,但 ack 一定要有。 两个人轮值、用 IM 通知、加一个"我已知晓"按钮------成本几乎为零,收益是"不会再有人因为消息太多而放弃"。升级策略等团队超过 5 人再建。

Q8:怎么知道告警体系是健康的?

看四个数字 :单人单班次 P1 ≤ 2 次、告警准确率 > 50%、无 runbook 告警 = 0、非计划静音 = 0。第二个数字最有价值也最少被统计------如果你的告警准确率低于 20%,值班同学对告警的默认态度必然是"大概率是噪音"。


参考资料

  1. Google SRE Book --- Practical Alerting from Time-Series Data (告警哲学与规则设计):https://sre.google/sre-book/practical-alerting/
  2. Google SRE Book --- Being On Call (值班负担、认知负荷与排班原则):https://sre.google/sre-book/being-on-call/
  3. Google SRE Book --- Monitoring Distributed Systems (警报分级:ticket / email / page):https://sre.google/sre-book/monitoring-distributed-systems/
  4. Prometheus 官方文档 --- Alerting Best Practices (什么该告警、标签与注解设计):https://prometheus.io/docs/practices/alerting/
  5. Prometheus 官方文档 --- Alertmanager (去重、分组、抑制、静音与路由):https://prometheus.io/docs/alerting/latest/alertmanager/
  6. Prometheus 官方文档 --- Recording Rules (用预聚合降低告警查询开销):https://prometheus.io/docs/prometheus/latest/configuration/recording_rules/
  7. Prometheus 官方文档 --- Metric Types (Histogram 与 histogram_quantile 的正确用法):https://prometheus.io/docs/concepts/metric_types/
  8. OpenTelemetry 官方文档 --- GenAI Metrics (Agent 成本与 Token 类指标的标准定义):https://opentelemetry.io/docs/specs/semconv/gen-ai/gen-ai-metrics/
  9. Grafana 官方文档 --- Grafana Alerting (告警规则与通知策略的现代实现):https://grafana.com/docs/grafana/latest/
相关推荐
严肃小白兔2 小时前
PHP 8.6 正式发布:部分函数应用、原生 I/O 轮询与新特性实战解析
开发语言·php
郝学胜-神的一滴2 小时前
Effective Python 条款36:优雅拼装迭代器与生成器
开发语言·数据结构·人工智能·python·numpy·scikit-learn
wuyk5554 小时前
Python办公自动化-第04讲-批量新建Excel
开发语言·python·excel
code2cat4 小时前
【随笔】Java客户端选了HTTP/3,怎样知道请求实际走了哪个版本
java·开发语言·http
prince_zxill5 小时前
把 17 个散文件装进一个文件夹:拆解 claude-plugins-official 的插件打包术(47,413 Star 实测)
python·github·agent·mcp·claude code
wflynn5 小时前
AI 产品 ChatPRD 遭遇 token 欺诈,滥用者用免费试用构建游戏地图
ai·技术
程序员张富华6 小时前
一次发布拦住12个破坏性变更:我们给Agent工作流加了Schema门禁
人工智能·agent
honker_X7 小时前
Python字符串全攻略:从入门到精通
开发语言·python
半杯咖啡半行码7 小时前
Qt 隐式共享(Implicit Sharing)深度解析:机制、陷阱与 Qt6迁移
开发语言·数据库·qt