nest流转requestId的最佳实践

requestId 的作用

js
复制
@Controller()
export class MiddleController {
  @Get('/getList')
  async getList(@Query('username') username: string) {
    console.log('username', username);
    const res = await this.getNotes(username);
    console.log('res', res);
    return res;
  }

  async getNotes(username: string) {
    return fetch('http://localhost:3001/notes?username=' + username, {
      method: 'GET',
      headers: {
        'Content-Type': 'application/json',
      },
    }).then((res) => res.json());
  }
}

js
复制
username 123
username 789
res 返回的数据
res 返回的数据

js
复制
console.log('res', res); 
// 改成
console.log('res', username , res);

最佳实践：AsyncLocalStorage

使用方法

1. 创建存储空间 (Store)： 创建一个 AsyncLocalStorage 实例，就像一个独立的盒子。
2. 运行并存储 (Run and Store)： 使用 .run() 方法在这个“盒子”里启动一个函数，并提供一个初始值（存储空间）。
3. 在任何地方访问 (Access Anywhere)： 在该函数及其所有同步或异步后继代码中，你都可以使用 .getStore() 方法来获取当前异步上下文中的那个值。

nest中如何使用

ts
复制
import { Injectable } from '@nestjs/common';
import { AsyncLocalStorage } from 'async_hooks';

// 定义上下文数据接口
interface AsyncContext {
  XTransactionID: string;
}

@Injectable()
export class AsyncContextService {
  private readonly asyncLocalStorage = new AsyncLocalStorage<AsyncContext>();

  /**
   * 运行带有上下文的函数
   * @param context 上下文数据
   * @param fn 要执行的函数
   * @returns 函数执行结果
   */
  run<T>(context: AsyncContext, fn: () => T): T {
    return this.asyncLocalStorage.run(context, fn);
  }

  /**
   * 获取当前上下文中的XTransactionID
   * @returns XTransactionID 或 'NULL'
   */
  getXTransactionID(): string {
    const context = this.asyncLocalStorage.getStore();
    return context?.XTransactionID ?? 'NULL';
  }

  /**
   * 设置当前上下文中的XTransactionID
   * @param XTransactionID 事务ID
   */
  setXTransactionID(XTransactionID: string): void {
    const context = this.asyncLocalStorage.getStore();
    if (context) {
      context.XTransactionID = XTransactionID;
    }
  }

  /**
   * 获取当前完整上下文
   * @returns 当前上下文或undefined
   */
  getContext(): AsyncContext | undefined {
    return this.asyncLocalStorage.getStore();
  }
}

ts
复制
import { Module, Global } from '@nestjs/common';
import { AsyncContextService } from './async.service';

@Global()
@Module({
  providers: [AsyncContextService],
  exports: [AsyncContextService],
})
export class AsyncContextModule {}

ts
复制
import {
  Injectable,
  Inject,
  LoggerService as LService,
} from '@nestjs/common';

import { WINSTON_MODULE_NEST_PROVIDER } from 'nest-winston';
import { AsyncContextService } from 'src/async.service';

@Injectable()
export class LoggerService {
  @Inject(WINSTON_MODULE_NEST_PROVIDER)
  private logger!: LService;

  @Inject(AsyncContextService)
  private asyncContext!: AsyncContextService;

  private get getId() {
    return this.asyncContext.getXTransactionID();
  }

  error(message: string, trace?: string) {
    this.logger.error(message, trace, this.getId);
  }

  warn(message: string) {
    this.logger.warn(message, this.getId);
  }

  log(message: string) {
    this.logger.log(message, this.getId);
  }

  verbose(message: string) {
    this.logger.verbose?.(message, this.getId);
  }

  debug(message: string) {
    this.logger.debug?.(message, this.getId);
  }
}

ts
复制
import { Global, Module, Logger } from '@nestjs/common';

import * as winston from 'winston';
import { WinstonModule, utilities } from 'nest-winston';

import { ConfigService } from '@nestjs/config';
import { LoggerService } from 'src/logger.service';

import 'winston-daily-rotate-file';

