catpm 0.9.4 → 0.9.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b71e3f131bb8edb7a07b1f0996aa4ad2be18a365bf2724c2b67d160c7716ae8c
-  data.tar.gz: f0961bf02dd509df819634f29fb5717345bc3d3efeabfaa8192476cd2c94917e
+  metadata.gz: 3731353688fdebaef1f9cb164731daba00a0d69df65da03dc309f6f7901e2708
+  data.tar.gz: 4ef7e26d0b721c8fea556f797d74c58ef2b0df8f9257edead653393fcb991229
 SHA512:
-  metadata.gz: 4e44d829fcb7ec331225d7539c00d76fafadceeb3192a7645c5f3149c2f060f1fb996c30f306c39166ca060074c78328372ff5a79e57696b03ce72abc0633fb8
-  data.tar.gz: de507352426ba225ec5c8dfb2cf4805ea8ca29ae095944276948cb9441993c84bfed5f7f7a4c9c6dd313fe7c82ec22df94e98b7af727b2ee362f15f9921eccb4
+  metadata.gz: df633940cf6beba3252b6915c45d22688ff23ef3200edf17622e971ce65191ad85af476bfdd853a2bee449da6d28df81431c48e663001c80b14242ba407d3a7b
+  data.tar.gz: 473011238fdf84d011bf9d3c0ceed1d47b7f1a3be5e6e9d640f6f66b62273c2a396c425166b09ceb5b0b8bf63a993e51651d99d373c48b1058ead4ede2451266

data/README.md

@@ -1,5 +1,5 @@
 gem build catpm.gemspec
-gem push catpm-0.9.3.gem
+gem push catpm-0.9.5.gem
 
 # Catpm
 
