catpm 0.7.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9d4f65535550d3a1201fe91d55206136dac09a1fb028e37b01e860a81260abc
-  data.tar.gz: 5ba5802a2361921a743745b88983399a1f792c7539f40c5a0fc804375c435101
+  metadata.gz: 5e79483c6546d21e4b6054d481f3625616eb0c4044f1251d11be907983dadeb7
+  data.tar.gz: 555afaca6bfb09499fea0c24359ee7709d8b982759fb6717a577882d64c543cc
 SHA512:
-  metadata.gz: b3aee4ecf169a3254ff5193c77e7d1579559d0cfd7915ceeba7d6608ebb397c813dd9e3bf1170ea253ef5c893a1c8a42d009d5d911a8b46eb9a5c194b51fed23
-  data.tar.gz: fc242376c61f8b0f6943bb534922f6b854f6896e554ab2aa26f72a63a3aea615b243c4d14d3ec1c9738ab2457aeaabfbbbb277ca5a4c8d7b91a8a220e1685e97
+  metadata.gz: 2971732b88f54566048545753164728886136408fc0db9d82e20652c08b098973d0889a839fd66cd4a504def1a9c576cf2eab822dac9b381eda0f2e40d908123
+  data.tar.gz: c8c7b98c039e7c483e8d4e3e3a9e8c9f06a58e7cd396d303da5bd37c9771d6b463d84d62c9da5c9f87e3e1f688ebefe7bb8b016d7eac477030588513b2e0988c

data/README.md

@@ -1,5 +1,5 @@
 gem build catpm.gemspec
-gem push catpm-0.6.6.gem
+gem push catpm-0.7.0.gem
 
 # Catpm
 

data/lib/catpm/call_tracer.rb

@@ -4,25 +4,6 @@ module Catpm
   class CallTracer
     MAX_CALL_DEPTH = 64
 
-    # Global thread-safe path classification cache — avoids repeated Fingerprint.app_frame? calls
-    @global_path_cache = {}
-    @global_path_mutex = Mutex.new
-
-    class << self
-      def app_frame_cached?(path)
-        cached = @global_path_cache[path]
-        return cached unless cached.nil?
-
-        result = Fingerprint.app_frame?(path)
-        @global_path_mutex.synchronize do
-          # Cap cache to prevent unbounded growth across process lifetime
-          @global_path_cache.clear if @global_path_cache.size > 2000
-          @global_path_cache[path] = result
-        end
-        result
-      end
-    end
-
     def initialize(request_segments:)
       @request_segments = request_segments
       @call_stack = []
@@ -60,7 +41,7 @@ module Catpm
       @depth += 1
 
       path = tp.path
-      app = self.class.app_frame_cached?(path)
+      app = Fingerprint.app_frame?(path)
 
       unless app
         @call_stack.push(:skip)
@@ -97,11 +78,14 @@ module Catpm
     end
 
     def format_detail(defined_class, method_id)
-      if defined_class.singleton_class?
+      name = defined_class.name
+      if name
+        "#{name}##{method_id}"
+      elsif defined_class.singleton_class?
         owner = defined_class.attached_object
         "#{owner.name || owner.inspect}.#{method_id}"
       else
-        "#{defined_class.name || defined_class.inspect}##{method_id}"
+        "#{defined_class.inspect}##{method_id}"
       end
     end
   end

data/lib/catpm/collector.rb

@@ -90,6 +90,20 @@ module Catpm
               end
             end
 
+            # Inject call tree segments from sampler (replaces TracePoint-based CallTracer)
+            ctrl_idx = segments.index { |s| s[:type] == 'controller' }
+            if Catpm.config.instrument_call_tree && req_segments
+              tree_segs = req_segments.call_tree_segments
+              if tree_segs.any?
+                base_idx = segments.size
+                tree_segs.each do |seg|
+                  tree_parent = seg.delete(:_tree_parent)
+                  seg[:parent_index] = tree_parent ? (tree_parent + base_idx) : (ctrl_idx || 0)
+                  segments << seg
+                end
+              end
+            end
+
             # Fill untracked controller time with sampler data or synthetic segment
             ctrl_idx = segments.index { |s| s[:type] == 'controller' }
             if ctrl_idx
@@ -246,6 +260,20 @@ module Catpm
             end
             segments.unshift(root_segment)
 
+            # Inject call tree segments from sampler
+            ctrl_idx = segments.index { |s| s[:type] == 'controller' }
+            if Catpm.config.instrument_call_tree && req_segments
+              tree_segs = req_segments.call_tree_segments
+              if tree_segs.any?
+                base_idx = segments.size
+                tree_segs.each do |seg|
+                  tree_parent = seg.delete(:_tree_parent)
+                  seg[:parent_index] = tree_parent ? (tree_parent + base_idx) : (ctrl_idx || 0)
+                  segments << seg
+                end
+              end
+            end
+
             # Fill untracked controller time with sampler data or synthetic segment
             ctrl_idx = segments.index { |s| s[:type] == 'controller' }
             if ctrl_idx
