ruby_method_tracer 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 172daf6a55bb4350983cdf15aafbe4b954f418183401ef2be69c6b68c31a575d
-  data.tar.gz: '019cd6fd2053967bff554ae244eed994c614a585b16d16f1509e57a5ec5a444e'
+  metadata.gz: 30805a204ee568f587faac32d8436594b0b7268751c1c51d297a63a35f727a97
+  data.tar.gz: e5fc11f03078cca02c167ccff3fa306e7d1a433b31677f98193a29c506289a27
 SHA512:
-  metadata.gz: 86454302178091a987db42dc9eff6e3fd320822ec38c29b27b35c7c0e92ffc16b4f2844131716202969929df8c90f3870e5b0a403ad290df7339d4fc986d2dc9
-  data.tar.gz: 3acee9f7dd4398d23ce23d34150dd88e258b9fe09cc420f364132d1fbdea4fb6bed07cdcef7a2710b2264763fb83b7dc8365534991c3057488aa3f41e3d45440
+  metadata.gz: 06d263839600dd89c18155ddc836a08aa6d304a763d4c92bb7235c28974e1a8ed1ce83eb7db174f81b75b1d0f5d98ecb1acf84ce6b1c2f875a9ab8b3b21f7fd7
+  data.tar.gz: f441ede20bd32db451673f5643a12292e2609d6c884a89f255cded0e60ff3ee2fab170a1396d7ae86e23e6a6af77b89bf5a32aa0049394107ed050a4cd98cf8e

data/CHANGELOG.md

@@ -1,5 +1,39 @@
 ## [Unreleased]
 
