I use 'rubyoverflow' gem in rails:
begin
puts "=== 1 ==="
qt = Questions.retrieve_by_tag(tag).questions
puts "=== 2 ==="
rescue
puts "=== 3 ==="
end
But sometimes I get the error on the console:
couldn't parse YAML at line 843 column 4
C:/Ruby192/lib/ruby/1.9.1/psych.rb:148:in parse'
C:/Ruby192/lib/ruby/1.9.1/psych.rb:148:inparse_stream' ... rubyoverflow
(1.0.1) lib/rubyoverflow.rb:86:in request' ...
C:/Ruby192/lib/ruby/1.9.1/webrick/server.rb:183:inblock in start_thread'
But the question not about the error in the gem, but about the exception handling. I get in the console only line:
puts "=== 1 ==="
but not lines
puts "=== 2 ==="
puts "=== 3 ==="
why?
How can I restore esecution of my program if the line
qt = Questions.retrieve_by_tag(tag).questions
fails?
By default rescue traps StandardError and whatever inherits from it.
From the docs:
By default, rescue only intercepts StandardError and its descendants...
The exception being raised is probably not that, so rescue doesn't handle it.
Usually you can figure out what to use as rescue's parameter from the docs to the method raising it, but, if not, you can use
rescue Exception => e
print e.to_s
end
to see what the exception is, then replace Exception with that value.
More information is on the internet, but here's a piece of code to print a list of Exceptions.
Related
This is sample code which i am trying to handle exception from unicorn.
unicron.rb
worker_processes Integer(ENV['WEB_CONCURRENCY'] || 3)
timeout 15
preload_app true
timeout.rb
Rack::Timeout.timeout = 12
Sample code
def create_store
ActiveRecord::Base.transaction do
#store = Store.new(params[:store])
if #store.save!
sleep 12.3
InformUserWorker.perform_async(store_id)
end
end
rescue => exception
exception.backtrace.each { |trace| puts trace }
rescue Timeout::Error
puts 'That took too long, exiting...1'
rescue Rack::Timeout::RequestTimeoutException
puts 'That took too long, exiting...2'
rescue Rack::Timeout::RequestTimeoutError
puts 'That took too long, exiting...3'
rescue Rack::Timeout::RequestExpiryError
puts 'That took too long, exiting...4'
end
I am getting code=H13 desc="Connection closed without response" with this sleep 12.3 seconds, and the transaction rollback happens, but none of these exceptions are executing. I have added couple of exception here. Anything goes wrong here?.
Rescues are executed in order. So your first rescue captures anything that is being raised and the code never gets past that point.
Try putting it last:
# other rescues in here.
rescue => exception
exception.backtrace.each { |trace| puts trace }
end # this one is the last, only executed if none of the others are
If the problem is that you're not sure which class is being raised, just use something like pry to debug the exception.class
I have the following code in Rails routing:
class LegacyRedirector
InvalidUrlError = Class.new(ActionController::RoutingError)
def call(params, request)
URI.parse(request.path)
rescue URI::InvalidURIError => e
raise InvalidUrlError.new(e.message)
end
end
# routes.rb
match 'a', to: redirect(LegacyRedirector.new)
This is for catching invaild URLs. However when I test it in browser for curl, it would still display URI::InvalidURIError, not my new error class. It seems the rescue block was never reached, yet I am sure I am rescuing the correct type. How can that be?
URI::InvalidURIError at /twitter/typeahead-js/wikis/home[
=========================================================
> bad URI(is not URI?): "/twitter/typeahead-js/wikis/home["
lib/gitlab/routing.rb, line 31
------------------------------
``` ruby
> 31 URI.parse(request.path)
32 rescue URI::InvalidURIError => e
33 raise InvalidUrlError.new(e.message)
34 end
```
One possible cause could be better_errors.
If an error is raised in a rescue block, its cause would be the original error. better_errors displays that cause instead, meaning the backtrace will not be in the rescue block. This gives you the illusion that it is never rescued.
This was recently fixed, see https://github.com/BetterErrors/better_errors/pull/459 for more details
I'm trying to figure out the best way to catch a specific error thrown AND the error's message in Ruby on Rails. My use case is that I encounter a timeout error every now and then which is thrown with a general error and I want to treat the timeout error differently than other errors within the same general error. I'm not sure what other type of errors could be thrown in the general error but I assume more of them exist. I have some sample code below of how I'm currently handling it, but I was thinking there might be a better way which I haven't found yet?
tries = 0
begin
tries += 1
<code>
rescue Foo::Bar => e
case e.to_s
when 'More specific timeout error message'
retry unless tries >= 5
else
# Let me see other error messages
log.info("Error: #{e.to_s}")
end
end
You can use multi rescue, to handle different errors.
begin
# DO SOMETHING
rescue Net::Timeout => e # change it to the error your want to catch, check the log.
# handle it
rescue SyntaxError => e # just an example
# handle it
rescue => e # any error that not catch by above rescue go here.
# handle it
end
Read more:
http://phrogz.net/programmingruby/tut_exceptions.html
You can try Rollbar, it help report error on production.
Take a look at retriable gem. It seems like a good fit for what you're proposing. Usually you'd rescue from an specific error type, but retriable also gives you the choice to rescue based on the error message.
begin
Retriable.retriable on: { Foo::Bar => /More specific timeout error message/ }, tries: 3 do
# will retry if an error of type Foo::Bar is raised
# and its message matches /More specific timeout error message/
# code here...
end
rescue => e # rescue for everything else
puts e.message # same as e.to_s
end
If ERB.new(...).result raises an exception how do I get the code and backtrace near it?
Like rails does with it's templates.
I tried what #Nathan suggested before:
begin
ERB.new('<%= fail %>').result
rescue Exception => e
p e
end
=> RuntimeError
That doesn't tell me the position of the error
Try:
begin
ERB.new(...).result
rescue Exception => e
# puts e
# or
# binding.pry if you use the pry gem
end
When exiting a Rails app using raise or fail, how to prevent the backtrace from being displayed?
Tried using back_trace_limit but it only seems to work for the console...?
You have total control over the backtrace returned with an exception instance by using its set_backtrace method. For example:
def strip_backtrace
yield
rescue => err
err.set_backtrace([])
raise err
end
begin
strip_backtrace do
puts 'hello'
raise 'ERROR!'
end
rescue => err
puts "Error message: #{err.message}"
puts "Error backtrace: #{err.backtrace}"
end
Output:
hello
Error message: ERROR!
Error backtrace: []
The strip_backtrace method here catches all errors, sets the backtrace to an empty array, and re-raises the modified exception.