bugsnag 6.15.0 → 6.27.1

data/lib/bugsnag/integrations/railtie.rb

@@ -1,19 +1,78 @@
 # Rails 3.x hooks
 
-require "json"
 require "rails"
-require "bugsnag"
-require "bugsnag/middleware/rails3_request"
-require "bugsnag/middleware/rack_request"
 require "bugsnag/integrations/rails/rails_breadcrumbs"
 
 module Bugsnag
   class Railtie < ::Rails::Railtie
-
     FRAMEWORK_ATTRIBUTES = {
       :framework => "Rails"
     }
 
+    ##
+    # Subscribes to an ActiveSupport event, leaving a breadcrumb when it triggers
+    #
+    # @api private
+    # @param event [Hash] details of the event to subscribe to
+    def event_subscription(event)
+      ActiveSupport::Notifications.subscribe(event[:id]) do |*, event_id, data|
+        filtered_data = data.slice(*event[:allowed_data])
+        filtered_data[:event_name] = event[:id]
+        filtered_data[:event_id] = event_id
+
+        case event[:id]
+        when "sql.active_record"
+          if data.key?(:binds)
+            binds = data[:binds].each_with_object({}) { |bind, output| output[bind.name] = '?' if defined?(bind.name) }
+            filtered_data[:binds] = JSON.dump(binds) unless binds.empty?
+          end
+
+          # Rails < 6.1 included connection_id in the event data, but now
+          # includes the connection object instead
+          if data.key?(:connection) && !data.key?(:connection_id)
+            # the connection ID is the object_id of the connection object
+            filtered_data[:connection_id] = data[:connection].object_id
+          end
+
+        when "start_processing.action_controller"
+          filtered_data[:path] = Bugsnag.cleaner.clean_url(data[:path]) if data.key?(:path)
+
+        when "redirect_to.action_controller"
+          filtered_data[:location] = Bugsnag.cleaner.clean_url(data[:location]) if data.key?(:location)
+        end
+
+        Bugsnag.leave_breadcrumb(
+          event[:message],
+          filtered_data,
+          event[:type],
+          :auto
+        )
+      end
+    end
+
+    ##
+    # Do we need to rescue (& notify) in Active Record callbacks?
+    #
+    # On Rails versions < 4.2, Rails did not raise errors in AR callbacks
+    # On Rails version 4.2, a config option was added to control this
+    # On Rails version 5.0, the config option was removed and errors in callbacks
+    # always bubble up
+    #
+    # @api private
+    def self.rescue_in_active_record_callbacks?
+      # Rails 5+ will re-raise errors in callbacks, so we don't need to rescue them
+      return false if ::Rails::VERSION::MAJOR > 4
+
+      # before 4.2, errors were always swallowed, so we need to rescue them
+      return true if ::Rails::VERSION::MAJOR < 4
+
+      # a config option was added in 4.2 to control this, but won't exist in 4.0 & 4.1
+      return true unless ActiveRecord::Base.respond_to?(:raise_in_transactional_callbacks)
+
+      # if the config option is false, we need to rescue and notify
+      ActiveRecord::Base.raise_in_transactional_callbacks == false
+    end
+
     rake_tasks do
       require "bugsnag/integrations/rake"
       load "bugsnag/tasks/bugsnag.rake"
@@ -25,9 +84,9 @@ module Bugsnag
       # initializer. If not, the key will be validated in after_initialize.
       Bugsnag.configure(false) do |config|
         config.logger = ::Rails.logger
-        config.release_stage = ENV["BUGSNAG_RELEASE_STAGE"] || ::Rails.env.to_s
+        config.release_stage ||= ::Rails.env.to_s
         config.project_root = ::Rails.root.to_s
-        config.middleware.insert_before Bugsnag::Middleware::Callbacks, Bugsnag::Middleware::Rails3Request
+        config.internal_middleware.use(Bugsnag::Middleware::Rails3Request)
         config.runtime_versions["rails"] = ::Rails::VERSION::STRING
       end
 
@@ -37,13 +96,25 @@ module Bugsnag
       end
 
       ActiveSupport.on_load(:active_record) do