+## [0.5.0] - 2026-09-30
+
+### Fixed
+- Tracing a method that is already traced no longer aliases the wrapper onto itself and raises `SystemStackError`. The duplicate-wrap guard now checks the target class for the alias instead of only consulting the tracer's own bookkeeping, so a second `trace_methods` call, or a second tracer instance, is refused with a warning rather than crashing at call time.
+- `CallTree` now honours `:max_calls`, capping both completed calls and retained root trees. Previously only the flat results list was bounded, so an `EnhancedTracer` left enabled grew without limit — every node, parent pointer and `Time` object stayed reachable for the life of the tracer.
+- `:threshold` now applies to the call tree as well as the flat list. Calls below the threshold are dropped unless they have children worth reporting, so `print_tree`, the JSON hierarchy and the tree statistics no longer disagree with `fetch_results`.
+- `trace_method` warns instead of silently doing nothing when the named method does not exist, and returns `false`. A typo, a rename or a method defined after the `trace_methods` call previously produced empty results with no explanation.
+- `RubyMethodTracer.configure` no longer holds a `Mutex` across the caller's block, which made a nested `configure` — reachable through any helper or engine initializer — fail with `ThreadError: deadlock; recursive locking`. The lock provided no real safety, since `configuration` hands out the same mutable object without it.
+- Methods that exit via `throw` or a non-`StandardError` exception are now recorded with a new `:incomplete` status instead of vanishing from the results.
+- `Exportable#export` no longer raises `NameError` on platforms without the POSIX `O_NOFOLLOW` flag (notably Windows); the flag is applied only where `File::NOFOLLOW` is defined, and the stat-based symlink guard still applies everywhere.
+- `Formatters::BaseFormatter#format` now takes `(_data, _options = {})`, matching every subclass. The abstract contract previously described a signature no implementation used.
+- On Ruby 3.0, tracing a method that uses `...` argument forwarding raised `ArgumentError` on any keyword argument. Ruby 3.0 describes `def m(...)` as a bare rest plus a block and omits the keyword rest that 3.1+ reports, so the generated wrapper funnelled keywords into the positional array. The missing keyword rest is put back on that version only — on 3.1+ the same shape means `def m(*, &)`, which genuinely takes no keywords.
+- Tracing a method whose name is not a plain identifier — a predicate (`ready?`), bang (`save!`), setter (`val=`) or operator (`==`, `[]`, `[]=`, `<=>`, `<<`, `-@`) — now works. The saved original is aliased under a name the parser accepts, since the generated wrapper calls it directly; previously such an alias could misparse silently rather than fail loudly.
+
+### Added
+- `CallTree#calls_snapshot`, and an optional `execution_time` argument to `CallTree#end_call` so a caller that already timed the call does not pay for a second clock read.
+- `SimpleTracer#untrace_method` and `#untrace_all` restore traced methods to their original implementation and visibility.
+- `trace_class_methods` on the mixin traces class (singleton) methods, which the documented API previously could not reach. Traced singleton methods are reported as `Klass.method` rather than `#<Class:Klass>#method`.
+- Real RBS signatures for the whole public API, validated in CI and by `rake rbs`. The shipped file was previously the generated template declaring only `VERSION`.
+- `RubyMethodTracer::Wrapper`, which generates the traced replacement for a method from the original's `parameters`.
+- `RubyMethodTracer::CallTreeStatistics`, extracted from `CallTree`.
+
+### Changed
+- **Breaking:** `trace_methods` now returns the `SimpleTracer` it created instead of the array of method names, and memoizes one tracer per class. Results collected through the mixin were previously unreachable unless `auto_output: true` was set.
+- Tracing a method preserves its `Method#arity` and `Method#parameters`. The wrapper is generated from the original signature rather than being a generic `proc { |*args, **kwargs, &block| }`, so reflection-driven callers (dependency injection, serializers, argument validators, documentation tooling) still see the real signature. Two limitations remain: a block parameter is always declared, because a method may `yield` without declaring one, and anonymous parameters (`def m(*)`, `def m(...)`) keep their arity but are given generated names.
+- The alias holding the original implementation (`__ruby_method_tracer_original_<name>__`) is now private. It previously inherited the original's visibility and appeared in the public API of every instance.
+- **Per-call overhead roughly halved for `EnhancedTracer` and cut by about a third for `SimpleTracer`.** Measured on one machine with the same harness for both versions, against an untraced call at ~54ns: `SimpleTracer` 464ns → 354ns below threshold and 836ns → 665ns when recording; `EnhancedTracer` 2144ns → 1081ns below threshold and 2264ns → 1344ns when recording. Three changes account for it:
+  - The timing path is now emitted inline in the generated wrapper — the reentrancy guard, both clock reads and the `begin/rescue/ensure` all live in the method itself. It calls the tracer once per invocation instead of threading a block down through `dispatch`, `wrap_call` and `timed`, each of which cost a frame and a `Proc`.
+  - `EnhancedTracer` no longer maintains a flat call list alongside the tree. `fetch_results` is derived from the tree instead, so a traced call is recorded once rather than twice — and the two views now agree by construction.
+  - Everything knowable at trace time is baked into the wrapper as a literal (the reentrancy key, the method name, the display name) and methods whose parameters all forward unconditionally skip building an argument array, so the common case allocates nothing and does no hash lookups on the call path.
+- CI now runs the specs on Ruby 3.0 through 3.4 and head, with RuboCop and RBS validation as a separate job. The matrix previously tested only 3.3.5 even though the gemspec supports `>= 3.0.0` — and two of the last four releases fixed keyword-forwarding breakage that only shows up on specific versions.
+- `render(format: :tree)` on a `SimpleTracer` now explains that the format needs a call tree instead of reporting an unknown format.
+- The gemspec globs `lib/` and `sig/` instead of deriving its file list from `git ls-files`, and no longer ships development files. The git-based list silently omitted any file that was new and not yet staged — which is how the released 0.3.0 shipped without `EnhancedTracer` and the formatters (fixed in 0.3.1). A `gem-smoke` CI job now builds the gem, installs it and traces through it, so a missing file fails the build instead of a user's install.
+
 ## [0.4.0] - 2026-06-09
 
 ### Added

data/README.md

@@ -6,13 +6,15 @@
 RubyMethodTracer is a lightweight Ruby mixin for targeted method tracing. It wraps instance methods, measures wall-clock runtime, flags errors, and can stream results to your logger without pulling in a full APM agent. Use it to surface slow paths in production or gather quick instrumentation while debugging.
 
 ## Highlights
