feat: API 성능 로깅, 쿼리 별 메트릭 전송 추가

build.gradle

@@ -68,6 +68,9 @@ dependencies {
     implementation 'org.hibernate.validator:hibernate-validator'
     implementation 'com.amazonaws:aws-java-sdk-s3:1.12.782'
     implementation 'org.springframework.boot:spring-boot-starter-websocket'
+
+    // Database Proxy
+    implementation 'net.ttddyy.observation:datasource-micrometer:1.2.0'
 }
 
 tasks.named('test', Test) {

src/main/java/com/example/solidconnection/common/config/datasource/DataSourceProxyConfig.java

@@ -0,0 +1,29 @@
+package com.example.solidconnection.common.config.datasource;
+
+import com.example.solidconnection.common.listener.QueryMetricsListener;
+import javax.sql.DataSource;
+import lombok.RequiredArgsConstructor;
+import net.ttddyy.dsproxy.support.ProxyDataSourceBuilder;
+import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Primary;
+
+@RequiredArgsConstructor
+@Configuration
+public class DataSourceProxyConfig {
+
+    private final QueryMetricsListener queryMetricsListener;
+
+    @Bean
+    @Primary
+    public DataSource proxyDataSource(DataSourceProperties props) {
+        DataSource dataSource = props.initializeDataSourceBuilder().build();
+
+        return ProxyDataSourceBuilder
+                .create(dataSource)
+                .listener(queryMetricsListener)
+                .name("main")
+                .build();
+    }
+}

src/main/java/com/example/solidconnection/common/config/web/WebMvcConfig.java

@@ -1,11 +1,18 @@
 package com.example.solidconnection.common.config.web;
 
+import com.example.solidconnection.common.filter.HttpLoggingFilter;
+import com.example.solidconnection.common.interceptor.ApiPerformanceInterceptor;
+import com.example.solidconnection.common.interceptor.RequestContextInterceptor;
 import com.example.solidconnection.common.resolver.AuthorizedUserResolver;
 import com.example.solidconnection.common.resolver.CustomPageableHandlerMethodArgumentResolver;
 import java.util.List;
 import lombok.RequiredArgsConstructor;
+import org.springframework.boot.web.servlet.FilterRegistrationBean;
+import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.core.Ordered;
 import org.springframework.web.method.support.HandlerMethodArgumentResolver;
+import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
 import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
 
 @Configuration
@@ -14,6 +21,9 @@ public class WebMvcConfig implements WebMvcConfigurer {
 
     private final AuthorizedUserResolver authorizedUserResolver;
     private final CustomPageableHandlerMethodArgumentResolver customPageableHandlerMethodArgumentResolver;
+    private final HttpLoggingFilter httpLoggingFilter;
+    private final ApiPerformanceInterceptor apiPerformanceInterceptor;
+    private final RequestContextInterceptor requestContextInterceptor;
 
     @Override
     public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
@@ -22,4 +32,23 @@ public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers)
                 customPageableHandlerMethodArgumentResolver
         ));
     }
+
+    @Override
+    public void addInterceptors(InterceptorRegistry registry){
+        registry.addInterceptor(apiPerformanceInterceptor)
+                .addPathPatterns("/**")
+                .excludePathPatterns("/actuator/**");
+
+        registry.addInterceptor(requestContextInterceptor)
+                .addPathPatterns("/**")
+                .excludePathPatterns("/actuator/**");
+    }
+
+    @Bean
+    public FilterRegistrationBean<HttpLoggingFilter> customHttpLoggingFilter() {
+        FilterRegistrationBean<HttpLoggingFilter> filterBean = new FilterRegistrationBean<>();
+        filterBean.setFilter(httpLoggingFilter);
+        filterBean.setOrder(Ordered.HIGHEST_PRECEDENCE);
+        return filterBean;
+    }
 }

src/main/java/com/example/solidconnection/common/filter/HttpLoggingFilter.java

