actionpack 3.2.22.5 → 5.2.4

data/lib/action_dispatch/middleware/debug_exceptions.rb

@@ -1,82 +1,205 @@
-require 'action_dispatch/http/request'
-require 'action_dispatch/middleware/exception_wrapper'
+# frozen_string_literal: true
+
+require "action_dispatch/http/request"
+require "action_dispatch/middleware/exception_wrapper"
+require "action_dispatch/routing/inspector"
+require "action_view"
+require "action_view/base"
+
+require "pp"
 
 module ActionDispatch
   # This middleware is responsible for logging exceptions and
   # showing a debugging page in case the request is local.
   class DebugExceptions
-    RESCUES_TEMPLATE_PATH = File.join(File.dirname(__FILE__), 'templates')
+    RESCUES_TEMPLATE_PATH = File.expand_path("templates", __dir__)
+
+    class DebugView < ActionView::Base
+      def debug_params(params)
+        clean_params = params.clone
+        clean_params.delete("action")
+        clean_params.delete("controller")
+
+        if clean_params.empty?
+          "None"
+        else
+          PP.pp(clean_params, "".dup, 200)
+        end
+      end
+
+      def debug_headers(headers)
+        if headers.present?
+          headers.inspect.gsub(",", ",\n")
+        else
+          "None"
+        end
+      end
 
-    def initialize(app)
-      @app = app
+      def debug_hash(object)
+        object.to_hash.sort_by { |k, _| k.to_s }.map { |k, v| "#{k}: #{v.inspect rescue $!.message}" }.join("\n")
+      end
+
+      def render(*)
+        logger = ActionView::Base.logger
+
+        if logger && logger.respond_to?(:silence)
+          logger.silence { super }
+        else
+          super
+        end
+      end
+    end
+
+    def initialize(app, routes_app = nil, response_format = :default)
+      @app             = app
+      @routes_app      = routes_app
+      @response_format = response_format
     end
 
     def call(env)
-      begin
-        response = @app.call(env)
+      request = ActionDispatch::Request.new env
+      _, headers, body = response = @app.call(env)
 
-        if response[1]['X-Cascade'] == 'pass'
-          body = response[2]
-          body.close if body.respond_to?(:close)
-          raise ActionController::RoutingError, "No route matches [#{env['REQUEST_METHOD']}] #{env['PATH_INFO'].inspect}"
-        end
-      rescue Exception => exception
-        raise exception if env['action_dispatch.show_exceptions'] == false
+      if headers["X-Cascade"] == "pass"
+        body.close if body.respond_to?(:close)
+        raise ActionController::RoutingError, "No route matches [#{env['REQUEST_METHOD']}] #{env['PATH_INFO'].inspect}"
       end
 
-      exception ? render_exception(env, exception) : response
+      response
+    rescue Exception => exception
+      raise exception unless request.show_exceptions?
+      render_exception(request, exception)
     end
 
     private
 
-    def render_exception(env, exception)
-      wrapper = ExceptionWrapper.new(env, exception)
-      log_error(env, wrapper)
-
-      if env['action_dispatch.show_detailed_exceptions']
-        template = ActionView::Base.new([RESCUES_TEMPLATE_PATH],
-          :request => Request.new(env),
-          :exception => wrapper.exception,
-          :application_trace => wrapper.application_trace,
-          :framework_trace => wrapper.framework_trace,
-          :full_trace => wrapper.full_trace
-        )
+      def render_exception(request, exception)
+        backtrace_cleaner = request.get_header("action_dispatch.backtrace_cleaner")
+        wrapper = ExceptionWrapper.new(backtrace_cleaner, exception)
+        log_error(request, wrapper)
+
+        if request.get_header("action_dispatch.show_detailed_exceptions")
+          content_type = request.formats.first
+
+          if api_request?(content_type)
+            render_for_api_request(content_type, wrapper)
+          else
+            render_for_browser_request(request, wrapper)
+          end
+        else
+          raise exception
+        end
+      end
 
