enhanced_errors 3.0.2 → 3.0.4

data/lib/enhanced/exception.rb

@@ -1,55 +1,54 @@
 # exception.rb
-require_relative 'enhanced_exception_context'
-
-module ExceptionBindingInfos
-  def binding_infos
-    ctx = EnhancedExceptionContext.context_for(self)
-    unless ctx
-      ctx = Context.new
-      EnhancedExceptionContext.store_context(self, ctx)
+require_relative 'exception_context'
+
+module Enhanced
+  module ExceptionBindingInfos
+    def binding_infos
+      ctx = Enhanced::ExceptionContext.context_for(self)
+      unless ctx
+        ctx = Context.new
+        Enhanced::ExceptionContext.store_context(self, ctx)
+      end
+      ctx.binding_infos
     end
-    ctx.binding_infos
-  end
 
-  def captured_variables
-    if binding_infos.any?
+    def captured_variables
+      return '' unless binding_infos&.any?
       bindings_of_interest = select_binding_infos
       EnhancedErrors.format(bindings_of_interest)
-    else
+    rescue
       ''
     end
-  rescue
-    ''
-  end
 
-  private
+    private
 
-  def select_binding_infos
-    # Preference:
-    # 1. First 'raise' binding that isn't from a library (gem).
-    # 2. If none, the first binding.
-    # 3. The last 'rescue' binding if available.
+    def select_binding_infos
+      # Preference:
+      # 1. First 'raise' binding that isn't from a library (gem).
+      # 2. If none, the first binding.
+      # 3. The last 'rescue' binding if available.
 
-    bindings_of_interest = []
+      bindings_of_interest = []
 
-    first_app_raise = binding_infos.find do |info|
-      info[:capture_event] == 'raise' && !info[:library]
-    end
-    bindings_of_interest << first_app_raise if first_app_raise
+      first_app_raise = binding_infos.find do |info|
+        info[:capture_event] == 'raise' && !info[:library]
+      end
+      bindings_of_interest << first_app_raise if first_app_raise
 
-    if bindings_of_interest.empty? && binding_infos.first
-      bindings_of_interest << binding_infos.first
-    end
+      if bindings_of_interest.empty? && binding_infos.first
+        bindings_of_interest << binding_infos.first
+      end
 
-    last_rescue = binding_infos.reverse.find do |info|
-      info[:capture_event] == 'rescue'
-    end
-    bindings_of_interest << last_rescue if last_rescue
+      last_rescue = binding_infos.reverse.find do |info|
+        info[:capture_event] == 'rescue'
+      end
+      bindings_of_interest << last_rescue if last_rescue
 
-    bindings_of_interest.compact
+      bindings_of_interest.compact
+    end
   end
 end
 
 class Exception
-  prepend ExceptionBindingInfos
+  prepend Enhanced::ExceptionBindingInfos
 end

data/lib/enhanced/exception_context.rb

@@ -0,0 +1,49 @@
+require 'weakref'
+
+require_relative 'context'
+
+require 'weakref'
+require 'monitor'
+
+module Enhanced
+  module ExceptionContext
+    extend self
+
+    REGISTRY = {}
+    MUTEX = Monitor.new
+
+    def store_context(exception, context)
+      MUTEX.synchronize do
+        REGISTRY[exception.object_id] = { weak_exc: WeakRef.new(exception), context: context }
+      end
+    end
+
+    def context_for(exception)
+      MUTEX.synchronize do
+        entry = REGISTRY[exception.object_id]
+        return nil unless entry
+
+        begin
+          _ = entry[:weak_exc].__getobj__ # ensure exception is still alive
+          entry[:context]
+        rescue RefError
+          # Exception no longer alive, clean up
+          REGISTRY.delete(exception.object_id)
+          nil
+        end
+      end
+    end
+
+    def clear_context(exception)
+      MUTEX.synchronize do
+        REGISTRY.delete(exception.object_id)
+      end
+    end
+
+    def clear_all
+      MUTEX.synchronize do
+        REGISTRY.clear
+      end
+    end
+  end
+end

