catpm 0.6.5 → 0.7.0

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
@@ -83,8 +96,8 @@ module Catpm
             adapter.persist_buckets(buckets)
 
             bucket_map = build_bucket_map(buckets)
-            samples = rotate_samples(samples)
             adapter.persist_samples(samples, bucket_map)
+            trim_samples(samples)
             adapter.persist_errors(errors)
           end
 
@@ -227,75 +240,43 @@ module Catpm
     end
 
 
-    def rotate_samples(samples)
-      return samples if samples.empty?
+    # Trim excess samples AFTER insert. Simpler and guaranteed correct —
+    # no stale-cache issues when a single flush batch crosses the limit.
+    def trim_samples(samples)
+      return if samples.empty?
 
-      # Pre-fetch counts for all endpoints and types in bulk
       endpoint_keys = samples.map { |s| s[:bucket_key][0..2] }.uniq
-      error_fps = samples.filter_map { |s| s[:error_fingerprint] }.uniq
-
-      # Build counts cache: { [kind, target, op, type] => count }
-      counts_cache = {}
-      if endpoint_keys.any?
-        Catpm::Sample.joins(:bucket)
-          .where(catpm_buckets: { kind: endpoint_keys.map(&:first), target: endpoint_keys.map { |k| k[1] }, operation: endpoint_keys.map { |k| k[2] } })
-          .where(sample_type: %w[random slow])
-          .group('catpm_buckets.kind', 'catpm_buckets.target', 'catpm_buckets.operation', 'catpm_samples.sample_type')
-          .count
-          .each { |(kind, target, op, type), cnt| counts_cache[[kind, target, op, type]] = cnt }
-      end
 
-      error_counts = {}
-      if error_fps.any?
-        Catpm::Sample.where(sample_type: 'error', error_fingerprint: error_fps)
-          .group(:error_fingerprint).count
-          .each { |fp, cnt| error_counts[fp] = cnt }
+      endpoint_keys.each do |kind, target, operation|
+        endpoint_scope = Catpm::Sample.joins(:bucket)
+          .where(catpm_buckets: { kind: kind, target: target, operation: operation })
+
+        # Random: keep newest N
+        max_random = Catpm.config.max_random_samples_per_endpoint
+        trim_by_column(endpoint_scope.where(sample_type: 'random'), max_random, :recorded_at) if max_random
+
+        # Slow: keep highest-duration N
+        max_slow = Catpm.config.max_slow_samples_per_endpoint
+        trim_by_column(endpoint_scope.where(sample_type: 'slow'), max_slow, :duration) if max_slow
+
       end
 
-      samples.each do |sample|
-        kind, target, operation = sample[:bucket_key][0..2]
-
-        case sample[:sample_type]
-        when 'random'
-          max_random = Catpm.config.max_random_samples_per_endpoint
-          if max_random
-            cache_key = [kind, target, operation, 'random']
-            if (counts_cache[cache_key] || 0) >= max_random
-              oldest = Catpm::Sample.joins(:bucket)
-                .where(catpm_buckets: { kind: kind, target: target, operation: operation })
-                .where(sample_type: 'random').order(recorded_at: :asc).first
-              oldest&.destroy
-            end
-          end
-        when 'slow'
-          max_slow = Catpm.config.max_slow_samples_per_endpoint
-          if max_slow
-            cache_key = [kind, target, operation, 'slow']
-            if (counts_cache[cache_key] || 0) >= max_slow
-              weakest = Catpm::Sample.joins(:bucket)
-                .where(catpm_buckets: { kind: kind, target: target, operation: operation })
-                .where(sample_type: 'slow').order(duration: :asc).first
-              if weakest && sample[:duration] > weakest.duration
-                weakest.destroy
-              else
-                sample[:_skip] = true
-              end
-            end
-          end
-        when 'error'
-          max_err = Catpm.config.max_error_samples_per_fingerprint
-          if max_err
-            fp = sample[:error_fingerprint]
-            if fp && (error_counts[fp] || 0) >= max_err
-              oldest = Catpm::Sample.where(sample_type: 'error', error_fingerprint: fp)
-                .order(recorded_at: :asc).first
-              oldest&.destroy
-            end
-          end
+      # Errors: per-fingerprint cap (keep newest within each fingerprint)
+      max_err_fp = Catpm.config.max_error_samples_per_fingerprint
+      if max_err_fp
+        fps = samples.filter_map { |s| s[:error_fingerprint] }.uniq
+        fps.each do |fp|
+          trim_by_column(Catpm::Sample.where(sample_type: 'error', error_fingerprint: fp), max_err_fp, :recorded_at)
         end
       end
+    end
+
+    def trim_by_column(scope, max, keep_column)
+      count = scope.count
+      return if count <= max
 
-      samples.reject { |s| s.delete(:_skip) }
+      excess_ids = scope.order(keep_column => :asc).limit(count - max).pluck(:id)
+      Catpm::Sample.where(id: excess_ids).delete_all if excess_ids.any?
     end
 
     def build_error_context(event)

data/lib/catpm/request_segments.rb

@@ -65,7 +65,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
 

data/lib/catpm/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: catpm
 version: !ruby/object:Gem::Version
-  version: 0.6.5
+  version: 0.7.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