catpm 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ee3b0b066416fbb74d3bdecd0397443272118d67a07b339e0d61a7c2f408351
-  data.tar.gz: 5b355e9a18cde63cd975c49300f8f56efa4d8a079e855a3747de518965ff1611
+  metadata.gz: ac5b510824ed9364db9d541a92eb95b1b0339c1972e48c2cfc634817d36d2600
+  data.tar.gz: 6f7f990fd824795ea8b9ef66e51f28e120d45aa960a2d1fb1e42c85f31458021
 SHA512:
-  metadata.gz: '0811e5ecba637add9c81496c180eb65fd4d8864761bb4c4d5c40b0be40ad9f3ca7e5b6e9ce120316ad2ed17f144e68b8953cf3d2ce2721f2b942a9e43aebece4'
-  data.tar.gz: 43434262c2f712032f5cf7e2205ccf2db0638d48c672e89dd2787b90258c1cd861353d21b62b504b53daa576501614e8c3aa1b6105ed6fc8e4655056120478d5
+  metadata.gz: ca29621896898fcf69b876260bb27f68df164931986695905737fee23080e55183a6440292d3a8f60f2668c417d20cfb39d9219b2882adbaa764a94e1a3345ea
+  data.tar.gz: e8bc348a4c5fe4028403512a8c96f5b60dbc62676167fc41c56710440688aac206ec4b423c2ccd904a5bebef6428a19835af9e10dcc5961141459a9a0dce1073

data/app/controllers/catpm/application_controller.rb

@@ -2,5 +2,13 @@
 
 module Catpm
   class ApplicationController < ActionController::Base
+    private
+
+    def remembered_range
+      if params[:range].present?
+        cookies[:catpm_range] = { value: params[:range], expires: 1.year.from_now }
+      end
+      params[:range] || cookies[:catpm_range]
+    end
   end
 end

data/app/controllers/catpm/endpoints_controller.rb

@@ -8,7 +8,7 @@ module Catpm
       @operation = params[:operation].presence || ''
 
       # Time range filter
-      @range, period, _bucket_seconds = helpers.parse_range(params[:range], extra_valid: ['all'])
+      @range, period, _bucket_seconds = helpers.parse_range(remembered_range, extra_valid: ['all'])
 
       scope = Catpm::Bucket
         .where(kind: @kind, target: @target, operation: @operation)
@@ -23,11 +23,15 @@ module Catpm
         'MAX(duration_max)',
         'MIN(duration_min)',
         'SUM(failure_count)',
-        'SUM(success_count)'
+        'SUM(success_count)',
+        'MIN(bucket_start)',
+        'MAX(bucket_start)'
       )
 
       @count, @duration_sum, @duration_max, @duration_min, @failure_count, @success_count =
-        @aggregate.map { |v| v || 0 }
+        @aggregate[0..5].map { |v| v || 0 }
+      @first_event_at = @aggregate[6]
+      @last_event_at = @aggregate[7]
 
       @avg_duration = @count > 0 ? @duration_sum / @count : 0.0
       @failure_rate = @count > 0 ? @failure_count.to_f / @count : 0.0
@@ -59,5 +63,14 @@ module Catpm
 
       @active_error_count = Catpm::ErrorRecord.unresolved.count
     end
+
+    def destroy
+      kind = params[:kind]
+      target = params[:target]
+      operation = params[:operation].presence || ''
+
+      Catpm::Bucket.where(kind: kind, target: target, operation: operation).destroy_all
+      redirect_to catpm.status_index_path, notice: 'Endpoint deleted'
+    end
   end
 end

data/app/controllers/catpm/errors_controller.rb

@@ -36,7 +36,7 @@ module Catpm
       @contexts = @error.parsed_contexts
       @active_error_count = Catpm::ErrorRecord.unresolved.count
 
-      @range, period, bucket_seconds = helpers.parse_range(params[:range] || '24h')
+      @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)

data/app/controllers/catpm/events_controller.rb

@@ -5,7 +5,7 @@ module Catpm
     PER_PAGE = 25
 
     def index
