catpm 0.10.0 → 0.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0283e922a2169d04e59405a273250c1fd226b4b72731f01ba6f6495b6a216ce2'
-  data.tar.gz: 5af58e9875ee9ce18afc02816e79d94cb025025218b78695e560a7a662ce2953
+  metadata.gz: 5dab2a97464afff0ad59e3913f7f1aca84505d3ca109966a611eed911d5bb1a7
+  data.tar.gz: aa4c892ce8a39fb2ba5ceacf1aef5f1b9c6c867a682536f67c895d887d93607b
 SHA512:
-  metadata.gz: 0e73b3ea6819f8633104be971da72ad30c5de1b13bc4e0bece856d1e13b5987c705fb322f48c91622ae87d8acbd6b3d71ff0d2bb151939370a2685f4cf0ec7a7
-  data.tar.gz: 988f46467fbf05398f71cefff884584fb1daf2b148500df100b0824049d2cc659e5e74038e65c8de30cec27b36aaa6d503c5267475b8b4c7313e35b4e208e375
+  metadata.gz: dbfa610b0355bf1f99b41c6be9476f622e4f756c75c79764abee15721bb2a729113425b6b81416e86e09f734d253301c36f8b0f577b8b15075c584d0e0728dae
+  data.tar.gz: ebaef872bc07283485e72ef2ccb5b9f14b836f581c66053ed0f7329621e83a5b7e3b58ef7e021cb43c5bdece61d20dda39867c85a73382bef055364424481f16

data/README.md

@@ -1,5 +1,5 @@
 gem build catpm.gemspec
-gem push catpm-0.9.7.gem
+gem push catpm-0.10.0.gem
 
 # Catpm
 

data/app/controllers/catpm/application_controller.rb

@@ -2,6 +2,9 @@
 
 module Catpm
   class ApplicationController < ActionController::Base
+    SAMPLES_PER_PAGE = 15
+    SAMPLES_PER_PAGE_OPTIONS = [10, 15, 25, 50].freeze
+
     before_action :authenticate!
     rescue_from ActiveRecord::RecordNotFound, with: :render_not_found
 
@@ -31,6 +34,11 @@ module Catpm
       end
     end
 
+    def sanitized_per_page(param_key = :per_page)
+      val = params[param_key].to_i
+      SAMPLES_PER_PAGE_OPTIONS.include?(val) ? val : SAMPLES_PER_PAGE
+    end
+
     def remembered_range
       if params[:range].present?
         cookies[:catpm_range] = { value: params[:range], expires: 1.year.from_now }

data/app/controllers/catpm/endpoints_controller.rb

@@ -81,9 +81,23 @@ module Catpm
         .joins(:bucket)
         .where(catpm_buckets: { kind: @kind, target: @target, operation: @operation })
 
+      @error_per_page = sanitized_per_page(:error_per_page)
+      @error_page = [params[:error_page].to_i, 1].max
+      @error_total = endpoint_samples.where(sample_type: 'error').count
+      @error_samples = endpoint_samples.where(sample_type: 'error').order(recorded_at: :desc)
+        .offset((@error_page - 1) * @error_per_page).limit(@error_per_page)
+
+      @slow_per_page = sanitized_per_page(:slow_per_page)
+      @slow_page = [params[:slow_page].to_i, 1].max
+      @slow_total = endpoint_samples.where(sample_type: 'slow').count
       @slow_samples = endpoint_samples.where(sample_type: 'slow').order(duration: :desc)
+        .offset((@slow_page - 1) * @slow_per_page).limit(@slow_per_page)
+
+      @samples_per_page = sanitized_per_page(:samples_per_page)
+      @samples_page = [params[:samples_page].to_i, 1].max
+      @samples_total = endpoint_samples.where(sample_type: 'random').count
       @samples = endpoint_samples.where(sample_type: 'random').order(recorded_at: :desc)
-      @error_samples = endpoint_samples.where(sample_type: 'error').order(recorded_at: :desc)
+        .offset((@samples_page - 1) * @samples_per_page).limit(@samples_per_page)
 
       @pref = Catpm::EndpointPref.find_by(kind: @kind, target: @target, operation: @operation)
       @active_error_count = Catpm::ErrorRecord.unresolved.count

