Merge pull request #339 from boostcampwm-2024/dev-be

Dev be to release

BE/src/InitDB/QUIZ_SET_TEST_DATA.ts

@@ -175,7 +175,7 @@ export const QUIZ_SET_TEST_DATA = [
   },
   {
     title: '영어 문법 테스트',
-    category: 'ENGLISH',
+    category: 'LANGUAGE',
     quizList: [
       {
         quiz: '다음 중 현재완료 시제는?',

BE/src/game/redis/subscribers/player.subscriber.ts

@@ -6,12 +6,12 @@ import { Namespace } from 'socket.io';
 import SocketEvents from '../../../common/constants/socket-events';
 import { REDIS_KEY } from '../../../common/constants/redis-key.constant';
 import { SurvivalStatus } from '../../../common/constants/game';
+import { createBatchProcessor } from '../../service/BatchProcessor';
 import { MetricService } from '../../../metric/metric.service';
 
 @Injectable()
 export class PlayerSubscriber extends RedisSubscriber {
-  private positionUpdates: Map<string, any> = new Map(); // Map<gameId, {playerId, playerPosition}[]>
-  private positionUpdatesForDead: Map<string, any> = new Map(); // Map<gameId, {playerId, playerPosition}[]>
+  private positionProcessor: ReturnType<typeof createBatchProcessor>;
   private positionUpdatesMetrics: Map<string, any> = new Map(); // Map<gameId, {startedAt}[]>
 
   constructor(
@@ -22,16 +22,20 @@ export class PlayerSubscriber extends RedisSubscriber {
   }
 
   async subscribe(server: Namespace): Promise<void> {
+    // Create batch processor for position updates
+    this.positionProcessor = createBatchProcessor(server, SocketEvents.UPDATE_POSITION);
+    this.positionProcessor.startProcessing(100); // Start processing every 100ms
+
     const subscriber = this.redis.duplicate();
     await subscriber.psubscribe('__keyspace@0__:Player:*');
 
     subscriber.on('pmessage', async (_pattern, channel, message) => {
-      const startedAt = process.hrtime();
-
       const playerId = this.extractPlayerId(channel);
       if (!playerId || message !== 'hset') {
         return;
       }
+
+      const startedAt = process.hrtime();
       const playerKey = REDIS_KEY.PLAYER(playerId);
       const gameId = await this.redis.hget(playerKey, 'gameId');
       const changes = await this.redis.get(`${playerKey}:Changes`);
@@ -43,16 +47,7 @@ export class PlayerSubscriber extends RedisSubscriber {
 
       await this.handlePlayerChanges(changes, playerId, server);
     });
-
     setInterval(() => {
-      // 배치 처리
-      this.positionUpdates.forEach((queue, gameId) => {
-        if (queue.length > 0) {
-          const batch = queue.splice(0, queue.length); //O(N)
-          server.to(gameId).emit(SocketEvents.UPDATE_POSITION, batch);
-        }
-      });
-
       // 배치 처리에 관한 메트릭 측정
       this.positionUpdatesMetrics.forEach((metrics) => {
         if (metrics.length > 0) {
@@ -129,13 +124,7 @@ export class PlayerSubscriber extends RedisSubscriber {
     const isAlivePlayer = await this.redis.hget(REDIS_KEY.PLAYER(playerId), 'isAlive');
 
     if (isAlivePlayer === SurvivalStatus.ALIVE) {
-      // 1. Map에 배열을 만들고 set
-      if (!this.positionUpdates.has(gameId)) {
-        this.positionUpdates.set(gameId, []); // 빈 배열로 초기화
-      }
-      this.positionUpdates.get(gameId).push(updateData);
-
-      // server.to(gameId).emit(SocketEvents.UPDATE_POSITION, updateData);
+      this.positionProcessor.pushData(gameId, updateData);
     } else if (isAlivePlayer === SurvivalStatus.DEAD) {
       const players = await this.redis.smembers(REDIS_KEY.ROOM_PLAYERS(gameId));
       const pipeline = this.redis.pipeline();

BE/src/game/service/BatchProcessor.ts

@@ -0,0 +1,77 @@
+/**
+ * @fileoverview Functional batch processor factory
+ */
+import { Namespace } from 'socket.io';
+import { Logger } from '@nestjs/common';
+
+interface BatchData {
+  gameId: string;
+  data: any;
+}
+
+/**
+ * Creates a batch processor instance
+ */
+export function createBatchProcessor(server: Namespace, eventName: string) {
+  const logger = new Logger(`BatchProcessor:${eventName}`);
+  // 이 변수들은 클로저에 의해 보호됨
+  const batchMap = new Map<string, any[]>();
+  let isProcessing = false;
+
+  /**
+   * Pushes data to batch queue
+   */
+  const pushData = (gameId: string, data: any) => {
+    if (!batchMap.has(gameId)) {
+      batchMap.set(gameId, []);
+    }
+    batchMap.get(gameId).push(data);
+  };
+
+  /**
+   * Processes and emits all batched data
+   */
+  const processBatch = () => {
+    if (isProcessing) {
+      return;
+    }
+
+    isProcessing = true;
+    try {
+      batchMap.forEach((queue, gameId) => {
+        if (queue.length > 0) {
+          const batch = queue.splice(0, queue.length);
+          server.to(gameId).emit(eventName, batch);
+          logger.debug(`Processed ${batch.length} items for game ${gameId}`);
+        }
+      });
+    } catch (error) {
+      logger.error(`Error processing batch: ${error.message}`);
+    } finally {
+      isProcessing = false;
+    }
+  };
+
+  /**
+   * Starts automatic batch processing
+   */
+  const startProcessing = (interval: number = 100) => {
+    setInterval(processBatch, interval);
+    logger.verbose(`Started batch processor for ${eventName} with ${interval}ms interval`);
+  };
+
+  /**
+   * Clears all batched data
+   */
+  const clear = () => {
+    batchMap.clear();
+  };
+
+  // 외부에서 사용할 수 있는 public 메서드만 노출
+  return {
+    pushData,
+    processBatch,
+    startProcessing,
+    clear
+  };
+}

BE/src/game/service/game.chat.service.ts

@@ -9,16 +9,18 @@ import { Namespace } from 'socket.io';
 import { TraceClass } from '../../common/interceptor/SocketEventLoggerInterceptor';
 import { SurvivalStatus } from '../../common/constants/game';
 import { MetricService } from '../../metric/metric.service';
+import { createBatchProcessor } from './BatchProcessor';
 
 @TraceClass()
 @Injectable()
 export class GameChatService {
   private readonly logger = new Logger(GameChatService.name);
+  private chatProcessor: ReturnType<typeof createBatchProcessor>;
 
   constructor(
     @InjectRedis() private readonly redis: Redis,
     private readonly gameValidator: GameValidator,
-    private metricService: MetricService,
+    private metricService: MetricService
   ) {}
 
   async chatMessage(chatMessage: ChatMessageDto, clientId: string) {
@@ -49,6 +51,9 @@ export class GameChatService {
   }
 
   async subscribeChatEvent(server: Namespace) {
+    this.chatProcessor = createBatchProcessor(server, SocketEvents.CHAT_MESSAGE);
+    this.chatProcessor.startProcessing(50); // 채팅은 더 빠른 업데이트가 필요할 수 있어서 50ms
+
     const chatSubscriber = this.redis.duplicate();
     chatSubscriber.psubscribe('chat:*');
 
@@ -63,7 +68,7 @@ export class GameChatService {
 
       // 생존한 사람이라면 전체 브로드캐스팅
       if (isAlivePlayer === SurvivalStatus.ALIVE) {
-        server.to(gameId).emit(SocketEvents.CHAT_MESSAGE, chatMessage);
+        this.chatProcessor.pushData(gameId, chatMessage);
       } else {
         // 죽은 사람의 채팅은 죽은 사람끼리만 볼 수 있도록 처리
         const players = await this.redis.smembers(REDIS_KEY.ROOM_PLAYERS(gameId));

BE/src/main.ts

@@ -1,12 +1,10 @@
-import { config } from 'dotenv';
-import { join } from 'path';
 import 'pinpoint-node-agent';
 import { NestFactory } from '@nestjs/core';
 import { AppModule } from './app.module';
 import { Logger } from '@nestjs/common';
 import { GameActivityInterceptor } from './game/interceptor/gameActivity.interceptor';
+
 // env 불러오기
-config({ path: join(__dirname, '..', '.env') }); // ../ 경로의 .env 로드
 
 async function bootstrap() {
   const app = await NestFactory.create(AppModule);

BE/src/quiz-set/entities/quiz-choice.entity.ts

@@ -1,4 +1,4 @@
-import { Column, Entity, JoinColumn, ManyToOne } from 'typeorm';
+import { Column, Entity, Index, JoinColumn, ManyToOne } from 'typeorm';
 import { QuizModel } from './quiz.entity';
 import { BaseModel } from '../../common/entity/base.entity';
 
@@ -11,6 +11,10 @@ export class QuizChoiceModel extends BaseModel {
   isAnswer: boolean;
 
   @Column({ name: 'choice_content', type: 'text' })
+  @Index({
+    fulltext: true,
+    parser: 'ngram'
+  })
   choiceContent: string;
 
   @Column({ name: 'choice_order', type: 'integer' })

BE/src/quiz-set/entities/quiz-set.entity.ts

@@ -26,6 +26,10 @@ const CategoriesEnum = Object.freeze({
 @Entity('quiz_set')
 export class QuizSetModel extends BaseModel {
   @Column()
+  @Index({
+    fulltext: true,
+    parser: 'ngram' // ngram 파서 사용
+  }) // Full Text Search 인덱스 추가
   title: string;
 
   @Column({ name: 'user_id' })

BE/src/quiz-set/entities/quiz.entity.ts

@@ -3,6 +3,7 @@ import {
   CreateDateColumn,
   DeleteDateColumn,
   Entity,
+  Index,
   JoinColumn,
   ManyToOne,
   OneToMany,
@@ -22,6 +23,10 @@ export class QuizModel extends BaseModel {
   quizSetId: number;
 
   @Column('text')
+  @Index({
+    fulltext: true,
+    parser: 'ngram'
+  })
   quiz: string;
 
   @Column({ name: 'limit_time' })

BE/src/quiz-set/quiz-set.controller.ts

@@ -44,13 +44,16 @@ export class QuizSetController {
     @Query('take', new ParseIntOrDefault(10)) take: number,
     @Query('search', new DefaultValuePipe('')) search: string
   ) {
+    const start = Date.now();
     const result = await this.quizService.findAllWithQuizzesAndChoices(
       category,
       cursor,
       take,
       search
     );
-    this.logger.verbose(`퀴즈셋 목록 조회: ${result}`);
+    const end = Date.now();
+    this.logger.verbose(`퀴즈셋 목록 조회: ${result}, ${end - start}ms`);
+    // this.logger.verbose(`퀴즈셋 목록 조회: ${result}`);
     return result;
   }