actionpack 4.2.10 → 7.2.0.rc1

data/lib/action_dispatch/middleware/debug_exceptions.rb

@@ -1,110 +1,193 @@
-require 'action_dispatch/http/request'
-require 'action_dispatch/middleware/exception_wrapper'
-require 'action_dispatch/routing/inspector'
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "action_dispatch/middleware/exception_wrapper"
+require "action_dispatch/routing/inspector"
+
+require "action_view"
 
 module ActionDispatch
-  # This middleware is responsible for logging exceptions and
-  # showing a debugging page in case the request is local.
+  # # Action Dispatch DebugExceptions
+  #
+  # 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', __FILE__)
+    cattr_reader :interceptors, instance_accessor: false, default: []
 
-    def initialize(app, routes_app = nil)
-      @app        = app
-      @routes_app = routes_app
+    def self.register_interceptor(object = nil, &block)
+      interceptor = object || block
+      interceptors << interceptor
+    end
+
+    def initialize(app, routes_app = nil, response_format = :default, interceptors = self.class.interceptors)
+      @app             = app
+      @routes_app      = routes_app
+      @response_format = response_format
+      @interceptors    = interceptors
     end
 
     def call(env)
       _, headers, body = response = @app.call(env)
 
-      if headers['X-Cascade'] == 'pass'
+      if headers[Constants::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 if env['action_dispatch.show_exceptions'] == false
-      render_exception(env, exception)
+      request = ActionDispatch::Request.new env
+      backtrace_cleaner = request.get_header("action_dispatch.backtrace_cleaner")
+      wrapper = ExceptionWrapper.new(backtrace_cleaner, exception)
+
+      invoke_interceptors(request, exception, wrapper)
+      raise exception unless wrapper.show?(request)
+      render_exception(request, exception, wrapper)
     end
 
     private
-
-    def render_exception(env, exception)
-      wrapper = ExceptionWrapper.new(env, exception)
-      log_error(env, wrapper)
-
-      if env['action_dispatch.show_detailed_exceptions']
-        request = Request.new(env)
-        traces = wrapper.traces
-
-        trace_to_show = 'Application Trace'
-        if traces[trace_to_show].empty? && wrapper.rescue_template != 'routing_error'
-          trace_to_show = 'Full Trace'
+      def invoke_interceptors(request, exception, wrapper)
+        @interceptors.each do |interceptor|
+          interceptor.call(request, exception)
+        rescue Exception
+          log_error(request, wrapper)
         end
+      end
 
-        if source_to_show = traces[trace_to_show].first
-          source_to_show_id = source_to_show[:id]
+      def render_exception(request, exception, wrapper)
+        log_error(request, wrapper)
+
+        if request.get_header("action_dispatch.show_detailed_exceptions")
+          begin
+            content_type = request.formats.first
+          rescue ActionDispatch::Http::MimeNegotiation::InvalidType
+            content_type = Mime[:text]
+          end
+
+          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
 
-        template = ActionView::Base.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(exception),
-          source_extracts: wrapper.source_extracts,
-          line_number: wrapper.line_number,
-          file: wrapper.file
-        )
+      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')
+          body = template.render(template: file, layout: "rescues/layout")
           format = "text/html"
         end
         render(wrapper.status_code, body, format)
-      else
-        raise exception
       end
-    end
 
-    def render(status, body, format)
-      [status, {'Content-Type' => "#{format}; 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)
+        DebugView.new(
+          request: request,
+          exception_wrapper: wrapper,
+          # Everything should use the wrapper, but we need to pass `exception` for legacy
+          # code.
+          exception: wrapper.exception,
+          traces: wrapper.traces,
+          show_source_idx: wrapper.source_to_show_id,
+          trace_to_show: wrapper.trace_to_show,
+          routes_inspector: routes_inspector(wrapper),
+          source_extracts: wrapper.source_extracts,
+        )
+      end
+
+      def render(status, body, format)
+        [status, { Rack::CONTENT_TYPE => "#{format}; charset=#{Response.default_charset}", Rack::CONTENT_LENGTH => body.bytesize.to_s }, [body]]
+      end
+
+      def log_error(request, wrapper)
+        logger = logger(request)
+
+        return unless logger
+        return if !log_rescued_responses?(request) && wrapper.rescue_response?
+
+        trace = wrapper.exception_trace
 
-      trace = wrapper.application_trace
-      trace = wrapper.framework_trace if trace.empty?
+        message = []
+        message << "  "
+        message << "#{wrapper.exception_class_name} (#{wrapper.message}):"
+        if wrapper.has_cause?
+          message << "\nCauses:"
+          wrapper.wrapped_causes.each do |wrapped_cause|
+            message << "#{wrapped_cause.exception_class_name} (#{wrapped_cause.message})"
+          end
+        end
+        message.concat(wrapper.annotated_source_code)
+        message << "  "
+        message.concat(trace)
 
-      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")
+        log_array(logger, message, request)
       end
-    end
 
-    def logger(env)
-      env['action_dispatch.logger'] || stderr_logger
-    end
+      def log_array(logger, lines, request)
+        return if lines.empty?
 
-    def stderr_logger
-      @stderr_logger ||= ActiveSupport::Logger.new($stderr)
-    end
+        level = request.get_header("action_dispatch.debug_exception_log_level")
+
+        if logger.formatter && logger.formatter.respond_to?(:tags_text)
+          logger.add(level, lines.join("\n#{logger.formatter.tags_text}"))
+        else
+          logger.add(level, lines.join("\n"))
+        end
+      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)
+      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.routing_error? || exception.template_error?)
+          ActionDispatch::Routing::RoutesInspector.new(@routes_app.routes.routes)
+        end
+      end
+
+      def api_request?(content_type)
+        @response_format == :api && !content_type.html?
+      end
+
+      def log_rescued_responses?(request)
+        request.get_header("action_dispatch.log_rescued_responses")
       end
-    end
   end
 end

data/lib/action_dispatch/middleware/debug_locks.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionDispatch
+  # # Action Dispatch DebugLocks
+  #
+  # 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
+  # `config/application.rb`:
+  #
+  #     config.middleware.insert_before Rack::Sendfile, ActionDispatch::DebugLocks
+  #
+  # After restarting the application and re-triggering the deadlock condition, the
+  # route `/rails/locks` 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("/")
+        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"
+          elsif info[:sharing] > 0
+            lock_state = +"Sharing"
+            lock_state << " x#{info[:sharing]}" if info[:sharing] > 1
+          else
+            lock_state = +"No lock"
+          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"
+
+          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, { Rack::CONTENT_TYPE => "text/plain; charset=#{ActionDispatch::Response.default_charset}",
+                Rack::CONTENT_LENGTH => str.size.to_s }, [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/debug_view.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "pp"
+
+require "action_view"
+require "action_view/base"
+
+module ActionDispatch
+  class DebugView < ActionView::Base # :nodoc:
+    RESCUES_TEMPLATE_PATHS = [File.expand_path("templates", __dir__)]
+
+    def initialize(assigns)
+      paths = RESCUES_TEMPLATE_PATHS.dup
+      lookup_context = ActionView::LookupContext.new(paths)
+      super(lookup_context, assigns, nil)
+      @exception_wrapper = assigns[:exception_wrapper]
+    end
+
+    def compiled_method_container
+      self.class
+    end
+
+    def error_highlight_available?
+      @exception_wrapper.error_highlight_available?
+    end
+
+    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, +"", 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
+
+    def protect_against_forgery?
+      false
+    end
+
+    def params_valid?
+      @request.parameters
+    rescue ActionController::BadRequest
+      false
+    end
+  end
+end