@@ -16,7 +16,6 @@ Catpm is designed for small-to-medium Rails applications where a full APM (Datad
 - **Error tracking** — fingerprinting, occurrence counting, context circular buffers
 - **Built-in dashboard** — filterable by kind, endpoint drill-down, waterfall visualization
 - **Custom events** — track business events (signups, payments, etc.) with `Catpm.event`
-- **Auto-instrumentation** — service objects (`ApplicationService`, `BaseService`) traced automatically
 - **Multi-database** — PostgreSQL (primary), SQLite (first-class)
 - **Zero dependencies** — only Rails >= 7.1, no Redis or background queues required
 - **Memory-safe** — configurable buffer limits, automatic downsampling with infinite retention
@@ -112,24 +111,6 @@ class PaymentService
 end
 ```
 
-### Auto-instrumentation
-
-Service objects following the `ApplicationService.call` pattern are instrumented automatically — no configuration needed. If your base class has a different name:
-
-```ruby
-Catpm.configure do |config|
-  config.service_base_classes = ['MyServiceBase']
-end
-```
-
-You can also instrument specific methods explicitly:
-
-```ruby
-Catpm.configure do |config|
-  config.auto_instrument_methods = ['Worker#process', 'Gateway.charge']
-end
-```
-
 ### Custom events
 
 Track business-level events that aren't tied to performance:
@@ -182,7 +163,7 @@ Catpm.configure do |config|
   ]
 
   # Tuning
-  config.max_buffer_memory = 32.megabytes # In-memory buffer limit
+  config.max_memory_per_thread = 2.megabytes # Memory budget per thread (buffer + request segments)
   config.flush_interval = 30              # Seconds between DB flushes
 end
 ```

data/app/controllers/catpm/system_controller.rb

@@ -6,6 +6,7 @@ module Catpm
       @stats = Catpm.stats
       @buffer_size = Catpm.buffer&.size || 0
       @buffer_bytes = Catpm.buffer&.current_bytes || 0
+      @buffer_max_bytes = Catpm.buffer&.max_bytes || 0
       @config = Catpm.config
       @oldest_bucket = Catpm::Bucket.minimum(:bucket_start)
       @active_error_count = Catpm::ErrorRecord.unresolved.count
@@ -13,7 +14,7 @@ module Catpm
     end
 
     def pipeline
-      render layout: "catpm/pipeline"
+      render layout: 'catpm/pipeline'
     end
   end
 end

data/app/helpers/catpm/application_helper.rb

@@ -68,7 +68,7 @@ module Catpm
       slow_threshold:                   { group: 'Segments', label: 'Slow Threshold', desc: 'Requests slower than this are flagged as slow', fmt: :ms },
       slow_threshold_per_kind:          { group: 'Segments', label: 'Slow Threshold (per kind)', desc: 'Override slow threshold for specific request kinds (http, job, custom)', fmt: :hash_ms },
       max_segments_per_request:         { group: 'Segments', label: 'Max Segments / Request', desc: 'Cap on segments captured per request', fmt: :nullable_int },
-      segment_source_threshold:         { group: 'Segments', label: 'Source Capture Threshold', desc: 'Minimum segment duration (ms) before caller_locations is captured; 0 = always', fmt: :ms_zero },
+      min_segment_duration:              { group: 'Segments', label: 'Min Segment Duration', desc: 'Segments shorter than this are counted in summary but not stored; 0 = store all', fmt: :ms_zero },
       max_sql_length:                   { group: 'Segments', label: 'Max SQL Length', desc: 'Truncate SQL queries beyond this many characters', fmt: :nullable_chars },
       ignored_targets:                  { group: 'Segments', label: 'Ignored Targets', desc: 'Endpoint patterns excluded from tracking (strings or regexps)', fmt: :list },
 
@@ -94,7 +94,7 @@ module Catpm
       events_max_samples_per_name:      { group: 'Events', label: 'Max Samples / Name', desc: 'Event samples retained per event name', fmt: :nullable_int },
 
       # ── Buffer & Flush ──
-      max_buffer_memory:                { group: 'Buffer & Flush', label: 'Max Buffer Memory', desc: 'Maximum memory for the in-memory event queue before events are dropped', fmt: :bytes },
+      max_memory:                       { group: 'Buffer & Flush', label: 'Max Memory (MB)', desc: 'Global memory budget for catpm gem in megabytes', fmt: :int },
       flush_interval:                   { group: 'Buffer & Flush', label: 'Flush Interval', desc: 'How often the background thread drains the buffer to the database', fmt: :seconds },
       flush_jitter:                     { group: 'Buffer & Flush', label: 'Flush Jitter', desc: 'Random jitter added to flush interval to avoid thundering herd', fmt: :pm_seconds },
       persistence_batch_size:           { group: 'Buffer & Flush', label: 'Batch Size', desc: 'Number of events written per database transaction', fmt: :int },
@@ -121,8 +121,6 @@ module Catpm
       # ── Advanced ──
       shutdown_timeout:                 { group: 'Advanced', label: 'Shutdown Timeout', desc: 'Seconds to wait for buffer flush on application shutdown', fmt: :seconds },
       caller_scan_depth:                { group: 'Advanced', label: 'Caller Scan Depth', desc: 'Max stack frames scanned to find app code for source attribution', fmt: :int },
-      auto_instrument_methods:          { group: 'Advanced', label: 'Auto-Instrument Methods', desc: 'Method signatures to automatically instrument (e.g. Worker#process)', fmt: :list },
-      service_base_classes:             { group: 'Advanced', label: 'Service Base Classes', desc: 'Base classes for auto-detection of service objects; nil = auto-detect', fmt: :nullable_list },
     }.freeze
 
     def format_config_value(config, attr, meta)

data/app/models/catpm/sample.rb

@@ -14,10 +14,6 @@ module Catpm
     scope :recent, ->(period = 1.hour) { where(recorded_at: period.ago..) }
     scope :for_error, ->(fingerprint) { where(error_fingerprint: fingerprint) }
 
-    def self.request_id_supported?
-      column_names.include?('request_id')
-    end
-
     def parsed_context
       case context
       when Hash then context

data/app/views/catpm/samples/show.html.erb

@@ -40,7 +40,7 @@
 
 <%# ─── Request Context ─── %>
 <%
