线上 Node SSR 服务内存只涨不跌,从三份 heapsnapshot 里找到了凶手

上个月团队负责的官网和营销活动页整体切到了 SSR(基于 Vue 2.6 和 Nuxt 的那套同构方案)。上线初期流量平稳,体感响应变快了不少。直到五一节前做了一轮压测,运维同学发来告警截图:几台 Node 节点的内存水位线几乎以一条恒定的斜率往上爬,从启动时的 180MB 稳步涨到 1.4GB 触发 PM2 的 max_memory_restart,然后 worker 退出、重启、再循环。

当时我们赶着放假,临时把 PM2 的阈值调大到了 1800MB,并且配置了凌晨定时 reload,靠重启硬顶了两个星期。但大家心里都清楚,内存只涨不跌说明垃圾回收机制完全拿这些常驻对象没办法。假期回来后抽了整整两天时间,通过在线下压测环境抓取三份堆快照做比对,才把藏在深处的一个隐蔽引用链给揪出来。

怎么判断是泄漏,而不是正常的内存占用?

很多人排查 Node 内存问题时容易陷入一个误区:看到 process.memoryUsage().rss 在上涨就惊慌失措。

实际上,Node 进程占用的操作系统常驻内存(RSS)由好几部分组成:

  • V8 堆内存(Heap used / Heap total)
  • V8 外部内存(External,比如 Buffer 和 C++ 绑定的对象)
  • ArrayBuffer 分配
  • 机器码与调用栈等其他杂项

RSS 持续上涨,很多时候只是因为 V8 惰性回收——只要堆大小还没逼近 --max-old-space-size,V8 就倾向于把从系统申请来的虚拟内存捏在手里,不立即归还给操作系统。

真正要命的是:堆内使用量(heapUsed)在多轮 Full GC 后依然只增不减。

在 V8 的分代垃圾回收模型里,堆被划分成新生代(New Space)和老生代(Old Space):

1
2
3
4
5
6
7
8
9
10
+-------------------------------------------------------+
| V8 堆内存 |
| +-------------------------+ +--------------------+ |
| | 新生代 (New) | | 老生代 (Old) | |
| | +---------+---------+ | | | |
| | | From | To | | | Mark-Sweep | |
| | | (分配) | (存活) | | | Mark-Compact | |
| | +---------+---------+ | | | |
| +-------------------------+ +--------------------+ |
+-------------------------------------------------------+

新生代通常只有几十 MB,内部切成 From 和 To 两个 Semi-space,采用 Cheneys 算法做 Scavenge 复制回收。绝大部分临时变量、一次 HTTP 请求生命周期里的局部对象,在几次轻量的 Scavenge 之后就死掉了。

但如果一个对象经历过一次 Scavenge 依然存活,或者在 To 空间已占用超过 25%,它就会晋升(Promote)到老生代。老生代由 --max-old-space-size 控制(在 64 位机器、Node 12 环境下默认约 1.4GB 到 2GB 上下)。老生代采用 Mark-Sweep-Compact 进行全量回收:从根节点(GC Roots,包括全局变量、当前调用栈等)出发打标记,清理死对象并进行内存碎片整理。

如果应用每承接一次 HTTP 请求,就有一小撮对象因为闭包、事件总线或全局字典的引用没有切断,被 GC Roots 一直抓着,那它们就会源源不断地晋升到老生代。一旦老生代堆积,Mark-Sweep 的耗时就会从几毫秒飙升到几百毫秒甚至上千毫秒,直接导致主线程事件循环卡顿,最后就是 OOM 崩溃退出。

当时我们线上节点在 Grafana 上的监控图非常典型:

1
2
3
4
5
6
7
RSS / HeapUsed (MB)
1600 | / (PM2 Restart)
1200 | /-----------/
800 | /-----------/
400 | /-----------/
0 +------+-----------+-----------+-----------+---> Time (Hours)
00:00 06:00 12:00 18:00

锯齿的下边缘(即每次 Full GC 后的基线水位)从不回落,且每次最低点都比前一次高出几十 MB。这是铁板钉钉的内存泄漏。

线下复现与抓取快照的方法

在线上直接抓堆快照风险极大。因为 dump 堆快照是一个完全同步阻塞的操作,V8 会先触发一次强制 GC,然后递归遍历整张对象依赖图,这期间 Node 主线程完全停摆。更麻烦的是,生成快照文件在序列化成 JSON 写入磁盘时,自身还需要额外的内存缓冲,如果当前堆已经逼近 1.4GB,这一抽可能直接把进程当场搞 OOM。

