예외 선언 방식 변경 제안 및 Logging 고도화

[Choi-JJunho]

제가 제안해놓고 바꾸자고하는 꼴이여서 머쓱하지만 더 나은 코드를 위해 부끄러움을 무릅쓰고 discussion 올려봅니다

초기에는 예외를 도메인별로 구체화시키고 HttpStatusCode를 Handler에서 잡아서 반환하게 하는 방식이 개발자의 소요를 줄일 수 있을것이라고 생각했습니다.

코드를 작성하면서 느낀 부분은 다음과 같습니다.

• 예외 이름짓기 어렵다.
• 각 예외별 status 코드 관리가 어렵다.
• 새로운 예외가 생길때마다 Handler를 추가해주는것이 번거롭다. (관리포인트가 불필요하게 늘어난다)
• 졸지에 ExceptionHandler를 유지보수해야하는 상황이 생기기도한다.
• 예외가 발생할 때 로그보기가 힘들다.
• withDetail로 상세정보를 찍는게 번거롭다.
  • 사용자의 request와 response를 ExceptionHandler에서 가로채는 방법을 발견함

위와 같은 번거로운 코드를 계속 작성하고있을바엔 이참에 개선하는게 좋겠다는 생각이 들었습니다.
이에 다음과 같은 방식으로 개선해보는 것을 건의드려봅니다.

Global 패키지에서 관리하는 공통 Exception

package in.koreatech.koin.global.exception;

public abstract class KoinException extends RuntimeException {

    protected KoinException() {
    }

    public abstract KoinExceptionType getExceptionType();
}

package in.koreatech.koin.global.exception;

public interface KoinExceptionType {

    HttpStatus getHttpStatus();

    String getMessage();
}

공통 Exception을 상속받는 예외

예외 선언방식

package in.koreatech.koin.domain.shop.exception;

import in.koreatech.koin.global.exception.KoinException;

public class ShopException extends KoinException {

    private final ShopExceptionType shopExceptionType;

    public ShopException(ShopExceptionType shopExceptionType) {
        this.shopExceptionType = shopExceptionType;
    }

    @Override
    public ShopExceptionType getExceptionType() {
        return shopExceptionType;
    }
}

예외 타입 선언 방식

package in.koreatech.koin.domain.shop.exception;

import org.springframework.http.HttpStatus;

import in.koreatech.koin.global.exception.KoinExceptionType;
import static org.springframework.http.HttpStatus.NOT_FOUND;

public enum ShopExceptionType implements KoinExceptionType {

    NOT_FOUND_FUNDING(NOT_FOUND, "상점을 찾을 수 없습니다."),
    ;

    private final HttpStatus httpStatus;
    private final String message;

    ShopExceptionType(HttpStatus httpStatus, String message) {
        this.httpStatus = httpStatus;
        this.message = message;
    }

    @Override
    public HttpStatus getHttpStatus() {
        return httpStatus;
    }

    @Override
    public String getMessage() {
        return message;
    }
}

사용 예시

사용하는 부분 예시

public interface MenuRepository extends Repository<Menu, Long> {

    Optional<Menu> findById(Long menuId);

    Menu save(Menu menu);

    default Menu getById(Long menuId) {
        return findById(menuId)
            .orElseThrow(() -> new ShopException(NOT_FOUND_MENU));
    }
}

패키지 구조

각 도메인 패키지별로 exception에 대해 선언할때 domainNameException, domainNameExceptionType이 존재하는 구조.

Handler 부분

@Slf4j
@RestControllerAdvice
@RequiredArgsConstructor
public class ExceptionControllerAdvice {

