NestJS：在异常过滤器之前执行拦截器

Question

我需要对某些 ​​API 调用进行事件跟踪（基于处理程序名称），它基本上是一个记录活动的函数。

目前我有一个拦截器可以执行此事件跟踪并且工作正常。

但问题是，每当出现错误时，我都会使用全局异常过滤器捕获它，并且这会立即返回响应，而无需输入拦截器和我的事件跟踪代码（我需要类名称、处理程序名称和返回的数据（如果可用））。

这是我的设置

应用程序模块.ts

import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import { MongooseModule } from '@nestjs/mongoose';
import { APP_INTERCEPTOR, APP_FILTER } from '@nestjs/core';

import { AuthModule } from './auth/auth.module';
import { MembersModule } from './members/members.module';

import { DatabaseConfigService } from './_database/database-config.service';
import { EventTrackerService } from './event-tracker/event-tracker.service';

import { LoggingInterceptor } from './_interceptors/logging.interceptor';
import { EventsTrackerInterceptor } from './_interceptors/events-tracker.interceptor';

import { AllExceptionsFilter } from './_filters/all-exception.filter';

@Module({
  imports: [
    ConfigModule.forRoot({
      isGlobal: true,
    }),
    MongooseModule.forRootAsync({
      useClass: DatabaseConfigService,
    }),
    AuthModule,
    MembersModule,
  ],
  providers: [
    {
      provide: APP_INTERCEPTOR,
      useClass: LoggingInterceptor,
    },
    {
      provide: APP_INTERCEPTOR,
      useClass: EventsTrackerInterceptor,
    },
    {
      provide: APP_FILTER,
      useClass: AllExceptionsFilter,
    },
    EventTrackerService,
  ],
})
export class AppModule {}

事件跟踪器.interceptor.ts

import {
  CallHandler,
  ExecutionContext,
  Injectable,
  NestInterceptor,
} from '@nestjs/common';
import { Observable } from 'rxjs';
import { tap } from 'rxjs/operators';
import { EventTrackerService } from '../event-tracker/event-tracker.service';

@Injectable()
export class EventsTrackerInterceptor implements NestInterceptor {
  constructor(private readonly eventTrackerService: EventTrackerService) {}

  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const request = context.switchToHttp().getRequest();
    const response = context.switchToHttp().getResponse();
    const className = context.getClass().name;
    const handler = context.getHandler().name;

    return next.handle().pipe(
      tap(data => {
        this.eventTrackerService.handleEvent(
          request.url,
          className,
          handler,
          data,
        );
      }),
    );
  }
}

所有异常.filter.ts

import {
  ExceptionFilter,
  Catch,
  ArgumentsHost,
  HttpException,
  HttpStatus,
  Logger,
} from '@nestjs/common';
import { EventTrackerService } from '../event-tracker/event-tracker.service';

@Catch()
export class AllExceptionsFilter implements ExceptionFilter {
  constructor(private readonly eventTrackerService: EventTrackerService) {}
  catch(exception: any, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse();
    const request = ctx.getRequest();

    const status =
      exception instanceof HttpException
        ? exception.getStatus()
        : HttpStatus.FORBIDDEN;

    const message =
      typeof exception.message === 'string'
        ? exception.message
        : exception.message.message;

    const errorResponse = {
      statusCode: status,
      timestamp: new Date().toISOString(),
      path: request.url,
      message: message || 'Something went wrong',
    };
    Logger.error(
      `${request.method} ${request.url} ${status}`,
      JSON.stringify(errorResponse),
      'AllExceptionsFilter',
      true,
    );
    response.status(status).json(errorResponse);
  }
}

我的最终问题是：尽管抛出异常，如何在拦截器中调用事件跟踪器？

Answer 1

对于拦截器，您有两种选择之一：1）实现 的一个catchError分支pipe，执行逻辑并重新抛出错误，或者 2）tap可以接受类似于订阅的对象next, error, complete，并运行某些函数以了解可观察到的情况。水龙头可能看起来像

return next.handle().pipe(
  tap({
    next: (data) => this.eventTrackerService.handleEvent(
          request.url,
          className,
          handler,
          data,
        ),
    error: (err) => this.eventTrackerService.handleEvent(
          request.url,
          className,
          handler,
          error,
        )
  })
);

现在您有了一个tap可以处理成功和错误的方法，但现在您还传递错误而不是返回到跟踪器的数据。