-  ctx_display = @context.except("segments", :segments, "segment_summary", :segment_summary, "segments_capped", :segments_capped, "backtrace", :backtrace, "method", :method, "path", :path, "status", :status)
+  ctx_display = @context.except("segments", :segments, "segment_summary", :segment_summary, "segments_capped", :segments_capped, "segments_filtered", :segments_filtered, "backtrace", :backtrace, "method", :method, "path", :path, "status", :status)
   ctx_flat = ctx_display.select { |_, v| !v.is_a?(Hash) && !v.is_a?(Array) }
   ctx_nested = ctx_display.select { |_, v| v.is_a?(Hash) || v.is_a?(Array) }
 %>
@@ -103,5 +103,5 @@
 
 <%# ─── Segments Waterfall (full width, no title) ─── %>
 <% if @segments.any? %>
-  <%= render "catpm/shared/segments_waterfall", segments: @segments, total_duration: @sample.duration, segments_capped: @context["segments_capped"] || @context[:segments_capped], table_id: "segments-table" %>
+  <%= render "catpm/shared/segments_waterfall", segments: @segments, total_duration: @sample.duration, segments_capped: @context["segments_capped"] || @context[:segments_capped], segments_filtered: @context["segments_filtered"] || @context[:segments_filtered] || 0, table_id: "segments-table" %>
 <% end %>

data/app/views/catpm/shared/_segments_waterfall.html.erb

@@ -1,4 +1,4 @@
-<%# Locals: segments, total_duration, segments_capped, table_id %>
+<%# Locals: segments, total_duration, segments_capped, segments_filtered, table_id %>
 
 <% if segments.any? %>
   <% total_dur = total_duration.to_f %>
@@ -147,6 +147,12 @@
         <% end %>
       </tbody>
     </table>
+    <% filtered = segments_filtered.to_i %>
+    <% if filtered > 0 %>
+      <div style="padding:6px 12px; font-size:12px; color:var(--text-2); border-top:1px solid var(--border)">
+        <%= filtered %> segment<%= filtered == 1 ? '' : 's' %> below <%= Catpm.config.min_segment_duration %>ms not shown (counted in Time Breakdown)
+      </div>
+    <% end %>
   </div>
 <% else %>
   <div class="empty-state">

data/app/views/catpm/system/index.html.erb

@@ -10,7 +10,7 @@
   <div class="diag-card">
     <div class="diag-label">Buffer</div>
     <div class="diag-value"><%= @buffer_size %> <span class="diag-unit">events</span></div>
-    <div class="diag-detail"><%= number_to_human_size(@buffer_bytes) %> / <%= number_to_human_size(@config.max_buffer_memory) %></div>
+    <div class="diag-detail"><%= number_to_human_size(@buffer_bytes) %> / <%= number_to_human_size(@buffer_max_bytes) %></div>
   </div>
   <div class="diag-card">
     <div class="diag-label">Flushes</div>

data/lib/catpm/adapter/base.rb

@@ -38,7 +38,6 @@ module Catpm
                 context: sample_data[:context],
                 error_fingerprint: sample_data[:error_fingerprint]
               }
-              record[:request_id] = sample_data[:request_id] if Catpm::Sample.request_id_supported?
               record
             end
 

data/lib/catpm/buffer.rb

@@ -2,7 +2,7 @@
 
 module Catpm
   class Buffer
-    attr_reader :current_bytes, :dropped_count
+    attr_reader :current_bytes, :max_bytes, :dropped_count
 
     def initialize(max_bytes:)
       @monitor = Monitor.new
@@ -22,17 +22,19 @@ module Catpm
     # Called from request threads. Returns :accepted or :dropped.
     # Never blocks — monitoring must not slow down the application.
     #
+    OVERFLOW_FACTOR = 1.5 # hard cap multiplier — drops events beyond this to prevent OOM
+
     # When buffer reaches max_bytes, signals the flusher for immediate drain