-      @range, period, bucket_seconds = helpers.parse_range(params[:range])
+      @range, period, bucket_seconds = helpers.parse_range(remembered_range)
 
       recent_buckets = Catpm::EventBucket.recent(period).to_a
 
@@ -59,7 +59,7 @@ module Catpm
 
     def show
       @name = params[:name]
-      @range, period, bucket_seconds = helpers.parse_range(params[:range])
+      @range, period, bucket_seconds = helpers.parse_range(remembered_range)
 
       recent_buckets = Catpm::EventBucket.by_name(@name).recent(period).to_a
 

data/app/controllers/catpm/status_controller.rb

@@ -6,7 +6,7 @@ module Catpm
 
     def index
       # Time range (parsed first — everything below uses this)
-      @range, period, bucket_seconds = helpers.parse_range(params[:range])
+      @range, period, bucket_seconds = helpers.parse_range(remembered_range)
 
       recent_buckets = Catpm::Bucket.recent(period).to_a
 

data/app/controllers/catpm/system_controller.rb

@@ -7,9 +7,6 @@ module Catpm
       @buffer_size = Catpm.buffer&.size || 0
       @buffer_bytes = Catpm.buffer&.current_bytes || 0
       @config = Catpm.config
-      @bucket_count = Catpm::Bucket.count
-      @sample_count = Catpm::Sample.count
-      @error_count = Catpm::ErrorRecord.count
       @oldest_bucket = Catpm::Bucket.minimum(:bucket_start)
       @active_error_count = Catpm::ErrorRecord.unresolved.count
     end

data/app/helpers/catpm/application_helper.rb

@@ -236,7 +236,7 @@ module Catpm
       prev_url = '?' + prev_params.compact.map { |k, v| "#{k}=#{v}" }.join('&')
       next_url = '?' + next_params.compact.map { |k, v| "#{k}=#{v}" }.join('&')
 
-      html = '<div class="pagination">'
+      html = +'<div class="pagination">'
       if current_page > 1
         html << %(<a href="#{prev_url}" class="btn">← Previous</a>)
       else

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

@@ -8,10 +8,15 @@
 
 <%= render "catpm/shared/page_nav", active: "performance" %>
 
-<div class="breadcrumbs">
-  <a href="<%= catpm.status_index_path %>">Performance</a>
-  <span class="sep">/</span>
-  <span><%= @target %></span>
+<div class="breadcrumbs" style="display:flex; align-items:center; justify-content:space-between">
+  <div>
+    <a href="<%= catpm.status_index_path %>">Performance</a>
+    <span class="sep">/</span>
+    <span><%= @target %></span>
+  </div>
+  <%= button_to "Delete Endpoint", catpm.endpoint_path(kind: @kind, target: @target, operation: @operation),
+      method: :delete, class: "btn btn-danger",
+      data: { confirm: "Delete this endpoint and all its data? This cannot be undone." } %>
 </div>
 
 <% ep_params = { kind: @kind, target: @target, operation: @operation } %>
@@ -27,12 +32,12 @@
     <div class="value"><%= @count %></div>
   </div>
   <div class="card">
-    <div class="label">Avg Duration</div>
-    <div class="value"><%= format_duration(@avg_duration) %></div>
+    <div class="label">First Event</div>
+    <div class="value"><%= @first_event_at ? time_with_tooltip(@first_event_at) : "—" %></div>
   </div>
   <div class="card">
-    <div class="label">p95</div>
-    <div class="value"><%= @tdigest ? format_duration(@tdigest.percentile(0.95)) : "—" %></div>
+    <div class="label">Last Event</div>
+    <div class="value"><%= @last_event_at ? time_with_tooltip(@last_event_at) : "—" %></div>
   </div>
   <div class="card">
     <div class="label">Max</div>

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

@@ -34,48 +34,34 @@
   <% end %>
 </div>
 
-<%# ─── Request Context + Full JSON side by side ─── %>
+<%# ─── Request Context ─── %>
 <%
