How would you design a structured error handling strategy for a large microservice codebase?

Question

Accepted Answer

// Domain error type
type AppError struct {
    Code    string
    Message string
    Cause   error
}

func (e *AppError) Error() string {
    if e.Cause != nil {
        return fmt.Sprintf("%s: %s: %v", e.Code, e.Message, e.Cause)
    }
    return fmt.Sprintf("%s: %s", e.Code, e.Message)
}
func (e *AppError) Unwrap() error { return e.Cause }

// Domain-specific constructors
func ErrNotFound(resource, id string) *AppError {
    return &AppError{Code: "NOT_FOUND", Message: fmt.Sprintf("%s %s not found", resource, id)}
}
func ErrForbidden(msg string) *AppError {
    return &AppError{Code: "FORBIDDEN", Message: msg}
}

// Map to HTTP at the boundary (middleware)
func errorToHTTP(err error) (int, string) {
    var appErr *AppError
    if errors.As(err, &appErr) {
        switch appErr.Code {
        case "NOT_FOUND": return 404, appErr.Message
        case "FORBIDDEN": return 403, appErr.Message
        case "VALIDATION": return 400, appErr.Message
        }
    }
    // Never expose internal errors to clients
    log.Printf("internal error: %+v", err)
    return 500, "internal server error"
} Layer errors: domain layer returns domain errors, service layer wraps with context, transport layer maps to protocol codes Wrap at boundaries: fmt.Errorf("operation: %w", err) to build traceable error chains Never expose internal errors (DB errors, stack traces) to external API clients Attach structured context to logs: error code, request ID, user ID, operation name Define sentinel errors for expected cases (ErrNotFound, ErrConflict) and typed errors for recoverable cases with extra data

How would you design a structured error handling strategy for a large microservice codebase?

Define typed domain errors with codes and messages, wrap errors with context at each layer boundary, map to HTTP/gRPC status codes in middleware, and log with full structured context.

How would you design a structured error handling strategy for a large microservice codebase?

Define typed domain errors with codes and messages, wrap errors with context at each layer boundary, map to HTTP/gRPC status codes in middleware, and log with full structured context.

Scenario Questions

Follow-up Questions