-- Wrap only the methods you care about; public, protected, and private methods are supported.
+- Wrap only the methods you care about; public, protected, and private methods are supported, along with class methods.
 - Records duration, success/error state, and timestamps with thread-safe storage.
 - **Hierarchical call tree visualization** to understand nested method calls and dependencies.
-- **NEW: JSON and flat-table formatters plus file export**, alongside the existing tree output.
-- **NEW: Global configuration** via `RubyMethodTracer.configure` for process-wide defaults.
+- **Signature-preserving wrappers**: a traced method keeps its `arity` and `parameters`, so reflection-driven code still sees the real signature.
+- **Reversible**: `untrace_method` puts the original implementation and visibility back.
+- JSON and flat-table formatters plus file export, alongside the tree output.
+- Global configuration via `RubyMethodTracer.configure` for process-wide defaults.
 - Configurable threshold to ignore fast calls and optional log streaming via `Logger`.
-- Zero dependencies beyond the Ruby standard library, keeping overhead minimal.
+- Zero dependencies beyond the Ruby standard library.
 
 ## Installation
 
@@ -63,7 +65,7 @@ class Worker
   end
 end
 
-Worker.trace_methods(:perform, threshold: 0.005, auto_output: true)
+tracer = Worker.trace_methods(:perform, threshold: 0.005, auto_output: true)
 
 Worker.new.perform(42)
 ```
@@ -74,11 +76,13 @@ With `auto_output: true`, each invocation prints a colorized summary:
 TRACE: Worker#perform [OK] took 6.3ms
 ```
 
-To inspect trace results programmatically, manage the tracer yourself:
+`trace_methods` returns the tracer it created, so results are available directly.
+One tracer is memoized per class: calling `trace_methods` again adds methods to
+the same tracer rather than wrapping anything twice, and options are read on the
+first call.
 
 ```ruby
-tracer = RubyMethodTracer::SimpleTracer.new(Worker, threshold: 0.002)
-tracer.trace_method(:perform)
+tracer = Worker.trace_methods(:perform, threshold: 0.002)
 
 Worker.new.perform(42)
 
@@ -93,6 +97,40 @@ pp tracer.fetch_results
 
 # Clear results when needed to free memory
 tracer.clear_results
+
+# Put the original method back when you are done
+tracer.untrace_method(:perform)
+```
+
+You can also construct a tracer directly, which is what you want when the class
+is not yours to modify:
+
+```ruby
+tracer = RubyMethodTracer::SimpleTracer.new(Worker, threshold: 0.002)
+tracer.trace_method(:perform)
+```
+
+### Tracing class methods
+
+Class (singleton) methods need `trace_class_methods`, or a tracer built on the
+singleton class. They are reported as `Klass.method`.
+
+```ruby
+class Report
+  include RubyMethodTracer
+
+  def self.generate(range)
+    # ...
+  end
+end
+
+tracer = Report.trace_class_methods(:generate, threshold: 0.0)
+Report.generate(1..10)
+
+tracer.fetch_results[:calls].first[:method_name] # => "Report.generate"
+
+# Equivalent, without the mixin:
+RubyMethodTracer::SimpleTracer.new(Report.singleton_class).trace_method(:generate)
 ```
 
 ### Example 2
@@ -263,9 +301,9 @@ Supported formats: `:json`, `:flat`, and `:tree` (EnhancedTracer only).
 
 ### Options (SimpleTracer)
 
-- `threshold` (Float, default `0.001`): minimum duration (in seconds) to record.
+- `threshold` (Float, default `0.001`): minimum duration (in seconds) to record. On `EnhancedTracer` this also filters the call tree; a call below the threshold is kept only if it has children worth reporting.
 - `auto_output` (Boolean, default `false`): emit a log line using `Logger` for each recorded call.
-- `max_calls` (Integer, default `1000`): maximum number of calls to store in memory. When exceeded, the oldest calls are automatically removed to prevent memory leaks.
+- `max_calls` (Integer, default `1000`): maximum number of calls to store in memory. When exceeded, the oldest calls are automatically removed to prevent memory leaks. On `EnhancedTracer` this bounds the call tree and the retained root trees as well.
 - `logger` (Logger, default `Logger.new($stdout)`): custom logger instance for output. Useful for directing logs to files or custom log handlers.
 
 ### Options (EnhancedTracer)
