catpm 0.1.4 → 0.3.0

data/lib/catpm/flusher.rb

@@ -123,14 +123,6 @@ module Catpm
       samples = []
       error_groups = {}
 
-      # Pre-load existing random sample counts per endpoint for filling phase
-      @random_sample_counts = {}
-      Catpm::Sample.where(sample_type: 'random')
-        .joins(:bucket)
-        .group('catpm_buckets.kind', 'catpm_buckets.target', 'catpm_buckets.operation')
-        .count
-        .each { |(kind, target, op), cnt| @random_sample_counts[[ kind, target, op ]] = cnt }
-
       events.each do |event|
         # Bucket aggregation
         key = [ event.kind, event.target, event.operation, event.bucket_start ]
@@ -155,40 +147,48 @@ module Catpm
         # TDigest
         bucket[:tdigest].add(event.duration)
 
-        # Collect samples
-        sample_type = determine_sample_type(event)
+        # Compute error fingerprint (used for both samples and error grouping)
+        error_fp = nil
+        if event.error?
+          error_fp = Catpm::Fingerprint.generate(
+            kind: event.kind,
+            error_class: event.error_class,
+            backtrace: event.backtrace
+          )
+        end
+
+        # Collect samples (pre-determined by collector — only these events carry full context)
+        sample_type = event.sample_type
         if sample_type
-          samples << {
+          sample_hash = {
             bucket_key: key,
             kind: event.kind,
             sample_type: sample_type,
             recorded_at: event.started_at,
             duration: event.duration,
-            context: event.context
+            context: event.context || {}
           }
+          sample_hash[:error_fingerprint] = error_fp if error_fp
+          samples << sample_hash
         end
 
         # Error grouping
-        if event.error?
-          fp = Catpm::Fingerprint.generate(
-            kind: event.kind,
-            error_class: event.error_class,
-            backtrace: event.backtrace
-          )
-
-          error = error_groups[fp] ||= {
-            fingerprint: fp,
+        if error_fp
+          error = error_groups[error_fp] ||= {
+            fingerprint: error_fp,
             kind: event.kind,
             error_class: event.error_class,
             message: event.error_message,
             occurrences_count: 0,
             first_occurred_at: event.started_at,
             last_occurred_at: event.started_at,
-            new_contexts: []
+            new_contexts: [],
+            occurrence_times: []
           }
 
           error[:occurrences_count] += 1
           error[:last_occurred_at] = [ error[:last_occurred_at], event.started_at ].max
+          error[:occurrence_times] << event.started_at
 
           if error[:new_contexts].size < Catpm.config.max_error_contexts
             error[:new_contexts] << build_error_context(event)
@@ -223,24 +223,6 @@ module Catpm
       }
     end
 
-    def determine_sample_type(event)
-      return 'error' if event.error?
-
-      threshold = Catpm.config.slow_threshold_for(event.kind.to_sym)
-      return 'slow' if event.duration >= threshold
-
-      # Always sample if endpoint has few random samples (filling phase)
-      endpoint_key = [ event.kind, event.target, event.operation ]
-      existing_random = @random_sample_counts[endpoint_key] || 0
-      if existing_random < Catpm.config.max_random_samples_per_endpoint
-        @random_sample_counts[endpoint_key] = existing_random + 1
-        return 'random'
-      end
-
-      return 'random' if rand(Catpm.config.random_sample_rate) == 0
-
-      nil
-    end
 
     def rotate_samples(samples)
       samples.each do |sample|
@@ -265,6 +247,14 @@ module Catpm
               sample[:_skip] = true
             end
           end
+        when 'error'
+          fp = sample[:error_fingerprint]
+          if fp
+            existing = Catpm::Sample.where(sample_type: 'error', error_fingerprint: fp)
+            if existing.count >= Catpm.config.max_error_samples_per_fingerprint
+              existing.order(recorded_at: :asc).first.destroy
+            end
+          end
         end
       end
 
@@ -272,24 +262,29 @@ module Catpm
     end
 
     def build_error_context(event)
+      event_context = event.context || {}
       ctx = {
         occurred_at: event.started_at.iso8601,
         kind: event.kind,
-        operation: event.context.slice(:method, :path, :params, :job_class, :job_id, :queue, :target, :metadata),
-        backtrace: (event.backtrace || []).first(Catpm.config.backtrace_lines),
+        operation: event_context.slice(:method, :path, :params, :job_class, :job_id, :queue, :target, :metadata),
+        backtrace: begin
+          bt = event.backtrace || []
+          limit = Catpm.config.backtrace_lines
+          limit ? bt.first(limit) : bt
+        end,
         duration: event.duration,
         status: event.status
       }
 
       ctx[:target] = event.target if event.target.present?
 
-      if event.context[:segments]
-        ctx[:segments] = event.context[:segments]
-        ctx[:segments_capped] = event.context[:segments_capped]
+      if event_context[:segments]
+        ctx[:segments] = event_context[:segments]
+        ctx[:segments_capped] = event_context[:segments_capped]
       end
 
-      if event.context[:segment_summary]
-        ctx[:segment_summary] = event.context[:segment_summary]
+      if event_context[:segment_summary]
+        ctx[:segment_summary] = event_context[:segment_summary]
       end
 
       ctx
@@ -415,14 +410,26 @@ module Catpm
         }
 
         source_ids = buckets.map(&:id)
