enhanced_errors 0.1.7 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12d823c10e0bd52d8ca38f39e5851104676be83be50ee5d3246b339eea00b3d4
-  data.tar.gz: 3d2df93d9c9b9712fe62bd1b3909032ece37ed8dc32ac9453d3b751655f6df83
+  metadata.gz: 42e0ffde5da4be326f8b1d721652eed031f7bfb20a07d31a256d69c588a383b7
+  data.tar.gz: 5ef8303d0e6dd089253643b2abbf4aeef9a195831c946b2c92396390685e0a5b
 SHA512:
-  metadata.gz: 4952714cb57a30e8100889c7e275d96626abdb41b9bae9a894f4e8eb9d74de429d0bc9d3e1b8848cc89759d017258044c71014453186ffde80d5b19b90d1ce54
-  data.tar.gz: 152b2feb1962389acf32e13ad965bb0959f5aed731840cf96979c840a2dd1e9843a599821b5b54acf599bf74cf0c4a9f90e21c34e6837aab412826a6662d072c
+  metadata.gz: cb553e2a7f127a2d7efbf77c25867a9706d500ffb70e6e48060cd42390cdd903f140d60a899ed61f0d3340697b3ec4458a704545aa4380dad928d64a76d9b158
+  data.tar.gz: 467e3f82cb5a170081b43f417dfa0b53c12df77a6a2614d13377d47227a00df0623d515a92707b52fd5cc8461f3862c16ae83c3aa264beff2ee63f88072299ce

data/README.md

@@ -384,7 +384,9 @@ Ruby's TracePoint binding capture very narrowly with no other C API or dependenc
 
 - **TBD**: Memory considerations. This does capture data when an exception happens. EnhancedErrors hides under the bed when it sees **NoMemoryError**.
 
-- **Goal: Production Safety**: The gem is designed to, once vetted, be safe for production use, giving you valuable insights without compromising performance. I suggest letting it get well-vetted before making the leap and testing it for both performance and memory under load internally, as well.
+- **Goal: Production Safety**: The gem is designed to, once vetted, be safe for production use, giving you valuable insights without compromising performance.
+I suggest letting it get well-vetted before making the leap and testing it for both performance and memory under load internally, as well.
+I would not enable it in production *yet*.
 
 ## Contributing
 

data/enhanced_errors.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name = "enhanced_errors"
-  spec.version = "0.1.7"
+  spec.version = "1.0.0"
   spec.authors = ["Eric Beland"]
 
   spec.summary = "Automatically enhance your errors with messages containing variable values from the moment they were raised."

data/lib/binding.rb

@@ -1,3 +1,5 @@
+# binding.rb
+
 module Debugging
   def let_vars_hash
     memoized_values = self.receiver.instance_variable_get(:@__memoized)&.instance_variable_get(:@memoized)
@@ -8,4 +10,3 @@ end
 class Binding
   include Debugging
 end
-

data/lib/enhanced_errors.rb

@@ -1,3 +1,5 @@
+# enhanced_errors.rb
+
 require 'set'
 require 'json'
 
@@ -5,19 +7,27 @@ require_relative 'colors'
 require_relative 'error_enhancements'
 require_relative 'binding'
 
-# While we could just catch StandardError, we would miss a number of things.
+# Exception class names to ignore. Using strings to avoid uninitialized constant errors.
+IGNORED_EXCEPTION_NAMES = %w[SystemExit NoMemoryError SignalException Interrupt
+                             ScriptError LoadError NotImplementedError SyntaxError
+                             SystemStackError Psych::BadAlias]
+
+# Helper method to safely resolve class names to constants
+def resolve_exception_class(name)
+  names = name.split('::')
+  names.inject(Object) do |mod, name_part|
+    if mod.const_defined?(name_part, false)
+      mod.const_get(name_part)
+    else
+      return nil
+    end
+  end
+rescue NameError
+  nil
+end
 
-IGNORED_EXCEPTIONS = [
-  SystemExit,
-  NoMemoryError,
-  SignalException,
-  Interrupt,
-  ScriptError,
-  LoadError,
-  NotImplementedError,
-  SyntaxError,
-  SystemStackError
-]
+# Attempt to resolve the exception classes, ignoring any that are not defined
+IGNORED_EXCEPTIONS = IGNORED_EXCEPTION_NAMES.map { |name| resolve_exception_class(name) }.compact
 
 # The EnhancedErrors class provides mechanisms to enhance exception handling by capturing
 # additional context such as binding information, variables, and method arguments when exceptions are raised.
