`

Exception Handling in Ruby on Rails and its Best Practices

image

Author: Himanshu Saxena

Exception handling in Ruby on Rails (Rails) is a crucial aspect of building robust web applications. Rails provides mechanisms to handle errors gracefully, ensuring that your application can recover from unexpected situations without crashing. Here's a detailed explanation of exception handling in Rails:

Basic Exception Handling in Ruby

Before diving into Rails-specific handling, it's essential to understand basic exception handling in Ruby:


begin
  # Code that might raise an exception
rescue SomeExceptionClass => e
  # Code that runs if the exception is raised
  puts "An error occurred: #{e.message}"
else
  # Code that runs if no exception is raised
ensure
  # Code that runs whether an exception is raised or not
end

Exception Handling in Rails

Rails builds on Ruby's exception handling with additional layers and features tailored for web applications.

1. Handling Exceptions in Controllers

In Rails controllers, you can handle exceptions using `rescue_from`. This method allows you to specify how certain exceptions should be handled across the entire controller.


class ApplicationController < ActionController::Base
  rescue_from ActiveRecord::RecordNotFound, with: :record_not_found
  rescue_from StandardError, with: :handle_standard_error

  private

  def record_not_found
    render plain: "404 Not Found", status: 404
  end

  def handle_standard_error
    render plain: "500 Internal Server Error", status: 500
  end
end


2. Custom Error Pages

Rails allows you to create custom error pages for common HTTP errors like 404 (Not Found) and 500 (Internal Server Error). These are placed in the `public` directory.

- `public/404.html`
- `public/500.html`

3. Logging Exceptions

Rails automatically logs exceptions to the log files (`log/development.log`, `log/production.log`). You can also customize the logging behavior.


class ApplicationController < ActionController::Base
  rescue_from StandardError, with: :log_error

  private

  def log_error(exception)
    logger.error exception.message
    logger.error exception.backtrace.join("\n")
    render plain: "500 Internal Server Error", status: 500
  end
end


4. Using Exception Notification Gem

For more sophisticated exception handling, you can use the `exception_notification` gem. It allows you to send notifications (via email, Slack, etc.) when exceptions occur.

Add the gem to your Gemfile:


gem 'exception_notification'


Then configure it in an initializer (`config/initializers/exception_notification.rb`):


Rails.application.config.middleware.use ExceptionNotification::Rack,
  email: {
    email_prefix: "[ERROR] ",
    sender_address: %{"notifier" <notifier@example.com>},
    exception_recipients: %w{exceptions@example.com}
  }


5. Custom Middleware

For advanced exception handling, you can create custom middleware. This approach gives you complete control over how exceptions are handled at the middleware level.


class CustomExceptionMiddleware
  def initialize(app)
    @app = app
  end

  def call(env)
    @app.call(env)
  rescue StandardError => e
    [500, { 'Content-Type' => 'text/html' }, ["Something went wrong: #{e.message}"]]
  end
end

Rails.application.config.middleware.use CustomExceptionMiddleware


Best Practices

1. Specificity: Rescue specific exceptions rather than using a general rescue block. This makes debugging easier and prevents swallowing unexpected errors.
2. Logging: Always log exceptions. Logs are invaluable for diagnosing issues in production.
3. User-Friendly Error Pages: Provide user-friendly error pages that inform users of the problem without exposing sensitive information.
4. Monitoring: Use tools like Sentry, Rollbar, or the `exception_notification` gem to monitor exceptions in real-time.
5. Testing: Write tests to ensure your exception handling works as expected. Simulate error conditions in your tests.

By following these practices and leveraging Rails' built-in mechanisms, you can handle exceptions gracefully, improving the robustness and user experience of your web application.

Published :