feat: 예외 처리 강화

ImGdevel · ImGdevel · commit e66cfe242d75 · 2025-08-16T14:40:51.000+09:00
diff --git a/ProjectVG.Api/Controllers/TestController.cs b/ProjectVG.Api/Controllers/TestController.cs
@@ -0,0 +1,73 @@
+using Microsoft.AspNetCore.Mvc;
+using ProjectVG.Common.Exceptions;
+using ProjectVG.Common.Constants;
+
+namespace ProjectVG.Api.Controllers
+{
+    [ApiController]
+    [Route("api/v1/test")]
+    public class TestController : ControllerBase
+    {
+        private readonly ILogger<TestController> _logger;
+
+        public TestController(ILogger<TestController> logger)
+        {
+            _logger = logger;
+        }
+
+        [HttpGet("exceptions/{type}")]
+        public IActionResult TestException(string type)
+        {
+            return type.ToLowerInvariant() switch
+            {
+                "validation" => throw new ValidationException(ErrorCode.VALIDATION_FAILED, "유효성 검사 실패"),
+                "notfound" => throw new NotFoundException(ErrorCode.NOT_FOUND, "리소스를 찾을 수 없습니다"),
+                "projectvg" => throw new ProjectVGException(ErrorCode.BAD_REQUEST, "ProjectVG 예외 테스트"),
+                "external" => throw new ExternalServiceException("테스트서비스", "http://test.com/api", "외부 서비스 오류", ErrorCode.EXTERNAL_SERVICE_ERROR),
+                "argument" => throw new ArgumentException("잘못된 인수입니다"),
+                "invalidoperation" => throw new InvalidOperationException("잘못된 작업입니다"),
+                "unauthorized" => throw new UnauthorizedAccessException("권한이 없습니다"),
+                "timeout" => throw new TimeoutException("타임아웃이 발생했습니다"),
+                "httprequest" => throw new HttpRequestException("HTTP 요청 오류"),
+                "keynotfound" => throw new KeyNotFoundException("키를 찾을 수 없습니다"),
+                "nullref" => throw new NullReferenceException("널 참조 오류"),
+                "divide" => throw new DivideByZeroException("0으로 나누기 오류"),
+                "index" => throw new IndexOutOfRangeException("인덱스 범위 오류"),
+                "format" => throw new FormatException("형식 오류"),
+                "overflow" => throw new OverflowException("오버플로우 오류"),
+                "notimplemented" => throw new NotImplementedException("구현되지 않은 기능"),
+                "notsupported" => throw new NotSupportedException("지원되지 않는 기능"),
+                "objectdisposed" => throw new ObjectDisposedException("TestObject", "이미 해제된 객체입니다"),
+                "aggregate" => throw new AggregateException(new Exception[] { new ArgumentException("인수 오류"), new InvalidOperationException("작업 오류") }),
+                _ => throw new ProjectVGException(ErrorCode.BAD_REQUEST, $"알 수 없는 예외 타입: {type}")
+            };
+        }
+
+        [HttpGet("db-exceptions/{type}")]
+        public IActionResult TestDbException(string type)
+        {
+            // 실제 DB 예외는 테스트하기 어려우므로 시뮬레이션
+            return type.ToLowerInvariant() switch
+            {
+                "duplicate" => throw new InvalidOperationException("Cannot insert duplicate key row in object 'dbo.Users' with unique index 'IX_Users_Username'"),
+                "foreignkey" => throw new InvalidOperationException("The DELETE statement conflicted with the REFERENCE constraint \"FK_Users_Characters\"."),
+                "constraint" => throw new InvalidOperationException("The INSERT statement conflicted with the CHECK constraint \"CK_Users_Email\"."),
+                _ => throw new InvalidOperationException("데이터베이스 오류 시뮬레이션")
+            };
+        }
+
+        [HttpGet("performance/{delay}")]
+        public async Task<IActionResult> TestPerformance(int delay = 1000)
+        {
+            await Task.Delay(delay);
+            return Ok(new { message = $"지연 시간 {delay}ms 완료", timestamp = DateTime.UtcNow });
+        }
+
+        [HttpGet("memory/{size}")]
+        public IActionResult TestMemory(int size = 1024)
+        {
+            var data = new byte[size * 1024]; // KB 단위
+            return Ok(new { message = $"{size}KB 메모리 할당 완료", actualSize = data.Length });
+        }
+    }
+}
diff --git a/ProjectVG.Api/Filters/ModelStateValidationFilter.cs b/ProjectVG.Api/Filters/ModelStateValidationFilter.cs
@@ -0,0 +1,16 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Filters;
+
+namespace ProjectVG.Api.Filters
+{
+    public class ModelStateValidationFilter : ActionFilterAttribute
+    {
+        public override void OnActionExecuting(ActionExecutingContext context)
+        {
+            if (!context.ModelState.IsValid)
+            {
+                context.Result = new BadRequestObjectResult(context.ModelState);
+            }
+        }
+    }
+}
diff --git a/ProjectVG.Api/Middleware/GlobalExceptionHandler.cs b/ProjectVG.Api/Middleware/GlobalExceptionHandler.cs
@@ -2,18 +2,21 @@
 using System.Text.Json;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.AspNetCore.Mvc;