@@ -274,6 +312,15 @@ EnhancedTracer supports all SimpleTracer options plus:
 
 - `track_hierarchy` (Boolean, default `true`): enable call tree tracking. Set to `false` to use EnhancedTracer like SimpleTracer.
 
+### API Methods (SimpleTracer)
+
+- `trace_method(name)` - Wrap a method. Returns `false` and warns if the method does not exist, or if it is already traced.
+- `untrace_method(name)` - Restore the original implementation and visibility. Returns `false` if this tracer did not trace it.
+- `untrace_all` - Restore every method this tracer wrapped; returns the method names.
+- `fetch_results` - Hash with `:total_calls`, `:total_time` and `:calls`.
+- `clear_results` - Discard recorded calls.
+- `render(format:)` / `export(path, format:)` - See Reporting & Export.
+
 ### API Methods (EnhancedTracer)
 
 - `print_tree(options = {})` - Print formatted call tree to stdout
@@ -282,11 +329,41 @@ EnhancedTracer supports all SimpleTracer options plus:
 - `fetch_enhanced_results` - Get hash with `:flat_calls`, `:call_hierarchy`, and `:statistics`
 - `clear_results` - Clear both flat results and call tree
 
+## Overhead
+
+Tracing wraps each call, so it is not free. As a rough shape on a warm VM,
+`SimpleTracer` costs a handful of times what an empty method call costs, and
+`EnhancedTracer` costs a few times that again to maintain the call tree.
+
+The wrapper is generated per method and does the timing inline — one tracer call
+per invocation, no intermediate frames, no `Proc` allocation, and the reentrancy
+key and display name baked in as literals — so the floor is close to the cost of
+two clock reads plus the bookkeeping you asked for.
+
+In practice that is invisible next to a method that does real work: a database
+query, an HTTP call, a template render. That is the case this gem is built for.
+It is not something to leave enabled on a hot inner method in a tight loop; for
+whole-process profiling, reach for a sampling profiler instead. Raising
+`threshold` avoids storing a record, which is the larger half of the cost, but
+the wrapper still runs on every call — so prefer tracing fewer methods over
+tracing many with a high threshold.
+
+## Known limitations
+
+- A traced method keeps its `arity` and `parameters`, with two exceptions: a
+  block parameter is always declared (a method may `yield` without declaring
+  one, and block parameters do not affect arity), and anonymous parameters
+  (`def m(*)`, `def m(...)`) keep their arity but are given generated names.
+- Tracing changes the method on the class itself, so it affects every instance
+  and every subclass that inherits it.
+- A method can only be traced by one tracer at a time. A second attempt warns
+  and is refused rather than wrapping twice.
+
 ## Choosing Between SimpleTracer and EnhancedTracer
 
 **Use SimpleTracer when:**
 - You only need flat timing data
-- You want minimal overhead
+- You want the lower overhead of the two — roughly a third of `EnhancedTracer`'s
 - You're tracing independent methods
 
 **Use EnhancedTracer when:**

data/lib/ruby_method_tracer/call_tree.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "call_tree_statistics"
+
 module RubyMethodTracer
   # CallTree manages the hierarchical structure of method calls,
   # tracking parent-child relationships and call depths.
@@ -10,12 +12,22 @@ module RubyMethodTracer
   # 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.
+  #
+  # Retention is bounded on both ends: calls faster than :threshold are
+  # dropped unless they have children worth keeping, and :max_calls caps how
+  # many completed calls and root trees are retained.
   class CallTree
     attr_reader :calls, :root_calls
 
-    def initialize
+    DEFAULT_MAX_CALLS = 1000
+
+    # @param threshold [Float] Minimum duration in seconds for a leaf call to be kept
+    # @param max_calls [Integer] Maximum completed calls and root trees to retain
+    def initialize(threshold: 0.0, max_calls: DEFAULT_MAX_CALLS)
+      @threshold = threshold
+      @max_calls = max_calls
       @calls = []           # All recorded calls (flat list, shared)
