Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
@@ -1,11 +1,17 @@
package devkor.com.teamcback.domain.apistatistics.controller;

import devkor.com.teamcback.domain.apistatistics.dto.response.ApiEndpointResponse;
import devkor.com.teamcback.domain.apistatistics.dto.response.ApiEndpointTrendResponse;
import devkor.com.teamcback.domain.apistatistics.dto.response.ApiStatisticsResponse;
import devkor.com.teamcback.domain.apistatistics.service.ApiStatisticsService;
import devkor.com.teamcback.global.exception.exception.GlobalException;
import devkor.com.teamcback.global.response.CommonResponse;
import devkor.com.teamcback.global.response.ResultCode;
import java.util.List;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
Expand All @@ -19,4 +25,19 @@ public class ApiStatisticsController {
public CommonResponse<ApiStatisticsResponse> getStatistics() {
return CommonResponse.success(apiStatisticsService.getStatistics());
}

@GetMapping("/endpoints")
public CommonResponse<?> getEndpoints(
@RequestParam(required = false) String endpoint,
@RequestParam(required = false) String method) {
if (endpoint == null && method == null) {
List<ApiEndpointResponse> endpoints = apiStatisticsService.getEndpoints();
return CommonResponse.success(endpoints);
}
if (endpoint == null || method == null) {
throw new GlobalException(ResultCode.INVALID_INPUT);
}
ApiEndpointTrendResponse trend = apiStatisticsService.getEndpointTrend(endpoint, method);
return CommonResponse.success(trend);
}
}
Original file line number Diff line number Diff line change
@@ -0,0 +1,11 @@
package devkor.com.teamcback.domain.apistatistics.dto.response;

import lombok.AllArgsConstructor;
import lombok.Getter;

@Getter
@AllArgsConstructor
public class ApiEndpointResponse {
private String endpoint;
private String method;
}
Original file line number Diff line number Diff line change
@@ -0,0 +1,17 @@
package devkor.com.teamcback.domain.apistatistics.dto.response;

import java.time.LocalDate;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.Getter;

