微服务

Node.js微服务日志功能实现方案

在微服务架构中，日志系统需要解决分布式系统的核心挑战：跨服务追踪、日志集中化和上下文连续性。以下是基于Node.js的完整实现方案：

一、核心架构设计

微服务日志架构

  1. 服务级日志收集：每个微服务实例独立记录日志
  2. 追踪ID传播：通过全链路ID串联跨服务请求
  3. 日志聚合层：使用Filebeat或Fluentd收集日志
  4. 存储分析层：Elasticsearch + Kibana技术栈

二、技术实现步骤

1. 基础日志库配置（Winston示例）

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
// lib/logger.js
const { createLogger, format, transports } = require('winston');
const { combine, timestamp, json } = format;

class Logger {
  constructor(serviceName) {
    this.logger = createLogger({
      level: process.env.LOG_LEVEL || 'info',
      format: combine(
        timestamp({ format: 'YYYY-MM-DD HH:mm:ss.SSS' }),
        format.json()
      ),
      defaultMeta: { service: serviceName },
      transports: [
        new transports.Console(),
        new transports.File({ 
          filename: 'logs/combined.log',
          maxsize: 1024 * 1024 * 5 // 5MB
        })
      ]
    });
  }

  // 代理所有日志方法
  log(level, message, meta) {
    this.logger.log(level, message, meta);
  }
}

module.exports = Logger;

2. 分布式追踪实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// middleware/tracing.js
const { v4: uuidv4 } = require('uuid');

module.exports = (req, res, next) => {
  // 从请求头获取或生成追踪ID
  req.traceId = req.headers['x-request-id'] || uuidv4();
  
  // 设置响应头用于后续服务
  res.setHeader('X-Request-ID', req.traceId);
  
  // 注入日志实例
  req.logger = logger.child({ 
    traceId: req.traceId,
    userId: req.user?.id 
  });
  
  next();
};

3. 增强型日志记录（带性能监控）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// middleware/requestLogger.js
module.exports = (req, res, next) => {
  const start = Date.now();
  
  res.on('finish', () => {
    const duration = Date.now() - start;
    req.logger.info('Request completed', {
      method: req.method,
      path: req.path,
      status: res.statusCode,
      duration,
      userAgent: req.headers['user-agent']
    });
  });

  next();
};

4. 异常处理强化

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
// errorHandler.js
const logger = require('./logger');

module.exports = {
  register: (app) => {
    // 捕获未处理异常
    process.on('uncaughtException', (error) => {
      logger.error('Uncaught Exception', { error });
      process.exit(1);
    });

    // 捕获未处理的Promise拒绝
    process.on('unhandledRejection', (reason) => {
      logger.error('Unhandled Rejection', { reason });
    });

    // Express错误处理中间件
    app.use((err, req, res, next) => {
      req.logger.error('Request Error', {
        error: err.stack,
        route: req.originalUrl
      });
      
      res.status(500).json({ 
        error: 'Internal Server Error',
        traceId: req.traceId 
      });
    });
  }
};

三、高级功能实现

1. 结构化日志增强

1
2
3
4
5
6
7
8
9
// 添加业务上下文
function businessLogger(req, eventType, details) {
  req.logger.info('BusinessEvent', {
    eventType,
    userId: req.user.id,
    ip: req.ip,
    ...details
  });
}

2. OpenTelemetry集成

1
2
3
4
5
6
7
8
9
10
11
12
13
const { NodeTracerProvider } = require('@opentelemetry/node');
const { SimpleSpanProcessor } = require('@opentelemetry/tracing');
const { JaegerExporter } = require('@opentelemetry/exporter-jaeger');

const provider = new NodeTracerProvider();
provider.addSpanProcessor(
  new SimpleSpanProcessor(
    new JaegerExporter({
      serviceName: 'order-service'
    })
  )
);
provider.register();

3. 日志采样配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 生产环境采样率控制
const samplingRate = process.env.NODE_ENV === 'production' ? 0.3 : 1.0;

const winstonLogger = createLogger({
  transports: [
    new transports.Console({
      log: (info, next) => {
        if (Math.random() < samplingRate) {
          next();
        }
      }
    })
  ]
});

四、部署架构建议

  1. Sidecar模式：每个Pod部署Filebeat容器收集日志
  2. Kubernetes集成：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    # fluent-bit配置示例
    apiVersion: v1
    kind: ConfigMap
    metadata:
      name: fluent-bit-config
    data:
      fluent-bit.conf: |
        [INPUT]
          Name              tail
          Path              /var/log/containers/*.log
          Parser            docker
        
        [OUTPUT]
          Name              es
          Host              elasticsearch
          Port              9200
          Logstash_Format   On
  3. 安全加固：
    • 使用RBAC控制ES访问权限
    • 日志字段脱敏处理
    • TLS加密日志传输通道

五、性能优化策略

  1. 异步日志写入：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    const asyncTransport = new transports.File({
      filename: 'logs/app.log',
      handleExceptions: true,
      maxsize: 1024 * 1024 * 5, // 5MB
      format: format.json(),
      options: { flags: 'a' },
      tailable: true,
      zippedArchive: true,
      maxFiles: 5
    });

    asyncTransport._write = (chunk, encoding, callback) => {
      setImmediate(() => {
        fs.appendFile(asyncTransport.filename, chunk, callback);
      });
    };

  2. 日志分级处理：

    1
    2
    3
    4
    5
    const errorTransport = new transports.File({
      filename: 'logs/errors.log',
      level: 'error',
      handleRejections: true
    });

六、监控告警配置

  1. Kibana告警规则：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    {
      "alert": {
        "name": "ErrorRateAlert",
        "conditions": {
          "script": {
            "source": "ctx.results[0].hits.total.value > 100",
            "lang": "painless"
          }
        },
        "actions": [{
          "type": "email",
          "subject": "High Error Rate Detected"
        }]
      }
    }

关键考量点：

  1. 日志分级策略：建议采用Syslog级别标准
  2. 敏感数据处理：使用正则表达式过滤器
  3. 日志生命周期：ES索引滚动策略（7天热存储+30天冷存储）
  4. 合规性要求：GDPR日志保留策略实现

通过上述方案，可以实现：

  • 单请求全链路追踪
  • 秒级日志搜索响应
  • 动态日志采样能力
  • 生产级可靠性保障