+      def render_for_browser_request(request, wrapper)
+        template = create_template(request, wrapper)
         file = "rescues/#{wrapper.rescue_template}"
-        body = template.render(:template => file, :layout => 'rescues/layout')
-        render(wrapper.status_code, body)
-      else
-        raise exception
+
+        if request.xhr?
+          body = template.render(template: file, layout: false, formats: [:text])
+          format = "text/plain"
+        else
+          body = template.render(template: file, layout: "rescues/layout")
+          format = "text/html"
+        end
+        render(wrapper.status_code, body, format)
       end
-    end
 
-    def render(status, body)
-      [status, {'Content-Type' => "text/html; charset=#{Response.default_charset}", 'Content-Length' => body.bytesize.to_s}, [body]]
-    end
+      def render_for_api_request(content_type, wrapper)
+        body = {
+          status: wrapper.status_code,
+          error:  Rack::Utils::HTTP_STATUS_CODES.fetch(
+            wrapper.status_code,
+            Rack::Utils::HTTP_STATUS_CODES[500]
+          ),
+          exception: wrapper.exception.inspect,
+          traces: wrapper.traces
+        }
+
+        to_format = "to_#{content_type.to_sym}"
+
+        if content_type && body.respond_to?(to_format)
+          formatted_body = body.public_send(to_format)
+          format = content_type
+        else
+          formatted_body = body.to_json
+          format = Mime[:json]
+        end
 
-    def log_error(env, wrapper)
-      logger = logger(env)
-      return unless logger
+        render(wrapper.status_code, formatted_body, format)
+      end
 
-      exception = wrapper.exception
+      def create_template(request, wrapper)
+        traces = wrapper.traces
 
-      trace = wrapper.application_trace
-      trace = wrapper.framework_trace if trace.empty?
+        trace_to_show = "Application Trace"
+        if traces[trace_to_show].empty? && wrapper.rescue_template != "routing_error"
+          trace_to_show = "Full Trace"
+        end
 
-      ActiveSupport::Deprecation.silence do
-        message = "\n#{exception.class} (#{exception.message}):\n"
-        message << exception.annoted_source_code.to_s if exception.respond_to?(:annoted_source_code)
-        message << "  " << trace.join("\n  ")
-        logger.fatal("#{message}\n\n")
+        if source_to_show = traces[trace_to_show].first
+          source_to_show_id = source_to_show[:id]
+        end
+
+        DebugView.new([RESCUES_TEMPLATE_PATH],
+          request: request,
+          exception: wrapper.exception,
+          traces: traces,
+          show_source_idx: source_to_show_id,
+          trace_to_show: trace_to_show,
+          routes_inspector: routes_inspector(wrapper.exception),
+          source_extracts: wrapper.source_extracts,
+          line_number: wrapper.line_number,
+          file: wrapper.file
+        )
       end
-    end
 
-    def logger(env)
-      env['action_dispatch.logger'] || stderr_logger
-    end
+      def render(status, body, format)
+        [status, { "Content-Type" => "#{format}; charset=#{Response.default_charset}", "Content-Length" => body.bytesize.to_s }, [body]]
+      end
 
-    def stderr_logger
-      @stderr_logger ||= Logger.new($stderr)
-    end
+      def log_error(request, wrapper)
+        logger = logger(request)
+        return unless logger
+
+        exception = wrapper.exception
+
+        trace = wrapper.application_trace
+        trace = wrapper.framework_trace if trace.empty?
+
+        ActiveSupport::Deprecation.silence do
+          logger.fatal "  "
+          logger.fatal "#{exception.class} (#{exception.message}):"
+          log_array logger, exception.annoted_source_code if exception.respond_to?(:annoted_source_code)
+          logger.fatal "  "
+          log_array logger, trace
+        end
+      end
+
+      def log_array(logger, array)
+        if logger.formatter && logger.formatter.respond_to?(:tags_text)
+          logger.fatal array.join("\n#{logger.formatter.tags_text}")
+        else
+          logger.fatal array.join("\n")
+        end
+      end
+
+      def logger(request)
+        request.logger || ActionView::Base.logger || stderr_logger
+      end
+
+      def stderr_logger
+        @stderr_logger ||= ActiveSupport::Logger.new($stderr)
+      end
+
+      def routes_inspector(exception)
+        if @routes_app.respond_to?(:routes) && (exception.is_a?(ActionController::RoutingError) || exception.is_a?(ActionView::Template::Error))
+          ActionDispatch::Routing::RoutesInspector.new(@routes_app.routes.routes)
+        end
+      end
+
+      def api_request?(content_type)
+        @response_format == :api && !content_type.html?
+      end
   end
 end