@Getter
@AllArgsConstructor
public class ApiEndpointTrendResponse {
private String endpoint;
private String method;
private LocalDate collectionStartDate;
private long last30DaysCallCount;
private List<ApiStatisticsResponse.DailyCountResponse> dailyCounts;
private List<ApiStatisticsResponse.MonthlyCountResponse> monthlyCounts;
}
Original file line number Diff line number Diff line change
Expand Up @@ -102,6 +102,86 @@ SELECT MIN(s.statDate)
""")
LocalDate findCollectionStartDate(@Param("environment") String environment);

@Query("""
SELECT DISTINCT s.endpoint AS endpoint, s.method AS method
FROM ApiDailyStatistic s
WHERE s.environment = :environment
ORDER BY s.endpoint, s.method
""")
List<EndpointMethod> findEndpointMethods(@Param("environment") String environment);

@Query("""
SELECT COALESCE(SUM(s.callCount), 0)
FROM ApiDailyStatistic s
WHERE s.statDate BETWEEN :startDate AND :endDate
AND s.environment = :environment
AND s.endpoint = :endpoint
AND s.method = :method
""")
Long sumBetweenByEndpointAndMethod(
@Param("startDate") LocalDate startDate,
@Param("endDate") LocalDate endDate,
@Param("environment") String environment,
@Param("endpoint") String endpoint,
@Param("method") String method
);

@Query("""
SELECT s.statDate AS statDate, SUM(s.callCount) AS callCount
FROM ApiDailyStatistic s
WHERE s.statDate BETWEEN :startDate AND :endDate
AND s.environment = :environment
AND s.endpoint = :endpoint
AND s.method = :method
GROUP BY s.statDate
ORDER BY s.statDate
""")
List<DailyCount> findDailyCountsByEndpointAndMethod(
@Param("startDate") LocalDate startDate,
@Param("endDate") LocalDate endDate,
@Param("environment") String environment,
@Param("endpoint") String endpoint,
@Param("method") String method
);

@Query(value = """
SELECT DATE_FORMAT(stat_date, '%Y-%m') AS period,
SUM(call_count) AS callCount
FROM api_daily_statistics
WHERE stat_date BETWEEN :startDate AND :endDate
AND environment = :environment
AND endpoint = :endpoint
AND method = :method
GROUP BY DATE_FORMAT(stat_date, '%Y-%m')
ORDER BY period
""", nativeQuery = true)
List<MonthlyCount> findMonthlyCountsByEndpointAndMethod(
@Param("startDate") LocalDate startDate,
@Param("endDate") LocalDate endDate,
@Param("environment") String environment,
@Param("endpoint") String endpoint,
@Param("method") String method
);

@Query("""
SELECT MIN(s.statDate)
FROM ApiDailyStatistic s
WHERE s.environment = :environment
AND s.endpoint = :endpoint
AND s.method = :method
""")
LocalDate findCollectionStartDateByEndpointAndMethod(
@Param("environment") String environment,
@Param("endpoint") String endpoint,
@Param("method") String method
);

interface EndpointMethod {
String getEndpoint();

String getMethod();
}

interface DailyCount {
LocalDate getStatDate();

Expand Down
Original file line number Diff line number Diff line change
@@ -1,16 +1,21 @@
package devkor.com.teamcback.domain.apistatistics.service;

import devkor.com.teamcback.domain.apistatistics.dto.response.ApiEndpointResponse;
import devkor.com.teamcback.domain.apistatistics.dto.response.ApiEndpointTrendResponse;
import devkor.com.teamcback.domain.apistatistics.dto.response.ApiStatisticsResponse;
import devkor.com.teamcback.domain.apistatistics.dto.response.ApiStatisticsResponse.DailyCountResponse;
import devkor.com.teamcback.domain.apistatistics.dto.response.ApiStatisticsResponse.EndpointCountResponse;
import devkor.com.teamcback.domain.apistatistics.dto.response.ApiStatisticsResponse.MonthlyCountResponse;
import devkor.com.teamcback.domain.apistatistics.repository.ApiDailyStatisticRepository;
import devkor.com.teamcback.global.exception.exception.GlobalException;
import devkor.com.teamcback.global.response.ResultCode;
import java.time.LocalDate;
import java.time.YearMonth;
import java.time.ZoneId;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Locale;
import java.util.stream.Collectors;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Value;
Expand Down Expand Up @@ -62,6 +67,43 @@ public ApiStatisticsResponse getStatistics() {
);
}

@Transactional(readOnly = true)
public List<ApiEndpointResponse> getEndpoints() {
return repository.findEndpointMethods(environment)
.stream()
.map(item -> new ApiEndpointResponse(item.getEndpoint(), item.getMethod()))
.toList();
}

@Transactional(readOnly = true)
public ApiEndpointTrendResponse getEndpointTrend(String endpoint, String method) {
String normalizedEndpoint = validateEndpoint(endpoint);
String normalizedMethod = validateMethod(method);

boolean registered = repository.findEndpointMethods(environment)
.stream()
.anyMatch(item -> item.getEndpoint().equals(normalizedEndpoint)
&& item.getMethod().equals(normalizedMethod));
if (!registered) {
throw new GlobalException(ResultCode.UNSUPPORTED_REQUEST);
}

LocalDate today = LocalDate.now(SEOUL_ZONE);
LocalDate last30DaysStart = today.minusDays(29);
LocalDate sixMonthsStart = today.withDayOfMonth(1).minusMonths(5);

return new ApiEndpointTrendResponse(
normalizedEndpoint,
normalizedMethod,
repository.findCollectionStartDateByEndpointAndMethod(
environment, normalizedEndpoint, normalizedMethod),
valueOrZero(repository.sumBetweenByEndpointAndMethod(
last30DaysStart, today, environment, normalizedEndpoint, normalizedMethod)),
getDailyCounts(last30DaysStart, today, normalizedEndpoint, normalizedMethod),
getMonthlyCounts(sixMonthsStart, today, normalizedEndpoint, normalizedMethod)
);
}

private List<DailyCountResponse> getDailyCounts(LocalDate startDate, LocalDate endDate) {
Map<LocalDate, Long> counts = repository.findDailyCounts(startDate, endDate, environment)
.stream()
Expand Down Expand Up @@ -93,6 +135,58 @@ private List<MonthlyCountResponse> getMonthlyCounts(LocalDate startDate, LocalDa
.toList();
}

private List<DailyCountResponse> getDailyCounts(
LocalDate startDate, LocalDate endDate, String endpoint, String method) {
Map<LocalDate, Long> counts = repository.findDailyCountsByEndpointAndMethod(
startDate, endDate, environment, endpoint, method)
.stream()
.collect(Collectors.toMap(
ApiDailyStatisticRepository.DailyCount::getStatDate,
item -> valueOrZero(item.getCallCount())
));

return startDate.datesUntil(endDate.plusDays(1))
.map(date -> new DailyCountResponse(date, counts.getOrDefault(date, 0L)))
.toList();
}

private List<MonthlyCountResponse> getMonthlyCounts(
LocalDate startDate, LocalDate endDate, String endpoint, String method) {
Map<String, Long> counts = new HashMap<>();
repository.findMonthlyCountsByEndpointAndMethod(
startDate, endDate, environment, endpoint, method)
.forEach(item -> counts.put(item.getPeriod(), valueOrZero(item.getCallCount())));

YearMonth startMonth = YearMonth.from(startDate);
YearMonth endMonth = YearMonth.from(endDate);
return startMonth
.atDay(1)
.datesUntil(endMonth.atEndOfMonth().plusDays(1))
.filter(date -> date.getDayOfMonth() == 1)
.map(date -> {
String month = YearMonth.from(date).toString();
return new MonthlyCountResponse(month, counts.getOrDefault(month, 0L));
})
.toList();
}

private String validateEndpoint(String endpoint) {
if (endpoint == null || endpoint.isBlank()
|| endpoint.length() > 255 || !endpoint.startsWith("/")
|| endpoint.contains("?")) {
throw new GlobalException(ResultCode.INVALID_INPUT);
}
return endpoint;
}

private String validateMethod(String method) {
if (method == null || method.isBlank() || method.length() > 10
|| !method.chars().allMatch(Character::isLetter)) {
throw new GlobalException(ResultCode.INVALID_INPUT);
}
return method.toUpperCase(Locale.ROOT);
}

private long valueOrZero(Long value) {
return value == null ? 0L : value;
}
Expand Down
Original file line number Diff line number Diff line change
@@ -1,10 +1,12 @@
package devkor.com.teamcback.domain.apistatistics.service;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.when;

import devkor.com.teamcback.domain.apistatistics.repository.ApiDailyStatisticRepository.EndpointMethod;
import devkor.com.teamcback.domain.apistatistics.repository.ApiDailyStatisticRepository;
import devkor.com.teamcback.domain.apistatistics.repository.ApiDailyStatisticRepository.DailyCount;
import devkor.com.teamcback.domain.apistatistics.repository.ApiDailyStatisticRepository.EndpointCount;
Expand Down Expand Up @@ -55,6 +57,56 @@ void returnsZeroFilledDailyAndMonthlyRanges() {
});
}

@Test
void returnsAllDistinctEndpointsForCurrentEnvironment() {
when(repository.findEndpointMethods("test")).thenReturn(List.of(
endpointMethod("/api/search", "GET"),
endpointMethod("/api/search", "POST")
));

var response = service.getEndpoints();

assertThat(response).extracting("endpoint", "method")
.containsExactly(
org.assertj.core.groups.Tuple.tuple("/api/search", "GET"),
org.assertj.core.groups.Tuple.tuple("/api/search", "POST"));
}

@Test
void returnsEndpointTrendWithZeroFilledDaysAndMonths() {
LocalDate today = LocalDate.now(java.time.ZoneId.of("Asia/Seoul"));
when(repository.findEndpointMethods("test"))
.thenReturn(List.of(endpointMethod("/api/search", "GET")));
when(repository.findCollectionStartDateByEndpointAndMethod(
"test", "/api/search", "GET")).thenReturn(today.minusDays(40));
when(repository.sumBetweenByEndpointAndMethod(
any(LocalDate.class), any(LocalDate.class), anyString(), anyString(), anyString()))
.thenReturn(12L);
when(repository.findDailyCountsByEndpointAndMethod(
any(LocalDate.class), any(LocalDate.class), anyString(), anyString(), anyString()))
.thenReturn(List.of(dailyCount(today.minusDays(1), 4L)));
when(repository.findMonthlyCountsByEndpointAndMethod(
any(LocalDate.class), any(LocalDate.class), anyString(), anyString(), anyString()))
.thenReturn(List.of(monthlyCount(java.time.YearMonth.from(today).toString(), 8L)));

var response = service.getEndpointTrend("/api/search", "get");

assertThat(response.getMethod()).isEqualTo("GET");
assertThat(response.getLast30DaysCallCount()).isEqualTo(12L);
assertThat(response.getDailyCounts()).hasSize(30);
assertThat(response.getDailyCounts().get(28).getCallCount()).isEqualTo(4L);
assertThat(response.getMonthlyCounts()).hasSize(6);
assertThat(response.getCollectionStartDate()).isEqualTo(today.minusDays(40));
}

@Test
void rejectsUnregisteredEndpoint() {
when(repository.findEndpointMethods("test")).thenReturn(List.of());

assertThatThrownBy(() -> service.getEndpointTrend("/api/unknown", "GET"))
.isInstanceOf(RuntimeException.class);
}

private DailyCount dailyCount(LocalDate date, Long count) {
return new DailyCount() {
@Override
Expand Down Expand Up @@ -101,4 +153,18 @@ public Long getCallCount() {
}
};
}

private EndpointMethod endpointMethod(String endpoint, String method) {
return new EndpointMethod() {
@Override
public String getEndpoint() {
return endpoint;
}

@Override
public String getMethod() {
return method;
}
};
}
}
Loading