From 973442aa4a08f3b9ecccc668b90c977e8a6e16a4 Mon Sep 17 00:00:00 2001 From: Jokebear777 Date: Tue, 17 Nov 2026 22:34:16 +0900 Subject: [PATCH] feat: add API request statistics dashboard backend --- .gitignore | 2 + docs/sql/2026-11-17-api-daily-statistics.sql | 11 ++ .../controller/ApiStatisticsController.java | 22 ++++ .../dto/response/ApiStatisticsResponse.java | 42 ++++++ .../entity/ApiDailyStatistic.java | 45 +++++++ .../ApiDailyStatisticRepository.java | 124 ++++++++++++++++++ .../service/ApiStatisticsService.java | 99 ++++++++++++++ .../global/logging/LoggingFilter.java | 39 ++++++ .../global/security/SecurityConfig.java | 4 +- .../service/ApiStatisticsServiceTest.java | 104 +++++++++++++++ .../global/logging/LoggingFilterTest.java | 80 +++++++++++ 11 files changed, 571 insertions(+), 1 deletion(-) create mode 100644 docs/sql/2026-11-17-api-daily-statistics.sql create mode 100644 src/main/java/devkor/com/teamcback/domain/apistatistics/controller/ApiStatisticsController.java create mode 100644 src/main/java/devkor/com/teamcback/domain/apistatistics/dto/response/ApiStatisticsResponse.java create mode 100644 src/main/java/devkor/com/teamcback/domain/apistatistics/entity/ApiDailyStatistic.java create mode 100644 src/main/java/devkor/com/teamcback/domain/apistatistics/repository/ApiDailyStatisticRepository.java create mode 100644 src/main/java/devkor/com/teamcback/domain/apistatistics/service/ApiStatisticsService.java create mode 100644 src/test/java/devkor/com/teamcback/domain/apistatistics/service/ApiStatisticsServiceTest.java create mode 100644 src/test/java/devkor/com/teamcback/global/logging/LoggingFilterTest.java diff --git a/.gitignore b/.gitignore index 53ed9689..c0dda87c 100644 --- a/.gitignore +++ b/.gitignore @@ -51,3 +51,5 @@ out/ /docker-compose.local.yml # Local migration tooling scripts/__pycache__/ +# Local AI agent files +/.agents/ diff --git a/docs/sql/2026-11-17-api-daily-statistics.sql b/docs/sql/2026-11-17-api-daily-statistics.sql new file mode 100644 index 00000000..e3c9b1cd --- /dev/null +++ b/docs/sql/2026-11-17-api-daily-statistics.sql @@ -0,0 +1,11 @@ +CREATE TABLE api_daily_statistics ( + id BIGINT NOT NULL AUTO_INCREMENT, + stat_date DATE NOT NULL, + environment VARCHAR(20) NOT NULL, + endpoint VARCHAR(255) NOT NULL, + method VARCHAR(10) NOT NULL, + call_count BIGINT NOT NULL, + PRIMARY KEY (id), + CONSTRAINT uk_api_daily_statistics_date_env_endpoint_method + UNIQUE (stat_date, environment, endpoint, method) +); diff --git a/src/main/java/devkor/com/teamcback/domain/apistatistics/controller/ApiStatisticsController.java b/src/main/java/devkor/com/teamcback/domain/apistatistics/controller/ApiStatisticsController.java new file mode 100644 index 00000000..5f46bb30 --- /dev/null +++ b/src/main/java/devkor/com/teamcback/domain/apistatistics/controller/ApiStatisticsController.java @@ -0,0 +1,22 @@ +package devkor.com.teamcback.domain.apistatistics.controller; + +import devkor.com.teamcback.domain.apistatistics.dto.response.ApiStatisticsResponse; +import devkor.com.teamcback.domain.apistatistics.service.ApiStatisticsService; +import devkor.com.teamcback.global.response.CommonResponse; +import lombok.RequiredArgsConstructor; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +@RestController +@RequiredArgsConstructor +@RequestMapping("/api/admin/api-statistics") +public class ApiStatisticsController { + + private final ApiStatisticsService apiStatisticsService; + + @GetMapping + public CommonResponse getStatistics() { + return CommonResponse.success(apiStatisticsService.getStatistics()); + } +} diff --git a/src/main/java/devkor/com/teamcback/domain/apistatistics/dto/response/ApiStatisticsResponse.java b/src/main/java/devkor/com/teamcback/domain/apistatistics/dto/response/ApiStatisticsResponse.java new file mode 100644 index 00000000..a7fcb288 --- /dev/null +++ b/src/main/java/devkor/com/teamcback/domain/apistatistics/dto/response/ApiStatisticsResponse.java @@ -0,0 +1,42 @@ +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 ApiStatisticsResponse { + private String environment; + private LocalDate collectionStartDate; + private long todayCallCount; + private long yesterdayCallCount; + private long last7DaysCallCount; + private long last30DaysCallCount; + private List dailyCounts; + private List monthlyCounts; + private List topEndpoints; + + @Getter + @AllArgsConstructor + public static class DailyCountResponse { + private LocalDate date; + private long callCount; + } + + @Getter + @AllArgsConstructor + public static class MonthlyCountResponse { + private String month; + private long callCount; + } + + @Getter + @AllArgsConstructor + public static class EndpointCountResponse { + private String endpoint; + private String method; + private long callCount; + } +} diff --git a/src/main/java/devkor/com/teamcback/domain/apistatistics/entity/ApiDailyStatistic.java b/src/main/java/devkor/com/teamcback/domain/apistatistics/entity/ApiDailyStatistic.java new file mode 100644 index 00000000..e592a0a8 --- /dev/null +++ b/src/main/java/devkor/com/teamcback/domain/apistatistics/entity/ApiDailyStatistic.java @@ -0,0 +1,45 @@ +package devkor.com.teamcback.domain.apistatistics.entity; + +import jakarta.persistence.Column; +import jakarta.persistence.Entity; +import jakarta.persistence.GeneratedValue; +import jakarta.persistence.GenerationType; +import jakarta.persistence.Id; +import jakarta.persistence.Table; +import jakarta.persistence.UniqueConstraint; +import java.time.LocalDate; +import lombok.AccessLevel; +import lombok.Getter; +import lombok.NoArgsConstructor; + +@Entity +@Table( + name = "api_daily_statistics", + uniqueConstraints = @UniqueConstraint( + name = "uk_api_daily_statistics_date_env_endpoint_method", + columnNames = {"stat_date", "environment", "endpoint", "method"} + ) +) +@Getter +@NoArgsConstructor(access = AccessLevel.PROTECTED) +public class ApiDailyStatistic { + + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + private Long id; + + @Column(name = "stat_date", nullable = false) + private LocalDate statDate; + + @Column(nullable = false, length = 20) + private String environment; + + @Column(nullable = false, length = 255) + private String endpoint; + + @Column(nullable = false, length = 10) + private String method; + + @Column(name = "call_count", nullable = false) + private Long callCount; +} diff --git a/src/main/java/devkor/com/teamcback/domain/apistatistics/repository/ApiDailyStatisticRepository.java b/src/main/java/devkor/com/teamcback/domain/apistatistics/repository/ApiDailyStatisticRepository.java new file mode 100644 index 00000000..b9b6883d --- /dev/null +++ b/src/main/java/devkor/com/teamcback/domain/apistatistics/repository/ApiDailyStatisticRepository.java @@ -0,0 +1,124 @@ +package devkor.com.teamcback.domain.apistatistics.repository; + +import devkor.com.teamcback.domain.apistatistics.entity.ApiDailyStatistic; +import java.time.LocalDate; +import java.util.List; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.Modifying; +import org.springframework.data.jpa.repository.Query; +import org.springframework.data.repository.query.Param; +import org.springframework.transaction.annotation.Transactional; + +public interface ApiDailyStatisticRepository extends JpaRepository { + + @Modifying + @Transactional + @Query(value = """ + INSERT INTO api_daily_statistics + (stat_date, environment, endpoint, method, call_count) + VALUES (:statDate, :environment, :endpoint, :method, 1) + ON DUPLICATE KEY UPDATE call_count = call_count + 1 + """, nativeQuery = true) + void increment( + @Param("statDate") LocalDate statDate, + @Param("environment") String environment, + @Param("endpoint") String endpoint, + @Param("method") String method + ); + + @Query(""" + SELECT COALESCE(SUM(s.callCount), 0) + FROM ApiDailyStatistic s + WHERE s.statDate = :statDate + AND s.environment = :environment + """) + Long sumByDate( + @Param("statDate") LocalDate statDate, + @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 + """) + Long sumBetween( + @Param("startDate") LocalDate startDate, + @Param("endDate") LocalDate endDate, + @Param("environment") String environment + ); + + @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 + GROUP BY s.statDate + ORDER BY s.statDate + """) + List findDailyCounts( + @Param("startDate") LocalDate startDate, + @Param("endDate") LocalDate endDate, + @Param("environment") String environment + ); + + @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 + GROUP BY DATE_FORMAT(stat_date, '%Y-%m') + ORDER BY period + """, nativeQuery = true) + List findMonthlyCounts( + @Param("startDate") LocalDate startDate, + @Param("endDate") LocalDate endDate, + @Param("environment") String environment + ); + + @Query(value = """ + SELECT endpoint AS endpoint, + method AS method, + SUM(call_count) AS callCount + FROM api_daily_statistics + WHERE stat_date BETWEEN :startDate AND :endDate + AND environment = :environment + GROUP BY endpoint, method + ORDER BY callCount DESC, endpoint, method + LIMIT 10 + """, nativeQuery = true) + List findTopEndpoints( + @Param("startDate") LocalDate startDate, + @Param("endDate") LocalDate endDate, + @Param("environment") String environment + ); + + @Query(""" + SELECT MIN(s.statDate) + FROM ApiDailyStatistic s + WHERE s.environment = :environment + """) + LocalDate findCollectionStartDate(@Param("environment") String environment); + + interface DailyCount { + LocalDate getStatDate(); + + Long getCallCount(); + } + + interface MonthlyCount { + String getPeriod(); + + Long getCallCount(); + } + + interface EndpointCount { + String getEndpoint(); + + String getMethod(); + + Long getCallCount(); + } +} diff --git a/src/main/java/devkor/com/teamcback/domain/apistatistics/service/ApiStatisticsService.java b/src/main/java/devkor/com/teamcback/domain/apistatistics/service/ApiStatisticsService.java new file mode 100644 index 00000000..40873a7b --- /dev/null +++ b/src/main/java/devkor/com/teamcback/domain/apistatistics/service/ApiStatisticsService.java @@ -0,0 +1,99 @@ +package devkor.com.teamcback.domain.apistatistics.service; + +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 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.stream.Collectors; +import lombok.RequiredArgsConstructor; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +@Service +@RequiredArgsConstructor +public class ApiStatisticsService { + + private static final ZoneId SEOUL_ZONE = ZoneId.of("Asia/Seoul"); + + private final ApiDailyStatisticRepository repository; + + @Value("${metrics.environment}") + private String environment; + + public void record(LocalDate statDate, String endpoint, String method) { + repository.increment(statDate, environment, endpoint, method); + } + + @Transactional(readOnly = true) + public ApiStatisticsResponse getStatistics() { + LocalDate today = LocalDate.now(SEOUL_ZONE); + LocalDate yesterday = today.minusDays(1); + LocalDate last7DaysStart = today.minusDays(6); + LocalDate last30DaysStart = today.minusDays(29); + LocalDate sixMonthsStart = today.withDayOfMonth(1).minusMonths(5); + + List dailyCounts = getDailyCounts(last30DaysStart, today); + List monthlyCounts = getMonthlyCounts(sixMonthsStart, today); + List topEndpoints = repository.findTopEndpoints( + last30DaysStart, today, environment) + .stream() + .map(item -> new EndpointCountResponse( + item.getEndpoint(), item.getMethod(), item.getCallCount())) + .toList(); + + return new ApiStatisticsResponse( + environment, + repository.findCollectionStartDate(environment), + valueOrZero(repository.sumByDate(today, environment)), + valueOrZero(repository.sumByDate(yesterday, environment)), + valueOrZero(repository.sumBetween(last7DaysStart, today, environment)), + valueOrZero(repository.sumBetween(last30DaysStart, today, environment)), + dailyCounts, + monthlyCounts, + topEndpoints + ); + } + + private List getDailyCounts(LocalDate startDate, LocalDate endDate) { + Map counts = repository.findDailyCounts(startDate, endDate, environment) + .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 getMonthlyCounts(LocalDate startDate, LocalDate endDate) { + Map counts = new HashMap<>(); + repository.findMonthlyCounts(startDate, endDate, environment) + .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 long valueOrZero(Long value) { + return value == null ? 0L : value; + } +} diff --git a/src/main/java/devkor/com/teamcback/global/logging/LoggingFilter.java b/src/main/java/devkor/com/teamcback/global/logging/LoggingFilter.java index f194473c..f839a985 100644 --- a/src/main/java/devkor/com/teamcback/global/logging/LoggingFilter.java +++ b/src/main/java/devkor/com/teamcback/global/logging/LoggingFilter.java @@ -1,5 +1,6 @@ package devkor.com.teamcback.global.logging; +import devkor.com.teamcback.domain.apistatistics.service.ApiStatisticsService; import devkor.com.teamcback.global.security.UserDetailsImpl; import jakarta.servlet.FilterChain; import jakarta.servlet.ServletException; @@ -10,6 +11,7 @@ import org.slf4j.MDC; import org.springframework.security.core.context.SecurityContextHolder; import org.springframework.stereotype.Component; +import org.springframework.web.servlet.HandlerMapping; import org.springframework.web.filter.OncePerRequestFilter; import java.io.IOException; @@ -19,6 +21,12 @@ @Component public class LoggingFilter extends OncePerRequestFilter { + private final ApiStatisticsService apiStatisticsService; + + public LoggingFilter(ApiStatisticsService apiStatisticsService) { + this.apiStatisticsService = apiStatisticsService; + } + @Override protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, @@ -41,10 +49,41 @@ protected void doFilterInternal(HttpServletRequest request, MDC.put("status", String.valueOf(response.getStatus())); MDC.put("latencyMs", String.valueOf(latency)); LoggerFactory.getLogger("REQUEST_LOG").info("요청 완료"); + recordApiStatistics(request); MDC.clear(); } } + private void recordApiStatistics(HttpServletRequest request) { + String uri = request.getRequestURI(); + if (isExcluded(uri)) return; + + String endpoint = (String) request.getAttribute(HandlerMapping.BEST_MATCHING_PATTERN_ATTRIBUTE); + if (endpoint == null || endpoint.isBlank()) endpoint = "UNMATCHED_API"; + + try { + apiStatisticsService.record( + java.time.LocalDate.now(java.time.ZoneId.of("Asia/Seoul")), + endpoint, + request.getMethod() + ); + } catch (Exception e) { + log.warn("API statistics recording failed. method={}, endpoint={}", request.getMethod(), endpoint, e); + } + } + + private boolean isExcluded(String uri) { + return !uri.startsWith("/api/") + || uri.equals("/actuator") + || uri.startsWith("/actuator/") + || uri.equals("/swagger-ui") + || uri.startsWith("/swagger-ui/") + || uri.equals("/v3/api-docs") + || uri.startsWith("/v3/api-docs/") + || uri.startsWith("/api/admin/api-statistics/") + || uri.equals("/api/admin/api-statistics"); + } + private String getUserIdFromToken() { var auth = SecurityContextHolder.getContext().getAuthentication(); if (auth != null && auth.getPrincipal() instanceof UserDetailsImpl userDetails) { diff --git a/src/main/java/devkor/com/teamcback/global/security/SecurityConfig.java b/src/main/java/devkor/com/teamcback/global/security/SecurityConfig.java index 2ac2c81c..084a13f3 100644 --- a/src/main/java/devkor/com/teamcback/global/security/SecurityConfig.java +++ b/src/main/java/devkor/com/teamcback/global/security/SecurityConfig.java @@ -1,5 +1,6 @@ package devkor.com.teamcback.global.security; +import devkor.com.teamcback.domain.apistatistics.service.ApiStatisticsService; import devkor.com.teamcback.global.exception.handler.CustomAccessDeniedHandler; import devkor.com.teamcback.global.exception.handler.CustomAuthenticationEntryPoint; import devkor.com.teamcback.global.exception.handler.ExceptionHandlerFilter; @@ -33,6 +34,7 @@ public class SecurityConfig { private final JwtUtil jwtUtil; private final RedisUtil redisUtil; private final UserDetailsService userDetailsService; + private final ApiStatisticsService apiStatisticsService; private final LogoutHandler logoutHandler; private final LogoutSuccessHandler logoutSuccessHandler; @@ -68,7 +70,7 @@ public CustomAuthenticationEntryPoint customAuthenticationEntryPoint() { @Bean public LoggingFilter loggingFilter() { - return new LoggingFilter(); + return new LoggingFilter(apiStatisticsService); } @Bean diff --git a/src/test/java/devkor/com/teamcback/domain/apistatistics/service/ApiStatisticsServiceTest.java b/src/test/java/devkor/com/teamcback/domain/apistatistics/service/ApiStatisticsServiceTest.java new file mode 100644 index 00000000..1b3c7752 --- /dev/null +++ b/src/test/java/devkor/com/teamcback/domain/apistatistics/service/ApiStatisticsServiceTest.java @@ -0,0 +1,104 @@ +package devkor.com.teamcback.domain.apistatistics.service; + +import static org.assertj.core.api.Assertions.assertThat; +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; +import devkor.com.teamcback.domain.apistatistics.repository.ApiDailyStatisticRepository.DailyCount; +import devkor.com.teamcback.domain.apistatistics.repository.ApiDailyStatisticRepository.EndpointCount; +import devkor.com.teamcback.domain.apistatistics.repository.ApiDailyStatisticRepository.MonthlyCount; +import java.time.LocalDate; +import java.util.List; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import org.springframework.test.util.ReflectionTestUtils; + +@ExtendWith(MockitoExtension.class) +class ApiStatisticsServiceTest { + + @Mock + private ApiDailyStatisticRepository repository; + + private ApiStatisticsService service; + + @BeforeEach + void setUp() { + service = new ApiStatisticsService(repository); + ReflectionTestUtils.setField(service, "environment", "test"); + } + + @Test + void returnsZeroFilledDailyAndMonthlyRanges() { + when(repository.sumByDate(any(LocalDate.class), anyString())).thenReturn(3L); + when(repository.sumBetween(any(LocalDate.class), any(LocalDate.class), anyString())).thenReturn(10L); + when(repository.findDailyCounts(any(LocalDate.class), any(LocalDate.class), anyString())) + .thenReturn(List.of(dailyCount(LocalDate.now().minusDays(1), 2L))); + when(repository.findMonthlyCounts(any(LocalDate.class), any(LocalDate.class), anyString())) + .thenReturn(List.of(monthlyCount("2026-11", 7L))); + when(repository.findTopEndpoints(any(LocalDate.class), any(LocalDate.class), anyString())) + .thenReturn(List.of(endpointCount("/api/users/{userId}", "GET", 5L))); + when(repository.findCollectionStartDate("test")).thenReturn(LocalDate.now().minusDays(10)); + + var response = service.getStatistics(); + + assertThat(response.getEnvironment()).isEqualTo("test"); + assertThat(response.getDailyCounts()).hasSize(30); + assertThat(response.getMonthlyCounts()).hasSize(6); + assertThat(response.getTopEndpoints()).singleElement().satisfies(item -> { + assertThat(item.getEndpoint()).isEqualTo("/api/users/{userId}"); + assertThat(item.getCallCount()).isEqualTo(5L); + }); + } + + private DailyCount dailyCount(LocalDate date, Long count) { + return new DailyCount() { + @Override + public LocalDate getStatDate() { + return date; + } + + @Override + public Long getCallCount() { + return count; + } + }; + } + + private MonthlyCount monthlyCount(String month, Long count) { + return new MonthlyCount() { + @Override + public String getPeriod() { + return month; + } + + @Override + public Long getCallCount() { + return count; + } + }; + } + + private EndpointCount endpointCount(String endpoint, String method, Long count) { + return new EndpointCount() { + @Override + public String getEndpoint() { + return endpoint; + } + + @Override + public String getMethod() { + return method; + } + + @Override + public Long getCallCount() { + return count; + } + }; + } +} diff --git a/src/test/java/devkor/com/teamcback/global/logging/LoggingFilterTest.java b/src/test/java/devkor/com/teamcback/global/logging/LoggingFilterTest.java new file mode 100644 index 00000000..89352cc0 --- /dev/null +++ b/src/test/java/devkor/com/teamcback/global/logging/LoggingFilterTest.java @@ -0,0 +1,80 @@ +package devkor.com.teamcback.global.logging; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.doThrow; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.verify; + +import devkor.com.teamcback.domain.apistatistics.service.ApiStatisticsService; +import jakarta.servlet.FilterChain; +import java.time.LocalDate; +import java.time.ZoneId; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import org.springframework.web.servlet.HandlerMapping; + +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +@ExtendWith(MockitoExtension.class) +class LoggingFilterTest { + + private static final ZoneId SEOUL_ZONE = ZoneId.of("Asia/Seoul"); + + @Mock + private ApiStatisticsService apiStatisticsService; + + @Test + void recordsOneCallAtRequestCompletionUsingMvcPattern() throws Exception { + var filter = new LoggingFilter(apiStatisticsService); + var request = mock(jakarta.servlet.http.HttpServletRequest.class); + var response = mock(jakarta.servlet.http.HttpServletResponse.class); + var chain = mock(FilterChain.class); + + when(request.getRequestURI()).thenReturn("/api/users/123"); + when(request.getMethod()).thenReturn("GET"); + when(request.getAttribute(HandlerMapping.BEST_MATCHING_PATTERN_ATTRIBUTE)) + .thenReturn("/api/users/{userId}"); + + filter.doFilterInternal(request, response, chain); + + verify(apiStatisticsService).record( + eq(LocalDate.now(SEOUL_ZONE)), eq("/api/users/{userId}"), eq("GET")); + } + + @Test + void excludesStatisticsEndpoint() throws Exception { + var filter = new LoggingFilter(apiStatisticsService); + var request = mock(jakarta.servlet.http.HttpServletRequest.class); + var response = mock(jakarta.servlet.http.HttpServletResponse.class); + var chain = mock(FilterChain.class); + + when(request.getRequestURI()).thenReturn("/api/admin/api-statistics"); + + filter.doFilterInternal(request, response, chain); + + verify(apiStatisticsService, never()).record(any(), any(), any()); + } + + @Test + void statisticsFailureDoesNotFailOriginalRequest() throws Exception { + var filter = new LoggingFilter(apiStatisticsService); + var request = mock(jakarta.servlet.http.HttpServletRequest.class); + var response = mock(jakarta.servlet.http.HttpServletResponse.class); + var chain = mock(FilterChain.class); + + when(request.getRequestURI()).thenReturn("/api/users"); + when(request.getMethod()).thenReturn("GET"); + when(request.getAttribute(HandlerMapping.BEST_MATCHING_PATTERN_ATTRIBUTE)) + .thenReturn("/api/users"); + doThrow(new RuntimeException("database unavailable")) + .when(apiStatisticsService).record(any(), any(), any()); + + filter.doFilterInternal(request, response, chain); + + verify(chain).doFilter(request, response); + } +}