-        require "bugsnag/integrations/rails/active_record_rescue"
-        include Bugsnag::Rails::ActiveRecordRescue
+        if Bugsnag::Railtie.rescue_in_active_record_callbacks?
+          require "bugsnag/integrations/rails/active_record_rescue"
+          include Bugsnag::Rails::ActiveRecordRescue
+        end
+      end
+
+      ActiveSupport.on_load(:active_job) do
+        require "bugsnag/middleware/active_job"
+        Bugsnag.configuration.internal_middleware.use(Bugsnag::Middleware::ActiveJob)
+
+        require "bugsnag/integrations/rails/active_job"
+        include Bugsnag::Rails::ActiveJob
       end
 
       Bugsnag::Rails::DEFAULT_RAILS_BREADCRUMBS.each { |event| event_subscription(event) }
 
-      Bugsnag.configuration.app_type = "rails"
+      # Make sure we don't overwrite the value set by another integration because
+      # Rails is a less specific app_type (e.g. Que sets this earlier than us)
+      Bugsnag.configuration.detected_app_type ||= "rails"
     end
 
     # Configure meta_data_filters after initialization, so that rails initializers
@@ -63,32 +134,19 @@ module Bugsnag
 
     initializer "bugsnag.use_rack_middleware" do |app|
       begin
-        app.config.middleware.insert_after ActionDispatch::DebugExceptions, Bugsnag::Rack
-      rescue
-        app.config.middleware.use Bugsnag::Rack
-      end
-    end
-
-    ##
-    # Subscribes to an ActiveSupport event, leaving a breadcrumb when it triggers
-    #
-    # @api private
-    # @param event [Hash] details of the event to subscribe to
-    def event_subscription(event)
-      ActiveSupport::Notifications.subscribe(event[:id]) do |*, event_id, data|
-        filtered_data = data.slice(*event[:allowed_data])
-        filtered_data[:event_name] = event[:id]
-        filtered_data[:event_id] = event_id
-        if event[:id] == "sql.active_record" && data.key?(:binds)
-          binds = data[:binds].each_with_object({}) { |bind, output| output[bind.name] = '?' if defined?(bind.name) }
-          filtered_data[:binds] = JSON.dump(binds) unless binds.empty?
+        begin
+          app.config.middleware.insert_after ActionDispatch::DebugExceptions, Bugsnag::Rack
+        rescue
+          app.config.middleware.use Bugsnag::Rack
         end
-        Bugsnag.leave_breadcrumb(
-          event[:message],
-          filtered_data,
-          event[:type],
-          :auto
-        )
+      rescue FrozenError
+        # This can happen when running RSpec if there is a crash after Rails has
+        # started booting but before we've added our middleware. If we don't ignore
+        # this error then the stacktrace blames Bugsnag, which isn't accurate as
+        # the middleware will only be frozen if an earlier error occurs
+        # See this comment for more info:
+        # https://github.com/thoughtbot/factory_bot_rails/issues/303#issuecomment-434560625
+        Bugsnag.configuration.warn("Unable to add Bugsnag::Rack middleware as the middleware stack is frozen")
       end
     end
   end

data/lib/bugsnag/integrations/rake.rb

@@ -1,4 +1,7 @@
-require 'bugsnag'
+# this file can either be required manually by a user, in which case 'bugsnag'
+# needs to be required, or it can be required automatically in the railtie,
+# in which case 'bugsnag' has already been required
+require 'bugsnag' unless defined?(Bugsnag)
 
 Rake::TaskManager.record_task_metadata = true
 
@@ -11,7 +14,8 @@ if Gem::Version.new(RUBY_VERSION.dup) >= Gem::Version.new('2.0')
 
       # Executes the rake task with Bugsnag setup with contextual data.
       def execute(args = nil)
-        Bugsnag.configuration.app_type ||= "rake"
+        Bugsnag.configuration.detected_app_type = "rake"
+
         old_task = Bugsnag.configuration.request_data[:bugsnag_running_task]
         Bugsnag.configuration.set_request_data :bugsnag_running_task, self
         Bugsnag.configuration.runtime_versions["rake"] = ::Rake::VERSION
@@ -42,7 +46,8 @@ else
     ##
     # Executes the rake task with Bugsnag setup with contextual data.
     def execute_with_bugsnag(args=nil)
-      Bugsnag.configuration.app_type ||= "rake"
+      Bugsnag.configuration.detected_app_type = "rake"
+
       old_task = Bugsnag.configuration.request_data[:bugsnag_running_task]
       Bugsnag.configuration.set_request_data :bugsnag_running_task, self
       Bugsnag.configuration.runtime_versions["rake"] = ::Rake::VERSION