-  ctx_display = @context.except("segments", :segments, "segment_summary", :segment_summary, "segments_capped", :segments_capped, "backtrace", :backtrace)
+  ctx_display = @context.except("segments", :segments, "segment_summary", :segment_summary, "segments_capped", :segments_capped, "backtrace", :backtrace, "method", :method, "path", :path, "status", :status)
   ctx_flat = ctx_display.select { |_, v| !v.is_a?(Hash) && !v.is_a?(Array) }
   ctx_nested = ctx_display.select { |_, v| v.is_a?(Hash) || v.is_a?(Array) }
 %>
 
-<div class="sample-layout">
-  <% if ctx_display.any? %>
-    <div class="sample-sidebar">
-      <h2 style="margin-top:0">Request Context</h2>
-      <% if ctx_flat.any? %>
-        <div class="context-grid" style="margin-bottom:12px">
-          <% ctx_flat.each do |k, v| %>
-            <div class="ctx-key"><%= k %></div>
-            <div class="ctx-val"><%= v.to_s.truncate(200) %></div>
-          <% end %>
-        </div>
-      <% end %>
-      <% if ctx_nested.any? %>
-        <% ctx_nested.each do |k, v| %>
-          <details class="collapsible" open>
-            <summary><%= k %></summary>
-            <div class="details-body">
-              <pre class="mono" style="color:var(--text-1); white-space:pre-wrap; font-size:12px"><%= JSON.pretty_generate(v) rescue v.inspect %></pre>
-            </div>
-          </details>
-        <% end %>
+<% if ctx_display.any? %>
+  <h2>Request Context</h2>
+  <% if ctx_flat.any? %>
+    <div class="context-grid" style="margin-bottom:12px">
+      <% ctx_flat.each do |k, v| %>
+        <div class="ctx-key"><%= k %></div>
+        <div class="ctx-val"><%= v.to_s.truncate(200) %></div>
       <% end %>
     </div>
   <% end %>
-
-  <div class="sample-main">
-    <%# ─── Full JSON ─── %>
-    <details class="collapsible" open>
-      <summary>Full JSON</summary>
-      <div class="details-body">
-        <pre class="mono" style="color:var(--text-1); white-space:pre-wrap; font-size:12px; word-break:break-all"><%= JSON.pretty_generate(@context.except("segments", :segments)) rescue @context.inspect %></pre>
-      </div>
-    </details>
-  </div>
-</div>
+  <% if ctx_nested.any? %>
+    <% ctx_nested.each do |k, v| %>
+      <details class="collapsible" open>
+        <summary><%= k %></summary>
+        <div class="details-body">
+          <pre class="mono" style="color:var(--text-1); white-space:pre-wrap; font-size:12px"><%= JSON.pretty_generate(v) rescue v.inspect %></pre>
+        </div>
+      </details>
+    <% end %>
+  <% end %>
+<% end %>
 
 <%# ─── Time Breakdown (full width, above waterfall) ─── %>
 <% if @summary.any? %>

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

@@ -1,6 +1,8 @@
 <div class="page-nav">
   <a href="<%= catpm.status_index_path %>"<%= ' class="active"'.html_safe if active == "performance" %>>Performance</a>
-  <a href="<%= catpm.events_path %>"<%= ' class="active"'.html_safe if active == "events" %>>Events</a>
+  <% if Catpm.config.events_enabled || Catpm::EventBucket.exists? %>
+    <a href="<%= catpm.events_path %>"<%= ' class="active"'.html_safe if active == "events" %>>Events</a>
+  <% end %>
   <a href="<%= catpm.errors_path %>"<%= ' class="active"'.html_safe if active == "errors" %>>Errors<% if @active_error_count.to_i > 0 %><span class="nav-count alert"><%= @active_error_count %></span><% end %></a>
   <a href="<%= catpm.system_index_path %>"<%= ' class="active"'.html_safe if active == "system" %>>System</a>
 </div>

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

