catpm 0.9.6 → 0.9.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3731353688fdebaef1f9cb164731daba00a0d69df65da03dc309f6f7901e2708
-  data.tar.gz: 4ef7e26d0b721c8fea556f797d74c58ef2b0df8f9257edead653393fcb991229
+  metadata.gz: 54937b58ef7d18fa437e232b7a660ac014737a6e716daed6e57ab7463dc38e27
+  data.tar.gz: 76cfd9389ecb1f37794806353c2c56f1d7f799a9bf6f9e8c0c975c93b8423c53
 SHA512:
-  metadata.gz: df633940cf6beba3252b6915c45d22688ff23ef3200edf17622e971ce65191ad85af476bfdd853a2bee449da6d28df81431c48e663001c80b14242ba407d3a7b
-  data.tar.gz: 473011238fdf84d011bf9d3c0ceed1d47b7f1a3be5e6e9d640f6f66b62273c2a396c425166b09ceb5b0b8bf63a993e51651d99d373c48b1058ead4ede2451266
+  metadata.gz: a948c19294ca90dc60215f58e3d8f6fbdd377f4b62f468eba76678b223af37610d549d4a52ea7f42d7c6fec4ab93952bceeb6e19857ec9c67ecf601a4a1a9b51
+  data.tar.gz: 298c9964d29d3fc9b2570720a7813b30adc5f21c9b7f75e49c288c9fc4f4cd65c4196c798dc05caeb7824ebefb2553cd82b6778a3f1e1a8eeaac4f3d893a703b

data/README.md

@@ -1,5 +1,5 @@
 gem build catpm.gemspec
-gem push catpm-0.9.5.gem
+gem push catpm-0.9.6.gem
 
 # Catpm
 

data/lib/catpm/collector.rb

@@ -6,12 +6,6 @@ module Catpm
     MIN_GAP_MS = 1.0
     DEFAULT_ERROR_STATUS = 500
     DEFAULT_SUCCESS_STATUS = 200
-    # 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
-    FORCE_INSTRUMENT_MAX_ENDPOINTS = 100 # cap per-endpoint force-instrument hash
-
     class << self
       def process_action_controller(event)
         return unless Catpm.enabled?
@@ -63,25 +57,6 @@ module Catpm
           instrumented: instrumented
         )
 
-        # Force the NEXT HTTP request to be fully instrumented when this one
-        # wasn't instrumented and was slow/error.
-        # Filling phase is handled by @http_filling_active flag in
-        # should_instrument_request? — no need for force_instrument here.
-        if !instrumented
-          if payload[:exception] || duration >= Catpm.config.slow_threshold_for(:http)
-            trigger_force_instrument
-          elsif !@http_filling_active
-            # Detect new/underfilled endpoints that appeared after filling phase ended
-            max = Catpm.config.max_random_samples_per_endpoint
-            if max
-              endpoint_key = ['http', target, operation]
-              if instrumented_sample_counts[endpoint_key] < max
-                @http_filling_active = true
-              end
-            end
-          end
-        end
-
         if sample_type
           context = build_http_context(payload)
 
@@ -286,11 +261,6 @@ module Catpm
           instrumented: instrumented
         )
 
-        # Slow spike detection: force instrument next request for this endpoint
-        if !instrumented && (error || duration >= Catpm.config.slow_threshold_for(kind.to_sym))
-          trigger_force_instrument(kind: kind, target: target, operation: operation)
-        end
-
         if sample_type
           context = (context || {}).dup
 
@@ -417,152 +387,18 @@ module Catpm
 
       # --- Pre-sampling: decide BEFORE request whether to instrument ---
 
-      # Eagerly load sample counts at startup so old endpoints don't
-      # re-enter filling phase on every process restart.
-      # Called from Lifecycle.register_hooks after flusher init.
-      def load_sample_counts_eagerly!
-        @instrumented_sample_counts = load_sample_counts_from_db
-        @instrumented_sample_counts_loaded = true
-        recompute_http_filling_active
-      end
-
       # For HTTP middleware where endpoint is unknown at start.
