It's now possible to catch all exceptions thrown within APIs and to specify the error format.

Author: dB

README.markdown

@@ -62,6 +62,31 @@ And would respond to the following routes:
 
 Serialization takes place automatically. For more detailed usage information, please visit the [Grape Wiki](http://github.com/intridea/grape/wiki).
 
+## Error Handling
+
+The default behavior of Grape is to rescue all exceptions and to return a 403 status code with the exception's message in the response body. 
+
+It's possible to disable this behavior and pass exceptions further up the stack. This usually means displaying the web server's error page as a result.
+
+    class Twitter::API < Grape::API
+      use Grape::Middleware::Error, :rescue => false
+      ...
+    end
+
+It's also common to change the error format to JSON. 
+
+    class Twitter::API < Grape::API
+      use Grape::Middleware::Error, :format => :json
+      ...
+    end
+
+Finally, you can specify your own error formatter. The following example returns a custom error message in the JSON format.
+
+    class Twitter::API < Grape::API
+      use Grape::Middleware::Error, :format => :custom, :formatters = { lambda { |message| { :custom => "the error message was: #{message}" } }
+      ...
+    end
+
 ## Note on Patches/Pull Requests
 
 * Fork the project.

lib/grape/middleware/error.rb

@@ -3,19 +3,73 @@
 module Grape
   module Middleware
     class Error < Base
+    
+      def default_options
+      { 
+        :default_status => 403, # default status returned on error
+        :rescue => true, # true to rescue all exceptions
+        :default_message => "",
+        :format => :txt,
+        :formatters => {},
+      }
+      end
+
+      FORMATTERS = {
+        :json => :format_json,
+        :txt => :format_txt,
+      }
+
+      def formatters
+        FORMATTERS.merge(options[:formatters])
+      end
+
+      def formatter_for(api_format)
+        spec = formatters[api_format]
+        case spec
+        when nil
+          lambda { |obj| obj }
+        when Symbol
+          method(spec)
+        else
+          spec
+        end
+      end
+
+      def format_json(message)
+        { :error => message }
+      end
+      
+      def format_txt(message)
+        message
+      end
+
       def call!(env)
         @env = env
-        result = catch :error do
-          @app.call(@env)
+        
+        begin
+          error_response(catch(:error){ 
+            return @app.call(@env) 
+          })
+        rescue Exception => e
+          raise unless options[:rescue]
+          error_response({ :message => e.message })
         end
 
-        result ||= {}
-        result.is_a?(Hash) ? error_response(result) : result
       end
 
       def error_response(error = {})
-        Rack::Response.new([(error[:message] || options[:default_message])], error[:status] || 403, error[:headers] || {}).finish
+        status = error[:status] || options[:default_status]
+        message = error[:message] || options[:default_message]
+        headers = error[:headers] || {}
+        Rack::Response.new([format_message(message, status)], status, headers).finish
+      end
+      
+      def format_message(message, status)
+        formatter = formatter_for(options[:format])
+        throw :error, :status => 406, :message => "The requested format #{options[:format]} is not supported." unless formatter        
+        formatter.call(message)
       end
+      
     end
   end
 end

spec/grape/middleware/error_spec.rb

@@ -46,4 +46,4 @@ def app
   context 'with formatting' do
 
   end
-end
+end

spec/grape/middleware/exception_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe Grape::Middleware::Error do
+  class ExceptionApp
+    class << self
+      def call(env)
+        raise "rain!"
+      end
+    end
+  end
+  
+  def app
+    @app
+  end
+  
+  it 'should set the message appropriately' do
+    @app ||= Rack::Builder.app do
+      use Grape::Middleware::Error
+      run ExceptionApp
+    end
+    get '/'
+    last_response.body.should == "rain!"
+  end
+
+  it 'should default to a 403 status' do
+    @app ||= Rack::Builder.app do
+      use Grape::Middleware::Error
+      run ExceptionApp
+    end
+    get '/'
+    last_response.status.should == 403
+  end
+
+  it 'should be possible to specify a different default status code' do
+    @app ||= Rack::Builder.app do
+      use Grape::Middleware::Error, :default_status => 500
+      run ExceptionApp
+    end
+    get '/'
+    last_response.status.should == 500
+  end
+     
+  it 'should be possible to disable exception trapping' do
+    @app ||= Rack::Builder.app do
+      use Grape::Middleware::Error, :rescue  => false
+      run ExceptionApp
+    end
+    lambda { get '/' }.should raise_error
+  end
+
+  it 'should be possible to return errors in json format' do
+    @app ||= Rack::Builder.app do
+      use Grape::Middleware::Error, :format => :json
+      run ExceptionApp
+    end
+    get '/'
+    last_response.body.should == '{:error=>"rain!"}'
+  end
+
+  it 'should be possible to specify a custom formatter' do
+    @app ||= Rack::Builder.app do
+      use Grape::Middleware::Error, 
+        :format => :custom, 
+        :formatters => { 
+          :custom => lambda { |message| { :custom_formatter => message } }  
+        }
+      run ExceptionApp
+    end
+    get '/'
+    last_response.body.should == '{:custom_formatter=>"rain!"}'
+  end
+  
+end