ruby_method_tracer 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0065736cb0a7ab6630033102a0d8ac8b1f580247af2a2d900fef370d20c47dd6
-  data.tar.gz: a1570a748f6efab75db30022ae009f0dae2a32a899ce7471f92ba995c34e72ac
+  metadata.gz: e5fe5404bd1497820b14ca1e4bc041f778cfe9bc02402a4456329c88d0096206
+  data.tar.gz: cb08942010ab25a16a604d0edb973bd9f889e3c34ba2ae24ead8a0dcceed4ca8
 SHA512:
-  metadata.gz: 23e09c2e3c206e25155bbfa5ee4b62fd1e5fc19d02fce8d3c004c6ac5ead1145077c78a87a597b67c06d9f2e06f542b9a8bae3cee7cdb484a8e2bc4319d53824
-  data.tar.gz: bcfdcb7a8a975596b8a7de6b7f91927c6ab3f3060d8f94cac82a289dde0af024cb5efce8736a2a9860551526bd620b53fe1f1f35d89f4185538cd78121b19c16
+  metadata.gz: f68e49cde1042577a5ed2f0054c263391070f29574d81bc58f6ec5db6f688f31411572372cce95eef010fbd6fc7cd981f38905cc01615eea914a680393af850a
+  data.tar.gz: 54b2ccc817924cd256dfdcfb66011acfa8641b76f66d2cb0ef59dab48e32f4d2bfa9d56d56d403f5bf60b53c627d784731984e0f61fc8ad01714576eba531620

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 ## [Unreleased]
 
+## [0.3.0] - 2025-11-19
+
+### Added
+- **NEW: Hierarchical Call Tree Visualization** - `EnhancedTracer` class for tracking nested method calls
+- `CallTree` class for managing call hierarchy with parent-child relationships
+- `TreeFormatter` for beautiful tree visualization with proper indentation and tree characters
+- Statistics calculation: slowest methods, most called methods, max call depth
+- `print_tree()` method for outputting formatted call trees
+- `format_tree()` method for programmatic access to tree visualization
+- `fetch_enhanced_results()` for combined flat and hierarchical data
+- Thread-safe call stack management
+- Error tracking in call tree with full error messages
+- Color-coded tree output for better readability
+- 24 new comprehensive tests covering call tree functionality
+
+### Changed
+- Main module now auto-loads `EnhancedTracer` and formatting classes
+- README updated with call tree examples and usage guide
+- Documentation expanded with decision guide for choosing between SimpleTracer and EnhancedTracer
+
 ## [0.2.0] - 2025-11-19
 
 ### Added

data/README.md

@@ -7,6 +7,7 @@ RubyMethodTracer is a lightweight Ruby mixin for targeted method tracing. It wra
 ## Highlights
 - Wrap only the methods you care about; public, protected, and private methods are supported.
 - Records duration, success/error state, and timestamps with thread-safe storage.
+- **NEW: Hierarchical call tree visualization** to understand nested method calls and dependencies.
 - Configurable threshold to ignore fast calls and optional log streaming via `Logger`.
 - Zero dependencies beyond the Ruby standard library, keeping overhead minimal.
 
@@ -125,14 +126,127 @@ tracer.trace_method(:expensive_operation)
 tracer.clear_results
 ```
 
+### Example 4: Call Tree Visualization (NEW!)
 
-### Options
+Visualize hierarchical method call relationships with the `EnhancedTracer`:
+
+```ruby
+class OrderProcessor
+  def process_order(order)
+    validate_order(order)
+    charge_payment(order)
+    send_confirmation(order)
+  end
+
+  def validate_order(order)
+    check_inventory(order.items)
+  end
+
+  def charge_payment(order)
+    # Payment processing...
+  end
+
+  def send_confirmation(order)
+    # Email sending...
+  end
+
+  private
+
+  def check_inventory(items)
+    # Inventory check...
+  end
+end
+
+# Use EnhancedTracer for call tree tracking
+tracer = RubyMethodTracer::EnhancedTracer.new(OrderProcessor, threshold: 0.0)
+tracer.trace_method(:process_order)
+tracer.trace_method(:validate_order)
+tracer.trace_method(:charge_payment)
+tracer.trace_method(:send_confirmation)
+tracer.trace_method(:check_inventory)
+
+processor = OrderProcessor.new
+processor.process_order(order)
+
+# Print beautiful call tree visualization
+tracer.print_tree
+```
+
+This outputs a hierarchical tree showing nested calls:
+
+```
+METHOD CALL TREE
+============================================================
+└── OrderProcessor#process_order (125.3ms)
+    ├── OrderProcessor#validate_order (15.2ms)
+    │   └── OrderProcessor#check_inventory (12.1ms)
+    ├── OrderProcessor#charge_payment (85.4ms)
+    └── OrderProcessor#send_confirmation (24.7ms)
+============================================================
+
+STATISTICS
+------------------------------------------------------------
+Total Calls: 5
+Total Time: 250.6ms
+Unique Methods: 5
+Max Depth: 2
+
+Slowest Methods (by average time):
+  1. OrderProcessor#process_order - 125.3ms
+  2. OrderProcessor#charge_payment - 85.4ms
+  3. OrderProcessor#send_confirmation - 24.7ms
+  4. OrderProcessor#validate_order - 15.2ms
+  5. OrderProcessor#check_inventory - 12.1ms
+
+Most Called Methods:
+  1. OrderProcessor#process_order - 1 calls
+  2. OrderProcessor#validate_order - 1 calls
+  ...
+```
+
+**Call Tree Features:**
+- Shows parent-child relationships between methods
+- Visual tree structure with proper indentation
+- Execution times for each method call
+- Statistics summary (slowest methods, most called, max depth)
+- Error indicators with full error messages
+- Color-coded output for better readability
+
+
+### Options (SimpleTracer)
 
 - `threshold` (Float, default `0.001`): minimum duration (in seconds) to record.
 - `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.
 - `logger` (Logger, default `Logger.new($stdout)`): custom logger instance for output. Useful for directing logs to files or custom log handlers.
 
+### Options (EnhancedTracer)
+
+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 (EnhancedTracer)
+
+- `print_tree(options = {})` - Print formatted call tree to stdout
+  - Options: `colorize: true/false`, `show_errors: true/false`
+- `format_tree(options = {})` - Get formatted call tree as string
+- `fetch_enhanced_results` - Get hash with `:flat_calls`, `:call_hierarchy`, and `:statistics`
+- `clear_results` - Clear both flat results and call tree
+
+## Choosing Between SimpleTracer and EnhancedTracer
+
+**Use SimpleTracer when:**
+- You only need flat timing data
+- You want minimal overhead
+- You're tracing independent methods
+
+**Use EnhancedTracer when:**
+- You need to understand call hierarchies
+- You want to visualize nested method calls
+- You're debugging complex call flows
+- You need statistics on method relationships
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then run `rake spec` to execute the test suite. You can also run `bin/console` for an interactive prompt.

data/lib/ruby_method_tracer/simple_tracer.rb

@@ -60,7 +60,7 @@ module RubyMethodTracer
 
       @lock.synchronize do
         @calls << call_details
-        # Enforce max_calls limit by removing oldesst entries
+        # Enforce max_calls limit by removing oldest entries
         @calls.shift if @calls.size > @options[:max_calls]
       end
 

data/lib/ruby_method_tracer/version.rb

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

data/lib/ruby_method_tracer.rb

@@ -2,6 +2,10 @@
 
 require_relative "ruby_method_tracer/version"
 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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_method_tracer
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Seun Adekunle