grape 4.0.1 → 4.1.0

data/lib/grape/middleware/error.rb

@@ -3,7 +3,6 @@
 module Grape
   module Middleware
     class Error < Base
-      extend Forwardable
       include PrecomputedContentTypes
 
       Options = Data.define(
@@ -25,30 +24,27 @@ module Grape
           # `Endpoint#error_middleware_options` when the API called no
           # `rescue_from` and no `format` — and an explicit nil bypasses the
           # keyword defaults above, so restore them here rather than letting nil
-          # propagate to `def_delegator :rescue_options, :backtrace` or to the
-          # formatter lookup in `#format_message`.
-          super(
-            rescue_options: rescue_options || Grape::DSL::RescueOptions.new,
-            default_error_formatter: default_error_formatter || Grape::ErrorFormatter::Txt,
-            all_rescue_handler:, base_only_rescue_handlers:, content_types:,
-            default_message:, default_status:, error_formatters:, format:,
-            grape_exceptions_rescue_handler:, internal_grape_exceptions_rescue_handler:,
-            rescue_all:, rescue_grape_exceptions:, rescue_handlers:
-          )
+          # reach `rescue_options.backtrace` in `#initialize` or the formatter
+          # lookup in `#format_message`. A bare `super` hands the parameters
+          # over as they stand, these two included.
+          rescue_options ||= Grape::DSL::RescueOptions.new
+          default_error_formatter ||= Grape::ErrorFormatter::Txt
+          super
         end
       end
 
-      def_delegators :config,
-                     :all_rescue_handler, :base_only_rescue_handlers, :default_error_formatter,
-                     :default_message, :default_status, :error_formatters, :format,
-                     :grape_exceptions_rescue_handler, :internal_grape_exceptions_rescue_handler,
-                     :rescue_all, :rescue_grape_exceptions, :rescue_handlers, :rescue_options
+      # Read off ivars rather than delegated into +config+: rendering an error
+      # asks for most of them, and each delegator cost a Forwardable frame plus
+      # a Data reader for a value that was fixed when the middleware was built.
+      attr_reader :all_rescue_handler, :base_only_rescue_handlers, :default_error_formatter,
+                  :default_message, :default_status, :error_formatters, :format,
+                  :grape_exceptions_rescue_handler, :internal_grape_exceptions_rescue_handler,
+                  :rescue_all, :rescue_grape_exceptions, :rescue_handlers, :rescue_options
 
       # +:backtrace+ / +:original_exception+ on the rescue options become
       # +#include_backtrace+ / +#include_original_exception+ on the middleware,
       # which is what the formatter call site reads.
-      def_delegator :rescue_options, :backtrace, :include_backtrace
-      def_delegator :rescue_options, :original_exception, :include_original_exception
+      attr_reader :include_backtrace, :include_original_exception
 
       # Emitted by {#render_failsafe_response} once even the framework's own message
       # could not be rendered. Deliberately built without a formatter, an i18n
@@ -57,18 +53,93 @@ module Grape
       FAILSAFE_MESSAGE = '500 Internal Server Error'
       FAILSAFE_CONTENT_TYPE = 'text/plain'
 
+      def initialize(app, **options)
+        super
+        read_rescue_config(config)
+        read_rendering_config(config)
+      end
+
+      # Base#call copies the middleware for every request so that #call! can
+      # keep the env in an ivar, but only rendering an error reads it there. A
+      # request that goes through without one is answered by the one instance
+      # the stack built, and a copy is taken once there is an error to render.
+      def call(env)
+        respond(env).to_a
+      end
+
       def call!(env)
         @env = env
-        error_response(catch(:error) { return @app.call(@env) })
-      rescue Exception => e # rubocop:disable Lint/RescueException
-        run_rescue_handler(find_handler(e.class), e, @env[Grape::Env::API_ENDPOINT])
+        respond(env)
+      end
+
+      protected
+
+      # What #respond hands a thrown error or a raised exception to: a copy of
+      # the middleware, holding the request's env for the rendering below.
+      def render_thrown(env, error)
+        @env = env
+        error_response(error)
+      end
+
+      def render_raised(env, exception)
+        @env = env
+        run_rescue_handler(find_handler(exception.class), exception, env[Grape::Env::API_ENDPOINT])
       end
 
       private
 
+      # What #find_handler looks a rescue handler up in.
+      def read_rescue_config(config)
+        @all_rescue_handler = config.all_rescue_handler
+        @base_only_rescue_handlers = config.base_only_rescue_handlers
+        @grape_exceptions_rescue_handler = config.grape_exceptions_rescue_handler
+        @internal_grape_exceptions_rescue_handler = config.internal_grape_exceptions_rescue_handler
+        @rescue_all = config.rescue_all
+        @rescue_grape_exceptions = config.rescue_grape_exceptions
+        @rescue_handlers = config.rescue_handlers
+      end
+
+      # What an error response is rendered with.
+      def read_rendering_config(config)
+        @default_error_formatter = config.default_error_formatter
+        @default_message = config.default_message
+        @default_status = config.default_status
+        @error_formatters = config.error_formatters
+        @format = config.format
+        @rescue_options = config.rescue_options
+        @include_backtrace = @rescue_options.backtrace
+        @include_original_exception = @rescue_options.original_exception
+      end
+
+      # Whether the app answered is recorded rather than returned from inside
+      # the +catch+ block: a +return+ there leaves the method through Kernel#catch,
+      # which unwinds like a throw and allocates for it, on every request that
+      # did not fail.
+      #
+      # +error!+ raises a Halt carrying what a +throw :error+ carries. It is
+      # taken inside the +catch+, so it is rendered where a thrown error is and
+      # never reaches a +rescue_from+ handler, the +:all+ one included.
+      def respond(env)
+        answered = false
+        response = catch(:error) do
+          app_response = @app.call(env)
+          answered = true
+          app_response
+        rescue Grape::Exceptions::Halt => e
+          e.response
+        end
+        answered ? response : dup.render_thrown(env, response)
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        dup.render_raised(env, e)
+      end
+
+      # +headers+ is handed over as it is: Rack::Response copies it into a
+      # Headers of its own on every supported Rack (Rack 2.2 through
+      # +HeaderHash[]+, which only adopts a Hash that already is one), and every
+      # caller builds it fresh for this response.
       def rack_response(status, headers, message)
         body = html_content_type?(headers[Rack::CONTENT_TYPE]) ? Rack::Utils.escape_html(message) : message
-        Rack::Response.new(Array.wrap(body), Rack::Utils.status_code(status), Grape::Util::Header.new.merge!(headers))
+        Rack::Response.new(Array.wrap(body), Rack::Utils.status_code(status), headers)
       end
 
       # Escaping must key off the media type only, case-insensitively. Comparing
@@ -87,7 +158,7 @@ module Grape
       # API set another — takes it from there, so this always has something
       # callable. The +throw :error, 406+ that used to stand in for a missing
       # formatter could not work anyway: nothing catches +:error+ around this
-      # call (+#call!+ has left its +catch+ by the time +error_response+ runs),
+      # call (+#respond+ has left its +catch+ by the time +error_response+ runs),
       # so it raised +UncaughtThrowError+ and the request answered with the
       # failsafe 500 rather than the 406 it named.
       def format_message(error)
@@ -108,18 +179,25 @@ module Grape
 
       def error_response(error = nil)
         raw = Grape::Exceptions::ErrorResponse.coerce(error)
-        headers = { Rack::CONTENT_TYPE => content_type }
-        headers.merge!(raw.headers) if raw.headers.is_a?(Hash)
-        payload = raw.with(
+        payload = Grape::Exceptions::ErrorResponse.new(
           status: raw.status || default_status,
           message: raw.message || default_message,
-          headers:,
-          backtrace: resolved_backtrace(raw)
+          headers: error_response_headers(raw.headers),
+          backtrace: resolved_backtrace(raw),
+          original_exception: raw.original_exception
         )
         env[Grape::Env::API_ENDPOINT].status(payload.status) # error! may not have been called
         render_response(payload)
       end
 
+      # The content type the error renders as, under any +headers+ it carries.
+      def error_response_headers(headers)
+        content_type_header = { Rack::CONTENT_TYPE => content_type }
+        return content_type_header unless headers.is_a?(Hash)
+
+        content_type_header.merge!(headers)
+      end
+
       # The backtrace an error formatter is handed. Assembled only when the API
       # asked for one with `rescue_from ..., backtrace: true`: reading it off
       # the exception is not free — +Exception#backtrace+ builds the whole Array
@@ -131,11 +209,11 @@ module Grape
         raw.backtrace || raw.original_exception&.backtrace || []
       end
 
-      # Rendering runs inside #call!'s own rescue clause, so it is not covered by
-      # that rescue: an error formatter that raises on the payload it was handed
-      # takes the exception out through every middleware above Grape. By this
-      # point Grape has committed to answering with an error, so it answers with
-      # one that does not depend on the payload rather than dropping the request.
+      # An error formatter that raises on its payload would take the exception
+      # out through every middleware above Grape: rendering from a rescue
+      # handler runs in #respond's rescue clause, which nothing covers. Grape has
+      # committed to an error by now, so it answers with one that does not
+      # depend on the payload.
       #
       # +Grape.config.raise_rendering_errors+ opts back out, for an application
       # that would rather have the exception propagate as it did before.
@@ -192,11 +270,13 @@ module Grape
         )
       end
 
+      # No +backtrace:+: #resolved_backtrace reads it off +original_exception+
+      # when the API asked for one, and only then, since building it is the
+      # dearest part of rendering the error.
       def default_rescue_handler(exception)
         error_response(
           Grape::Exceptions::ErrorResponse.new(
             message: exception.message,
-            backtrace: exception.backtrace,
             original_exception: exception
           )
         )
@@ -268,8 +348,12 @@ module Grape
       def run_rescue_handler(handler, error, endpoint, redispatched: false)
         callable = handler.is_a?(Symbol) ? endpoint.public_method(handler) : handler
         response = catch(:error) do
-          callable.arity.zero? ? endpoint.instance_exec(&callable) : endpoint.instance_exec(error, &callable)
+          call_rescue_handler(callable, error, endpoint)
+        rescue Grape::Exceptions::Halt => e
+          e.response
         rescue StandardError => e
+          raise if Grape.config.raise_rescue_handler_errors
+
           return redispatch(e, endpoint, redispatched)
         end
 
@@ -279,6 +363,20 @@ module Grape
         run_rescue_handler(method(:default_rescue_handler), Grape::Exceptions::InvalidResponse.new, endpoint)
       end
 
+      # A +rescue_from+ block runs as the endpoint. A Method (the middleware's
+      # own handlers, or the endpoint's for a +with:+ Symbol) is already bound
+      # to a receiver that instance_exec cannot change, so it is called as it
+      # is rather than turned into a Proc first.
+      def call_rescue_handler(callable, error, endpoint)
+        if callable.is_a?(Method)
+          callable.arity.zero? ? callable.call : callable.call(error)
+        elsif callable.arity.zero?
+          endpoint.instance_exec(&callable)
+        else
+          endpoint.instance_exec(error, &callable)
+        end
+      end
+
       # Route an exception raised inside a +rescue_from+ block.
       #
       # * If we have already redispatched once (the redispatched handler