Engineer Resilient Go Apps: Demystifying errors.Is and errors.As

package main

import (
	"errors"
	"fmt"
)

// simulateReadConfig simulates reading a configuration file.
// It might fail due to a file not found error.
func simulateReadConfig(path string) error {
	if path == "invalid.yaml" {
		// Use fmt.Errorf with %w to wrap the underlying error.
		// This retains the original error in the chain.
		return fmt.Errorf("config file '%s' not found: %w", path, errors.New("file system error"))
	}
	return nil
}

// processRequest attempts to process a request that depends on configuration.
func processRequest(configPath string) error {
	err := simulateReadConfig(configPath)
	if err != nil {
		// Wrap the configuration error again, adding more context.
		return fmt.Errorf("failed to initialize system: %w", err)
	}
	fmt.Println("System initialized successfully.")
	return nil
}

func main() {
	// Scenario 1: Successful execution
	if err := processRequest("valid.yaml"); err != nil {
		fmt.Printf("Error: %v\n", err)
	}

	// Scenario 2: Error path, demonstrating wrapping
	fmt.Println("\n--- Running with error ---")
	if err := processRequest("invalid.yaml"); err != nil {
		fmt.Printf("Encountered error: %v\n", err)
	}
}

package main

import (
	"errors"
	"fmt"
)

// Define a sentinel error for specific conditions.
var ErrInvalidConfig = errors.New("invalid configuration data")
var ErrNetworkFailure = errors.New("network communication failed")

// DataStore simulates a data storage operation that might fail.
func DataStore(key string) error {
	if key == "network_issue" {
		return fmt.Errorf("failed to connect to DB: %w", ErrNetworkFailure)
	} else if key == "corrupt_data" {
		return fmt.Errorf("data parsing error: %w", ErrInvalidConfig)
	}
	return nil
}

// BusinessLogic wraps DataStore operation with business context.
func BusinessLogic(identifier string) error {
	err := DataStore(identifier)
	if err != nil {
		return fmt.Errorf("business rule violation for '%s': %w", identifier, err)
	}
	return nil
}

func main() {
	// Scenario 1: Handling a network error
	if err := BusinessLogic("network_issue"); err != nil {
		fmt.Printf("Processing error: %v\n", err)
		// Use errors.Is to check if any error in the chain matches ErrNetworkFailure.
		if errors.Is(err, ErrNetworkFailure) {
			fmt.Println("-> Action: A network issue was detected. Please check connectivity.")
		}
	}

	fmt.Println("\n--- Second Scenario ---")
	// Scenario 2: Handling an invalid configuration error
	if err := BusinessLogic("corrupt_data"); err != nil {
		fmt.Printf("Processing error: %v\n", err)
		// Use errors.Is to check for ErrInvalidConfig.
		if errors.Is(err, ErrInvalidConfig) {
			fmt.Println("-> Action: Configuration data is invalid. Review source.")
		}
		// errors.Is is also robust against different wrapping levels.
		if errors.Is(err, ErrNetworkFailure) {
			fmt.Println("This will not print for corrupt_data, demonstrating precision.")
		}
	}

	fmt.Println("\n--- No Error Scenario ---")
	if err := BusinessLogic("valid_key"); err != nil {
		fmt.Printf("Processing error: %v\n", err)
	} else {
		fmt.Println("Operation completed successfully.")
	}
}

package main

import (
	"errors"
	"fmt"
)

// DatabaseError represents a custom error type for database operations.
type DatabaseError struct {
	Op   string // Operation that failed (e.g., "read", "write")
	Code int    // Specific error code from the DB
	Err  error  // Underlying error
}

// Error implements the error interface for DatabaseError.
func (e *DatabaseError) Error() string {
	return fmt.Sprintf("DB %s failed (code %d): %v", e.Op, e.Code, e.Err)
}

// Unwrap allows DatabaseError to be part of an error chain.
func (e *DatabaseError) Unwrap() error {
	return e.Err
}

// Simulate database access.
func QueryData(query string) error {
	// Simulate different database errors.
	if query == "invalid_syntax" {
		// Wrap a standard error in our custom DatabaseError.
		return &DatabaseError{Op: "query", Code: 1064, Err: errors.New("syntax error in SQL")}
	} else if query == "connection_timeout" {
		return &DatabaseError{Op: "connect", Code: 2002, Err: errors.New("connection timed out")}
	}
	return nil
}