我们选择在线下测试容器中复现。

好在升级到 Node 12(Node 11.13 起原生支持)之后,抓取快照不再需要折腾老旧且容易跟 Node 内部头文件版本冲突的 heapdump 扩展模块了,标准库的 v8 模块就自带了 writeHeapSnapshot。

为了能够随时从外部安全地命令进程 dump 内存,我们写了一个轻量的信号监听:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// scripts/dump-snapshot.js
const v8 = require('v8');
const path = require('path');

// 允许通过向进程发送 SIGUSR2 信号触发快照
process.on('SIGUSR2', () => {
const mem = process.memoryUsage();
console.log(`[Snapshot] 开始记录快照, 当前 heapUsed: ${(mem.heapUsed / 1024 / 1024).toFixed(2)} MB`);

const startTime = Date.now();
// 也可以不传参数,默认会生成 Heap-${timestamp}-${pid}-${threadId}.heapsnapshot
const snapshotPath = path.resolve(process.cwd(), `snapshot-${Date.now()}.heapsnapshot`);
const filename = v8.writeHeapSnapshot(snapshotPath);

console.log(`[Snapshot] 快照已写入 ${filename}, 耗时: ${Date.now() - startTime}ms`);
});

我们在压测机上用 autocannon 模拟用户流量。为了避免其他干扰,排查泄漏有一个行之有效的方法——三快照对比法(Three Snapshot Technique):

  1. 第一份快照(基线):服务启动,先用小流量(比如 200 个请求)热身,让 V8 完成 JIT 优化、各种模块单例完成初始化。然后触发一次快照,记为 Snapshot 1。
  2. 第二份快照(负载期):用 autocannon -c 50 -d 60s http://127.0.0.1:3000/ 压一轮,跑完之后等待几十秒让正在处理的请求彻底结束。这时候生成 Snapshot 2。
  3. 第三份快照(回收验证):再重复一轮相同强度的压测,跑完并静置几分钟。生成 Snapshot 3。

为什么要三份?因为从 Snapshot 1 到 Snapshot 2,有很多模块级缓存、连接池(比如与后端微服务的 Keep-Alive socket)确实是在被动初始化的,这个增量往往包含大量正常开销。

但如果在负载模型完全相同的 Snapshot 2 与 Snapshot 3 之间,还有大批对象“新生成且未释放”,那它几乎 100% 就是泄漏源。

1
2
3
4
5
$ kill -USR2 <pid> # Snapshot 1 (基线)
$ autocannon -c 40 -a 2000 http://127.0.0.1:3000/detail/10086
$ kill -USR2 <pid> # Snapshot 2 (第一轮后)
$ autocannon -c 40 -a 2000 http://127.0.0.1:3000/detail/10086
$ kill -USR2 <pid> # Snapshot 3 (第二轮后)

三个文件落地后,体积分别是 112MB、328MB、546MB。很明显,每次 2000 个请求之后,净增了 200MB 左右的顽固对象。

在 DevTools 里抽丝剥茧

把这三份 .heapsnapshot 下载到本地,打开 Chrome 浏览器的 DevTools -> Memory 面板,点击 Load 逐个载入。

搞清 Shallow Size 和 Retained Size

在看面板数据前,先理清快照里两列至关重要的指标:

  • Shallow Size(自身大小):对象本身直接占用的内存空间(不包含它引用的其他对象)。在 V8 内部,常规的 Object、Closure、Promise 往往只有 24 到 80 字节,除了大字符串、数组缓冲区之外,几乎所有复杂实体的 Shallow Size 都小得不起眼。
  • Retained Size(保留大小):一旦这个对象被垃圾回收器释放,能够连带被级联回收掉的所有对象占用的总字节数。也就是说,如果一个对象是这颗子树的唯一父节点,把父节点斩断,整棵子树都能被释放。

在内存排查中,只看 Shallow Size 经常会被带偏。一个只有 64 字节的看似普通的函数闭包,它的 Retained Size 可能会有 400MB,因为它间接引用了一整个庞大的 Vue 实例树。

切换到 Comparison 视图

打开 Snapshot 3,把顶部的下拉框从 Summary 切成 Comparison,并在基准快照下拉框中选择 Snapshot 2。

我们在底部的构造函数过滤中按照 Size Delta(内存变化增量)和 # Delta(对象数量增量)降序排序:

1
2
3
4
5
6
7
Constructor             # Alloc    # Freed    # Delta    Alloc. Size    Freed. Size    Size Delta
--------------------------------------------------------------------------------------------------
(closure) 18,400 400 +18,000 1.44 MB 32 KB +1.41 MB
system / Context 18,120 120 +18,000 2.17 MB 14 KB +2.16 MB
Object 42,600 6,600 +36,000 3.41 MB 528 KB +2.88 MB
VueComponent 4,020 20 +4,000 1.28 MB 64 KB +1.22 MB
Array 24,100 6,100 +18,000 2.89 MB 732 KB +2.16 MB

在 Snapshot 2 到 Snapshot 3 的这 2000 次请求期间:

  • (closure) 净增加了 18,000 个。
  • system / Context 净增加了 18,000 个。
  • VueComponent 净增加了正好 4,000 个(每个请求渲染刚好包含两个组件)。

这说明:每次 HTTP 请求渲染出来的 Vue 组件实例,连同它的上下文环境和闭包,全都没有被释放。

顺藤摸瓜:阅读 Retainers 引用链

我们在 Comparison 视图中展开 VueComponent,随便点进一个实例,查看下半部分的 Retainers(持有者)面板。

Retainers 面板展示的是:到底是谁在抓着这个对象不放?链路是自底向上推导到 GC Roots 的。

我们看到的依赖链大致是这样(精简了内部属性层级):

1
2
3
4
5
6
7
8
9
VueComponent @1429815
└── $options in Object @1429813
└── context in system / Context @1429801
└── requestInterceptor in Object @1389025
└── [1842] in Array @1120441
└── handlers in InterceptorManager @1120421
└── request in InterceptorManager @1120419
└── interceptors in Axios @984123
└── axiosInstance in Object (module scope)

看到 InterceptorManager 和 Axios 的瞬间,谜底其实已经浮出水面一大半了。

这个 Axios 单例对象里的 interceptors.request.handlers 数组,长度赫然写着 1842,里面密密麻麻塞满了各种拦截器函数。而每一个拦截器函数内部,都在闭包作用域里捕获了当次请求的上下文或者 Vue 实例。

追查根因:SSR 中的 Axios 拦截器黑洞

顺着快照里的线索,我们翻开了项目里的网络请求工具封装文件 src/utils/http.js。

这个文件最开始是客户端单页应用(SPA)时代的遗留代码。当时为了统一处理接口的鉴权头和全局错误提示,前端同事写了类似下面这样的逻辑:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// 客户端 SPA 时代的写法
import axios from 'axios';

const service = axios.create({
baseURL: process.env.API_BASE_URL,
timeout: 5000,
});

export function setTokenAndHeader(token) {
// 每次路由跳转或获取到 token 时注册拦截器
service.interceptors.request.use(
config => {
if (token) {
config.headers['Authorization'] = `Bearer ${token}`;
}
return config;
},
error => Promise.reject(error)
);
}

export default service;

在客户端浏览器里,用户只有一个标签页,刷新就重新加载,就算在导航守卫里调了两三次 setTokenAndHeader,因为生命周期只有单用户,最多数组里多两个函数,完全察觉不到问题。

但是到了 Node SSR 环境,情况完全不同了。

在服务端,所有的 HTTP 请求共享同一个 Node 进程空间。import service from '@/utils/http' 导出的 service 是一个由 Node 模块系统(CommonJS/ESM 缓存)常驻在老生代的模块级单例。

而在 Nuxt 的一个插件里,为了让每次请求都能根据当前请求的 Cookie 解析出用户的鉴权信息并挂到请求头上,开发者写了这样的代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// plugins/axios-setup.js
export default function ({ app, req, store }) {
const token = req.headers.cookie ? parseCookie(req.headers.cookie).token : '';

// 致命的一行:在每个 SSR 请求到来时,向全局单例追加拦截器!
service.interceptors.request.use((config) => {
// 这里引用了当次请求的作用域变量 token 和 store
if (token) {
config.headers['X-User-Token'] = token;
config.headers['X-Trace-Id'] = store.state.traceId;
}
return config;
});
}

Axios 内部的 interceptors.request.use 实现非常朴素,它的源码核心只有两行:

1
2
3
4
5
6
7
8
// axios/lib/core/InterceptorManager.js
InterceptorManager.prototype.use = function use(fulfilled, rejected) {
this.handlers.push({
fulfilled: fulfilled,
rejected: rejected
});
return this.handlers.length - 1;
};

