grape 3.2.1 → 3.3.0

data/lib/grape/dsl/rescue_options.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Grape
+  module DSL
+    # Immutable value object holding the response-shaping booleans accepted
+    # by +Grape::DSL::RequestResponse#rescue_from+. Stored on the
+    # inheritable settings as +namespace_stackable[:rescue_options]+ and
+    # delegated to by +Grape::Middleware::Error+ (which forwards
+    # +backtrace+/+original_exception+ to the formatter as
+    # +include_backtrace+/+include_original_exception+).
+    #
+    # Defaults are duplicated on +#initialize+ here and on +#rescue_from+'s
+    # signature on purpose: keeping them on both sides means each entry point
+    # is self-documenting without needing to import a shared constant — the
+    # DSL signature shows what a user sees in the IDE, and the Data object
+    # has working defaults when constructed directly (middleware
+    # `DEFAULT_OPTIONS`, spec fixtures, etc.). The two must stay in lockstep.
+    RescueOptions = Data.define(:backtrace, :original_exception) do
+      def initialize(backtrace: false, original_exception: false)
+        super
+      end
+    end
+  end
+end

data/lib/grape/dsl/routing.rb

@@ -23,6 +23,12 @@ module Grape
 
       # Specify an API version.
       #
+      # Called without arguments, returns the most recently declared version
+      # (or +nil+). Called with one or more version strings, registers them
+      # and stores a {Grape::DSL::VersionOptions} value object on the
+      # inheritable settings; when given a block, the registration applies
+      # within a nested namespace.
+      #
       # @example API with legacy support.
       #   class MyAPI < Grape::API
       #     version 'v2'
@@ -38,26 +44,41 @@ module Grape
       #     end
       #   end
       #
-      def version(*args, **options, &block)
-        if args.any?
-          options = options.reverse_merge(using: :path)
-          requested_versions = args.flatten.map(&:to_s)
-
-          raise Grape::Exceptions::MissingVendorOption.new if options[:using] == :header && !options.key?(:vendor)
-
-          @versions = versions | requested_versions
-
-          if block
-            within_namespace do
-              inheritable_setting.namespace_inheritable[:version] = requested_versions
-              inheritable_setting.namespace_inheritable[:version_options] = options
-
-              instance_eval(&block)
-            end
-          else
+      # @param args [Array<String, Symbol>] one or more version identifiers.
+      # @param using [Symbol] versioning strategy — one of +:path+ (default),
+      #   +:header+, +:param+, or +:accept_version_header+.
+      # @param cascade [Boolean] forward to subsequent routes via the
+      #   +X-Cascade+ header on version mismatch. Defaults to +true+.
+      # @param parameter [String] name of the query/body parameter that
+      #   carries the version when +using: :param+. Defaults to +'apiver'+.
+      # @param strict [Boolean] reject requests that don't supply a usable
+      #   version (header strategies). Defaults to +false+.
+      # @param vendor [String, nil] vendor segment for the +:header+
+      #   strategy (+application/vnd.<vendor>-<version>+); required when
+      #   +using: :header+.
+      # @yield optional block to scope routes under this version.
+      # @return [String, nil] the most recently declared version.
+      # @raise [Grape::Exceptions::MissingVendorOption] when +using: :header+
+      #   is supplied without a +:vendor+.
+      def version(*args, using: :path, cascade: true, parameter: 'apiver', strict: false, vendor: nil, &block)
+        return @versions&.last if args.empty?
+
+        raise Grape::Exceptions::MissingVendorOption.new if using == :header && vendor.nil?
+
+        requested_versions = args.flatten.map(&:to_s)
+        options = VersionOptions.new(using:, cascade:, parameter:, strict:, vendor:)
+
+        @versions = versions | requested_versions
+
+        if block
+          within_namespace do
             inheritable_setting.namespace_inheritable[:version] = requested_versions
             inheritable_setting.namespace_inheritable[:version_options] = options
+            instance_eval(&block)
           end
+        else
+          inheritable_setting.namespace_inheritable[:version] = requested_versions
+          inheritable_setting.namespace_inheritable[:version_options] = options
         end
 
         @versions&.last
