ruby_method_tracer 0.3.2 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c68cde18a5b8ae25abfbefdee213491e5f325aa7d47308e406fac073a4311e1d
-  data.tar.gz: 44a7c4e3ee69f0c34747e1a9f6b3b69ea0cbb12732c3b25d44471163ed7620cd
+  metadata.gz: 7d467252ce5eedf8fe0111fe1afb3983d0d4a80ad7558940908543804e963b58
+  data.tar.gz: e650becb6eee60e5bc118cf287a8dc05cbafbcb404536f1b2ab2aba2072f88f9
 SHA512:
-  metadata.gz: 3f7ba3648b90cabfc0752f40e2f3b50b0fdb261162f67ad80e2832f8df922700e8837e04c70f874e3b6e3eb201df79b827f516cd74792b63753ba70424f3dd1f
-  data.tar.gz: 3031618de6d982cc269e3b1f7220156ce67f648fcd1699c9dba10df3cd9e344d6eeb4e72550a03dcbf259fdb6caa5fae895a8c7d9718fbb9e6ba8a22f761860d
+  metadata.gz: 890623622e3f183687caba11a65577d20a82f9fc0032da94f8471b2947a2a0c805df3492b686623c3384584e338d625710531b37ca35adf7a251451fb0907e9f
+  data.tar.gz: 5cac3c1469df35c933e45a525e9384a7411553059633e98762fffdc1d56afe2eca1ab73b74d12c975a1d6dc2d6a7cd87720f3619aec9beffdf38d41a67961f0c

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 ## [Unreleased]
 
+## [0.3.3] - 2026-06-08
+
+### Changed
+- `CallTree` now stores its call stack in per-thread storage (keyed per instance) instead of a single shared `@call_stack`, so concurrent callers each track their own nesting depth. `@calls` and `@root_calls` remain shared and `Mutex`-guarded.
+- `SimpleTracer` and `EnhancedTracer` now use a per-instance reentrancy key (`__ruby_method_tracer_in_trace_<object_id>`) so separate tracer instances no longer interfere with each other's re-entry guards.
+- `EnhancedTracer` hierarchy tracking extracted into a dedicated `run_with_hierarchy` method; the call-tree entry is now always closed in an `ensure` block (even for non-`StandardError` exceptions) to prevent the per-thread call stack from becoming corrupted.
+- `SimpleTracer` now delegates `format_time` and `colorize` to a `Formatters::BaseFormatter` instance instead of duplicating the formatting logic inline.
+
+### Fixed
+- Keyword-argument forwarding in `EnhancedTracer`'s wrapper now avoids passing `**{}`, preventing `SystemStackError` on Ruby 3.4+ (mirrors the `SimpleTracer` fix from 0.3.2).
+
 ## [0.3.2] - 2025-11-22
 
 ### Fixed

data/lib/ruby_method_tracer/call_tree.rb

@@ -4,45 +4,48 @@ module RubyMethodTracer
   # CallTree manages the hierarchical structure of method calls,
   # tracking parent-child relationships and call depths.
   #
-  # It uses a stack-based approach to manage nested calls and builds
+  # It uses a per-thread stack to manage nested calls and builds
   # a tree structure showing the complete call hierarchy.
+  #
+  # Note: @calls and @root_calls are shared across threads and protected
+  # by a Mutex. The call stack is stored in thread-local storage so that
+  # concurrent callers each maintain their own independent call depth.
   class CallTree
     attr_reader :calls, :root_calls
 
     def initialize
-      @calls = []           # All recorded calls (flat list)
-      @call_stack = []      # Current execution stack
-      @root_calls = []      # Top-level calls (depth 0)
-      @lock = Mutex.new     # Thread safety
+      @calls = []           # All recorded calls (flat list, shared)
+      @root_calls = []      # Top-level calls (depth 0, shared)
+      @lock = Mutex.new     # Protects @calls and @root_calls
+      @thread_key = :"__ruby_method_tracer_call_stack_#{object_id}" # per-instance thread-local key
     end
 
     # Start tracking a method call
     #
     # @param method_name [String] The name of the method being called
     # @return [Hash] The call record that was pushed to the stack
-    def start_call(method_name) # rubocop:disable Metrics/MethodLength
-      @lock.synchronize do
-        call_record = {
-          method_name: method_name,
-          start_time: monotonic_time,
-          depth: @call_stack.size,
-          parent: @call_stack.last,
-          children: [],
-          status: nil,
-          error: nil,
-          execution_time: nil,
-          timestamp: Time.now
-        }
+    def start_call(method_name)
+      stack = thread_call_stack
+
+      call_record = {
+        method_name: method_name,
+        start_time: monotonic_time,
+        depth: stack.size,
+        children: [],
+        status: nil,
+        error: nil,
+        execution_time: nil,
+        timestamp: Time.now
+      }
 
-        # Add as child to parent if we're nested
-        @call_stack.last[:children] << call_record if @call_stack.any?
+      # Add as child to parent if we're nested
+      stack.last[:children] << call_record if stack.any?
 
