catpm 0.9.4 → 0.9.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b71e3f131bb8edb7a07b1f0996aa4ad2be18a365bf2724c2b67d160c7716ae8c
-  data.tar.gz: f0961bf02dd509df819634f29fb5717345bc3d3efeabfaa8192476cd2c94917e
+  metadata.gz: 18b84e4c767fa3872bbf196d21c3d197e6d4f6517269357e7b24bf0514da3708
+  data.tar.gz: 6cc282d9f10f13546939f8e9c39b12b784687ef4c0d25e42a2a7e34a39cd3124
 SHA512:
-  metadata.gz: 4e44d829fcb7ec331225d7539c00d76fafadceeb3192a7645c5f3149c2f060f1fb996c30f306c39166ca060074c78328372ff5a79e57696b03ce72abc0633fb8
-  data.tar.gz: de507352426ba225ec5c8dfb2cf4805ea8ca29ae095944276948cb9441993c84bfed5f7f7a4c9c6dd313fe7c82ec22df94e98b7af727b2ee362f15f9921eccb4
+  metadata.gz: 1968d1e8c7ed1257d2f0bfc3e28f9e34b4e38057ec89e103c10f02bd42d99daa78cf7ba0a9fc31ff5c07a8dc9e0895d9f6c541c557345469a20e2c09da88dd9c
+  data.tar.gz: d9e5c1b664605c6e66c92e9e6520a1c606f979f10e5e0deb8883307b965f4b4c3d361ef2dcf7ddfe3fb840d99e107c4c666a1ef4487165543f5904285f2a5a07

data/README.md

@@ -1,5 +1,5 @@
 gem build catpm.gemspec
-gem push catpm-0.9.3.gem
+gem push catpm-0.9.4.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_per_thread:            { group: 'Buffer & Flush', label: 'Memory per Thread', desc: 'Memory budget per application thread (split between request segments and event buffer)', fmt: :bytes },
       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/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/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

data/lib/catpm/collector.rb

@@ -4,6 +4,8 @@ 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.
@@ -19,7 +21,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 +52,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,
@@ -159,6 +161,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 +343,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
@@ -376,7 +380,7 @@ module Catpm
           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,
@@ -427,7 +431,7 @@ module Catpm
           operation: operation.to_s,
           duration: duration_so_far,
           started_at: Time.current,
-          status: 200,
+          status: DEFAULT_SUCCESS_STATUS,
           context: checkpoint_context,
           sample_type: 'random',
           metadata: (metadata || {}).dup.merge(checkpoint_data[:summary] || {}),
@@ -627,13 +631,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.
@@ -758,10 +758,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,13 @@
 
 module Catpm
   class Configuration
+    # Memory budget shares — how max_memory_per_thread is split
+    BUFFER_MEMORY_SHARE = 0.5   # half per-thread budget goes to buffer pool
+    REQUEST_MEMORY_SHARE = 0.5  # half per-thread budget for request segments
+    MIN_REQUEST_MEMORY = 1_024     # 1 KB — floor for per-request (checkpoint viability, ~5 minimal segments)
+    MIN_BUFFER_MEMORY = 1_048_576  # 1 MB — floor for buffer (meaningful buffering)
+    DEFAULT_ASSUMED_THREADS = 5         # fallback when thread detection fails
+
     # Boolean / non-numeric settings — plain attr_accessor
     attr_accessor :enabled,
                   :instrument_http,
@@ -19,8 +26,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 +33,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
     ].freeze
 
     # Numeric settings where nil means "no limit" / "disabled"
@@ -43,7 +48,7 @@ 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
+      max_memory_per_thread
     ].freeze
 
     (REQUIRED_NUMERIC + OPTIONAL_NUMERIC).each do |attr|
@@ -72,13 +77,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_per_thread = 2.megabytes
       @flush_interval = 30 # seconds
       @flush_jitter = 5 # ±seconds
       @max_error_contexts = 5
@@ -88,8 +93,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 +120,23 @@ 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
 