-      @root_calls = []      # Top-level calls (depth 0, shared)
+      @root_calls = []      # Completed 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
@@ -41,29 +53,32 @@ module RubyMethodTracer
       # Add as child to parent if we're nested
       stack.last[:children] << call_record if stack.any?
 
-      # Track root-level calls (lock required since @root_calls is shared)
-      @lock.synchronize { @root_calls << call_record } if stack.empty?
-
+      # Root calls are collected on completion rather than here, so an
+      # in-flight call is never visible to readers of the hierarchy.
       stack.push(call_record)
       call_record
     end
 
     # End tracking a method call
     #
-    # @param status [Symbol] :success or :error
+    # @param status [Symbol] :success, :error or :incomplete
     # @param error [Exception, nil] The exception if status is :error
-    # @return [Hash, nil] The completed call record
-    def end_call(status = :success, error = nil)
+    # @param execution_time [Float, nil] Duration in seconds. Callers that
+    #   already timed the call pass it in, which saves a clock read here; when
+    #   omitted it is measured from the record's start time.
+    # @return [Hash, nil] The completed call record, or nil if it was dropped
+    def end_call(status = :success, error = nil, execution_time = nil)
       stack = thread_call_stack
       return nil if stack.empty?
 
       call_record = stack.pop
       call_record[:status] = status
       call_record[:error] = error
-      call_record[:execution_time] = monotonic_time - call_record[:start_time]
+      call_record[:execution_time] = execution_time || (monotonic_time - call_record[:start_time])
 
-      @lock.synchronize { @calls << call_record }
-      call_record
+      return discard(call_record, stack.last) if discardable?(call_record)
+
+      retain(call_record)
     end
 
     # Get the current call depth for the calling thread
@@ -73,6 +88,13 @@ module RubyMethodTracer
       thread_call_stack.size
     end
 
+    # Snapshot of every retained call, flat.
+    #
+    # @return [Array<Hash>] Completed call records, oldest first
+    def calls_snapshot
+      @lock.synchronize { @calls.dup }
+    end
+
     # Get call hierarchy as nested structure
     #
     # @return [Array<Hash>] Root calls with nested children
@@ -84,21 +106,7 @@ module RubyMethodTracer
     #
     # @return [Hash] Statistics including total calls, time, slowest methods, etc.
     def statistics
-      @lock.synchronize do
-        return default_statistics if @calls.empty?
-
-        method_stats = calculate_method_stats
-
-        {
-          total_calls: @calls.size,
-          total_time: @calls.sum { |c| c[:execution_time] },
-          unique_methods: method_stats.size,
-          slowest_methods: slowest_methods(method_stats),
-          most_called_methods: most_called_methods(method_stats),
-          average_time_per_method: average_times(method_stats),
-          max_depth: @calls.map { |c| c[:depth] }.max || 0
-        }
-      end
+      CallTreeStatistics.new(calls_snapshot).to_h
     end
 
     # Clear all recorded calls and reset state
@@ -122,58 +130,42 @@ module RubyMethodTracer
 
     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)
+    # A call is dropped only when it is too fast to be interesting and has no
+    # children — dropping a parent would orphan the descendants it recorded.
+    def discardable?(call_record)
+      call_record[:execution_time] < @threshold && call_record[:children].empty?
     end
 
-    def default_statistics
-      {
-        total_calls: 0,
-        total_time: 0.0,
-        unique_methods: 0,
-        slowest_methods: [],
-        most_called_methods: [],
-        average_time_per_method: {},
-        max_depth: 0
-      }
+    # The record is always the last child appended by this thread's stack, so
+    # detaching it is a pop rather than a scan.
+    def discard(call_record, parent)
+      parent[:children].pop if parent && parent[:children].last.equal?(call_record)
+      nil
     end
 
