refactor: 로깅 구체화 하기

backend/build.gradle

@@ -26,6 +26,10 @@ dependencies {
 	implementation 'io.jsonwebtoken:jjwt-api:0.11.5'
 	implementation 'io.jsonwebtoken:jjwt-impl:0.11.5'
 	implementation 'io.jsonwebtoken:jjwt-jackson:0.11.5'
+
+	implementation 'ch.qos.logback.contrib:logback-jackson:0.1.5'
+	implementation 'ch.qos.logback.contrib:logback-json-classic:0.1.5'
+	implementation 'net.logstash.logback:logstash-logback-encoder:6.1'
 }
 
 tasks.named('test') {

backend/src/main/java/com/now/naaga/common/config/FilterConfig.java

@@ -0,0 +1,23 @@
+package com.now.naaga.common.config;
+
+import com.now.naaga.common.presentation.LogFilter;
+import com.now.naaga.common.presentation.QueryCounter;
+import org.springframework.boot.web.servlet.FilterRegistrationBean;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class FilterConfig {
+
+    private final QueryCounter queryCounter;
+
+    public FilterConfig(final QueryCounter queryCounter) {
+        this.queryCounter = queryCounter;
+    }
+
+    @Bean
+    public FilterRegistrationBean<LogFilter> logFilter() {
+        final LogFilter logFilter = new LogFilter(queryCounter);
+        return new FilterRegistrationBean<>(logFilter);
+    }
+}

backend/src/main/java/com/now/naaga/common/config/HibernateConfig.java

@@ -0,0 +1,23 @@
+package com.now.naaga.common.config;
+
+import com.now.naaga.common.presentation.QueryInspector;
+import org.springframework.boot.autoconfigure.orm.jpa.HibernatePropertiesCustomizer;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+import static org.hibernate.cfg.AvailableSettings.STATEMENT_INSPECTOR;
+
+@Configuration
+public class HibernateConfig {
+
+    private final QueryInspector queryInspector;
+
+    public HibernateConfig(final QueryInspector queryInspector) {
+        this.queryInspector = queryInspector;
+    }
+
+    @Bean
+    public HibernatePropertiesCustomizer hibernatePropertiesCustomizer() {
+        return hibernateProperties -> hibernateProperties.put(STATEMENT_INSPECTOR, queryInspector);
+    }
+}

backend/src/main/java/com/now/naaga/common/exception/ControllerExceptionHandler.java

@@ -1,6 +1,5 @@
 package com.now.naaga.common.exception;
 
-import jakarta.persistence.criteria.CriteriaBuilder;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.http.HttpStatus;
@@ -20,46 +19,41 @@ public class ControllerExceptionHandler {
     public ResponseEntity<ExceptionResponse> handleBaseException(final BaseException e) {
         final BaseExceptionType baseExceptionType = e.exceptionType();
         final ExceptionResponse exceptionResponse = new ExceptionResponse(baseExceptionType.errorCode(), baseExceptionType.errorMessage());
-        log.warn("error = {}", exceptionResponse, e);
+
+        log.info("error = {}", exceptionResponse);
+
         return ResponseEntity.status(baseExceptionType.httpStatus()).body(exceptionResponse);
     }
 
     @ExceptionHandler({
             HttpMessageNotReadableException.class,
             MethodArgumentNotValidException.class,
-            HttpMediaTypeNotSupportedException.class
-    })
+            HttpMediaTypeNotSupportedException.class})
     public ResponseEntity<ExceptionResponse> handleTypeMismatchException(final Exception e) {
         final CommonExceptionType commonExceptionType = CommonExceptionType.INVALID_REQUEST_BODY;
         final ExceptionResponse exceptionResponse = new ExceptionResponse(commonExceptionType.errorCode(), commonExceptionType.errorMessage());
-        log.warn("error = {}", exceptionResponse, e);
+
+        log.info("error = {}", exceptionResponse);
+
         return ResponseEntity.status(commonExceptionType.httpStatus()).body(exceptionResponse);
     }
 
     @ExceptionHandler(InternalException.class)