+    def derived_request_memory_limit
+      return nil unless max_memory_per_thread
+
+      [max_memory_per_thread * REQUEST_MEMORY_SHARE, MIN_REQUEST_MEMORY].max
+    end
+
+    def derived_buffer_memory_limit(detected_threads = nil)
+      return MIN_BUFFER_MEMORY unless max_memory_per_thread
+
+      threads = detected_threads || DEFAULT_ASSUMED_THREADS
+      [max_memory_per_thread * BUFFER_MEMORY_SHARE * threads, MIN_BUFFER_MEMORY].max
+    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/lifecycle.rb

@@ -39,7 +39,15 @@ module Catpm
       end
 
       def initialize_buffer
-        Catpm.buffer ||= Buffer.new(max_bytes: Catpm.config.max_buffer_memory)
+        max_bytes = Catpm.config.derived_buffer_memory_limit(detect_threads)
+        Catpm.buffer ||= Buffer.new(max_bytes: max_bytes)
+      end
+
+      def detect_threads
+        return Puma.cli_config.options[:max_threads] if defined?(Puma::Server) && Puma.respond_to?(:cli_config)
+        return ENV['RAILS_MAX_THREADS'].to_i if ENV['RAILS_MAX_THREADS'].present?
+        return Sidekiq[:concurrency] if defined?(Sidekiq) && Sidekiq.respond_to?(:[])
+        nil
       end
 
       def initialize_flusher

data/lib/catpm/middleware.rb

@@ -21,7 +21,7 @@ module Catpm
           request_start: env['catpm.request_start'],
           stack_sample: use_sampler,
           call_tree: Catpm.config.instrument_call_tree,
-          memory_limit: Catpm.config.max_request_memory
+          memory_limit: Catpm.config.derived_request_memory_limit
         )
         env['catpm.segments'] = req_segments
         Thread.current[:catpm_request_segments] = req_segments
