javascriptjavaphprubydotnet

Ruby raising exceptions

Raising Exceptions in Ruby

Rescuing pre-defined exceptions is one thing, but to more effectively utilize exceptions within your application, it is important to understand how to create and raise your own. At its core, every Ruby exception stems from a built-in Exception class, and includes a handful of built-in methods, but the most commonly used exception method is message. This method can be used to retrieve a specific exception message from a raised exception object.

Raising Generic Exceptions

Like the title of this section implies, raising exceptions in Ruby can be done using the raise method. While a blank exception can be raised, however, most exceptions include a message with additional information about the error. For example, a default RuntimeError exception can be raised with a custom error message in just one line:

raise "This is an exception"

While this is valuable for raising generic exceptions, it is also possible to raise an instance of an Exception class, such as StandardError:

raise StandardError.new "This is an exception"

Keep in mind, however, that while StandardError exceptions are intended to be rescued, Exception exceptions are not (see Exception Handling in Ruby). This means that if you choose to raise a new Exception instance, you will not be able to rescue it without explicitly rescuing every top-level Exception instance, which could cause unexpected problems down the line.

raise Exception.new "This is an exception"

Raising Custom Exceptions

In a nutshell, every custom Ruby exception should extend StandardError, rather than the Exception class (the reason for this is outlined in Exception Handling in Ruby). With this in mind, the simplest custom exception class that we can define will look something like this:

class MyCustomException < StandardError
end

Given the above class definition, we will be able to raise a MyCustomException exception, yet have access to all the bells and whistles that come from the built-in StandardError class. But what if you wanted to define a default error message, or pass additional data along with your custom error? To do this, we simply need to override the constructor to accept custom parameters:

class MyCustomException < StandardError
  def initialize(msg="This is a custom exception", exception_type="custom")
    @exception_type = exception_type
    super(msg)
  end
end

This class definition allows us to raise our custom exception with the additional data:

begin
    raise MyCustomException.new "Message, message, message", "Yup"
rescue MyCustomException => e
    puts e.message *# Message, message, message*
    puts e.exception_type *# Yup*
end

Writing to STDERR

Outside of raising exceptions, Ruby also supports writing directly to STDERR. Where puts writes messages directly to STDOUT, STDERR.puts can be used to write raw messages to STDERR without interrupting program execution. This is useful when you need to track debug data or keep track of caught and handled exceptions.

STDERR.puts "I am an error message"