catpm 0.6.6 → 0.8.0

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/flusher.rb

@@ -16,6 +16,16 @@ module Catpm
       @thread = nil
       @pid = nil
       @mutex = Mutex.new
+      @sleep_mutex = Mutex.new
+      @flush_signal = ConditionVariable.new
+
+      # When buffer reaches capacity, wake flusher immediately
+      @buffer.on_flush_needed { signal_flush }
+    end
+
+    # Wake the flusher thread for an immediate flush cycle.
+    def signal_flush
+      @sleep_mutex.synchronize { @flush_signal.signal }
     end
 
     def start
@@ -32,7 +42,9 @@ module Catpm
         @pid = Process.pid
         @thread = Thread.new do
           while @running
-            sleep(effective_interval)
+            @sleep_mutex.synchronize do
+              @flush_signal.wait(@sleep_mutex, effective_interval)
+            end
             flush_cycle if @running
           end
         rescue => e
@@ -61,6 +73,7 @@ module Catpm
         @thread = nil
       end
 
+      signal_flush # Wake flusher thread for clean exit
       thread&.join(timeout)
       flush_cycle # Final flush
     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
 
@@ -65,7 +70,12 @@ module Catpm
     def pop_span(index)
       return unless index
 
-      @span_stack.delete(index)
+      # Pop from stack — typically it's the last element (LIFO)
+      if @span_stack.last == index
+        @span_stack.pop
+      else
+        @span_stack.delete(index)
+      end
       segment = @segments[index]
       return unless segment
 
@@ -74,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
@@ -83,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.6.6'
+  VERSION = '0.8.0'
 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.6.6
+  version: 0.8.0
 platform: ruby
 authors:
 - ''
@@ -68,7 +68,9 @@ files:
 - app/views/catpm/shared/_segments_waterfall.html.erb
 - app/views/catpm/status/index.html.erb
 - app/views/catpm/system/index.html.erb
+- app/views/catpm/system/pipeline.html.erb
 - app/views/layouts/catpm/application.html.erb
+- app/views/layouts/catpm/pipeline.html.erb
 - config/routes.rb
 - db/migrate/20250601000001_create_catpm_tables.rb
 - lib/catpm.rb