data/app/controllers/catpm/errors_controller.rb

@@ -38,23 +38,26 @@ module Catpm
 
       @range, period, bucket_seconds = helpers.parse_range(remembered_range)
 
-      # Samples table: 20 most recent linked by fingerprint
-      @samples = Catpm::Sample.where(error_fingerprint: @error.fingerprint)
-                              .order(recorded_at: :desc)
-                              .limit(Catpm.config.max_error_samples_per_fingerprint)
+      # Samples table: linked by fingerprint
+      samples_scope = Catpm::Sample.where(error_fingerprint: @error.fingerprint)
+                                   .order(recorded_at: :desc)
 
       # Fallback: match error samples by recorded_at from contexts
-      if @samples.empty? && @contexts.any?
+      if !samples_scope.exists? && @contexts.any?
         occurred_times = @contexts.filter_map { |c|
           Time.parse(c['occurred_at'] || c[:occurred_at]) rescue nil
         }
         if occurred_times.any?
-          @samples = Catpm::Sample.where(sample_type: 'error', kind: @error.kind, recorded_at: occurred_times)
-                                  .order(recorded_at: :desc)
-                                  .limit(Catpm.config.max_error_samples_per_fingerprint)
+          samples_scope = Catpm::Sample.where(sample_type: 'error', kind: @error.kind, recorded_at: occurred_times)
+                                       .order(recorded_at: :desc)
         end
       end
 
+      @samples_per_page = sanitized_per_page
+      @samples_page = [params[:page].to_i, 1].max
+      @samples_total = samples_scope.count
+      @samples = samples_scope.offset((@samples_page - 1) * @samples_per_page).limit(@samples_per_page)
+
       # Chart from occurrence_buckets (multi-resolution, no dependency on samples)
       ob = @error.parsed_occurrence_buckets
 

data/app/controllers/catpm/events_controller.rb

@@ -114,7 +114,11 @@ module Catpm
       @chart_times = 60.times.map { |i| Time.at(now_slot - (59 - i) * bucket_seconds).strftime('%H:%M') }
 
       # Recent samples
-      @samples = Catpm::EventSample.by_name(@name).order(recorded_at: :desc).limit(Catpm.config.events_max_samples_per_name)
+      samples_scope = Catpm::EventSample.by_name(@name).order(recorded_at: :desc)
+      @samples_per_page = sanitized_per_page
+      @samples_page = [params[:page].to_i, 1].max
+      @samples_total = samples_scope.count
+      @samples = samples_scope.offset((@samples_page - 1) * @samples_per_page).limit(@samples_per_page)
 
       @pref = Catpm::EventPref.find_by(name: @name)
       @active_error_count = Catpm::ErrorRecord.unresolved.count

data/app/helpers/catpm/application_helper.rb

@@ -78,6 +78,7 @@ module Catpm
 
       # ── Sampling ──
       random_sample_rate:               { group: 'Sampling', label: 'Random Sample Rate', desc: '1-in-N requests are sampled randomly for detailed traces', fmt: :one_in_n },
+      always_sample_targets:            { group: 'Sampling', label: 'Always Sample Targets', desc: 'Endpoint patterns that are always sampled regardless of random rate', fmt: :list },
       max_random_samples_per_endpoint:  { group: 'Sampling', label: 'Max Random / Endpoint', desc: 'Random samples retained per endpoint', fmt: :nullable_int },
       max_slow_samples_per_endpoint:    { group: 'Sampling', label: 'Max Slow / Endpoint', desc: 'Slow samples retained per endpoint', fmt: :nullable_int },
       max_error_samples_per_fingerprint: { group: 'Sampling', label: 'Max Error / Fingerprint', desc: 'Error samples retained per error fingerprint', fmt: :nullable_int },
@@ -308,7 +309,7 @@ module Catpm
       new_dir = active && current_dir == 'asc' ? 'desc' : 'asc'
       arrow = active ? (current_dir == 'asc' ? ' ▲' : ' ▼') : ''
       params_hash = extra_params.merge(sort: column, dir: new_dir)
