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
2 changes: 2 additions & 0 deletions .gitignore
Original file line number Diff line number Diff line change
Expand Up @@ -51,3 +51,5 @@ out/
/docker-compose.local.yml
# Local migration tooling
scripts/__pycache__/
# Local AI agent files
/.agents/
11 changes: 11 additions & 0 deletions docs/sql/2026-11-17-api-daily-statistics.sql
Original file line number Diff line number Diff line change
@@ -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)
);
Original file line number Diff line number Diff line change
@@ -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<ApiStatisticsResponse> getStatistics() {
return CommonResponse.success(apiStatisticsService.getStatistics());
}
}
Original file line number Diff line number Diff line change
@@ -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<DailyCountResponse> dailyCounts;
private List<MonthlyCountResponse> monthlyCounts;
private List<EndpointCountResponse> 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;
}
}
Original file line number Diff line number Diff line change
@@ -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;
}
Original file line number Diff line number Diff line change
@@ -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<ApiDailyStatistic, Long> {

@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<DailyCount> 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<MonthlyCount> 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<EndpointCount> 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();
}
}
Original file line number Diff line number Diff line change
@@ -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<DailyCountResponse> dailyCounts = getDailyCounts(last30DaysStart, today);
List<MonthlyCountResponse> monthlyCounts = getMonthlyCounts(sixMonthsStart, today);
List<EndpointCountResponse> 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<DailyCountResponse> getDailyCounts(LocalDate startDate, LocalDate endDate) {
Map<LocalDate, Long> 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<MonthlyCountResponse> getMonthlyCounts(LocalDate startDate, LocalDate endDate) {
Map<String, Long> 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;
}
}
Loading
Loading