catpm 0.10.0 → 0.10.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0283e922a2169d04e59405a273250c1fd226b4b72731f01ba6f6495b6a216ce2'
-  data.tar.gz: 5af58e9875ee9ce18afc02816e79d94cb025025218b78695e560a7a662ce2953
+  metadata.gz: 3b2fde17350e1e195b3e7aa1cf8084b435d474c8d73aee1e83b2924cf8809a40
+  data.tar.gz: 253e27024b75ef3a5d1cb538b87275afbe373b9645b41d56ff751d86c3c27612
 SHA512:
-  metadata.gz: 0e73b3ea6819f8633104be971da72ad30c5de1b13bc4e0bece856d1e13b5987c705fb322f48c91622ae87d8acbd6b3d71ff0d2bb151939370a2685f4cf0ec7a7
-  data.tar.gz: 988f46467fbf05398f71cefff884584fb1daf2b148500df100b0824049d2cc659e5e74038e65c8de30cec27b36aaa6d503c5267475b8b4c7313e35b4e208e375
+  metadata.gz: dd586cd99584f463ef1c77e25c8c4e2c0920dc66115528c90a53af483e3601f1b1d4a554c9b80e0f403174ceb67fa5e3956d10a60d4c96c206f1669bd74d7c0d
+  data.tar.gz: 74fc43ecc58017374a011982100e1780ff44e7c068b36c814626be37e85ac517b658527e7021bd7ea2b500b499935b807745cb52a54989f1e23b413f093cd90a

data/README.md

@@ -1,5 +1,5 @@
 gem build catpm.gemspec
-gem push catpm-0.9.7.gem
+gem push catpm-0.10.1.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
 
@@ -200,6 +201,10 @@ module Catpm
 
         duration = event.duration
         exception = payload[:exception_object]
+        owns_segments = payload[:_catpm_job_owns_segments]
+
+        req_segments = Thread.current[:catpm_request_segments] if owns_segments
+        instrumented = !req_segments.nil?
 
         queue_wait = if job.respond_to?(:enqueued_at) && job.enqueued_at
           ((Time.current - job.enqueued_at.to_time) * 1000.0) rescue nil
@@ -207,21 +212,110 @@ module Catpm
 
         metadata = { queue_wait: queue_wait }.compact
 
+        if req_segments
+          segment_data = req_segments.to_h
+          segment_data[:segment_summary].each { |k, v| metadata[k] = v }
+        end
+
+        metadata[:_instrumented] = 1 if instrumented
+
         sample_type = early_sample_type(
           error: exception,
           duration: duration,
           kind: :job,
           target: target,
-          operation: job.queue_name
+          operation: job.queue_name,
+          instrumented: instrumented
         )
 
-        context = if sample_type
-          {
+        context = nil
+        if sample_type
+          context = {
             job_class: target,
             job_id: job.job_id,
             queue: job.queue_name,
             attempts: job.executions
           }
+
+          if req_segments
+            segments = segment_data[:segments]
+            collapse_code_wrappers(segments)
+
+            # Inject root job segment with full duration
+            root_segment = {
+              type: 'request',
+              detail: "job #{target}",
+              duration: duration.round(2),
+              offset: 0.0
+            }
+            segments.each do |seg|
+              if seg.key?(:parent_index)
+                seg[:parent_index] += 1
+              else
+                seg[:parent_index] = 0
+              end
+            end
+            segments.unshift(root_segment)
+
+            # Inject call tree segments from sampler
+            ctrl_idx = segments.index { |s| s[:type] == 'controller' }
+            if Catpm.config.instrument_call_tree && req_segments
+              tree_segs = req_segments.call_tree_segments
+              if tree_segs.any?
+                base_idx = segments.size
+                tree_segs.each do |seg|
+                  tree_parent = seg.delete(:_tree_parent)
+                  seg[:parent_index] = tree_parent ? (tree_parent + base_idx) : (ctrl_idx || 0)
+                  segments << seg
+                end
+                reparent_under_call_tree(segments, ctrl_idx)
+              end
+            end
+
+            # Fill untracked controller time with sampler data or synthetic segment
+            ctrl_idx = segments.index { |s| s[:type] == 'controller' }
+            if ctrl_idx
+              ctrl_seg = segments[ctrl_idx]
+              ctrl_dur = (ctrl_seg[:duration] || 0).to_f
+              child_dur = segments.each_with_index.sum do |pair|
+                seg, i = pair
+                next 0.0 if i == ctrl_idx
+                (seg[:parent_index] == ctrl_idx) ? (seg[:duration] || 0).to_f : 0.0
+              end
+              gap = ctrl_dur - child_dur
+
+              if gap > MIN_GAP_MS && Catpm.config.show_untracked_segments
+                inject_gap_segments(segments, req_segments, gap, ctrl_idx, ctrl_seg)
+              end
+            end
+
+            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 exception
+              error_parent = ctrl_idx || 0
+              error_offset = if ctrl_idx
+                ctrl = segments[ctrl_idx]
+                ((ctrl[:offset] || 0) + (ctrl[:duration] || 0)).round(2)
+              else
+                duration.round(2)
+              end
+
+              context[:segments] << {
+                type: 'error',
+                detail: "#{exception.class.name}: #{exception.message}".truncate(Catpm.config.max_error_detail_length),
+                source: exception.backtrace&.first,
+                duration: 0,
+                offset: error_offset,
+                parent_index: error_parent
+              }
+            end
+          end
+
+          context = scrub(context)
         end
 
         ev = Event.new(
@@ -239,6 +333,12 @@ module Catpm
         )
 
         Catpm.buffer&.push(ev)
+      ensure
+        if owns_segments
+          req_segments&.release!
+          Collector.end_instrumentation
+          Thread.current[:catpm_request_segments] = nil
+        end
       end
 
       def process_tracked(kind:, target:, operation:, duration:, context:, metadata:, error:, req_segments:)
@@ -299,6 +399,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 +535,102 @@ 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.
+      #
+      # After reparenting, extends code segment durations up the call tree chain
+      # when children (e.g. external HTTP spans) extend beyond the code segment's
+      # sampler-derived duration. This happens because the stack sampler may hit its
+      # sample cap before the code finishes (e.g. during a long I/O call).
+      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?
+
+        # Tolerance for offset matching: spans created via push_span record exact timing,
+        # while call tree code segments start from the first sampler capture (up to one
+        # sampling interval later). Without tolerance, the span's offset falls just before
+        # the code segment's range and reparenting silently fails.
+        sampling_tolerance_ms = Catpm.config.stack_sample_interval * 1000.0
+
+        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 - sampling_tolerance_ms) && 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
+
+        # Extend code segment durations when reparented children extend beyond them.
+        # The stack sampler may hit its cap early, producing short code segments that
+        # don't cover the full wall-clock time of long I/O calls within them.
+        extend_call_tree_durations(segments)
+      end
+
+      # Walk all segments; when a child's end time exceeds its parent code segment's
+      # end time, extend the parent (and propagate up the chain).
+      def extend_call_tree_durations(segments)
+        segments.each do |seg|
+          parent_idx = seg[:parent_index]
+          next unless parent_idx
+
+          parent = segments[parent_idx]
+          next unless parent && parent[:type] == 'code'
+
+          seg_end = (seg[:offset] || 0).to_f + (seg[:duration] || 0).to_f
+          parent_offset = (parent[:offset] || 0).to_f
+          parent_end = parent_offset + (parent[:duration] || 0).to_f
+
+          next unless seg_end > parent_end
+
+          parent[:duration] = (seg_end - parent_offset).round(2)
+
+          # Propagate up the call tree chain
+          propagate_duration_up(segments, parent_idx)
+        end
+      end
+
+      def propagate_duration_up(segments, idx)
+        seg = segments[idx]
+        parent_idx = seg[:parent_index]
+        return unless parent_idx
+
+        parent = segments[parent_idx]
+        return unless parent && parent[:type] == 'code'
+
+        seg_end = (seg[:offset] || 0).to_f + (seg[:duration] || 0).to_f
+        parent_offset = (parent[:offset] || 0).to_f
+        parent_end = parent_offset + (parent[:duration] || 0).to_f
+
+        return unless seg_end > parent_end
+
+        parent[:duration] = (seg_end - parent_offset).round(2)
+        propagate_duration_up(segments, parent_idx)
+      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/segment_subscribers.rb

