5장: 에러 처리 패턴과 베스트 프랙티스

type error interface {
    Error() string
}

result, err := doSomething()
if err != nil {
    return fmt.Errorf("작업 실패: %w", err)
}
// result 사용

import (
    "errors"
    "fmt"
)
 
// 단순 에러
err := errors.New("사용자를 찾을 수 없습니다")
 
// 포맷이 포함된 에러
err := fmt.Errorf("사용자 ID %d를 찾을 수 없습니다", userID)
 
// 에러 래핑 -- %w 동사 사용
err := fmt.Errorf("사용자 조회 실패: %w", originalErr)

package repository
 
import "errors"
 
var (
    ErrNotFound      = errors.New("리소스를 찾을 수 없습니다")
    ErrAlreadyExists = errors.New("리소스가 이미 존재합니다")
    ErrUnauthorized  = errors.New("인증이 필요합니다")
    ErrForbidden     = errors.New("접근 권한이 없습니다")
)

func (s *UserService) GetUser(ctx context.Context, id int64) (*User, error) {
    user, err := s.repo.FindByID(ctx, id)
    if err != nil {
        // 원본 에러를 래핑하여 컨텍스트 추가
        return nil, fmt.Errorf("UserService.GetUser(id=%d): %w", id, err)
    }
    return user, nil
}

UserService.GetUser(id=42): UserRepo.FindByID: sql: no rows in result set

user, err := userService.GetUser(ctx, 42)
if err != nil {
    if errors.Is(err, repository.ErrNotFound) {
        // 404 Not Found 응답
        http.Error(w, "사용자를 찾을 수 없습니다", http.StatusNotFound)
        return
    }
    if errors.Is(err, context.DeadlineExceeded) {
        // 504 Gateway Timeout 응답
        http.Error(w, "요청 시간 초과", http.StatusGatewayTimeout)
        return
    }
    // 500 Internal Server Error
    http.Error(w, "서버 내부 오류", http.StatusInternalServerError)
}

var validationErr *ValidationError
if errors.As(err, &validationErr) {
    // ValidationError의 필드에 접근 가능
    fmt.Println("유효하지 않은 필드:", validationErr.Field)
    fmt.Println("에러 메시지:", validationErr.Message)
}

type ValidationError struct {
    Field   string
    Message string
    Value   any
}
 
func (e *ValidationError) Error() string {
    return fmt.Sprintf("유효성 검사 실패 - 필드: %s, 메시지: %s", e.Field, e.Message)
}
 
func validateEmail(email string) error {
    if !strings.Contains(email, "@") {
        return &ValidationError{
            Field:   "email",
            Message: "올바른 이메일 형식이 아닙니다",
            Value:   email,
        }
    }
    return nil
}

type APIError struct {
    Code       int    `json:"code"`
    Message    string `json:"message"`
    Detail     string `json:"detail,omitempty"`
    RequestID  string `json:"request_id,omitempty"`
    Err        error  `json:"-"` // JSON 직렬화에서 제외
}
 
func (e *APIError) Error() string {
    if e.Err != nil {
        return fmt.Sprintf("[%d] %s: %v", e.Code, e.Message, e.Err)
    }
    return fmt.Sprintf("[%d] %s", e.Code, e.Message)
}
 
func (e *APIError) Unwrap() error {
    return e.Err
}
 
// 생성 헬퍼 함수
func NewNotFoundError(resource string, id any) *APIError {
    return &APIError{
        Code:    404,
        Message: fmt.Sprintf("%s을(를) 찾을 수 없습니다", resource),
        Detail:  fmt.Sprintf("ID: %v", id),
    }
}
 
func NewInternalError(err error) *APIError {
    return &APIError{
        Code:    500,
        Message: "서버 내부 오류가 발생했습니다",
        Err:     err,
    }
}

func processOrder(ctx context.Context, orderID int64) error {
    order, err := findOrder(ctx, orderID)
    if err != nil {
        return fmt.Errorf("주문 조회 실패: %w", err)
    }
 
    if err := validateOrder(order); err != nil {
        return fmt.Errorf("주문 유효성 검사 실패: %w", err)
    }
 
    if err := chargePayment(ctx, order); err != nil {
        return fmt.Errorf("결제 처리 실패: %w", err)
    }
 
    if err := shipOrder(ctx, order); err != nil {
        return fmt.Errorf("배송 처리 실패: %w", err)
    }
 
    return nil
}

// 나쁜 예 -- 컨텍스트 없음
return err
 
// 나쁜 예 -- 중복 정보
return fmt.Errorf("에러 발생: %w", err)
 
// 좋은 예 -- 함수명과 핵심 파라미터 포함
return fmt.Errorf("UserRepo.FindByEmail(%s): %w", email, err)

// 하위 계층 -- 에러를 래핑하여 전파
func (r *UserRepo) FindByID(ctx context.Context, id int64) (*User, error) {
    var user User
    err := r.db.QueryRowContext(ctx, query, id).Scan(&user.ID, &user.Name)
    if err != nil {
        if errors.Is(err, sql.ErrNoRows) {
            return nil, ErrNotFound // 도메인 에러로 변환
        }
        return nil, fmt.Errorf("UserRepo.FindByID(%d): %w", id, err)
    }
    return &user, nil
}
 
// 상위 계층 -- 에러를 처리하고 사용자에게 응답
func (h *UserHandler) GetUser(w http.ResponseWriter, r *http.Request) {
    user, err := h.service.GetUser(r.Context(), userID)
    if err != nil {
        if errors.Is(err, repository.ErrNotFound) {
            writeJSON(w, http.StatusNotFound, ErrorResponse{
                Message: "사용자를 찾을 수 없습니다",
            })
            return
        }
        slog.Error("사용자 조회 실패", "error", err, "userID", userID)
        writeJSON(w, http.StatusInternalServerError, ErrorResponse{
            Message: "서버 내부 오류",
        })
        return
    }
    writeJSON(w, http.StatusOK, user)
}

// 적절한 panic 사용 사례
func MustParseURL(rawURL string) *url.URL {
    u, err := url.Parse(rawURL)
    if err != nil {
        panic(fmt.Sprintf("잘못된 URL: %s: %v", rawURL, err))
    }
    return u
}
 
// 초기화 시 필수 환경 변수 확인
func MustGetEnv(key string) string {
    val := os.Getenv(key)
    if val == "" {
        panic(fmt.Sprintf("필수 환경 변수 %s가 설정되지 않았습니다", key))
    }
    return val
}

func RecoveryMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        defer func() {
            if rec := recover(); rec != nil {
                // 스택 트레이스 로깅
                stack := debug.Stack()
                slog.Error("panic 복구",
                    "panic", rec,
                    "stack", string(stack),
                    "method", r.Method,
                    "path", r.URL.Path,
                )
 
                http.Error(w, "서버 내부 오류", http.StatusInternalServerError)
            }
        }()
        next.ServeHTTP(w, r)
    })
}

1. 에러를 무시하지 않는다 (명시적으로 _ 할당은 가능)
2. 에러를 래핑할 때 컨텍스트(함수명, 파라미터)를 추가한다
3. 센티널 에러 비교는 errors.Is, 타입 검사는 errors.As를 사용한다
4. 에러 메시지는 소문자로 시작하고 마침표로 끝나지 않는다 (Go 관례)
5. panic은 복구 불가능한 상황에서만 사용한다
6. 에러를 로깅하고 반환하는 것을 동시에 하지 않는다 (중복 로깅 방지)
7. 라이브러리는 에러를 반환하고, 애플리케이션이 에러를 로깅한다