@@ -0,0 +1,156 @@
+package com.example.solidconnection.common.filter;
+
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.net.URLDecoder;
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.slf4j.MDC;
+import org.springframework.http.HttpStatus;
+import org.springframework.stereotype.Component;
+import org.springframework.util.AntPathMatcher;
+import org.springframework.web.filter.OncePerRequestFilter;
+
+@Slf4j
+@RequiredArgsConstructor
+@Component
+public class HttpLoggingFilter extends OncePerRequestFilter {
+
+    private static final AntPathMatcher PATH_MATCHER = new AntPathMatcher();
+    private static final List<String> EXCLUDE_PATTERNS = List.of("/actuator/**");
+    private static final List<String> EXCLUDE_QUERIES = List.of("token");
+    private static final String MASK_VALUE = "****";
+
+    @Override
+    protected void doFilterInternal(
+            HttpServletRequest request,
+            HttpServletResponse response,
+            FilterChain filterChain
+    ) throws ServletException, IOException {
+
+        // 1) traceId 부여
+        String traceId = generateTraceId();
+        MDC.put("traceId", traceId);
+
+        boolean excluded = isExcluded(request);
+
+        // 2) 로깅 제외 대상이면 그냥 통과 (traceId는 유지: 추후 하위 레이어 로그에도 붙음)
+        if (excluded) {
+            try {
+                filterChain.doFilter(request, response);
+            } finally {
+                MDC.clear();
+            }
+            return;
+        }
+
+        printRequestUri(request);
+
+        try {
+            filterChain.doFilter(request, response);
+            printResponse(request, response);
+        } finally {
+            MDC.clear();
+        }
+    }
+
+    private boolean isExcluded(HttpServletRequest req) {
+        String path = req.getRequestURI();
+        for (String p : EXCLUDE_PATTERNS) {
+            if (PATH_MATCHER.match(p, path)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private String generateTraceId() {
+        return java.util.UUID.randomUUID().toString().replace("-", "").substring(0, 16);
+    }
+
+    private void printRequestUri(HttpServletRequest request) {
+        String methodType = request.getMethod();
+        String uri = buildDecodedRequestUri(request);
+        log.info("[REQUEST] {} {}", methodType, uri);
+    }
+
+    private void printResponse(
+            HttpServletRequest request,
+            HttpServletResponse response
+    ) {
+        Long userId = (Long) request.getAttribute("userId");
+        String uri = buildDecodedRequestUri(request);
+        HttpStatus status = HttpStatus.valueOf(response.getStatus());
+
+        log.info("[RESPONSE] {} userId = {}, ({})", uri, userId, status);
+    }
+
+    private String buildDecodedRequestUri(HttpServletRequest request) {
+        String path = request.getRequestURI();
+        String query = request.getQueryString();
+
+        if(query == null || query.isBlank()){
+            return path;
+        }
+
+        String decodedQuery = decodeQuery(query);
+        String maskedQuery = maskSensitiveParams(decodedQuery);
+
+        return path + "?" + maskedQuery;
+    }
+
+    private String decodeQuery(String rawQuery) {
+        if(rawQuery == null || rawQuery.isBlank()){
+            return rawQuery;
+        }
+
+        try {
+            return URLDecoder.decode(rawQuery, StandardCharsets.UTF_8);
+        } catch (IllegalArgumentException e) {
+            log.warn("Query 디코딩 실패 parameter: {}, msg: {}", rawQuery, e.getMessage());
+            return rawQuery;
+        }
+    }
+
+    private String maskSensitiveParams(String decodedQuery) {
+        String[] params = decodedQuery.split("&");
+        StringBuilder maskedQuery = new StringBuilder();
+
+        for(int i = 0; i < params.length; i++){
+            String param = params[i];
+
+            if(!param.contains("=")){
+                maskedQuery.append(param);
+            }else{
+                int equalIndex = param.indexOf("=");
+                String key = param.substring(0, equalIndex);
+
+                if(isSensitiveParam(key)){
+                    maskedQuery.append(key).append("=").append(MASK_VALUE);
+                }else{
+                    maskedQuery.append(param);
+                }
+            }
+
+            if(i < params.length - 1){
+                maskedQuery.append("&");
+            }
+        }
+
+        return maskedQuery.toString();
+    }
+
+    private boolean isSensitiveParam(String paramKey) {
+        for (String sensitiveParam : EXCLUDE_QUERIES){
+            if(sensitiveParam.equalsIgnoreCase(paramKey)){
+                return true;
+            }
+        }
+        return false;
+    }
+}

src/main/java/com/example/solidconnection/common/interceptor/ApiPerformanceInterceptor.java

@@ -0,0 +1,67 @@
+package com.example.solidconnection.common.interceptor;
+
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Component;
+import org.springframework.web.servlet.HandlerInterceptor;
+
+@Slf4j
+@RequiredArgsConstructor
+@Component
+public class ApiPerformanceInterceptor implements HandlerInterceptor {
+    private static final String START_TIME_ATTRIBUTE = "startTime";
+    private static final String REQUEST_URI_ATTRIBUTE = "requestUri";
+    private static final int RESPONSE_TIME_THRESHOLD = 3_000;
+    private static final Logger API_PERF = LoggerFactory.getLogger("API_PERF");
+
+    @Override
+    public boolean preHandle(
+            HttpServletRequest request,
+            HttpServletResponse response,
+            Object handler
+    ) throws Exception {
+
+        long startTime = System.currentTimeMillis();
+
+        request.setAttribute(START_TIME_ATTRIBUTE, startTime);
+        request.setAttribute(REQUEST_URI_ATTRIBUTE, request.getRequestURI());
+
+        return true;
+    }
+
+    @Override
+    public void afterCompletion(
+            HttpServletRequest request,
+            HttpServletResponse response,
+            Object handler,
+            Exception ex
+    ) throws Exception {
+        Long startTime = (Long) request.getAttribute(START_TIME_ATTRIBUTE);
+        if(startTime == null) {
+            return;
+        }
+
+        long responseTime = System.currentTimeMillis() - startTime;
+
+        String uri = request.getRequestURI();
+        String method = request.getMethod();
+        int status = response.getStatus();
+
+        if (responseTime > RESPONSE_TIME_THRESHOLD) {
+            API_PERF.warn(
+                    "type=API_Performance method_type={} uri={} response_time={} status={}",
+                    method, uri, responseTime, status
+            );
+        }
+        else {
+            API_PERF.info(
+                    "type=API_Performance method_type={} uri={} response_time={} status={}",
+                    method, uri, responseTime, status
+            );
+        }
+    }
+}

src/main/java/com/example/solidconnection/common/interceptor/RequestContext.java

@@ -0,0 +1,14 @@
+package com.example.solidconnection.common.interceptor;
+
+import lombok.Getter;
+
+@Getter
+public class RequestContext {
+    private final String httpMethod;
+    private final String bestMatchPath;
+
+    public RequestContext(String httpMethod, String bestMatchPath) {
+        this.httpMethod = httpMethod;
+        this.bestMatchPath = bestMatchPath;
+    }
+}

src/main/java/com/example/solidconnection/common/interceptor/RequestContextHolder.java

@@ -0,0 +1,18 @@
+package com.example.solidconnection.common.interceptor;
+
+public class RequestContextHolder {
+    private static final ThreadLocal<RequestContext> CONTEXT = new ThreadLocal<>();
+
+    public static void initContext(RequestContext requestContext) {
+        CONTEXT.remove();
+        CONTEXT.set(requestContext);
+    }
+
+    public static RequestContext getContext() {
+        return CONTEXT.get();
+    }
+
+    public static void clear(){
+        CONTEXT.remove();
+    }
+}

src/main/java/com/example/solidconnection/common/interceptor/RequestContextInterceptor.java

@@ -0,0 +1,36 @@
+package com.example.solidconnection.common.interceptor;
+
+import static org.springframework.web.servlet.HandlerMapping.BEST_MATCHING_PATTERN_ATTRIBUTE;
+
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import org.springframework.stereotype.Component;
+import org.springframework.web.servlet.HandlerInterceptor;
+
+@Component
+public class RequestContextInterceptor implements HandlerInterceptor {
+
+    @Override
+    public boolean preHandle(
+            HttpServletRequest request,
+            HttpServletResponse response,
+            Object handler
+    ) {
+        String httpMethod = request.getMethod();
+        String bestMatchPath = (String) request.getAttribute(BEST_MATCHING_PATTERN_ATTRIBUTE);
+
+        RequestContext context = new RequestContext(httpMethod, bestMatchPath);
+        RequestContextHolder.initContext(context);
+
+        return true;
+    }
+
+    @Override
+    public void afterCompletion(
+            HttpServletRequest request,
+            HttpServletResponse response,
+            Object handler, Exception ex
+    ) {
+        RequestContextHolder.clear();
+    }
+}