data/lib/bugsnag/integrations/resque.rb

@@ -21,7 +21,7 @@ module Bugsnag
       return if ::Resque::Failure.backend == self
 
       # Ensure resque is using a "Multiple" failure backend
-      unless ::Resque::Failure.backend < ::Resque::Failure::Multiple
+      unless ::Resque::Failure.backend <= ::Resque::Failure::Multiple
         original_backend = ::Resque::Failure.backend
         ::Resque::Failure.backend = ::Resque::Failure::Multiple
         ::Resque::Failure.backend.classes ||= []
@@ -44,9 +44,23 @@ module Bugsnag
           :attributes => FRAMEWORK_ATTRIBUTES
         }
 
-        context = "#{payload['class']}@#{queue}"
-        report.meta_data.merge!({:context => context, :payload => payload})
-        report.context = context
+        metadata = payload
+        class_name = metadata['class']
+
+        # when using Active Job the payload "class" will always be the Resque
+        # "JobWrapper", so we need to unwrap the actual class name
+        if class_name == "ActiveJob::QueueAdapters::ResqueAdapter::JobWrapper"
+          unwrapped_class_name = metadata['args'][0]['job_class'] rescue nil
+
+          if unwrapped_class_name
+            class_name = unwrapped_class_name
+            metadata['wrapped'] ||= unwrapped_class_name
+          end
+        end
+
+        context = "#{class_name}@#{queue}"
+        report.meta_data.merge!({ context: context, payload: metadata })
+        report.automatic_context = context
       end
     end
   end
@@ -58,16 +72,23 @@ Resque::Failure::Bugsnag = Bugsnag::Resque
 # Auto-load the failure backend
 Bugsnag::Resque.add_failure_backend
 
-if Resque::Worker.new(:bugsnag_fork_check).fork_per_job?
+worker = Resque::Worker.new(:bugsnag_fork_check)
+
+# If at_exit hooks are not enabled then we can't use the thread queue delivery
+# method because it relies on an at_exit hook to ensure the queue is flushed
+can_use_thread_queue = worker.respond_to?(:run_at_exit_hooks) && worker.run_at_exit_hooks
+default_delivery_method = can_use_thread_queue ? :thread_queue : :synchronous
+
+if worker.fork_per_job?
   Resque.after_fork do
-    Bugsnag.configuration.app_type = "resque"
-    Bugsnag.configuration.default_delivery_method = :synchronous
+    Bugsnag.configuration.detected_app_type = "resque"
+    Bugsnag.configuration.default_delivery_method = default_delivery_method
     Bugsnag.configuration.runtime_versions["resque"] = ::Resque::VERSION
   end
 else
   Resque.before_first_fork do
-    Bugsnag.configuration.app_type = "resque"
-    Bugsnag.configuration.default_delivery_method = :synchronous
+    Bugsnag.configuration.detected_app_type = "resque"
+    Bugsnag.configuration.default_delivery_method = default_delivery_method
     Bugsnag.configuration.runtime_versions["resque"] = ::Resque::VERSION
   end
 end

data/lib/bugsnag/integrations/shoryuken.rb

@@ -11,8 +11,9 @@ module Bugsnag
 
     def initialize
       Bugsnag.configure do |config|
-        config.app_type ||= "shoryuken"
+        config.detected_app_type = "shoryuken"
         config.default_delivery_method = :synchronous
+        config.runtime_versions["shoryuken"] = ::Shoryuken::VERSION
       end
     end
 

data/lib/bugsnag/integrations/sidekiq.rb

@@ -4,6 +4,7 @@ module Bugsnag
   ##
   # Extracts and attaches Sidekiq job and queue information to an error report
   class Sidekiq
