catpm 0.9.7 → 0.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 54937b58ef7d18fa437e232b7a660ac014737a6e716daed6e57ab7463dc38e27
-  data.tar.gz: 76cfd9389ecb1f37794806353c2c56f1d7f799a9bf6f9e8c0c975c93b8423c53
+  metadata.gz: 5dab2a97464afff0ad59e3913f7f1aca84505d3ca109966a611eed911d5bb1a7
+  data.tar.gz: aa4c892ce8a39fb2ba5ceacf1aef5f1b9c6c867a682536f67c895d887d93607b
 SHA512:
-  metadata.gz: a948c19294ca90dc60215f58e3d8f6fbdd377f4b62f468eba76678b223af37610d549d4a52ea7f42d7c6fec4ab93952bceeb6e19857ec9c67ecf601a4a1a9b51
-  data.tar.gz: 298c9964d29d3fc9b2570720a7813b30adc5f21c9b7f75e49c288c9fc4f4cd65c4196c798dc05caeb7824ebefb2553cd82b6778a3f1e1a8eeaac4f3d893a703b
+  metadata.gz: dbfa610b0355bf1f99b41c6be9476f622e4f756c75c79764abee15721bb2a729113425b6b81416e86e09f734d253301c36f8b0f577b8b15075c584d0e0728dae
+  data.tar.gz: ebaef872bc07283485e72ef2ccb5b9f14b836f581c66053ed0f7329621e83a5b7e3b58ef7e021cb43c5bdece61d20dda39867c85a73382bef055364424481f16

data/README.md

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

data/app/controllers/catpm/application_controller.rb

@@ -2,23 +2,43 @@
 
 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
+
+    def not_found
+      render 'catpm/shared/not_found', layout: 'catpm/application', status: :not_found
+    end
 
     private
 
+    def render_not_found
+      respond_to do |format|
+        format.html { render 'catpm/shared/record_not_found', layout: 'catpm/application', status: :not_found }
+        format.json { render json: { error: 'not_found' }, status: :not_found }
+      end
+    end
+
     def authenticate!
       if Catpm.config.access_policy
         unless Catpm.config.access_policy.call(request)
-          render plain: "Unauthorized", status: :unauthorized
+          render plain: 'Unauthorized', status: :unauthorized
         end
       elsif Catpm.config.http_basic_auth_user.present? && Catpm.config.http_basic_auth_password.present?
-        authenticate_or_request_with_http_basic("Catpm") do |username, password|
+        authenticate_or_request_with_http_basic('Catpm') do |username, password|
           ActiveSupport::SecurityUtils.secure_compare(username, Catpm.config.http_basic_auth_user) &
             ActiveSupport::SecurityUtils.secure_compare(password, Catpm.config.http_basic_auth_password)
         end
       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/catpm/shared/not_found.html.erb

@@ -0,0 +1,24 @@
+<% content_for :head_extra do %>
+<style>
+  body { display: flex; flex-direction: column; min-height: 100vh; }
+  .not-found-content { flex: 1; display: flex; align-items: center; justify-content: center; }
+  .not-found-inner { text-align: center; padding: 24px; }
+  .not-found-cat {
+    font-family: var(--font-mono); font-size: 14px; line-height: 1.3;
+    color: var(--accent); white-space: pre; margin-bottom: 20px; user-select: none;
+  }
+  .not-found-code { font-size: 13px; color: var(--text-2); font-weight: 500; letter-spacing: 1px; margin-bottom: 24px; }
+  .not-found-link { font-size: 13px; color: var(--accent); }
+  .not-found-link:hover { text-decoration: underline; }
+</style>
+<% end %>
+
+<div class="not-found-content">
+  <div class="not-found-inner">
+    <div class="not-found-cat"> /\_/\
+( o.o )
+ > ^ <</div>
+    <div class="not-found-code">404</div>
+    <a href="<%= catpm.status_index_path %>" class="not-found-link">&larr; Dashboard</a>
+  </div>
+</div>

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