每一次请求进入,handlers.push 就会塞入两个匿名函数。
更致命的是,这个匿名函数闭包捕获了 token 和 store。而 Nuxt 的 store 又深层引用着当前请求的 Vue 实例、路由上下文、以及一整批组件树。

因为 service 是老生代的全局根对象,它的 handlers 数组永不销毁。这 2000 个请求之后,数组里就挂了 2000 个闭包。每一个闭包像一个倒钩,把整套当次请求的内存全牢牢钉在了老生代里,Mark-Sweep 遍历时判定全为 Live Objects,分毫未收。

这就是为什么 (closure)、system / Context、VueComponent 会以 1:1:2 的比例精准暴涨。

几种典型的 SSR 内存泄漏暗坑

排查完 Axios 这个问题后,我们团队把整个 SSR 项目的代码彻底排查了一遍。很多在前端浏览器里完全合规的写法,一旦进入同构直出环境,全是雷。

1. 跨请求共享的单例 Store

在浏览器里,const store = new Vuex.Store(...) 挂在全局没有任何问题。但在服务端:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 错误示范:在模块作用域导出了一个固定单例
import Vue from 'vue';
import Vuex from 'vuex';

Vue.use(Vuex);

const store = new Vuex.Store({
state: {
userInfo: null,
posts: []
}
});

export default store;

如果每个请求直接对这个 store 做 commit,除了会导致状态污染(用户 A 看到用户 B 的私密信息),万一 state 里有数组做 push 操作却未在请求结束时清空,常年累月请求跑下来,内存就会一直膨胀。

正统的做法必须是工厂模式(Factory Pattern),每次请求在独立的上下文中新建实例:

1
2
3
4
5
6
7
8
export function createStore() {
return new Vuex.Store({
state: () => ({
userInfo: null,
posts: []
})
});
}

2. 闭包共享上下文导致的级联持有

很多工程师以为:“我这个闭包只引用了一个小字符串,不应该导致泄漏吧?”

当年 Meteor 团队在博客里提过一个非常经典的 theThing 泄漏模型,它揭示了 V8 闭包的一个底层特性:在同一个外部函数作用域内创建的多个闭包,会共享同一个上下文环境(Context Object)。

看下面这个简化的模型:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
let theThing = null;

function replaceThing() {
const originalThing = theThing;

// 这个函数虽然从没被调用,但它引用了 originalThing
const unused = function () {
if (originalThing) {
console.log('never used');
}
};

// theThing 被重新赋值,它的方法 someMethod 没有使用 originalThing
theThing = {
longStr: new Array(1000000).join('*'),
someMethod: function () {
// 哪怕这里什么都不干
}
};
}

setInterval(replaceThing, 100);

直觉上:unused 根本没执行,someMethod 也没碰 originalThing,每次循环完成,上一次的局部变量 originalThing 应该随函数调用栈销毁。

但 V8 的实现机制是:

  1. unused 和 someMethod 诞生在同一个 replaceThing 执行上下文里。
  2. V8 为了词法作用域链的查找,会为该函数生成一个包含所有被闭包捕获变量的 Context 对象。
  3. someMethod 被赋给了全局变量 theThing,因此 someMethod 存活。
  4. someMethod 间接持有这个共享的 Context 对象。
  5. Context 对象中又包含着 originalThing,而 originalThing 又是上一次循环的 theThing。

最终形成了一条隐式的单向引用链条:每次迭代生成的对象,都通过共享 Context 串着前一次的对象,哪怕前一次的数据早已逻辑作废,V8 依然不得不把它们全部保存在内存里。

3. EventEmitter 监听未注销

在 SSR 服务端逻辑里,如果有使用 process.on、某些全局的 EventBus、或者 Redis/MQ 的订阅客户端,在请求生命周期内添加监听器也是极高发的灾区:

1
2
3
4
5
6
7
8
// 某个请求中间件
app.use((req, res, next) => {
// 错误:向全局单例添加监听
eventBus.on('themeChange', () => {
res.setHeader('X-Theme', 'dark');
});
next();
});

Node 默认有防御机制:当同一个 EventEmitter 上的监听器超过 10 个时,控制台会抛出:
(node:12345) MaxListenersExceededWarning: Possible EventEmitter memory leak detected. 11 themeChange listeners added.

有的人图省事,看到警告直接加一行 eventBus.setMaxListeners(0) 把限制关了,这无异于把烟雾报警器的电池抠掉。正确的做法是使用 .once(),或者在 res.on('finish', ...) 里显式移除对应监听。