@@ -47,10 +47,10 @@ module Catpm
       ev = Event.new(
         kind: :http,
         target: target_from_env(env),
-        operation: env['REQUEST_METHOD'] || 'GET',
+        operation: env['REQUEST_METHOD'] || '',
         duration: elapsed_ms(env),
         started_at: Time.current,
-        status: 500,
+        status: Collector::DEFAULT_ERROR_STATUS,
         sample_type: 'error',
         error_class: exception.class.name,
         error_message: exception.message,

data/lib/catpm/patches/httpclient.rb

@@ -17,7 +17,7 @@ module Catpm
         status = response.status rescue nil
         detail = "#{http_method} #{uri.host}#{uri.path}"
         detail += " (#{status})" if status
-        source = duration >= Catpm.config.segment_source_threshold ? extract_catpm_source : nil
+        source = Catpm.segment_storable?(duration) ? extract_catpm_source : nil
 
         segments.add(
           type: :http, duration: duration, detail: detail,

data/lib/catpm/patches/net_http.rb

@@ -12,7 +12,7 @@ module Catpm
         duration = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000.0
 
         detail = "#{req.method} #{@address}#{req.path} (#{response.code})"
-        source = duration >= Catpm.config.segment_source_threshold ? extract_catpm_source : nil
+        source = Catpm.segment_storable?(duration) ? extract_catpm_source : nil
 
         segments.add(
           type: :http, duration: duration, detail: detail,

data/lib/catpm/request_segments.rb

@@ -9,7 +9,7 @@ module Catpm
     SEGMENT_BASE_BYTES = Event::OBJECT_OVERHEAD + (6 * Event::HASH_ENTRY_SIZE)
     SEGMENT_STRING_OVERHEAD = Event::OBJECT_OVERHEAD # per-string overhead in segment values
 
-    attr_reader :segments, :summary, :request_start, :estimated_bytes, :checkpoint_count, :request_id
+    attr_reader :segments, :summary, :request_start, :estimated_bytes, :checkpoint_count, :request_id, :segments_filtered
 
     def initialize(max_segments:, request_start: nil, stack_sample: false, call_tree: false, memory_limit: nil)
       @max_segments = max_segments
@@ -25,6 +25,7 @@ module Catpm
       @checkpoint_callback = nil
       @checkpoint_count = 0
       @request_id = memory_limit ? SecureRandom.hex(8) : nil
+      @segments_filtered = 0
 
       if stack_sample
         @sampler = StackSampler.new(target_thread: Thread.current, request_start: @request_start, call_tree: call_tree)
@@ -42,6 +43,18 @@ module Catpm
       @summary[count_key] += 1
       @summary[dur_key] += duration
 
+      # Record time range so sampler can skip already-tracked periods
+      if started_at && duration > 0
+        @tracked_ranges << [started_at, started_at + duration / 1000.0]
+      end
+
+      # Skip storing segment below minimum duration threshold —
+      # summary counters above are still updated for accurate Time Breakdown.
+      unless Catpm.segment_storable?(duration)
+        @segments_filtered += 1
+        return
+      end
+
       offset = started_at ? ((started_at - @request_start) * 1000.0).round(2) : nil
 
       segment = { type: type.to_s, duration: duration.round(2), detail: detail }
@@ -49,11 +62,6 @@ module Catpm
       segment[:source] = source if source
       segment[:parent_index] = @span_stack.last if @span_stack.any?
 
-      # Record time range so sampler can skip already-tracked periods
-      if started_at && duration > 0
-        @tracked_ranges << [started_at, started_at + duration / 1000.0]
-      end
-
       if @max_segments.nil? || @segments.size < @max_segments
         @segments << segment
       else
@@ -132,6 +140,7 @@ module Catpm
       @tracked_ranges = []
       @sampler = nil
       @estimated_bytes = 0
+      @segments_filtered = 0
     end
 
     def overflowed?
@@ -142,7 +151,8 @@ module Catpm
       {
         segments: @segments,
         segment_summary: @summary,
-        segments_capped: @overflow
+        segments_capped: @overflow,
+        segments_filtered: @segments_filtered
       }
     end
 
@@ -217,6 +227,7 @@ module Catpm
       @tracked_ranges = []
       @overflow = false
       @estimated_bytes = 0
+      @segments_filtered = 0
     end
   end
 end

data/lib/catpm/segment_subscribers.rb

@@ -155,7 +155,7 @@ module Catpm
         record_count = payload[:record_count] || 0
         class_name = payload[:class_name] || 'ActiveRecord'
         detail = "#{class_name} x#{record_count}"
-        source = duration >= Catpm.config.segment_source_threshold ? extract_source_location : nil
+        source = Catpm.segment_storable?(duration) ? extract_source_location : nil
 
         # Fold into sql summary for cleaner breakdown
         req_segments.add(
@@ -176,7 +176,7 @@ module Catpm
         sql = payload[:sql].to_s
         max_len = Catpm.config.max_sql_length
         sql = sql.truncate(max_len) if max_len && sql.length > max_len
-        source = duration >= Catpm.config.segment_source_threshold ? extract_source_location : nil
+        source = Catpm.segment_storable?(duration) ? extract_source_location : nil
 
         req_segments.add(
           type: :sql, duration: duration, detail: sql,
@@ -193,7 +193,7 @@ module Catpm
         hit = event.payload[:hit]
         detail = "cache.#{operation} #{key}"
         detail += hit ? ' (hit)' : ' (miss)' if operation == 'read' && !hit.nil?
-        source = duration >= Catpm.config.segment_source_threshold ? extract_source_location : nil
+        source = Catpm.segment_storable?(duration) ? extract_source_location : nil
 
         req_segments.add(
           type: :cache, duration: duration, detail: detail,
@@ -209,7 +209,7 @@ module Catpm
         mailer = payload[:mailer].to_s
         to = Array(payload[:to]).first.to_s
         detail = to.empty? ? mailer : "#{mailer} to #{to}"
-        source = event.duration >= Catpm.config.segment_source_threshold ? extract_source_location : nil
+        source = Catpm.segment_storable?(event.duration) ? extract_source_location : nil
 
         req_segments.add(
           type: :mailer, duration: event.duration, detail: detail,
@@ -224,7 +224,7 @@ module Catpm
         payload = event.payload
         key = payload[:key].to_s
         detail = "#{operation} #{key}"
-        source = event.duration >= Catpm.config.segment_source_threshold ? extract_source_location : nil
+        source = Catpm.segment_storable?(event.duration) ? extract_source_location : nil
 
         req_segments.add(
           type: :storage, duration: event.duration, detail: detail,

data/lib/catpm/trace.rb

@@ -47,7 +47,7 @@ module Catpm
 
       req_segments = Thread.current[:catpm_request_segments]
       if req_segments
-        source = duration_ms >= config.segment_source_threshold ? extract_trace_source : nil
+        source = segment_storable?(duration_ms) ? extract_trace_source : nil
         req_segments.add(
           type: :custom, duration: duration_ms, detail: name,
           source: source, started_at: start_time
@@ -90,12 +90,12 @@ module Catpm
           request_start: start_time,
           stack_sample: use_sampler,
           call_tree: config.instrument_call_tree,
-          memory_limit: config.max_request_memory
+          memory_limit: config.derived_request_memory_limit
         )
         Thread.current[:catpm_request_segments] = req_segments
         owns_segments = true
 
-        if config.max_request_memory
+        if config.derived_request_memory_limit
           req_segments.on_checkpoint do |checkpoint_data|
             Collector.process_checkpoint(
               kind: kind, target: target, operation: operation,
@@ -162,7 +162,7 @@ module Catpm
 
       req_segments = Thread.current[:catpm_request_segments]
       if req_segments
-        source = duration_ms >= Catpm.config.segment_source_threshold ? Catpm.send(:extract_trace_source) : nil
+        source = Catpm.segment_storable?(duration_ms) ? Catpm.send(:extract_trace_source) : nil
         req_segments.add(
           type: :custom, duration: duration_ms, detail: @name,
           source: source, started_at: @start_time

data/lib/catpm/version.rb

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

data/lib/catpm.rb

@@ -22,7 +22,6 @@ require 'catpm/segment_subscribers'
 require 'catpm/lifecycle'
 require 'catpm/trace'
 require 'catpm/span_helpers'
-require 'catpm/auto_instrument'
 require 'catpm/engine'
 
 module Catpm
@@ -64,5 +63,11 @@ module Catpm
       return unless enabled? && config.events_enabled
       buffer&.push(CustomEvent.new(name: name, payload: payload))
     end
+
+    # Whether a segment with the given duration should be stored (and have source captured).
+    # Segments below min_segment_duration are still counted in summary but not stored.
+    def segment_storable?(duration)
+      duration >= config.min_segment_duration
+    end
   end
 end

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

@@ -23,13 +23,9 @@ Catpm.configure do |config|
   # config.show_untracked_segments = false
   # config.track_own_requests = false
 
-  # === Auto-instrumentation ===
-  # config.service_base_classes = nil                  # nil = auto-detect (ApplicationService, BaseService)
-  # config.auto_instrument_methods = []                # e.g. ["Worker#process", "Gateway.charge"]
-
   # === Segments ===
   # config.max_segments_per_request = 50               # nil = unlimited
-  # config.segment_source_threshold = 0.0              # ms — capture caller_locations above this
+  # config.min_segment_duration = 5.0                   # ms — segments shorter than this are counted but not stored (0 = store all)
   # config.max_sql_length = 200                        # nil = no truncation
   # config.slow_threshold = 500                        # ms
   # config.slow_threshold_per_kind = {}                # { http: 500, job: 5_000, custom: 1_000 }
@@ -53,8 +49,10 @@ Catpm.configure do |config|
   # config.events_enabled = false
   # config.events_max_samples_per_name = 20            # nil = unlimited
 
+  # === Memory ===
+  # config.max_memory_per_thread = 2.megabytes  # memory budget per thread (buffer + request segments)
+
   # === Buffering & Flushing ===
-  # config.max_buffer_memory = 8.megabytes
   # config.flush_interval = 30                         # seconds
   # config.flush_jitter = 5                            # ±seconds
   # config.persistence_batch_size = 100

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: catpm
 version: !ruby/object:Gem::Version
-  version: 0.9.4
+  version: 0.9.5
 platform: ruby
 authors:
 - ''
@@ -78,7 +78,6 @@ files:
 - lib/catpm/adapter/base.rb
 - lib/catpm/adapter/postgresql.rb
 - lib/catpm/adapter/sqlite.rb
-- lib/catpm/auto_instrument.rb
 - lib/catpm/buffer.rb
 - lib/catpm/call_tracer.rb
 - lib/catpm/circuit_breaker.rb

data/lib/catpm/auto_instrument.rb

@@ -1,145 +0,0 @@
-# frozen_string_literal: true
-
-module Catpm
-  # Zero-config service auto-instrumentation.
-  #
-  # Detects common service base classes (ApplicationService, BaseService)
-  # and prepends span tracking on their .call class method. Since subclasses
-  # inherit .call from the base, ALL service objects get instrumented
-  # automatically — no code changes, no configuration lists.
-  #
-  # The typical Rails service pattern:
-  #   class ApplicationService
-  #     def self.call(...) = new(...).call
-  #   end
-  #
-  #   class Sync::Processor < ApplicationService
-  #     def call = ...
-  #   end
-  #
-  # After auto-instrumentation, Sync::Processor.call creates a span
-  # named "Sync::Processor#call" that wraps the entire service execution.
-  #
-  # Custom base classes:
-  #   Catpm.configure { |c| c.service_base_classes = ["MyBase"] }
-  #
-  # Explicit method list for edge cases:
-  #   Catpm.configure do |c|
-  #     c.auto_instrument_methods = ["Worker#process", "Gateway.charge"]
-  #   end
-  #
-  module AutoInstrument
-    DEFAULT_SERVICE_BASES = %w[
-      ApplicationService
-      BaseService
-    ].freeze
-
-    class << self
-      def apply!
-        instrument_service_bases
-        instrument_explicit_methods
-      end
-
-      def reset!
-        @applied = Set.new
-        @bases_applied = Set.new
-      end
-
-      private
-
-      # ─── Auto-detect service base classes ───
-
-      def instrument_service_bases
-        @bases_applied ||= Set.new
-
-        bases = Catpm.config.service_base_classes
-        bases = DEFAULT_SERVICE_BASES if bases.nil?
-
-        bases.each do |base_name|
-          next if @bases_applied.include?(base_name)
-
-          begin
-            klass = Object.const_get(base_name)
-          rescue NameError
-            next
-          end
-
-          next unless klass.is_a?(Class)
-
-          # Prepend on the class-level .call so ALL subclasses get instrumented.
-          # Since subclasses inherit .call from the base and only override
-          # instance #call, this single prepend covers everything.
-          if klass.respond_to?(:call)
-            # Guard against double-prepend (e.g. code reloading in development)
-            already = klass.singleton_class.ancestors.any? do |a|
-              a.instance_variable_defined?(:@catpm_service_span)
-            end
-            next if already
-
-            mod = Module.new do
-              @catpm_service_span = true
-
-              define_method(:call) do |*args, **kwargs, &block|
-                Catpm.span("#{name}#call", type: :code) { super(*args, **kwargs, &block) }
-              end
-            end
-            klass.singleton_class.prepend(mod)
-          end
-
-          @bases_applied << base_name
-        end
-      end
-
-      # ─── Explicit method list ───
-
-      def instrument_explicit_methods
-        methods = Catpm.config.auto_instrument_methods
-        return if methods.nil? || methods.empty?
-
-        @applied ||= Set.new
-
-        methods.each do |method_spec|
-          next if @applied.include?(method_spec)
-
-          if method_spec.include?('#')
-            class_name, method_name = method_spec.split('#', 2)
-            instrument_instance_method(class_name, method_name, method_spec)
-          elsif method_spec.include?('.')
-            class_name, method_name = method_spec.split('.', 2)
-            instrument_class_method(class_name, method_name, method_spec)
-          end
-        end
-      end
-
-      def instrument_instance_method(class_name, method_name, spec)
-        klass = Object.const_get(class_name)
-        span_name = spec
-
-        mod = Module.new do
-          define_method(method_name.to_sym) do |*args, **kwargs, &block|
-            Catpm.span(span_name) { super(*args, **kwargs, &block) }
-          end
-        end
-        klass.prepend(mod)
-        @applied << spec
-      rescue NameError
-        nil
-      end
-
-      def instrument_class_method(class_name, method_name, spec)
-        klass = Object.const_get(class_name)
-        span_name = spec
-
-        mod = Module.new do
-          define_method(method_name.to_sym) do |*args, **kwargs, &block|
-            Catpm.span(span_name) { super(*args, **kwargs, &block) }
-          end
-        end
-        klass.singleton_class.prepend(mod)
-        @applied << spec
-      rescue NameError
-        nil
-      end
-    end
-  end
-end