@@ -38,8 +38,8 @@
   <div class="pipeline-node">
     <div class="node-icon"><svg width="28" height="28" viewBox="0 0 28 28" fill="none" stroke="var(--text-2)" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><ellipse cx="14" cy="8" rx="8" ry="4"/><path d="M6 8v12c0 2.2 3.58 4 8 4s8-1.8 8-4V8"/><path d="M6 14c0 2.2 3.58 4 8 4s8-1.8 8-4"/></svg></div>
     <div class="node-label">Database</div>
-    <div class="node-value"><%= @bucket_count %> <span style="font-size:12px;font-weight:400;color:var(--text-2)">buckets</span></div>
-    <div class="node-detail">Aggregated stats are stored as time buckets, plus <%= @sample_count %> detailed samples and <%= @error_count %> error fingerprints.<br><%= @oldest_bucket ? "Data since #{@oldest_bucket.strftime('%b %-d')}, retained #{@config.retention_period ? "#{(@config.retention_period / 1.day).to_i} days" : "forever"}." : "No data yet." %></div>
+    <div class="node-value" style="font-size:14px">Storage</div>
+    <div class="node-detail">Aggregated stats are stored as time buckets, with detailed samples and error fingerprints.<br><%= @oldest_bucket ? "Data since #{@oldest_bucket.strftime('%b %-d')}, retained #{@config.retention_period ? "#{(@config.retention_period / 1.day).to_i} days" : "forever"}." : "No data yet." %></div>
   </div>
 </div>
 

data/config/routes.rb

@@ -5,6 +5,7 @@ Catpm::Engine.routes.draw do
   resources :status, only: [:index]
   resources :system, only: [:index]
   get 'endpoint', to: 'endpoints#show', as: :endpoint
+  delete 'endpoint', to: 'endpoints#destroy'
   resources :samples, only: [:show]
   resources :events, only: [:index, :show], param: :name
   resources :errors, only: [:index, :show, :destroy] do

data/lib/catpm/collector.rb

@@ -13,118 +13,133 @@ module Catpm
 
         duration = event.duration # milliseconds
         status = payload[:status] || (payload[:exception] ? 500 : nil)
-        context = build_http_context(payload)
         metadata = build_http_metadata(payload)
 
         req_segments = Thread.current[:catpm_request_segments]
         if req_segments
           segment_data = req_segments.to_h
-          segments = segment_data[:segments]
 
-          # Compute full request duration from middleware start to now
-          # (event.duration only covers the controller action, not middleware)
+          # Total request duration is always needed (includes middleware time)
           total_request_duration = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - req_segments.request_start) * 1000.0
+          duration = total_request_duration
 