@@ -29,10 +39,10 @@ class EnhancedErrors
     # @return [Boolean]
     attr_accessor :enabled
 
-    # The TracePoint object used for tracing exceptions.
+    # The TracePoint objects used for tracing exceptions per thread.
     #
-    # @return [TracePoint, nil]
-    attr_accessor :trace
+    # @return [Hash{Thread => TracePoint}]
+    attr_accessor :traces
 
     # The configuration block provided during enhancement.
     #
@@ -64,6 +74,11 @@ class EnhancedErrors
     # @return [Set<Symbol>]
     attr_accessor :skip_list
 
+    # Determines whether to capture :rescue events.
+    #
+    # @return [Boolean]
+    attr_accessor :capture_rescue
+
     # Regular expression to identify gem paths.
     #
     # @return [Regexp]
@@ -137,6 +152,19 @@ class EnhancedErrors
       @capture_let_variables
     end
 
+    # Gets or sets whether to capture :rescue events.
+    #
+    # @param value [Boolean, nil] The desired state. If `nil`, returns the current value.
+    # @return [Boolean] Whether :rescue events are being captured.
+    def capture_rescue(value = nil)
+      if value.nil?
+        @capture_rescue = @capture_rescue.nil? ? false : @capture_rescue
+      else
+        @capture_rescue = value
+      end
+      @capture_rescue
+    end
+
     # Retrieves the current skip list, initializing it with default values if not already set.
     #
     # @return [Set<Symbol>] The current skip list.
@@ -166,21 +194,20 @@ class EnhancedErrors
     # @param options [Hash] Additional configuration options.
     # @yield [void] A block for additional configuration.
     # @return [void]
-    def enhance!(enabled: true, debug: false, capture_events: default_capture_events, **options, &block)
-      capture_events = Array(capture_events)
+    def enhance!(enabled: true, debug: false, capture_events: nil, **options, &block)
       @output_format = nil
       @eligible_for_capture = nil
       @original_global_variables = nil
       if enabled == false
         @original_global_variables = nil
         @enabled = false
-        @trace.disable if @trace
+        # Disable TracePoints in all threads
+        @traces.each_value { |trace| trace.disable } if @traces
       else
         @enabled = true
         @debug = debug
         @original_global_variables = global_variables
 
-        validate_and_set_capture_events(capture_events)
         options.each do |key, value|
           setter_method = "#{key}="
           if respond_to?(setter_method)
@@ -195,7 +222,21 @@ class EnhancedErrors
         @config_block = block_given? ? block : nil
         instance_eval(&@config_block) if @config_block
 
-        start_tracing
+        validate_and_set_capture_events(capture_events)
+
+        # Initialize @traces hash to keep track of TracePoints per thread
+        @traces ||= {}
+        # Set up TracePoint in the main thread
+        start_tracing(Thread.current)
+
+        # Set up TracePoint in all existing threads
+        Thread.list.each do |thread|
+          next if thread == Thread.current
+          start_tracing(thread)
+        end
+
+        # Hook into Thread creation to set up TracePoint in new threads
+        override_thread_new
       end
     end
 
@@ -259,7 +300,13 @@ class EnhancedErrors
     def format(captured_bindings = [], output_format = get_default_format_for_environment)
       result = binding_infos_array_to_string(captured_bindings, output_format)
       if @on_format_hook
-        result = @on_format_hook.call(result)
+        begin
+          result = @on_format_hook.call(result)
+        rescue => e
+          # Since the on_format_hook failed, do not display the data
+          result = ''
+          # Optionally, log the error safely if logging is guaranteed not to raise exceptions
+        end
       else
         result = default_on_format(result)
       end
@@ -272,20 +319,10 @@ class EnhancedErrors
     # @param format [Symbol] The format to use (:json, :plaintext, :terminal).
     # @return [String] The formatted string representation of the binding information.
     def binding_infos_array_to_string(captured_bindings, format = :terminal)