-      # Returns true if this request should get full instrumentation.
       def should_instrument_request?
-        # Force after slow spike detection
-        if (@force_instrument_count || 0) > 0
-          @force_instrument_count -= 1
-          return true
-        end
-
-        # During filling phase, instrument all requests so underfilled
-        # endpoints collect their quota (max_random_samples_per_endpoint).
-        # The flag is set by load_sample_counts_eagerly! and maintained
-        # by early_sample_type as endpoints fill up.
-        return true if @http_filling_active
-
         rand(Catpm.config.random_sample_rate) == 0
       end
 
       # For track_request where endpoint is known at start.
-      # Filling phase ensures new endpoints get instrumented samples quickly.
-      def should_instrument?(kind, target, operation)
-        endpoint_key = [kind.to_s, target.to_s, (operation || '').to_s]
-
-        # Force after slow spike
-        if force_instrument_endpoints.delete(endpoint_key)
-          return true
-        end
-
-        # Filling phase — endpoint hasn't collected enough instrumented samples yet
-        max = Catpm.config.max_random_samples_per_endpoint
-        if max.nil? || instrumented_sample_counts[endpoint_key] < max
-          return true
-        end
-
+      def should_instrument?(_kind, _target, _operation)
         rand(Catpm.config.random_sample_rate) == 0
       end
 
-      # 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]
-          if force_instrument_endpoints.size < FORCE_INSTRUMENT_MAX_ENDPOINTS
-            force_instrument_endpoints[endpoint_key] = true
-          end
-        else
-          @force_instrument_count = [(@force_instrument_count || 0) + 1, MAX_FORCE_INSTRUMENT_COUNT].min
-        end
-      end
-
-      def reset_sample_counts!
-        @instrumented_sample_counts = nil
-        @instrumented_sample_counts_loaded = false
-        @force_instrument_endpoints = nil
-        @force_instrument_count = nil
-        @http_filling_active = false
-      end
-
       private
 
-      # Recompute whether any HTTP endpoint is still below its sample quota.
-      # Called after loading counts from DB and when an endpoint exits filling.
-      def recompute_http_filling_active
-        max = Catpm.config.max_random_samples_per_endpoint
-        @http_filling_active = if max
-          # True if hash is empty (new app / new endpoints may appear) or any endpoint below quota
-          instrumented_sample_counts.empty? || instrumented_sample_counts.any? { |_, c| c < max }
-        else
-          false # unlimited quota → no filling phase for HTTP middleware
-        end
-      end
-
-      # Evict half the entries from instrumented_sample_counts.
-      # Prefers evicting filled entries (count >= max) to avoid
-      # re-triggering filling phase for those endpoints.
-      def evict_sample_counts(max_random)
-        evict_count = instrumented_sample_counts.size / 2
-        if max_random
-          filled_keys = []
-          unfilled_keys = []
-          instrumented_sample_counts.each do |k, c|
-            (c >= max_random ? filled_keys : unfilled_keys) << k
-          end
-          # Evict filled first (safe), then unfilled if needed
-          to_evict = (filled_keys + unfilled_keys).first(evict_count)
-          to_evict.each { |k| instrumented_sample_counts.delete(k) }
-        else
-          evict_count.times { instrumented_sample_counts.shift }
-        end
-      end
-
-      def force_instrument_endpoints
-        @force_instrument_endpoints ||= {}
-      end
-
-      def instrumented_sample_counts
-        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.
       # This happens when CallTracer (TracePoint) captures a thin dispatch method
       # (e.g. Telegram::WebhookController#process) whose :return fires before the
@@ -618,49 +454,11 @@ module Catpm
 
       # Determine sample type at event creation time so only sampled events
       # carry full context in the buffer.
