ExceptionHandler is a “mistake pages” pearl for Ruby on Rails.
At present at rendition 0.7.7.0, the jewel has been downloaded more than 170,000 times and is generally viewed as the “best” powerful mistake pages diamond for the structure. It works amazingly well.
The most critical thing to acknowledge about ExceptionHandler is that it’s essentially intended to give an “interpretation” framework for Rails mistakes, changing over them into the fitting HTTP blunder that an internet browser can read.
Whilst Rails may raise special cases from inside its center, these mistakes are not what you find in your program. You see the http mistake that the system conveys to the web server. This http blunder is joined by a “HTTP Message Body” which is the thing that the program shows on the page.
At the end of the day, when managing Rails mistakes – on the off chance that you need to really demonstrate “marked” blunder pages (with your own particular format or another) – you need to “hack” Rails to convey those particular pages when blunders happen. The pages that are demonstrated make little difference to what the client finds in their internet browser; they’re just there to give a “marked” route for them to connect with it.
At whatever point Rails raises a special case inside its application – that blunder (it could be anything, for example, a database issue or something) is legitimate for the Rails application. What Rails does is “make an interpretation of” that mistake into one of two kinds of HTTP blunder (which a program can read): 4xx (customer mistake) or 5xx (server mistake).
Each time you utilize a “web” application, your PC is sending a demand for information on port 80 of an openly available IP address. In the event that the other PC (server) has a “web server” application running on port 80, it will acknowledge the demand and react with HTTP based information (which will regularly incorporate HTML code).
The whole “web” is an open catalog for the “Web”, implying that on the off chance that you the IP (or proportionate area name) for an associated PC, you ought to have the capacity to get to it through the “HTTP” (Hyper Content Exchange Convention). This HTTP convention is the center of how the “web” functions, and why a great many people get mistook when managing for “mistakes” in their Rails based applications.
HTTP “blunders” are not by any stretch of the imagination mistakes at everything except incorrect reactions. Every “blunder” you see is as yet a HTML page, showed with a relating HTTP status code.
Since HTTP is a “stateless” convention, it needs to work with what’s known as a “demand/reaction” design – basically implying that each and every time you send another demand to a web benefit, that demand is dealt with as totally new.
This is against “stateful” procedures, which “hold state” between demands; in the feeling of local applications or comparative. The fact of the matter is that what you see with HTTP blunders is a reaction to a wrong demand. They’re extremely just status codes which clarify that.
To do this legitimately, you must have the capacity to “make an interpretation of” Rails-based mistakes into the suitable HTTP blunder reaction. This is finished by the ActionDispatch::ShowExceptions middleware – which calls a middleware “snare” (“exceptions_app”) to figure out which “HTML” reaction to appear in the body of the wrong message.
It utilizes the “rescue_responses” hash to figure out which HTTP mistake code to coordinate any Rails special cases to. This hash can be reached out inside Rails, enabling clients to outline Rails-based “special cases” to the proper HTTP reaction code.
Say your application raises a mistake with ActiveRecord.
On the off chance that it can’t locate a specific thing in the database – Rails will raise the ActiveRecord::NotFound exemption class. This isn’t a HTTP-perfect blunder; it’s basically a “Rails” special case. The key is that it must be “interpreted” into a mistake that HTTP-based programs can get it. This is the place ActionDispatch::ShowExceptions comes in.
ShowExceptions basically takes the special case protest – goes it through the “rescue_responses” hash (to get a proper HTTP status code) and – significantly – summons the “exceptions_app” middleware snare to produce the “HTTP message body” for the reaction…
wrapper = ExceptionWrapper.new(backtrace_cleaner, special case)
status = wrapper.status_code
request.set_header “action_dispatch.exception”, wrapper.exception
request.set_header “action_dispatch.original_path”, request.path_info
request.path_info = “/#{status}”
reaction = @exceptions_app.call(request.env)
The key thing to acknowledge here is that @exceptions_app is the thing that ExceptionHandler has been worked to ovrsee.
Each time Rails raises a special case, the HTTP convention still remains regardless. At the end of the day, you’re continually going to require sending a HTTP status code and message body to the asking for internet browser… the distinction lies in what you send.
The issue for Rails is that @exceptions_app defaults to the “courses” – which implies that it will stack 404.HTML or 500.HTML from the/open catalog of your application. While this works, the pages are amateurish and static.
To change the pages, ExceptionHandler supersedes the “@exceptions_app” snare with its own particular controller and perspectives. This implies you’re fundamentally ready to conjure “dynamic” website pages with Rails.
The manner in which ExceptionHandler works is to utilize the application’s “default” design (ordinarily “application”) for 4xx blunders, and incorporate a totally custom “special case” format for 5xx mistakes. The custom design is for the most part prescribed as 5xx blunders signify server issues, which implies that in case you’re utilizing a format that references the database (as most “application” formats do), it could make a limitless circle happen.
This implies on the off chance that you have a mistake – say ActiveRecord can’t stack a record from the database – Rails will at present conjure ActiveDispatch::ShowExceptions.
Nonetheless, because of ExceptionHandler abrogating the “exceptions_app” snare, as opposed to the static 404.HTML/500.HTML pages being called, the controller and perspectives pipeline given by the diamond are summoned.
In the event that you need to peruse more about ExceptionHandler, the pleasure is all mine to take a gander at its Github responsitory.