actionpack 5.2.3

data/lib/action_dispatch/middleware/debug_exceptions.rb

@@ -0,0 +1,205 @@
+# 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.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 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)
+      request = ActionDispatch::Request.new env
+      _, headers, body = response = @app.call(env)
+
+      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
+
+      response
+    rescue Exception => exception
+      raise exception unless request.show_exceptions?
+      render_exception(request, exception)
+    end
+
+    private
+
+      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}"
+
+        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
+
+      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
+
+        render(wrapper.status_code, formatted_body, format)
+      end
+
+      def create_template(request, wrapper)
+        traces = wrapper.traces
+
+        trace_to_show = "Application Trace"
+        if traces[trace_to_show].empty? && wrapper.rescue_template != "routing_error"
+          trace_to_show = "Full Trace"
+        end
+
+        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
+
+      def render(status, body, format)
+        [status, { "Content-Type" => "#{format}; charset=#{Response.default_charset}", "Content-Length" => body.bytesize.to_s }, [body]]
+      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

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/attribute_accessors"
+require "rack/utils"
+
+module ActionDispatch
+  class ExceptionWrapper
+    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, 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 :backtrace_cleaner, :exception, :line_number, :file
+
+    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
+      @@rescue_templates[@exception.class.name]
+    end
+
+    def status_code
+      self.class.status_code_for_exception(@exception.class.name)
+    end
+
+    def application_trace
+      clean_backtrace(:silent)
+    end
+
+    def framework_trace
+      clean_backtrace(:noise)
+    end
+
+    def full_trace
+      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
+
+    def source_extracts
+      backtrace.map do |trace|
+        file, line_number = extract_file_and_line_number(trace)
+
+        {
+          code: source_fragment(file, line_number),
+          line_number: line_number
+        }
+      end
+    end
+
+    private
+
+      def backtrace
+        Array(@exception.backtrace)
+      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