모든 Request에 대해 로깅을 적용한다.

build.gradle

@@ -2,6 +2,7 @@ plugins {
 	id 'java'
 	id 'org.springframework.boot' version '3.5.3'
 	id 'io.spring.dependency-management' version '1.1.7'
+	id "io.sentry.jvm.gradle" version "5.9.0"
 }
 
 group = 'akuma'
@@ -13,6 +14,14 @@ java {
 	}
 }
 
+sentry {
+	includeSourceContext = true
+
+	org = "akuma-ir"
+	projectName = "nuntteo_dev"
+	authToken = System.getenv("SENTRY_AUTH_TOKEN")
+}
+
 configurations {
 	compileOnly {
 		extendsFrom annotationProcessor
@@ -30,6 +39,7 @@ dependencies {
 	implementation 'org.springframework.boot:spring-boot-starter-security'
 	implementation 'org.springframework.boot:spring-boot-starter-validation'
 	implementation 'org.springframework.boot:spring-boot-starter-webflux' // 버전 명시 X (BOM 관리)
+	implementation 'org.springframework.boot:spring-boot-starter-aop'
 
 	// --- Swagger/OpenAPI ---
 	implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.7.0'
@@ -52,6 +62,10 @@ dependencies {
 	implementation 'com.google.apis:google-api-services-sheets:v4-rev612-1.25.0'
 	implementation 'com.google.firebase:firebase-admin:9.2.0'
 
+	// Sentry BOM 추가하여 버전 관리 일원화
+	implementation platform("io.sentry:sentry-bom:8.19.0")
+	implementation "io.sentry:sentry-spring-boot-starter-jakarta"
+
 	// --- Lombok ---
 	compileOnly 'org.projectlombok:lombok'
 	annotationProcessor 'org.projectlombok:lombok'
@@ -73,15 +87,5 @@ dependencies {
 	testImplementation platform('org.testcontainers:testcontainers-bom:1.21.3')
 	testImplementation 'org.testcontainers:junit-jupiter'
 	testImplementation 'org.testcontainers:mysql'
-
-	// (선택) 일부 CI 환경에서 필요한 경우만 사용
-	testRuntimeOnly 'net.bytebuddy:byte-buddy-agent:1.14.17'
 }
 
-tasks.withType(Test).configureEach {
-	useJUnitPlatform()
-	// Mockito가 ByteBuddy 에이전트를 self-attach 할 수 있게 허용 (CI에서 static/final 모킹 이슈 방지)
-	jvmArgs += ['-Djdk.attach.allowAttachSelf=true']
-	// JDK 21+를 쓰는 CI라면 아래 한 줄도 고려
-	// jvmArgs += ['-XX:+EnableDynamicAgentLoading']
-}

src/main/java/akuma/whiplash/global/config/sentry/SentryConfig.java

@@ -0,0 +1,32 @@
+package akuma.whiplash.global.config.sentry;
+
+import io.sentry.SentryOptions;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class SentryConfig {
+
+    @Bean
+    public SentryOptions.BeforeSendCallback beforeSendCallback() {
+        return (event, hint) -> {
+            if (event.getExceptions() != null && !event.getExceptions().isEmpty()) {
+                var ex = event.getExceptions().get(0);
+                if (ex.getType() != null && ex.getType().endsWith("ApplicationException")) {
+                    // 전역 핸들러에서 미리 심어둔 태그
+                    String code = event.getTag("error.code");
+                    if (code != null) {
+                        String originalMessage = ex.getValue(); // 기존 사람이 읽는 메시지
+                        // 타이틀에 반영되는 'type'을 에러코드로 교체
+                        ex.setType(code);
+                        // 부제목(value)은 원래 메시지를 유지(또는 필요 시 축약)
+                        ex.setValue(originalMessage);
+                        // 참고용으로 원본도 extra에 보존
+                        event.setExtra("original.message", originalMessage);
+                    }
+                }
+            }
+            return event;
+        };
+    }
+}

src/main/java/akuma/whiplash/global/exception/GlobalExceptionHandler.java

@@ -1,14 +1,18 @@
 package akuma.whiplash.global.exception;
 
+import akuma.whiplash.global.log.LogUtils;
 import akuma.whiplash.global.response.ApplicationResponse;
 import akuma.whiplash.global.response.code.BaseErrorCode;
 import akuma.whiplash.global.response.code.CommonErrorCode;
+import io.sentry.Sentry;
 import jakarta.servlet.http.HttpServletRequest;
 import jakarta.validation.ConstraintViolation;
 import jakarta.validation.ConstraintViolationException;
 import java.util.LinkedHashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Optional;
+import java.util.stream.Collectors;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpStatus;
@@ -45,6 +49,14 @@ public ResponseEntity<Object> handleMethodArgumentNotValid(
                     (existingErrorMessage, newErrorMessage) -> existingErrorMessage + ", " + newErrorMessage);
             });
 
+        sendErrorToSentry(
+            e,
+            extractRequestUri(request),
+            LogUtils.maskSensitiveQuery(extractQueryString(request)),
+            CommonErrorCode.METHOD_ARGUMENT_NOT_VALID.getCustomCode(),
+            CommonErrorCode.METHOD_ARGUMENT_NOT_VALID.getHttpStatus()
+        );
+
         return handleExceptionInternalArgs(
             e,
             request,
@@ -59,6 +71,18 @@ public ResponseEntity<Object> validation(ConstraintViolationException e, WebRequ
             .findFirst()
             .orElseThrow(() -> new RuntimeException("ConstraintViolationException Error"));
 
+        sendErrorToSentry(
+            e,
+            extractRequestUri(request),
+            LogUtils.maskSensitiveQuery(
+                e.getConstraintViolations().stream()
+                    .map(v -> v.getPropertyPath() + "=" + v.getInvalidValue())
+                    .collect(Collectors.joining(", "))
+            ),
+            errorMessage,
+            CommonErrorCode.METHOD_ARGUMENT_NOT_VALID.getHttpStatus()
+            );
+
         return handleExceptionInternalConstraint(e, CommonErrorCode.valueOf(errorMessage), request);
     }
 
@@ -74,13 +98,30 @@ protected ResponseEntity<Object> handleHttpMessageNotReadable(
             CommonErrorCode.METHOD_ARGUMENT_NOT_VALID.getCustomCode(),
             CommonErrorCode.METHOD_ARGUMENT_NOT_VALID.getMessage()
         );
+
+        sendErrorToSentry(
+            ex,
+            extractRequestUri(request),
+            LogUtils.maskSensitiveQuery(extractQueryString(request)),
+            CommonErrorCode.METHOD_ARGUMENT_NOT_VALID.getCustomCode(),
+            CommonErrorCode.METHOD_ARGUMENT_NOT_VALID.getHttpStatus()
+        );
+
         return new ResponseEntity<>(response, HttpStatus.BAD_REQUEST);
     }
 
     @ExceptionHandler
     public ResponseEntity<Object> exception(Exception e, WebRequest request) {
         log.error("Unexpected error: ", e);
 
+        sendErrorToSentry(
+            e,
+            request.getDescription(false),
+            request.getParameterMap().toString(),
+            CommonErrorCode.INTERNAL_SERVER_ERROR.getCustomCode(),
+            CommonErrorCode.INTERNAL_SERVER_ERROR.getHttpStatus()
+        );
+
         return handleExceptionInternalFalse(
             e,
             CommonErrorCode.INTERNAL_SERVER_ERROR.getHttpStatus(),
@@ -90,10 +131,18 @@ public ResponseEntity<Object> exception(Exception e, WebRequest request) {
     }
 
     @ExceptionHandler(value = ApplicationException.class)
-    public ResponseEntity<Object> onThrowException(ApplicationException applicationException, HttpServletRequest request) {
-        BaseErrorCode baseErrorCode = applicationException.getCode();
+    public ResponseEntity<Object> onThrowException(ApplicationException ex, HttpServletRequest request) {
+        BaseErrorCode baseErrorCode = ex.getCode();
 
-        return handleExceptionInternal(applicationException, baseErrorCode, null, request);
+        sendErrorToSentry(
+            ex,
+            request.getRequestURI(),
+            LogUtils.maskSensitiveQuery(request.getQueryString()),
+            baseErrorCode.getCustomCode(),
+            baseErrorCode.getHttpStatus()
+        );
+
+        return handleExceptionInternal(ex, baseErrorCode, null, request);
     }
 
     private ResponseEntity<Object> handleExceptionInternal(
@@ -179,4 +228,40 @@ private ResponseEntity<Object> handleExceptionInternalConstraint(
             request
         );
     }
+
+    private static String extractRequestUri(WebRequest request) {
+        if (request instanceof ServletWebRequest servletWebRequest) {
+            return servletWebRequest.getRequest().getRequestURI();
+        }
+        String desc = request.getDescription(false); // ex: "uri=/api/alarms/100/checkin"
+        if (desc != null && desc.startsWith("uri=")) return desc.substring(4);
+        return desc;
+    }
+
+    private static String extractQueryString(WebRequest request) {
+        if (request instanceof ServletWebRequest servletWebRequest) {
+            return servletWebRequest.getRequest().getQueryString();
+        }
+        return null;
+    }
+
+    private static void sendErrorToSentry(Exception ex, String requestUri, String queryString, String errorCode, HttpStatus status) {
+        if (status.is5xxServerError()) {
+            Sentry.withScope(scope -> {
+                scope.setTransaction(requestUri);
+                scope.setTag("path", requestUri);
+
+                if (errorCode != null && !errorCode.isBlank()) {
+                    scope.setTag("error.code", errorCode);
+                    scope.setFingerprint(List.of(errorCode));
+                }
+
+                if (queryString != null && !queryString.isBlank()) {
+                    scope.setExtra("query", queryString);
+                }
+
+                Sentry.captureException(ex);
+            });
+        }
+    }
 }