시나리오: 기업용 웹 API 개발

당신은 기업용 웹 API를 개발하고 있어. 이 API는 다음과 같은 요구사항을 가지고 있어:

1. 모든 API 요청/응답 로깅
2. API 키 기반 인증
3. 요청 속도 제한(Rate Limiting)
4. 일관된 오류 응답 형식
5. 응답 데이터 표준화
6. 성능 모니터링

이 요구사항을 필터를 사용해 구현해보자!

1. API 요청/응답 로깅 필터

public class ApiLoggingFilterAttribute : ActionFilterAttribute
{
    private readonly ILogger _logger;
    private Stopwatch _stopwatch;
    
    public ApiLoggingFilterAttribute(ILogger<ApiLoggingFilterAttribute> logger)
    {
        _logger = logger;
    }
    
    public override void OnActionExecuting(ActionExecutingContext context)
    {
        _stopwatch = Stopwatch.StartNew();
        
        var request = context.HttpContext.Request;
        var requestBody = GetRequestBody(request);
        
        _logger.LogInformation(
            $"API 요청: {request.Method} {request.Path} - 본문: {requestBody}");
    }
    
    public override void OnActionExecuted(ActionExecutedContext context)
    {
        _stopwatch.Stop();
        
        var statusCode = context.HttpContext.Response.StatusCode;
        var responseBody = GetResponseBody(context);
        
        _logger.LogInformation(
            $"API 응답: 상태 코드 {statusCode} - 본문: {responseBody} - 소요 시간: {_stopwatch.ElapsedMilliseconds}ms");
    }
    
    private string GetRequestBody(HttpRequest request)
    {
        // 요청 본문 읽기 로직
        return "[요청 본문]";
    }
    
    private string GetResponseBody(ActionExecutedContext context)
    {
        // 응답 본문 읽기 로직
        return "[응답 본문]";
    }
}
        

2. API 키 인증 필터

public class ApiKeyAuthFilterAttribute : Attribute, IAuthorizationFilter
{
    private const string API_KEY_HEADER = "X-API-Key";
    
    private readonly IApiKeyService _apiKeyService;
    
    public ApiKeyAuthFilterAttribute(IApiKeyService apiKeyService)
    {
        _apiKeyService = apiKeyService;
    }
    
    public void OnAuthorization(AuthorizationFilterContext context)
    {
        // API 키 헤더 확인
        if (!context.HttpContext.Request.Headers.TryGetValue(
            API_KEY_HEADER, out var apiKeyValue))
        {
            SetUnauthorizedResult(context, "API 키가 필요합니다.");
            return;
        }
        
        var apiKey = apiKeyValue.ToString();
        
        // API 키 유효성 검사
        if (!_apiKeyService.IsValidApiKey(apiKey))
        {
            SetUnauthorizedResult(context, "유효하지 않은 API 키입니다.");
            return;
        }
        
        // 선택적: API 키에 연결된 사용자 정보 설정
        var user = _apiKeyService.GetUserForApiKey(apiKey);
        if (user != null)
        {
            var identity = new ClaimsIdentity(new[]
            {
                new Claim(ClaimTypes.Name, user.Username),
                new Claim(ClaimTypes.Role, user.Role)
            }, "ApiKey");
            
            context.HttpContext.User = new ClaimsPrincipal(identity);
        }
    }
    
    private void SetUnauthorizedResult(
        AuthorizationFilterContext context, string message)
    {
        context.Result = new ObjectResult(new
        {
            Error = message
        })
        {
            StatusCode = StatusCodes.Status401Unauthorized
        };
    }
}
        

3. 요청 속도 제한 필터

public class RateLimitFilterAttribute : ActionFilterAttribute
{
    private readonly IRateLimitService _rateLimitService;
    
    public RateLimitFilterAttribute(IRateLimitService rateLimitService)
    {
        _rateLimitService = rateLimitService;
    }
    