@@ -339,14 +367,18 @@ module Catpm
       # ActiveSupport controller notification finishes.
       # Mutates segments in place: removes the wrapper and re-indexes parent references.
       def collapse_code_wrappers(segments)
+        # Pre-build set of parent indices that have a controller child — O(n)
+        parents_with_controller = {}
+        segments.each do |seg|
+          parents_with_controller[seg[:parent_index]] = true if seg[:type] == 'controller' && seg[:parent_index]
+        end
+
         # Identify code spans to collapse: near-zero duration wrapping a controller child
         collapse = {}
         segments.each_with_index do |seg, i|
           next unless seg[:type] == 'code'
           next unless (seg[:duration] || 0).to_f < 1.0
-
-          has_controller_child = segments.any? { |s| s[:parent_index] == i && s[:type] == 'controller' }
-          next unless has_controller_child
+          next unless parents_with_controller[i]
 
           collapse[i] = seg[:parent_index]
         end

data/lib/catpm/configuration.rb

@@ -71,7 +71,7 @@ module Catpm
       @instrument_stack_sampler = false
       @instrument_middleware_stack = false
       @max_segments_per_request = 50
-      @segment_source_threshold = 0.0 # ms — capture caller_locations for all segments (set higher to reduce overhead)
+      @segment_source_threshold = 5.0 # ms — capture caller_locations only for segments >= 5ms (set to 0.0 to capture all)
       @max_sql_length = 200
       @slow_threshold = 500 # milliseconds
       @slow_threshold_per_kind = {}
@@ -98,7 +98,7 @@ module Catpm
       @circuit_breaker_recovery_timeout = 60 # seconds
       @sqlite_busy_timeout = 5_000 # milliseconds
       @persistence_batch_size = 100
-      @backtrace_lines = nil
+      @backtrace_lines = 20 # frames per error backtrace (nil = unlimited)
       @shutdown_timeout = 5 # seconds
       @events_enabled = false
       @events_max_samples_per_name = 20

data/lib/catpm/fingerprint.rb

@@ -4,6 +4,9 @@ require 'digest'
 
 module Catpm
   module Fingerprint
+    @path_cache = {}
+    @path_cache_mutex = Mutex.new
+
     # Generates a stable fingerprint for error grouping.
     # Includes kind so the same exception in HTTP vs job = different groups.
     def self.generate(kind:, error_class:, backtrace:)
@@ -30,23 +33,60 @@ module Catpm
         .join("\n")
     end
 
-    # Checks if a backtrace line belongs to the host application (not a gem or stdlib)
+    # Cached wrapper — all callers benefit from the shared path cache.
     def self.app_frame?(line)
-      return false if line.include?('/gems/')
-      return false if line.include?('/ruby/')
-      return false if line.include?('<internal:')
-      return false if line.include?('/catpm/')
+      cached = @path_cache[line]
+      return cached unless cached.nil?
+
+      result = _app_frame?(line)
+      @path_cache_mutex.synchronize do
+        @path_cache.clear if @path_cache.size > 4000
+        @path_cache[line] = result
+      end
+      result
+    end
+
+    # Cached Rails.root.to_s — computed once, never changes after boot.
+    def self.cached_rails_root
+      return @cached_rails_root if defined?(@cached_rails_root)
 
-      if defined?(Rails) && Rails.respond_to?(:root) && Rails.root
-        return line.start_with?(Rails.root.to_s) if line.start_with?('/')
+      @cached_rails_root = if defined?(Rails) && Rails.respond_to?(:root) && Rails.root
+        Rails.root.to_s.freeze
       end
+    end
 
-      line.start_with?('app/') || line.include?('/app/')
+    # Cached "#{Rails.root}/" for path stripping.
+    def self.cached_rails_root_slash
+      return @cached_rails_root_slash if defined?(@cached_rails_root_slash)
+
+      root = cached_rails_root
+      @cached_rails_root_slash = root ? "#{root}/".freeze : nil
+    end
+
+    def self.reset_caches!
+      @path_cache_mutex.synchronize { @path_cache.clear }
+      remove_instance_variable(:@cached_rails_root) if defined?(@cached_rails_root)
+      remove_instance_variable(:@cached_rails_root_slash) if defined?(@cached_rails_root_slash)
     end
 
     # Strips line numbers: "app/models/user.rb:42:in `validate'" → "app/models/user.rb:in `validate'"
     def self.strip_line_number(line)
       line.sub(/:\d+:in /, ':in ')
     end