@@ -113,7 +134,7 @@ module Grape
           in_setting = inheritable_setting
 
           if app.respond_to?(:inheritable_setting, true)
-            mount_path = Grape::Router.normalize_path(path)
+            mount_path = Grape::Util::PathNormalizer.call(path)
             app.top_level_setting.namespace_stackable[:mount_path] = mount_path
 
             app.inherit_settings(inheritable_setting)
@@ -163,7 +184,7 @@ module Grape
         endpoint_description = inheritable_setting.route[:description]
         all_route_options = { params: endpoint_params }
         all_route_options.deep_merge!(endpoint_description) if endpoint_description
-        all_route_options.deep_merge!(route_options) if route_options&.any?
+        all_route_options.deep_merge!(route_options) if route_options.present?
 
         new_endpoint = Grape::Endpoint.new(
           inheritable_setting,
@@ -180,9 +201,8 @@ module Grape
       end
 
       Grape::HTTP_SUPPORTED_METHODS.each do |supported_method|
-        define_method supported_method.downcase do |*args, **options, &block|
-          paths = args.first || ['/']
-          route(supported_method, paths, options, &block)
+        define_method supported_method.downcase do |path = '/', **options, &block|
+          route(supported_method, path, options, &block)
         end
       end
 
@@ -260,28 +280,24 @@ module Grape
       # of settings stack pushes.
       def nest(*blocks, &block)
         blocks.compact!
-        if blocks.any?
-          evaluate_as_instance_with_configuration(block) if block
-          blocks.each { |b| evaluate_as_instance_with_configuration(b) }
-          reset_validations!
-        else
-          instance_eval(&block)
-        end
+        return instance_eval(&block) if blocks.empty?
+
+        evaluate_as_instance_with_configuration(block) if block
+        blocks.each { |b| evaluate_as_instance_with_configuration(b) }
+        reset_validations!
       end
 
       def evaluate_as_instance_with_configuration(block, lazy: false)
         lazy_block = Grape::Util::Lazy::Block.new do |configuration|
           value_for_configuration = configuration
-          self.configuration = value_for_configuration.evaluate if value_for_configuration.respond_to?(:lazy?) && value_for_configuration.lazy?
+          self.configuration = value_for_configuration.evaluate if value_for_configuration.is_a?(Grape::Util::Lazy::Base)
           response = instance_eval(&block)
           self.configuration = value_for_configuration
           response
         end
-        if @base && base_instance? && lazy
-          lazy_block
-        else
-          lazy_block.evaluate_from(configuration)
-        end
+        return lazy_block if @base && base_instance? && lazy
+
+        lazy_block.evaluate_from(configuration)
       end
     end
   end

data/lib/grape/dsl/settings.rb

@@ -11,19 +11,25 @@ module Grape
 
       # Fetch our top-level settings, which apply to all endpoints in the API.
       def top_level_setting
-        @top_level_setting ||= Grape::Util::InheritableSetting.new.tap do |setting|
-          # Doesn't try to inherit settings from +Grape::API::Instance+ which also responds to
-          # +inheritable_setting+, however, it doesn't contain any user-defined settings.
-          # Otherwise, it would lead to an extra instance of +Grape::Util::InheritableSetting+
-          # in the chain for every endpoint.
-          setting.inherit_from superclass.inheritable_setting if defined?(superclass) && superclass.respond_to?(:inheritable_setting) && superclass != Grape::API::Instance
-        end
+        return @top_level_setting if @top_level_setting
+
+        @top_level_setting = Grape::Util::InheritableSetting.new
+        # Doesn't try to inherit settings from +Grape::API::Instance+ which also responds to
+        # +inheritable_setting+, however, it doesn't contain any user-defined settings.
+        # Otherwise, it would lead to an extra instance of +Grape::Util::InheritableSetting+
+        # in the chain for every endpoint.
+        @top_level_setting.inherit_from superclass.inheritable_setting if defined?(superclass) && superclass.respond_to?(:inheritable_setting) && superclass != Grape::API::Instance
+        @top_level_setting
       end
 
       # Fetch our current inheritable settings, which are inherited by
       # nested scopes but not shared across siblings.
       def inheritable_setting
-        @inheritable_setting ||= Grape::Util::InheritableSetting.new.tap { |new_settings| new_settings.inherit_from top_level_setting }
+        return @inheritable_setting if @inheritable_setting
+
+        @inheritable_setting = Grape::Util::InheritableSetting.new
+        @inheritable_setting.inherit_from top_level_setting
+        @inheritable_setting
       end
 
       def global_setting(key, value = nil)

data/lib/grape/dsl/version_options.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Grape
+  module DSL
+    # Immutable value object holding the resolved options from
+    # +Grape::DSL::Routing#version+. Stored on the inheritable settings as
+    # +namespace_inheritable[:version_options]+ and read by internal call
+    # sites (`Path`, `Endpoint`, `API::Instance#cascade?`,
+    # `Middleware::Versioner::Base`) via accessors.
+    #
+    # Defaults are duplicated on +#initialize+ here and on +#version+'s
+    # signature on purpose: keeping them on both sides means each entry point
+    # is self-documenting without needing to import a shared constant — the
+    # DSL signature shows what a user sees in the IDE, and the Data object
+    # has working defaults when constructed directly (middleware
+    # `DEFAULT_OPTIONS`, spec fixtures, etc.). The two must stay in lockstep.
+    VersionOptions = Data.define(:using, :cascade, :parameter, :strict, :vendor) do
+      def initialize(using: :path, cascade: true, parameter: 'apiver', strict: false, vendor: nil)
+        super
+      end
+    end
+  end
+end

data/lib/grape/endpoint/options.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Grape
+  class Endpoint
+    # Immutable value object holding the keyword inputs passed to
+    # +Grape::Endpoint.new+. Internal to {Grape::Endpoint}, which builds it
+    # from the +**options+ Hash in #initialize so the public +options+ reader
+    # stays a plain Hash for downstream gems (e.g. grape-swagger).
+    # +:method+ is renamed to +:http_methods+ on the value object to avoid
+    # shadowing +Object#method+ via the generated Data accessor.
+    Options = Data.define(:path, :http_methods, :for, :route_options, :app, :format, :forward_match) do
+      def initialize(path:, method:, route_options: {}, app: nil, format: nil, forward_match: nil, **rest)
+        path = Array(path)
+        path << '/' if path.empty?
+        super(path:, http_methods: Array(method), route_options:, app:, format:, forward_match:, **rest)
+      end
+    end
+  end
+end

data/lib/grape/endpoint.rb

@@ -12,29 +12,19 @@ module Grape
     include Grape::DSL::InsideRoute
 
     attr_reader :env, :request, :source, :options, :endpoints
+    attr_accessor :options_route_enabled
 
     def_delegators :request, :params, :headers, :cookies
     def_delegator :cookies, :response_cookies
 
-    class << self
-      def before_each(new_setup = false, &block)
-        @before_each ||= []
-        if new_setup == false
-          return @before_each unless block
-
-          @before_each << block
-        elsif new_setup
-          @before_each = [new_setup]
-        else
-          @before_each.clear
-        end
-      end
-
-      def run_before_each(endpoint)
-        superclass.run_before_each(endpoint) unless self == Endpoint
-        before_each.each { |blk| blk.call(endpoint) }
-      end
+    # The logger configured on the API this endpoint belongs to. Available
+    # inside route handlers, +before+/+after+/+after_validation+/+finally+
+    # filters, and +rescue_from+ blocks.
+    def logger
+      config.for.logger
+    end
 
+    class << self
       def block_to_unbound_method(block)
         return unless block
 
@@ -48,7 +38,8 @@ module Grape
     # Create a new endpoint.
     # @param new_settings [InheritableSetting] settings to determine the params,
     #   validations, and other properties from.
-    # @param options [Hash] attributes of this endpoint
+    # @param options [Hash] attributes of this endpoint, normalized into a
+    #   +Grape::Endpoint::Options+ value object.
     # @option options path [String or Array] the path to this endpoint, within
     #   the current scope.
     # @option options method [String or Array] which HTTP method(s) can be used
@@ -64,23 +55,24 @@ module Grape
       # this endpoint and its parents, but later it will be cleaned up,
       # see +reset_validations!+ in lib/grape/dsl/validations.rb
       inheritable_setting.route[:declared_params] = inheritable_setting.namespace_stackable[:declared_params].flatten
-      inheritable_setting.route[:saved_validations] = inheritable_setting.namespace_stackable[:validations]
+      inheritable_setting.route[:saved_validations] = inheritable_setting.namespace_stackable[:validations].dup
 
       inheritable_setting.namespace_stackable[:representations] ||= []
       inheritable_setting.namespace_inheritable[:default_error_status] ||= 500
 
       @options = options
-
       @options[:path] = Array(@options[:path])
       @options[:path] << '/' if @options[:path].empty?
       @options[:method] = Array(@options[:method])
+      @config = Options.new(**options)
 
       @status = nil
       @stream = nil
       @body = nil
       @source = self.class.block_to_unbound_method(block)
       @before_filter_passed = false
-      @endpoints = @options[:app].endpoints if @options[:app].respond_to?(:endpoints)
+      @options_route_enabled = false
+      @endpoints = @config.app.endpoints if @config.app.respond_to?(:endpoints)
     end
 
     # Update our settings from a given set of stackable parameters. Used when
@@ -141,8 +133,8 @@ module Grape
 
     def ==(other)
       other.is_a?(self.class) &&
-        options == other.options &&
-        inheritable_setting.to_hash == other.inheritable_setting.to_hash
+        config == other.config &&
+        inheritable_setting == other.inheritable_setting
     end
     alias eql? ==
 
@@ -158,10 +150,9 @@ module Grape
     protected
 
     def run
-      ActiveSupport::Notifications.instrument('endpoint_run.grape', endpoint: self, env:) do
-        @request = Grape::Request.new(env, build_params_with: inheritable_setting.namespace_inheritable[:build_params_with])
+      instrument_run do
+        @request = Grape::Request.new(env, build_params_with: @build_params_with)
         begin
-          self.class.run_before_each(self)
           run_filters befores, :before
           @before_filter_passed = true
 
@@ -169,7 +160,6 @@ module Grape
             header['Allow'] = env[Grape::Env::GRAPE_ALLOWED_METHODS].join(', ')
             raise Grape::Exceptions::MethodNotAllowed.new(header) unless options?
 
-            header 'Allow', header['Allow']
             response_object = ''
             status 204
           else
@@ -198,77 +188,104 @@ module Grape
     def execute
       return unless source
 
-      ActiveSupport::Notifications.instrument('endpoint_render.grape', endpoint: self) do
+      instrument_render do
         source.bind_call(self)
       end
     end
 
     def run_validators(request:)
       validators = inheritable_setting.route[:saved_validations]
-      return if validators.empty?
+      return if validators.blank?
 
-      validation_errors = []
+      validation_exceptions = nil
 
       Grape::Validations::ParamScopeTracker.track do
-        ActiveSupport::Notifications.instrument('endpoint_run_validators.grape', endpoint: self, validators:, request:) do
+        instrument_run_validators(validators, request) do
           validators.each do |validator|
             validator.validate(request)
-          rescue Grape::Exceptions::Validation => e
-            validation_errors << e
-            break if validator.fail_fast?
-          rescue Grape::Exceptions::ValidationArrayErrors => e
-            validation_errors.concat e.errors
+          rescue Grape::Exceptions::Validation, Grape::Exceptions::ValidationArrayErrors => e
+            (validation_exceptions ||= []) << e
             break if validator.fail_fast?
           end
         end
       end
 
-      raise(Grape::Exceptions::ValidationErrors.new(errors: validation_errors, headers: header)) if validation_errors.any?
+      raise Grape::Exceptions::ValidationErrors.new(exceptions: validation_exceptions, headers: header) if validation_exceptions
     end
 
     def run_filters(filters, type = :other)
-      return unless filters
+      return if filters.blank?
 
-      ActiveSupport::Notifications.instrument('endpoint_run_filters.grape', endpoint: self, filters:, type:) do
+      instrument_run_filters(filters, type) do
         filters.each { |filter| instance_eval(&filter) }
       end
     end
 
-    %i[befores before_validations after_validations afters finallies].each do |method|
-      define_method method do
-        inheritable_setting.namespace_stackable[method]
-      end
-    end
+    attr_reader :befores, :before_validations, :after_validations, :afters, :finallies, :config
 
     def options?
-      options[:options_route_enabled] &&
-        env[Rack::REQUEST_METHOD] == Rack::OPTIONS
+      options_route_enabled && env[Rack::REQUEST_METHOD] == Rack::OPTIONS
     end
 
     private
 
     attr_reader :before_filter_passed
 
+    # Instrument helpers. Each guards on +listening?+ so that with no subscriber
+    # the payload Hash and notification machinery are skipped and the block runs
+    # directly (no added allocations); the block is forwarded anonymously so
+    # nothing is allocated unless a subscriber is present.
+    def instrument_run(&)
+      return yield unless ActiveSupport::Notifications.notifier.listening?('endpoint_run.grape')
+
+      ActiveSupport::Notifications.instrument('endpoint_run.grape', endpoint: self, env:, &)
+    end
+
+    def instrument_render(&)
+      return yield unless ActiveSupport::Notifications.notifier.listening?('endpoint_render.grape')
+
+      ActiveSupport::Notifications.instrument('endpoint_render.grape', endpoint: self, &)
+    end
+
+    def instrument_run_validators(validators, request, &)
+      return yield unless ActiveSupport::Notifications.notifier.listening?('endpoint_run_validators.grape')
+
+      ActiveSupport::Notifications.instrument('endpoint_run_validators.grape', endpoint: self, validators:, request:, &)
+    end
+
+    def instrument_run_filters(filters, type, &)
+      return yield unless ActiveSupport::Notifications.notifier.listening?('endpoint_run_filters.grape')
+
+      ActiveSupport::Notifications.instrument('endpoint_run_filters.grape', endpoint: self, filters:, type:, &)
+    end
+
     def compile!
-      @app = options[:app] || build_stack
+      @app = config.app || build_stack
       @helpers = build_helpers
+      stackable = inheritable_setting.namespace_stackable
+      @befores            = stackable[:befores]
+      @before_validations = stackable[:before_validations]
+      @after_validations  = stackable[:after_validations]
+      @afters             = stackable[:afters]
+      @finallies          = stackable[:finallies]
+      @build_params_with  = inheritable_setting.namespace_inheritable[:build_params_with]
     end
 
     def to_routes
-      route_options = options[:route_options]
+      route_options = config.route_options
       default_route_options = prepare_default_route_attributes(route_options)
       complete_route_options = route_options.merge(default_route_options)
       path_settings = prepare_default_path_settings
 
-      options[:method].flat_map do |method|
-        options[:path].map do |path|
+      config.http_methods.flat_map do |method|
+        config.path.map do |path|
           prepared_path = Path.new(path, default_route_options[:namespace], path_settings)
           pattern = Grape::Router::Pattern.new(
             origin: prepared_path.origin,
             suffix: prepared_path.suffix,
             anchor: default_route_options[:anchor],
             params: route_options[:params],
-            format: options[:format],
+            format: config.format,
             version: default_route_options[:version],
             requirements: default_route_options[:requirements]
           )
@@ -285,7 +302,7 @@ module Grape
         prefix: inheritable_setting.namespace_inheritable[:root_prefix],
         anchor: route_options.fetch(:anchor, true),
         settings: inheritable_setting.route.except(:declared_params, :saved_validations),
-        forward_match: options[:forward_match]
+        forward_match: config.forward_match
       }
     end
 
