�Refactor/252 Logging 설정 추가및 리팩토링 (#270)

* chore: 로그 파일 디렉토리를 gitignore 추가

-root/logs 디렉토리의 ignore 설정

* feat: loki 의존성 추가

- 로그 저장, 시각화를 위한 loki 의존성 추가

* refactor: logback-spring.xml 리팩토링

- loki 관련 설정 추가
- 로그 패턴의 단일화 적용
- 파일 저장 appender의 설정 변경

* chore: jacoco 예외 클래스 추가

- Extractor 클래스의 테스트 커버리지 예외 조건 추가

* refactor: logging AOP 리팩토링

- 로그 기록 세분화
- 민감한 데이터 마스킹 처리
- 책임에 따른 클래스 분리
- 마스킹 테스트및 검증 완

* feat: log 공통 응답 객체 생성

- 로그 응답에 대한 Response 객체 생성

* refactor: 명시적인 생성자 제거및 어노테이션 대체

- ParameterExtractor의 생성자 코드 제거및 RequiredArgs 어노테이션 추가
- ResponseExtractor의 생성자 코드 제거및 RequiredArgs 어노테이션 추가
- SensitiveDataMasker의 불필요한 어노테이션 제거

* chore: 잠재적 에러 예방을 위한 개행 추가

- logback-spring.xml 파일의 마지막 라인에 개행 추가

Author: 7zrv

.gitignore

@@ -41,3 +41,6 @@ out/
 
 ### env file ###
 *.env
+
+### log file ###
+/logs/

build.gradle

@@ -69,6 +69,7 @@ dependencies {
     // Monitoring
     implementation group: 'org.springframework.boot', name: 'spring-boot-starter-actuator', version: '3.3.3'
     implementation 'io.micrometer:micrometer-registry-prometheus'
+    implementation 'com.github.loki4j:loki-logback-appender:1.5.1'
 
     //elastic-search
     implementation 'org.springframework.boot:spring-boot-starter-data-elasticsearch'
@@ -116,6 +117,7 @@ def jacocoExcludePatterns = [
         '**/*Application.class',
         '**/*Config*',
         '**/*Exception*',
+        '**/*Extractor*',
         '**/*Request*',
         '**/*Response*',
         '**/*Entity*',
@@ -135,6 +137,7 @@ def jacocoExcludePatternsForVerify = [
         '*.*Application*',
         '*.*Config*',
         '*.*Exception*',
+        '*.*Extractor*',
         '*.*Request*',
         '*.*Response*',
         '*.*Entity*',

src/main/java/com/somemore/global/aspect/LoggingAspect.java

@@ -0,0 +1,90 @@
+package com.somemore.global.aspect.log;
+
+import com.somemore.global.aspect.log.extractor.ParameterExtractor;
+import com.somemore.global.aspect.log.extractor.RequestExtractor;
+import com.somemore.global.aspect.log.extractor.ResponseExtractor;
+import com.somemore.global.common.response.LoggedResponse;
+import jakarta.servlet.http.HttpServletRequest;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Pointcut;
+import org.slf4j.MDC;
+import org.springframework.http.HttpStatus;
+import org.springframework.stereotype.Component;
+
+
+import java.util.UUID;
+
+@RequiredArgsConstructor
+@Slf4j
+@Aspect
+@Component
+public class LoggingAspect {
+
+    private final RequestExtractor requestExtractor;
+    private final ResponseExtractor responseExtractor;
+    private final ParameterExtractor parameterExtractor;
+
+    @Pointcut("execution(* com.somemore.domains.*.controller..*.*(..))")
+    private void controllerPointCut() {}
+
+    @Around("controllerPointCut()")
+    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
+        String requestId = UUID.randomUUID().toString();
+        MDC.put("requestId", requestId);
+
+        try {
+            return doLogAround(joinPoint);
+        } finally {
+            MDC.remove("requestId");
+        }
+    }
+
+    private Object doLogAround(ProceedingJoinPoint joinPoint) throws Throwable {
+        String methodName = joinPoint.getSignature().toShortString();
+        HttpServletRequest request = requestExtractor.getCurrentRequest();
+
+        MDC.put("method", request.getMethod());
+        MDC.put("uri", request.getRequestURI());
+
+        String params = parameterExtractor.extractParameters(joinPoint);
+        log.info("엔드포인트 호출: {} \n- URI: {} \n- Method: {} \n- 파라미터: {}",
+                methodName,
+                request.getRequestURI(),
+                request.getMethod(),
+                params);
+
+        long startTime = System.currentTimeMillis();
+
+        try {
+            Object result = joinPoint.proceed();
+            long elapsedTime = System.currentTimeMillis() - startTime;
+
+            LoggedResponse loggedResponse = responseExtractor.extractResponse(result);
+            log.info("호출 성공: {} \n- 응답 코드: {} \n- 응답 값: {} \n- 실행 시간: {}ms",
+                    methodName,
+                    loggedResponse.getStatusCode(),
+                    loggedResponse.getBody(),
+                    elapsedTime);
+
+            return result;
+        } catch (Exception e) {
+            long elapsedTime = System.currentTimeMillis() - startTime;
+            HttpStatus status = responseExtractor.extractExceptionStatus(e);
+
+            log.warn("예외 발생: {} \n- 예외 코드: {} \n- 예외 타입: {} \n- 예외 메세지: {} \n- 실행 시간: {}ms",
+                    methodName,
+                    status,
+                    e.getClass().getSimpleName(),
+                    e.getMessage(),
+                    elapsedTime);
+
+            throw e;
+        } finally {
+            MDC.clear();
+        }
+    }
+}

src/main/java/com/somemore/global/aspect/log/LoggingAspect.java

@@ -0,0 +1,68 @@
+package com.somemore.global.aspect.log.extractor;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.somemore.global.aspect.log.utils.SensitiveDataMasker;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.reflect.MethodSignature;
+import org.springframework.stereotype.Component;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestParam;
+
+import java.lang.reflect.Parameter;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+@RequiredArgsConstructor
+@Slf4j
+@Component
+public class ParameterExtractor {
+
+    private final ObjectMapper objectMapper;
+    private final SensitiveDataMasker sensitiveDataMasker;
+
+    public String extractParameters(ProceedingJoinPoint joinPoint) {
+        try {
+            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
+            Parameter[] parameters = signature.getMethod().getParameters();
+            Object[] args = joinPoint.getArgs();
+
+            if (parameters.length == 0) {
+                return "{}";
+            }
+
+            Map<String, Object> paramMap = new LinkedHashMap<>();
+            for (int i = 0; i < parameters.length; i++) {
+                if (args[i] != null) {
+                    addParameter(paramMap, parameters[i], args[i]);
+                }
+            }
+
+            return objectMapper.writeValueAsString(paramMap);
+        } catch (Exception e) {
+            log.warn("파라미터 변환 실패: {}", e.getMessage());
+            return "{}";
+        }
+    }
+
+    private void addParameter(Map<String, Object> paramMap, Parameter parameter, Object value) throws JsonProcessingException {
+        String paramName = extractParamName(parameter);
+        paramMap.put(paramName, sensitiveDataMasker.maskSensitiveData(paramName, value, objectMapper));
+    }
+
+    private String extractParamName(Parameter parameter) {
+        PathVariable pathVariable = parameter.getAnnotation(PathVariable.class);
+        if (pathVariable != null && !pathVariable.value().isEmpty()) {
+            return pathVariable.value();
+        }
+
+        RequestParam requestParam = parameter.getAnnotation(RequestParam.class);
+        if (requestParam != null && !requestParam.value().isEmpty()) {
+            return requestParam.value();
+        }
+
+        return parameter.getName();
+    }
+}

src/main/java/com/somemore/global/aspect/log/extractor/ParameterExtractor.java

@@ -0,0 +1,18 @@
+package com.somemore.global.aspect.log.extractor;
+
+import jakarta.servlet.http.HttpServletRequest;
+import org.springframework.stereotype.Component;
+import org.springframework.web.context.request.RequestContextHolder;
+import org.springframework.web.context.request.ServletRequestAttributes;
+
+@Component
+public class RequestExtractor {
+
+    public HttpServletRequest getCurrentRequest() {
+        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
+        if (attributes == null) {
+            throw new IllegalStateException("요청을 찾을수 없습니다.");
+        }
+        return attributes.getRequest();
+    }
+}

src/main/java/com/somemore/global/aspect/log/extractor/RequestExtractor.java

@@ -0,0 +1,52 @@
+package com.somemore.global.aspect.log.extractor;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.somemore.global.common.response.LoggedResponse;
+import com.somemore.global.exception.DuplicateException;
+import com.somemore.global.exception.ImageUploadException;
+import com.somemore.global.exception.BadRequestException;
+import com.somemore.global.exception.NoSuchElementException;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Component;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+
+@RequiredArgsConstructor
+@Slf4j
+@Component
+public class ResponseExtractor {
+
+    private final ObjectMapper objectMapper;
+
+    public LoggedResponse extractResponse(Object result) {
+        try {
+            if (result == null) {
+                return new LoggedResponse(HttpStatus.OK, "null");
+            }
+
+            if (result instanceof ResponseEntity<?> responseEntity) {
+                String body = objectMapper.writeValueAsString(responseEntity.getBody());
+                return new LoggedResponse(responseEntity.getStatusCode(), body);
+            }
+
+            return new LoggedResponse(HttpStatus.OK, objectMapper.writeValueAsString(result));
+        } catch (Exception e) {
+            log.warn("응답 변환 실패: {}", e.getMessage());
+            return new LoggedResponse(HttpStatus.OK, "[응답 변환 실패]");
+        }
+    }
+
+    public HttpStatus extractExceptionStatus(Exception e) {
+        if (e instanceof BadRequestException ||
+                e instanceof ImageUploadException ||
+                e instanceof DuplicateException ||
+                e instanceof MethodArgumentNotValidException) {
+            return HttpStatus.BAD_REQUEST;
+        } else if (e instanceof NoSuchElementException) {
+            return HttpStatus.NOT_FOUND;
+        }
+        return HttpStatus.INTERNAL_SERVER_ERROR;
+    }
+}