-        # Track root-level calls
-        @root_calls << call_record if @call_stack.empty?
+      # Track root-level calls (lock required since @root_calls is shared)
+      @lock.synchronize { @root_calls << call_record } if stack.empty?
 
-        @call_stack.push(call_record)
-        call_record
-      end
+      stack.push(call_record)
+      call_record
     end
 
     # End tracking a method call
@@ -51,24 +54,23 @@ module RubyMethodTracer
     # @param error [Exception, nil] The exception if status is :error
     # @return [Hash, nil] The completed call record
     def end_call(status = :success, error = nil)
-      @lock.synchronize do
-        return nil if @call_stack.empty?
+      stack = thread_call_stack
+      return nil if stack.empty?
 
-        call_record = @call_stack.pop
-        call_record[:status] = status
-        call_record[:error] = error
-        call_record[:execution_time] = monotonic_time - call_record[:start_time]
+      call_record = stack.pop
+      call_record[:status] = status
+      call_record[:error] = error
+      call_record[:execution_time] = monotonic_time - call_record[:start_time]
 
-        @calls << call_record
-        call_record
-      end
+      @lock.synchronize { @calls << call_record }
+      call_record
     end
 
-    # Get the current call depth
+    # Get the current call depth for the calling thread
     #
     # @return [Integer] The current nesting level
     def current_depth
-      @lock.synchronize { @call_stack.size }
+      thread_call_stack.size
     end
 
     # Get call hierarchy as nested structure
@@ -100,23 +102,33 @@ module RubyMethodTracer
     end
 
     # Clear all recorded calls and reset state
+    #
+    # Note: only the current thread's call stack is cleared; other threads
+    # that are mid-trace retain their stacks.
     def clear
       @lock.synchronize do
         @calls.clear
-        @call_stack.clear
         @root_calls.clear
       end
+      thread_call_stack.clear
     end
 
-    # Check if call stack is empty (no active calls)
+    # Check if the current thread has no active calls
     #
     # @return [Boolean]
     def empty?
-      @lock.synchronize { @call_stack.empty? }
+      thread_call_stack.empty?
     end
 
     private
 
+    # Returns the call stack for the current thread, creating it if needed.
+    # Using a per-instance key prevents interference between multiple CallTree
+    # instances running in the same thread.
+    def thread_call_stack
+      Thread.current[@thread_key] ||= []
+    end
+
     def monotonic_time
       Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end

data/lib/ruby_method_tracer/enhanced_tracer.rb

@@ -39,7 +39,7 @@ module RubyMethodTracer
       @target_class.send(:alias_method, aliased, method_name)
 
       tracer = self
-      key = :__ruby_method_tracer_in_trace
+      key = @tracer_key # unique per tracer instance; prevents cross-tracer interference
 
       # Build wrapper that tracks hierarchy
       @target_class.define_method(method_name, &build_enhanced_wrapper(aliased, method_name, key, tracer))
@@ -83,51 +83,59 @@ module RubyMethodTracer
 
     private
 
-    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
     def build_enhanced_wrapper(aliased, method_name, key, tracer)
       track_hierarchy = tracer.instance_variable_get(:@track_hierarchy)
       # Use method-specific key to prevent only SELF-recursion, not all nested calls
       method_key = :"#{key}_#{method_name}"
 
       proc do |*args, **kwargs, &block|
-        if track_hierarchy
-          # Prevent only recursive calls to the SAME method
-          return __send__(aliased, *args, **kwargs, &block) if Thread.current[method_key]
-
-          Thread.current[method_key] = true
-          full_method_name = "#{tracer.instance_variable_get(:@target_class)}##{method_name}"
-
-          # Start tracking in call tree
-          tracer.call_tree.start_call(full_method_name)
-
-          start = tracer.__send__(:monotonic_time)
-          begin
-            result = __send__(aliased, *args, **kwargs, &block)
-            execution_time = tracer.__send__(:monotonic_time) - start
-
-            # Record in both places
-            tracer.__send__(:record_call, method_name, execution_time, :success)
-            tracer.call_tree.end_call(:success)
-
-            result
-          rescue StandardError => e
-            execution_time = tracer.__send__(:monotonic_time) - start
-
-            # Record in both places
-            tracer.__send__(:record_call, method_name, execution_time, :error, e)
-            tracer.call_tree.end_call(:error, e)
+        # Ruby 3+ compatible forwarding helper (avoids passing **{} which caused
+        # SystemStackError with Ruby 3.4+ keyword argument forwarding)
+        call_aliased = lambda do
+          kwargs.empty? ? __send__(aliased, *args, &block) : __send__(aliased, *args, **kwargs, &block)
+        end
 
-            raise
-          ensure
-            Thread.current[method_key] = false
-          end
+        if track_hierarchy
+          tracer.__send__(:run_with_hierarchy, method_name, method_key, call_aliased)
         else
