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

hyo-limilimee · web-flow · commit 07b87ac18815 · 2024-11-28T20:57:27.000+09:00
[BE] Merge to main
diff --git a/backend/console-server/src/log/rank/dto/get-success-rate-rank-response.dto.ts b/backend/console-server/src/log/rank/dto/get-success-rate-rank-response.dto.ts
@@ -1,12 +1,13 @@
 import { ApiProperty } from '@nestjs/swagger';
-import { Expose, Type } from 'class-transformer';
+import { Expose, Transform, Type } from 'class-transformer';
 import { IsNumber, IsString } from 'class-validator';
 
 export class SuccessRateRank {
     @IsString()
     projectName: string;
 
     @Type(() => Number)
+    @Transform(({ value }) => Math.floor(value))
     @IsNumber()
     value: number;
 }
@@ -24,15 +25,15 @@ export class GetSuccessRateRankResponseDto {
         example: [
             {
                 projectName: 'test059',
-                value: 98.23100936524453,
+                value: 98,
             },
             {
                 projectName: 'test007',
-                value: 98.1094527363184,
+                value: 98,
             },
             {
                 projectName: 'test079',
-                value: 98.0083857442348,
+                value: 98,
             },
         ],
     })
diff --git a/backend/console-server/src/log/rank/rank.repository.spec.ts b/backend/console-server/src/log/rank/rank.repository.spec.ts
@@ -7,7 +7,7 @@ import type { HostElapsedTimeMetric } from './metric/host-elapsed-time.metric';
 
 jest.mock('../../clickhouse/query-builder/time-series.query-builder');
 