data/lib/enhanced/minitest_patch.rb

@@ -9,7 +9,7 @@ module Minitest
       begin
         binding_infos = EnhancedErrors.stop_minitest_binding_capture
         EnhancedErrors.override_exception_message(result.failures.last, binding_infos) if result.failures.any?
-        EnhancedExceptionContext.clear_all
+        Enhanced::ExceptionContext.clear_all
       rescue => e
         puts "Ignored error during error enhancement: #{e}"
       end

data/lib/enhanced_errors.rb

@@ -4,12 +4,12 @@ require 'set'
 require 'json'
 require 'monitor'
 
-require_relative 'enhanced/colors'
-require_relative 'enhanced/exception'
+module Enhanced; end
 
-IGNORED_EXCEPTIONS = %w[SystemExit NoMemoryError SignalException Interrupt ScriptError LoadError
-NotImplementedError SyntaxError RSpec::Expectations::ExpectationNotMetError
-RSpec::Matchers::BuiltIn::RaiseError SystemStackError Psych::BadAlias]
+# Exceptions we could handle but overlook for other reasons. These class constants are not always loaded
+# and generally are only be available when `required`, so we detect them by strings.
+IGNORED_EXCEPTIONS = %w[RSpec::Expectations::ExpectationNotMetError RSpec::Matchers::BuiltIn::RaiseError
+                        JSON::ParserError Zlib::Error OpenSSL::SSL::SSLError Psych::Exception]
 
 class EnhancedErrors
   extend ::Enhanced