+
+    # The actual classification logic (uncached).
+    def self._app_frame?(line)
+      return false if line.include?('/gems/')
+      return false if line.include?('/ruby/')
+      return false if line.include?('<internal:')
+      return false if line.include?('/catpm/')
+
+      if (root = cached_rails_root)
+        return line.start_with?(root) if line.start_with?('/')
+      end
+
+      line.start_with?('app/') || line.include?('/app/')
+    end
+    private_class_method :_app_frame?
   end
 end

data/lib/catpm/middleware.rb

@@ -14,19 +14,15 @@ module Catpm
       env['catpm.request_start'] = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
       if Catpm.config.instrument_segments
+        use_sampler = Catpm.config.instrument_stack_sampler || Catpm.config.instrument_call_tree
         req_segments = RequestSegments.new(
           max_segments: Catpm.config.max_segments_per_request,
           request_start: env['catpm.request_start'],
-          stack_sample: Catpm.config.instrument_stack_sampler
+          stack_sample: use_sampler,
+          call_tree: Catpm.config.instrument_call_tree
         )
         env['catpm.segments'] = req_segments
         Thread.current[:catpm_request_segments] = req_segments
-
-        if Catpm.config.instrument_call_tree
-          call_tracer = CallTracer.new(request_segments: req_segments)
-          call_tracer.start
-          env['catpm.call_tracer'] = call_tracer
-        end
       end
 
       @app.call(env)
@@ -35,7 +31,6 @@ module Catpm
       raise
     ensure
       if Catpm.config.instrument_segments
-        env['catpm.call_tracer']&.stop
         req_segments&.stop_sampler
         Thread.current[:catpm_request_segments] = nil
       end

data/lib/catpm/request_segments.rb

@@ -2,9 +2,12 @@
 
 module Catpm
   class RequestSegments
+    # Pre-computed symbol pairs — each type computed once per process lifetime.
+    SUMMARY_KEYS = Hash.new { |h, k| h[k] = [:"#{k}_count", :"#{k}_duration"] }
+
     attr_reader :segments, :summary, :request_start
 
-    def initialize(max_segments:, request_start: nil, stack_sample: false)
+    def initialize(max_segments:, request_start: nil, stack_sample: false, call_tree: false)
       @max_segments = max_segments
       @request_start = request_start || Process.clock_gettime(Process::CLOCK_MONOTONIC)
       @segments = []
@@ -12,17 +15,19 @@ module Catpm
       @summary = Hash.new(0)
       @span_stack = []
       @tracked_ranges = []
+      @call_tree = call_tree
 
       if stack_sample
-        @sampler = StackSampler.new(target_thread: Thread.current, request_start: @request_start)
+        @sampler = StackSampler.new(target_thread: Thread.current, request_start: @request_start, call_tree: call_tree)
         @sampler.start
       end
     end
 
     def add(type:, duration:, detail:, source: nil, started_at: nil)
       type_key = type.to_sym
-      @summary[:"#{type_key}_count"] += 1
-      @summary[:"#{type_key}_duration"] += duration
+      count_key, dur_key = SUMMARY_KEYS[type_key]
+      @summary[count_key] += 1
+      @summary[dur_key] += duration
 
       offset = started_at ? ((started_at - @request_start) * 1000.0).round(2) : nil
 
@@ -79,8 +84,9 @@ module Catpm
       segment[:duration] = duration.round(2)
 
       type_key = segment[:type].to_sym
-      @summary[:"#{type_key}_count"] += 1
-      @summary[:"#{type_key}_duration"] += duration
+      count_key, dur_key = SUMMARY_KEYS[type_key]
+      @summary[count_key] += 1
+      @summary[dur_key] += duration
     end
 
     def stop_sampler
@@ -88,9 +94,15 @@ module Catpm
     end
 
     def sampler_segments
+      return [] if @call_tree # call tree mode produces segments via call_tree_segments
       @sampler&.to_segments(tracked_ranges: @tracked_ranges) || []
     end
 
+    def call_tree_segments
+      return [] unless @sampler && @call_tree
+      @sampler.to_call_tree(tracked_ranges: @tracked_ranges)
+    end
+
     def overflowed?
       @overflow
     end

data/lib/catpm/segment_subscribers.rb

@@ -33,8 +33,9 @@ module Catpm
         return unless req_segments
 
         identifier = payload[:identifier].to_s
-        if defined?(Rails.root) && identifier.start_with?(Rails.root.to_s)
-          identifier = identifier.sub("#{Rails.root}/", '')
+        root_slash = Fingerprint.cached_rails_root_slash
+        if root_slash
+          identifier = identifier.delete_prefix(root_slash)
         end
 
         started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)