-      case format
-      when :json
-        Colors.enabled = false
-        JSON.pretty_generate(captured_bindings)
-      when :plaintext
-        Colors.enabled = false
-        captured_bindings.map { |binding_info| binding_info_string(binding_info) }.join("\n")
-      when :terminal
-        Colors.enabled = true
-        captured_bindings.map { |binding_info| binding_info_string(binding_info) }.join("\n")
-      else
-        Colors.enabled = false
-        captured_bindings.map { |binding_info| binding_info_string(binding_info) }.join("\n")
-      end
+      Colors.enabled = format == :terminal
+      formatted_bindings = captured_bindings.map { |binding_info| binding_info_string(binding_info) }
+
+      format == :json ? JSON.pretty_generate(captured_bindings) : formatted_bindings.join("\n")
     end
 
     # Determines the default output format based on the current environment.
@@ -345,7 +382,7 @@ class EnhancedErrors
     # @return [Hash, nil] The validated binding information or `nil` if invalid.
     def validate_binding_format(binding_info)
       unless binding_info.keys.include?(:capture_event) && binding_info[:variables].is_a?(Hash)
-        puts "Invalid binding_info format."
+        # Log or handle the invalid format as needed
         return nil
       end
       binding_info
@@ -356,10 +393,12 @@ class EnhancedErrors
     # @param binding_info [Hash] The binding information to format.
     # @return [String] The formatted string.
     def binding_info_string(binding_info)
-      capture_event = binding_info[:capture_event].to_s.capitalize
-      result = "#{Colors.red(capture_event)}: #{Colors.blue(binding_info[:source])}"
+      capture_event = safe_to_s(binding_info[:capture_event]).capitalize
+      source = safe_to_s(binding_info[:source])
+      result = "#{Colors.red(capture_event)}: #{Colors.blue(source)}"
 
-      result += method_and_args_desc(binding_info[:method_and_args])
+      method_desc = method_and_args_desc(binding_info[:method_and_args])
+      result += method_desc
 
       variables = binding_info[:variables] || {}
 
@@ -386,22 +425,21 @@ class EnhancedErrors
       end
       result + "\n"
     rescue => e
-      # we swallow and don't re-raise to avoid any recursion problems. We don't want to
-      # mess up the original exception handling.
-      puts "EnhancedErrors error in binding_info_string: #{e.message} #{e.backtrace}"
+      # Avoid raising exceptions during formatting
       return ''
     end
 
     private
 
-    # Starts the TracePoint for capturing exceptions based on configured events.
+    # Starts the TracePoint for capturing exceptions based on configured events in a specific thread.
     #
+    # @param thread [Thread] The thread to start tracing in.
     # @return [void]
-    def start_tracing
-      return if @trace && @trace.enabled?
-      events = @capture_events ? @capture_events.to_a : [:raise]
-      @trace = TracePoint.new(*events) do |tp|
-        next if Thread.current[:enhanced_errors_processing] || ignored_exception?(tp.raised_exception)
+    def start_tracing(thread)
+      return if @traces[thread]&.enabled?
+      events = @capture_events ? @capture_events.to_a : default_capture_events
+      trace = TracePoint.new(*events) do |tp|
+        next if Thread.current[:enhanced_errors_processing] || Thread.current[:on_capture] || ignored_exception?(tp.raised_exception)
         Thread.current[:enhanced_errors_processing] = true
         exception = tp.raised_exception
         capture_me = !exception.frozen? && EnhancedErrors.eligible_for_capture.call(exception)
@@ -411,7 +449,6 @@ class EnhancedErrors
           next
         end
 
-        exception = tp.raised_exception
         binding_context = tp.binding
 
         unless exception.instance_variable_defined?(:@binding_infos)
@@ -426,13 +463,13 @@ class EnhancedErrors
         }
 
         locals = binding_context.local_variables.map { |var|
-          [var, binding_context.local_variable_get(var)]
+          [var, safe_local_variable_get(binding_context, var)]
         }.to_h
 
         instance_vars = binding_context.receiver.instance_variables
 
         instances = instance_vars.map { |var|
-          [var, (binding_context.receiver.instance_variable_get(var) rescue "#<Error getting instance variable: #{$!.message}>")]
+          [var, safe_instance_variable_get(binding_context.receiver, var)]
         }.to_h
 
         # Extract 'let' variables from :@__memoized (RSpec specific)
@@ -453,8 +490,8 @@ class EnhancedErrors
           }.to_h
         end
 
