catpm 0.9.0 → 0.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f73d14442e21e40a399d3df0635a640cf6067dc10f34e17a74054ab855ac212a
-  data.tar.gz: db34666075f0f5e2c2506a6e7ddad705673f8328ae22edcf1264ae0b94fe999a
+  metadata.gz: 7550489165d4ba6b3c476bd1f2637fc6e68eed8e3def5bd32420dfc0632ff2d7
+  data.tar.gz: ec9ed224bcd90cd67835842385305146736ce634310b9b62eaf33997bf7e2ff8
 SHA512:
-  metadata.gz: 16edf4257962cc5b52ee5207604d6f4643fd93b3219ef15aaf4fbaac14779fa09f49b22aff387a97796d9435b741820f4e9380e2e5276df4939b47af9202f01d
-  data.tar.gz: c5e5b2de2aa7994d827760f77ff7e30fa313d77a51b58573a5129a6a09010815ba30deade3603c15482076b6a4e3cd888123cea7dd78ba026db6fbeab6bc7bc3
+  metadata.gz: ad84a45f6d0b8b508c94a5a9d0d06b9671a7820fedd93eda19eeee070b41669e625a814a6a2fab6e69fa80ae83edbaa81edd9a8f20e915d921973ba8a6e70822
+  data.tar.gz: 75cd050d65178c666e0369eecbc13c1fe1cb18f8d159f75c2078ecea7422e1844e4836c87320681d6b6d68718c9624f0b8abd67276888d28b09410265b43f8ad

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

@@ -9,6 +9,12 @@ module Catpm
 
     req_segments = Thread.current[:catpm_request_segments]
     unless req_segments
+      # Inside a non-instrumented HTTP request — just run the block
+      # without promoting the span to a standalone endpoint
+      if Thread.current[:catpm_request_start]
+        return block.call if block
+        return nil
+      end
       return trace(name, &block)
     end
 
@@ -46,7 +52,7 @@ module Catpm
           type: :custom, duration: duration_ms, detail: name,
           source: source, started_at: start_time
         )
-      elsif buffer
+      elsif buffer && !Thread.current[:catpm_request_start]
         Collector.process_custom(
           name: name, duration: duration_ms,
           metadata: metadata, error: error, context: context
@@ -129,6 +135,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
@@ -155,7 +166,7 @@ module Catpm
           type: :custom, duration: duration_ms, detail: @name,
           source: source, started_at: @start_time
         )
-      elsif Catpm.enabled? && Catpm.buffer
+      elsif Catpm.enabled? && Catpm.buffer && !Thread.current[:catpm_request_start]
         Collector.process_custom(
           name: @name, duration: duration_ms,
           metadata: @metadata, error: error, context: @context

data/lib/catpm/version.rb

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

metadata

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