@@ -0,0 +1,24 @@
+<% content_for :head_extra do %>
+<style>
+  body { display: flex; flex-direction: column; min-height: 100vh; }
+  .not-found-content { flex: 1; display: flex; align-items: center; justify-content: center; }
+  .not-found-inner { text-align: center; padding: 24px; }
+  .not-found-paws { font-size: 40px; color: var(--accent); margin-bottom: 20px; letter-spacing: 6px; }
+  .not-found-title { font-size: 15px; font-weight: 600; color: var(--text-0); margin-bottom: 6px; }
+  .not-found-hint { font-size: 13px; color: var(--text-2); max-width: 380px; margin: 0 auto 24px; line-height: 1.6; }
+  .not-found-link { font-size: 13px; color: var(--accent); }
+  .not-found-link:hover { text-decoration: underline; }
+</style>
+<% end %>
+
+<div class="not-found-content">
+  <div class="not-found-inner">
+    <div class="not-found-paws">&#x1F43E;</div>
+    <div class="not-found-title">This record is no longer available</div>
+    <p class="not-found-hint">
+      catpm rotates older performance data to keep memory usage low.
+      This resource was likely purged during a routine cleanup.
+    </p>
+    <a href="<%= catpm.status_index_path %>" class="not-found-link">&larr; Dashboard</a>
+  </div>
+</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/config/routes.rb

@@ -29,4 +29,5 @@ Catpm::Engine.routes.draw do
       patch :toggle_pin
     end
   end
+  match '*unmatched', to: 'application#not_found', via: :all
 end

data/lib/catpm/collector.rb

@@ -6,6 +6,10 @@ module Catpm
     MIN_GAP_MS = 1.0
     DEFAULT_ERROR_STATUS = 500
     DEFAULT_SUCCESS_STATUS = 200
+
+    @instrumentation_mutex = Mutex.new
+    @active_instrumented_count = 0
+
     class << self
       def process_action_controller(event)
         return unless Catpm.enabled?
@@ -118,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
 
@@ -295,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
 
@@ -389,16 +395,86 @@ module Catpm
 
       # For HTTP middleware where endpoint is unknown at start.
       def should_instrument_request?
-        rand(Catpm.config.random_sample_rate) == 0
+        rand(Catpm.config.random_sample_rate) == 0 && try_start_instrumentation
       end
 
       # For track_request where endpoint is known at start.
-      def should_instrument?(_kind, _target, _operation)
-        rand(Catpm.config.random_sample_rate) == 0
+      # Always instruments targets matched by always_sample_targets.
+      def should_instrument?(_kind, target, _operation)
+        if Catpm.config.always_sample?(target)
+          try_start_instrumentation
+        else
+          rand(Catpm.config.random_sample_rate) == 0 && try_start_instrumentation
+        end
+      end
+
+      # Reset the concurrency counter (for tests and config reloads).
+      def reset_instrumentation_counter!
+        @instrumentation_mutex.synchronize { @active_instrumented_count = 0 }
+      end
+
+      # Release an instrumentation slot. Must be called in ensure block
+      # for every request where try_start_instrumentation returned true.
+      def end_instrumentation
+        @instrumentation_mutex.synchronize do
+          @active_instrumented_count = [@active_instrumented_count - 1, 0].max
+        end
+      end
+
+      # Atomically claim an instrumentation slot if within budget.
+      # Returns true if the slot was acquired, false if at capacity.
+      # Already-running instrumented requests are not affected.
+      def try_start_instrumentation
+        @instrumentation_mutex.synchronize do
+          max = Catpm.config.effective_max_concurrent_instrumented
+          return false if @active_instrumented_count >= max
+
+          @active_instrumented_count += 1
+          true
+        end
       end
 
       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
@@ -456,8 +532,9 @@ module Catpm
       # carry full context in the buffer.
       # Non-instrumented requests have no segments — skip sample creation.
       def early_sample_type(error:, duration:, kind:, target:, operation:, instrumented: true)
-        return 'error' if error && instrumented
-        return nil unless instrumented
+        always = Catpm.config.always_sample?(target)
+        return 'error' if error && (instrumented || always)
+        return nil unless instrumented || always
         return 'slow' if duration >= Catpm.config.slow_threshold_for(kind.to_sym)
 
         'random'

data/lib/catpm/configuration.rb