-        capture_event = tp.event.to_s  # 'raise' or 'rescue'
-        location = "#{tp.path}:#{tp.lineno}"
+        capture_event = safe_to_s(tp.event)  # 'raise' or 'rescue'
+        location = "#{safe_to_s(tp.path)}:#{safe_to_s(tp.lineno)}"
 
         binding_info = {
           source: location,
@@ -468,48 +505,86 @@ class EnhancedErrors
             lets: lets,
             globals: globals
           },
-          exception: exception.class.name,
-          capture_event: capture_event.to_s
+          exception: safe_to_s(exception.class.name),
+          capture_event: capture_event
         }
 
+        binding_info = default_on_capture(binding_info) # Apply default processing
+
         if on_capture_hook
-          binding_info = on_capture_hook.call(binding_info)
-        else
-          binding_info = default_on_capture(binding_info)
+          begin
+            Thread.current[:on_capture] = true
+            binding_info = on_capture_hook.call(binding_info)
+          rescue => e
+            # Since the on_capture_hook failed, do not capture this binding_info
+            binding_info = nil
+            # Optionally, log the error safely if logging is guaranteed not to raise exceptions
+          ensure
+            Thread.current[:on_capture] = false
+          end
         end
 
-        binding_info = validate_binding_format(binding_info)
-
+        # Proceed only if binding_info is valid
         if binding_info
-          exception.instance_variable_get(:@binding_infos) << binding_info
-        else
-          puts "Invalid binding_info returned from on_capture, skipping."
+          binding_info = validate_binding_format(binding_info)
+          if binding_info
+            exception.instance_variable_get(:@binding_infos) << binding_info
+          end
         end
       rescue => e
-        puts "Error in TracePoint block: #{e.message}"
+        # Avoid any code here that could raise exceptions
       ensure
         Thread.current[:enhanced_errors_processing] = false
       end
 
-      @trace.enable
+      @traces[thread] = trace
+      trace.enable
     end
 
-    def ignored_exception?(exception)
-      IGNORED_EXCEPTIONS.each do |klass|
-        return true if exception.is_a?(klass)
+    # Overrides Thread.new and Thread.start to ensure TracePoint is enabled in new threads.
+    #
+    # @return [void]
+    def override_thread_new
+      return if @thread_overridden
+      @thread_overridden = true
+
+      class << Thread
+        alias_method :original_new, :new
+
+        def new(*args, &block)
+          original_new(*args) do |*block_args|
+            EnhancedErrors.send(:start_tracing, Thread.current)
+            block.call(*block_args)
+          end
+        end
+
+        alias_method :original_start, :start
+
+        def start(*args, &block)
+          original_start(*args) do |*block_args|
+            EnhancedErrors.send(:start_tracing, Thread.current)
+            block.call(*block_args)
+          end
+        end
       end
-      false
     end
 
+    # Checks if the exception is in the ignored exceptions list.
+    #
+    # @param exception [Exception] The exception to check.
+    # @return [Boolean] `true` if the exception should be ignored, otherwise `false`.
+    def ignored_exception?(exception)
+      IGNORED_EXCEPTIONS.any? { |klass| exception.is_a?(klass) }
+    end
 
     # Retrieves the current test name from RSpec, if available.
     #
     # @return [String, nil] The current test name or `nil` if not in a test context.
     def test_name
       if defined?(RSpec)
-        return RSpec&.current_example&.full_description
+        RSpec&.current_example&.full_description
       end
-    rescue => e
+    rescue
       nil
     end
 
@@ -517,32 +592,47 @@ class EnhancedErrors
     #
     # @return [Set<Symbol>] The default set of capture types
     def default_capture_events
-      default_events = [:raise]
-      default_events << :rescue if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.3.0')
-      Set.new(default_events)
+      events = [:raise]
+      if capture_rescue && Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.3.0')
+        events << :rescue
+      end
+      Set.new(events)
     end
 
+    # Validates and sets the capture events for TracePoint.
+    #
+    # @param capture_events [Array<Symbol>, nil] The events to capture.
+    # @return [void]
     def validate_and_set_capture_events(capture_events)
-      if capture_events.nil? || !valid_capture_events?(capture_events)
+      if capture_events.nil?
+        @capture_events = default_capture_events
+        return
+      end
+
+      unless valid_capture_events?(capture_events)
         puts "EnhancedErrors: Invalid capture_events provided. Falling back to defaults."
-        capture_events = default_capture_events
+        @capture_events = default_capture_events
+        return
       end
 