-    # and continues accepting events. Only drops as a last resort at 3x capacity
-    # (flusher stuck or DB down).
+    # and continues accepting events. Only drops as a last resort at OVERFLOW_FACTOR
+    # capacity (flusher stuck or DB down).
     def push(event)
       signal_flush = false
 
       @monitor.synchronize do
         bytes = event.estimated_bytes
 
-        # Hard safety cap: 3x configured limit prevents OOM if flusher is stuck
-        if @current_bytes + bytes > @max_bytes * 3
+        # Hard safety cap: prevents OOM if flusher is stuck
+        if @current_bytes + bytes > @max_bytes * OVERFLOW_FACTOR
           @dropped_count += 1
           Catpm.stats[:dropped_events] += 1
           return :dropped

data/lib/catpm/collector.rb

@@ -4,10 +4,13 @@ module Catpm
   module Collector
     SYNTHETIC_MIDDLEWARE_OFFSET_MS = 0.5
     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)
@@ -19,7 +22,7 @@ module Catpm
         return if Catpm.config.ignored?(target)
 
         duration = event.duration # milliseconds
-        status = payload[:status] || (payload[:exception] ? 500 : nil)
+        status = payload[:status] || (payload[:exception] ? DEFAULT_ERROR_STATUS : nil)
         metadata = build_http_metadata(payload)
 
         req_segments = Thread.current[:catpm_request_segments]
@@ -50,7 +53,7 @@ module Catpm
         metadata[:_instrumented] = 1 if instrumented
 
         # Early sampling decision — only build heavy context for sampled events
-        operation = payload[:method] || 'GET'
+        operation = payload[:method] || ''
         sample_type = early_sample_type(
           error: payload[:exception],
           duration: duration,
@@ -61,16 +64,20 @@ module Catpm
         )
 
         # Force the NEXT HTTP request to be fully instrumented when this one
-        # wasn't. Covers slow/error spikes and filling phase (new endpoints that
-        # haven't collected enough instrumented samples yet).
+        # 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
-          else
+          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]
-              trigger_force_instrument if instrumented_sample_counts[endpoint_key] < max
+              if instrumented_sample_counts[endpoint_key] < max
+                @http_filling_active = true
+              end
             end
           end
         end
@@ -159,6 +166,7 @@ module Catpm
             context[:segments] = segments
             context[:segment_summary] = segment_data[:segment_summary]
             context[:segments_capped] = segment_data[:segments_capped]
+            context[:segments_filtered] = segment_data[:segments_filtered] if segment_data[:segments_filtered] > 0
 
             # Append error marker segment inside the controller
             if payload[:exception]
@@ -340,6 +348,7 @@ module Catpm
             context[:segments] = segments
             context[:segment_summary] = segment_data[:segment_summary]
             context[:segments_capped] = segment_data[:segments_capped]
+            context[:segments_filtered] = segment_data[:segments_filtered] if segment_data[:segments_filtered] > 0
 
             # Append error marker segment inside the controller
             if error
@@ -368,70 +377,19 @@ module Catpm
           context = nil
         end
 
