Node.js async_hooks模块：处理异步问题

为什么需要 async_hooks？

node 是异步编程模型，存在一些痛点问题：

  • 异步调用链很难追踪
  • 缺少异步上下文的概念
  • 缺少异步上下文的存储 API

而 async_hooks 就是为了解决这些问题而生。

Async Scope

函数有上下文，异步调用也有上下文。

对于一段异步代码，在不做特殊处理情况下，无法得知是哪个函数调用了此段代码：

1
2
3
4
5
function readFile(filePath) {
  fs.read(filePath, (err, data) => {
    console.log('data is', data)
  })
}

readFile 可能被 Function A、Async Function A 调用，也可能在 setTimeout 等回调函数中调用。

而每个 async scope 都有一个上下文，executionAsyncId()返回当前 async scope 的 id，triggerAsyncId()返回调用者的 async scope 的 id。

Async Hooks

每次 async scope 生成或者销毁时，都会触发 async hook，可以通过creatHook创建相关 hook，并且启用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
const fs = require('fs')
const async_hooks = require('async_hooks')
async_hooks.createHook({
  init (asyncId, type, triggerAsyncId, resource) {
    fs.writeSync(1, `${type}(${asyncId}): trigger: ${triggerAsyncId}\n`)
  },
  destroy (asyncId) {
    fs.writeSync(1, `destroy: ${asyncId}\n`);
  }
}).enable()
async function A () {
  fs.writeSync(1, `A -> ${async_hooks.executionAsyncId()}\n`)
  setTimeout(() => {
    fs.writeSync(1, `A in setTimeout -> ${async_hooks.executionAsyncId()}\n`)
    B()
  })
}
async function B () {
  fs.writeSync(1, `B -> ${async_hooks.executionAsyncId()}\n`)
  process.nextTick(() => {
    fs.writeSync(1, `B in process.nextTick -> ${async_hooks.executionAsyncId()}\n`)
    C()
    C()
  })
}
function C () {
  fs.writeSync(1, `C -> ${async_hooks.executionAsyncId()}\n`)
  Promise.resolve().then(() => {
    fs.writeSync(1, `C in promise.then -> ${async_hooks.executionAsyncId()}\n`)
  })
}
fs.writeSync(1, `top level -> ${async_hooks.executionAsyncId()}\n`)
A()

CLS：Connection Local Storage

对于多线程的语言，例如 Java，有 TLS（Thread Local Storage）。它提供线程级存储，只能在相同线程内访问到。

类似地，对于异步模型的 Nodejs，CLS 提供 Async Scope 级的存储。它只能在异步上下文中被访问。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
const http = require('http');
const fs = require('fs')
const { AsyncLocalStorage } = require('async_hooks');

const asyncLocalStorage = new AsyncLocalStorage();

function logWithId(msg) {
  console.log('logWithId: ', asyncLocalStorage.getStore())
}

function readFile() {
    fs.readFile('./index.js', (err, data) => {
        console.log('readFile: ', asyncLocalStorage.getStore())
    })
}

let idSeq = 0;
http.createServer((req, res) => {
  asyncLocalStorage.run(idSeq++, () => {
    logWithId(); // 正常打印
    readFile(); // 正常打印
    setImmediate(() => {
      logWithId(); // 正常打印
      res.end();
    });
  });

  logWithId(); // 打印：undefined
  readFile(); // 打印：undefined
}).listen(8080);

http.get('http://localhost:8080');

应用场景

应用 1：利用 Hook 接口，追踪异步调用链路

应用 2：利用 CLS，埋点请求链路信息

对于应用 2，类似于 Nestjs 提供的 Scope.REQUEST 概念：对每次请求，生成实例。

对于 NestJS/Koa/Express 等 Node 应用来说，都有next回调函数的概念，由开发者控制。

因此，可以在请求进入的最前面的中间件中，创建整个链路都会使用的信息（例如 RequestID），并且构造 CLS。

1
2
3
4
5
let alsId = 0;

async function firstMiddleware(ctx, next) {
  asyncLocalStorage.run(alsId++, () => next());
}

这是一个简单的 demo，之后的链路中，都可以通过 asyncLocalStorage.getStore() 来拿到请求 ID。

在真实场景中，store 可以是一个复杂对象。

参考链接