enhanced_errors 3.0.3 → 3.0.5

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,7 +149,7 @@ class EnhancedErrors
 
     def skip_list
       mutex.synchronize do
-        @skip_list ||= DEFAULT_SKIP_LIST
+        @skip_list ||= DEFAULT_SKIP_LIST.to_set
       end
     end
 
@@ -187,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
 
@@ -223,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
 
@@ -235,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
@@ -243,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
 
@@ -269,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
 
@@ -277,21 +275,29 @@ class EnhancedErrors
         @rspec_example_binding = nil
         @capture_next_binding = false
         @rspec_tracepoint&.disable
-
         @rspec_tracepoint = TracePoint.new(:raise) do |tp|
-            class_name = tp.raised_exception.class.name
-            case class_name
-            when 'RSpec::Expectations::ExpectationNotMetError'
-              start_rspec_binding_trap
-            else
-              handle_tracepoint_event(tp)
-            end
+          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
 
-    # grab the next rspec binding that goes by, and then stop the expensive listening trace
+    # 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
@@ -302,13 +308,12 @@ class EnhancedErrors
         next unless @capture_next_binding
         @capture_next_binding = false
         @rspec_example_binding = tp.binding
-        @rspec_binding_trap.disable
+        @rspec_binding_trap&.disable
         @rspec_binding_trap = nil
       end
-      @rspec_binding_trap.enable
+      @rspec_binding_trap&.enable
     end
 
-
     def stop_rspec_binding_capture
       mutex.synchronize do
         @rspec_tracepoint&.disable
@@ -327,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
 
@@ -355,7 +362,7 @@ class EnhancedErrors
           globals: {}
         },
         exception: 'NoException',
-        capture_event: 'RSpecContext'
+        capture_event: 'test_context'
       }
 
       default_on_capture(binding_info)
@@ -437,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
@@ -453,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)
@@ -524,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
@@ -533,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
@@ -544,32 +554,43 @@ class EnhancedErrors
 
       binding_context = tp.binding
       method_name = tp.method_id
+      receiver = binding_context.receiver
+
+      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 = {}
 
-      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,
@@ -583,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
@@ -601,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
@@ -674,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}]"
@@ -696,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]'
@@ -798,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

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: enhanced_errors
 version: !ruby/object:Gem::Version
-  version: 3.0.3
+  version: 3.0.5
 platform: ruby
 authors:
 - Eric Beland
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-18 00:00:00.000000000 Z
+date: 2024-12-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: awesome_print
@@ -69,24 +68,22 @@ dependencies:
 description: 'EnhancedErrors will automatically enhance your errors with messages
   containing variable values from the moment they were raised, using no extra dependencies,
   and only Ruby''s built-in TracePoint. '
-email:
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".yardoc/checksums"
-- ".yardoc/complete"
-- ".yardoc/object_types"
-- ".yardoc/objects/root.dat"
-- ".yardoc/proxy_types"
 - LICENSE
 - README.md
 - benchmark/benchmark.rb
 - benchmark/memory_bench.rb
+- benchmark/result.txt
 - benchmark/stackprofile.rb
 - doc/Context.html
 - doc/Enhanced.html
 - doc/Enhanced/Colors.html
+- doc/Enhanced/Context.html
+- doc/Enhanced/ExceptionBindingInfos.html
+- doc/Enhanced/ExceptionContext.html
 - doc/Enhanced/Integrations.html
 - doc/Enhanced/Integrations/RSpecErrorFailureMessage.html
 - doc/EnhancedErrors.html
@@ -117,8 +114,8 @@ files:
 - examples/demo_rspec.rb
 - lib/enhanced/colors.rb
 - lib/enhanced/context.rb
-- lib/enhanced/enhanced_exception_context.rb
 - lib/enhanced/exception.rb
+- lib/enhanced/exception_context.rb
 - lib/enhanced/minitest_patch.rb
 - lib/enhanced_errors.rb
 homepage: https://github.com/ericbeland/enhanced_errors
@@ -126,7 +123,6 @@ licenses: []
 metadata:
   homepage_uri: https://github.com/ericbeland/enhanced_errors
   source_code_uri: https://github.com/ericbeland/enhanced_errors
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -141,8 +137,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Automatically enhance your errors with messages containing variable values
   from the moment they were raised.

data/.yardoc/checksums

@@ -1,6 +0,0 @@
-lib/enhanced/colors.rb ed3b11d00ff9ceed089d4a65f0be5b3fca64bbe6
-lib/enhanced_errors.rb f79331fea888262a0447d2fff4e5067fdf1418a9
-lib/enhanced/context.rb 24ca2d1f4ee2ff48dd83c913ad1f1e7c1aa367c4
-lib/enhanced/exception.rb 5572411e9e32bbe9ed01b98787e1a53a4ab61408
-lib/enhanced/minitest_patch.rb 3e7fb88ddc37a1f966877735a43ae206ee396bbc
-lib/enhanced/enhanced_exception_context.rb 23423dbdb33b7961a0b8a297e052ebb2fbe1c6ac

data/lib/enhanced/enhanced_exception_context.rb

@@ -1,47 +0,0 @@
-require 'weakref'
-
-require_relative 'context'
-
-require 'weakref'
-require 'monitor'
-
-module EnhancedExceptionContext
-  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