Add: logging middleware

package.json

@@ -76,7 +76,10 @@
     "passport-jwt": "^4.0.1",
     "reflect-metadata": "^0.1.13",
     "rimraf": "^3.0.2",
-    "rxjs": "^7.2.0"
+    "rxjs": "^7.2.0",
+    "uuid": "^10.0.0",
+    "winston": "^3.14.2",
+    "winston-daily-rotate-file": "^5.0.0"
   },
   "devDependencies": {
     "@nestjs/cli": "^9.0.0",
@@ -88,6 +91,7 @@
     "@types/jest": "28.1.4",
     "@types/node": "^16.18.23",
     "@types/supertest": "^6.0.2",
+    "@types/uuid": "^10.0.0",
     "@typescript-eslint/eslint-plugin": "^5.0.0",
     "@typescript-eslint/parser": "^5.0.0",
     "cross-env": "^7.0.3",

src/app.module.ts

@@ -1,4 +1,4 @@
-import { Module } from '@nestjs/common';
+import { MiddlewareConsumer, Module, NestModule } from '@nestjs/common';
 import { APP_GUARD } from '@nestjs/core';
 import { JwtService } from '@nestjs/jwt';
 import { AppController } from './app.controller';
@@ -29,6 +29,7 @@
 import { ClsPluginTransactional } from '@nestjs-cls/transactional';
 import { PrismaService } from '@src/prisma/prisma.service';
 import { TransactionalAdapterPrisma } from '@nestjs-cls/transactional-adapter-prisma';
+// import { LoggingMiddleware } from "@src/common/middleware/http.logging.middleware";
 
 @Module({
   imports: [
@@ -83,7 +84,7 @@
     {
       provide: APP_GUARD,
       useFactory: () => {
         const env = process.env.NODE_ENV;
       },
     },
     JwtCookieGuard,

src/bootstrap/bootstrap.ts

@@ -5,6 +5,8 @@ import session from 'express-session';
 import { AppModule } from '../app.module';
 import settings from '../settings';
 import morgan = require('morgan');
+import { LoggingInterceptor } from '@src/common/middleware/http.logging.middleware';
+import { HttpExceptionFilter } from '@src/common/filter/http.exception.filter';
 
 async function bootstrap() {
   const app = await NestFactory.create(AppModule);
@@ -53,6 +55,8 @@ async function bootstrap() {
     }),
   );
 
+  app.useGlobalInterceptors(new LoggingInterceptor());
+  app.useGlobalFilters(new HttpExceptionFilter());
   app.enableShutdownHooks();
   return app.listen(8000);
 }

src/common/filter/http.exception.filter.ts

@@ -0,0 +1,93 @@
+import {
+  ExceptionFilter,
+  Catch,
+  ArgumentsHost,
+  HttpException,
+  HttpStatus,
+} from '@nestjs/common';
+import { Request, Response } from 'express';
+import * as winston from 'winston';
+import 'winston-daily-rotate-file';
+import { v4 as uuidv4 } from 'uuid';
+
+// JSON 포맷을 커스터마이징하여 메시지와 속성 순서를 설정
+const customFormat = winston.format.printf(({ message }) => {
+  return JSON.stringify(message);
+});
+
+// 파일 핸들러 설정
+const fileTransport = new winston.transports.DailyRotateFile({
+  filename: 'logs/response-%DATE%.log', // 파일 이름 패턴
+  datePattern: 'YYYY-MM-DD', // 날짜 패턴
+  zippedArchive: true, // 압축 여부
+  maxSize: '10m', // 파일 최대 크기
+  maxFiles: '10d', // 백업 파일 수
+  handleExceptions: true, // 예외 처리
+  format: winston.format.combine(customFormat),
+});
+
+const logger = winston.createLogger({
+  transports: [fileTransport],
+  exitOnError: false, // 예외 발생 시 프로세스 종료하지 않음
+});
+
+@Catch(HttpException)
+export class HttpExceptionFilter implements ExceptionFilter {
+  catch(exception: HttpException, host: ArgumentsHost) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse();
+    const request = ctx.getRequest();
+    const status = exception.getStatus
+      ? exception.getStatus()
+      : HttpStatus.INTERNAL_SERVER_ERROR;
+
+    const startTime = Date.now();
+    const requestId = request.headers['uuid'] || uuidv4();
+
+    const { method, headers, query } = request;
+
+    // 요청 데이터 처리
+    let requestData = {};
+    try {
+      if (method === 'GET') {
+        requestData = { ...query };
+      } else if (method === 'POST') {
+        requestData = { ...request.body };
+      } else {
+        requestData = { ...request.body };
+      }
+    } catch (error) {
+      requestData = {}; // 예외 발생 시 빈 객체로 처리
+    }
+    const requestLog = {
+      method,
+      path: request.path, // URI만 포함하도록 수정
+      UUID: requestId,
+      data: requestData,
+      user: request?.user?.sid ?? '',
+      // meta,
+    };
+
+    // 예외 로그 기록
+    const errorResponseLog = {
+      status: status,
+      data: response?.body ?? '',
+    };
+
+    // 전체 로그 객체
+    const logData = {
+      request: requestLog,
+      response: errorResponseLog,
+    };
+
+    // 로그 출력
+    logger.error(logData);
+
+    // 응답 생성
+    response.status(status).json({
+      statusCode: status,
+      timestamp: new Date().toISOString(),
+      path: request.url,
+    });
+  }
+}

src/common/middleware/http.logging.middleware.ts

@@ -0,0 +1,145 @@
+import {
+  CallHandler,
+  ExecutionContext,
+  Injectable,
+  NestInterceptor,
+  HttpException,
+  HttpStatus,
+} from '@nestjs/common';
+import { Observable, throwError } from 'rxjs';
+import { tap, catchError } from 'rxjs/operators';
+import { v4 as uuidv4 } from 'uuid';
+import * as winston from 'winston';
+import 'winston-daily-rotate-file';
+
+// JSON 포맷을 커스터마이징하여 메시지와 속성 순서를 설정
+const customFormat = winston.format.printf(({ message }) => {
+  return JSON.stringify(message);
+});
+
+// 파일 핸들러 설정
+const fileTransport = new winston.transports.DailyRotateFile({
+  filename: 'logs/response-%DATE%.log', // 파일 이름 패턴
+  datePattern: 'YYYY-MM-DD', // 날짜 패턴
+  zippedArchive: true, // 압축 여부
+  maxSize: '10m', // 파일 최대 크기
+  maxFiles: '10d', // 백업 파일 수
+  handleExceptions: true, // 예외 처리
+  format: winston.format.combine(customFormat),
+});
+
+export const logger = winston.createLogger({
+  transports: [fileTransport],
+  exitOnError: false, // 예외 발생 시 프로세스 종료하지 않음
+});
+
+@Injectable()
+export class LoggingInterceptor implements NestInterceptor {
+  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+    const req = context.switchToHttp().getRequest();
+    const res = context.switchToHttp().getResponse();
+
+    const startTime = Date.now();
+    const requestId = req.headers['uuid'] || uuidv4();
+
+    const { method, headers, query } = req;
+
+    // 요청 데이터 처리
+    let requestData = {};
+    try {
+      if (method === 'GET') {
+        requestData = { ...query };
+      } else if (method === 'POST') {
+        requestData = { ...req.body };
+      } else {
+        requestData = { ...req.body };
+      }
+    } catch (error) {
+      requestData = {}; // 예외 발생 시 빈 객체로 처리
+    }
+
+    const meta = {
+      tz: new Date().toLocaleString('en-US', {
+        timeZone: 'Asia/Seoul',
+        timeZoneName: 'short',
+      }),
+      remote_host: req.hostname,
+      content_length: headers['content-length'] || '',
+      path_info: req.path,
+      remote_addr: req.ip,
+      content_type: headers['content-type'] || '',
+      http_host: headers['host'] || '',
+      http_user_agent: headers['user-agent'] || '',
+    };
+
+    const requestLog = {
+      method,
+      path: req.path, // URI만 포함하도록 수정
+      UUID: requestId,
+      data: requestData,
+      user: req?.user?.sid ?? '',
+      // meta,
+    };
+
+    return next.handle().pipe(
+      tap((responseBody) => {
+        res.on('finish', () => {
+          const duration = Date.now() - startTime;
+          const { statusCode } = res;
+
+          const responseLog = {
+            status: statusCode,
+            // headers: {
+            //   'Content-Type': res.getHeader('Content-Type') || '',
+            //   // ...res.getHeaders(), // 모든 응답 헤더를 포함
+            // },
+            // charset: res.charset || 'utf-8',
+            data: responseBody, // Response Body 저장
+          };
+
+          // request와 response를 하나의 객체로 묶어서 로깅
+          const logData = {
+            request: requestLog,
+            response: responseLog,
+            duration: duration,
+          };
+
+          logger.info(logData);
+        });
+      }),
+      catchError((err) => {
+        res.on('finish', () => {
+          const duration = Date.now() - startTime;
+          const statusCode =
+            err instanceof HttpException
+              ? err.getStatus()
+              : HttpStatus.INTERNAL_SERVER_ERROR;
+
+          const errorResponseLog = {
+            status: statusCode,
+            headers: {
+              'Content-Type': res.getHeader('Content-Type') || '',
+              ...res.getHeaders(), // 모든 응답 헤더를 포함
+            },
+            charset: res.charset || 'utf-8',
+            data: {
+              message: err.message || 'Internal Server Error',
+              stack: err.stack || '', // Stack trace 포함 (원하는 경우)
+            },
+            duration: `${duration}ms`,
+          };
+
+          // 예외 발생 시에도 request는 그대로 남기고, error response를 로깅
+          const logData = {
+            request: requestLog,
+            response: errorResponseLog,
+          };
+
+          logger.error(logData);
+        });
+
+        return throwError(() => err);
+      }),
+    );
+  }
+}

