如何追踪NodeJS+ExpressJS中请求重定向的函数调用序列

针对重定向这种跨请求的场景，普通栈追踪和morgan日志确实没法直接覆盖完整调用链，下面是几个实用的实现方案：

方案1：自定义追踪中间件+重定向拦截 #

给每个请求生成唯一ID，手动记录每个自定义函数的调用信息，同时拦截res.redirect来标记跳转行为，最后在响应结束时输出完整链路。

const express = require('express');
const app = express();
const crypto = require('crypto');

// 初始化追踪信息的中间件
app.use((req, res, next) => {
  req.traceId = crypto.randomUUID();
  req.traceChain = [{
    timestamp: Date.now(),
    step: '请求入口',
    path: req.path
  }];
  next();
});

// 重写res.redirect，记录跳转动作
const originalRedirect = res.redirect.bind(res);
res.redirect = function(targetUrl) {
  req.traceChain.push({
    type: '重定向',
    from: req.path,
    to: targetUrl,
    timestamp: Date.now()
  });
  return originalRedirect(targetUrl);
};

// 封装工具函数：自动获取当前函数的名称和代码位置
function getCallerInfo() {
  const stackLine = new Error().stack.split('\n')[2];
  const matchResult = stackLine.match(/\((.*):(\d+):\d+\)/) || [];
  return {
    funcName: stackLine.split(' ')[1],
    file: matchResult[1],
    line: matchResult[2]
  };
}

// 自定义处理函数示例
function userPageHandler(req, res) {
  const callerInfo = getCallerInfo();
  req.traceChain.push({
    timestamp: Date.now(),
    step: '函数调用',
    funcName: callerInfo.funcName,
    file: callerInfo.file,
    line: callerInfo.line,
    path: req.path
  });
  
  res.redirect('/profile');
}

function profilePageHandler(req, res) {
  const callerInfo = getCallerInfo();
  req.traceChain.push({
    timestamp: Date.now(),
    step: '函数调用',
    funcName: callerInfo.funcName,
    file: callerInfo.file,
    line: callerInfo.line,
    path: req.path
  });
  
  res.send('个人主页');
}

// 响应结束时打印完整追踪链
app.use((req, res, next) => {
  res.on('finish', () => {
    console.log(`请求追踪链 [${req.traceId}]:`, JSON.stringify(req.traceChain, null, 2));
  });
  next();
});

app.get('/user', userPageHandler);
app.get('/profile', profilePageHandler);

app.listen(3000);

方案2：用AsyncLocalStorage跨请求关联追踪 #

重定向本质是发起新的HTTP请求，所以需要用请求ID关联前后两次请求的追踪信息。Node.js 14+的AsyncLocalStorage可以跨异步上下文传递数据，结合Cookie保存追踪ID，就能串联起完整的跳转链路：

const { AsyncLocalStorage } = require('async_hooks');
const express = require('express');
const cookieParser = require('cookie-parser');
const crypto = require('crypto');
const app = express();
app.use(cookieParser());

const als = new AsyncLocalStorage();
// 内存存储追踪链，生产环境可替换为Redis
const traceStore = new Map();

// 初始化追踪上下文
app.use((req, res, next) => {
  let traceId = req.cookies.traceId;
  if (!traceId) {
    traceId = crypto.randomUUID();
    res.cookie('traceId', traceId, { maxAge: 3600000 });
  }

  // 取出之前的追踪链（如果是重定向过来的）
  let traceChain = traceStore.get(traceId) || [];

  als.run({ traceId, traceChain }, () => {
    // 记录当前请求的入口
    const callerInfo = getCallerInfo();
    als.getStore().traceChain.push({
      timestamp: Date.now(),
      step: '新请求入口',
      path: req.path,
      file: callerInfo.file,
      line: callerInfo.line
    });
    next();
  });
});

// 复用方案1的getCallerInfo工具函数
function getCallerInfo() {
  const stackLine = new Error().stack.split('\n')[2];
  const matchResult = stackLine.match(/\((.*):(\d+):\d+\)/) || [];
  return {
    funcName: stackLine.split(' ')[1],
    file: matchResult[1],
    line: matchResult[2]
  };
}

// 自动给处理函数加追踪的包装器
function withTrace(fn) {
  return (req, res, next) => {
    const callerInfo = getCallerInfo();
    als.getStore().traceChain.push({
      timestamp: Date.now(),
      step: '函数调用',
      funcName: fn.name,
      file: callerInfo.file,
      line: callerInfo.line,
      path: req.path
    });
    return fn(req, res, next);
  };
}

// 拦截重定向，保存当前追踪链
app.use((req, res, next) => {
  const originalRedirect = res.redirect.bind(res);
  res.redirect = function(targetUrl) {
    als.getStore().traceChain.push({
      type: '重定向',
      from: req.path,
      to: targetUrl,
      timestamp: Date.now()
    });
    traceStore.set(als.getStore().traceId, als.getStore().traceChain);
    return originalRedirect(targetUrl);
  };
  next();
});

// 响应结束时输出完整链路并清理存储
app.use((req, res, next) => {
  res.on('finish', () => {
    const store = als.getStore();
    console.log(`完整追踪链 [${store.traceId}]:`, JSON.stringify(store.traceChain, null, 2));
    traceStore.delete(store.traceId);
  });
  next();
});

// 用包装器处理自定义函数
const userHandler = withTrace((req, res) => {
  res.redirect('/profile');
});

const profileHandler = withTrace((req, res) => {
  res.send('个人主页');
});

app.get('/user', userHandler);
app.get('/profile', profileHandler);

app.listen(3000);

方案3：用debug模块手动标记（轻量版） #

如果不想写复杂的中间件，直接用debug模块给每个函数加日志标记，简单直接：

const debug = require('debug')('req-trace');
const express = require('express');
const app = express();

function userHandler(req, res) {
  debug(`[${req.path}] 调用函数: ${userHandler.name} (${__filename}:20)`);
  debug(`[${req.path}] 重定向到 /profile`);
  res.redirect('/profile');
}

function profileHandler(req, res) {
  debug(`[${req.path}] 调用函数: ${profileHandler.name} (${__filename}:26)`);
  res.send('个人主页');
}

app.get('/user', userHandler);
app.get('/profile', profileHandler);

app.listen(3000);

启动时设置环境变量DEBUG=req-trace就能看到日志，行号可以手动填写，或者配合Node.js的--enable-source-maps自动获取。

内容的提问来源于stack exchange，提问作者ginjaemocoes