data/lib/catpm/stack_sampler.rb

@@ -4,6 +4,7 @@ module Catpm
   class StackSampler
     MS_PER_SECOND = 1000.0
     MIN_SEGMENT_DURATION_MS = 1.0
+    CALL_TREE_SAMPLE_INTERVAL = 0.001 # 1ms — higher resolution for call tree reconstruction
     SAMPLING_THREAD_PRIORITY = -1
 
     # Single global thread that samples all active requests.
@@ -31,7 +32,12 @@ module Catpm
       def start_thread
         @thread = Thread.new do
           loop do
-            sleep(Catpm.config.stack_sample_interval)
+            interval = if Catpm.config.instrument_call_tree
+              [CALL_TREE_SAMPLE_INTERVAL, Catpm.config.stack_sample_interval].min
+            else
+              Catpm.config.stack_sample_interval
+            end
+            sleep(interval)
             sample_all
           end
         end
@@ -51,10 +57,11 @@ module Catpm
       attr_reader :loop
     end
 
-    def initialize(target_thread:, request_start:)
+    def initialize(target_thread:, request_start:, call_tree: false)
       @target = target_thread
       @request_start = request_start
       @samples = []
+      @call_tree = call_tree
     end
 
     def start
@@ -159,8 +166,88 @@ module Catpm
       end
     end
 
+    # Build a call tree from samples — replacement for TracePoint-based CallTracer.
+    # Returns flat array of segments with :_tree_parent (relative index or nil for top-level).
+    def to_call_tree(tracked_ranges: [])
+      return [] if @samples.size < 2
+
+      # Build a tree of app-frame call chains across all samples
+      tree = {} # key → {frame:, children: {}, count:, first_time:, last_time:}
+
+      @samples.each do |time, locs|
+        chain = extract_app_chain(locs)
+        next if chain.empty?
+
+        current_level = tree
+        chain.each do |frame|
+          key = frame_key(frame)
+          unless current_level.key?(key)
+            current_level[key] = {
+              frame: frame, children: {}, count: 0,
+              first_time: time, last_time: time
+            }
+          end
+          node = current_level[key]
+          node[:count] += 1
+          node[:last_time] = time
+          current_level = node[:children]
+        end
+      end
+
+      # Flatten tree into segments with relative parent references
+      segments = []
+      flatten_call_tree(tree, segments, nil)
+      segments
+    end
+
     private
 
+    # Extract all app frames from a backtrace, ordered caller-first (outer → inner).
+    def extract_app_chain(locations)
+      frames = []
+      locations.each do |loc|
+        path = loc.path.to_s
+        next if path.start_with?('<internal:')
+        next if path.include?('/catpm/')
+        next if path.include?('/ruby/') && !path.include?('/gems/')
+
+        frames << loc if Fingerprint.app_frame?(path)
+      end
+      frames.reverse
+    end
+
+    def flatten_call_tree(children_hash, segments, parent_idx)
+      children_hash.each_value do |node|
+        duration = call_tree_node_duration(node)
+        next if duration < MIN_SEGMENT_DURATION_MS
+
+        frame = node[:frame]
+        seg = {
+          type: 'code',
+          detail: build_app_detail(frame),
+          duration: duration.round(2),
+          offset: ((node[:first_time] - @request_start) * MS_PER_SECOND).round(2),
+          source: "#{frame.path}:#{frame.lineno}",
+          _tree_parent: parent_idx
+        }
+
+        idx = segments.size
+        segments << seg
+
+        flatten_call_tree(node[:children], segments, idx)
+      end
+    end
+
+    def call_tree_node_duration(node)
+      interval = Catpm.config.instrument_call_tree ?
+        [CALL_TREE_SAMPLE_INTERVAL, Catpm.config.stack_sample_interval].min :
+        Catpm.config.stack_sample_interval
+      [
+        (node[:last_time] - node[:first_time]) * MS_PER_SECOND,
+        node[:count] * interval * MS_PER_SECOND
+      ].max
+    end
+
     # Walk the stack: find the leaf (deepest interesting frame)
     # and the app_frame (nearest app code above the leaf)
     def extract_frame_pair(locations)

data/lib/catpm/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Catpm
-  VERSION = '0.7.0'
+  VERSION = '0.8.1'
 end

data/lib/catpm.rb

@@ -39,6 +39,7 @@ module Catpm
       @config = Configuration.new
       @buffer = nil
       @flusher = nil
+      Fingerprint.reset_caches!
     end
 
     def enabled?

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: catpm
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.1
 platform: ruby
 authors:
 - ''