+    include ::Sidekiq::ServerMiddleware if defined?(::Sidekiq::ServerMiddleware)
 
     unless const_defined?(:FRAMEWORK_ATTRIBUTES)
       FRAMEWORK_ATTRIBUTES = {
@@ -13,8 +14,7 @@ module Bugsnag
 
     def initialize
       Bugsnag.configuration.internal_middleware.use(Bugsnag::Middleware::Sidekiq)
-      Bugsnag.configuration.app_type = "sidekiq"
-      Bugsnag.configuration.default_delivery_method = :synchronous
+      Bugsnag.configuration.detected_app_type = "sidekiq"
       Bugsnag.configuration.runtime_versions["sidekiq"] = ::Sidekiq::VERSION
     end
 
@@ -50,7 +50,7 @@ module Bugsnag
 
     def self.configure_server(server)
       if Bugsnag::Sidekiq.sidekiq_supports_error_handlers
-        server.error_handlers << proc do |ex, _context|
+        server.error_handlers << proc do |ex, _context, _config = nil|
           Bugsnag::Sidekiq.notify(ex)
           Bugsnag.configuration.clear_request_data
         end

data/lib/bugsnag/middleware/active_job.rb

@@ -0,0 +1,18 @@
+module Bugsnag::Middleware
+  class ActiveJob
+    def initialize(bugsnag)
+      @bugsnag = bugsnag
+    end
+
+    def call(report)
+      data = report.request_data[:active_job]
+
+      if data
+        report.add_tab(:active_job, data)
+        report.automatic_context = "#{data[:job_name]}@#{data[:queue]}"
+      end
+
+      @bugsnag.call(report)
+    end
+  end
+end

data/lib/bugsnag/middleware/classify_error.rb

@@ -9,6 +9,7 @@ module Bugsnag::Middleware
         "ActionController::UnknownAction",
         "ActionController::UnknownFormat",
         "ActionController::UnknownHttpMethod",
+        "ActionDispatch::Http::MimeNegotiation::InvalidType",
         "ActiveRecord::RecordNotFound",
         "CGI::Session::CookieStore::TamperedWithCookie",
         "Mongoid::Errors::DocumentNotFound",

data/lib/bugsnag/middleware/delayed_job.rb

@@ -2,6 +2,11 @@ module Bugsnag::Middleware
   ##
   # Attaches delayed_job information to an error report
   class DelayedJob
+    # Active Job's queue adapter sets the "display_name" to this format. This
+    # breaks the event context as the ID and arguments are included, which will
+    # differ between executions of the same job
+    ACTIVE_JOB_DISPLAY_NAME = /^.* \[[0-9a-f-]+\] from DelayedJob\(.*\) with arguments: \[.*\]$/
+
     def initialize(bugsnag)
       @bugsnag = bugsnag
     end
@@ -23,7 +28,10 @@ module Bugsnag::Middleware
         if job.respond_to?(:payload_object)
           job_data[:active_job] = job.payload_object.job_data if job.payload_object.respond_to?(:job_data)
           payload_data = construct_job_payload(job.payload_object)
-          report.context = payload_data[:display_name] if payload_data.include?(:display_name)
+
+          context = get_context(payload_data, job_data[:active_job])
+          report.automatic_context = context unless context.nil?
+
           job_data[:payload] = payload_data
         end
 
@@ -69,5 +77,17 @@ module Bugsnag::Middleware
       end
       data
     end
+
+    private
+
+    def get_context(payload_data, active_job_data)
+      if payload_data.include?(:display_name) && !ACTIVE_JOB_DISPLAY_NAME.match?(payload_data[:display_name])
+        payload_data[:display_name]
+      elsif active_job_data && active_job_data['job_class'] && active_job_data['queue_name']
+        "#{active_job_data['job_class']}@#{active_job_data['queue_name']}"
+      elsif payload_data.include?(:class)
+        payload_data[:class]
+      end
+    end
   end
 end

data/lib/bugsnag/middleware/exception_meta_data.rb

@@ -16,6 +16,8 @@ module Bugsnag::Middleware
 
         if exception.respond_to?(:bugsnag_context)
           context = exception.bugsnag_context
+          # note: this should set 'context' not 'automatic_context' as it's a
+          #       user-supplied value
           report.context = context if context.is_a?(String)
         end
 

data/lib/bugsnag/middleware/rack_request.rb

@@ -3,6 +3,7 @@ module Bugsnag::Middleware
   # Extracts and attaches rack data to an error report
   class RackRequest
     SPOOF = "[SPOOF]".freeze
+    COOKIE_HEADER = "Cookie".freeze
 
     def initialize(bugsnag)
       @bugsnag = bugsnag
@@ -14,12 +15,20 @@ module Bugsnag::Middleware
 
         request = ::Rack::Request.new(env)
 
-        params = request.params rescue {}
+        params =
+          # if the request body isn't rewindable then we can't read request.POST
+          # which is used internally by request.params
+          if request.body.respond_to?(:rewind)
+            request.params rescue {}
+          else
+            request.GET rescue {}
+          end
+
         client_ip = request.ip.to_s rescue SPOOF
         session = env["rack.session"]
 
-        # Set the context
-        report.context = "#{request.request_method} #{request.path}"
+        # Set the automatic context
+        report.automatic_context = "#{request.request_method} #{request.path}"
 
         # Set a sensible default for user_id
         report.user["id"] = request.ip
@@ -42,22 +51,6 @@ module Bugsnag::Middleware
           Bugsnag.configuration.warn "RackRequest - Rescued error while cleaning request.referer: #{stde}"
         end
 
-        headers = {}
-
-        env.each_pair do |key, value|
-          if key.to_s.start_with?("HTTP_")
-            header_key = key[5..-1]
-          elsif ["CONTENT_TYPE", "CONTENT_LENGTH"].include?(key)
-            header_key = key
-          else
-            next
-          end
-
-          headers[header_key.split("_").map {|s| s.capitalize}.join("-")] = value
-        end
-
-        headers["Referer"] = referer if headers["Referer"]
-
         # Add a request tab
         report.add_tab(:request, {
           :url => url,
@@ -65,9 +58,17 @@ module Bugsnag::Middleware
           :params => params.to_hash,
           :referer => referer,
           :clientIp => client_ip,
-          :headers => headers
+          :headers => format_headers(env, referer)
         })
 
+        # add the HTTP version if present
+        if env["SERVER_PROTOCOL"]
+          report.add_metadata(:request, :httpVersion, env["SERVER_PROTOCOL"])
+        end
+
+        add_request_body(report, request, env)
+        add_cookies(report, request)
+
         # Add an environment tab
         if report.configuration.send_environment
           report.add_tab(:environment, env)
@@ -87,5 +88,87 @@ module Bugsnag::Middleware
 
       @bugsnag.call(report)
     end
+
+    private
+
+    def format_headers(env, referer)
+      headers = {}
+
+      env.each_pair do |key, value|
+        if key.to_s.start_with?("HTTP_")
+          header_key = key[5..-1]
+        elsif ["CONTENT_TYPE", "CONTENT_LENGTH"].include?(key)
+          header_key = key
+        else
+          next
+        end
+
+        headers[header_key.split("_").map {|s| s.capitalize}.join("-")] = value
+      end
+
+      headers["Referer"] = referer if headers["Referer"]
+
+      headers
+    end
+
+    def add_request_body(report, request, env)
+      begin
+        body = parsed_request_body(request, env)
+      rescue StandardError
+        return nil
+      end
+
+      # this request may not have a body
+      return unless body.is_a?(Hash) && !body.empty?
+
+      report.add_metadata(:request, :body, body)
+    end
+
+    def parsed_request_body(request, env)
+      # if the request is not rewindable then either:
+      # - it's been read already and so is impossible to read
+      # - it hasn't been read yet and us reading it will prevent the user from
+      #   reading it themselves
+      # in either case we should avoid attempting to
+      return nil unless request.body.respond_to?(:rewind)
+
+      if request.form_data?
+        begin
+          return request.POST
+        ensure
+          request.body.rewind
+        end
+      end
+
+      content_type = env["CONTENT_TYPE"]
+
+      return nil if content_type.nil?
+      return nil unless content_type.include?('/json') || content_type.include?('+json')
+
+      begin
+        body = request.body
+
+        JSON.parse(body.read)
+      ensure
+        # the body must be rewound so other things can read it after we do
+        body.rewind
+      end
+    end
+
+    def add_cookies(report, request)
+      return unless record_cookies?
+
+      cookies = request.cookies rescue nil
+
+      return unless cookies.is_a?(Hash) && !cookies.empty?
+
+      report.add_metadata(:request, :cookies, cookies)
+    end
+
+    def record_cookies?
+      # only record cookies in the request if none of the filters match "Cookie"
+      # the "Cookie" header will be filtered as normal
+      !Bugsnag.cleaner.filters_match?(COOKIE_HEADER)
+    end
   end
 end

data/lib/bugsnag/middleware/rails3_request.rb

@@ -15,8 +15,8 @@ module Bugsnag::Middleware
         client_ip = env["action_dispatch.remote_ip"].to_s rescue SPOOF
 
         if params
-          # Set the context
-          report.context = "#{params[:controller]}##{params[:action]}"
+          # Set the automatic context
+          report.automatic_context = "#{params[:controller]}##{params[:action]}"
 
           # Augment the request tab
           report.add_tab(:request, {

data/lib/bugsnag/middleware/rake.rb

@@ -16,7 +16,7 @@ module Bugsnag::Middleware
           :arguments => task.arg_description
         })
 
-        report.context ||= task.name
+        report.automatic_context ||= task.name
       end
 
       @bugsnag.call(report)

data/lib/bugsnag/middleware/session_data.rb

@@ -8,12 +8,14 @@ module Bugsnag::Middleware
 
     def call(report)
       session = Bugsnag::SessionTracker.get_current_session
-      unless session.nil?
+
+      if session && !session[:paused?]
         if report.unhandled
           session[:events][:unhandled] += 1
         else
           session[:events][:handled] += 1
         end
+
         report.session = session
       end
 

data/lib/bugsnag/middleware/sidekiq.rb

@@ -10,7 +10,7 @@ module Bugsnag::Middleware
       sidekiq = report.request_data[:sidekiq]
       if sidekiq
         report.add_tab(:sidekiq, sidekiq)
-        report.context ||= "#{sidekiq[:msg]['wrapped'] || sidekiq[:msg]['class']}@#{sidekiq[:msg]['queue']}"
+        report.automatic_context ||= "#{sidekiq[:msg]['wrapped'] || sidekiq[:msg]['class']}@#{sidekiq[:msg]['queue']}"
       end
       @bugsnag.call(report)
     end

data/lib/bugsnag/middleware/suggestion_data.rb

@@ -10,23 +10,25 @@ module Bugsnag::Middleware
       @bugsnag = bugsnag
     end
 
-    def call(report)
+    def call(event)
       matches = []
-      report.raw_exceptions.each do |exception|
-        match = CAPTURE_REGEX.match(exception.message)
+
+      event.errors.each do |error|
+        match = CAPTURE_REGEX.match(error.error_message)
+
         next unless match
 
         suggestions = match.captures[0].split(DELIMITER)
-        matches.concat suggestions.map{ |suggestion| suggestion.strip }
+        matches.concat(suggestions.map(&:strip))
       end
 
       if matches.size == 1
-        report.add_tab(:error, {:suggestion => matches.first})
+        event.add_metadata(:error, { suggestion: matches.first })
       elsif matches.size > 1
-        report.add_tab(:error, {:suggestions => matches})
+        event.add_metadata(:error, { suggestions: matches })
       end
 
-      @bugsnag.call(report)
+      @bugsnag.call(event)
     end
   end
 end

data/lib/bugsnag/middleware/warden_user.rb

@@ -23,7 +23,10 @@ module Bugsnag::Middleware
           # Extract useful user information
           user = {}
           user_object = env["warden"].user({:scope => best_scope, :run_callbacks => false}) rescue nil
+
           if user_object
+            user[:warden_scope] = best_scope
+
             # Build the user info for this scope
             COMMON_USER_FIELDS.each do |field|
               user[field] = user_object.send(field) if user_object.respond_to?(field)

data/lib/bugsnag/middleware_stack.rb

@@ -131,8 +131,8 @@ module Bugsnag
     #
     # @return [Array<Proc>]
     def middleware_procs
-      # Split the middleware into separate lists of Procs and Classes
-      procs, classes = @middlewares.partition {|middleware| middleware.is_a?(Proc) }
+      # Split the middleware into separate lists of callables (e.g. Proc, Lambda, Method) and Classes
+      callables, classes = @middlewares.partition {|middleware| middleware.respond_to?(:call) }
 
       # Wrap the classes in a proc that, when called, news up the middleware and
       # passes the next middleware in the queue
@@ -140,12 +140,12 @@ module Bugsnag
         proc {|next_middleware| middleware.new(next_middleware) }
       end
 
-      # Wrap the list of procs in a proc that, when called, wraps them in an
+      # Wrap the list of callables in a proc that, when called, wraps them in an
       # 'OnErrorCallbacks' instance that also has a reference to the next middleware
-      wrapped_procs = proc {|next_middleware| OnErrorCallbacks.new(next_middleware, procs) }
+      wrapped_callables = proc {|next_middleware| OnErrorCallbacks.new(next_middleware, callables) }
 
-      # Return the combined middleware and wrapped procs
-      middleware_instances.push(wrapped_procs)
+      # Return the combined middleware and wrapped callables
+      middleware_instances.push(wrapped_callables)
     end
   end
 end