-describe('RankRepository', () => {
+describe('RankRepository의', () => {
     let repository: RankRepository;
     let clickhouse: Clickhouse;
 
@@ -34,129 +34,129 @@ describe('RankRepository', () => {
         jest.clearAllMocks();
     });
 
-    describe('RankRepository의', () => {
-        describe('findSuccessRateOrderByCount()는', () => {
-            const mockQueryResult = {
-                query: 'SELECT host, is_error FROM http_log GROUP BY host ORDER BY is_error_rate',
-                params: {},
-            };
+    describe('findSuccessRateOrderByCount()는', () => {
+        const mockDate = '2024-11-25';
+        const mockQueryResult = {
+            query: 'SELECT host, is_error FROM http_log GROUP BY host ORDER BY is_error_rate',
+            params: {},
+        };
 
-            const mockResults = [
-                { host: 'test1.com', is_error_rate: 10 },
-                { host: 'test2.com', is_error_rate: 20 },
-            ];
+        const mockResults = [
+            { host: 'test1.com', is_error_rate: 10 },
+            { host: 'test2.com', is_error_rate: 20 },
+        ];
 
-            beforeEach(() => {
-                (TimeSeriesQueryBuilder as jest.Mock).mockImplementation(() => ({
-                    metrics: jest.fn().mockReturnThis(),
-                    from: jest.fn().mockReturnThis(),
-                    groupBy: jest.fn().mockReturnThis(),
-                    orderBy: jest.fn().mockReturnThis(),
-                    build: jest.fn().mockReturnValue(mockQueryResult),
-                }));
-            });
+        beforeEach(() => {
+            (TimeSeriesQueryBuilder as jest.Mock).mockImplementation(() => ({
+                metrics: jest.fn().mockReturnThis(),
+                from: jest.fn().mockReturnThis(),
+                filter: jest.fn().mockReturnThis(),
+                groupBy: jest.fn().mockReturnThis(),
+                orderBy: jest.fn().mockReturnThis(),
+                build: jest.fn().mockReturnValue(mockQueryResult),
+            }));
+        });
 
-            it('TimeSeriesQueryBuilder를 사용하여 쿼리를 생성해야 한다', async () => {
-                mockClickhouse.query.mockResolvedValue(mockResults);
+        it('TimeSeriesQueryBuilder를 사용하여 쿼리를 생성해야 한다', async () => {
+            mockClickhouse.query.mockResolvedValue(mockResults);
 
-                await repository.findSuccessRateOrderByCount();
+            await repository.findSuccessRateOrderByCount(mockDate);
 
-                expect(TimeSeriesQueryBuilder).toHaveBeenCalled();
-            });
+            expect(TimeSeriesQueryBuilder).toHaveBeenCalled();
+        });
 
-            it('생성된 쿼리로 Clickhouse를 호출해야 한다', async () => {
-                mockClickhouse.query.mockResolvedValue(mockResults);
+        it('생성된 쿼리로 Clickhouse를 호출해야 한다', async () => {
+            mockClickhouse.query.mockResolvedValue(mockResults);
 
-                await repository.findSuccessRateOrderByCount();
+            await repository.findSuccessRateOrderByCount(mockDate);
 
-                expect(clickhouse.query).toHaveBeenCalledWith(
-                    mockQueryResult.query,
-                    mockQueryResult.params,
-                );
-            });
+            expect(clickhouse.query).toHaveBeenCalledWith(
+                mockQueryResult.query,
+                mockQueryResult.params,
+            );
+        });
 
-            it('조회 결과는 HostErrorRateMetric 객체 타입을 가져야한다', async () => {
-                mockClickhouse.query.mockResolvedValue(mockResults);
+        it('조회 결과는 HostErrorRateMetric 객체 타입을 가져야한다', async () => {
+            mockClickhouse.query.mockResolvedValue(mockResults);
 
-                const results = await repository.findSuccessRateOrderByCount();
+            const results = await repository.findSuccessRateOrderByCount(mockDate);
 
-                expect(results).toHaveLength(mockResults.length);
-                results.forEach((result, index) => {
-                    expect(typeof result.host).toBe('string');
-                    expect(typeof result.is_error_rate).toBe('number');
-                    expect(result.host).toBe(mockResults[index].host);
-                    expect(result.is_error_rate).toBe(mockResults[index].is_error_rate);
-                });
+            expect(results).toHaveLength(mockResults.length);
+            results.forEach((result, index) => {
+                expect(typeof result.host).toBe('string');
+                expect(typeof result.is_error_rate).toBe('number');
+                expect(result.host).toBe(mockResults[index].host);
+                expect(result.is_error_rate).toBe(mockResults[index].is_error_rate);
             });
+        });
 
-            it('Clickhouse 쿼리 실패 시 에러를 전파해야 한다', async () => {
-                const error = new Error('Clickhouse query failed');
-                mockClickhouse.query.mockRejectedValue(error);
+        it('Clickhouse 쿼리 실패 시 에러를 전파해야 한다', async () => {
+            const error = new Error('Clickhouse query failed');
+            mockClickhouse.query.mockRejectedValue(error);
 
-                await expect(repository.findSuccessRateOrderByCount()).rejects.toThrow(error);
-            });
+            await expect(repository.findSuccessRateOrderByCount(mockDate)).rejects.toThrow(error);
         });
+    });
 
-        describe('findCountOrderByCount()는', () => {
-            const mockQueryResult = {
-                query: 'SELECT host, count() as count FROM http_log GROUP BY host ORDER BY count',
-                params: {},
-            };
+    describe('findCountOrderByCount()는', () => {
+        const mockQueryResult = {
+            query: 'SELECT host, count() as count FROM http_log GROUP BY host ORDER BY count',
+            params: {},
+        };
 
-            const mockResults = [
-                { host: 'test1.com', count: 9999 },
-                { host: 'test2.com', count: 9898 },
-            ];
+        const mockResults = [
+            { host: 'test1.com', count: 9999 },
+            { host: 'test2.com', count: 9898 },
+        ];
 
-            beforeEach(() => {
-                (TimeSeriesQueryBuilder as jest.Mock).mockImplementation(() => ({
-                    metrics: jest.fn().mockReturnThis(),
-                    from: jest.fn().mockReturnThis(),
-                    groupBy: jest.fn().mockReturnThis(),
-                    orderBy: jest.fn().mockReturnThis(),
-                    build: jest.fn().mockReturnValue(mockQueryResult),
-                }));
-            });
+        beforeEach(() => {
+            (TimeSeriesQueryBuilder as jest.Mock).mockImplementation(() => ({
+                metrics: jest.fn().mockReturnThis(),
+                from: jest.fn().mockReturnThis(),
+                groupBy: jest.fn().mockReturnThis(),
+                orderBy: jest.fn().mockReturnThis(),
+                build: jest.fn().mockReturnValue(mockQueryResult),
+            }));
+        });
 
-            it('TimeSeriesQueryBuilder를 사용하여 쿼리를 생성해야 한다', async () => {
-                mockClickhouse.query.mockResolvedValue(mockResults);
+        it('TimeSeriesQueryBuilder를 사용하여 쿼리를 생성해야 한다', async () => {
+            mockClickhouse.query.mockResolvedValue(mockResults);
 
-                await repository.findCountOrderByCount();
+            await repository.findCountOrderByCount();
 
-                expect(TimeSeriesQueryBuilder).toHaveBeenCalled();
-            });
+            expect(TimeSeriesQueryBuilder).toHaveBeenCalled();
+        });
 
-            it('생성된 쿼리로 Clickhouse를 호출해야 한다', async () => {
-                mockClickhouse.query.mockResolvedValue(mockResults);
+        it('생성된 쿼리로 Clickhouse를 호출해야 한다', async () => {
+            mockClickhouse.query.mockResolvedValue(mockResults);
 
-                await repository.findCountOrderByCount();
+            await repository.findCountOrderByCount();
 
-                expect(clickhouse.query).toHaveBeenCalledWith(
-                    mockQueryResult.query,
-                    mockQueryResult.params,
-                );
-            });
+            expect(clickhouse.query).toHaveBeenCalledWith(
+                mockQueryResult.query,
+                mockQueryResult.params,
+            );
+        });
 
-            it('조회 결과는 HostCountMetric 객체 타입을 가져야한다', async () => {
-                mockClickhouse.query.mockResolvedValue(mockResults);
+        it('조회 결과는 HostCountMetric 객체 타입을 가져야한다', async () => {
+            mockClickhouse.query.mockResolvedValue(mockResults);
 
-                const results = await repository.findCountOrderByCount();
+            const results = await repository.findCountOrderByCount();
 
-                expect(results).toHaveLength(mockResults.length);
-                results.forEach((result, index) => {
-                    expect(typeof result.host).toBe('string');
-                    expect(typeof result.count).toBe('number');
-                    expect(result.host).toBe(mockResults[index].host);
-                    expect(result.count).toBe(mockResults[index].count);
-                });
+            expect(results).toHaveLength(mockResults.length);
+            results.forEach((result, index) => {
+                expect(typeof result.host).toBe('string');
+                expect(typeof result.count).toBe('number');
+                expect(result.host).toBe(mockResults[index].host);
+                expect(result.count).toBe(mockResults[index].count);
             });
+        });
 
-            it('Clickhouse 쿼리 실패 시 에러를 전파해야 한다', async () => {
-                const error = new Error('Clickhouse query failed');
-                mockClickhouse.query.mockRejectedValue(error);
+        it('Clickhouse 쿼리 실패 시 에러를 전파해야 한다', async () => {
+            const error = new Error('Clickhouse query failed');
+            mockClickhouse.query.mockRejectedValue(error);
 
-                await expect(repository.findCountOrderByCount()).rejects.toThrow(error);
-            });
+            await expect(repository.findCountOrderByCount()).rejects.toThrow(error);
         });
     });
 
diff --git a/backend/console-server/src/log/rank/rank.repository.ts b/backend/console-server/src/log/rank/rank.repository.ts
@@ -10,11 +10,16 @@ import { HostCountMetric } from './metric/host-count.metric';
 export class RankRepository {
     constructor(private readonly clickhouse: Clickhouse) {}
 
-    async findSuccessRateOrderByCount() {
+    async findSuccessRateOrderByCount(date: string) {
         const { query, params } = new TimeSeriesQueryBuilder()
-            .metrics([{ name: 'host' }, { name: 'is_error', aggregation: 'rate' }])
+            .metrics([
+                { name: 'host' },
+                { name: 'is_error', aggregation: 'rate' },
+                { name: 'toDate(timestamp) as timestamp' },
+            ])
             .from('http_log')
-            .groupBy(['host'])
+            .filter({ timestamp: date })
+            .groupBy(['host', 'timestamp'])
             .orderBy(['is_error_rate'])
             .build();
 
diff --git a/backend/console-server/src/log/rank/rank.service.ts b/backend/console-server/src/log/rank/rank.service.ts
@@ -28,7 +28,9 @@ export class RankService {
     ) {}
 
     async getSuccessRateRank(_getSuccessRateRankDto: GetSuccessRateRankDto) {
-        const results = await this.rankRepository.findSuccessRateOrderByCount();
+        const results = await this.rankRepository.findSuccessRateOrderByCount(
+            this.getYesterdayDateString(),
+        );
         const hosts = results.map((result) => result.host);
 
         const projectMap = await this.hostsToProjectMap(hosts);
diff --git a/backend/console-server/src/log/traffic/dto/get-traffic-top5-response.dto.ts b/backend/console-server/src/log/traffic/dto/get-traffic-top5-response.dto.ts
@@ -1,18 +1,29 @@
 import { ApiProperty } from '@nestjs/swagger';
 import { Expose } from 'class-transformer';
-import { TrafficRankMetric } from '../metric/traffic-rank.metric';
+import { IsNotEmpty, IsNumber, IsString, ValidateNested } from 'class-validator';
+
+export class TrafficRankData {
+    @IsNotEmpty()
+    @IsString()
+    projectName: string;
+
+    @IsNotEmpty()
+    @IsNumber()
+    count: number;
+}
 
 export class GetTrafficTop5ResponseDto {
     @ApiProperty({
         example: [
-            { host: 'watchducks01', count: 100 },
-            { host: 'watchducks02', count: 99 },
-            { host: 'watchducks03', count: 98 },
-            { host: 'watchducks04', count: 97 },
-            { host: 'watchducks05', count: 96 },
+            { projectName: 'watchducks01', count: 100 },
+            { projectName: 'watchducks02', count: 99 },
+            { projectName: 'watchducks03', count: 98 },
+            { projectName: 'watchducks04', count: 97 },
+            { projectName: 'watchducks05', count: 96 },
         ],
         description: '트래픽 수가 가장 많은 Top5 호스트, 트래픽 수',
     })
     @Expose()
-    rank: TrafficRankMetric[];
+    @ValidateNested()
+    rank: TrafficRankData[];
 }
diff --git a/backend/console-server/src/log/traffic/metric/traffic-rank-top5.metric.ts b/backend/console-server/src/log/traffic/metric/traffic-rank-top5.metric.ts
diff --git a/backend/console-server/src/log/traffic/traffic.repository.ts b/backend/console-server/src/log/traffic/traffic.repository.ts
@@ -3,7 +3,6 @@ import { plainToInstance } from 'class-transformer';
 import { Clickhouse } from '../../clickhouse/clickhouse';
 import { TimeSeriesQueryBuilder } from '../../clickhouse/query-builder/time-series.query-builder';
 import { TrafficRankMetric } from './metric/traffic-rank.metric';
-import { TrafficRankTop5Metric } from './metric/traffic-rank-top5.metric';
 import { TrafficCountMetric } from './metric/traffic-count.metric';
 import { Injectable } from '@nestjs/common';
 import type { TimeUnit } from './traffic.constant';
@@ -29,12 +28,7 @@ export class TrafficRepository {
             .limit(5)
             .build();
 
-        const results = await this.clickhouse.query<TrafficRankMetric>(query, params);
-
-        return plainToInstance(
-            TrafficRankTop5Metric,
-            results.map((result) => plainToInstance(TrafficRankMetric, result)),
-        );
+        return await this.clickhouse.query<TrafficRankMetric>(query, params);
     }
 
     async findTrafficByGeneration() {
diff --git a/backend/console-server/src/log/traffic/traffic.service.spec.ts b/backend/console-server/src/log/traffic/traffic.service.spec.ts
diff --git a/backend/console-server/src/log/traffic/traffic.service.ts b/backend/console-server/src/log/traffic/traffic.service.ts