    @ExceptionHandler({MoaException.class, MethodArgumentNotValidException.class})
    ResponseEntity<ExceptionResponse> handleException(HttpServletRequest request, MoaException e) {
        MoaExceptionType type = e.getExceptionType();
        log.info("[{}] 잘못된 요청이 들어왔습니다. uri: {} {},  내용:  {}",
                MDC.get(REQUEST_ID), request.getMethod(), request.getRequestURI(), type.getMessage());
        log.info("[{}] request header: {}", MDC.get(REQUEST_ID), getHeaders(request));
        log.info("[{}] request body: {}", MDC.get(REQUEST_ID), getRequestBody(request));
        return ResponseEntity.status(type.getHttpStatus())
                .body(new ExceptionResponse(type.getMessage()));
    }

    @ExceptionHandler(Exception.class)
    ResponseEntity<ExceptionResponse> handleException(HttpServletRequest request, Exception e) {
        log.error("[{}] 예상하지 못한 예외가 발생했습니다. uri: {} {}, ",
                MDC.get(REQUEST_ID), request.getMethod(), request.getRequestURI(), e);
        log.info("[{}] request header: {}", MDC.get(REQUEST_ID), getHeaders(request));
        log.info("[{}] request body: {}", MDC.get(REQUEST_ID), getRequestBody(request));
        return ResponseEntity.internalServerError()
                .body(new ExceptionResponse("알 수 없는 오류가 발생했습니다."));
    }

    private Map<String, Object> getHeaders(HttpServletRequest request) {
        Map<String, Object> headerMap = new HashMap<>();
        Enumeration<String> headerArray = request.getHeaderNames();
        while (headerArray.hasMoreElements()) {
            String headerName = headerArray.nextElement();
            headerMap.put(headerName, request.getHeader(headerName));
        }
        return headerMap;
    }

    private String getRequestBody(HttpServletRequest request) {
        ContentCachingRequestWrapper wrapper = WebUtils.getNativeRequest(request, ContentCachingRequestWrapper.class);
        if (wrapper != null) {
            byte[] buf = wrapper.getContentAsByteArray();
            if (buf.length > 0) {
                try {
                    return new String(buf, wrapper.getCharacterEncoding());
                } catch (UnsupportedEncodingException e) {
                    return " - ";
                }
            }
        }
        return " - ";
    }
}

해당 코드가 다소 복잡하여 간략하게 설명해봅니다.

slf4j에서 제공하는 MDC라는 라이브러리를 이용해 클라이언트의 요청을 저장할 수 있습니다.
이를 통해 클라이언트의 요청 / 응답을 핸들링하며 로깅을 수행할 수 있습니다.

• 참고 블로그

Config

해당 설정을 위해 다음과 같은 설정들이 추가됩니다.

패키지 구조

RequestLoggingFilter

package moa.global.log;

@Slf4j
@Component
@RequiredArgsConstructor
public class RequestLoggingFilter implements Filter {

    public static final String REQUEST_ID = "requestId";

    private final ObjectProvider<PathMatcher> pathMatcherProvider;
    private final Set<String> setIgnoredUrlPatterns = new HashSet<>();