-      #
-      # Non-instrumented requests never get a sample (they have no segments).
-      # Filling phase is handled by the caller via trigger_force_instrument,
-      # so the NEXT request gets full instrumentation with segments.
-      #
-      # Post-filling: non-instrumented requests just contribute duration/count
-      # to the bucket, no sample created.
+      # Non-instrumented requests have no segments — skip sample creation.
       def early_sample_type(error:, duration:, kind:, target:, operation:, instrumented: true)
-        # 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 requests have no segments — skip sample creation.
-        # Slow/error spikes are handled by the caller via trigger_force_instrument
-        # so the NEXT request gets full instrumentation with useful segments.
         return nil unless instrumented
-
-        # 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
-          # Evict when hash exceeds derived limit — prefer filled entries
-          max_entries = Catpm.config.effective_sample_counts_max
-          if instrumented_sample_counts.size >= max_entries
-            evict_sample_counts(max_random)
-          end
-          instrumented_sample_counts[endpoint_key] = count + 1
-
-          # Endpoint just reached quota — recheck if any filling endpoints remain
-          if max_random && count + 1 >= max_random
-            recompute_http_filling_active
-          end
-        end
-
-        return 'slow' if is_slow
+        return 'slow' if duration >= Catpm.config.slow_threshold_for(kind.to_sym)
 
         'random'
       end

data/lib/catpm/configuration.rb

@@ -9,8 +9,6 @@ module Catpm
     BUFFER_MEMORY_SHARE = 0.5       # 50% of max_memory for event buffer
     CACHE_ENTRIES_PER_MB = 10_000   # ~100 bytes/entry in path_cache
     PATH_CACHE_BUDGET_SHARE = 0.05  # 5% of max_memory for path_cache
-    SAMPLE_COUNTS_PER_MB = 12_500   # ~80 bytes/entry in sample counts hash
-    SAMPLE_COUNTS_BUDGET_SHARE = 0.02 # 2% of max_memory for sample counts
 
     # Boolean / non-numeric settings — plain attr_accessor
     attr_accessor :enabled,
@@ -137,11 +135,6 @@ module Catpm
       (max_memory * CACHE_ENTRIES_PER_MB * PATH_CACHE_BUDGET_SHARE).to_i
     end
 
-    # Sample counts hash limit derived from max_memory
-    def effective_sample_counts_max
-      (max_memory * SAMPLE_COUNTS_PER_MB * SAMPLE_COUNTS_BUDGET_SHARE).to_i
-    end
-
     def slow_threshold_for(kind)
       slow_threshold_per_kind.fetch(kind.to_sym, slow_threshold)
     end

data/lib/catpm/flusher.rb

@@ -346,7 +346,6 @@ module Catpm
       @last_cleanup_at = Time.now
       downsample_buckets
       cleanup_expired_data if Catpm.config.retention_period
-      Collector.reset_sample_counts!
     end
 
     def downsample_buckets

data/lib/catpm/lifecycle.rb

@@ -8,7 +8,6 @@ module Catpm
 
         initialize_buffer
         initialize_flusher
-        load_sample_counts
         apply_patches
 
         # Start the flusher in the current process.
@@ -25,12 +24,6 @@ module Catpm
 
       private
 
-      def load_sample_counts
-        Collector.load_sample_counts_eagerly!
-      rescue => e
-        Catpm.config.error_handler&.call(e)
-      end
-
       def apply_patches
         if Catpm.config.instrument_net_http
           if defined?(::Net::HTTP)

data/lib/catpm/trace.rb

@@ -125,8 +125,7 @@ module Catpm
         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.
+        # nil req_segments and think the request was not instrumented.
         Thread.current[:catpm_tracked_instrumented] = true
       end
     end

data/lib/catpm/version.rb

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

data/lib/catpm.rb

@@ -39,7 +39,6 @@ module Catpm
       @buffer = nil
       @flusher = nil
       Fingerprint.reset_caches!
-      Collector.reset_sample_counts!
     end
 
     def enabled?

metadata

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