@@ -315,26 +332,15 @@ module Grape
 
       stack.use Rack::Head
       stack.use Rack::Lint if lint?
-      stack.use Grape::Middleware::Error,
-                format:,
-                content_types:,
-                default_status: inheritable_setting.namespace_inheritable[:default_error_status],
-                rescue_all: inheritable_setting.namespace_inheritable[:rescue_all],
-                rescue_grape_exceptions: inheritable_setting.namespace_inheritable[:rescue_grape_exceptions],
-                default_error_formatter: inheritable_setting.namespace_inheritable[:default_error_formatter],
-                error_formatters: inheritable_setting.namespace_stackable_with_hash(:error_formatters),
-                rescue_options: inheritable_setting.namespace_stackable_with_hash(:rescue_options),
-                rescue_handlers:,
-                base_only_rescue_handlers: inheritable_setting.namespace_stackable_with_hash(:base_only_rescue_handlers),
-                all_rescue_handler: inheritable_setting.namespace_inheritable[:all_rescue_handler],
-                grape_exceptions_rescue_handler: inheritable_setting.namespace_inheritable[:grape_exceptions_rescue_handler]
+      stack.use Grape::Middleware::Error, **error_middleware_options(format, content_types)
 
       stack.concat inheritable_setting.namespace_stackable[:middleware]
 
       if inheritable_setting.namespace_inheritable[:version].present?