@@ -45,13 +45,8 @@ class EnhancedErrors
     ].freeze
 
     RAILS_SKIP_LIST = [
-      :@new_record,
-      :@attributes,
       :@association_cache,
-      :@readonly,
-      :@previously_new_record,
       :@_routes,
-      :@routes,
       :@app,
       :@arel_table,
       :@assertion_instance,
@@ -127,7 +122,7 @@ class EnhancedErrors
       mutex.synchronize { @max_capture_length || DEFAULT_MAX_CAPTURE_LENGTH }
     end
 
-    def max_capture_length=(val)
+    def max_capture_length=(value)
       mutex.synchronize { @max_capture_length = value }
     end
 
@@ -140,7 +135,6 @@ class EnhancedErrors
       end
     end
 
-
     def reset!
       mutex.synchronize do
         @rspec_tracepoint&.disable
@@ -155,31 +149,28 @@ class EnhancedErrors
 
     def skip_list
       mutex.synchronize do
-        @skip_list ||= DEFAULT_SKIP_LIST
+        @skip_list ||= DEFAULT_SKIP_LIST.to_set
       end
     end
 
     def override_rspec_message(example, binding_or_bindings)
       exception_obj = example.exception
-      case exception_obj
-      when nil
-        return nil
-      when RSpec::Core::MultipleExceptionError
+      return if exception_obj.nil?
+
+      from_bindings = [binding_or_bindings].flatten.compact
+      case exception_obj.class.to_s
+      when 'RSpec::Core::MultipleExceptionError'
         exception_obj.all_exceptions.each do |exception|
-          override_exception_message(exception, binding_or_bindings)
+          override_exception_message(exception, from_bindings + exception.binding_infos)
         end
-      else
+      when 'RSpec::Expectations::ExpectationNotMetError'
         override_exception_message(exception_obj, binding_or_bindings)
+      else
+        override_exception_message(exception_obj, from_bindings + exception_obj.binding_infos)
       end
     end
 
     def override_exception_message(exception, binding_or_bindings)
-      return nil unless exception && exception.respond_to?(:message)
-      test_binding = !(binding_or_bindings.nil? || binding_or_bindings.empty?)
-      exception_binding = (exception.binding_infos.length > 0)
-      has_message = !(exception.respond_to?(:unaltered_message))
-      return nil unless (test_binding || exception_binding) && has_message
-
       variable_str = EnhancedErrors.format(binding_or_bindings)
       message_str = exception.message
       exception.define_singleton_method(:unaltered_message) { message_str }
@@ -190,12 +181,13 @@ class EnhancedErrors
 
     def add_to_skip_list(*vars)
       mutex.synchronize do
-        @skip_list.concat(vars)
+        @skip_list.add(*vars)
       end
     end
 
     def enhance_exceptions!(enabled: true, debug: false, capture_events: nil, override_messages: false, **options, &block)
       mutex.synchronize do
+        ensure_extensions_are_required
         @exception_trace&.disable
         @exception_trace = nil
 
@@ -226,10 +218,11 @@ class EnhancedErrors
 
         events = @capture_events ? @capture_events.to_a : default_capture_events
         @exception_trace = TracePoint.new(*events) do |tp|
+          return unless exception_is_handleable?(tp.raised_exception)
           handle_tracepoint_event(tp)
         end
 
-        @exception_trace.enable if @enabled
+        @exception_trace&.enable if @enabled
       end
     end
 
@@ -238,7 +231,8 @@ class EnhancedErrors
     end
 
     def start_minitest_binding_capture
-      EnhancedExceptionContext.clear_all
+      ensure_extensions_are_required
+      Enhanced::ExceptionContext.clear_all
       @enabled = true if @enabled.nil?
       return unless @enabled
       mutex.synchronize do
@@ -246,7 +240,7 @@ class EnhancedErrors
           next unless tp.method_id.to_s.start_with?('test_') && is_a_minitest?(tp.defined_class)
           @minitest_test_binding = tp.binding
         end
-        @minitest_trace.enable
+        @minitest_trace&.enable
       end
     end
 
@@ -272,7 +266,8 @@ class EnhancedErrors
     end
 
     def start_rspec_binding_capture
-      EnhancedExceptionContext.clear_all
+      ensure_extensions_are_required
+      Enhanced::ExceptionContext.clear_all
       @enabled = true if @enabled.nil?
       return unless @enabled
 
@@ -280,34 +275,43 @@ class EnhancedErrors
         @rspec_example_binding = nil
         @capture_next_binding = false
         @rspec_tracepoint&.disable
-
-        @rspec_tracepoint = TracePoint.new(:raise, :b_return) do |tp|
-          # puts "name #{tp.raised_exception.class.name rescue ''} method:#{tp.method_id} tp.binding:#{tp.binding.local_variables rescue ''}"
-          # puts "event: #{tp.event} defined_class#{class_to_string(tp.defined_class)} #{tp.path}:#{tp.lineno} #{tp.callee_id} "
-          # This trickery below is to help us identify the anonymous block return we want to grab
-          # Very kluge-y and edge cases have grown it, but it works
-          if tp.event == :b_return
-            if RSPEC_HANDLER_NAMES.include?(class_to_string(tp.defined_class))
-              @capture_next_binding = :next
-              next
-            end
-            next unless @capture_next_binding
-            if @capture_next_binding == :next || @capture_next_binding == :next_matching && is_rspec_example?(tp)
-              @capture_next_binding = false
-              @rspec_example_binding = tp.binding
-            end
-          elsif tp.event == :raise
-            class_name = tp.raised_exception.class.name
-            case class_name
-            when 'RSpec::Expectations::ExpectationNotMetError'
-              @capture_next_binding = :next_matching
-            else
-              handle_tracepoint_event(tp)
-            end
+        @rspec_tracepoint = TracePoint.new(:raise) do |tp|
+          return unless exception_is_handleable?(tp.raised_exception)
+          class_name = tp.raised_exception.class.name
+          case class_name
+          when 'RSpec::Expectations::ExpectationNotMetError'
+            start_rspec_binding_trap
+          else
+            handle_tracepoint_event(tp)
           end
         end
-        @rspec_tracepoint.enable
       end
+      @rspec_tracepoint&.enable
+    end
+
+    # Behavior: Grabs the next rspec spec binding that goes by, and stops the more-expensive b_return trace.
+    # This part of RSpec has been stable, since 2015, so although this is kluge-y, it is stable.
+    # The optimization does a 2-3x on spec speed vs. opening up the Tracepoint. With it,
+    # things are pretty close in speed to plain rspec.
+    # Should the behavior change this can be updated by using a trace to print out items
+    # and their local variables then, find the exception or call that goes by right
+    # before the spec blocks with the variables, and use that to narrow-down the costly part of
+    # the probe to just this point in time. The good news is that
+    # this part is test-time only, and this optimization and kluge only applies to RSpec.
+    def start_rspec_binding_trap
+      @rspec_binding_trap = TracePoint.new(:b_return) do |tp|
+        # kluge-y hack and will be a pain to maintain
+        if tp.callee_id == :handle_matcher
+          @capture_next_binding = :next
+          next
+        end
+        next unless @capture_next_binding
+        @capture_next_binding = false
+        @rspec_example_binding = tp.binding
+        @rspec_binding_trap&.disable
+        @rspec_binding_trap = nil
+      end
+      @rspec_binding_trap&.enable
     end
 
     def stop_rspec_binding_capture
@@ -328,6 +332,8 @@ class EnhancedErrors
 
       locals = b.local_variables.map { |var| [var, safe_local_variable_get(b, var)] }.to_h
       receiver = b.receiver
+      return unless safe_to_inspect?(receiver)
+
       instance_vars = receiver.instance_variables
       instances = instance_vars.map { |var| [var, safe_instance_variable_get(receiver, var)] }.to_h
 
@@ -356,7 +362,7 @@ class EnhancedErrors
           globals: {}
         },
         exception: 'NoException',