@@ -9,6 +9,18 @@ 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
+    INSTRUMENTATION_BUDGET_SHARE = 0.30  # 30% of max_memory for concurrent instrumented requests
+
+    # 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
+
+    # 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,
@@ -30,7 +42,8 @@ module Catpm
                   :events_enabled,
                   :track_own_requests,
                   :downsampling_thresholds,
-                  :show_untracked_segments
+                  :show_untracked_segments,
+                  :always_sample_targets
 
     # Numeric settings that must be positive numbers (nil not allowed)
     REQUIRED_NUMERIC = %i[
@@ -122,6 +135,7 @@ module Catpm
       @caller_scan_depth = 50
       @instrument_call_tree = false
       @show_untracked_segments = false
+      @always_sample_targets = []
     end
 
     # Buffer gets BUFFER_MEMORY_SHARE of max_memory, scaled by thread count
@@ -135,12 +149,56 @@ module Catpm
       (max_memory * CACHE_ENTRIES_PER_MB * PATH_CACHE_BUDGET_SHARE).to_i
     end
 
+    # Max concurrent instrumented requests derived from max_memory.
+    # Each instrumented request holds stack samples + segments in memory
+    # until the request completes. This limits how many can run at once
+    # so total live instrumentation data stays within budget.
+    def effective_max_concurrent_instrumented
+      budget_bytes = max_memory * 1_048_576 * INSTRUMENTATION_BUDGET_SHARE
+      (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
 
     def ignored?(target)
-      ignored_targets.any? do |pattern|
+      match_target?(ignored_targets, target)
+    end
+
+    def always_sample?(target)
+      match_target?(always_sample_targets, target)
+    end
+
+    private
+
+    def match_target?(patterns, target)
+      patterns.any? do |pattern|
         case pattern
         when Regexp then pattern.match?(target)
         when String
@@ -152,5 +210,17 @@ module Catpm
         end
       end
     end
+
+    def estimated_instrumented_request_bytes
+      bytes = 0
+
+      if instrument_stack_sampler || instrument_call_tree
+        bytes += effective_max_stack_samples_per_request * ESTIMATED_BYTES_PER_STACK_SAMPLE
+      end
+
+      bytes += effective_max_segments_per_request * ESTIMATED_BYTES_PER_SEGMENT
+
+      [bytes, 50_000].max # minimum 50 KB estimate per request
+    end
   end
 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
@@ -33,6 +33,7 @@ module Catpm
     ensure
       req_segments&.stop_sampler
       req_segments&.release!
+      Collector.end_instrumentation if req_segments
       Thread.current[:catpm_request_segments] = nil
       Thread.current[:catpm_request_start] = nil
       Thread.current[:catpm_tracked_instrumented] = nil

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

@@ -75,18 +75,19 @@ module Catpm
   #     process_update(...)
   #   end
   #
-  def self.track_request(kind: :http, target:, operation: '', context: {}, metadata: {})
+  def self.track_request(kind: :http, target:, operation: '', context: {}, metadata: {}, always_sample: false)
     return yield unless enabled?
 
     req_segments = Thread.current[:catpm_request_segments]
     owns_segments = false
 
     if req_segments.nil? && config.instrument_segments
-      if Collector.should_instrument?(kind, target, operation)
+      force = always_sample || config.always_sample?(target)
+      if force ? Collector.try_start_instrumentation : Collector.should_instrument?(kind, target, operation)
         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
@@ -122,6 +123,7 @@ module Catpm
 
       if owns_segments
         req_segments&.release!
+        Collector.end_instrumentation
         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

data/lib/catpm/version.rb

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

data/lib/catpm.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: catpm
 version: !ruby/object:Gem::Version
-  version: 0.9.7
+  version: 0.10.1
 platform: ruby
 authors:
 - ''
@@ -66,6 +66,8 @@ files:
 - app/views/catpm/samples/show.html.erb
 - app/views/catpm/shared/_page_nav.html.erb
 - app/views/catpm/shared/_segments_waterfall.html.erb
+- app/views/catpm/shared/not_found.html.erb
+- app/views/catpm/shared/record_not_found.html.erb
 - app/views/catpm/status/index.html.erb
 - app/views/catpm/system/index.html.erb
 - app/views/catpm/system/pipeline.html.erb