feat: 에러 발생시 슬랙 채널 알림 자동

Author: JunRain2

tuk-api/src/main/kotlin/nexters/tuk/infrastructure/slack/SlackAlertSender.kt

@@ -3,6 +3,7 @@ package nexters.tuk.infrastructure.slack
 import com.slack.api.methods.MethodsClient
 import mu.KotlinLogging
 import org.springframework.beans.factory.annotation.Value
+import org.springframework.scheduling.annotation.Async
 import org.springframework.stereotype.Component
 
 private val logger = KotlinLogging.logger {}
@@ -13,7 +14,8 @@ class SlackAlertSender(
     @Value("\${slack.channels.error-alert}")
     private val alertChannel: String,
 ) {
-    
+
+    @Async
     fun sendAlert(slackErrorAlert: SlackErrorAlert) {
         alertChannel.takeIf { it.isNotBlank() }
             ?.let { channel ->

tuk-api/src/main/kotlin/nexters/tuk/infrastructure/slack/SlackErrorAlert.kt

@@ -13,8 +13,7 @@ data class SlackErrorAlert(
     val httpMethod: String,
     val path: String,
     val occurredAt: ZonedDateTime,
-    val errorMessage: String,
-    val requestParamsJson: String
+    val errorMessage: String
 ) {
     private fun kstString(): String =
         occurredAt.withZoneSameInstant(ZoneId.of("Asia/Seoul"))
@@ -50,11 +49,6 @@ data class SlackErrorAlert(
         val errorMd = "❌ *에러 메시지*\n```$errorMessage```"
         blocks += Blocks.section { it.text(MarkdownTextObject(errorMd, false)) }
 
-        // 요청 파라미터(코드블록, 비어있지 않을 때만)
-        if (requestParamsJson.isNotBlank()) {
-            val paramsMd = "📦 *요청 파라미터*\n```$requestParamsJson```"
-            blocks += Blocks.section { it.text(MarkdownTextObject(paramsMd, false)) }
-        }
 
         return blocks
     }

tuk-api/src/main/kotlin/nexters/tuk/ui/ApiControllerAdvice.kt

@@ -6,6 +6,8 @@ import com.fasterxml.jackson.databind.exc.MismatchedInputException
 import nexters.tuk.contract.ApiResponse
 import nexters.tuk.contract.BaseException
 import nexters.tuk.contract.ErrorType
+import nexters.tuk.infrastructure.slack.SlackAlertSender
+import nexters.tuk.infrastructure.slack.SlackErrorAlert
 import org.slf4j.LoggerFactory
 import org.springframework.http.ResponseEntity
 import org.springframework.http.converter.HttpMessageNotReadableException
@@ -14,33 +16,40 @@ import org.springframework.web.bind.annotation.RestControllerAdvice
 import org.springframework.web.server.MissingRequestValueException
 import org.springframework.web.server.ServerWebInputException
 import org.springframework.web.servlet.resource.NoResourceFoundException
+import jakarta.servlet.http.HttpServletRequest
+import java.time.ZonedDateTime
 
 @RestControllerAdvice
-class ApiControllerAdvice {
+class ApiControllerAdvice(
+    private val slackAlertSender: SlackAlertSender
+) {
     private val log = LoggerFactory.getLogger(ApiControllerAdvice::class.java)
 
     @ExceptionHandler
-    fun handle(e: BaseException): ResponseEntity<ApiResponse<*>> {
+    fun handle(e: BaseException, request: HttpServletRequest): ResponseEntity<ApiResponse<*>> {
         log.warn("BaseException : {}", e.message, e)
+        sendSlackAlert(request, e.errorType, e.message)
         return failureResponse(errorType = e.errorType, errorMessage = e.message)
     }
 
     @ExceptionHandler
-    fun handle(e: IllegalArgumentException): ResponseEntity<ApiResponse<*>> {
+    fun handle(e: IllegalArgumentException, request: HttpServletRequest): ResponseEntity<ApiResponse<*>> {
         log.warn("BaseException : {}", e.message, e)
+        sendSlackAlert(request, ErrorType.BAD_REQUEST, e.message)
         return failureResponse(errorType = ErrorType.BAD_REQUEST, errorMessage = e.message)
     }
 
     @ExceptionHandler
-    fun handle(e: MissingRequestValueException): ResponseEntity<ApiResponse<*>> {
+    fun handle(e: MissingRequestValueException, request: HttpServletRequest): ResponseEntity<ApiResponse<*>> {
         val name = e.methodParameter?.parameter?.name
         val type = e.methodParameter?.parameter?.type?.simpleName
         val message = "필수 요청 파라미터 '$name' (타입: $type)가 누락되었습니다."
+        sendSlackAlert(request, ErrorType.BAD_REQUEST, message)
         return failureResponse(errorType = ErrorType.BAD_REQUEST, errorMessage = message)
     }
 
     @ExceptionHandler
-    fun handle(e: HttpMessageNotReadableException): ResponseEntity<ApiResponse<*>> {
+    fun handle(e: HttpMessageNotReadableException, request: HttpServletRequest): ResponseEntity<ApiResponse<*>> {
         val errorMessage = when (val rootCause = e.rootCause) {
             is InvalidFormatException -> {
                 val fieldName = rootCause.path.joinToString(".") { it.fieldName ?: "?" }
@@ -74,11 +83,12 @@ class ApiControllerAdvice {
             else -> "요청 본문을 처리하는 중 오류가 발생했습니다. JSON 메세지 규격을 확인해주세요."
         }
 
+        sendSlackAlert(request, ErrorType.BAD_REQUEST, errorMessage)
         return failureResponse(errorType = ErrorType.BAD_REQUEST, errorMessage = errorMessage)
     }
 
     @ExceptionHandler
-    fun handleBadRequest(e: ServerWebInputException): ResponseEntity<ApiResponse<*>> {
+    fun handleBadRequest(e: ServerWebInputException, request: HttpServletRequest): ResponseEntity<ApiResponse<*>> {
         val errorMessage = when (val rootCause = e.rootCause) {
             is InvalidFormatException -> {
                 val fieldName = rootCause.path.joinToString(".") { it.fieldName ?: "?" }
@@ -114,19 +124,27 @@ class ApiControllerAdvice {
             else -> "요청 본문을 처리하는 중 오류가 발생했습니다. JSON 메세지 규격을 확인해주세요."
         }
 
+        sendSlackAlert(request, ErrorType.BAD_REQUEST, errorMessage)
         return failureResponse(errorType = ErrorType.BAD_REQUEST, errorMessage = errorMessage)
     }
 
     @ExceptionHandler
-    fun handleNotFound(e: NoResourceFoundException): ResponseEntity<ApiResponse<*>> {
+    fun handleNotFound(e: NoResourceFoundException, request: HttpServletRequest): ResponseEntity<ApiResponse<*>> {
+        val message = "리소스를 찾을 수 없습니다: ${request.requestURI}"
+        sendSlackAlert(request, ErrorType.NOT_FOUND, message)
         return failureResponse(errorType = ErrorType.NOT_FOUND)
     }
 
     @ExceptionHandler
-    fun handle(e: Throwable): ResponseEntity<ApiResponse<*>> {
+    fun handle(e: Throwable, request: HttpServletRequest): ResponseEntity<ApiResponse<*>> {
         log.error("Exception : {}", e.message, e)
-        val errorType = ErrorType.INTERNAL_ERROR
-        return failureResponse(errorType = errorType)
+        val message = e.message ?: "알 수 없는 서버 오류가 발생했습니다"
+        sendSlackAlert(request, ErrorType.INTERNAL_ERROR, message)
+        return failureResponse(errorType = ErrorType.INTERNAL_ERROR)
+    }
+
+    private fun sendSlackAlert(request: HttpServletRequest, errorType: ErrorType, errorMessage: String? = null) {
+        slackAlertSender.sendAlert(SlackErrorAlert(errorType.status.value(), request.method, request.requestURI, ZonedDateTime.now(), errorMessage ?: errorType.message))
     }
 
     private fun failureResponse(errorType: ErrorType, errorMessage: String? = null): ResponseEntity<ApiResponse<*>> =