    public override void OnActionExecuting(ActionExecutingContext context)
    {
        var clientIp = context.HttpContext.Connection.RemoteIpAddress.ToString();
        
        // API 키가 있으면 사용
        if (context.HttpContext.Request.Headers.TryGetValue(
            "X-API-Key", out var apiKey))
        {
            clientIp = apiKey.ToString(); // API 키로 클라이언트 식별
        }
        
        if (!_rateLimitService.IsAllowed(clientIp))
        {
            context.Result = new ObjectResult(new
            {
                Error = "요청 한도를 초과했습니다. 잠시 후 다시 시도하세요."
            })
            {
                StatusCode = StatusCodes.Status429TooManyRequests
            };
        }
    }
}
        

4. 예외 처리 필터

public class ApiExceptionFilterAttribute : ExceptionFilterAttribute
{
    private readonly ILogger _logger;
    private readonly IHostEnvironment _env;
    
    public ApiExceptionFilterAttribute(
        ILogger<ApiExceptionFilterAttribute> logger,
        IHostEnvironment env)
    {
        _logger = logger;
        _env = env;
    }
    
    public override void OnException(ExceptionContext context)
    {
        _logger.LogError(context.Exception, 
            $"API 예외: {context.Exception.Message}");
        
        var apiError = new ApiErrorResponse
        {
            TraceId = Activity.Current?.Id ?? context.HttpContext.TraceIdentifier,
            Message = GetUserFriendlyMessage(context.Exception)
        };
        
        // 개발 환경에서만 상세 정보 추가
        if (_env.IsDevelopment())
        {
            apiError.Detail = context.Exception.ToString();
            apiError.StackTrace = context.Exception.StackTrace;
        }
        
        // 예외 유형에 따라 상태 코드 설정
        var statusCode = GetStatusCodeForException(context.Exception);
        
        context.Result = new ObjectResult(apiError)
        {
            StatusCode = statusCode
        };
        
        context.ExceptionHandled = true;
    }
    
    private int GetStatusCodeForException(Exception exception)
    {
        // 예외 유형에 따라 적절한 HTTP 상태 코드 반환
        return exception switch
        {
            NotFoundException => StatusCodes.Status404NotFound,
            ValidationException => StatusCodes.Status400BadRequest,
            UnauthorizedException => StatusCodes.Status401Unauthorized,
            ForbiddenException => StatusCodes.Status403Forbidden,
            _ => StatusCodes.Status500InternalServerError
        };
    }
    
    private string GetUserFriendlyMessage(Exception exception)
    {
        // 사용자 친화적인 오류 메시지 반환
        return exception switch
        {
            NotFoundException => "요청한 리소스를 찾을 수 없습니다.",
            ValidationException => "입력 데이터가 유효하지 않습니다.",
            UnauthorizedException => "인증이 필요합니다.",
            ForbiddenException => "이 작업을 수행할 권한이 없습니다.",
            _ => "요청을 처리하는 중 오류가 발생했습니다."
        };
    }
    
    private class ApiErrorResponse
    {
        public string TraceId { get; set; }
        public string Message { get; set; }
        public string Detail { get; set; }
        public string StackTrace { get; set; }
    }
}
        

5. 응답 래퍼 필터

public class ApiResponseWrapperAttribute : ResultFilterAttribute
{
    public override void OnResultExecuting(ResultExecutingContext context)
    {
        if (context.Result is ObjectResult objectResult)
        {
            // 이미 ApiResponse로 래핑된 경우 건너뛰기
            if (objectResult.Value is ApiResponse)
            {
                return;
            }
            
            var apiResponse = new ApiResponse
            {
                Success = true,
                Data = objectResult.Value,
                StatusCode = objectResult.StatusCode ?? 200,
                Timestamp = DateTime.UtcNow
            };
            
            objectResult.Value = apiResponse;
        }
    }
    
    public class ApiResponse
    {
        public bool Success { get; set; }
        public object Data { get; set; }
        public int StatusCode { get; set; }
        public DateTime Timestamp { get; set; }
    }
}
        

