Merge pull request #69 from YAPP-Github/feature/MAFOO-121

[MAFOO-121] feat: 포토 서비스의 슬랙 에러 알림에 payload 정보를 추가했어요

photo-service/src/main/java/kr/mafoo/photo/config/WebExceptionHandler.java

@@ -4,14 +4,32 @@
 import kr.mafoo.photo.controller.dto.response.ErrorResponse;
 import kr.mafoo.photo.exception.DomainException;
 import kr.mafoo.photo.exception.ErrorCode;
+import kr.mafoo.photo.service.SlackService;
+import lombok.RequiredArgsConstructor;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.core.io.buffer.DataBufferUtils;
+import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.MethodArgumentNotValidException;
 import org.springframework.web.bind.annotation.ExceptionHandler;
 import org.springframework.web.bind.annotation.RestControllerAdvice;
 import org.springframework.web.bind.support.WebExchangeBindException;
+import org.springframework.web.server.ResponseStatusException;
+import org.springframework.web.server.ServerWebExchange;
+import reactor.core.publisher.Mono;
+
+import java.net.InetSocketAddress;
+import java.nio.charset.StandardCharsets;
+import java.util.Optional;
 
 @RestControllerAdvice
+@RequiredArgsConstructor
 public class WebExceptionHandler {
+
+    private final Logger logger = LoggerFactory.getLogger(WebExceptionHandler.class);
+    private final SlackService slackService;
+
     @ExceptionHandler(DomainException.class)
     public ResponseEntity<ErrorResponse> handleDomainException(DomainException exception) {
         return ResponseEntity
@@ -42,4 +60,79 @@ public ResponseEntity<ErrorResponse> validException(Exception ex) {
                 .badRequest()
                 .body(response);
     }
+
+    @ExceptionHandler(ResponseStatusException.class)
+    public Mono<ResponseEntity<String>> handleResponseStatusException(ServerWebExchange exchange, ResponseStatusException exception) {
+        return handleExceptionInternal(exchange, exception, (HttpStatus) exception.getStatusCode());
+    }
+
+    @ExceptionHandler(Exception.class)
+    public Mono<ResponseEntity<String>> handleGenericException(ServerWebExchange exchange, Exception exception) {
+        return handleExceptionInternal(exchange, exception, HttpStatus.INTERNAL_SERVER_ERROR);
+    }
+
+    private Mono<ResponseEntity<String>> handleExceptionInternal(ServerWebExchange exchange, Exception exception, HttpStatus status) {
+        String method = extractMethod(exchange);
+        String userAgent = extractUserAgent(exchange);
+        String fullPath = extractURI(exchange);
+        String originIp = extractOriginIp(exchange);
+
+        return extractRequestBody(exchange).flatMap(requestBody -> {
+
+            logException(method, fullPath, originIp, userAgent, exception);
+
+            if (status == HttpStatus.INTERNAL_SERVER_ERROR) {
+                return slackService.sendErrorNotification(
+                        method, fullPath, requestBody, originIp, userAgent, exception.getMessage()
+                ).then(Mono.just(new ResponseEntity<>("Internal Server Error", status)));
+            }
+
+            return Mono.just(new ResponseEntity<>(status.getReasonPhrase(), status));
+        });
+    }
+
+    private String extractMethod(ServerWebExchange exchange) {
+        return exchange.getRequest().getMethod().toString();
+    }
+
+    private String extractUserAgent(ServerWebExchange exchange) {
+        return exchange.getRequest().getHeaders().getFirst("User-Agent");
+    }
+
+    private String extractURI(ServerWebExchange exchange) {
+        var request = exchange.getRequest();
+
+        String scheme = request.getURI().getScheme();
+        String host = request.getURI().getHost();
+        int port = request.getURI().getPort();
+        String fullPath = request.getURI().getRawPath();
+        String query = request.getURI().getQuery();
+
+        String baseUrl = (port != -1) ? host + ":" + port : host;
+        String uriWithHost = scheme + "://" + baseUrl + fullPath;
+
+        return (query != null && !query.isEmpty()) ? uriWithHost + "?" + query : uriWithHost;
+    }
+
+    private String extractOriginIp(ServerWebExchange exchange) {
+        String proxyIp = exchange.getRequest().getHeaders().getFirst("X-Forwarded-For");
+        InetSocketAddress remoteAddress = exchange.getRequest().getRemoteAddress();
+        return Optional.ofNullable(proxyIp)
+                .orElseGet(() -> remoteAddress != null ? remoteAddress.getAddress().getHostAddress() : "UNKNOWN SOURCE");
+    }
+
+    private Mono<String> extractRequestBody(ServerWebExchange exchange) {
+        return exchange.getRequest().getBody().map(dataBuffer -> {
+                    byte[] bytes = new byte[dataBuffer.readableByteCount()];
+                    dataBuffer.read(bytes);
+                    DataBufferUtils.release(dataBuffer);
+
+                    return new String(bytes, StandardCharsets.UTF_8);
+                }).reduce(new StringBuilder(), StringBuilder::append)
+                .map(StringBuilder::toString);
+    }
+
+    private void logException(String method, String fullPath, String originIp, String userAgent, Exception exception) {
+        logger.error("Exception occurred: {} {} {} ERROR {} {}", method, fullPath, originIp, exception.getMessage(), userAgent);
+    }
 }

photo-service/src/main/java/kr/mafoo/photo/service/SlackService.java

@@ -20,23 +20,23 @@
 @RequiredArgsConstructor
 public class SlackService {
 
-    @Value(value = "${slack.webhook.token}")
-    private String token;
-
     @Value(value = "${slack.webhook.channel.error}")
     private String errorChannel;
 
+    @Value(value = "${slack.webhook.channel.qr}")
+    private String qrErrorChannel;
+
     private final MethodsClient methodsClient;
 
-    public Mono<Void> sendErrorNotification(String method, String uri, String originIp, String userAgent, String message) {
+    public Mono<Void> sendNotification(String channel, String headerText, String method, String uri, String requestBody, String originIp, String userAgent, String message) {
         return Mono.fromCallable(() -> {
             List<LayoutBlock> layoutBlocks = new ArrayList<>();
 
             // Header 삽입
             layoutBlocks.add(
                     Blocks.header(
                             headerBlockBuilder ->
-                                    headerBlockBuilder.text(plainText("🚨 예상하지 못한 에러 발생"))
+                                    headerBlockBuilder.text(plainText(headerText))
                     )
             );
 
@@ -55,6 +55,15 @@ public Mono<Void> sendErrorNotification(String method, String uri, String origin
                     )
             );
 
+            MarkdownTextObject requestBodyMarkdown =
+                    MarkdownTextObject.builder().text("`요청 바디`\n" + requestBody).build();
+
+            layoutBlocks.add(
+                    section(
+                            section -> section.fields(List.of(requestBodyMarkdown))
+                    )
+            );
+
             MarkdownTextObject errorOriginIpMarkdown =
                     MarkdownTextObject.builder().text("`에러 발생 IP`\n" + originIp).build();
 
@@ -79,8 +88,8 @@ public Mono<Void> sendErrorNotification(String method, String uri, String origin
             ChatPostMessageRequest chatPostMessageRequest =
                     ChatPostMessageRequest
                             .builder()
-                            .text("예상하지 못한 에러 발생 알림")
-                            .channel(errorChannel)
+                            .text("에러 발생 알림")
+                            .channel(channel)  // 동적으로 채널 선택
                             .blocks(layoutBlocks)
                             .build();
 
@@ -89,4 +98,11 @@ public Mono<Void> sendErrorNotification(String method, String uri, String origin
         }).then();
     }
 
+    public Mono<Void> sendErrorNotification(String method, String uri, String requestBody, String originIp, String userAgent, String message) {
+        return sendNotification(errorChannel, "🚨 예상하지 못한 에러 발생", method, uri, requestBody, originIp, userAgent, message);
+    }
+
+    public Mono<Void> sendQrRelatedErrorNotification(String method, String uri, String requestBody, String originIp, String userAgent, String message) {
+        return sendNotification(qrErrorChannel, "📸 지원하지 않는 QR 브랜드 에러 발생", method, uri, requestBody, originIp, userAgent, message);
+    }
 }