-        capture_event: 'RSpecContext'
+        capture_event: 'test_context'
       }
 
       default_on_capture(binding_info)
@@ -438,11 +444,7 @@ class EnhancedErrors
         env = ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
         @output_format = case env
                          when 'development', 'test'
-                           if running_in_ci?
-                             :plaintext
-                           else
-                             :terminal
-                           end
+                           running_in_ci? ? :plaintext : :terminal
                          when 'production'
                            :json
                          else
@@ -454,28 +456,32 @@ class EnhancedErrors
     def running_in_ci?
       mutex.synchronize do
         return @running_in_ci if defined?(@running_in_ci)
-
         @running_in_ci = CI_ENV_VARS.any? { |_, value| value.to_s.downcase == 'true' }
       end
     end
 
     def apply_skip_list(binding_info)
-      mutex.synchronize do
-        variables = binding_info[:variables]
-        variables[:instances]&.reject! { |var, _| skip_list.include?(var) || (var.to_s.start_with?('@_') && !@debug) }
-        variables[:locals]&.reject! { |var, _| skip_list.include?(var) }
-        if @debug
-          variables[:globals]&.reject! { |var, _| skip_list.include?(var) }
-        end
+      binding_info[:variables][:instances]&.reject! { |var, _| skip_list.include?(var) || (var.to_s[0, 2] == '@_' && !@debug) }
+      binding_info[:variables][:locals]&.reject! { |var, _| skip_list.include?(var) }
+      if @debug
+        binding_info[:variables][:globals]&.reject! { |var, _| skip_list.include?(var) }
       end
       binding_info
     end
 
     def validate_binding_format(binding_info)
-      unless binding_info.keys.include?(:capture_event) && binding_info[:variables].is_a?(Hash)
-        return nil
+      binding_info.keys.include?(:capture_event) && binding_info[:variables].is_a?(Hash)
+    end
+
+    # Here, we are detecting BasicObject, which is surprisingly annoying.
+    # We also, importantly, need to detect descendants, as they will also present with a
+    # lack of :respond_to? and any other useful method for us.
+    def safe_to_inspect?(obj)
+      begin
+        obj.class
+      rescue NoMethodError
+        return false
       end
-      binding_info
     end
 
     def binding_info_string(binding_info)