-        stack.use Grape::Middleware::Versioner.using(inheritable_setting.namespace_inheritable[:version_options][:using]),
+        version_options = inheritable_setting.namespace_inheritable[:version_options]
+        stack.use Grape::Middleware::Versioner.using(version_options.using),
                   versions: inheritable_setting.namespace_inheritable[:version].flatten,
-                  version_options: inheritable_setting.namespace_inheritable[:version_options],
+                  version_options:,
                   prefix: inheritable_setting.namespace_inheritable[:root_prefix],
                   mount_path: inheritable_setting.namespace_stackable[:mount_path].first
       end
@@ -351,6 +357,26 @@ module Grape
       builder.to_app
     end
 
+    def error_middleware_options(format, content_types)
+      ns_inh = inheritable_setting.namespace_inheritable
+      ns_stack = inheritable_setting
+      {
+        format:,
+        content_types:,
+        default_status: ns_inh[:default_error_status],
+        rescue_all: ns_inh[:rescue_all],
+        rescue_grape_exceptions: ns_inh[:rescue_grape_exceptions],
+        default_error_formatter: ns_inh[:default_error_formatter],
+        error_formatters: ns_stack.namespace_stackable_with_hash(:error_formatters),
+        rescue_options: ns_stack.namespace_stackable[:rescue_options]&.last,
+        rescue_handlers:,
+        base_only_rescue_handlers: ns_stack.namespace_stackable_with_hash(:base_only_rescue_handlers),
+        all_rescue_handler: ns_inh[:all_rescue_handler],
+        grape_exceptions_rescue_handler: ns_inh[:grape_exceptions_rescue_handler],
+        internal_grape_exceptions_rescue_handler: ns_inh[:internal_grape_exceptions_rescue_handler]
+      }
+    end
+
     def build_helpers
       helpers = inheritable_setting.namespace_stackable[:helpers]
       return if helpers.empty?