-          tracer.__send__(:wrap_call, method_name, key) do
-            __send__(aliased, *args, **kwargs, &block)
-          end
+          tracer.__send__(:wrap_call, method_name, key) { call_aliased.call }
         end
       end
     end
+
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    def run_with_hierarchy(method_name, method_key, call_aliased)
+      # Prevent only recursive calls to the SAME method
+      return call_aliased.call if Thread.current[method_key]
+
+      Thread.current[method_key] = true
+      full_method_name = "#{@target_class}##{method_name}"
+
+      # Start tracking in call tree before entering the timed section
+      @call_tree.start_call(full_method_name)
+
+      start = monotonic_time
+      call_status = :success
+      call_error = nil
+
+      begin
+        result = call_aliased.call
+        execution_time = monotonic_time - start
+        record_call(method_name, execution_time, :success)
+        result
+      rescue StandardError => e
+        call_status = :error
+        call_error = e
+        execution_time = monotonic_time - start
+        record_call(method_name, execution_time, :error, e)
+        raise
+      ensure
+        Thread.current[method_key] = false
+        # Always end the call tree entry, even for non-StandardError exceptions,
+        # to prevent the per-thread call stack from becoming corrupted.
+        @call_tree.end_call(call_status, call_error)
+      end
+    end
     # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
     def default_options

data/lib/ruby_method_tracer/simple_tracer.rb

@@ -2,6 +2,7 @@
 
 require "set"
 require "logger"
+require_relative "formatters/base_formatter"
 
 module RubyMethodTracer
   # SimpleTracer wraps instance methods on a target class and records
@@ -19,7 +20,7 @@ module RubyMethodTracer
   #   tracer = RubyMethodTracer::SimpleTracer.new(MyClass, threshold: 0.005)
   #   tracer.trace_method(:expensive_call)
   #   results = tracer.fetch_results
-  class SimpleTracer # rubocop:disable Metrics/ClassLength
+  class SimpleTracer
     def initialize(target_class, **options)
       @target_class = target_class
       @options = default_options.merge(options)
@@ -27,6 +28,9 @@ module RubyMethodTracer
       @lock  = Mutex.new # Mutex to make writes to @calls thread safe.
       @wrapped_methods = Set.new
       @logger = @options[:logger] || Logger.new($stdout)
+      # Unique per instance so separate tracers don't interfere with each other.
+      @tracer_key = :"__ruby_method_tracer_in_trace_#{object_id}"
+      @formatter = Formatters::BaseFormatter.new
     end
 
     def trace_method(name)
@@ -39,7 +43,7 @@ module RubyMethodTracer
       @target_class.send(:alias_method, aliased, method_name) # Aliases original implementation to our private name.
 
       tracer = self
-      key = :__ruby_method_tracer_in_trace # local key to avoid recursive tracing.
+      key = @tracer_key # unique per tracer instance; prevents cross-tracer interference
 
       # Defines a new method with the original name that delegates to our wrapper.
       @target_class.define_method(method_name, &build_wrapper(aliased, method_name, key, tracer))
@@ -161,27 +165,11 @@ module RubyMethodTracer
     end
 
     def format_time(seconds)
-      if seconds >= 1.0
-        "#{seconds.round(3)}s"
-      elsif seconds >= 0.001
-        "#{(seconds * 1000).round(1)}ms"
-      else
-        "#{(seconds * 1_000_000).round(0)}µs"
-      end
+      @formatter.format_time(seconds)
     end
 
     def colorize(text, color)
-      colors = {
-        red: "31",
-        green: "32",
-        yellow: "33",
-        blue: "34",
-        magenta: "35",
-        cyan: "36",
-        white: "37",
-        reset: "0"
-      }
-      "\e[#{colors[color]}m#{text}\e[#{colors[:reset]}m"
+      @formatter.colorize(text, color)
     end
   end
 end

data/lib/ruby_method_tracer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyMethodTracer
-  VERSION = "0.3.2"
+  VERSION = "0.3.3"
 end

data/lib/ruby_method_tracer.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 require_relative "ruby_method_tracer/version"
+require_relative "ruby_method_tracer/formatters/base_formatter"
 require_relative "ruby_method_tracer/simple_tracer"
 require_relative "ruby_method_tracer/call_tree"
 require_relative "ruby_method_tracer/enhanced_tracer"
-require_relative "ruby_method_tracer/formatters/base_formatter"
 require_relative "ruby_method_tracer/formatters/tree_formatter"
 
 # Public: Mixin that adds lightweight method tracing to classes.

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ruby_method_tracer
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors:
 - Seun Adekunle
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-11-22 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: A developer-friendly gem for tracing method calls, execution times, with
   minimal overhead.
@@ -42,7 +41,6 @@ metadata:
   source_code_uri: https://github.com/Seunadex/ruby_method_tracer
   changelog_uri: https://github.com/Seunadex/ruby_method_tracer/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -57,8 +55,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
-signing_key:
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Lightweight method tracing for Ruby applications
 test_files: []