+using ProjectVG.Common.Exceptions;
 
 namespace ProjectVG.Api.Middleware
 {
     public class GlobalExceptionHandler
     {
         private readonly RequestDelegate _next;
         private readonly ILogger<GlobalExceptionHandler> _logger;
+        private readonly IWebHostEnvironment _environment;
 
-        public GlobalExceptionHandler(RequestDelegate next, ILogger<GlobalExceptionHandler> logger)
+        public GlobalExceptionHandler(RequestDelegate next, ILogger<GlobalExceptionHandler> logger, IWebHostEnvironment environment)
         {
             _next = next;
             _logger = logger;
+            _environment = environment;
         }
 
         public async Task InvokeAsync(HttpContext context)
@@ -37,15 +40,16 @@ private async Task HandleExceptionAsync(HttpContext context, Exception exception
 
             var jsonResponse = JsonSerializer.Serialize(errorResponse, new JsonSerializerOptions
             {
-                PropertyNamingPolicy = JsonNamingPolicy.CamelCase
+                PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+                WriteIndented = _environment.IsDevelopment()
             });
 
             await context.Response.WriteAsync(jsonResponse);
         }
 
         private ErrorResponse CreateErrorResponse(Exception exception, HttpContext context)
         {
-            if (exception is ValidationException validationEx)
+            if (exception is ProjectVG.Common.Exceptions.ValidationException validationEx)
             {
                 return HandleValidationException(validationEx, context);
             }
@@ -75,6 +79,31 @@ private ErrorResponse CreateErrorResponse(Exception exception, HttpContext conte
                 return HandleKeyNotFoundException(keyNotFoundEx, context);
             }
             
+            if (exception is ArgumentException argumentEx)
+            {
+                return HandleArgumentException(argumentEx, context);
+            }
+            
+            if (exception is InvalidOperationException invalidOpEx)
+            {
+                return HandleInvalidOperationException(invalidOpEx, context);
+            }
+            
+            if (exception is UnauthorizedAccessException unauthorizedEx)
+            {
+                return HandleUnauthorizedAccessException(unauthorizedEx, context);
+            }
+            
+            if (exception is TimeoutException timeoutEx)
+            {
+                return HandleTimeoutException(timeoutEx, context);
+            }
+            
+            if (exception is HttpRequestException httpEx)
+            {
+                return HandleHttpRequestException(httpEx, context);
+            }
+            
             return HandleGenericException(exception, context);
         }
 
@@ -140,23 +169,38 @@ private ErrorResponse HandleExternalServiceException(ExternalServiceException ex
 
         private ErrorResponse HandleDbUpdateException(DbUpdateException exception, HttpContext context)
         {
-            if (exception.InnerException?.Message.Contains("duplicate") == true)
+            var innerMessage = exception.InnerException?.Message?.ToLowerInvariant() ?? string.Empty;
+            
+            if (innerMessage.Contains("duplicate") || innerMessage.Contains("unique"))
             {
                 _logger.LogWarning(exception, "데이터베이스 중복 키 오류 발생");
                 return new ErrorResponse
                 {
-                    ErrorCode = "리소스_중복",
+                    ErrorCode = "RESOURCE_CONFLICT",
                     Message = "이미 존재하는 데이터입니다",
                     StatusCode = 409,
                     Timestamp = DateTime.UtcNow,
                     TraceId = context.TraceIdentifier
                 };
             }
             
+            if (innerMessage.Contains("foreign key") || innerMessage.Contains("constraint"))
+            {
+                _logger.LogWarning(exception, "데이터베이스 제약 조건 위반");
+                return new ErrorResponse
+                {
+                    ErrorCode = "CONSTRAINT_VIOLATION",
+                    Message = "관련 데이터가 존재하여 삭제할 수 없습니다",
+                    StatusCode = 400,
+                    Timestamp = DateTime.UtcNow,
+                    TraceId = context.TraceIdentifier
+                };
+            }
+            
             _logger.LogError(exception, "데이터베이스 업데이트 오류 발생");
             return new ErrorResponse
             {
-                ErrorCode = "데이터베이스_오류",
+                ErrorCode = "DATABASE_ERROR",
                 Message = "데이터베이스 처리 중 오류가 발생했습니다",
                 StatusCode = (int)HttpStatusCode.InternalServerError,
                 Timestamp = DateTime.UtcNow,
@@ -170,26 +214,105 @@ private ErrorResponse HandleKeyNotFoundException(KeyNotFoundException exception,
             
             return new ErrorResponse
             {
-                ErrorCode = "리소스_찾을_수_없음",
+                ErrorCode = "RESOURCE_NOT_FOUND",
                 Message = exception.Message,
                 StatusCode = (int)HttpStatusCode.NotFound,
                 Timestamp = DateTime.UtcNow,
                 TraceId = context.TraceIdentifier
             };
         }
 
+        private ErrorResponse HandleArgumentException(ArgumentException exception, HttpContext context)
+        {
+            _logger.LogWarning(exception, "잘못된 인수: {Message}", exception.Message);
+            
+            return new ErrorResponse
+            {
+                ErrorCode = "INVALID_ARGUMENT",
+                Message = "잘못된 요청 파라미터입니다",
+                StatusCode = (int)HttpStatusCode.BadRequest,
+                Timestamp = DateTime.UtcNow,
+                TraceId = context.TraceIdentifier,
+                Details = _environment.IsDevelopment() ? new List<string> { exception.Message } : null
+            };
+        }
+
+        private ErrorResponse HandleInvalidOperationException(InvalidOperationException exception, HttpContext context)
+        {
+            _logger.LogWarning(exception, "잘못된 작업: {Message}", exception.Message);
+            
+            return new ErrorResponse
+            {
+                ErrorCode = "INVALID_OPERATION",
+                Message = "요청한 작업을 수행할 수 없습니다",
+                StatusCode = (int)HttpStatusCode.BadRequest,
+                Timestamp = DateTime.UtcNow,
+                TraceId = context.TraceIdentifier,
+                Details = _environment.IsDevelopment() ? new List<string> { exception.Message } : null
+            };
+        }
+
+        private ErrorResponse HandleUnauthorizedAccessException(UnauthorizedAccessException exception, HttpContext context)
+        {
+            _logger.LogWarning(exception, "권한 없음: {Message}", exception.Message);
+            
+            return new ErrorResponse
+            {
+                ErrorCode = "UNAUTHORIZED",
+                Message = "접근 권한이 없습니다",
+                StatusCode = (int)HttpStatusCode.Unauthorized,
+                Timestamp = DateTime.UtcNow,
+                TraceId = context.TraceIdentifier
+            };
+        }
+
+        private ErrorResponse HandleTimeoutException(TimeoutException exception, HttpContext context)
+        {
+            _logger.LogWarning(exception, "타임아웃 발생: {Message}", exception.Message);
+            
+            return new ErrorResponse
+            {
+                ErrorCode = "TIMEOUT",
+                Message = "요청 처리 시간이 초과되었습니다",
+                StatusCode = (int)HttpStatusCode.RequestTimeout,
+                Timestamp = DateTime.UtcNow,
+                TraceId = context.TraceIdentifier
+            };
+        }
+
+        private ErrorResponse HandleHttpRequestException(HttpRequestException exception, HttpContext context)
+        {
+            _logger.LogError(exception, "HTTP 요청 오류: {Message}", exception.Message);
+            
+            return new ErrorResponse
+            {
+                ErrorCode = "HTTP_REQUEST_ERROR",
+                Message = "외부 서비스와의 통신 중 오류가 발생했습니다",
+                StatusCode = (int)HttpStatusCode.BadGateway,
+                Timestamp = DateTime.UtcNow,
+                TraceId = context.TraceIdentifier
+            };
+        }
+
         private ErrorResponse HandleGenericException(Exception exception, HttpContext context)
         {
-            _logger.LogError(exception, "예상치 못한 예외 발생: {ExceptionType} - {Message}", 
-                exception.GetType().Name, exception.Message);
+            var exceptionType = exception.GetType().Name;
+            var isDevelopment = _environment.IsDevelopment();
+            
+            _logger.LogError(exception, "예상치 못한 예외 발생: {ExceptionType} - {Message}", exceptionType, exception.Message);
             
             return new ErrorResponse
             {
-                ErrorCode = "내부_서버_오류",
-                Message = "서버에서 예상치 못한 오류가 발생했습니다",
+                ErrorCode = "INTERNAL_SERVER_ERROR",
+                Message = isDevelopment ? exception.Message : "서버에서 예상치 못한 오류가 발생했습니다",
                 StatusCode = (int)HttpStatusCode.InternalServerError,
                 Timestamp = DateTime.UtcNow,
-                TraceId = context.TraceIdentifier
+                TraceId = context.TraceIdentifier,
+                Details = isDevelopment ? new List<string> 
+                { 
+                    $"Exception Type: {exceptionType}",
+                    $"Stack Trace: {exception.StackTrace}"
+                } : null
             };
         }
     }
diff --git a/ProjectVG.Api/Program.cs b/ProjectVG.Api/Program.cs
@@ -14,6 +14,7 @@
 using ProjectVG.Api.Configuration;
 using ProjectVG.Api.Services;
 using ProjectVG.Api.Middleware;
+using ProjectVG.Api.Filters;
 using ProjectVG.Infrastructure.Realtime.WebSocketConnection;
 using ProjectVG.Application.Services.Messaging;
 using ProjectVG.Common.Models.Session;
@@ -30,7 +31,10 @@
 builder.Configuration.AddEnvironmentVariableSubstitution(builder.Configuration);
 
 // Add services to the container.
-builder.Services.AddControllers();
+builder.Services.AddControllers(options =>
+{
+    options.Filters.Add<ModelStateValidationFilter>();
+});
 builder.Services.AddEndpointsApiExplorer();
 builder.Services.AddSwaggerGen(c => {
     c.SwaggerDoc("v1", new Microsoft.OpenApi.Models.OpenApiInfo {
