Error Handling In Ruby On Rails

Web Dev @ Microsoft SEO By WooRank Books Courses Screencasts Newsletters Versioning ruby exception handling best practices Shop Forums Advertise Contribute Contact Us Our Story 995kSubscribers 132kFollowers 80kFollowers rails throw exception Ruby Article Ruby Error Handling, Beyond the Basics By Darko Gjorgjievski June 16, 2015 Imagine you're riding

Rails Raise Exception With Message

a bike. Now, imagine the designers of that bike built it so it rides smoothly only on roads without bumps and encountering one would result in the entire

Ruby Raise Exception In Rescue

bicycle breaking! You wouldn't want that, would you? Yet this is how thousands of software developers design their software every single day. They put error handling in as an afterthought, dealing with it only when it's inevitable. The truth is, it's not their fault. Most of the material on this subject is very basic, covering simple begin rescue rails things like raising an error, rescuing it, different error types and…that's about it. This article will attempt to go deeper than that. I assume you're familiar with the basics of error handling (using raise, begin/rescue, what StandardError is, error inheritance). That's the only prerequisite for reading this article. Let's begin. What Did We Do Before Raising/Handling Exceptions? Before exceptions were invented, the primary method of communication that something in the program has failed was through error return codes. As time passed, people looked at ways to clearly distinguish between what their program does and what would happen if it didn't do what it was supposed to (return codes were far from ideal for this purpose) do. Thus, the invention of language constructs like: raise rescue begin/end (Many other languages use different wording, like try/catch or throw, but the idea behind it remains the same.) There are opposing views to using exceptions and error handling in the first place. Some of these points make sense and we'll discus

those solutions. Let me walk you through the possibilities. begin/rescue block begin/rescue blocks are the standard ruby mechanism to deal with exceptions. It might look like this: begin

Ruby Rescue Rethrow

do_something rescue handle_exception end This works nice for exceptions that might happen in rescue = e your code. But what if you want to rescue every occurrence of a specific exception, say a NoPermissionError which rescue exception = e might be raised from your security layer? Clearly you do not want to add a begin/rescue block in all your actions just to render an error message, right? Around filter An around https://www.sitepoint.com/ruby-error-handling-beyond-basics/ filter could be used to catch all those exceptions of a given class. Honestly I haven't used a before filter for this, this idea came to my mind when writing this blog post. class ApplicationController < ActionController::Base around_action :handle_exceptions private def handle_exceptions   begin     yield   rescue NoPermissionError     redirect_to 'permission_error' end end end rescue_from rescue_from gives you the same possibilities as the https://blog.simplificator.com/2015/03/13/handling-errors-in-ruby-on-rails/ around filter. It's just shorter and easier to read and if the framework offers a convenient way, then why not use it. There are multiple ways to define a handler for an exception, for a short and sweet handler I prefer the block syntax: class ApplicationController < ActionController::Base rescue_from 'NoPermissionError' do |exception| redirect_to 'permission_error' end end exceptions_app There is an additional feature (added in Rails 3.2) that allows to handle exceptions. You can specify an exceptions_app which is used to handle errors. You can use your own Rails app for this: config.exceptions_app = self.routes If you do so, then your routing must be configured to match error codes like so: match '/404', to: 'exceptions#handle_404' ... Alternatively you can specify a lambda which receives the whole Rack env: config.exceptions_app = lambda do |env| # do something end Do you wonder how you can call an arbitrary action when you have the env? It's pretty easy: action = ExceptionsController.action(:render_error) action.call(env) In any case you want to set following configuration for exceptions_app to be used: Rails.application.config.consider_all_requests_local = false Rails.application.config.action_dispatch.show_exceptions = true But where is the exception you ask? It is stored in the Rack env: env[http://ruby.bastardsbook.com/chapters/exception-handling Classes Further reading Previous Chapter: Image Manipulation Next Chapter: Object-Oriented Concepts Planking on the High Line. (Photo by Dan Nguyen) This was a chapter that I decided to include at the last minute. It's not complete but at least you can be aware of basic exception handling. No matter how carefully you code your script, your program is prone to failure for reasons beyond your control. A website that your script scrapes may suddenly raise exception be down. Or someone sharing the same hard drive may delete a file your program is supposed to read from. Circumstances such as these will crash your program. For any kind of long continuous task that you don't want to baby-sit and manually restart, you will need to write some exception-handling code to tell the program how to carry on when things go wrong. Demonstrating exceptions Before the formal description of the the error handling in begin/rescue block, let's walk through a couple examples of it in action. At a skin-deep level, it behaves nearly the same as the if/else construct. Skipping past an error The Exception class handles nearly every kind of hiccup that might occur during runtime, including syntax screwups and incorrect type handling. We learned early on that adding numbers and strings with no type conversion would crash a program: a = 10 b = "42" a + b The attempted arithmetic results in this error: The begin/rescue block is typically used on code in which you anticipate errors. There's only one line here for us to worry about: a = 10 b = "42" begin a + b rescue puts "Could not add variables a (#{a.class}) and b (#{b.class})" else puts "a + b is #{a + b}" end Executing the revised code gets us this: Two obvious differences from the first try: The puts statement in the rescue clause executed. And more importantly, the Ruby program did not crash. Let's feed this simple operation with an array of values of different types to see how the else clause comes into play: values = [42, 'a', 'r', 9, 5, 10022, 8.7, "sharon", "Libya", "Mars", "12", 98, rand + rand, {:dog=>'cat'}, 100, nil, 200.0000, Object, 680, 3.14, "Steve", 78, "Argo"].shuffle while