catpm 0.9.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f73d14442e21e40a399d3df0635a640cf6067dc10f34e17a74054ab855ac212a
-  data.tar.gz: db34666075f0f5e2c2506a6e7ddad705673f8328ae22edcf1264ae0b94fe999a
+  metadata.gz: 1bb890d1a121d0351a7153a0575608c76c9b003b2d5798931fa4eaaca0067b81
+  data.tar.gz: bb4b7b4978e199de34306e18aafcdcac0ed7cd1fcc7a784d685ebe1ba6e9793e
 SHA512:
-  metadata.gz: 16edf4257962cc5b52ee5207604d6f4643fd93b3219ef15aaf4fbaac14779fa09f49b22aff387a97796d9435b741820f4e9380e2e5276df4939b47af9202f01d
-  data.tar.gz: c5e5b2de2aa7994d827760f77ff7e30fa313d77a51b58573a5129a6a09010815ba30deade3603c15482076b6a4e3cd888123cea7dd78ba026db6fbeab6bc7bc3
+  metadata.gz: 1b377c63b639edf420597d451c2ef2349e73598ca7118bdda9a05c5a455ebad517c821f0cd2a8d8e9a6fde4b1dd71f15482442f9192158b08a6a5564996d3a6c
+  data.tar.gz: ef93cd60ad7840b0a90fd5389ef3ec8f35016fd01eb5d19032fc7e73822c7218d1259a7c326ccfc80109f944ccddddb2eeb9e8e638dae8fe725d7741974704ac

data/README.md

@@ -1,5 +1,5 @@
 gem build catpm.gemspec
-gem push catpm-0.8.4.gem
+gem push catpm-0.9.0.gem
 
 # Catpm
 

data/lib/catpm/collector.rb

@@ -4,6 +4,10 @@ module Catpm
   module Collector
     SYNTHETIC_MIDDLEWARE_OFFSET_MS = 0.5
     MIN_GAP_MS = 1.0
+    # Cap global force-instrument counter to avoid cascade when many requests
+    # are slow. Without this cap, apps with 30% slow requests would see ~23%
+    # instrumentation instead of the configured 1/random_sample_rate.
+    MAX_FORCE_INSTRUMENT_COUNT = 3
 
     class << self
       def process_action_controller(event)
@@ -19,7 +23,11 @@ module Catpm
         metadata = build_http_metadata(payload)
 
         req_segments = Thread.current[:catpm_request_segments]
-        instrumented = !req_segments.nil?
+        # track_request clears req_segments after processing but leaves a marker
+        # so we know the request was already fully instrumented.
+        tracked_instrumented = Thread.current[:catpm_tracked_instrumented]
+        Thread.current[:catpm_tracked_instrumented] = nil
+        instrumented = !req_segments.nil? || tracked_instrumented
 
         if req_segments
           segment_data = req_segments.to_h
@@ -52,9 +60,11 @@ module Catpm
           instrumented: instrumented
         )
 
-        # Slow spike detection: force instrument next request for this endpoint
+        # Slow spike detection: force the NEXT HTTP request through middleware
+        # to be fully instrumented (uses global counter for should_instrument_request?).
+        # Skip if already handled by track_request (tracked_instrumented).
         if !instrumented && (payload[:exception] || duration >= Catpm.config.slow_threshold_for(:http))
-          trigger_force_instrument(kind: :http, target: target, operation: operation)
+          trigger_force_instrument
         end
 
         if sample_type
@@ -470,28 +480,68 @@ module Catpm
 
       # Called when a slow/error request had no instrumentation —
       # forces the NEXT request(s) to be fully instrumented.
+      #
+      # Two modes (mutually exclusive to avoid double-instrumentation):
+      # - With endpoint: sets per-endpoint flag consumed by should_instrument?
+      #   (for track_request paths where endpoint is known)
+      # - Without endpoint: increments global counter consumed by
+      #   should_instrument_request? (for middleware path where endpoint is unknown)
       def trigger_force_instrument(kind: nil, target: nil, operation: nil)
         if kind && target
           endpoint_key = [kind.to_s, target.to_s, (operation || '').to_s]
           force_instrument_endpoints[endpoint_key] = true
+        else
+          @force_instrument_count = [(@force_instrument_count || 0) + 1, MAX_FORCE_INSTRUMENT_COUNT].min
         end
-        @force_instrument_count = (@force_instrument_count || 0) + 1
       end
 
       def reset_sample_counts!
         @instrumented_sample_counts = nil