-        request_id = req_segments&.request_id
-
         ev = Event.new(
           kind: kind,
           target: target,
           operation: operation.to_s,
           duration: duration,
           started_at: Time.current,
-          status: error ? 500 : 200,
+          status: error ? DEFAULT_ERROR_STATUS : DEFAULT_SUCCESS_STATUS,
           context: context,
           sample_type: sample_type,
           metadata: metadata,
           error_class: error&.class&.name,
           error_message: error&.message,
-          backtrace: error&.backtrace,
-          request_id: request_id
-        )
-
-        Catpm.buffer&.push(ev)
-      end
-
-      def process_checkpoint(kind:, target:, operation:, context:, metadata:, checkpoint_data:, request_start:, request_id: nil)
-        return unless Catpm.enabled?
-
-        segments = checkpoint_data[:segments].dup
-        collapse_code_wrappers(segments)
-
-        duration_so_far = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - request_start) * 1000.0
-
-        # Inject root request segment
-        root_segment = {
-          type: 'request',
-          detail: "#{operation.presence || kind} #{target}",
-          duration: duration_so_far.round(2),
-          offset: 0.0
-        }
-        segments.each do |seg|
-          if seg.key?(:parent_index)
-            seg[:parent_index] += 1
-          else
-            seg[:parent_index] = 0
-          end
-        end
-        segments.unshift(root_segment)
-
-        checkpoint_context = (context || {}).dup
-        checkpoint_context[:segments] = segments
-        checkpoint_context[:segment_summary] = checkpoint_data[:summary]
-        checkpoint_context[:segments_capped] = checkpoint_data[:overflow]
-        checkpoint_context[:partial] = true
-        checkpoint_context[:checkpoint_number] = checkpoint_data[:checkpoint_number]
-        checkpoint_context = scrub(checkpoint_context)
-
-        ev = Event.new(
-          kind: kind,
-          target: target,
-          operation: operation.to_s,
-          duration: duration_so_far,
-          started_at: Time.current,
-          status: 200,
-          context: checkpoint_context,
-          sample_type: 'random',
-          metadata: (metadata || {}).dup.merge(checkpoint_data[:summary] || {}),
-          request_id: request_id
+          backtrace: error&.backtrace
         )
 
         Catpm.buffer&.push(ev)
@@ -459,6 +417,15 @@ 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?
@@ -468,6 +435,12 @@ module Catpm
           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
 
@@ -501,7 +474,9 @@ module Catpm
       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
+          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
@@ -512,10 +487,42 @@ module Catpm
         @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
@@ -627,13 +634,9 @@ module Catpm
 
         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.
-        # Filling phase is handled by the caller via trigger_force_instrument
-        # so the NEXT request gets full instrumentation with segments.
+        # 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.
@@ -644,7 +647,17 @@ module Catpm
         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
@@ -758,10 +771,10 @@ module Catpm
       end
 
       def build_http_metadata(payload)
-        h = {}
-        h[:db_runtime] = payload[:db_runtime] if payload[:db_runtime]
-        h[:view_runtime] = payload[:view_runtime] if payload[:view_runtime]
-        h
+        metadata = {}
+        metadata[:db_runtime] = payload[:db_runtime] if payload[:db_runtime]
+        metadata[:view_runtime] = payload[:view_runtime] if payload[:view_runtime]
+        metadata
       end
 
       def scrub(hash)

data/lib/catpm/configuration.rb

@@ -2,6 +2,16 @@
 
 module Catpm
   class Configuration
+    MIN_BUFFER_MEMORY = 1_048_576  # 1 MB — floor for buffer (meaningful buffering)
+    DEFAULT_ASSUMED_THREADS = 5   # fallback when thread detection fails
+
+    # Global memory budget distribution shares
+    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,
                   :instrument_http,
@@ -19,8 +29,6 @@ module Catpm
                   :http_basic_auth_password,
                   :access_policy,
                   :additional_filter_parameters,
-                  :auto_instrument_methods,
-                  :service_base_classes,
                   :events_enabled,
                   :track_own_requests,
                   :downsampling_thresholds,
@@ -28,11 +36,11 @@ module Catpm
 
     # Numeric settings that must be positive numbers (nil not allowed)
     REQUIRED_NUMERIC = %i[
-      slow_threshold max_buffer_memory flush_interval flush_jitter
+      slow_threshold flush_interval flush_jitter
       random_sample_rate cleanup_interval
       circuit_breaker_failure_threshold circuit_breaker_recovery_timeout
       sqlite_busy_timeout persistence_batch_size shutdown_timeout
-      stack_sample_interval segment_source_threshold
+      stack_sample_interval min_segment_duration max_memory
     ].freeze
 
     # Numeric settings where nil means "no limit" / "disabled"
@@ -43,7 +51,6 @@ module Catpm
       events_max_samples_per_name max_stack_samples_per_request
       max_error_detail_length max_fingerprint_app_frames
       max_fingerprint_gem_frames cleanup_batch_size caller_scan_depth