+        survivor = buckets.first
 
-        # Delete source buckets first (to avoid unique constraint conflict
-        # if one source bucket has the same bucket_start as the target)
-        Catpm::Sample.where(bucket_id: source_ids).delete_all
-        Catpm::Bucket.where(id: source_ids).delete_all
+        # Reassign all samples to the survivor bucket
+        Catpm::Sample.where(bucket_id: source_ids).update_all(bucket_id: survivor.id)
 
-        # Create the merged bucket
-        adapter.persist_buckets([merged])
+        # Delete non-survivor source buckets (now sample-free)
+        Catpm::Bucket.where(id: source_ids - [survivor.id]).delete_all
+
+        # Overwrite survivor with merged data
+        survivor.update!(
+          bucket_start: aligned_start,
+          count: merged[:count],
+          success_count: merged[:success_count],
+          failure_count: merged[:failure_count],
+          duration_sum: merged[:duration_sum],
+          duration_max: merged[:duration_max],
+          duration_min: merged[:duration_min],
+          metadata_sum: merged[:metadata_sum],
+          p95_digest: merged[:p95_digest]
+        )
       end
     end
 

data/lib/catpm/stack_sampler.rb

@@ -4,28 +4,69 @@ module Catpm
   class StackSampler
     SAMPLE_INTERVAL = 0.005 # 5ms
 
+    # Single global thread that samples all active requests.
+    # Avoids creating a thread per request.
+    class SamplingLoop
+      def initialize
+        @mutex = Mutex.new
+        @samplers = []
+        @thread = nil
+      end
+
+      def register(sampler)
+        @mutex.synchronize do
+          @samplers << sampler
+          start_thread unless @thread&.alive?
+        end
+      end
+
+      def unregister(sampler)
+        @mutex.synchronize { @samplers.delete(sampler) }
+      end
+
+      private
+
+      def start_thread
+        @thread = Thread.new do
+          loop do
+            sleep(SAMPLE_INTERVAL)
+            sample_all
+          end
+        end
+        @thread.priority = -1
+      end
+
+      def sample_all
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        targets = @mutex.synchronize { @samplers.dup }
+        targets.each { |s| s.capture(now) }
+      end
+    end
+
+    @loop = SamplingLoop.new
+
+    class << self
+      attr_reader :loop
+    end
+
     def initialize(target_thread:, request_start:)
       @target = target_thread
       @request_start = request_start
       @samples = []
-      @running = false
     end
 
     def start
-      @running = true
-      @thread = Thread.new do
-        while @running
-          locs = @target.backtrace_locations
-          @samples << [Process.clock_gettime(Process::CLOCK_MONOTONIC), locs] if locs
-          sleep(SAMPLE_INTERVAL)
-        end
-      end
-      @thread.priority = -1
+      self.class.loop.register(self)
     end
 
     def stop
-      @running = false
-      @thread&.join(0.1)
+      self.class.loop.unregister(self)
+    end
+
+    # Called by SamplingLoop from the global thread
+    def capture(now)
+      locs = @target.backtrace_locations
+      @samples << [now, locs] if locs
     end
 
     # Returns array of { parent: {segment}, children: [{segment}, ...] }

data/lib/catpm/version.rb

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

data/lib/generators/catpm/templates/initializer.rb.tt

@@ -20,6 +20,7 @@ Catpm.configure do |config|
   config.instrument_http = true              # Track HTTP requests (default: true)
   config.instrument_jobs = false             # Track ActiveJob (default: false)
   config.instrument_segments = true          # Track SQL/view/cache segments (default: true)
+  # config.track_own_requests = false           # Track catpm dashboard requests (default: false)
   # config.instrument_net_http = false         # Patch Net::HTTP for outbound tracking (default: false)
   # config.instrument_middleware_stack = false # Decompose middleware into per-middleware segments (default: false)
   # config.max_segments_per_request = 50       # Cap segments per request (keeps slowest)

data/lib/tasks/catpm_tasks.rake

@@ -1,6 +1,23 @@
 # frozen_string_literal: true
 
-# desc "Explaining what the task does"
-# task :catpm do
-#   # Task goes here
-# end
+namespace :catpm do
+  desc 'Add missing columns to catpm tables (safe to run multiple times)'
+  task upgrade: :environment do
+    connection = ActiveRecord::Base.connection
+
+    unless connection.column_exists?(:catpm_samples, :error_fingerprint)
+      connection.add_column :catpm_samples, :error_fingerprint, :string, limit: 64
+      connection.add_index :catpm_samples, :error_fingerprint, name: 'idx_catpm_samples_error_fp'
+      puts '[catpm] Added error_fingerprint column to catpm_samples'
+    else
+      puts '[catpm] catpm_samples.error_fingerprint already exists, skipping'
+    end
+
+    unless connection.column_exists?(:catpm_errors, :occurrence_buckets)
+      connection.add_column :catpm_errors, :occurrence_buckets, :json
+      puts '[catpm] Added occurrence_buckets column to catpm_errors'
+    else
+      puts '[catpm] catpm_errors.occurrence_buckets already exists, skipping'
+    end
+  end
+end

metadata

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