Error Handling and Retries

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

{
  "error": {
    "code": "RESOURCE_NOT_FOUND",
    "message": "The requested resource was not found.",
    "details": "User with ID 12345 does not exist.",
    "timestamp": "2023-06-15T08:42:15Z",
    "requestId": "req-123456",
    "path": "/api/users/12345",
    "status": 404,
    "fields": [
      {
        "name": "userId",
        "reason": "not_found"
      }
    ]
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

// Java Spring Boot 예시
@PostMapping("/users")
public ResponseEntity<User> createUser(@Valid @RequestBody UserRequest userRequest) {
    // @Valid 어노테이션이 유효성 검사를 처리합니다.
    // 유효하지 않은 경우 MethodArgumentNotValidException이 발생합니다.
    User user = userService.createUser(userRequest);
    return ResponseEntity.status(HttpStatus.CREATED).body(user);
}

// 전역 예외 처리기
@ControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<ErrorResponse> handleValidationExceptions(
            MethodArgumentNotValidException ex) {
        
        List<FieldError> fieldErrors = ex.getBindingResult().getFieldErrors();
        List<Map<String, String>> fields = fieldErrors.stream()
            .map(err -> Map.of(
                "name", err.getField(),
                "reason", err.getDefaultMessage()
            ))
            .collect(Collectors.toList());
        
        ErrorResponse errorResponse = new ErrorResponse(
            "VALIDATION_ERROR",
            "입력 데이터 유효성 검사에 실패했습니다.",
            "하나 이상의 필드가 유효하지 않습니다.",
            ZonedDateTime.now(),
            UUID.randomUUID().toString(),
            ex.getRequest().getRequestURI(),
            HttpStatus.BAD_REQUEST.value(),
            fields
        );
        
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(errorResponse);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

// 사용자 정의 예외 클래스
public class ResourceNotFoundException extends RuntimeException {
    private final String resourceType;
    private final String resourceId;
    
    public ResourceNotFoundException(String resourceType, String resourceId) {
        super(String.format("%s with ID %s not found", resourceType, resourceId));
        this.resourceType = resourceType;
        this.resourceId = resourceId;
    }
    
    // getters…
}

// 서비스 레이어
@Service
public class UserService {
    public User getUserById(String userId) {
        return userRepository.findById(userId)
            .orElseThrow(() -> new ResourceNotFoundException("User", userId));
    }
}

// 전역 예외 처리기에 추가
@ExceptionHandler(ResourceNotFoundException.class)
public ResponseEntity<ErrorResponse> handleResourceNotFoundException(
        ResourceNotFoundException ex, HttpServletRequest request) {
    
    ErrorResponse errorResponse = new ErrorResponse(
        "RESOURCE_NOT_FOUND",
        ex.getMessage(),
        null,
        ZonedDateTime.now(),
        UUID.randomUUID().toString(),
        request.getRequestURI(),
        HttpStatus.NOT_FOUND.value(),
        null
    );
    
    return ResponseEntity.status(HttpStatus.NOT_FOUND).body(errorResponse);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

@Service
public class OrderService {
    @Transactional
    public Order createOrder(OrderRequest orderRequest) {
        // 전체 작업이 트랜잭션으로 묶여 있어 일부에서 실패하면 모두 롤백됩니다.
        Customer customer = customerRepository.findById(orderRequest.getCustomerId())
            .orElseThrow(() -> new ResourceNotFoundException("Customer", orderRequest.getCustomerId()));
        
        // 재고 확인
        for (OrderItemRequest item : orderRequest.getItems()) {
            Product product = productRepository.findById(item.getProductId())
                .orElseThrow(() -> new ResourceNotFoundException("Product", item.getProductId()));
            
            if (product.getStock() < item.getQuantity()) {
                throw new InsufficientStockException(product.getId(), product.getStock(), item.getQuantity());
            }
        }
        
        // 주문 생성 및 재고 업데이트
        Order order = new Order();
        // …주문 처리 로직…
        
        return orderRepository.save(order);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

@Service
public class PaymentService {
    private static final Logger log = LoggerFactory.getLogger(PaymentService.class);
    
    public PaymentResult processPayment(PaymentRequest request) {
        try {
            // 결제 처리 로직
            log.info("Payment processed successfully for order: {}", request.getOrderId());
            return result;
        } catch (PaymentProviderTemporaryException ex) {
            // 일시적인 오류 - 재시도 가능
            log.warn("Temporary payment provider error: {}. Will retry.", ex.getMessage());
            throw ex;
        } catch (PaymentDeclinedException ex) {
            // 정상적인 비즈니스 거부 - 심각한 오류 아님
            log.info("Payment declined: {}", ex.getMessage());
            throw ex;
        } catch (Exception ex) {
            // 예상치 못한 오류 - 심각한 문제
            log.error("Critical payment processing error", ex);
            throw new PaymentFailedException("Payment processing failed unexpectedly", ex);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// MDC(Mapped Diagnostic Context)를 사용한 로깅
@Component
public class RequestLoggingFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, 
                                  FilterChain filterChain) throws ServletException, IOException {
        // 요청 ID 생성 및 MDC에 추가
        String requestId = UUID.randomUUID().toString();
        MDC.put("requestId", requestId);
        
        // 요청 정보 로깅
        MDC.put("clientIp", request.getRemoteAddr());
        MDC.put("userAgent", request.getHeader("User-Agent"));
        MDC.put("path", request.getRequestURI());
        
        try {
            // 응답 헤더에 요청 ID 추가
            response.setHeader("X-Request-ID", requestId);
            filterChain.doFilter(request, response);
        } finally {
            // MDC 정리
            MDC.clear();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

// Fetch API 사용시 오류 처리
async function fetchUser(userId) {
  try {
    const response = await fetch(`/api/users/${userId}`);
    
    // HTTP 오류 응답 확인
    if (!response.ok) {
      const errorData = await response.json();
      throw new APIError(
        response.status,
        errorData.error.code,
        errorData.error.message,
        errorData.error.requestId
      );
    }
    
    return await response.json();
  } catch (error) {
    if (error instanceof APIError) {
      // API 오류 처리
      console.error(`API Error ${error.status}: ${error.code} - ${error.message}`);
      // 사용자에게 적절한 메시지 표시
      displayErrorMessage(error.userFriendlyMessage);
    } else {
      // 네트워크 오류 등 다른 예외 처리
      console.error('Network or unknown error:', error);
      displayErrorMessage('네트워크 연결을 확인해 주세요.');
    }
    throw error; // 필요한 경우 상위 레벨로 오류 전파
  }
}

// 사용자 정의 API 오류 클래스
class APIError extends Error {
  constructor(status, code, message, requestId) {
    super(message);
    this.name = 'APIError';
    this.status = status;
    this.code = code;
    this.requestId = requestId;
    this.userFriendlyMessage = this.getUserFriendlyMessage();
  }
  
  getUserFriendlyMessage() {
    // 오류 코드에 따른 사용자 친화적 메시지 반환
    switch (this.code) {
      case 'RESOURCE_NOT_FOUND':
        return '요청하신 정보를 찾을 수 없습니다.';
      case 'VALIDATION_ERROR':
        return '입력한 정보가 유효하지 않습니다.';
      case 'UNAUTHORIZED':
        return '이 작업을 수행하기 위한 권한이 없습니다.';
      default:
        return '요청을 처리하는 중 오류가 발생했습니다. 나중에 다시 시도해 주세요.';
    }
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

async function handleAPIResponse(response) {
  // 응답 본문 파싱
  let data;
  let errorData;
  
  try {
    // 응답이 JSON인지 확인
    const contentType = response.headers.get('Content-Type');
    if (contentType && contentType.includes('application/json')) {
      data = await response.json();
    } else {
      data = await response.text();
    }
  } catch (error) {
    // 응답 본문 파싱 오류
    errorData = { message: 'Invalid response format' };
  }
  
  // 성공적인 응답
  if (response.ok) {
    return data;
  }
  
  // 오류 응답 처리
  switch (response.status) {
    case 400: // Bad Request
      return handleValidationErrors(data);
      
    case 401: // Unauthorized
      // 인증 토큰 갱신 또는 로그인 페이지로 리디렉션
      authService.refreshToken().catch(() => {
        window.location.href = '/login';
      });
      throw new AuthError('Authentication required');
      
    case 403: // Forbidden
      throw new AccessDeniedError('You do not have permission to access this resource');
      
    case 404: // Not Found
      throw new NotFoundError(`The requested resource was not found`);
      
    case 422: // Unprocessable Entity
      return handleValidationErrors(data);
      
    case 429: // Too Many Requests
      // 재시도 지연 설정
      const retryAfter = response.headers.get('Retry-After');
      throw new RateLimitError('Rate limit exceeded', retryAfter);
      
    case 500: // Internal Server Error
    case 502: // Bad Gateway
    case 503: // Service Unavailable
    case 504: // Gateway Timeout
      throw new ServerError('A server error occurred. Please try again later.');
      
    default:
      throw new APIError(`Unknown error: ${response.status}`, data);
  }
}

// 유효성 검사 오류 처리
function handleValidationErrors(data) {
  if (data.error && data.error.fields) {
    // 필드별 오류 메시지 추출
    const fieldErrors = data.error.fields.reduce((acc, field) => {
      acc[field.name] = field.reason;
      return acc;
    }, {});
    
    throw new ValidationError(data.error.message, fieldErrors);
  }
  
  throw new BadRequestError(data.error?.message || 'Invalid request');
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

// React에서의 오류 UI 예시
function UserForm() {
  const [user, setUser] = useState({ name: '', email: '' });
  const [errors, setErrors] = useState({});
  const [isSubmitting, setIsSubmitting] = useState(false);
  const [serverError, setServerError] = useState(null);
  
  async function handleSubmit(event) {
    event.preventDefault();
    setErrors({});
    setServerError(null);
    setIsSubmitting(true);
    
    try {
      // 로컬 유효성 검사
      const validationErrors = validateUser(user);
      if (Object.keys(validationErrors).length > 0) {
        setErrors(validationErrors);
        return;
      }
      
      // API 호출
      const response = await createUser(user);
      
      // 성공 처리
      toast.success('User created successfully!');
      // 리디렉션 또는 다음 단계 처리
      
    } catch (error) {
      if (error instanceof ValidationError) {
        // 필드별 오류 표시
        setErrors(error.fieldErrors);
      } else if (error instanceof ServerError) {
        // 서버 오류 표시
        setServerError('The server is currently unavailable. Please try again later.');
      } else {
        // 일반 오류 표시
        setServerError(error.userFriendlyMessage || 'An unexpected error occurred.');
      }
      
      // 오류 로깅
      logErrorToMonitoringService(error);
    } finally {
      setIsSubmitting(false);
    }
  }
  
  return (
    <form onSubmit={handleSubmit}>
      {serverError && (
        <div className="error-banner">
          <ErrorIcon /> {serverError}
        </div>
      )}
      
      <div className="form-field">
        <label htmlFor="name">Name</label>
        <input
          id="name"
          value={user.name}
          onChange={(e) => setUser({…user, name: e.target.value})}
          className={errors.name ? 'input-error' : ''}
        />
        {errors.name && <div className="field-error">{errors.name}</div>}
      </div>
      
      <div className="form-field">
        <label htmlFor="email">Email</label>
        <input
          id="email"
          type="email"
          value={user.email}
          onChange={(e) => setUser({…user, email: e.target.value})}
          className={errors.email ? 'input-error' : ''}
        />
        {errors.email && <div className="field-error">{errors.email}</div>}
      </div>
      
      <button type="submit" disabled={isSubmitting}>
        {isSubmitting ? 'Creating…' : 'Create User'}
      </button>
    </form>
  );
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

// 오류 복구 옵션을 제공하는 컴포넌트 예시
function PaymentErrorHandler({ error, onRetry, onAlternativeMethod }) {
  // 오류 유형에 따른 대응
  switch (error.code) {
    case 'PAYMENT_DECLINED':
      return (
        <ErrorCard>
          <h3>결제가 거부되었습니다</h3>
          <p>카드 발급사에서 이 거래를 거부했습니다. 다음 중 하나를 시도해 보세요:</p>
          <ul>
            <li>카드 정보가 올바른지 확인하세요</li>
            <li>충분한 잔액이 있는지 확인하세요</li>
            <li>다른 카드로 시도하세요</li>
          </ul>
          <ButtonGroup>
            <Button primary onClick={onRetry}>다시 시도</Button>
            <Button secondary onClick={onAlternativeMethod}>다른 결제 방법</Button>
          </ButtonGroup>
        </ErrorCard>
      );
      
    case 'NETWORK_ERROR':
      return (
        <ErrorCard>
          <h3>연결 오류</h3>
          <p>인터넷 연결에 문제가 있습니다. 네트워크 연결을 확인한 후 다시 시도하세요.</p>
          <ConnectionStatus />
          <Button primary onClick={onRetry}>다시 시도</Button>
        </ErrorCard>
      );
      
    case 'SERVICE_UNAVAILABLE':
      return (
        <ErrorCard>
          <h3>서비스 일시 중단</h3>
          <p>결제 서비스가 현재 일시적으로 사용 불가능합니다. 불편을 드려 죄송합니다.</p>
          <p>현재 시스템 상태: <ServiceStatusIndicator /></p>
          <p>예상 복구 시간: {formatTime(error.estimatedResolutionTime)}</p>
          <ButtonGroup>
            <Button primary onClick={onRetry}>다시 시도</Button>
            <Button secondary onClick={() => saveOrderForLater()}>나중에 완료</Button>
          </ButtonGroup>
        </ErrorCard>
      );
      
    default:
      return (
        <ErrorCard>
          <h3>결제 처리 중 오류가 발생했습니다</h3>
          <p>{error.userFriendlyMessage}</p>
          <Button primary onClick={onRetry}>다시 시도</Button>
        </ErrorCard>
      );
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

// 오류의 재시도 가능성 평가
function isRetryable(error) {
  // 네트워크 오류는 재시도 가능
  if (error.name === 'NetworkError' || error.message.includes('network')) {
    return true;
  }
  
  // API 오류인 경우 상태 코드 확인
  if (error instanceof APIError) {
    // 서버 오류(5xx)는 일반적으로 재시도 가능
    if (error.status >= 500 && error.status < 600) {
      return true;
    }
    
    // 429(Too Many Requests)는 재시도 가능하지만 Retry-After 헤더 준수 필요
    if (error.status === 429) {
      return true;
    }
    
    // 특정 비즈니스 오류 코드가 재시도 가능한지 확인
    if (RETRYABLE_ERROR_CODES.includes(error.code)) {
      return true;
    }
  }
  
  // 특정 데이터베이스 오류 식별
  if (error.code === 'DEADLOCK' || error.code === 'CONNECTION_TIMEOUT') {
    return true;
  }
  
  // 기본적으로 재시도하지 않음
  return false;
}

// 재시도 가능한 비즈니스 오류 코드 목록
const RETRYABLE_ERROR_CODES = [
  'TEMPORARY_OUTAGE',
  'DATABASE_TIMEOUT',
  'RESOURCE_EXHAUSTED',
  'SERVICE_UNAVAILABLE',
  'GATEWAY_TIMEOUT'
];

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

/**
 * 지수 백오프 및 지터를 사용한 재시도 함수
 * @param {Function} operation - 실행할 작업 함수
 * @param {Object} options - 재시도 옵션
 * @returns {Promise} 작업 결과
 */
async function retryWithBackoff(operation, options = {}) {
  const {
    maxRetries = 5,
    baseDelay = 300,
    maxDelay = 30000,
    factor = 2,
    jitter = true,
    retryableErrors = isRetryable
  } = options;
  
  let attempt = 0;
  
  while (true) {
    try {
      return await operation();
    } catch (error) {
      attempt++;
      
      // 최대 재시도 횟수 초과 또는 재시도할 수 없는 오류인 경우
      if (attempt >= maxRetries || !retryableErrors(error)) {
        throw error;
      }
      
      // Retry-After 헤더가 있는 경우 해당 값 사용
      if (error.retryAfter) {
        const retryAfterMs = parseRetryAfter(error.retryAfter);
        await sleep(retryAfterMs);
        continue;
      }
      
      // 지수 백오프 계산
      let delay = Math.min(maxDelay, baseDelay * Math.pow(factor, attempt - 1));
      
      // 지터 추가 (선택 사항)
      if (jitter) {
        // 계산된 지연의 0%~100% 사이의 무작위 값 사이에서 지연 시간 조정
        delay = Math.random() * delay;
      }
      
      console.log(`Retrying after ${delay}ms (attempt ${attempt} of ${maxRetries})`);
      await sleep(delay);
    }
  }
}

// 헬퍼 함수
function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

function parseRetryAfter(retryAfter) {
  // 숫자만 있는 경우 초 단위로 해석
  if (/^\d+$/.test(retryAfter)) {
    return parseInt(retryAfter, 10) * 1000;
  }
  
  // HTTP 날짜 형식인 경우 밀리초로 변환
  const date = new Date(retryAfter);
  return date.getTime() - Date.now();
}

// 사용 예시
async function fetchUserWithRetry(userId) {
  return retryWithBackoff(
    () => fetch(`/api/users/${userId}`).then(res => {
      if (!res.ok) {
        const error = new Error('API request failed');
        error.status = res.status;
        error.retryAfter = res.headers.get('Retry-After');
        throw error;
      }
      return res.json();
    }),
    {
      maxRetries: 3,
      baseDelay: 500,
      retryableErrors: (error) => error.status >= 500 || error.status === 429
    }
  );
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

/**
 * 간단한 서킷 브레이커 구현
 */
class CircuitBreaker {
  constructor(options = {}) {
    this.failureThreshold = options.failureThreshold || 5;
    this.resetTimeout = options.resetTimeout || 30000;
    this.monitorInterval = options.monitorInterval || 5000;
    
    this.state = 'CLOSED';
    this.failureCount = 0;
    this.lastFailureTime = null;
    this.monitors = [];
    
    // 모니터링 간격 설정
    setInterval(() => this.updateState(), this.monitorInterval);
  }
  
  // 상태 업데이트
  updateState() {
    if (this.state === 'OPEN') {
      const now = Date.now();
      if (now - this.lastFailureTime >= this.resetTimeout) {
        // 재설정 시간이 지나면 반열림 상태로 전환
        this.state = 'HALF_OPEN';
        this.notifyMonitors();
      }
    }
  }
  
  // 작업 실행
  async execute(operation) {
    if (this.state === 'OPEN') {
      throw new Error('Circuit is OPEN - operation rejected');
    }
    
    try {
      const result = await operation();
      
      // 성공 시 회로 닫기
      if (this.state === 'HALF_OPEN') {
        this.state = 'CLOSED';
        this.failureCount = 0;
        this.notifyMonitors();
      }
      
      return result;
    } catch (error) {
      // 실패 처리
      this.recordFailure();
      throw error;
    }
  }
  
  // 실패 기록
  recordFailure() {
    this.failureCount++;
    this.lastFailureTime = Date.now();
    
    if (this.state === 'CLOSED' && this.failureCount >= this.failureThreshold) {
      // 실패 임계값 초과 시 회로 열기
      this.state = 'OPEN';
      this.notifyMonitors();
    } else if (this.state === 'HALF_OPEN') {
      // 반열림 상태에서 실패하면 다시 열림 상태로
      this.state = 'OPEN';
      this.notifyMonitors();
    }
  }
  
  // 상태 변경 시 이벤트 발생
  notifyMonitors() {
    this.monitors.forEach(callback => {
      try {
        callback(this.state);
      } catch (error) {
        console.error('Circuit breaker monitor error:', error);
      }
    });
  }
  
  // 상태 변경 이벤트 구독
  onStateChange(callback) {
    this.monitors.push(callback);
    return () => {
      this.monitors = this.monitors.filter(cb => cb !== callback);
    };
  }
}

// 서킷 브레이커 사용 예시
const paymentServiceBreaker = new CircuitBreaker({
  failureThreshold: 3,
  resetTimeout: 10000
});

// 로깅 및 메트릭 수집
paymentServiceBreaker.onStateChange(state => {
  console.log(`Payment service circuit breaker state changed to: ${state}`);
  metrics.recordCircuitBreakerState('payment-service', state);
});

// API 호출 시 서킷 브레이커 적용
async function processPayment(paymentData) {
  try {
    return await paymentServiceBreaker.execute(() => {
      return paymentApiClient.processPayment(paymentData);
    });
  } catch (error) {
    if (error.message.includes('Circuit is OPEN')) {
      // 대체 결제 처리 또는 사용자에게 알림
      return fallbackPaymentProcessing(paymentData);
    }
    throw error;
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

// 오류 분류 및 심각도 평가 함수
function categorizeError(error) {
  // 기본 정보 수집
  const errorData = {
    type: error.name || 'Unknown',
    message: error.message,
    stack: error.stack,
    timestamp: new Date().toISOString(),
    component: error.component || getCurrentComponent(),
    requestId: error.requestId || getCurrentRequestId(),
    userId: getCurrentUserId(),
    url: error.url || window.location.href
  };
  
  // 심각도 결정
  let severity = 'info';
  
  if (error instanceof NetworkError || error.status >= 500) {
    severity = 'error';
  } else if (error instanceof AuthError) {
    severity = 'warning';
  } else if (error instanceof ValidationError) {
    severity = 'info';
  }
  
  // 재시도 가능성 평가
  const isRetryable = evaluateRetryability(error);
  
  // 사용자 영향 평가
  const userImpact = evaluateUserImpact(error);
  
  // 비즈니스 영향 평가
  const businessImpact = evaluateBusinessImpact(error);
  
  // 우선순위 계산
  const priority = calculatePriority(severity, userImpact, businessImpact);
  
  return {
    …errorData,
    severity,
    isRetryable,
    userImpact,
    businessImpact,
    priority
  };
}

// 오류 보고 및 처리
function reportError(error) {
  const categorizedError = categorizeError(error);
  
  // 심각도에 따른 처리
  switch (categorizedError.severity) {
    case 'error':
      // 중요 오류는 즉시 알림
      notifyOnCall(categorizedError);
      break;
    case 'warning':
      // 경고는 집계 후 알림
      addToErrorAggregation(categorizedError);
      break;
    // 기타 심각도…
  }
  
  // 모든 오류는 중앙 에러 추적 시스템에 보고
  errorTrackingService.captureException(error, {
    extra: categorizedError
  });
  
  // 내부 분석을 위한 로깅
  logger.log(categorizedError.severity, JSON.stringify(categorizedError));
}