// HandleUserRequest processes a user request, interacting with the database.
func HandleUserRequest(requestID string) error {
	err := QueryData("invalid_syntax") // Simulate a scenario
	if err != nil {
		// Wrap the database error with a request-specific context.
		return fmt.Errorf("processing request %s failed: %w", requestID, err)
	}
	return nil
}

func main() {
	// Scenario: An error occurs during a user request.
	if err := HandleUserRequest("user_123"); err != nil {
		fmt.Printf("Application error: %v\n", err)

		var dbErr *DatabaseError
		// Use errors.As to check if any error in the chain can be assigned to *DatabaseError.
		// If successful, dbErr will point to the specific DatabaseError instance.
		if errors.As(err, &dbErr) {
			fmt.Printf("-> Action: Database error detected: operation '%s', code %d. Underlying: %v\n",
				dbErr.Op, dbErr.Code, dbErr.Err)
			// Based on the code, we can take specific actions.
			if dbErr.Code == 1064 {
				fmt.Println("   -> Specific action: SQL syntax error. Alert developer.")
			} else if dbErr.Code == 2002 {
				fmt.Println("   -> Specific action: Connection timeout. Retry or check DB status.")
			}
		} else {
			fmt.Println("-> Action: A different type of error occurred.")
		}
	}

	fmt.Println("\n--- Another Scenario ---")
	if err := HandleUserRequest("user_456"); err != nil {
		var anotherDBErr *DatabaseError
		if errors.As(QueryData("connection_timeout"), &anotherDBErr) {
			fmt.Printf("Detected connection timeout: %d\n", anotherDBErr.Code)
		}
	}
}

package main

import (
	"errors"
	"fmt"
)

// Sentinel error for a specific business rule violation.
var ErrAccountNotFound = errors.New("account not found")

// UserError represents a user-facing error with a public message.
type UserError struct {
	Message string
	Code    int
	Err     error // Underlying technical error, for internal logging/debugging
}

func (e *UserError) Error() string {
	return e.Message
}

func (e *UserError) Unwrap() error {
	return e.Err
}

// Service layer function that might encounter various errors.
func GetAccountDetails(accountID string) error {
	if accountID == "nonexistent" {
		// Wrap ErrAccountNotFound, potentially adding more details relevant to the service.
		return fmt.Errorf("failed to retrieve: %w", ErrAccountNotFound)
	} else if accountID == "db_timeout" {
		// Simulate a low-level error, wrapped as a UserError for presentation.
		return &UserError{
			Message: "Service temporarily unavailable. Please try again later.",
			Code:    503,
			Err:     errors.New("database connection timed out"), // Internal detail
		}
	}
	return nil
}

// API layer function that handles requests and translates errors.
func HandleAPIRequest(reqID, accountID string) error {
	err := GetAccountDetails(accountID)
	if err != nil {
		// Always wrap errors at boundaries to add context.
		return fmt.Errorf("API request %s failed: %w", reqID, err)
	}
	return nil
}

func main() {
	// Scenario 1: Account not found
	if err := HandleAPIRequest("req001", "nonexistent"); err != nil {
		fmt.Printf("API Response: %v\n", err)

		// Use errors.Is for business-level decision making.
		if errors.Is(err, ErrAccountNotFound) {
			fmt.Println("-> HTTP Status: 404 Not Found (Business Logic)")
		} else {
			fmt.Println("-> HTTP Status: 500 Internal Server Error (Generic)")
		}
	}

	fmt.Println("\n--- Another Scenario ---")
	// Scenario 2: Database timeout (presented as a user error)
	if err := HandleAPIRequest("req002", "db_timeout"); err != nil {
		fmt.Printf("API Response: %v\n", err)

		var userErr *UserError
		// Use errors.As to extract user-facing message and code.
		if errors.As(err, &userErr) {
			fmt.Printf("-> HTTP Status: %d, User Message: '%s' (Internal: %v)\n", userErr.Code, userErr.Message, userErr.Err)
		} else {
			fmt.Println("-> HTTP Status: 500 Internal Server Error (Unknown type)")
		}
	}

	fmt.Println("\n--- Success Scenario ---")
	if err := HandleAPIRequest("req003", "valid_account"); err != nil {
		fmt.Printf("API Response: %v\n", err)
	} else {
		fmt.Println("API Response: Success")
	}
}