@@ -359,6 +385,8 @@ module Grape
     end
 
     def build_response_cookies
+      return unless request.cookies?
+
       response_cookies do |name, value|
         cookie_value = value.is_a?(Hash) ? value : { value: }
         Rack::Utils.set_cookie_header! header, name, cookie_value

data/lib/grape/env.rb

@@ -11,10 +11,8 @@ module Grape
     API_VENDOR = 'api.vendor'
     API_FORMAT = 'api.format'
 
-    GRAPE_REQUEST = 'grape.request'
-    GRAPE_REQUEST_HEADERS = 'grape.request.headers'
-    GRAPE_REQUEST_PARAMS = 'grape.request.params'
     GRAPE_ROUTING_ARGS = 'grape.routing_args'
     GRAPE_ALLOWED_METHODS = 'grape.allowed_methods'
+    GRAPE_EXCEPTION = 'grape.exception'
   end
 end

data/lib/grape/error_formatter/base.rb

@@ -4,34 +4,39 @@ module Grape
   module ErrorFormatter
     class Base
       class << self
-        def call(message, backtrace, options = {}, env = nil, original_exception = nil)
-          merge_backtrace = backtrace.present? && options.dig(:rescue_options, :backtrace)
-          merge_original_exception = original_exception && options.dig(:rescue_options, :original_exception)
-
-          wrapped_message = wrap_message(present(message, env))
+        # Custom error formatters override +call+. The +error+ is a frozen
+        # {Grape::Exceptions::ErrorResponse} carrying +status+/+message+/
+        # +headers+/+backtrace+/+original_exception+. +env+ is the Rack env
+        # (needed by entity-presenter resolution). +include_backtrace+ and
+        # +include_original_exception+ are the request-time toggles set by
+        # +rescue_from+; the base implementation embeds the corresponding
+        # fields in the response body when they are true.
+        def call(error:, env: nil, include_backtrace: false, include_original_exception: false)
+          wrapped_message = wrap_message(present(error.message, env))
           if wrapped_message.is_a?(Hash)
