Merge pull request #188 from boostcampwm-2024/dev-back

merge main

Author: hyo-limilimee

backend/console-server/src/log/elapsed-time/elapsed-time.controller.ts

@@ -48,7 +48,8 @@ export class ElapsedTimeController {
     @HttpCode(HttpStatus.OK)
     @ApiOperation({
         summary: '개별 프로젝트의 경로별 응답 속도 순위',
-        description: '개별 프로젝트의 경로별 응답 속도 중 가장 빠른/느린 3개를 반환합니다.',
+        description:
+            '개별 프로젝트의 경로별 응답 속도 중 가장 빠른/느린 3개를 반환합니다. 빠른 응답은 유효한(상태 코드 200번대)만을 포함합니다.',
     })
     @ApiResponse({
         status: HttpStatus.OK,

backend/console-server/src/log/elapsed-time/elapsed-time.repository.ts

@@ -33,12 +33,16 @@ export class ElapsedTimeRepository {
         return results.map((result) => plainToInstance(HostAvgElapsedTimeMetric, result));
     }
 
-    async getFastestPathsByDomain(domain: string) {
+    async findFastestPathsByDomain(domain: string) {
         const { query, params } = new TimeSeriesQueryBuilder()
-            .metrics([{ name: 'elapsed_time', aggregation: 'avg' }, { name: 'path' }])
+            .metrics([
+                { name: 'toUInt32(avg(elapsed_time)) as avg_elapsed_time' },
+                { name: 'path' },
+                { name: 'if(status_code >= 200 AND status_code < 300, 1, 0) AS is_valid' },
+            ])
             .from('http_log')
-            .filter({ host: domain })
-            .groupBy(['path'])
+            .filter({ host: domain, is_valid: 1 })
+            .groupBy(['path', 'is_valid'])
             .orderBy(['avg_elapsed_time'], false)
             .limit(3)
             .build();
@@ -50,7 +54,10 @@ export class ElapsedTimeRepository {
 
     async findSlowestPathsByDomain(domain: string) {
         const { query, params } = new TimeSeriesQueryBuilder()
-            .metrics([{ name: 'elapsed_time', aggregation: 'avg' }, { name: 'path' }])
+            .metrics([
+                { name: 'toUInt32(avg(elapsed_time)) as avg_elapsed_time' },
+                { name: 'path' },
+            ])
             .from('http_log')
             .filter({ host: domain })
             .groupBy(['path'])

backend/console-server/src/log/elapsed-time/elapsed-time.service.ts

@@ -56,7 +56,7 @@ export class ElapsedTimeService {
 
         if (!project) throw new NotFoundException(`Project with name ${projectName} not found`);
 
-        const fastestPaths = await this.elapsedTimeRepository.getFastestPathsByDomain(
+        const fastestPaths = await this.elapsedTimeRepository.findFastestPathsByDomain(
             project.domain,
         );
         const slowestPaths = await this.elapsedTimeRepository.findSlowestPathsByDomain(

backend/console-server/src/log/rank/dto/get-dau-rank-response.dto.ts

@@ -0,0 +1,41 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsNumber, IsString } from 'class-validator';
+import { Expose, Type } from 'class-transformer';
+
+export class DAURank {
+    @IsString()
+    projectName: string;
+
+    @Type(() => Number)
+    @IsNumber()
+    dau: number;
+}
+
+export class GetDAURankResponseDto {
+    @ApiProperty({
+        description: '총 갯수',
+        example: 30,
+    })
+    @IsNumber()
+    total: number;
+
+    @ApiProperty({
+        description: 'dau 순위',
+        example: [
+            {
+                projectName: 'test059',
+                dau: 12345,
+            },
+            {
+                projectName: 'test007',
+                dau: 234234,
+            },
+            {
+                projectName: 'test079',
+                dau: 21212,
+            },
+        ],
+    })
+    @Expose()
+    rank: DAURank[];
+}

backend/console-server/src/log/rank/dto/get-dau-rank.dto.ts

@@ -0,0 +1,10 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsNotEmpty } from 'class-validator';
+import { Type } from 'class-transformer';
+
+export class GetDAURankDto {
+    @ApiProperty({ description: '기수', example: 9 })
+    @Type(() => Number)
+    @IsNotEmpty()
+    generation: number;
+}

backend/console-server/src/log/rank/dto/get-elapsed-time-rank-response.dto.ts

@@ -0,0 +1,42 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { Expose } from 'class-transformer';
+import { IsNumber, IsString } from 'class-validator';
+
+export class ElapsedTimeRank {
+    @IsString()
+    @Expose()
+    projectName: string;
+
+    @IsNumber()
+    @Expose()
+    elapsedTime: number;
+}
+
+export class GetElapsedTimeRankResponseDto {
+    @ApiProperty({
+        description: '총 갯수',
+        example: 30,
+    })
+    @IsNumber()
+    total: number;
+
+    @ApiProperty({
+        description: '응답 소요 시간 짧은 순으로 정렬된 프로젝트명과 시간(ms)',
+        example: [
+            {
+                projectName: 'test059',
+                elapsedTime: 100,
+            },
+            {
+                projectName: 'test007',
+                elapsedTime: 110,
+            },
+            {
+                projectName: 'test079',
+                elapsedTime: 120,
+            },
+        ],
+    })
+    @Expose()
+    rank: ElapsedTimeRank[];
+}

backend/console-server/src/log/rank/dto/get-elapsed-time-rank.dto.ts

@@ -0,0 +1,10 @@
+import { Type } from 'class-transformer';
+import { IsNumber } from 'class-validator';
+import { ApiProperty } from '@nestjs/swagger';
+
+export class GetElapsedTimeRankDto {
+    @ApiProperty({ description: '기수', example: 9 })
+    @Type(() => Number)
+    @IsNumber()
+    generation: number;
+}

backend/console-server/src/log/rank/metric/host-dau.metric.ts

@@ -0,0 +1,13 @@
+import { IsNumber, IsString } from 'class-validator';
+import { Expose, Type } from 'class-transformer';
+
+export class HostDauMetric {
+    @IsString()
+    @Expose()
+    host: string;
+
+    @Type(() => Number)
+    @IsNumber()
+    @Expose()
+    dau: number;
+}

backend/console-server/src/log/rank/metric/host-elapsed-time.metric.ts

@@ -0,0 +1,4 @@
+export type HostElapsedTimeMetric = {
+    host: string;
+    avg_elapsed_time: number;
+};

backend/console-server/src/log/rank/rank.controller.spec.ts

@@ -3,16 +3,20 @@ import { Test } from '@nestjs/testing';
 import { RankController } from './rank.controller';
 import { RankService } from './rank.service';
 import type { GetSuccessRateRankDto } from './dto/get-success-rate-rank.dto';
+import type { GetDAURankDto } from './dto/get-dau-rank.dto';
 import type { GetSuccessRateRankResponseDto } from './dto/get-success-rate-rank-response.dto';
 import type { GetTrafficRankDto } from './dto/get-traffic-rank.dto';
 import type { GetTrafficRankResponseDto } from './dto/get-traffic-rank-response.dto';
+import type { GetElapsedTimeRankDto } from './dto/get-elapsed-time-rank.dto';
 
 describe('RankController', () => {
     let controller: RankController;
     let service: RankService;
 
     const mockRankService = {
         getSuccessRateRank: jest.fn(),
+        getElapsedTimeRank: jest.fn(),
+        getDAURank: jest.fn(),
         getTrafficRank: jest.fn(),
     };
 
@@ -83,6 +87,41 @@ describe('RankController', () => {
             });
         });
 
+        describe('getDAURank()는', () => {
+            const mockDto: GetDAURankDto = {
+                generation: 9,
+            };
+
+            const mockResponse = {
+                total: 2,
+                rank: [
+                    {
+                        projectName: 'Project A',
+                        dau: 1000,
+                    },
+                    {
+                        projectName: 'Project B',
+                        dau: 500,
+                    },
+                ],
+                date: '2024-01-01',
+            };
+
+            it('정의되어 있어야 한다', () => {
+                expect(controller.getDAURank).toBeDefined();
+            });
+
+            it('DAU 랭킹 데이터를 반환해야 한다', async () => {
+                mockRankService.getDAURank.mockResolvedValue(mockResponse);
+
+                const result = await controller.getDAURank(mockDto);
+
+                expect(result).toBe(mockResponse);
+                expect(service.getDAURank).toHaveBeenCalledWith(mockDto);
+                expect(service.getDAURank).toHaveBeenCalledTimes(1);
+            });
+        });
+
         describe('getTrafficRank()는', () => {
             let mockDto: GetTrafficRankDto;
             let mockResponse: GetTrafficRankResponseDto;
@@ -123,11 +162,59 @@ describe('RankController', () => {
 
             it('서비스 계층에서 오류가 발생하면 해당 오류를 그대로 던져야 한다', async () => {
                 const error = new Error('Service error');
+
+                mockRankService.getDAURank.mockRejectedValue(error);
+
+                await expect(controller.getDAURank(mockDto)).rejects.toThrow(error);
+                expect(service.getDAURank).toHaveBeenCalledWith(mockDto);
+
                 mockRankService.getTrafficRank.mockRejectedValue(error);
 
                 await expect(controller.getTrafficRank(mockDto)).rejects.toThrow(error);
                 expect(service.getTrafficRank).toHaveBeenCalledWith(mockDto);
             });
         });
+
+        describe('getElapsedTimeRank()는', () => {
+            const mockDto: GetElapsedTimeRankDto = {
+                generation: 1,
+            };
+
+            const mockResponse = {
+                total: 2,
+                rank: [
+                    {
+                        projectName: 'Project A',
+                        elapsedTime: 120,
+                    },
+                    {
+                        projectName: 'Project B',
+                        elapsedTime: 130,
+                    },
+                ],
+            };
+
+            it('정의되어 있어야 한다', () => {
+                expect(controller.getElapsedTimeRank).toBeDefined();
+            });
+
+            it('응답 소요 시간 랭킹 데이터를 반환해야 한다', async () => {
+                mockRankService.getElapsedTimeRank.mockResolvedValue(mockResponse);
+
+                const result = await controller.getElapsedTimeRank(mockDto);
+
+                expect(result).toBe(mockResponse);
+                expect(service.getElapsedTimeRank).toHaveBeenCalledWith(mockDto);
+                expect(service.getElapsedTimeRank).toHaveBeenCalledTimes(1);
+            });
+
+            it('서비스 계층에서 오류가 발생하면 해당 오류를 그대로 던져야 한다', async () => {
+                const error = new Error('Service error');
+                mockRankService.getElapsedTimeRank.mockRejectedValue(error);
+
+                await expect(controller.getElapsedTimeRank(mockDto)).rejects.toThrow(error);
+                expect(service.getElapsedTimeRank).toHaveBeenCalledWith(mockDto);
+            });
+        });
     });
 });