@@ -51,6 +51,44 @@ module Catpm
       end
     end
 
+    # Subscriber with start/finish callbacks so all segments (SQL, cache, etc.)
+    # fired during a job are automatically captured and nested under the job span.
+    class JobSpanSubscriber
+      def start(_name, _id, payload)
+        return unless Catpm.config.instrument_segments
+
+        job = payload[:job]
+        target = job.class.name
+        return if Catpm.config.ignored?(target)
+
+        if Collector.should_instrument?(:job, target, job.queue_name)
+          use_sampler = Catpm.config.instrument_stack_sampler || Catpm.config.instrument_call_tree
+          start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          req_segments = RequestSegments.new(
+            max_segments: Catpm.config.effective_max_segments_per_request,
+            request_start: start_time,
+            stack_sample: use_sampler,
+            call_tree: Catpm.config.instrument_call_tree
+          )
+          Thread.current[:catpm_request_segments] = req_segments
+
+          index = req_segments.push_span(type: :controller, detail: target, started_at: start_time)
+          payload[:_catpm_job_span_index] = index
+          payload[:_catpm_job_owns_segments] = true
+        end
+      end
+
+      def finish(_name, _id, payload)
+        return unless payload[:_catpm_job_owns_segments]
+
+        req_segments = Thread.current[:catpm_request_segments]
+        return unless req_segments
+
+        req_segments.pop_span(payload[:_catpm_job_span_index])
+        req_segments.stop_sampler
+      end
+    end
+
     IGNORED_SQL_NAMES = Set.new([
       'SCHEMA', 'EXPLAIN',
       'ActiveRecord::SchemaMigration Load',
@@ -65,6 +103,12 @@ module Catpm
           'process_action.action_controller', ControllerSpanSubscriber.new
         )
 
+        if Catpm.config.instrument_jobs
+          @job_span_subscriber = ActiveSupport::Notifications.subscribe(
+            'perform.active_job', JobSpanSubscriber.new
+          )
+        end
+
         @sql_subscriber = ActiveSupport::Notifications.subscribe(
           'sql.active_record'
         ) do |event|
@@ -122,7 +166,7 @@ module Catpm
 
       def unsubscribe!
         [
-          @controller_span_subscriber,
+          @controller_span_subscriber, @job_span_subscriber,
           @sql_subscriber, @instantiation_subscriber,
           @render_template_subscriber, @render_partial_subscriber,
           @cache_read_subscriber, @cache_write_subscriber,
@@ -131,6 +175,7 @@ module Catpm
           ActiveSupport::Notifications.unsubscribe(sub) if sub
         end
         @controller_span_subscriber = nil
+        @job_span_subscriber = nil
         @sql_subscriber = nil
         @instantiation_subscriber = nil
         @render_template_subscriber = 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

@@ -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.2'
 end

metadata

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