src/modules/auth/auth.config.ts

@@ -6,6 +6,7 @@ import { JwtCommand } from './command/jwt.command';
 import { SidCommand } from './command/sid.command';
 import { IsPublicCommand } from './command/isPublic.command';
 import { AuthChain } from './auth.chain';
+import { SessionCommand } from '@src/modules/auth/command/session.command';
 
 @Injectable()
 export class AuthConfig {
@@ -14,6 +15,7 @@ export class AuthConfig {
     private readonly jwtCommand: JwtCommand,
     private readonly sidCommand: SidCommand,
     private readonly isPublicCommand: IsPublicCommand,
+    private readonly sessionCommand: SessionCommand,
   ) {}
 
   public async config(env: string) {
@@ -34,7 +36,7 @@ export class AuthConfig {
     return this.authChain
       .register(this.isPublicCommand)
       .register(this.sidCommand)
-      .register(this.jwtCommand);
+      .register(this.sessionCommand);
   };
 
   private getProdGuardConfig = () => {

src/modules/auth/auth.service.ts

@@ -130,4 +130,8 @@ export class AuthService {
   ): Promise<session_userprofile> {
     return await this.userRepository.updateUser(userId, user);
   }
+
+  async findBySessionKey(session_key: string) {
+    return await this.userRepository.findBySessionKey(session_key);
+  }
 }

src/modules/auth/command/session.command.ts

@@ -0,0 +1,44 @@
+import { ExecutionContext, Injectable } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { Request } from 'express';
+import { AuthService } from '../auth.service';
+import { JwtService } from '@nestjs/jwt';
+import { AuthCommand, AuthResult } from '../auth.command';
+
+@Injectable()
+export class SessionCommand implements AuthCommand {
+  constructor(
+    private reflector: Reflector,
+    private authService: AuthService,
+    private jwtService: JwtService,
+  ) {}
+
+  public async next(
+    context: ExecutionContext,
+    prevResult: AuthResult,
+  ): Promise<AuthResult> {
+    const request = context.switchToHttp().getRequest<Request>();
+    const response = context.switchToHttp().getResponse<Response>();
+    const accessToken = this.extractTokenFromCookie(request, 'accessToken');
+    const cookie = request.cookies['sessionid'];
+    if (!cookie) {
+      return prevResult;
+    }
+    const user = await this.authService.findBySessionKey(cookie);
+    request['user'] = user;
+    prevResult.authentication = true;
+    prevResult.authorization = true;
+    return prevResult;
+  }
+
+  private extractTokenFromCookie(
+    request: Request,
+    type: 'accessToken' | 'refreshToken',
+  ): string | undefined {
+    const cookie = request.cookies[type];
+    if (cookie) {
+      return cookie;
+    }
+    return undefined;
+  }
+}

src/modules/semesters/semesters.controller.ts

@@ -2,12 +2,14 @@ import { Controller, Get, Query } from '@nestjs/common';
 import { ISemester } from 'src/common/interfaces/ISemester';
 import { toJsonSemester } from '../../common/interfaces/serializer/semester.serializer';
 import { SemestersService } from './semesters.service';
+import { Public } from '@src/common/decorators/skip-auth.decorator';
 
 @Controller('api/semesters')
 export class SemestersController {
   constructor(private readonly semestersService: SemestersService) {}
 
   @Get()
+  @Public()
   async getSemesters(@Query() query: ISemester.QueryDto) {
     const semesters = await this.semestersService.getSemesters(query);
     return semesters.map((semester) => toJsonSemester(semester));