-            wrapped_message[:backtrace] = backtrace if merge_backtrace
-            wrapped_message[:original_exception] = original_exception.inspect if merge_original_exception
+            wrapped_message[:backtrace] = error.backtrace if include_backtrace && error.backtrace.present?
+            wrapped_message[:original_exception] = error.original_exception.inspect if include_original_exception && error.original_exception
           end
 
           format_structured_message(wrapped_message)
         end
 
         def present(message, env)
-          present_options = {}
-          presented_message = message
-          if presented_message.is_a?(Hash)
-            presented_message = presented_message.dup
-            present_options[:with] = presented_message.delete(:with)
+          # error! accepts a message hash with an optional :with key specifying the entity presenter.
+          # Extract it here so the presenter can be resolved and the key is not serialized in the response.
+          # See spec/integration/grape_entity/entity_spec.rb for examples.
+          with = nil
+          if message.is_a?(Hash) && message.key?(:with)
+            message = message.dup
+            with = message.delete(:with)
           end
 
-          presenter = env[Grape::Env::API_ENDPOINT].entity_class_for_obj(presented_message, present_options)
+          presenter = with || env[Grape::Env::API_ENDPOINT].entity_class_for_obj(message)
 
           unless presenter || env[Grape::Env::GRAPE_ROUTING_ARGS].nil?
             # env['api.endpoint'].route does not work when the error occurs within a middleware
             # the Endpoint does not have a valid env at this moment
             http_codes = env[Grape::Env::GRAPE_ROUTING_ARGS][:route_info].http_codes || []