-      if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('3.3.0') && capture_events.include?(:rescue)
+      if capture_events.include?(:rescue) && Gem::Version.new(RUBY_VERSION) < Gem::Version.new('3.3.0')
         puts "EnhancedErrors: Warning: :rescue capture_event is not supported in Ruby versions below 3.3.0 and will be ignored."
-        capture_events.delete(:rescue)
+        capture_events = capture_events - [:rescue]
       end
 
       if capture_events.empty?
         puts "No valid capture_events provided to EnhancedErrors.enhance! Falling back to defaults."
-        capture_events = default_capture_events
+        @capture_events = default_capture_events
+        return
       end
 
-      @capture_events = capture_events.to_a
+      @capture_events = capture_events.to_set
     end
 
-
-    # Validate capture_events: must be an Array or Set containing only :raise and/or :rescue.
+    # Validates the capture events.
+    #
+    # @param capture_events [Array<Symbol>] The events to validate.
+    # @return [Boolean] `true` if valid, otherwise `false`.
     def valid_capture_events?(capture_events)
       return false unless capture_events.is_a?(Array) || capture_events.is_a?(Set)
       valid_types = [:raise, :rescue].to_set
@@ -564,8 +654,8 @@ class EnhancedErrors
         locals = bind.local_variables
 
         parameters.map do |(type, name)|
-          value = locals.include?(name) ? bind.local_variable_get(name) : nil
-          "#{name}=#{value.inspect}"
+          value = locals.include?(name) ? safe_local_variable_get(bind, name) : nil
+          "#{name}=#{safe_inspect(value)}"
         rescue => e
           "#{name}=#<Error getting argument: #{e.message}>"
         end.join(", ")
@@ -581,9 +671,9 @@ class EnhancedErrors
     # @return [String] The formatted object name.
     def determine_object_name(tp, method_name)
       if tp.self.is_a?(Class) && tp.self.singleton_class == tp.defined_class
-        "#{tp.self}.#{method_name}"
+        "#{safe_to_s(tp.self)}.#{method_name}"
       else
-        "#{tp.self.class.name}##{method_name}"
+        "#{safe_to_s(tp.self.class.name)}##{method_name}"
       end
     rescue => e
       "#<Error inspecting value: #{e.message}>"
@@ -597,7 +687,7 @@ class EnhancedErrors
       begin
         var.is_a?(Symbol) ? eval("#{var}") : nil
       rescue => e
-        "#<Error getting value for #{var}>" rescue '<value error>'
+        "#<Error getting value for #{var}>"
       end
     end
 
@@ -606,11 +696,14 @@ class EnhancedErrors
     # @param method_info [Hash] Information about the method and its arguments.
     # @return [String] The formatted description.
     def method_and_args_desc(method_info)
-      return '' unless method_info[:object_name] != '' || method_info[:args]&.length.to_i > 0
-      arg_str = method_info[:args]
-      arg_str = "(#{arg_str})" if arg_str != ""
-      str = method_info[:object_name] + arg_str
+      object_name = safe_to_s(method_info[:object_name])
+      args = safe_to_s(method_info[:args])
+      return '' if object_name.empty? && args.empty?
+      arg_str = args.empty? ? '' : "(#{args})"
+      str = object_name + arg_str
       "\n#{Colors.green('Method: ')}#{Colors.blue(str)}\n"
+    rescue => e
+      ''
     end
 
     # Generates a formatted description for a set of variables.
@@ -621,26 +714,23 @@ class EnhancedErrors
       vars_hash.map do |name, value|
         "  #{Colors.purple(name)}: #{format_variable(value)}\n"
       end.join
+    rescue => e
+      ''
     end
 
     # Formats a variable for display, using `awesome_print` if available and enabled.
     #
     # @param variable [Object] The variable to format.
     # @return [String] The formatted variable.
-
     def format_variable(variable)
       if awesome_print_available? && Colors.enabled?
         variable.ai
       else
-        variable.inspect
+        safe_inspect(variable)
       end
     rescue => e
-      var_str = begin
-                  variable.to_s.truncate(30)
-                rescue
-                  "[Unprintable variable]"
-                end
-      return "#{var_str}: [Inspection Error]"
+      var_str = safe_to_s(variable)
+      "#{var_str}: [Inspection Error]"
     end
 
     # Checks if the `AwesomePrint` gem is available.
