[Re-Open] Sentry 연동, 코드베이스에 Exception Filter, Response Interceptor 적용

.env

@@ -1,3 +1,4 @@
-MONGO_URL=mongodb+srv://linkit-dev:[email protected]/linkit-dev
+MONGO_URL="mongodb+srv://<UserName>:<Password>@<Host>/<DB>?<External Options>"
+SENTRY_DSN="Sentry DSN"
 JWT_SECRET="JWT Secret"
-JWT_EXPIRE_TIME="Expire Time"
+JWT_EXPIRE_TIME="Expire Time"

.github/workflows/build.yml

@@ -22,7 +22,6 @@ jobs:
       - name: pnpm settings
         uses: pnpm/action-setup@v4
         with:
-          version: '9.4'
           run_install: false
       - name: Install dependencies
         run: pnpm install

package.json

@@ -31,6 +31,8 @@
     "@nestjs/passport": "^10.0.3",
     "@nestjs/platform-express": "^10.0.0",
     "@nestjs/swagger": "^7.3.1",
+    "@sentry/node": "^8.9.2",
+    "@sentry/profiling-node": "^8.9.2",
     "aws-lambda": "^1.0.7",
     "aws-serverless-express": "^3.4.0",
     "class-transformer": "^0.5.1",

src/app.config.ts

@@ -1,10 +1,13 @@
-// Nest Packages
 import {
   ClassSerializerInterceptor,
   INestApplication,
   ValidationPipe,
 } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
 import { Reflector } from '@nestjs/core';
+import * as Sentry from '@sentry/node';
+import { nodeProfilingIntegration } from '@sentry/profiling-node';
+import { CommonResponseInterceptor, RootExceptionFilter } from './common';
 
 export async function nestAppConfig<
   T extends INestApplication = INestApplication,
@@ -17,6 +20,35 @@ export async function nestAppConfig<
       transform: true,
     }),
   );
-
   app.useGlobalInterceptors(new ClassSerializerInterceptor(reflector));
 }
+
+export function nestResponseConfig<
+  T extends INestApplication = INestApplication,
+>(app: T, connectSentry = false) {
+  app.useGlobalInterceptors(new CommonResponseInterceptor());
+  connectSentry
+    ? configExceptionFilterWithSentry(app)
+    : configFilterStandAlone(app);
+}
+
+// Enable Exception Filter stand-alone
+function configFilterStandAlone<T extends INestApplication = INestApplication>(
+  app: T,
+) {
+  app.useGlobalFilters(new RootExceptionFilter());
+}
+
+// Enalbe Exception Filter with Sentry Connection
+function configExceptionFilterWithSentry<
+  T extends INestApplication = INestApplication,
+>(app: T) {
+  const config = app.get<ConfigService>(ConfigService);
+  Sentry.init({
+    dsn: config.get<string>('SENTRY_DSN'),
+    integrations: [nodeProfilingIntegration()],
+    tracesSampleRate: 1.0,
+    profilesSampleRate: 1.0,
+  });
+  Sentry.setupNestErrorHandler(app, new RootExceptionFilter());
+}

src/bootstrap.ts

@@ -3,7 +3,7 @@ import { ExpressAdapter } from '@nestjs/platform-express';
 import express from 'express';
 import { AppModule } from './app.module';
 import { nestSwaggerConfig } from './app.swagger';
