Exceptions in Ruby - Tips and Tricks

Exceptions in Ruby
Tips & Tricks

Vlad ZLOTEANU
#ParisRB
July 3, 2002 Software Engineer @ Dimelo
@vladzloteanu

Copyright Dimelo SA www.dimelo.com

About me

R&D Software Engineer @ Dimelo

@vladzloteanu

https://github.com/vladzloteanu


Exceptions (in Ruby)

Failure: abnormal situation

Exception: instance of Exception class (or instance of
descendant)
What: allows packaging info about the failure
message string
backtrace
default behavior: program terminates (exits)


Exceptions classes in Ruby

Exception
NoMemoryError
ScriptError
LoadError
SignalException
Interrupt
StandardError
ArgumentError
IOError ...
RuntimeError
SystemExit

Raising an exception

class MyException < StandardError; end

raise MyException.new

raise # aka: raise RuntimeError.new

raise “Boom!!” # aka raise RuntimeError.new(“Boom!!”)

raise MyException, “Boom!!”, backtrace


Rescuing exceptions

begin
raise MyError.new("Booooom!")

rescue MyError
puts "MyError just hapened"

rescue # Will rescue StandardError
puts "a RuntimeError just happened"

rescue Exception => e
puts ”Exception: #{e.message}”
e.backtrace.each{|line| puts “ > #{line}”}

end


Intermezzo: Signals

Signals – used to alert threads/processes
(hardware faults, timer expiration, terminal
activity, kill command, etc)
SIGINT: CTRL+C in terminal (can be caught)
SIGTERM: Sent by kill command by default
(can be caught)
SIGKILL: Uncatchable exception (kill -9)

A SignalException is raised when a signal is
received


What should we rescue?


Rescuing exceptions

TIP: DON’T RESCUE ‘EXCEPTION’ class!

begin

while(true) ; end
rescue Exception
puts "Rescued exception; Will retry"
retry
end

^CRescued exception; WIll retry

# Kill -9, baby!

Rescuing exceptions (third-party libraries)

# You may think this will save you from all evil ..
begin
Net::HTTP.get_response(’external.resource', '/')
rescue => e
[…]

# Think again!

# Excerpt from net/http.rb
def connect
s = timeout(@open_timeout)
{ TCPSocket.open(conn_address(), conn_port()) }

Net::HTTP(Timeout library) may throw
Timeout::Error < InterruptError

Rescuing exceptions (third-party libraries)

# Solution is easy:

begin
Net::HTTP.get_response(’external.resource', '/')
rescue StandardError, Timeout::Error => e
[…]

Tip: Net::HTTP (and many of the gems that
depend on it) can throw Timeout::Error – don’t
forget to rescue it


Rescuing exceptions - cont

TIP: (rescue blocks): rescue most specific
errors first, most generic last

TIP: inline rescue
but avoid it because:
No access to rescued exception
Exceptions are slow (explained later)
# Will return: DefaultDecorator
@decorator = “foo”.constantize rescue DefaultDecorator


What should we raise?


Raising exceptions

Tip: make your own exception class, do not
“raise string”
avoid using error message for making
discriminating error type
begin
if @avatar_url.empty?
raise “Input should not be empty”
elsif @avatar_url.valid?
raise “Avatar URL invalid”
end

rescue RuntimeError => e
# They are both instances of RuntimeError, can’t
# rescue only the first one
end

Raising exceptions (cont)

# excerpt from OpenSSL::SSLError
# - invalid certificate, invalid hostname, protocol
mismatch, etc.
class SSLError
def initialize(message)
@message = message
end
[…]

# Client code
rescue OpenSSL::SSL::SSLError => e
if e.message =~ /sslv3 alert unexpected message/
@conn.ssl_version="SSLv3“
retry
else
raise


Getting latest exception

begin
raise ”Boom!"
rescue
puts $!.inspect
# > #<RuntimeError: Boom!>
end

puts $!.inspect
# > nil

1 / 0 rescue nil
puts $!.inspect
# > nil


Intermezzo: caller method

TIP: ’caller’ gets you current execution
stacktrace

def foo
bar
end

def bar
puts caller.inspect
end

foo
# [”test_caller:2:in `foo'",
”test_caller.rb:9"]


Re-raise exception – backtrace issue

def foo
Net::HTTP.get_response('does.not.exists', '/')
rescue => e
# some logging, or whatever..

# raising a new error
raise MyCustomException.new(‘Boom!’)
end

begin
foo
rescue => e
puts e.backtrace.inspect
end

["reraise_ex.rb:7:in `foo'", "reraise_ex.rb:11"]


Re-raise exception – backtrace issue (2)

TIP: when reraising new exception, ensure you
don’t loose the backtrace

def foo
Net::HTTP.get_response('does.not.exists', '/')
rescue => e

# raising a new error, keeping old backtrace
raise MyException, "And now.. boom!", e.backtrace

# another option is to reraise same error:
raise
End


Ensure
begin
puts '> always executed (even if there was
normal flow’ or there
raise "error in normal flow”
puts "< was not flow"
normal an exception)
rescue
good place for code cleanup
puts "> RESCUE - last error is <#{$!}>”
raise "error in rescue”
puts "< RESCUE"
ensure
puts "> ENSURE - last error is <#{$!}>”
raise "error in ensure”
puts "< ENSURE after raising"
end

ruby raise_rescue.rb
> normal flow
> RESCUE - last error is <error in normal flow>
> ENSURE - last error is <error in rescue>
www.dimelo.com
raise_rescue.rb:11: error in ensure (RuntimeError)
Copyright Dimelo SA

Catch/throw

ruby ‘goto label’ implementation
should be used on ‘expected’ situations

# Sinatra code

def last_modified(time)
response['Last-Modified'] = time
request.env['HTTP_IF_MODIFIED_SINCE'] > time
throw :halt, response
end
end

def invoke
res = catch(:halt) { yield }
..
end

Exceptions are slow ?

https://github.com/vladzloteanu/ruby_exceptions_benchmark

user_name = ““
~ 0.3ns
# Test with ‘if’
nil if user_name.empty?

# Test with raise/rescue
begin ~ 74 ns
raise "boom!" if user_name.empty?
rescue => e
nil
end
~ 2 ns
# Test with try/catch
catch(:error) do
throw :error if user_name.empty?
end

Exceptions are slow ? (2)

class User < ActiveRecord::Base
validates :email, :presence => true
end

user = User.new

# Test with ‘if’
~ 1.5 ms
nil unless user.save

# Test with raise/rescue
~ 2 ms
user.save! rescue nil


Exceptions are slow ? (3)

TIP: Exceptions should be used only on
‘exceptional’ situations
Use conditional constructs or ‘throw’ for
expected cases
TIP: Detect errors at low level, handle them at
high level


Recap

Don’t rescue Exception!
Watch out for exceptions thrown by your libs
(Timeout::Error on Net::HTTP) Avoid putting
error type (only) in exception message
Avoid using exceptions for normal program
flow
Exceptions are slow(er)
Catch errors on the caller code, not on the
callee
When you reraise, ensure that you don’t
loose initial error’s backtrace

Thank you!

Questions?

http://jobs.dimelo.com ;)


Exceptions in Ruby - Tips and Tricks

Recommandé

Recommandé

Contenu connexe

Similaire à Exceptions in Ruby - Tips and Tricks

Similaire à Exceptions in Ruby - Tips and Tricks (20)

Dernier

Dernier (20)

Exceptions in Ruby - Tips and Tricks