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

build.gradle

@@ -68,6 +68,10 @@ 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:datasource-proxy:1.11.0'
+    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,21 @@ public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers)
                 customPageableHandlerMethodArgumentResolver
         ));
     }
+
+    @Override
+    public void addInterceptors(InterceptorRegistry registry){
+        registry.addInterceptor(apiPerformanceInterceptor)
+                .addPathPatterns("/**");
+
+        registry.addInterceptor(requestContextInterceptor)
+                .addPathPatterns("/**");
+    }
+
+    @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/exception/CustomExceptionHandler.java

@@ -9,6 +9,7 @@
 import com.example.solidconnection.common.response.ErrorResponse;
 import com.fasterxml.jackson.databind.exc.InvalidFormatException;
 import io.jsonwebtoken.JwtException;
+import jakarta.servlet.http.HttpServletRequest;
 import java.util.ArrayList;
 import java.util.List;
 import lombok.extern.slf4j.Slf4j;
@@ -24,62 +25,96 @@
 public class CustomExceptionHandler {
 
     @ExceptionHandler(CustomException.class)
-    protected ResponseEntity<ErrorResponse> handleCustomException(CustomException ex) {
-        log.error("커스텀 예외 발생 : {}", ex.getMessage());
+    protected ResponseEntity<ErrorResponse> handleCustomException(
+            CustomException ex,
+            HttpServletRequest request
+    ) {
+        request.setAttribute("exceptionHandlerLogged", true);
+        Long userId = (Long) request.getAttribute("userId");
+        log.error("커스텀 예외 발생 userId : {} msg: {}", userId, ex.getMessage());
         ErrorResponse errorResponse = new ErrorResponse(ex);
         return ResponseEntity
                 .status(ex.getCode())
                 .body(errorResponse);
     }
 
     @ExceptionHandler(InvalidFormatException.class)
-    public ResponseEntity<Object> handleInvalidFormatException(InvalidFormatException ex) {
+    public ResponseEntity<Object> handleInvalidFormatException(
+            InvalidFormatException ex,
+            HttpServletRequest request
+    ) {
+        request.setAttribute("exceptionHandlerLogged", true);
+        Long userId = (Long) request.getAttribute("userId");
         String errorMessage = ex.getValue() + " 은(는) 유효하지 않은 값입니다.";
-        log.error("JSON 파싱 예외 발생 : {}", errorMessage);
+        log.error("JSON 파싱 예외 발생 userId: {} msg: {}", userId, errorMessage);
         ErrorResponse errorResponse = new ErrorResponse(JSON_PARSING_FAILED, errorMessage);
         return ResponseEntity
                 .status(JSON_PARSING_FAILED.getCode())
                 .body(errorResponse);
     }
 
     @ExceptionHandler(MethodArgumentNotValidException.class)
-    public ResponseEntity<ErrorResponse> handleValidationExceptions(MethodArgumentNotValidException ex) {
+    public ResponseEntity<ErrorResponse> handleValidationExceptions(
+            MethodArgumentNotValidException ex,
+            HttpServletRequest request
+    ) {
+        request.setAttribute("exceptionHandlerLogged", true);
+        Long userId = (Long) request.getAttribute("userId");
+
         List<String> errors = new ArrayList<>();
         ex.getBindingResult()
                 .getFieldErrors()
                 .forEach(fieldError -> errors.add(fieldError.getDefaultMessage()));
 
         String errorMessage = errors.toString();
-        log.error("입력값 검증 예외 발생 : {}", errorMessage);
+        log.error("입력값 검증 예외 발생 userId : {} msg: {}", userId, errorMessage);
         ErrorResponse errorResponse = new ErrorResponse(INVALID_INPUT, errorMessage);
         return ResponseEntity
                 .status(HttpStatus.BAD_REQUEST)
                 .body(errorResponse);
     }
 
     @ExceptionHandler(DataIntegrityViolationException.class)
-    public ResponseEntity<Object> handleDataIntegrityViolationException(DataIntegrityViolationException ex) {
-        log.error("데이터 무결성 제약조건 위반 예외 발생 : {}", ex.getMessage());
+    public ResponseEntity<Object> handleDataIntegrityViolationException(
+            DataIntegrityViolationException ex,
+            HttpServletRequest request
+    ) {
+        request.setAttribute("exceptionHandlerLogged", true);
+        Long userId = (Long) request.getAttribute("userId");
+
+        log.error("데이터 무결성 제약조건 위반 예외 발생 userId : {} msg : {}", userId, ex.getMessage());
         ErrorResponse errorResponse = new ErrorResponse(DATA_INTEGRITY_VIOLATION, "데이터 무결성 제약조건 위반 예외 발생");
         return ResponseEntity
                 .status(DATA_INTEGRITY_VIOLATION.getCode())
                 .body(errorResponse);
     }
 
     @ExceptionHandler(JwtException.class)
-    public ResponseEntity<Object> handleJwtException(JwtException ex) {
+    public ResponseEntity<Object> handleJwtException(
+            JwtException ex,
+            HttpServletRequest request
+    ) {
+        request.setAttribute("exceptionHandlerLogged", true);
+        Long userId = (Long) request.getAttribute("userId");
+
         String errorMessage = ex.getMessage();
-        log.error("JWT 예외 발생 : {}", errorMessage);
+        log.error("JWT 예외 발생 userId : {} msg : {}", userId, errorMessage);
         ErrorResponse errorResponse = new ErrorResponse(JWT_EXCEPTION, errorMessage);
         return ResponseEntity
                 .status(HttpStatus.BAD_REQUEST)
                 .body(errorResponse);
     }
 
     @ExceptionHandler(Exception.class)
-    public ResponseEntity<Object> handleOtherException(Exception ex) {
+    public ResponseEntity<Object> handleOtherException(
+            Exception ex,
+            HttpServletRequest request
+    ) {
+        request.setAttribute("exceptionHandlerLogged", true);
+        Long userId = (Long) request.getAttribute("userId");
+
         String errorMessage = ex.getMessage();
-        log.error("서버 내부 예외 발생 : {}", errorMessage);
+        log.error("서버 내부 예외 발생 userId : {} , msg : {}", userId, errorMessage);
         ErrorResponse errorResponse = new ErrorResponse(NOT_DEFINED_ERROR, errorMessage);
         return ResponseEntity
                 .status(HttpStatus.INTERNAL_SERVER_ERROR)

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

@@ -0,0 +1,116 @@
+package com.example.solidconnection.common.filter;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+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/**"
+    );
+
+    @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);
+
+            Boolean alreadyExceptionLogging = (Boolean) request.getAttribute("exceptionHandlerLogged");
+            if (alreadyExceptionLogging == null || !alreadyExceptionLogging) {
+                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 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 void printRequestUri(HttpServletRequest request) {
+        String methodType = request.getMethod();
+        String uri = buildDecodedRequestUri(request);
+        log.info("[REQUEST] {} {}", methodType, uri);
+    }
+
+    private String decodeQuery(String rawQuery) {
+        if (rawQuery == null) {
+            return null;
+        }
+        try {
+            return URLDecoder.decode(rawQuery, StandardCharsets.UTF_8);
+        } catch (IllegalArgumentException e) {
+            return rawQuery;
+        }
+    }
+
+    private String buildDecodedRequestUri(HttpServletRequest request) {
+        String path = request.getRequestURI();
+        String query = decodeQuery(request.getQueryString());
+        return (query == null || query.isBlank()) ? path : path + "?" + query;
+    }
+}