-    def calculate_method_stats
-      method_stats = Hash.new { |h, k| h[k] = { calls: 0, total_time: 0.0, times: [] } }
-
-      @calls.each do |call|
-        stats = method_stats[call[:method_name]]
-        stats[:calls] += 1
-        stats[:total_time] += call[:execution_time]
-        stats[:times] << call[:execution_time]
+    def retain(call_record)
+      @lock.synchronize do
+        @calls << call_record
+        @calls.shift while @calls.size > @max_calls
+        next unless call_record[:depth].zero?
+
+        # Dropping the oldest root releases its whole subtree; without this the
+        # flat cap above could not actually free anything.
+        @root_calls << call_record
+        @root_calls.shift while @root_calls.size > @max_calls
       end
-
-      method_stats
-    end
-
-    def slowest_methods(method_stats)
-      method_stats
-        .map { |name, stats| { method: name, avg_time: stats[:total_time] / stats[:calls] } }
-        .sort_by { |m| -m[:avg_time] }
-        .take(10)
+      call_record
     end
 
-    def most_called_methods(method_stats)
-      method_stats
-        .map { |name, stats| { method: name, count: stats[:calls] } }
-        .sort_by { |m| -m[:count] }
-        .take(10)
+    # 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 average_times(method_stats)
-      method_stats.transform_values { |stats| stats[:total_time] / stats[:calls] }
+    def monotonic_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
   end
 end

data/lib/ruby_method_tracer/call_tree_statistics.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RubyMethodTracer
+  # CallTreeStatistics summarises a list of completed call records.
+  #
+  # It is a pure function of the records handed to it — the caller is
+  # responsible for reading them under whatever lock protects them.
+  class CallTreeStatistics
+    TOP_N = 10
+
+    EMPTY = {
+      total_calls: 0,
+      total_time: 0.0,
+      unique_methods: 0,
+      slowest_methods: [],
+      most_called_methods: [],
+      average_time_per_method: {},
+      max_depth: 0
+    }.freeze
+
+    def initialize(calls)
+      @calls = calls
+    end
+
+    # @return [Hash] Totals, the slowest and most-called methods, and max depth
+    def to_h
+      return EMPTY.dup if @calls.empty?
+
+      stats = per_method
+
+      {
+        total_calls: @calls.size,
+        total_time: @calls.sum { |call| call[:execution_time] },
+        unique_methods: stats.size,
+        slowest_methods: slowest(stats),
+        most_called_methods: most_called(stats),
+        average_time_per_method: averages(stats),
+        max_depth: max_depth
+      }
+    end
+
+    private
+
+    def per_method
+      blank = Hash.new { |hash, key| hash[key] = { calls: 0, total_time: 0.0 } }
+      @calls.each_with_object(blank) do |call, stats|
+        entry = stats[call[:method_name]]
+        entry[:calls] += 1
+        entry[:total_time] += call[:execution_time]
+      end
+    end
+
+    def slowest(stats)
+      stats
+        .map { |name, entry| { method: name, avg_time: entry[:total_time] / entry[:calls] } }
+        .sort_by { |method| -method[:avg_time] }
+        .take(TOP_N)
+    end
+
+    def most_called(stats)
+      stats
+        .map { |name, entry| { method: name, count: entry[:calls] } }
+        .sort_by { |method| -method[:count] }
+        .take(TOP_N)
+    end
+
+    def averages(stats)
+      stats.transform_values { |entry| entry[:total_time] / entry[:calls] }
+    end
+
+    def max_depth
+      @calls.map { |call| call[:depth] }.max || 0
+    end
+  end
+end

data/lib/ruby_method_tracer/enhanced_tracer.rb

@@ -15,6 +15,12 @@ module RubyMethodTracer
   # - All options from SimpleTracer
   # - :track_hierarchy (Boolean): Enable call tree tracking; defaults to true
   #
+  # The call tree honours the same :threshold and :max_calls limits as the flat
+  # results, so leaving a tracer enabled cannot grow the tree without bound.
+  #
+  # The tree is the only store: `fetch_results` is derived from it rather than
+  # maintained alongside it, so a traced call is recorded once, not twice.
+  #
   # Usage:
   #   tracer = RubyMethodTracer::EnhancedTracer.new(MyClass, threshold: 0.005)
   #   tracer.trace_method(:expensive_call)