+        @instrumented_sample_counts_loaded = false
         @force_instrument_endpoints = nil
         @force_instrument_count = nil
       end
 
-    private
+      private
 
       def force_instrument_endpoints
         @force_instrument_endpoints ||= {}
       end
 
       def instrumented_sample_counts
-        @instrumented_sample_counts ||= Hash.new(0)
+        return @instrumented_sample_counts if @instrumented_sample_counts_loaded
+
+        @instrumented_sample_counts = load_sample_counts_from_db
+        @instrumented_sample_counts_loaded = true
+        @instrumented_sample_counts
+      end
+
+      # Pre-populate filling counters from DB so old endpoints don't
+      # re-enter filling phase on every process restart.
+      # Temporarily clears thread-local to prevent our query from being
+      # captured as a segment in any active request.
+      def load_sample_counts_from_db
+        counts = Hash.new(0)
+        return counts unless defined?(Catpm::Sample) && Catpm::Bucket.table_exists?
+
+        saved_rs = Thread.current[:catpm_request_segments]
+        Thread.current[:catpm_request_segments] = nil
+        begin
+          Catpm::Sample.joins(:bucket)
+            .where(sample_type: 'random')
+            .group('catpm_buckets.kind', 'catpm_buckets.target', 'catpm_buckets.operation')
+            .count
+            .each do |(kind, target, operation), count|
+              counts[[kind.to_s, target.to_s, operation.to_s]] = count
+            end
+        ensure
+          Thread.current[:catpm_request_segments] = saved_rs
+        end
+
+        counts
+      rescue => e
+        Catpm.config.error_handler&.call(e)
+        Hash.new(0)
       end
 
       # Remove near-zero-duration "code" spans that merely wrap a "controller" span.
@@ -555,22 +605,34 @@ module Catpm
       # Filling counter only increments for instrumented requests so
       # non-instrumented requests don't waste filling slots.
       def early_sample_type(error:, duration:, kind:, target:, operation:, instrumented: true)
-        return 'error' if error
-        return 'slow' if duration >= Catpm.config.slow_threshold_for(kind.to_sym)
+        # Errors: only create sample for instrumented requests (with segments).
+        # Non-instrumented errors are still tracked in error_groups via
+        # event.error? — occurrence counts, contexts, and backtrace are preserved.
+        # trigger_force_instrument ensures the next occurrence gets full segments.
+        return 'error' if error && instrumented
+
+        is_slow = duration >= Catpm.config.slow_threshold_for(kind.to_sym)
+
+        # Non-instrumented slow requests still get a sample (for dashboard) but
+        # don't count towards filling phase (they have no segments).
+        return 'slow' if is_slow && !instrumented
 
         # Non-instrumented requests have no segments — skip sample creation
         return nil unless instrumented
 
-        # Filling phase: always sample until endpoint has enough instrumented samples
+        # Count this instrumented request towards filling phase completion.
+        # Both slow and random requests count — without this, endpoints where
+        # most requests exceed slow_threshold would never exit the filling phase,
+        # causing 100% instrumentation regardless of random_sample_rate.
         endpoint_key = [kind.to_s, target, operation.to_s]
         count = instrumented_sample_counts[endpoint_key]
         max_random = Catpm.config.max_random_samples_per_endpoint
         if max_random.nil? || count < max_random
           instrumented_sample_counts[endpoint_key] = count + 1
-          return 'random'
         end
 
-        # Instrumented request was already chosen by dice roll at start — always sample
+        return 'slow' if is_slow
+
         'random'
       end
 

data/lib/catpm/middleware.rb

@@ -36,6 +36,7 @@ module Catpm
       req_segments&.release!
       Thread.current[:catpm_request_segments] = nil
       Thread.current[:catpm_request_start] = nil
+      Thread.current[:catpm_tracked_instrumented] = nil
     end
 
     private

data/lib/catpm/trace.rb

@@ -129,6 +129,11 @@ module Catpm
       if owns_segments
         req_segments&.release!
         Thread.current[:catpm_request_segments] = nil
+        # Mark that this request was already instrumented and processed by
+        # track_request. Without this, process_action_controller would see
+        # nil req_segments and falsely trigger force_instrument for slow
+        # requests — even though they were fully instrumented here.
+        Thread.current[:catpm_tracked_instrumented] = true
       end
     end
   end

data/lib/catpm/version.rb

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

metadata

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