我之前刚好处理过类似的需求，核心问题确实是Winston的全局Logger实例没法直接拿到请求上下文，得从请求处理的链路里入手解决——毕竟路由信息只有在请求进来的时候才能拿到嘛。这里给你两种可行的实现方案，你可以根据自己的场景选：

方案一：中间件层面动态绑定专属Logger（简单直接） #

这个思路是在请求进入时，通过Express/Koa中间件识别路由，给当前请求挂载一个包含对应日志文件Transport的Logger实例，后续业务代码直接用这个请求级的Logger打日志即可。

步骤1：预定义各业务线的Transport #

先初始化好教师、学生以及合并日志的Transport，避免重复创建：

const winston = require('winston');
const fs = require('fs');

// 确保日志目录存在
const logDir = './logs';
if (!fs.existsSync(logDir)) {
  fs.mkdirSync(logDir);
}

// 初始化各业务日志Transport
const teacherTransport = new winston.transports.File({
  level: 'info',
  filename: `${logDir}/teachers.log`
});

const studentTransport = new winston.transports.File({
  level: 'info',
  filename: `${logDir}/students.log`
});

// 基础Logger：包含控制台输出+合并日志
const baseLogger = winston.createLogger({
  transports: [
    new winston.transports.Console({ level: 'info', colorize: true }),
    new winston.transports.File({ level: 'info', filename: `${logDir}/combined.log` })
  ]
});

步骤2：编写路由识别中间件 #

在中间件里根据请求路由，给当前请求挂载专属Logger：

function routeLoggerMiddleware(req, res, next) {
  // 复制基础Logger的配置，避免修改全局实例
  const requestLogger = winston.createLogger({
    transports: [...baseLogger.transports]
  });

  // 根据路由添加对应业务的Transport
  if (req.path.startsWith('/api/v1/teachers')) {
    requestLogger.add(teacherTransport);
  } else if (req.path.startsWith('/api/v1/students')) {
    requestLogger.add(studentTransport);
  }

  // 将Logger挂载到req对象上，后续业务直接调用
  req.logger = requestLogger;
  next();
}

// 在Express中注册中间件（要放在所有路由之前）
app.use(routeLoggerMiddleware);

步骤3：业务代码中使用请求级Logger #

在路由处理逻辑里，直接用req.logger打日志即可：

app.get('/api/v1/teachers', (req, res) => {
  req.logger.info('获取教师列表接口被调用', { query: req.query });
  // 业务逻辑...
  res.status(200).json({ data: [] });
});

app.post('/api/v1/students', (req, res) => {
  req.logger.info('新增学生接口被调用', { body: req.body });
  // 业务逻辑...
  res.status(201).json({ msg: '创建成功' });
});

方案二：自定义Transport实现路由动态分文件（更灵活） #

如果后续需要扩展更多业务线的日志分离，这种方式更适合——通过自定义Transport，根据日志元数据里的路由信息，自动将日志写入对应文件。

步骤1：自定义路由匹配的Transport #

继承Winston的File Transport，根据日志中的路由字段动态切换输出文件：

const { File } = winston.transports;
const fs = require('fs');
const path = require('path');

class RouteBasedFileTransport extends File {
  constructor(opts) {
    super(opts);
    // 配置路由与日志文件的映射关系
    this.routeFileMap = opts.routeFileMap || {};
  }

  log(info, callback) {
    // 根据日志中的route字段匹配对应文件
    let targetFile = this.filename;
    if (info.route && this.routeFileMap[info.route]) {
      targetFile = this.routeFileMap[info.route];
    }

    // 确保目标文件所在目录存在
    const dir = path.dirname(targetFile);
    if (!fs.existsSync(dir)) {
      fs.mkdirSync(dir, { recursive: true });
    }

    // 切换当前Transport的输出文件，再执行父类的日志写入逻辑
    this.filename = targetFile;
    super.log(info, callback);
  }
}

步骤2：初始化全局Logger并注入路由元数据 #

通过Winston的Format，将请求路由注入到日志元数据中：

const winston = require('winston');
const { format } = winston;

// 自定义Format：注入请求路由信息
const injectRouteFormat = format((info, opts) => {
  if (opts.route) {
    // 只保留路由前缀，去掉查询参数
    info.route = opts.route.split('?')[0];
  }
  return info;
});

// 初始化全局Logger
const logger = winston.createLogger({
  format: format.combine(
    injectRouteFormat(),
    format.timestamp(),
    format.json()
  ),
  transports: [
    new winston.transports.Console({ level: 'info', colorize: true }),
    new RouteBasedFileTransport({
      level: 'info',
      filename: './logs/combined.log',
      // 配置路由-文件映射
      routeFileMap: {
        '/api/v1/teachers': './logs/teachers.log',
        '/api/v1/students': './logs/students.log'
      }
    })
  ]
});

步骤3：中间件绑定路由到Logger #

通过中间件创建Logger的子实例，注入当前请求的路由信息：

app.use((req, res, next) => {
  // 创建Logger子实例，携带当前路由信息
  req.logger = logger.child({ route: req.path });
  next();
});

后续业务代码里的用法和方案一完全一致，无需额外修改。

两种方案都能实现你的需求：教师CRUD日志写入teachers.log，学生CRUD日志写入students.log，同时所有日志都会保留在combined.log里。方案一更适合小项目快速落地，方案二更适合需要长期扩展的场景。

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