data/lib/action_dispatch/middleware/debug_locks.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module ActionDispatch
+  # This middleware can be used to diagnose deadlocks in the autoload interlock.
+  #
+  # To use it, insert it near the top of the middleware stack, using
+  # <tt>config/application.rb</tt>:
+  #
+  #     config.middleware.insert_before Rack::Sendfile, ActionDispatch::DebugLocks
+  #
+  # After restarting the application and re-triggering the deadlock condition,
+  # <tt>/rails/locks</tt> will show a summary of all threads currently known to
+  # the interlock, which lock level they are holding or awaiting, and their
+  # current backtrace.
+  #
+  # Generally a deadlock will be caused by the interlock conflicting with some
+  # other external lock or blocking I/O call. These cannot be automatically
+  # identified, but should be visible in the displayed backtraces.
+  #
+  # NOTE: The formatting and content of this middleware's output is intended for
+  # human consumption, and should be expected to change between releases.
+  #
+  # This middleware exposes operational details of the server, with no access
+  # control. It should only be enabled when in use, and removed thereafter.
+  class DebugLocks
+    def initialize(app, path = "/rails/locks")
+      @app = app
+      @path = path
+    end
+
+    def call(env)
+      req = ActionDispatch::Request.new env
+
+      if req.get?
+        path = req.path_info.chomp("/".freeze)
+        if path == @path
+          return render_details(req)
+        end
+      end
+
+      @app.call(env)
+    end
+
+    private
+      def render_details(req)
+        threads = ActiveSupport::Dependencies.interlock.raw_state do |raw_threads|
+          # The Interlock itself comes to a complete halt as long as this block
+          # is executing. That gives us a more consistent picture of everything,
+          # but creates a pretty strong Observer Effect.
+          #
+          # Most directly, that means we need to do as little as possible in
+          # this block. More widely, it means this middleware should remain a
+          # strictly diagnostic tool (to be used when something has gone wrong),
+          # and not for any sort of general monitoring.
+
+          raw_threads.each.with_index do |(thread, info), idx|
+            info[:index] = idx
+            info[:backtrace] = thread.backtrace
+          end
+
+          raw_threads
+        end
+
+        str = threads.map do |thread, info|
+          if info[:exclusive]
+            lock_state = "Exclusive".dup
+          elsif info[:sharing] > 0
+            lock_state = "Sharing".dup
+            lock_state << " x#{info[:sharing]}" if info[:sharing] > 1
+          else
+            lock_state = "No lock".dup
+          end
+
+          if info[:waiting]
+            lock_state << " (yielded share)"
+          end
+
+          msg = "Thread #{info[:index]} [0x#{thread.__id__.to_s(16)} #{thread.status || 'dead'}]  #{lock_state}\n".dup
+
+          if info[:sleeper]
+            msg << "  Waiting in #{info[:sleeper]}"
+            msg << " to #{info[:purpose].to_s.inspect}" unless info[:purpose].nil?
+            msg << "\n"
+
+            if info[:compatible]
+              compat = info[:compatible].map { |c| c == false ? "share" : c.to_s.inspect }
+              msg << "  may be pre-empted for: #{compat.join(', ')}\n"
+            end
+
+            blockers = threads.values.select { |binfo| blocked_by?(info, binfo, threads.values) }
+            msg << "  blocked by: #{blockers.map { |i| i[:index] }.join(', ')}\n" if blockers.any?
+          end
+
+          blockees = threads.values.select { |binfo| blocked_by?(binfo, info, threads.values) }
+          msg << "  blocking: #{blockees.map { |i| i[:index] }.join(', ')}\n" if blockees.any?
+
+          msg << "\n#{info[:backtrace].join("\n")}\n" if info[:backtrace]
+        end.join("\n\n---\n\n\n")
+
+        [200, { "Content-Type" => "text/plain", "Content-Length" => str.size }, [str]]
+      end
+
+      def blocked_by?(victim, blocker, all_threads)
+        return false if victim.equal?(blocker)
+
+        case victim[:sleeper]
+        when :start_sharing
+          blocker[:exclusive] ||
+            (!victim[:waiting] && blocker[:compatible] && !blocker[:compatible].include?(false))
+        when :start_exclusive
+          blocker[:sharing] > 0 ||
+            blocker[:exclusive] ||
+            (blocker[:compatible] && !blocker[:compatible].include?(victim[:purpose]))
+        when :yield_shares
+          blocker[:exclusive]
+        when :stop_exclusive
+          blocker[:exclusive] ||
+            victim[:compatible] &&
+            victim[:compatible].include?(blocker[:purpose]) &&
+            all_threads.all? { |other| !other[:compatible] || blocker.equal?(other) || other[:compatible].include?(blocker[:purpose]) }
+        end
+      end
+  end
+end