6. 성능 모니터링 필터

public class PerformanceMonitorFilterAttribute : ActionFilterAttribute
{
    private readonly ILogger _logger;
    private readonly IPerformanceMetricsService _metricsService;
    private Stopwatch _stopwatch;
    private string _actionName;
    
    public PerformanceMonitorFilterAttribute(
        ILogger<PerformanceMonitorFilterAttribute> logger,
        IPerformanceMetricsService metricsService)
    {
        _logger = logger;
        _metricsService = metricsService;
    }
    
    public override void OnActionExecuting(ActionExecutingContext context)
    {
        _stopwatch = Stopwatch.StartNew();
        _actionName = context.ActionDescriptor.DisplayName;
    }
    
    public override void OnActionExecuted(ActionExecutedContext context)
    {
        _stopwatch.Stop();
        var elapsedMs = _stopwatch.ElapsedMilliseconds;
        
        // 메트릭 기록
        _metricsService.RecordApiCallDuration(_actionName, elapsedMs);
        
        // 임계값 초과 시 경고 로그
        if (elapsedMs > 500) // 500ms 이상 걸리면 경고
        {
            _logger.LogWarning(
                $"성능 경고: {_actionName}이(가) {elapsedMs}ms 걸림");
        }
    }
}
        

필터 등록 및 적용

이제 이 필터들을 등록하고 적용해보자:

// Startup.cs의 ConfigureServices 메서드
public void ConfigureServices(IServiceCollection services)
{
    // 필요한 서비스 등록
    services.AddSingleton<IApiKeyService, ApiKeyService>();
    services.AddSingleton<IRateLimitService, RateLimitService>();
    services.AddSingleton<IPerformanceMetricsService, PerformanceMetricsService>();
    
    // 필터 등록
    services.AddScoped<ApiLoggingFilterAttribute>();
    services.AddScoped<ApiKeyAuthFilterAttribute>();
    services.AddScoped<RateLimitFilterAttribute>();
    services.AddScoped<ApiExceptionFilterAttribute>();
    services.AddScoped<ApiResponseWrapperAttribute>();
    services.AddScoped<PerformanceMonitorFilterAttribute>();
    
    services.AddControllers(options =>
    {
        // 전역 필터 등록
        options.Filters.AddService<ApiExceptionFilterAttribute>();
        options.Filters.AddService<ApiResponseWrapperAttribute>();
    });
}
        

컨트롤러 예제

[ApiController]
[Route("api/[controller]")]
[ServiceFilter(typeof(ApiLoggingFilterAttribute))]
[ServiceFilter(typeof(ApiKeyAuthFilterAttribute))]
[ServiceFilter(typeof(RateLimitFilterAttribute))]
[ServiceFilter(typeof(PerformanceMonitorFilterAttribute))]
public class ProductsController : ControllerBase
{
    private readonly IProductService _productService;
    
    public ProductsController(IProductService productService)
    {
        _productService = productService;
    }
    
    [HttpGet]
    public async Task<IActionResult> GetProducts()
    {
        var products = await _productService.GetAllProductsAsync();
        return Ok(products);
    }
    
    [HttpGet("{id}")]
    public async Task<IActionResult> GetProduct(int id)
    {
        var product = await _productService.GetProductByIdAsync(id);
        
        if (product == null)
        {
            throw new NotFoundException($"상품 ID {id}를 찾을 수 없습니다.");
        }
        
        return Ok(product);
    }
    
    [HttpPost]
    public async Task<IActionResult> CreateProduct(ProductCreateDto dto)
    {
        if (!ModelState.IsValid)
        {
            throw new ValidationException("상품 데이터가 유효하지 않습니다.");
        }
        
        var product = await _productService.CreateProductAsync(dto);
        return CreatedAtAction(nameof(GetProduct), new { id = product.Id }, product);
    }
}