【Node.js】process：从底层原理到生产实践（一）

1
template <typename T, size_t StaticCapacity>
2
class MaybeStackBuffer {
3
public:
4
  MaybeStackBuffer() : buffer_(static_buffer_), size_(StaticCapacity) {}
5

6
  // 分配足够的内存
7
  void AllocateSufficientStorage(size_t required) {
8
    if (required <= StaticCapacity) return; // 栈内存足够
9
    // 分配堆内存
10
    buffer_ = static_cast<T*>(realloc(buffer_, required * sizeof(T)));
11
    size_ = required;
12
  }
13

14
  T* data() const { return buffer_; }
15
  size_t size() const { return size_; }
16

17
private:
18
  T static_buffer_[StaticCapacity]; // 栈内存
19
  T* buffer_; // 指向栈或堆内存
20
  size_t size_;
21
};

1
node::Maybe<std::string> RealEnvStore::Get(const char* key) const {
2
  size_t init_size = 256;
3
  MaybeStackBuffer<char, 256> buffer; // 栈内存256字节
4

5
  // 1. 尝试用栈内存读取
6
  int ret = uv_os_getenv(key, buffer.data(), &init_size);
7
  if (ret == UV_ENOBUFS) { // 栈内存不够
8
    // 2. 分配足够的堆内存
9
    buffer.AllocateSufficientStorage(init_size);
10
    // 3. 再次读取
11
    ret = uv_os_getenv(key, buffer.data(), &init_size);
12
  }
13

14
  if (ret == 0) { // 成功
15
    return node::Just(std::string(buffer.data(), init_size));
16
  } else { // 失败（如环境变量不存在）
17
    return node::Nothing<std::string>();
18
  }
19
}

1
static void EnvSetter(v8::Local<v8::Name> property,
2
                      v8::Local<v8::Value> value,
3
                      const v8::PropertyCallbackInfo<v8::Value>& info) {
4
  Environment* env = Environment::GetCurrent(info);
5
  v8::Isolate* isolate = env->isolate();
6

7
  // 1. 转换属性名和值为C字符串
8
  std::string key, val;
9
  if (!node::ToCString(isolate, property.As<v8::String>(), &key).ok()) return;
10
  if (!node::ToCString(isolate, value, &val).ok()) return;
11

12
  // 2. 设置环境变量
13
  int ret = uv_os_setenv(key.c_str(), val.c_str());
14
  if (ret != 0) {
15
    // 设置失败，抛出错误
16
    node::ThrowErrnoException(isolate, ret, "uv_os_setenv");
17
  }
18
}

1
require('dotenv').config() // 加载.env到process.env
2
console.log(process.env.DB_HOST) // 输出"localhost"

1
process._fatalException = function (er) {
2
  // 1. 检查是否有`uncaughtException`监听器
3
  if (process.listenerCount('uncaughtException') > 0) {
4
    // 2. 触发`uncaughtException`事件
5
    process.emit('uncaughtException', er)
6
    // 3. 如果监听器处理了异常，返回true（不退出进程）
7
    return true
8
  }
9
  // 4. 没有监听器，返回false（退出进程）
10
  return false
11
}

1
const winston = require('winston')
2
const logger = winston.createLogger({
3
  transports: [
4
    new winston.transports.File({ filename: 'error.log' }),
5
    new winston.transports.Console(),
6
  ],
7
  format: winston.format.combine(
8
    winston.format.timestamp(),
9
    winston.format.json()
10
  ),
11
})
12

13
process.on('uncaughtException', (err) => {
14
  logger.error('未处理的异常', {
15
    error: err.message,
16
    stack: err.stack,
17
    pid: process.pid,
18
    env: process.env.NODE_ENV,
19
  })
20

21
  // 紧急清理 + 退出
22
  process.exit(1)
23
})

1
process.on('uncaughtException', async (err) => {
2
  logger.error('未处理的异常', { err })
3

4
  try {
5
    await dbClient.close() // 关闭数据库连接（快速操作）
6
    logger.info('数据库连接已关闭')
7
  } catch (closeErr) {
8
    logger.error('关闭数据库失败', { closeErr })
9
  }
10

11
  process.exit(1)
12
})