-          # Inject root request segment with full duration
-          root_segment = {
-            type: 'request',
-            detail: "#{payload[:method]} #{payload[:path]}",
-            duration: total_request_duration.round(2),
-            offset: 0.0
-          }
-          segments.each do |seg|
-            if seg.key?(:parent_index)
-              seg[:parent_index] += 1
-            else
-              seg[:parent_index] = 0
+          # Segment summary is always needed for bucket metadata aggregation
+          segment_data[:segment_summary].each { |k, v| metadata[k] = v }
+        end
+
+        # Early sampling decision — only build heavy context for sampled events
+        operation = payload[:method] || 'GET'
+        sample_type = early_sample_type(
+          error: payload[:exception],
+          duration: duration,
+          kind: :http,
+          target: target,
+          operation: operation
+        )
+
+        if sample_type
+          context = build_http_context(payload)
+
+          if req_segments
+            segments = segment_data[:segments]
+
+            # Inject root request segment with full duration
+            root_segment = {
+              type: 'request',
+              detail: "#{payload[:method]} #{payload[:path]}",
+              duration: total_request_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
-          end
-          segments.unshift(root_segment)
-
-          # Inject synthetic middleware segment if there's a time gap before the controller action
-          # (only when real per-middleware segments are not present)
-          ctrl_idx = segments.index { |s| s[:type] == 'controller' }
-          if ctrl_idx
-            has_real_middleware = segments.any? { |s| s[:type] == 'middleware' }
-            ctrl_offset = (segments[ctrl_idx][:offset] || 0.0).to_f
-            if ctrl_offset > 0.5 && !has_real_middleware
-              middleware_seg = {
-                type: 'middleware',
-                detail: 'Middleware Stack',
-                duration: ctrl_offset.round(2),
-                offset: 0.0,
-                parent_index: 0
-              }
-              segments.insert(1, middleware_seg)
-              # Shift parent_index for segments that moved down
-              segments.each_with_index do |seg, i|
-                next if i <= 1
-                next unless seg.key?(:parent_index)
-                seg[:parent_index] += 1 if seg[:parent_index] >= 1
+            segments.unshift(root_segment)
+
+            # Inject synthetic middleware segment if there's a time gap before the controller action
+            # (only when real per-middleware segments are not present)
+            ctrl_idx = segments.index { |s| s[:type] == 'controller' }
+            if ctrl_idx
+              has_real_middleware = segments.any? { |s| s[:type] == 'middleware' }
+              ctrl_offset = (segments[ctrl_idx][:offset] || 0.0).to_f
+              if ctrl_offset > 0.5 && !has_real_middleware
+                middleware_seg = {
+                  type: 'middleware',
+                  detail: 'Middleware Stack',
+                  duration: ctrl_offset.round(2),
+                  offset: 0.0,
+                  parent_index: 0
+                }
+                segments.insert(1, middleware_seg)
+                # Shift parent_index for segments that moved down
+                segments.each_with_index do |seg, i|
+                  next if i <= 1
+                  next unless seg.key?(:parent_index)
+                  seg[:parent_index] += 1 if seg[:parent_index] >= 1
+                end
+                # Add to summary so Time Breakdown shows middleware
+                segment_data[:segment_summary][:middleware_count] = 1
+                segment_data[:segment_summary][:middleware_duration] = ctrl_offset.round(2)
               end
-              # Add to summary so Time Breakdown shows middleware
-              segment_data[:segment_summary][:middleware_count] = 1
-              segment_data[:segment_summary][:middleware_duration] = ctrl_offset.round(2)
             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
+            # 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 > 1.0
-              inject_gap_segments(segments, req_segments, gap, ctrl_idx, ctrl_seg)
+              if gap > 1.0
+                inject_gap_segments(segments, req_segments, gap, ctrl_idx, ctrl_seg)
+              end
             end
-          end
-
-          context[:segments] = segments
-          context[:segment_summary] = segment_data[:segment_summary]
-          context[:segments_capped] = segment_data[:segments_capped]
-
-          segment_data[:segment_summary].each do |k, v|
-            metadata[k] = v
-          end
 
-          # Use full request duration (including middleware) for the event
-          duration = total_request_duration
+            context[:segments] = segments
+            context[:segment_summary] = segment_data[:segment_summary]
+            context[:segments_capped] = segment_data[:segments_capped]
+
+            # Append error marker segment inside the controller
+            if payload[: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
 
-          # Append error marker segment inside the controller
-          if payload[: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)
+              context[:segments] << {
+                type: 'error',
+                detail: "#{payload[:exception].first}: #{payload[:exception].last}".truncate(200),
+                source: payload[:exception_object]&.backtrace&.first,
+                duration: 0,
+                offset: error_offset,
+                parent_index: error_parent
+              }
             end
-
-            context[:segments] << {
-              type: 'error',
-              detail: "#{payload[:exception].first}: #{payload[:exception].last}".truncate(200),
-              source: payload[:exception_object]&.backtrace&.first,
-              duration: 0,
-              offset: error_offset,
-              parent_index: error_parent
-            }
           end
+
+          context = scrub(context)
         end
 
         ev = Event.new(
           kind: :http,
           target: target,
-          operation: payload[:method] || 'GET',
+          operation: operation,
           duration: duration,
           started_at: Time.current,
           status: status,
-          context: scrub(context),
+          context: context,
+          sample_type: sample_type,
           metadata: metadata,
           error_class: payload[:exception]&.first,
           error_message: payload[:exception]&.last,
@@ -149,15 +164,25 @@ module Catpm
           ((Time.current - job.enqueued_at.to_time) * 1000.0) rescue nil
         end
 
-        context = {
-          job_class: target,
-          job_id: job.job_id,
-          queue: job.queue_name,
-          attempts: job.executions
-        }
-
         metadata = { queue_wait: queue_wait }.compact
 
+        sample_type = early_sample_type(
+          error: exception,
+          duration: duration,
+          kind: :job,
+          target: target,
+          operation: job.queue_name
+        )
+
+        context = if sample_type
+          {
+            job_class: target,
+            job_id: job.job_id,
+            queue: job.queue_name,
+            attempts: job.executions
+          }
+        end
+
         ev = Event.new(
           kind: :job,
           target: target,
@@ -165,6 +190,7 @@ module Catpm
           duration: duration,
           started_at: Time.current,
           context: context,
+          sample_type: sample_type,
           metadata: metadata,
           error_class: exception&.class&.name,
           error_message: exception&.message,
@@ -178,73 +204,88 @@ module Catpm
         return unless Catpm.enabled?
         return if Catpm.config.ignored?(target)
 
-        context = (context || {}).dup
         metadata = (metadata || {}).dup
 
         if req_segments
           segment_data = req_segments.to_h
-          segments = segment_data[:segments]
-
-          # Inject root request segment
-          root_segment = {
-            type: 'request',
-            detail: "#{operation.presence || kind} #{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)
-
-          # 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
+          segment_data[:segment_summary]&.each { |k, v| metadata[k] = v }
+        end
 
-            if gap > 1.0
-              inject_gap_segments(segments, req_segments, gap, ctrl_idx, ctrl_seg)
-            end
-          end
+        sample_type = early_sample_type(
+          error: error,
+          duration: duration,
+          kind: kind,
+          target: target,
+          operation: operation
+        )
 
-          context[:segments] = segments
-          context[:segment_summary] = segment_data[:segment_summary]
-          context[:segments_capped] = segment_data[:segments_capped]
+        if sample_type
+          context = (context || {}).dup
 
-          segment_data[:segment_summary]&.each do |k, v|
-            metadata[k] = v
-          end
+          if req_segments && segment_data
+            segments = segment_data[:segments]
+
+            # Inject root request segment
+            root_segment = {
+              type: 'request',
+              detail: "#{operation.presence || kind} #{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)
+
+            # 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
 
-          # Append error marker segment inside the controller
-          if error
-            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)
+              if gap > 1.0
+                inject_gap_segments(segments, req_segments, gap, ctrl_idx, ctrl_seg)
+              end
             end
 
-            context[:segments] << {
-              type: 'error',
-              detail: "#{error.class.name}: #{error.message}".truncate(200),
-              source: error.backtrace&.first,
-              duration: 0,
-              offset: error_offset,
-              parent_index: error_parent
-            }
+            context[:segments] = segments
+            context[:segment_summary] = segment_data[:segment_summary]
+            context[:segments_capped] = segment_data[:segments_capped]
+
+            # Append error marker segment inside the controller
+            if error
+              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: "#{error.class.name}: #{error.message}".truncate(200),
+                source: error.backtrace&.first,
+                duration: 0,
+                offset: error_offset,
+                parent_index: error_parent
+              }
+            end
           end
+
+          context = scrub(context)
+        else
+          context = nil
         end
 
         ev = Event.new(
@@ -254,7 +295,8 @@ module Catpm
           duration: duration,
           started_at: Time.current,
           status: error ? 500 : 200,
-          context: scrub(context),
+          context: context,
+          sample_type: sample_type,
           metadata: metadata,
           error_class: error&.class&.name,
           error_message: error&.message,
@@ -286,6 +328,29 @@ module Catpm
 
       private
 
+      # Determine sample type at event creation time so only sampled events
+      # carry full context in the buffer. Includes filling phase via
+      # process-level counter (resets on restart — acceptable approximation).
+      def early_sample_type(error:, duration:, kind:, target:, operation:)
+        return 'error' if error
+        return 'slow' if duration >= Catpm.config.slow_threshold_for(kind.to_sym)
+
+        # Filling phase: always sample until endpoint has enough random samples
+        endpoint_key = [kind.to_s, target, operation.to_s]
+        count = random_sample_counts[endpoint_key]
+        if count < Catpm.config.max_random_samples_per_endpoint
+          random_sample_counts[endpoint_key] = count + 1
+          return 'random'
+        end
+
+        return 'random' if rand(Catpm.config.random_sample_rate) == 0
+        nil
+      end
+
+      def random_sample_counts
+        @random_sample_counts ||= Hash.new(0)
+      end
+
       def inject_gap_segments(segments, req_segments, gap, ctrl_idx, ctrl_seg)
         sampler_groups = req_segments&.sampler_segments || []
 

data/lib/catpm/event.rb

@@ -23,7 +23,7 @@ module Catpm
       @error_message = error_message
       @backtrace = backtrace
       @sample_type = sample_type
-      @context = context || {}
+      @context = context
       @status = status
     end
 
@@ -61,7 +61,7 @@ module Catpm
     end
 
     def context_bytes
-      return 0 if context.empty?
+      return 0 if context.nil? || context.empty?
 
       context.to_json.bytesize + REF_SIZE
     end

data/lib/catpm/flusher.rb

@@ -123,14 +123,6 @@ module Catpm
       samples = []
       error_groups = {}
 
-      # Pre-load existing random sample counts per endpoint for filling phase
-      @random_sample_counts = {}
-      Catpm::Sample.where(sample_type: 'random')
-        .joins(:bucket)
-        .group('catpm_buckets.kind', 'catpm_buckets.target', 'catpm_buckets.operation')
-        .count
-        .each { |(kind, target, op), cnt| @random_sample_counts[[ kind, target, op ]] = cnt }
-
       events.each do |event|
         # Bucket aggregation
         key = [ event.kind, event.target, event.operation, event.bucket_start ]
@@ -165,8 +157,8 @@ module Catpm
           )
         end
 
-        # Collect samples
-        sample_type = determine_sample_type(event)
+        # Collect samples (pre-determined by collector — only these events carry full context)
+        sample_type = event.sample_type
         if sample_type
           sample_hash = {
             bucket_key: key,
@@ -174,7 +166,7 @@ module Catpm
             sample_type: sample_type,
             recorded_at: event.started_at,
             duration: event.duration,
-            context: event.context
+            context: event.context || {}
           }
           sample_hash[:error_fingerprint] = error_fp if error_fp
           samples << sample_hash
@@ -231,24 +223,6 @@ module Catpm
       }
     end
 
-    def determine_sample_type(event)
-      return 'error' if event.error?
-
-      threshold = Catpm.config.slow_threshold_for(event.kind.to_sym)
-      return 'slow' if event.duration >= threshold
-
-      # Always sample if endpoint has few random samples (filling phase)
-      endpoint_key = [ event.kind, event.target, event.operation ]
-      existing_random = @random_sample_counts[endpoint_key] || 0
-      if existing_random < Catpm.config.max_random_samples_per_endpoint
-        @random_sample_counts[endpoint_key] = existing_random + 1
-        return 'random'
-      end
-
-      return 'random' if rand(Catpm.config.random_sample_rate) == 0
-
-      nil
-    end
 
     def rotate_samples(samples)
       samples.each do |sample|
@@ -288,10 +262,11 @@ module Catpm
     end
 
     def build_error_context(event)
+      event_context = event.context || {}
       ctx = {
         occurred_at: event.started_at.iso8601,
         kind: event.kind,
-        operation: event.context.slice(:method, :path, :params, :job_class, :job_id, :queue, :target, :metadata),
+        operation: event_context.slice(:method, :path, :params, :job_class, :job_id, :queue, :target, :metadata),
         backtrace: begin
           bt = event.backtrace || []
           limit = Catpm.config.backtrace_lines
@@ -303,13 +278,13 @@ module Catpm
 
       ctx[:target] = event.target if event.target.present?
 
-      if event.context[:segments]
-        ctx[:segments] = event.context[:segments]
-        ctx[:segments_capped] = event.context[:segments_capped]
+      if event_context[:segments]
+        ctx[:segments] = event_context[:segments]
+        ctx[:segments_capped] = event_context[:segments_capped]
       end
 
-      if event.context[:segment_summary]
-        ctx[:segment_summary] = event.context[:segment_summary]
+      if event_context[:segment_summary]
+        ctx[:segment_summary] = event_context[:segment_summary]
       end
 
       ctx
@@ -435,14 +410,26 @@ module Catpm
         }
 
         source_ids = buckets.map(&:id)
+        survivor = buckets.first
+
+        # Reassign all samples to the survivor bucket
+        Catpm::Sample.where(bucket_id: source_ids).update_all(bucket_id: survivor.id)
 
-        # Delete source buckets first (to avoid unique constraint conflict
-        # if one source bucket has the same bucket_start as the target)
-        Catpm::Sample.where(bucket_id: source_ids).delete_all
-        Catpm::Bucket.where(id: source_ids).delete_all
+        # Delete non-survivor source buckets (now sample-free)
+        Catpm::Bucket.where(id: source_ids - [survivor.id]).delete_all
 
-        # Create the merged bucket
-        adapter.persist_buckets([merged])
+        # Overwrite survivor with merged data
+        survivor.update!(
+          bucket_start: aligned_start,
+          count: merged[:count],
+          success_count: merged[:success_count],
+          failure_count: merged[:failure_count],
+          duration_sum: merged[:duration_sum],
+          duration_max: merged[:duration_max],
+          duration_min: merged[:duration_min],
+          metadata_sum: merged[:metadata_sum],
+          p95_digest: merged[:p95_digest]
+        )
       end
     end
 

data/lib/catpm/stack_sampler.rb

@@ -4,28 +4,69 @@ module Catpm
   class StackSampler
     SAMPLE_INTERVAL = 0.005 # 5ms
 
+    # Single global thread that samples all active requests.
+    # Avoids creating a thread per request.
+    class SamplingLoop
+      def initialize
+        @mutex = Mutex.new
+        @samplers = []
+        @thread = nil
+      end
+
+      def register(sampler)
+        @mutex.synchronize do
+          @samplers << sampler
+          start_thread unless @thread&.alive?
+        end
+      end
+
+      def unregister(sampler)
+        @mutex.synchronize { @samplers.delete(sampler) }
+      end
+
+      private
+
+      def start_thread
+        @thread = Thread.new do
+          loop do
+            sleep(SAMPLE_INTERVAL)
+            sample_all
+          end
+        end
+        @thread.priority = -1
+      end
+
+      def sample_all
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        targets = @mutex.synchronize { @samplers.dup }
+        targets.each { |s| s.capture(now) }
+      end
+    end
+
+    @loop = SamplingLoop.new
+
+    class << self
+      attr_reader :loop
+    end
+
     def initialize(target_thread:, request_start:)
       @target = target_thread
       @request_start = request_start
       @samples = []
-      @running = false
     end
 
     def start
-      @running = true
-      @thread = Thread.new do
-        while @running
-          locs = @target.backtrace_locations
-          @samples << [Process.clock_gettime(Process::CLOCK_MONOTONIC), locs] if locs
-          sleep(SAMPLE_INTERVAL)
-        end
-      end
-      @thread.priority = -1
+      self.class.loop.register(self)
     end
 
     def stop
-      @running = false
-      @thread&.join(0.1)
+      self.class.loop.unregister(self)
+    end
+
+    # Called by SamplingLoop from the global thread
+    def capture(now)
+      locs = @target.backtrace_locations
+      @samples << [now, locs] if locs
     end
 
     # Returns array of { parent: {segment}, children: [{segment}, ...] }

data/lib/catpm/version.rb

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

metadata

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