@Global()
@Module({
  imports: [
    WinstonModule.forRootAsync({
      useFactory: (configService: ConfigService) => {

        const logger = new Logger('WinstonConfig');
        const winstonConfig = configService.get('winston') as WinstonConfig;
        logger.debug(`${JSON.stringify(winstonConfig)}`);

        const { level, dirname, filename, datePattern, maxSize, maxFiles } =
          winstonConfig;

        return {
          level: 'debug',
          transports: [
            new winston.transports.Console({
              format: winston.format.combine(
                winston.format.timestamp(),
                utilities.format.nestLike(),
              ),
            }),
            new winston.transports.DailyRotateFile({
              level,
              dirname,
              filename,
              datePattern,
              maxSize,
              maxFiles, // 最多保存多少天
              zippedArchive: true, // 压缩
              format: winston.format.combine(
                winston.format.timestamp(),
                winston.format.simple(),
              ),
            }),
            new winston.transports.DailyRotateFile({
              level: 'error',
              dirname,
              filename: `error-${filename}`,
              datePattern,
              maxSize,
              maxFiles,
              zippedArchive: true,
              format: winston.format.combine(
                winston.format.timestamp(),
                winston.format.simple(),
              ),
            }),
          ],
        };
      },
      inject: [ConfigService],
    }),
  ],
  providers: [LoggerService],
  exports: [LoggerService],
})
export class LoggerModule {}

ts
复制
import {
  CallHandler,
  ExecutionContext,
  Injectable,
  NestInterceptor,
  Inject,
} from '@nestjs/common';

import { Observable, tap } from 'rxjs';
import { uuid } from 'src/utils';

import { LoggerService } from 'src/logger.service';
import { AsyncContextService } from 'src/async.service';

@Injectable()
export class InvokeRecordInterceptor implements NestInterceptor {
  @Inject(LoggerService)
  private logger!: LoggerService;

  @Inject(AsyncContextService)
  private asyncContext!: AsyncContextService;

  intercept(
    context: ExecutionContext,
    next: CallHandler<any>,
  ): Observable<any> | Promise<Observable<any>> {
    const XTransactionID = uuid();

    // 使用AsyncLocalStorage存储XTransactionID
    return new Observable((observer) => {
      this.asyncContext.run({ XTransactionID }, () => {
        const result = this.handleRequest(next);
        result.then((obs) => obs.subscribe(observer));
      });
    });
  }

  private async handleRequest(
    next: CallHandler<any>,
  ): Promise<Observable<any>> {
    const now = Date.now();

    const tapOperator = tap((res) => {
      this.logger.debug(
        JSON.stringify({
          time: `${Date.now() - now}ms`,
          Response: res,
        }),
      );
    });

    return next.handle().pipe(tapOperator);
  }
}

效果展示

绝对不推荐使用：Scope.REQUEST

ts
复制
@Injectable({ scope: Scope.REQUEST }) // 请求级作用域
export class xxxService {
}

1. 性能损耗与内存开销

在nest中，默认创建的模块都是单例模块，它的特点就是在服务启动时实例化一次（也就是new 这个类），在重新启动服务前，这个实例都不会再初始化了，并且这个模块可以使用 onModuleInit, onApplicationBootstrap 等生命周期钩子。

使用 Scope.REQUEST 定义的模块就是懒加载模块，他在服务启动时并不会实例化，在每个请求流转执行到他时都会实例化，也就是请求流转涉及到的 class 的 constructor 在每次请求时都会执行，这个要特别注意！这就造成一定的性能开销。onModuleInit, onApplicationBootstrap 等生命周期钩子都不会执行了，因为他们已经错过了执行时机，这就像一场派对（应用启动）。onApplicationBootstrap 是派对正式开始时的鸣枪仪式。如果一个客人（懒加载模块）在派对开始一小时后才迟到入场，我们不可能为了他再鸣一次枪。不要小瞧这些小钩子，有的时候他们很有用。而懒加载会导致有些生命周期钩子不可用（onModuleInit, onApplicationBootstrap）

2. 依赖链污染

在 NestJS 中，一旦一个模块直接或间接引入了任何 Scope.REQUEST 的模块，整个模块都会变成“懒加载模块”（Lazy-loaded module）。这个是一个非常值得注意的点，我之前就是使用Scope.REQUEST 定义的logger.service，由于日志打印每个模块基本都用，造成了所有模块几乎都是懒加载模块！

3. 与某些特性不兼容