-import { nestAppConfig } from './app.config';
+import { nestAppConfig, nestResponseConfig } from './app.config';
 
 export async function bootstrap() {
   const expressInstance: express.Express = express();
@@ -17,6 +17,8 @@ export async function bootstrap() {
   nestAppConfig(app);
   // Config application Swagger
   nestSwaggerConfig(app);
+  // Config Response
+  nestResponseConfig(app, false);
 
   return { app, expressInstance };
 }

src/common/error/exception.abstract.ts

@@ -0,0 +1,15 @@
+import { ExceptionPayload } from '../types/type';
+
+export abstract class RootException<
+  T extends ExceptionPayload = ExceptionPayload,
+  U extends number = number,
+> extends Error {
+  constructor(
+    public readonly payload: T,
+    public readonly statuscode: U,
+    public readonly name: string,
+  ) {
+    super();
+    this.message = payload.message as string;
+  }
+}

src/common/error/exception.factory.ts

@@ -0,0 +1,23 @@
+import { ExceptionPayload } from '../types/type';
+import { RootException } from './exception.abstract';
+
+const codeUnknown = 'Unknown';
+
+export const createException = (
+  statusCode: number,
+  message: string,
+  code = codeUnknown,
+) => {
+  const payload: ExceptionPayload = {
+    code: code,
+    message: message,
+  };
+
+  const errorContextName =
+    code === codeUnknown ? `${codeUnknown} - ${message}` : code;
+  return class extends RootException {
+    constructor() {
+      super(payload, statusCode, errorContextName);
+    }
+  };
+};

src/common/error/index.ts

@@ -0,0 +1,2 @@
+export * from './exception.abstract';
+export * from './exception.factory';

src/common/filter/base.filter.ts

@@ -0,0 +1,70 @@
+import {
+  ArgumentsHost,
+  Catch,
+  ExceptionFilter,
+  HttpException,
+} from '@nestjs/common';
+import { captureException } from '@sentry/node';
+import { Response } from 'express';
+import { RootException, createException } from '../error';
+import { ExceptionPayload, ICommonResponse } from '../types/type';
+
+@Catch()
+export class RootExceptionFilter implements ExceptionFilter {
+  private unknownCode = 'Unknown';
+
+  catch(exception: any, host: ArgumentsHost) {
+    const context = host.switchToHttp();
+    const response: Response = context.getResponse<Response>();
+    let targetException = exception;
+    let responseStatusCode = 500;
+    let responseErrorPayload: ExceptionPayload = {
+      code: this.unknownCode,
+      message: '',
+    };
+
+    // If exception is http exception instance
+    if (targetException instanceof HttpException) {
+      // Response Message
+      const response = targetException.getResponse();
+      // Response Status Code
+      responseStatusCode = targetException.getStatus();
+      responseErrorPayload = {
+        code: this.unknownCode,
+        message: response,
+      };
+    }
+    // Custom Exception
+    else if (targetException instanceof RootException) {
+      // Response Message
+      const response = targetException.payload;
+      // Response Status Code
+      const statusCode = targetException.statuscode;
+      responseErrorPayload = response;
+      responseStatusCode = statusCode;
+    }
+    // Error
+    else {
+      const errorMessage = targetException.message;
+      // Response Status Code
+      responseStatusCode = 500;
+      // Response Message
+      responseErrorPayload = {
+        code: this.unknownCode,
+        message: errorMessage,
+      };
+      targetException = new (class extends createException(
+        responseStatusCode,
+        errorMessage ?? exception.name,
+        this.unknownCode,
+      ) {})();
+    }
+    captureException(targetException);
+    const exceptionResponse: ICommonResponse = {
+      success: false,
+      error: responseErrorPayload,
+    };
+
+    return response.status(responseStatusCode).json(exceptionResponse);
+  }
+}

src/common/filter/index.ts

@@ -0,0 +1 @@
+export * from './base.filter';

src/common/index.ts

@@ -1 +1,4 @@
+export * from './error';
+export * from './filter';
+export * from './interceptor';
 export * from './decorators';

src/common/interceptor/index.ts

@@ -0,0 +1 @@
+export * from './response.interceptor';

src/common/interceptor/response.interceptor.ts

@@ -0,0 +1,19 @@
+import { CallHandler, ExecutionContext, NestInterceptor } from '@nestjs/common';
+import { Observable, map } from 'rxjs';
+import { ICommonResponse } from '../types/type';
+
+export class CommonResponseInterceptor implements NestInterceptor {
+  intercept(
+    context: ExecutionContext,
+    next: CallHandler<any>,
+  ): Observable<any> | Promise<Observable<any>> {
+    return next.handle().pipe(
+      map((payload = {}): ICommonResponse => {
+        return {
+          success: true,
+          data: payload,
+        };
+      }),
+    );
+  }
+}

src/common/types/type.d.ts

@@ -1,4 +1,24 @@
 import { Types } from 'mongoose';
+// Exception Payload
+export type ExceptionPayload = {
+  code?: string;
+  message: string | object;
+};
+
+export type ICommonResponse = ICommonErrorResponse | ICommonSuccessResponse;
+
+// Error Response
+export type ICommonErrorResponse = {
+  success: true;
+  data: any;
+};
+
+// Success Response
+export type ICommonSuccessResponse = {
+  success: false;
+  error: ExceptionPayload;
+}
+
 
 export type JwtPayload = {
   id: string;