-      url = '?' + params_hash.map { |k, v| "#{k}=#{v}" }.join('&')
+      url = '?' + Rack::Utils.build_query(params_hash)
       %(<a href="#{url}" class="sort-link#{active ? ' active' : ''}">#{label}#{arrow}</a>).html_safe
     end
 
@@ -350,31 +351,69 @@ module Catpm
       (span / 60.0).ceil
     end
 
-    def pagination_nav(current_page, total_count, per_page, extra_params: {})
+    def pagination_nav(current_page, total_count, per_page, extra_params: {}, page_param: :page, anchor: nil)
       total_pages = (total_count.to_f / per_page).ceil
       return '' if total_pages <= 1
 
-      prev_params = extra_params.merge(page: current_page - 1)
-      next_params = extra_params.merge(page: current_page + 1)
-      prev_url = '?' + prev_params.compact.map { |k, v| "#{k}=#{v}" }.join('&')
-      next_url = '?' + next_params.compact.map { |k, v| "#{k}=#{v}" }.join('&')
+      fragment = anchor ? "##{anchor}" : ''
+
+      prev_url = '?' + Rack::Utils.build_query(extra_params.merge(page_param => current_page - 1).compact) + fragment
+      next_url = '?' + Rack::Utils.build_query(extra_params.merge(page_param => current_page + 1).compact) + fragment
 
       html = +'<div class="pagination">'
       if current_page > 1
-        html << %(<a href="#{prev_url}" class="btn">← Previous</a>)
+        html << %(<a href="#{prev_url}" class="page-btn">&lsaquo;</a>)
       else
-        html << '<span class="btn" style="opacity:0.3;cursor:default">← Previous</span>'
+        html << '<span class="page-btn disabled">&lsaquo;</span>'
       end
-      html << %(<span class="pagination-info">Page #{current_page} of #{total_pages}</span>)
+      html << %(<span class="pagination-info">#{current_page} / #{total_pages}</span>)
       if current_page < total_pages
-        html << %(<a href="#{next_url}" class="btn">Next →</a>)
+        html << %(<a href="#{next_url}" class="page-btn">&rsaquo;</a>)
       else
-        html << '<span class="btn" style="opacity:0.3;cursor:default">Next →</span>'
+        html << '<span class="page-btn disabled">&rsaquo;</span>'
       end
       html << '</div>'
       html.html_safe
     end
 
+    def samples_pagination(current_page, total_count, per_page, extra_params: {}, page_param: :page, anchor: nil, storage_key:, per_page_param:)
+      total_pages = (total_count.to_f / per_page).ceil
+      fragment = anchor ? "##{anchor}" : ''
+
+      html = +'<div class="pagination">'
+
+      if total_pages > 1
+        prev_url = '?' + Rack::Utils.build_query(extra_params.merge(page_param => current_page - 1).compact) + fragment
+        next_url = '?' + Rack::Utils.build_query(extra_params.merge(page_param => current_page + 1).compact) + fragment
+
+        if current_page > 1
+          html << %(<a href="#{prev_url}" class="page-btn">&lsaquo;</a>)
+        else
+          html << '<span class="page-btn disabled">&lsaquo;</span>'
+        end
+        html << %(<span class="pagination-info">#{current_page} / #{total_pages}</span>)
+        if current_page < total_pages
+          html << %(<a href="#{next_url}" class="page-btn">&rsaquo;</a>)
+        else
+          html << '<span class="page-btn disabled">&rsaquo;</span>'
+        end
+      end
+
+      # Per-page select — right-aligned
+      html << '<select class="per-page-select" data-storage-key="'
+      html << ERB::Util.html_escape(storage_key)
+      html << '" data-page-param="' << ERB::Util.html_escape(page_param)
+      html << '" data-per-page-param="' << ERB::Util.html_escape(per_page_param) << '">'
+      Catpm::ApplicationController::SAMPLES_PER_PAGE_OPTIONS.each do |opt|
+        sel = opt == per_page ? ' selected' : ''
+        html << %(<option value="#{opt}"#{sel}>#{opt}</option>)
+      end
+      html << '</select>'
+
+      html << '</div>'
+      html.html_safe
+    end
+
     def trend_indicator(error)
       return '' unless error.last_occurred_at
       if error.last_occurred_at > 1.hour.ago

data/app/views/catpm/endpoints/_sample_table.html.erb

@@ -1,4 +1,5 @@
-<h2><%= title %> (<%= samples.size %>)</h2>
+<% anchor_id = "samples-#{page_param.to_s.delete_suffix('_page')}" %>
+<h2 id="<%= anchor_id %>"><%= title %> (<%= total_count %>)</h2>
 <% if samples.any? %>
   <div class="table-scroll">
   <table>
@@ -36,6 +37,8 @@
     </tbody>
   </table>
   </div>
+  <% base_params = request.query_parameters.symbolize_keys.except(page_param.to_sym) %>
+  <%= samples_pagination(page, total_count, per_page, extra_params: base_params, page_param: page_param.to_sym, anchor: anchor_id, storage_key: storage_key, per_page_param: per_page_param) %>
 <% else %>
   <div class="empty-state">
     <div class="empty-hint"><%= empty_msg %></div>

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

@@ -147,6 +147,12 @@
   </div>
 <% end %>
 
-<%= render "catpm/endpoints/sample_table", title: "Error Requests", samples: @error_samples, empty_msg: "No errors for this endpoint." %>
-<%= render "catpm/endpoints/sample_table", title: "Slowest Requests", samples: @slow_samples, empty_msg: "No slow requests captured yet." %>
-<%= render "catpm/endpoints/sample_table", title: "Sample Requests", samples: @samples, empty_msg: "No samples captured yet." %>
+<%= render "catpm/endpoints/sample_table", title: "Error Requests", samples: @error_samples, empty_msg: "No errors for this endpoint.",
+    page: @error_page, total_count: @error_total, per_page: @error_per_page,
+    page_param: "error_page", per_page_param: "error_per_page", storage_key: "catpm_per_page_errors" %>
+<%= render "catpm/endpoints/sample_table", title: "Slowest Requests", samples: @slow_samples, empty_msg: "No slow requests captured yet.",
+    page: @slow_page, total_count: @slow_total, per_page: @slow_per_page,
+    page_param: "slow_page", per_page_param: "slow_per_page", storage_key: "catpm_per_page_slow" %>
+<%= render "catpm/endpoints/sample_table", title: "Sample Requests", samples: @samples, empty_msg: "No samples captured yet.",
+    page: @samples_page, total_count: @samples_total, per_page: @samples_per_page,
+    page_param: "samples_page", per_page_param: "samples_per_page", storage_key: "catpm_per_page_requests" %>

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

@@ -94,8 +94,8 @@
 </div>
 
 <%# ─── Samples ─── %>
-<% if @samples.any? %>
-  <h2>Recent Samples</h2>
+<% if @samples.any? || @samples_page > 1 %>
+  <h2 id="samples-error">Recent Samples (<%= @samples_total %>)</h2>
   <%= section_description("Linked request samples for this error. Click to view full details.") %>
   <div class="table-scroll">
   <table>
@@ -129,6 +129,8 @@
     </tbody>
   </table>
   </div>
+  <% base_params = request.query_parameters.symbolize_keys.except(:page) %>
+  <%= samples_pagination(@samples_page, @samples_total, @samples_per_page, extra_params: base_params, anchor: "samples-error", storage_key: "catpm_per_page_errors", per_page_param: "per_page") %>
 <% end %>
 
 <%# ─── Legacy Occurrences (for errors without linked samples) ─── %>

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

@@ -55,7 +55,7 @@
 <% end %>
 
 <%# ─── Recent Samples ─── %>
-<h2>Recent Samples</h2>
+<h2 id="samples-events">Recent Samples (<%= @samples_total %>)</h2>
 <%= section_description("Most recent event payloads captured.") %>
 
 <% if @samples.any? %>
@@ -99,6 +99,8 @@
       <% end %>
     </tbody>
   </table>
+  <% base_params = request.query_parameters.symbolize_keys.except(:page) %>
+  <%= samples_pagination(@samples_page, @samples_total, @samples_per_page, extra_params: base_params, anchor: "samples-events", storage_key: "catpm_per_page_requests", per_page_param: "per_page") %>
 <% else %>
   <div class="empty-state">
     <div class="empty-title">No samples recorded</div>

data/app/views/layouts/catpm/application.html.erb

@@ -183,8 +183,12 @@
     .empty-state .empty-hint { font-size: 13px; }
 
     /* ─── Pagination ─── */
-    .pagination { display: flex; align-items: center; gap: 12px; margin: 16px 0; }
-    .pagination-info { font-size: 13px; color: var(--text-2); }
+    .pagination { display: flex; align-items: center; gap: 6px; margin: 8px 0; font-size: 12px; }
+    .pagination-info { color: var(--text-2); min-width: 32px; text-align: center; }
+    .page-btn { display: inline-flex; align-items: center; justify-content: center; width: 24px; height: 24px; border: 1px solid var(--border); border-radius: 4px; color: var(--text-1); font-size: 14px; line-height: 1; }
+    .page-btn:hover { background: var(--bg-1); color: var(--text-0); text-decoration: none; }
+    .page-btn.disabled { opacity: 0.3; cursor: default; pointer-events: none; }
+    .per-page-select { margin-left: 6px; padding: 2px 4px; border: 1px solid var(--border); border-radius: 4px; font-size: 12px; background: var(--bg-0); color: var(--text-1); cursor: pointer; }
 
     /* ─── Code / Backtrace ─── */
     .source { color: var(--green); font-size: 12px; font-family: var(--font-mono); }
@@ -602,6 +606,46 @@
       /* Close menu on outside click */
       closeActionMenu();
     });
+
+    /* ─── Per-Page Selector: persist in localStorage, update URL ─── */
+    document.addEventListener('DOMContentLoaded', function() {
+      var selects = document.querySelectorAll('.per-page-select');
+      var urlParams = new URLSearchParams(window.location.search);
+      var needsRedirect = false;
+
+      // Batch: apply all stored per_page values missing from URL
+      selects.forEach(function(sel) {
+        var storageKey = sel.dataset.storageKey;
+        var perPageParam = sel.dataset.perPageParam;
+        var pageParam = sel.dataset.pageParam;
+        if (!urlParams.has(perPageParam) && storageKey) {
+          var stored = localStorage.getItem(storageKey);
+          if (stored && stored !== sel.value) {
+            urlParams.set(perPageParam, stored);
+            urlParams.delete(pageParam);
+            needsRedirect = true;
+          }
+        }
+      });
+      if (needsRedirect) { window.location.search = urlParams.toString(); return; }
+
+      // Change handler: persist and reload
+      selects.forEach(function(sel) {
+        sel.addEventListener('change', function() {
+          var storageKey = sel.dataset.storageKey;
+          if (storageKey) localStorage.setItem(storageKey, sel.value);
+          var params = new URLSearchParams(window.location.search);
+          params.set(sel.dataset.perPageParam, sel.value);
+          params.delete(sel.dataset.pageParam);
+          // Find heading anchor above this pagination bar
+          var el = sel.closest('.pagination');
+          while (el && !el.id) el = el.previousElementSibling;
+          if (!el) { el = sel.closest('.pagination')?.parentElement; while (el && !el.id) el = el.previousElementSibling; }
+          var hash = el?.id ? '#' + el.id : '';
+          window.location.href = window.location.pathname + '?' + params.toString() + hash;
+        });
+      });
+    });
   </script>
 </body>
 </html>

data/lib/catpm/collector.rb

@@ -122,6 +122,7 @@ module Catpm
                   seg[:parent_index] = tree_parent ? (tree_parent + base_idx) : (ctrl_idx || 0)
                   segments << seg
                 end
+                reparent_under_call_tree(segments, ctrl_idx)
               end
             end
 
@@ -299,6 +300,7 @@ module Catpm
                   seg[:parent_index] = tree_parent ? (tree_parent + base_idx) : (ctrl_idx || 0)
                   segments << seg
                 end
+                reparent_under_call_tree(segments, ctrl_idx)
               end
             end
 
@@ -434,6 +436,45 @@ module Catpm
 
       private
 
+      # Re-parent non-code segments (sql, cache, etc.) under call tree code segments
+      # when their offset falls within the code segment's time range.
+      # This gives proper nesting: code → sql, instead of both being siblings under controller.
+      def reparent_under_call_tree(segments, ctrl_idx)
+        # Build index of code segments with their time ranges: [index, offset, end]
+        code_nodes = []
+        segments.each_with_index do |seg, i|
+          next unless seg[:type] == 'code' && seg[:offset] && seg[:duration]
+          code_nodes << [i, seg[:offset].to_f, seg[:offset].to_f + seg[:duration].to_f]
+        end
+        return if code_nodes.empty?
+
+        segments.each_with_index do |seg, i|
+          # Only reparent direct children of controller that aren't code segments
+          next if seg[:type] == 'code' || seg[:type] == 'controller' || seg[:type] == 'request'
+          next unless seg[:parent_index] == ctrl_idx
+          next unless seg[:offset]
+
+          seg_offset = seg[:offset].to_f
+
+          # Find the innermost (deepest-nested) code node that contains this segment.
+          # Innermost = the one with the smallest duration among all containing nodes.
+          best_idx = nil
+          best_dur = Float::INFINITY
+
+          code_nodes.each do |code_i, code_start, code_end|
+            next unless seg_offset >= code_start && seg_offset < code_end
+
+            dur = code_end - code_start
+            if dur < best_dur
+              best_dur = dur
+              best_idx = code_i
+            end
+          end
+
+          seg[:parent_index] = best_idx if best_idx
+        end
+      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

data/lib/catpm/configuration.rb

@@ -14,7 +14,13 @@ module Catpm
     # Estimated per-request memory for instrumentation budget
     ESTIMATED_BYTES_PER_STACK_SAMPLE = 10_000  # ~10 KB: backtrace_locations array (~100 frames × ~100 bytes)
     ESTIMATED_BYTES_PER_SEGMENT = 500          # segment hash with strings
-    DEFAULT_SEGMENTS_ESTIMATE = 200            # used when max_segments_per_request is nil
+
+    # Within per-request instrumentation budget, split between stack samples and segments
+    STACK_SAMPLES_BUDGET_SHARE = 0.7
+    SEGMENT_BUDGET_SHARE = 0.3
+    MIN_EFFECTIVE_STACK_SAMPLES = 10
+    MIN_EFFECTIVE_SEGMENTS = 20
+    MAX_EFFECTIVE_SEGMENTS = 1000
 
     # Boolean / non-numeric settings — plain attr_accessor
     attr_accessor :enabled,
@@ -152,6 +158,31 @@ module Catpm
       (budget_bytes / estimated_instrumented_request_bytes).clamp(1, 1000).to_i
     end
 
+    # Stack samples per request, auto-derived from max_memory when not explicitly set.
+    # Ensures per-request memory fits within the instrumentation budget.
+    def effective_max_stack_samples_per_request
+      if max_stack_samples_per_request
+        [max_stack_samples_per_request, StackSampler::HARD_SAMPLE_CAP].min
+      else
+        return StackSampler::HARD_SAMPLE_CAP unless instrument_stack_sampler || instrument_call_tree
+
+        per_request_budget = max_memory * 1_048_576 * INSTRUMENTATION_BUDGET_SHARE
+        stack_budget = per_request_budget * STACK_SAMPLES_BUDGET_SHARE
+        (stack_budget / ESTIMATED_BYTES_PER_STACK_SAMPLE).to_i.clamp(MIN_EFFECTIVE_STACK_SAMPLES, StackSampler::HARD_SAMPLE_CAP)
+      end
+    end
+
+    # Segments per request, auto-derived from max_memory when not explicitly set.
+    def effective_max_segments_per_request
+      return max_segments_per_request if max_segments_per_request
+
+      per_request_budget = max_memory * 1_048_576 * INSTRUMENTATION_BUDGET_SHARE
+      use_sampler = instrument_stack_sampler || instrument_call_tree
+      segment_share = use_sampler ? SEGMENT_BUDGET_SHARE : 0.9
+      segment_budget = per_request_budget * segment_share
+      (segment_budget / ESTIMATED_BYTES_PER_SEGMENT).to_i.clamp(MIN_EFFECTIVE_SEGMENTS, MAX_EFFECTIVE_SEGMENTS)
+    end
+
     def slow_threshold_for(kind)
       slow_threshold_per_kind.fetch(kind.to_sym, slow_threshold)
     end
@@ -184,12 +215,10 @@ module Catpm
       bytes = 0
 
       if instrument_stack_sampler || instrument_call_tree
-        samples = max_stack_samples_per_request || StackSampler::HARD_SAMPLE_CAP
-        bytes += samples * ESTIMATED_BYTES_PER_STACK_SAMPLE
+        bytes += effective_max_stack_samples_per_request * ESTIMATED_BYTES_PER_STACK_SAMPLE
       end
 
-      segments = max_segments_per_request || DEFAULT_SEGMENTS_ESTIMATE
-      bytes += segments * ESTIMATED_BYTES_PER_SEGMENT
+      bytes += effective_max_segments_per_request * ESTIMATED_BYTES_PER_SEGMENT
 
       [bytes, 50_000].max # minimum 50 KB estimate per request
     end

data/lib/catpm/flusher.rb

@@ -243,6 +243,22 @@ module Catpm
     # Trim excess samples AFTER insert. Simpler and guaranteed correct —
     # no stale-cache issues when a single flush batch crosses the limit.
     def trim_samples(samples)
+      # Errors: per-fingerprint cap (keep newest within each fingerprint)
+      # Query DB for all fingerprints that exceed the limit — the current batch
+      # may not contain error samples, so this runs regardless of batch contents.
+      max_err_fp = Catpm.config.max_error_samples_per_fingerprint
+      if max_err_fp
+        over_limit_fps = Catpm::Sample
+          .where(sample_type: 'error')
+          .group(:error_fingerprint)
+          .having('COUNT(*) > ?', max_err_fp)
+          .pluck(:error_fingerprint)
+
+        over_limit_fps.each do |fp|
+          trim_by_column(Catpm::Sample.where(sample_type: 'error', error_fingerprint: fp), max_err_fp, :recorded_at)
+        end
+      end
+
       return if samples.empty?
 
       endpoint_keys = samples.map { |s| s[:bucket_key][0..2] }.uniq
@@ -258,16 +274,6 @@ module Catpm
         # Slow: keep highest-duration N
         max_slow = Catpm.config.max_slow_samples_per_endpoint
         trim_by_column(endpoint_scope.where(sample_type: 'slow'), max_slow, :duration) if max_slow
-
-      end
-
-      # Errors: per-fingerprint cap (keep newest within each fingerprint)
-      max_err_fp = Catpm.config.max_error_samples_per_fingerprint
-      if max_err_fp
-        fps = samples.filter_map { |s| s[:error_fingerprint] }.uniq
-        fps.each do |fp|
-          trim_by_column(Catpm::Sample.where(sample_type: 'error', error_fingerprint: fp), max_err_fp, :recorded_at)
-        end
       end
     end
 

data/lib/catpm/middleware.rb

@@ -17,7 +17,7 @@ module Catpm
       if Catpm.config.instrument_segments && Collector.should_instrument_request?
         use_sampler = Catpm.config.instrument_stack_sampler || Catpm.config.instrument_call_tree
         req_segments = RequestSegments.new(
-          max_segments: Catpm.config.max_segments_per_request,
+          max_segments: Catpm.config.effective_max_segments_per_request,
           request_start: env['catpm.request_start'],
           stack_sample: use_sampler,
           call_tree: Catpm.config.instrument_call_tree

data/lib/catpm/stack_sampler.rb

@@ -85,9 +85,7 @@ module Catpm
 
     # Called by SamplingLoop from the global thread
     def capture(now)
-      max = Catpm.config.max_stack_samples_per_request
-      cap = max ? [max, HARD_SAMPLE_CAP].min : HARD_SAMPLE_CAP
-      return if @samples.size >= cap
+      return if @samples.size >= Catpm.config.effective_max_stack_samples_per_request
 
       locs = @target&.backtrace_locations
       @samples << [now, locs] if locs

data/lib/catpm/trace.rb

@@ -87,7 +87,7 @@ module Catpm
         use_sampler = config.instrument_stack_sampler || config.instrument_call_tree
         start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         req_segments = RequestSegments.new(
-          max_segments: config.max_segments_per_request,
+          max_segments: config.effective_max_segments_per_request,
           request_start: start_time,
           stack_sample: use_sampler,
           call_tree: config.instrument_call_tree

data/lib/catpm/version.rb

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

metadata

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