    public void setIgnoredUrlPatterns(String... ignoredUrlPatterns) {
        this.setIgnoredUrlPatterns.addAll(Arrays.asList(ignoredUrlPatterns));
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws ServletException, IOException {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        if (CorsUtils.isPreFlightRequest(httpRequest) || isIgnoredUrl(httpRequest)) {
            chain.doFilter(request, response);
            return;
        }

        ContentCachingRequestWrapper cachedRequest = new ContentCachingRequestWrapper((HttpServletRequest) request);
        ContentCachingResponseWrapper cachedResponse = new ContentCachingResponseWrapper(
                (HttpServletResponse) response);

        StopWatch stopWatch = new StopWatch();
        try {
            MDC.put(REQUEST_ID, getRequestId(httpRequest));
            stopWatch.start();
            log.info("[{}] request start [uri: {} {}]",
                    MDC.get(REQUEST_ID), httpRequest.getMethod(), httpRequest.getRequestURI());
            chain.doFilter(cachedRequest, cachedResponse);
        } finally {
            stopWatch.stop();
            log.info("[{}] response body: {}", MDC.get(REQUEST_ID), getResponseBody(cachedResponse));
            log.info("[{}] request end [time: {}ms]", MDC.get(REQUEST_ID), stopWatch.getTotalTimeMillis());
            MDC.clear();
        }
    }

    private boolean isIgnoredUrl(HttpServletRequest request) {
        PathMatcher pathMatcher = this.pathMatcherProvider.getIfAvailable();
        Objects.requireNonNull(pathMatcher);
        return setIgnoredUrlPatterns.stream()
                .anyMatch(pattern -> pathMatcher.match(pattern, request.getRequestURI()));
    }

    private String getRequestId(HttpServletRequest httpRequest) {
        String requestId = httpRequest.getHeader("X-Request-ID");
        if (ObjectUtils.isEmpty(requestId)) {
            return UUID.randomUUID().toString().replace("-", "");
        }
        return requestId;
    }

    private String getResponseBody(HttpServletResponse response) throws IOException {
        String payload = null;
        ContentCachingResponseWrapper wrapper =
                WebUtils.getNativeResponse(response, ContentCachingResponseWrapper.class);
        if (wrapper != null) {
            wrapper.setCharacterEncoding("UTF-8");
            byte[] buf = wrapper.getContentAsByteArray();
            if (buf.length > 0) {
                payload = new String(buf, wrapper.getCharacterEncoding());
                wrapper.copyBodyToResponse();
            }
        }
        return null == payload ? " - " : payload;
    }
}

• CORS preflight 요청의 경우 로깅 생략
• stopWatch로 요청, 응답 시간 체크
• Web request, response가 consume (소비) 되지 않도록 읽어들이는 ContentCachingRequestWrapper, ContentCachingResponseWrapper
• ThreadLocal에 로깅 정보를 저장하는 MDC에 내용 put해서 저장.
• dofilter() 이후 (요청에 대한 처리가 끝난 후에) 응답에 대한 로깅을 남기고 MDC clear (ThreadLocal 에 저장하는 값이라서 요청이 끝나고 반드시 초기화시켜줘야한다.)

  • 여담으로 Spring Security가 사용자 인증정보를 이렇게 ThreadLocal로 관리하고 filter 종료 시 clear 하는식으로 동작한다.

• 그 외 기타 정보 추출용 로직들 다수 포함

WebLogConfig

Configuration에 RequestLoggingFilter 필터 등록

package in.koreatech.koin.global.log;

@Configuration
@RequiredArgsConstructor
public class WebLogConfig {

    private final RequestLoggingFilter requestLoggingFilter;

    @Bean
    public FilterRegistrationBean<RequestLoggingFilter> firstFilter() {
        FilterRegistrationBean<RequestLoggingFilter> registrationBean = new FilterRegistrationBean<>();
        requestLoggingFilter.setIgnoredUrlPatterns(
                "/error",
                "/favicon.ico",
                "/api-docs/**",
                "/swagger-ui/**"
        );
        registrationBean.setFilter(requestLoggingFilter);
        registrationBean.addUrlPatterns("/*");
        registrationBean.setOrder(1);
        registrationBean.setName("requestLoggingFilter");
        return registrationBean;
    }
}

내용이 많아 복잡할 수 있습니다.
모두가 같은 시선으로 모든 내용을 이해하고 진행하면 좋겠다는 마음에 최대한 상세하게 정리해봤으니 한번씩 확인 부탁드리며
해당 예외처리방식 및 로깅 방식에 대해 개선하는 부분에 여러분들의 동의를 구하고자합니다~!

(물론 작업은 제가 후다닥 해오겠습니다)

[Choi-JJunho]

TODO: logback 설정으로 대체 가능한지 확인

[Choi-JJunho]

production: Datadog 활용
stage: logback 설정

• feat: stage logback 적용 #300