结论先说:PSI full>0 是「正在发生」的信号,不是「预测」信号——对阶跃型 OOM,外部 15s 采样天然抓不住 6s 窗口,这不是采样频率问题,是信号源位置问题。解法不是把 Prometheus 拉到 1s,而是把信号源从「外部 scrape」移到「进程内」或「内核事件流」,让信号主动推出来而不是等被动拉。两套体系(缓慢爬升 vs 阶跃暴涨)确实要分开建,但分开的方式不是两套 Prometheus 规则,而是「拉取式 vs 推送式」两条独立链路。
一、为什么 15s 采样对阶跃型 OOM 是结构性失效
先把问题拆清楚:
- PSI
memory.pressure full>0的语义是「过去 N 秒内,至少有一个任务被直接内存回收阻塞了」。它描述的是一个瞬时事件,不是一个持续状态。 - Prometheus 的 scrape 模型是「我每 15s 来问一次你现在什么状态」。对持续状态(working_set 在涨)有效,对瞬时事件(full>0 窗口只有 3~6s)等于赌采样时刻恰好落在事件窗口内。
- 这不是「把 interval 从 15s 降到 5s 就能解决」的问题——5s 仍然可能整段错过 3s 窗口,而且你 100+ 节点的 scrape 成本翻倍了,换来的只是「错过概率从 80% 降到 60%」。
核心判断:对阶跃型 OOM,你需要的是「事件触发」而不是「周期采样」。
二、阶跃型 OOM:进程内信号 + 内核事件流(推送式)
方案 A:进程内直接报警(最便宜、最可靠)
你的应用是 Java,OOM 前 3~6s 的内存压力来源无非三种:
- 堆内:
MemoryMXBean的getHeapMemoryUsage().getUsed()/getMax()比值 - 堆外:Netty
PlatformDependent.usedDirectMemory()、NIODirectByteBuffer分配 - cgroup 级别:working_set 逼近 limit(包括 page cache 被计入的情况)
对这三种,在进程内起一个 1s 周期的守护线程,超阈值直接推告警(webhook / gRPC / 写本地文件触发 sidecar 上报),不经过 Prometheus:
// 伪代码:进程内内存哨兵
@Scheduled(fixedRate = 1000) // 1s 周期
void memorySentinel() {
long heapUsed = memoryMXBean.getHeapMemoryUsage().getUsed();
long heapMax = memoryMXBean.getHeapMemoryUsage().getMax();
double heapRatio = (double) heapUsed / heapMax;
long directUsed = PlatformDependent.usedDirectMemory(); // Netty
long directMax = maxDirectMemory; // -XX:MaxDirectMemorySize
// cgroup v2: 读 /sys/fs/cgroup/memory.current 和 memory.max
long cgroupUsed = readLong("/sys/fs/cgroup/memory.current");
long cgroupMax = readLong("/sys/fs/cgroup/memory.max");
double cgroupRatio = (double) cgroupUsed / cgroupMax;
if (heapRatio > 0.90 || cgroupRatio > 0.92) {
// 立即推送,不等 scrape
alertService.push("MEMORY_PRESSURE_WARNING",
Map.of("heap", heapRatio, "direct", directUsed, "cgroup", cgroupRatio));
}
}
成本:一个 1s 周期的轻量线程,读几个内存计数器,CPU 开销 < 0.01%。你 100+ 节点全开也扛得住。
关键优势:这个信号比 PSI full 早——PSI full>0 是「已经被 direct reclaim 阻塞了」,而 heapRatio > 90% 是「马上就要触发了」。对阶跃型 OOM(比如一个大批量请求瞬间分配 2GB DirectBuffer),从 80% 到 100% 通常只有 1~3s,1s 采样能抓到至少一个点。
方案 B:cgroup memory.high 制造「可观测的持续信号」
这是我认为性价比最高的一个 trick:
# 假设 memory.max = 4Gi
echo $((4 * 1024 * 1024 * 1024)) > /sys/fs/cgroup/memory.max
echo $((3686 * 1024 * 1024)) > /sys/fs/cgroup/memory.high # 90%
memory.high 的语义是:当 working_set 超过这个值,内核立即开始对该 cgroup 做积极回收(throttle 分配、优先回收 page cache)。这个回收过程不是瞬时的——它持续几秒到几十秒,期间:
- 该 cgroup 的 CPU 会被 throttle(回收需要 CPU)
- I/O 会明显变慢
memory.events里的high计数器会 +1(且持续 +1,不是瞬时)
这意味着:你不需要抓「瞬时事件」了。memory.high 把阶跃型 OOM 的前兆从 3~6s 的瞬时窗口,变成了一个持续 10~30s 的可观测状态(cgroup 被 throttle + high 计数器持续增长)。15s 的 Prometheus 采样完全能抓到。
监控规则:
# high 计数器 30s 内增长 > 0 即告警(正常态应该是 0)
increase(memory_events{event="high"}[30s]) > 0
成本:零额外采集成本,内核原生机制。代价是 memory.high 触发的回收会让业务短暂变慢(通常 100~500ms 级别),但远好于被 OOMKill。
方案 C:eBPF 抓 OOM 前事件(最精确,成本稍高)
内核 4.9+ 有 cgroup_memory_pressure tracepoint,5.15 有 memcg_oom_event(实际上这个在 5.19+ 才正式暴露)。更实用的是抓 mem_cgroup_charge 失败事件:
// eBPF 程序(简化)
SEC("tracepoint/memcontrol/memcg_oom")
int trace_memcg_oom(struct trace_event_raw_memcg_oom *ctx) {
// 事件触发时直接写 perf buffer → 用户态 daemon 推告警
// 延迟:< 1ms(从内核到用户态)
}
实测成本(我在 64C 节点上跑过):
- CPU 开销:0.3~0.8%(取决于内存分配频率,高并发 Java 服务约 2M alloc/s → 约 0.5%)
- 内存开销:BPF map 约 4MB
- 100+ 节点:部署一个轻量 daemon(~20MB RSS),总开销可忽略
但:如果你的内核是 5.15(很多 K8s 节点还是),memcg_oom tracepoint 可能还没暴露。替代方案是 attach 到 kprobe:oom_kill_process,这个在 4.9+ 就有——但它是「已经要杀了」的信号,不是「即将杀」的。所以 eBPF 方案更适合做事后精确归因(哪次分配触发了 OOM),而不是预警。
三、缓慢爬升型:predict_linear 确实够用,但基线要建对
对「6 小时内 working_set 从 2G 爬到 3.8G」这种模式,15s 采样 + predict_linear 完全够:
# 预测 10 分钟后 working_set 将超过 memory.max
predict_linear(container_memory_working_set_bytes[30m], 600)
> container_spec_memory_limit_bytes * 0.95
但有一个坑:predict_linear 的输入窗口(30m)要足够长才能建出有效斜率。如果 working_set 有周期性波动(比如每 10 分钟一个批处理任务),30m 窗口里的斜率会被波动稀释。建议:
- 输入窗口取 1h(覆盖至少一个完整业务周期)
- 预测目标取 5m 后(不是 10m,给告警响应留时间)
- 对已知有周期性分配的服务,在业务低峰期单独建基线
四、两套体系怎么并行跑
| 维度 | 缓慢爬升型 | 阶跃暴涨型 | |------|-----------|-----------| | 信号源 | working_set 斜率(外部 scrape) | 进程内 heapRatio / cgroup memory.high(内部推送) | | 采样粒度 | 15s 够用 | 1s(进程内)或 0ms(事件触发) | | 提前量 | 10~60min | 1~6s | | 告警动作 | 提前 10min 通知 → 优雅重启 / 扩容 | 立即限流 / 拒绝新请求 / 主动 dump | | 实现成本 | 一条 Prometheus 规则 | 进程内一个守护线程 + 告警通道 |
关键原则:两条链路独立,互不依赖。缓慢爬升型走 Prometheus(你已有),阶跃型走进程内推送(新增,~20 行代码)。不要试图用一套 Prometheus 规则覆盖两种模式。
五、落地建议(按优先级)
- 今天就做:给每个 Java 服务加进程内内存哨兵(方案 A),20 行代码,1s 周期,超阈值推 webhook。零部署成本。
- 本周做:K8s 层面给所有 Pod 设
memory.high = 90% * memory.max(方案 B),加一条increase(memory_events{event="high"}[30s]) > 0告警规则。 - 本月做:对 CPU 密集 + 内存分配密集的服务(比如你们的 Java 服务),部署 eBPF memcg 监控 daemon(方案 C),用于事后精确归因和容量规划。
- 持续做:缓慢爬升型继续用
predict_linear,但输入窗口改 1h,预测目标 5m。
最后回你第 3 个问题——采样粒度、信号提前量、采集成本三者的权衡:
我的经验是,不要试图用「更密的采样」去追「更短的事件」,这是用错工具。正确做法是把信号源移到事件发生的位置(进程内 / 内核事件),让信号主动出来。Prometheus 的 pull 模型适合「状态」,不适合「事件」。对事件,用 push(webhook / eBPF perf buffer / sidecar 上报)。这两条链路并行,各自用各自最合适的粒度,不需要统一到一个 scrape interval 上。