@@ -525,7 +531,6 @@ class EnhancedErrors
 
     private
 
-
     def handle_tracepoint_event(tp)
       # Check enabled outside the synchronized block for speed, but still safe due to re-check inside.
       return unless enabled
@@ -534,9 +539,13 @@ class EnhancedErrors
       Thread.current[:enhanced_errors_processing] = true
       exception = tp.raised_exception
 
-      capture_me = mutex.synchronize do
-        !exception.frozen? && (@eligible_for_capture || method(:default_eligible_for_capture)).call(exception)
-      end
+      return if exception.frozen?
+
+      capture_me = if @eligible_for_capture
+                     @eligible_for_capture.call(exception)
+                   else
+                     default_eligible_for_capture(exception)
+                   end
 
       unless capture_me
         Thread.current[:enhanced_errors_processing] = false
@@ -545,32 +554,43 @@ class EnhancedErrors
 
       binding_context = tp.binding
       method_name = tp.method_id
+
+      locals = {}
+
+      binding_context.local_variables.each do |var|
+        locals[var] = safe_local_variable_get(binding_context, var)
+      end
+
       method_and_args = {
         object_name: determine_object_name(tp, method_name),
-        args: extract_arguments(tp, method_name)
+        args: extract_arguments(tp, method_name, locals)
       }
 
-      locals = binding_context.local_variables.map { |var|
-        [var, safe_local_variable_get(binding_context, var)]
-      }.to_h
+      instances = {}
+      receiver = binding_context.receiver
 
-      instance_vars = binding_context.receiver.instance_variables
-      instances = instance_vars.map { |var|
-        [var, safe_instance_variable_get(binding_context.receiver, var)]
-      }.to_h
+      begin
+        if safe_to_inspect?(receiver)
+          receiver.instance_variables.each { |var|
+            instances[var] = safe_instance_variable_get(receiver, var)
+          }
+        end
+      rescue => e
+        puts "#{e.class.name} #{e.backtrace}"
+      end
 
       lets = {}
 
       globals = {}
       mutex.synchronize do
         if @debug
-          globals = (global_variables - @original_global_variables.to_a).map { |var|
-            [var, get_global_variable_value(var)]
-          }.to_h
+          globals = (global_variables - @original_global_variables.to_a).each do |var|
+            globals[var] = get_global_variable_value(var)
+          end
         end
       end
 
-      capture_event = safe_to_s(tp.event)
+      capture_event = tp.event.to_s
       location = "#{safe_to_s(tp.path)}:#{safe_to_s(tp.lineno)}"
       binding_info = {
         source: location,
@@ -584,17 +604,16 @@ class EnhancedErrors
           lets: lets,
           globals: globals
         },
-        exception: safe_to_s(exception.class.name),
+        exception: exception.class.name,
         capture_event: capture_event
       }
 
       binding_info = default_on_capture(binding_info)
-      on_capture_hook_local = mutex.synchronize { @on_capture_hook }
 
-      if on_capture_hook_local
+      if on_capture_hook
         begin
           Thread.current[:on_capture] = true
-          binding_info = on_capture_hook_local.call(binding_info)
+          binding_info = on_capture_hook.call(binding_info)
         rescue
           binding_info = nil
         ensure
@@ -602,20 +621,16 @@ class EnhancedErrors
         end
       end
 
-      if binding_info
-        binding_info = validate_binding_format(binding_info)
-        if binding_info && exception.binding_infos.length >= MAX_BINDING_INFOS
-          exception.binding_infos.delete_at(MAX_BINDING_INFOS / 2.round)
-        end
-        if binding_info
-          exception.binding_infos << binding_info
-          mutex.synchronize do
-            override_exception_message(exception, exception.binding_infos) if @override_messages
-          end
-        end
+      return unless binding_info && validate_binding_format(binding_info)
+      if exception.binding_infos.length >= MAX_BINDING_INFOS
+        exception.binding_infos.delete_at(MAX_BINDING_INFOS / 2.round)
       end