data/lib/action_dispatch/middleware/exception_wrapper.rb

@@ -1,32 +1,41 @@
-require 'action_controller/metal/exceptions'
-require 'active_support/core_ext/exception'
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/attribute_accessors"
+require "rack/utils"
 
 module ActionDispatch
   class ExceptionWrapper
-    cattr_accessor :rescue_responses
-    @@rescue_responses = Hash.new(:internal_server_error)
-    @@rescue_responses.merge!(
-      'ActionController::RoutingError'             => :not_found,
-      'AbstractController::ActionNotFound'         => :not_found,
-      'ActionController::MethodNotAllowed'         => :method_not_allowed,
-      'ActionController::NotImplemented'           => :not_implemented,
-      'ActionController::InvalidAuthenticityToken' => :unprocessable_entity
+    cattr_accessor :rescue_responses, default: Hash.new(:internal_server_error).merge!(
+      "ActionController::RoutingError"               => :not_found,
+      "AbstractController::ActionNotFound"           => :not_found,
+      "ActionController::MethodNotAllowed"           => :method_not_allowed,
+      "ActionController::UnknownHttpMethod"          => :method_not_allowed,
+      "ActionController::NotImplemented"             => :not_implemented,
+      "ActionController::UnknownFormat"              => :not_acceptable,
+      "ActionController::InvalidAuthenticityToken"   => :unprocessable_entity,
+      "ActionController::InvalidCrossOriginRequest"  => :unprocessable_entity,
+      "ActionDispatch::Http::Parameters::ParseError" => :bad_request,
+      "ActionController::BadRequest"                 => :bad_request,
+      "ActionController::ParameterMissing"           => :bad_request,
+      "Rack::QueryParser::ParameterTypeError"        => :bad_request,
+      "Rack::QueryParser::InvalidParameterError"     => :bad_request
     )
 
-    cattr_accessor :rescue_templates
-    @@rescue_templates = Hash.new('diagnostics')
-    @@rescue_templates.merge!(
-      'ActionView::MissingTemplate'         => 'missing_template',
-      'ActionController::RoutingError'      => 'routing_error',
-      'AbstractController::ActionNotFound'  => 'unknown_action',
-      'ActionView::Template::Error'         => 'template_error'
+    cattr_accessor :rescue_templates, default: Hash.new("diagnostics").merge!(
+      "ActionView::MissingTemplate"         => "missing_template",
+      "ActionController::RoutingError"      => "routing_error",
+      "AbstractController::ActionNotFound"  => "unknown_action",
+      "ActiveRecord::StatementInvalid"      => "invalid_statement",
+      "ActionView::Template::Error"         => "template_error"
     )
 
-    attr_reader :env, :exception
+    attr_reader :backtrace_cleaner, :exception, :line_number, :file
 
-    def initialize(env, exception)
-      @env = env
+    def initialize(backtrace_cleaner, exception)
+      @backtrace_cleaner = backtrace_cleaner
       @exception = original_exception(exception)
+
+      expand_backtrace if exception.is_a?(SyntaxError) || exception.cause.is_a?(SyntaxError)
     end
 
     def rescue_template
@@ -49,34 +58,90 @@ module ActionDispatch
       clean_backtrace(:all)
     end
 
+    def traces
+      application_trace_with_ids = []
+      framework_trace_with_ids = []
+      full_trace_with_ids = []
+
+      full_trace.each_with_index do |trace, idx|
+        trace_with_id = { id: idx, trace: trace }
+
+        if application_trace.include?(trace)
+          application_trace_with_ids << trace_with_id
+        else
+          framework_trace_with_ids << trace_with_id
+        end
+
+        full_trace_with_ids << trace_with_id
+      end
+
+      {
+        "Application Trace" => application_trace_with_ids,
+        "Framework Trace" => framework_trace_with_ids,
+        "Full Trace" => full_trace_with_ids
+      }
+    end
+
     def self.status_code_for_exception(class_name)
       Rack::Utils.status_code(@@rescue_responses[class_name])
     end
 
-    private
+    def source_extracts
+      backtrace.map do |trace|
+        file, line_number = extract_file_and_line_number(trace)
 
-    def original_exception(exception)
-      if registered_original_exception?(exception)
-        exception.original_exception
-      else
-        exception
+        {
+          code: source_fragment(file, line_number),
+          line_number: line_number
+        }
       end
     end
 
-    def registered_original_exception?(exception)
-      exception.respond_to?(:original_exception) && @@rescue_responses.has_key?(exception.original_exception.class.name)
-    end
+    private
 
-    def clean_backtrace(*args)
-      if backtrace_cleaner
-        backtrace_cleaner.clean(@exception.backtrace, *args)
-      else
-        @exception.backtrace
+      def backtrace
+        Array(@exception.backtrace)
       end
-    end
 
-    def backtrace_cleaner
-      @backtrace_cleaner ||= @env['action_dispatch.backtrace_cleaner']
-    end
+      def original_exception(exception)
+        if @@rescue_responses.has_key?(exception.cause.class.name)
+          exception.cause
+        else
+          exception
+        end
+      end
+
+      def clean_backtrace(*args)
+        if backtrace_cleaner
+          backtrace_cleaner.clean(backtrace, *args)
+        else
+          backtrace
+        end
+      end
+
+      def source_fragment(path, line)
+        return unless Rails.respond_to?(:root) && Rails.root
+        full_path = Rails.root.join(path)
+        if File.exist?(full_path)
+          File.open(full_path, "r") do |file|
+            start = [line - 3, 0].max
+            lines = file.each_line.drop(start).take(6)
+            Hash[*(start + 1..(lines.count + start)).zip(lines).flatten]
+          end
+        end
+      end
+
+      def extract_file_and_line_number(trace)
+        # Split by the first colon followed by some digits, which works for both
+        # Windows and Unix path styles.
+        file, line = trace.match(/^(.+?):(\d+).*$/, &:captures) || trace
+        [file, line.to_i]
+      end
+
+      def expand_backtrace
+        @exception.backtrace.unshift(
+          @exception.to_s.split("\n")
+        ).flatten!
+      end
   end
 end

data/lib/action_dispatch/middleware/executor.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "rack/body_proxy"
+
+module ActionDispatch
+  class Executor
+    def initialize(app, executor)
+      @app, @executor = app, executor
+    end
+
+    def call(env)
+      state = @executor.run!
+      begin
+        response = @app.call(env)
+        returned = response << ::Rack::BodyProxy.new(response.pop) { state.complete! }
+      ensure
+        state.complete! unless returned
+      end
+    end
+  end
+end