@@ -651,6 +741,53 @@ class EnhancedErrors
       @awesome_print_available = defined?(AwesomePrint)
     end
 
+    # Safely calls `inspect` on a variable.
+    #
+    # @param variable [Object] The variable to inspect.
+    # @return [String] The inspected variable or a safe fallback.
+    def safe_inspect(variable)
+      variable.inspect
+    rescue => e
+      safe_to_s(variable)
+    end
+
+    # Safely converts a variable to a string, handling exceptions.
+    #
+    # @param variable [Object] The variable to convert.
+    # @return [String] The string representation or a safe fallback.
+    def safe_to_s(variable)
+      str = variable.to_s
+      if str.length > 120
+        str[0...120] + '...'
+      else
+        str
+      end
+    rescue
+      "[Unprintable variable]"
+    end
+
+    # Safely retrieves a local variable from a binding.
+    #
+    # @param binding_context [Binding] The binding context.
+    # @param var_name [Symbol] The name of the local variable.
+    # @return [Object] The value of the local variable or a safe fallback.
+    def safe_local_variable_get(binding_context, var_name)
+      binding_context.local_variable_get(var_name)
+    rescue
+      "[Error accessing local variable #{var_name}]"
+    end
+
+    # Safely retrieves an instance variable from an object.
+    #
+    # @param obj [Object] The object.
+    # @param var_name [Symbol] The name of the instance variable.
+    # @return [Object] The value of the instance variable or a safe fallback.
+    def safe_instance_variable_get(obj, var_name)
+      obj.instance_variable_get(var_name)
+    rescue
+      "[Error accessing instance variable #{var_name}]"
+    end
+
     # Default implementation for the on_format hook.
     #
     # @param string [String] The formatted exception message.

data/lib/error_enhancements.rb

@@ -1,57 +1,59 @@
+# error_enhancements.rb
+
 module ErrorEnhancements
   def message
-    original_message = super()
-    if original_message.include?(variables_message)
+    original_message = begin
+                         super()
+                       rescue
+                         ''
+                       end
+    vars_message = variables_message rescue ""
+    if original_message.include?(vars_message)
       original_message
     else
-      "#{original_message}\n#{variables_message}"
+      "#{original_message}\n#{vars_message}"
     end
   rescue => e
-    original_message
+    original_message || ''
   end
 
   def variables_message
     @variables_message ||= begin
-                             bindings_of_interest = []
-                             if defined?(@binding_infos) && @binding_infos && !@binding_infos.empty?
+                             if @binding_infos&.any?
                                bindings_of_interest = select_binding_infos(@binding_infos)
+                               EnhancedErrors.format(bindings_of_interest)
+                             else
+                               ''
                              end
-                             EnhancedErrors.format(bindings_of_interest)
-                           rescue => e
-                             puts "Error in variables_message: #{e.message}"
-                             ""
+                           rescue
+                             ''
                            end
   end
 
   private
 
-  def select_binding_infos(binding_infos)
-    # Preference:
-    # Grab the first raise binding that isn't a library (gem) binding.
-    # If there are only library bindings, grab the first one.
-    # Grab the last rescue binding if we have one
+    def select_binding_infos(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 = []
 
-    binding_infos.each do |info|
-      if info[:capture_event] == 'raise' && !info[:library]
-        bindings_of_interest << info
-        break
+      first_app_raise = binding_infos.find do |info|
+        info[:capture_event] == 'raise' && !info[:library]
       end
-    end
+      bindings_of_interest << first_app_raise if first_app_raise
 
-    if bindings_of_interest.empty?
-      bindings_of_interest << binding_infos.first if binding_infos.first
-    end
+      if bindings_of_interest.empty? && binding_infos.first
+        bindings_of_interest << binding_infos.first
+      end
 
-    # find the last rescue binding if there is one
-    binding_infos.reverse.each do |info|
-      if info[:capture_event] == 'rescue'
-        bindings_of_interest << info
-        break
+      last_rescue = binding_infos.reverse.find do |info|
+        info[:capture_event] == 'rescue'
       end
-    end
-    bindings_of_interest
-  end
+      bindings_of_interest << last_rescue if last_rescue
 
+      bindings_of_interest
+    end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: enhanced_errors
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 1.0.0
 platform: ruby
 authors:
 - Eric Beland
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-04 00:00:00.000000000 Z
+date: 2024-12-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: awesome_print