@@ -24,29 +30,11 @@ module RubyMethodTracer
 
     def initialize(target_class, **options)
       super
-      @call_tree = CallTree.new
+      @call_tree = CallTree.new(threshold: @options[:threshold], max_calls: @options[:max_calls])
       @track_hierarchy = @options.fetch(:track_hierarchy, true)
       @formatter = Formatters::TreeFormatter.new
     end
 
-    def trace_method(name)
-      method_name = name.to_sym
-      visibility = method_visibility(method_name)
-      return unless visibility
-      return unless mark_wrapped?(method_name)
-
-      aliased = alias_for(method_name)
-      @target_class.send(:alias_method, aliased, method_name)
-
-      tracer = self
-      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))
-
-      @target_class.send(visibility, method_name)
-    end
-
     # Print the call tree visualization
     #
     # @param options [Hash] Formatting options
@@ -64,6 +52,25 @@ module RubyMethodTracer
       @formatter.format(@call_tree, options)
     end
 
+    # Flat results, derived from the call tree.
+    #
+    # The tree already holds every completed call with its duration, status and
+    # error, so keeping a second parallel list would mean recording each call
+    # twice. The projection below is what makes the two views agree by
+    # construction.
+    #
+    # @return [Hash] Totals and the flat call list
+    def fetch_results
+      return super unless @track_hierarchy
+
+      snapshot = @call_tree.calls_snapshot
+      {
+        total_calls: snapshot.size,
+        total_time: snapshot.sum { |call| call[:execution_time] },
+        calls: snapshot.map { |call| flat_record(call) }
+      }
+    end
+
     # Get enhanced results including both flat list and hierarchy
     #
     # @return [Hash] Results with call tree and statistics
@@ -75,6 +82,28 @@ module RubyMethodTracer
       }
     end
 
+    # Wrapper entry point: open a call-tree entry.
+    #
+    # Public because the generated wrapper calls it with an explicit receiver,
+    # which cannot reach a private method.
+    #
+    # @param display_name [String] Name as it should appear in reports
+    def start_call(display_name)
+      @call_tree.start_call(display_name)
+    end
+
+    # Wrapper entry point: close the call-tree entry for this invocation.
+    #
+    # Nothing is stored in the flat list — `fetch_results` derives it from the
+    # tree — so a traced call is recorded once. `end_call` returns nil when the
+    # call fell below the threshold, which is what gates auto output.
+    def record_call(method_name, execution_time, status, error = nil)
+      return super unless @track_hierarchy
+
+      call = @call_tree.end_call(status, error, execution_time)
+      output_call(flat_record(call)) if call && @options[:auto_output]
+    end
+
     # Clear both simple tracer results and call tree
     def clear_results
       super
@@ -83,6 +112,30 @@ module RubyMethodTracer
 
     private
 
+    def flat_record(call)
+      {
+        method_name: call[:method_name],
+        execution_time: call[:execution_time],
+        status: call[:status],
+        error: call[:error],
+        timestamp: call[:timestamp]
+      }
+    end
+
+    # Per-method reentrancy key so that *different* wrapped methods can nest
+    # inside each other; only self-recursion is blocked. Baked into the wrapper
+    # as a literal, so no lookup happens on the call path.
+    def wrapper_plan(method_name)
+      return super unless @track_hierarchy
+
+      Wrapper::Plan.new(
+        key: :"#{@tracer_key}_#{method_name}",
+        close: :record_call,
+        open: :start_call,
+        display_name: qualified_name(method_name)
+      )
+    end
+
     # Expose the call tree so JSON/flat exports include hierarchy + statistics.
     def report_source
       @call_tree
@@ -94,61 +147,6 @@ module RubyMethodTracer
       super
     end
 
-    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|
-        # 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
-
-        if track_hierarchy
-          tracer.__send__(:run_with_hierarchy, method_name, method_key, call_aliased)
-        else
-          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
       super.merge(track_hierarchy: RubyMethodTracer.configuration.track_hierarchy)
     end