-      max_request_memory
     ].freeze
 
     (REQUIRED_NUMERIC + OPTIONAL_NUMERIC).each do |attr|
@@ -72,13 +79,13 @@ module Catpm
       @instrument_stack_sampler = false
       @instrument_middleware_stack = false
       @max_segments_per_request = 50
-      @segment_source_threshold = 5.0 # ms — capture caller_locations only for segments >= 5ms (set to 0.0 to capture all)
+      @min_segment_duration = 5.0 # ms — segments shorter than this are counted in summary but not stored (0.0 = store all)
       @max_sql_length = 200
       @slow_threshold = 500 # milliseconds
       @slow_threshold_per_kind = {}
       @ignored_targets = []
       @retention_period = nil # nil = keep forever (data is downsampled, not deleted)
-      @max_buffer_memory = 8.megabytes
+      @max_memory = 20 # MB — global memory budget (2% of 1GB server)
       @flush_interval = 30 # seconds
       @flush_jitter = 5 # ±seconds
       @max_error_contexts = 5
@@ -88,8 +95,6 @@ module Catpm
       @http_basic_auth_password = nil
       @access_policy = nil
       @additional_filter_parameters = []
-      @auto_instrument_methods = []
-      @service_base_classes = nil # nil = auto-detect (ApplicationService, BaseService)
       @random_sample_rate = 20
       @max_random_samples_per_endpoint = 5
       @max_slow_samples_per_endpoint = 5
@@ -117,11 +122,26 @@ module Catpm
       @max_fingerprint_gem_frames = 3
       @cleanup_batch_size = 1_000
       @caller_scan_depth = 50
-      @max_request_memory = 2.megabytes
       @instrument_call_tree = false
       @show_untracked_segments = false
     end
 
+    # Buffer gets BUFFER_MEMORY_SHARE of max_memory, scaled by thread count
+    def effective_max_buffer_memory
+      bytes = (max_memory * 1_048_576 * BUFFER_MEMORY_SHARE).to_i
+      [bytes, MIN_BUFFER_MEMORY].max
+    end
+
+    # Path cache limit derived from max_memory
+    def effective_path_cache_max
+      (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/engine.rb

@@ -12,7 +12,6 @@ module Catpm
       if Catpm.enabled?
         Catpm::Subscribers.subscribe!
         Catpm::Lifecycle.register_hooks
-        Catpm::AutoInstrument.apply!
 
         if Catpm.config.instrument_middleware_stack
           app = Rails.application
@@ -26,8 +25,5 @@ module Catpm
       end
     end
 
-    config.to_prepare do
-      Catpm::AutoInstrument.apply! if Catpm.enabled?
-    end
   end
 end

data/lib/catpm/event.rb

@@ -9,14 +9,14 @@ module Catpm
 
     attr_accessor :kind, :target, :operation, :duration, :started_at,
                   :metadata, :error_class, :error_message, :backtrace,
-                  :sample_type, :context, :status, :request_id
+                  :sample_type, :context, :status
 
     EMPTY_HASH = {}.freeze
     private_constant :EMPTY_HASH
 
     def initialize(kind:, target:, operation: '', duration: 0.0, started_at: nil,
                    metadata: nil, error_class: nil, error_message: nil, backtrace: nil,
-                   sample_type: nil, context: nil, status: nil, request_id: nil)
+                   sample_type: nil, context: nil, status: nil)
       @kind = kind.to_s
       @target = target.to_s
       @operation = (operation || '').to_s
@@ -32,7 +32,6 @@ module Catpm
       @sample_type = sample_type
       @context = context
       @status = status
-      @request_id = request_id
     end
 
     def estimated_bytes

data/lib/catpm/fingerprint.rb

@@ -40,7 +40,7 @@ module Catpm
 
       result = _app_frame?(line)
       @path_cache_mutex.synchronize do
-        @path_cache.clear if @path_cache.size > 4000
+        @path_cache.clear if @path_cache.size > Catpm.config.effective_path_cache_max
         @path_cache[line] = result
       end
       result