4. 模块级缓存无上限

不少人喜欢在服务端写内存缓存:

1
2
3
4
5
6
7
8
9
10
11
12
// utils/cache.js
const cache = {};

export function getCachedData(key, fetcher) {
if (cache[key]) {
return Promise.resolve(cache[key]);
}
return fetcher().then(res => {
cache[key] = res;
return res;
});
}

如果是根据 URL 或者用户 ID 缓存,当请求的维度不可控时,这个简单对象的 key 会无休止地涨下去。如果不设容量上限和过期驱逐策略(比如 LRU),这种写法就是一个定时炸弹。

改造与落地修复

回到我们前面遇到的 Axios 拦截器泄漏问题,修复的核心思路是:永远不要在请求级别(Per-request)修改进程级别(Process-level)的单例状态。

针对每个 SSR 请求,网络客户端要么基于原生配置重新实例化,要么确保单例上的拦截器只在应用启动阶段绑定一次:

1
2
3
4
5
6
7
8
9
10
11
12
13
// plugins/axios-setup.js
export default function ({ $axios, store }) {
// 如果是自己封装的 Axios 单例,必须通过标记位确保全局拦截器只注册一次
if ($axios.__hasInjectedInterceptors) {
return;
}
$axios.__hasInjectedInterceptors = true;

// 在请求拦截器里,不要从外部闭包捕获请求作用域对象,而是从 config 内部拿挂载的动态参数
$axios.interceptors.request.use((config) => {
return config;
});
}

更彻底的重构方案是将请求客户端的创建直接注入到 Nuxt 的 context 中:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// utils/http.js
import axios from 'axios';

// 每次调用生成一个全新的独立实例,绝不共用 handlers
export function createHttpClient(req) {
const instance = axios.create({
baseURL: process.env.API_BASE_URL,
timeout: 5000,
});

const token = req && req.headers && req.headers.cookie ? parseCookie(req.headers.cookie).token : '';

instance.interceptors.request.use((config) => {
if (token) {
config.headers['Authorization'] = `Bearer ${token}`;
}
return config;
});

return instance;
}

在请求处理结束并完成渲染后,由于这个 instance 只在当前请求作用域内流转,当请求响应完毕,整条调用链路的对象全部失去根引用,在下一轮 V8 新生代的 Scavenge 回收中就会被直接清理,根本走不到晋升老生代那一步。

修复后,我们在压测环境下重复了上一轮的测试:

1
$ autocannon -c 50 -a 5000 http://127.0.0.1:3000/

压测期间内存确实会往上冲(因为并发处理需要分配缓冲区),但在流量归零、触发一轮显式 GC 后,老生代堆内存从 310MB 回落到了初始的 92MB。

1
2
3
4
5
6
HeapUsed (MB)
350 | /---\ /---\
250 | / \ / \
150 | / \ / \
90 |________/ \_____/ \_____ (稳定基线)
0 +-----------------------------------------> Time

基线维持在一根水平线上,说明每一个请求生命周期内的对象都如期赴死。

踩坑后的几点体会

经历了这次排查,吸取的几条最深刻的教训:

  1. PM2 的 max_memory_restart 只能当安全气囊,绝不能当降落伞用。 靠频繁重启遮丑,一来会丢失进程内辛苦积攒的 JIT 优化成果,二来在瞬时高峰期,很容易因为重启期间 worker 数量减少直接导致服务雪崩。
  2. 写 SSR 代码时,脑子里要时刻区分“进程生命周期”与“请求生命周期”。 前端工程化演进这么多年,很多开发者习惯了前端浏览器环境“单用户、单实例、页面刷新一键清空”的特性,潜意识里把模块作用域当成请求作用域用,这是同构架构下最隐蔽的杀手。
  3. 善用 v8.writeHeapSnapshot。 以前很多文章教大家装 C++ 扩展,繁琐又容易踩构建坑。在 Node 12 环境下官方内置工具已经足够好用,在线下用真实的请求流量配合三快照对比,基本能把绝大多数异常引用链给看个通透。

至于线上怎么做无感观测,我们目前还在搭针对 Node 进程指标的 Prometheus 探针,后续打算把堆内存增长率和 Full GC 耗时纳入常规监控,比单纯看 RSS 有效得多。

------ 有问题请 留言给我哦! 也欢迎入群讨论! 点我呀! ------

评论加载中…

0%