-    public ResponseEntity<ExceptionResponse> handleInternalException(final InternalException e){
+    public ResponseEntity<ExceptionResponse> handleInternalException(final InternalException e) {
         final BaseExceptionType internalExceptionType = e.exceptionType();
 
-//        log.error("errorCode = {} \n message = {}",
-//                internalExceptionType.errorCode(),
-//                internalExceptionType.errorMessage());
-
-        log.error("errorCode = {} \n message = {} \n error = {}",
-                internalExceptionType.errorCode(),
-                internalExceptionType.errorMessage(),
-                 e.getMessage() , e);
+        log.error(e.getMessage(), e);
 
         final ExceptionResponse exceptionResponse = new ExceptionResponse(10000, "예기치 못한 오류입니다");
         return ResponseEntity.status(internalExceptionType.httpStatus())
                 .body(exceptionResponse);
     }
 
     @ExceptionHandler(Exception.class)
-    public ResponseEntity<ExceptionResponse> handleException(final Exception e){
-        log.error("error = {}"+ e.getMessage() , e);
+    public ResponseEntity<ExceptionResponse> handleException(final Exception e) {
+        log.error(e.getMessage(), e);
 
         final ExceptionResponse exceptionResponse = new ExceptionResponse(10000, "예기치 못한 오류입니다");
-        e.printStackTrace();
         return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                 .body(exceptionResponse);
     }

backend/src/main/java/com/now/naaga/common/presentation/LogFilter.java

@@ -0,0 +1,51 @@
+package com.now.naaga.common.presentation;
+
+import jakarta.servlet.*;
+import jakarta.servlet.http.HttpServletRequest;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.slf4j.MDC;
+
+import java.io.IOException;
+import java.util.UUID;
+
+import static com.now.naaga.common.presentation.MdcToken.*;
+
+public class LogFilter implements Filter {
+
+    private static final String LOG_FORMAT = "uri: {}, method: {}, time: {}ms, queryCount: {}";
+
+    private final Logger log = LoggerFactory.getLogger(this.getClass().getSimpleName());
+    private final QueryCounter queryCounter;
+
+    public LogFilter(final QueryCounter queryCounter) {
+        this.queryCounter = queryCounter;
+    }
+
+    @Override
+    public void doFilter(final ServletRequest request,
+                         final ServletResponse response,
+                         final FilterChain chain)
+            throws IOException, ServletException {
+        queryCounter.init();
+
+        final long start = System.currentTimeMillis();
+        final HttpServletRequest httpServletRequest = (HttpServletRequest) request;
+        MDC.put(REQUEST_ID.getKey(), UUID.randomUUID().toString());
+
+        chain.doFilter(request, response);
+
+        final int queryCount = queryCounter.count();
+        log(start, queryCount, httpServletRequest);
+        queryCounter.close();
+        MDC.clear();
+    }
+
+    private void log(final long start,
+                     final int queryCount,
+                     final HttpServletRequest httpServletRequest) {
+        final long end = System.currentTimeMillis();
+        final long time = end - start;
+        log.info(LOG_FORMAT, httpServletRequest.getRequestURI(), httpServletRequest.getMethod(), time, queryCount);
+    }
+}

backend/src/main/java/com/now/naaga/common/presentation/MdcToken.java

@@ -0,0 +1,17 @@
+package com.now.naaga.common.presentation;
+
+public enum MdcToken {
+
+    REQUEST_ID("request_id")
+    ;
+
+    private final String key;
+
+    MdcToken(final String key) {
+        this.key = key;
+    }
+
+    public String getKey() {
+        return key;
+    }
+}

backend/src/main/java/com/now/naaga/common/presentation/QueryCounter.java

@@ -0,0 +1,30 @@
+package com.now.naaga.common.presentation;
+
+import org.springframework.stereotype.Component;
+
+@Component
+public class QueryCounter {
+
+    private static final int INITIAL_VALUE = 0;
+
+    private final ThreadLocal<Integer> count = new ThreadLocal<>();
+
+    public void increase() {
+        if (count.get() == null) {
+            init();
+        }
+        count.set(count.get() + 1);
+    }
+
+    public void init() {
+        count.set(INITIAL_VALUE);
+    }
+
+    public int count() {
+        return count.get();
+    }
+
+    public void close() {
+        count.remove();
+    }
+}

backend/src/main/java/com/now/naaga/common/presentation/QueryInspector.java

@@ -0,0 +1,31 @@
+package com.now.naaga.common.presentation;
+
+import org.hibernate.resource.jdbc.spi.StatementInspector;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Component;
+import org.springframework.web.context.request.RequestContextHolder;
+
+import java.util.Objects;
+
+@Component
+public class QueryInspector implements StatementInspector {
+
+    private final QueryCounter queryCounter;
+
+    public QueryInspector(final QueryCounter queryCounter) {
+        this.queryCounter = queryCounter;
+    }
+
+    @Override
+    public String inspect(final String sql) {
+        if (isInRequestScope()) {
+            queryCounter.increase();
+        }
+        return sql;
+    }
+
+    private boolean isInRequestScope() {
+        return Objects.nonNull(RequestContextHolder.getRequestAttributes());
+    }
+}

backend/src/main/java/com/now/naaga/gameresult/domain/ResultType.java

@@ -2,13 +2,8 @@
 
 import com.now.naaga.game.domain.EndType;
 import com.now.naaga.game.domain.Game;
-import com.now.naaga.game.domain.GameStatus;
-import com.now.naaga.gameresult.exception.GameResultException;
-import com.now.naaga.gameresult.exception.GameResultExceptionType;
 import com.now.naaga.place.domain.Position;
 
-import static com.now.naaga.game.domain.GameStatus.IN_PROGRESS;
-
 public enum ResultType {
 
     SUCCESS,

backend/src/main/java/com/now/naaga/player/presentation/PlayerController.java

@@ -38,7 +38,6 @@ public ResponseEntity<RankResponse> findMyRank(@Auth final PlayerRequest playerR
     public ResponseEntity<List<RankResponse>> findAllRank(@RequestParam(name = "sort-by") final String sortBy,
                                                           @RequestParam(name = "order") final String order) {
         if (!sortBy.equalsIgnoreCase("RANK") || !order.equalsIgnoreCase("ASCENDING")) {
-            System.out.println("sortBy: "+sortBy);
             throw new CommonException(INVALID_REQUEST_PARAMETERS);
         }
 
@@ -48,4 +47,5 @@ public ResponseEntity<List<RankResponse>> findAllRank(@RequestParam(name = "sort
                 .collect(Collectors.toList());
         return ResponseEntity.ok(rankResponseList);
     }
+
 }

backend/src/main/resources/application.yml

@@ -31,9 +31,9 @@ logging:
 
 spring:
   config:
-    import: classpath:security/application-prod.yml
+    import: classpath:security/application-local.yml
     activate:
-      on-profile: prod
+      on-profile: local
 
 ---