-
             found_code = http_codes.find do |http_code|
               (http_code[0].to_i == env[Grape::Env::API_ENDPOINT].status) && http_code[2].respond_to?(:represent)
             end if env[Grape::Env::API_ENDPOINT].request
@@ -39,13 +44,11 @@ module Grape
             presenter = found_code[2] if found_code
           end
 
-          if presenter
-            embeds = { env: }
-            embeds[:version] = env[Grape::Env::API_VERSION] if env.key?(Grape::Env::API_VERSION)
-            presented_message = presenter.represent(presented_message, embeds).serializable_hash
-          end
+          return message unless presenter
 
-          presented_message
+          embeds = { env: }
+          embeds[:version] = env[Grape::Env::API_VERSION] if env.key?(Grape::Env::API_VERSION)
+          presenter.represent(message, embeds).serializable_hash
         end
 
         def wrap_message(message)

data/lib/grape/error_formatter/json.rb

@@ -11,10 +11,14 @@ module Grape
         private
 
         def wrap_message(message)
-          return message if message.is_a?(Hash)
-          return message.as_json if message.is_a?(Exceptions::ValidationErrors)
-
-          { error: ensure_utf8(message) }
+          case message
+          when Hash
+            message
+          when Exceptions::ValidationErrors
+            message.as_json
+          else
+            { error: ensure_utf8(message) }
+          end
         end
 
         def ensure_utf8(message)