-    rescue
-      # Avoid raising exceptions here
+      exception.binding_infos << binding_info
+      mutex.synchronize do
+        override_exception_message(exception, exception.binding_infos) if @override_messages
+      end
+    rescue => e
+      puts "Error: #{e&.class&.name} #{e&.backtrace}"
     ensure
       Thread.current[:enhanced_errors_processing] = false
     end
@@ -675,17 +690,15 @@ class EnhancedErrors
       capture_events.is_a?(Array) && capture_events.all? { |ev| [:raise, :rescue].include?(ev) }
     end
 
-    def extract_arguments(tp, method_name)
+    def extract_arguments(tp, method_name, local_vars_hash)
       return '' unless method_name
       begin
-        bind = tp.binding
         unbound_method = tp.defined_class.instance_method(method_name)
         method_obj = unbound_method.bind(tp.self)
         parameters = method_obj.parameters
-        locals = bind.local_variables
 
         parameters.map do |(_, name)|
-          value = locals.include?(name) ? safe_local_variable_get(bind, name) : nil
+          value = local_vars_hash[name]
           "#{name}=#{safe_inspect(value)}"
         rescue => e
           "#{name}=[Error getting argument: #{e.message}]"
@@ -697,17 +710,20 @@ class EnhancedErrors
 
     def determine_object_name(tp, method_name = '')
       begin
-        self_class = Object.instance_method(:class).bind(tp.self).call
-        singleton_class = Object.instance_method(:singleton_class).bind(tp.self).call
-
-        if self_class && tp.defined_class == singleton_class
-          object_identifier = safe_to_s(tp.self)
-          method_suffix = method_name && !method_name.empty? ? ".#{method_name}" : ""
-          "#{object_identifier}#{method_suffix}"
+        # Check if we're dealing with a singleton method
+        if (
+          class << tp.self
+            self;
+          end) == tp.defined_class
+          # Singleton method call
+          object_str = safe_to_s(tp.self)
+          method_suffix = method_name.to_s.empty? ? '' : ".#{method_name}"
+          "#{object_str}#{method_suffix}"
         else
-          object_class_name = safe_to_s(self_class.name || 'UnknownClass')
-          method_suffix = method_name && !method_name.empty? ? "##{method_name}" : ""
-          "#{object_class_name}#{method_suffix}"
+          # Instance method call
+          klass_name = safe_to_s(tp.self.class.name || 'UnknownClass')
+          method_suffix = method_name.to_s.empty? ? '' : "##{method_name}"
+          "#{klass_name}#{method_suffix}"
         end
       rescue
         '[ErrorGettingName]'
@@ -799,10 +815,42 @@ class EnhancedErrors
       apply_skip_list(binding_info)
     end
 
+    # By default, we have filtering for safety, but past that, we capture everything by default
+    # at the moment.
     def default_eligible_for_capture(exception)
-      ignored = ignored_exception?(exception)
-      rspec = exception.class.name.start_with?('RSpec::Matchers')
-      !ignored && !rspec
+      true
     end
+
+    def exception_is_handleable?(exception)
+      case exception
+      when SystemExit, SignalException, SystemStackError, NoMemoryError
+        # Non-actionable: Ignore these exceptions
+        false
+      when SyntaxError, LoadError, ScriptError
+        # Non-actionable: Structural issues so there's no useful runtime context
+        false
+      else
+        # Ignore internal fatal errors
+        exception.class.to_s != 'fatal'
+      end
+    end
+
+    # This prevents loading it for say, production, if you don't want to,
+    # and keeps things cleaner. It allows a path to put this behind a feature-flag
+    # or env variable, and dynamically enable some capture instrumentation only
+    # when a Heisenbug is being hunted.
+    def ensure_extensions_are_required
+      mutex.synchronize do
+        return if @loaded_required_extensions
+        require_relative 'enhanced/colors'
+        require_relative 'enhanced/exception'
+        @loaded_required_extensions = true
+      end
+    end
+
   end
 end
+
+module Enhanced
+
+end