Exception handling and error management

# Custom exception classes
class ApplicationError < StandardError; end
class AuthenticationError < ApplicationError; end
class AuthorizationError < ApplicationError; end
class ValidationError < ApplicationError
  attr_reader :errors

  def initialize(errors)
    @errors = errors
    super("Validation failed: #{errors.join(', ')}")
  end
end

# Usage
def authenticate_user(credentials)
  raise AuthenticationError, "Invalid credentials" unless valid?(credentials)
  # Authentication logic
end

def authorize_user(user, action)
  raise AuthorizationError, "Not authorized to #{action}" unless user.can?(action)
  # Authorization logic
end

def validate_input(data)
  errors = []
  errors << "Name is required" if data[:name].blank?
  errors << "Email is invalid" unless data[:email]&.match?(/@/)

  raise ValidationError.new(errors) if errors.any?
end

# Catching custom exceptions
begin
  validate_input(params)
rescue ValidationError => e
  render json: { errors: e.errors }, status: :unprocessable_entity
rescue AuthenticationError => e
  render json: { error: e.message }, status: :unauthorized
rescue AuthorizationError => e
  render json: { error: e.message }, status: :forbidden
end

# Exception with custom data
class APIError < StandardError
  attr_reader :status_code, :response_body

  def initialize(message, status_code:, response_body: nil)
    @status_code = status_code
    @response_body = response_body
    super(message)
  end
end

# Usage
raise APIError.new(
  "API request failed",
  status_code: 500,
  response_body: { error: "Internal error" }
)

# Exception translation pattern
class ExternalAPIClient
  class APIError < StandardError; end
  class NotFoundError < APIError; end
  class RateLimitError < APIError; end

  def fetch_data(id)
    response = HTTParty.get("https://api.example.com/items/#{id}")

    case response.code
    when 200
      response.parsed_response
    when 404
      raise NotFoundError, "Item #{id} not found"
    when 429
      raise RateLimitError, "Rate limit exceeded"
    else
      raise APIError, "Request failed with status #{response.code}"
    end
  rescue HTTParty::Error => e
    raise APIError, "HTTP error: #{e.message}"
  end
end

# Circuit breaker pattern
class CircuitBreaker
  class CircuitOpenError < StandardError; end

  def initialize(threshold: 5, timeout: 60)
    @failure_count = 0
    @threshold = threshold
    @timeout = timeout
    @last_failure_time = nil
    @state = :closed
  end

  def call
    raise CircuitOpenError if open?

    yield
    on_success
  rescue StandardError => e
    on_failure
    raise
  end

  private

  def open?
    @state == :open && Time.now - @last_failure_time < @timeout
  end

  def on_success
    @failure_count = 0
    @state = :closed
  end

  def on_failure
    @failure_count += 1
    @last_failure_time = Time.now
    @state = :open if @failure_count >= @threshold
  end
end

# Safe navigation with exceptions
def safe_find(model, id)
  model.find(id)
rescue ActiveRecord::RecordNotFound
  nil
end

# Exception logging
begin
  dangerous_operation
rescue StandardError => e
  Rails.logger.error("Operation failed: #{e.class.name} - #{e.message}")
  Rails.logger.error(e.backtrace.join("\n"))

  # Report to error tracking service
  Sentry.capture_exception(e)

  raise
end

# Suppressing exceptions (use sparingly!)
suppress(Errno::ENOENT) do
  File.delete('tmp/cache.dat')
end