catpm 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d64ad9022afec2d8de112617ff00ef0a43900f4d1d0f3c81b24a8d08fe8e18b2
-  data.tar.gz: 6881f8432b4ec2f330b5f17a419e53b68b15c0dd4a7059a98eb0bc43f89dd3a0
+  metadata.gz: 4ee3b0b066416fbb74d3bdecd0397443272118d67a07b339e0d61a7c2f408351
+  data.tar.gz: 5b355e9a18cde63cd975c49300f8f56efa4d8a079e855a3747de518965ff1611
 SHA512:
-  metadata.gz: a64704f846d4d4c5bcd7ecda2703f31e056c8f9861490eafb261560072004513e229dcc99ef1ff47114655b3db4ff81358a3d71f4636149014d4ca8d99a82832
-  data.tar.gz: ed1c75c3508829c7f8a692cf5df3001c6d930b1d7603c815e26b866e54046424e56d5d5bd834a2fc6e49bf01923a1f518e3f7c6d21354bfc51f4a309a12f25cf
+  metadata.gz: '0811e5ecba637add9c81496c180eb65fd4d8864761bb4c4d5c40b0be40ad9f3ca7e5b6e9ce120316ad2ed17f144e68b8953cf3d2ce2721f2b942a9e43aebece4'
+  data.tar.gz: 43434262c2f712032f5cf7e2205ccf2db0638d48c672e89dd2787b90258c1cd861353d21b62b504b53daa576501614e8c3aa1b6105ed6fc8e4655056120478d5

data/app/controllers/catpm/errors_controller.rb

@@ -35,6 +35,48 @@ module Catpm
       @error = Catpm::ErrorRecord.find(params[:id])
       @contexts = @error.parsed_contexts
       @active_error_count = Catpm::ErrorRecord.unresolved.count
+
+      @range, period, bucket_seconds = helpers.parse_range(params[:range] || '24h')
+
+      # 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)
+
+      # Fallback: match error samples by recorded_at from contexts
+      if @samples.empty? && @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)
+        end
+      end
+
+      # Chart from occurrence_buckets (multi-resolution, no dependency on samples)
+      ob = @error.parsed_occurrence_buckets
+
+      # Pick resolution: minute for short ranges, hour for medium, day for long
+      resolution = case @range
+                   when '1h', '6h', '24h' then 'm'
+                   when '1w', '2w', '1m' then 'h'
+                   else 'd'
+      end
+
+      slots = {}
+      cutoff = period.ago.to_i
+      (ob[resolution] || {}).each do |ts_str, count|
+        ts = ts_str.to_i
+        next if ts < cutoff
+        slot_key = (ts / bucket_seconds) * bucket_seconds
+        slots[slot_key] = (slots[slot_key] || 0) + count
+      end
+
+      now_slot = (Time.current.to_i / bucket_seconds) * bucket_seconds
+      @chart_data = 60.times.map { |i| slots[now_slot - (59 - i) * bucket_seconds] || 0 }
+      @chart_times = 60.times.map { |i| Time.at(now_slot - (59 - i) * bucket_seconds).strftime('%H:%M') }
     end
 
     def resolve

data/app/controllers/catpm/events_controller.rb

@@ -81,7 +81,7 @@ 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(20)
+      @samples = Catpm::EventSample.by_name(@name).order(recorded_at: :desc).limit(Catpm.config.events_max_samples_per_name)
 
       @active_error_count = Catpm::ErrorRecord.unresolved.count
     end

data/app/controllers/catpm/samples_controller.rb

@@ -8,6 +8,9 @@ module Catpm
       @context = @sample.parsed_context
       @segments = @context['segments'] || @context[:segments] || []
       @summary = @context['segment_summary'] || @context[:segment_summary] || {}
+      @error_record = if @sample.error_fingerprint.present?
+        Catpm::ErrorRecord.find_by(fingerprint: @sample.error_fingerprint)
+      end
     end
   end
 end

data/app/helpers/catpm/application_helper.rb

@@ -7,14 +7,14 @@ module Catpm
       'sql' => '#b8e4c6', 'view' => '#e4d4f4', 'cache' => '#fdd8b5',
       'http' => '#f9c4c0', 'mailer' => '#e4d4f4', 'storage' => '#fdd8b5',
       'custom' => '#dde2e8', 'code' => '#c8daf0', 'gem' => '#f0e0f0', 'other' => '#e8e8e8', 'controller' => '#b6d9f7',
-      'middleware' => '#f0dfa0', 'request' => '#b6d9f7'
+      'middleware' => '#f0dfa0', 'request' => '#b6d9f7', 'error' => '#fca5a5'
     }.freeze
 
     SEGMENT_TEXT_COLORS = {
       'sql' => '#1a7f37', 'view' => '#6639a6', 'cache' => '#953800',
       'http' => '#a1110a', 'mailer' => '#6639a6', 'storage' => '#953800',
       'custom' => '#4b5563', 'code' => '#3b5998', 'gem' => '#7b3f9e', 'other' => '#9ca3af', 'controller' => '#0550ae',
-      'middleware' => '#7c5c00', 'request' => '#0550ae'
+      'middleware' => '#7c5c00', 'request' => '#0550ae', 'error' => '#991b1b'
     }.freeze
 
     BADGE_CLASSES = {
@@ -32,7 +32,7 @@ module Catpm
       'sql' => 'SQL Queries', 'view' => 'View Renders', 'cache' => 'Cache Ops',
       'http' => 'HTTP Calls', 'mailer' => 'Mailer', 'storage' => 'Storage',
       'custom' => 'Custom', 'code' => 'App Code', 'gem' => 'Gems', 'other' => 'Untracked',
-      'controller' => 'Controller', 'middleware' => 'Middleware', 'request' => 'Request'
+      'controller' => 'Controller', 'middleware' => 'Middleware', 'request' => 'Request', 'error' => 'Error'
     }.freeze
 
     RANGES = {

data/app/models/catpm/error_record.rb

@@ -33,5 +33,20 @@ module Catpm
     rescue JSON::ParserError
       []
     end
+
+    def parsed_occurrence_buckets
+      raw = case occurrence_buckets
+            when Hash then occurrence_buckets
+            when String then JSON.parse(occurrence_buckets)
+            else {}
+      end
+      {
+        'm' => (raw['m'].is_a?(Hash) ? raw['m'] : {}),
+        'h' => (raw['h'].is_a?(Hash) ? raw['h'] : {}),
+        'd' => (raw['d'].is_a?(Hash) ? raw['d'] : {})
+      }
+    rescue JSON::ParserError
+      { 'm' => {}, 'h' => {}, 'd' => {} }
+    end
   end
 end

data/app/models/catpm/sample.rb

@@ -12,6 +12,7 @@ module Catpm
     scope :slow, -> { where(sample_type: 'slow') }
     scope :errors, -> { where(sample_type: 'error') }
     scope :recent, ->(period = 1.hour) { where(recorded_at: period.ago..) }
+    scope :for_error, ->(fingerprint) { where(error_fingerprint: fingerprint) }
 
     def parsed_context
       case context

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

@@ -48,6 +48,19 @@
   </div>
 </div>
 
+<%# ─── Error Frequency Chart ─── %>
+<div class="time-range">
+  <% Catpm::ApplicationHelper::RANGE_KEYS.each do |r| %>
+    <a href="<%= catpm.error_path(@error, range: r) %>" class="<%= 'active' if @range == r %>"><%= r %></a>
+  <% end %>
+</div>
+
+<h2>Error Frequency</h2>
+<%= section_description("Occurrences per time slot over the selected range.") %>
+<div style="border:1px solid var(--border); border-radius:var(--radius); padding:16px; margin-bottom:24px; position:relative">
+  <%= bar_chart_svg(@chart_data, width: 600, height: 180, color: "var(--red, #e5534b)", time_labels: @chart_times) %>
+</div>
+
 <%# ─── Backtrace ─── %>
 <% first_bt = @contexts.first && (@contexts.first["backtrace"] || @contexts.first[:backtrace] || []) %>
 <% if first_bt.any? %>
@@ -55,8 +68,17 @@
   <%= section_description("All occurrences share the same fingerprint and backtrace.") %>
   <div style="border:1px solid var(--border); border-radius:var(--radius); padding:14px; margin-bottom:12px; position:relative">
     <button class="copy-btn" style="position:absolute; top:8px; right:8px" onclick="copyText(this)">Copy</button>
-    <pre class="mono" style="font-size:12px; white-space:pre-wrap; margin:0; line-height:1.8"><% first_bt.first(20).each do |line| %><span class="<%= line.match?(%r{/(gems|ruby|vendor|bundle)/}) ? 'backtrace-lib' : 'backtrace-app' %>"><%= line %></span>
+    <% preview_lines = first_bt.first(10) %>
+    <% remaining_lines = first_bt.drop(10) %>
+    <pre class="mono" style="font-size:12px; white-space:pre-wrap; margin:0; line-height:1.8"><% preview_lines.each do |line| %><span class="<%= line.match?(%r{/(gems|ruby|vendor|bundle)/}) ? 'backtrace-lib' : 'backtrace-app' %>"><%= line %></span>
 <% end %></pre>
+    <% if remaining_lines.any? %>
+      <details style="margin-top:4px">
+        <summary style="cursor:pointer; font-size:12px; color:var(--text-2)">Show full backtrace (<%= first_bt.size %> lines)</summary>
+        <pre class="mono" style="font-size:12px; white-space:pre-wrap; margin:0; line-height:1.8"><% remaining_lines.each do |line| %><span class="<%= line.match?(%r{/(gems|ruby|vendor|bundle)/}) ? 'backtrace-lib' : 'backtrace-app' %>"><%= line %></span>
+<% end %></pre>
+      </details>
+    <% end %>
   </div>
 <% end %>
 
@@ -66,14 +88,14 @@
   <span class="mono" style="word-break:break-all"><%= @error.fingerprint %></span>
 </div>
 
-<%# ─── Occurrences ─── %>
-<% if @contexts.any? %>
-  <h2>Last <%= @contexts.size %> Captured Occurrences</h2>
+<%# ─── Samples ─── %>
+<% if @samples.any? %>
+  <h2>Recent Samples</h2>
+  <%= section_description("Linked request samples for this error. Click to view full details.") %>
   <div class="table-scroll">
   <table>
     <thead>
       <tr>
-        <th>#</th>
         <th>Time</th>
         <th>Duration</th>
         <th>Status</th>
@@ -82,24 +104,42 @@
       </tr>
     </thead>
     <tbody>
-      <% @contexts.each_with_index do |ctx, i| %>
-        <% segments = ctx["segments"] || ctx[:segments] || [] %>
-        <% has_detail = segments.any? %>
-        <tr id="occurrence-<%= i + 1 %>" class="<%= 'expandable' if has_detail %>" data-occurrence="<%= i %>" <% if has_detail %>onclick="toggleOccurrence(this)"<% end %>>
-          <td class="mono text-muted"><% if has_detail %><span class="chevron">&#x25B8;</span> <% end %>#<%= i + 1 %></td>
+      <% @samples.each do |sample| %>
+        <% ctx = sample.parsed_context %>
+        <tr class="clickable-row" onclick="window.location='<%= catpm.sample_path(sample) %>';" style="cursor:pointer">
+          <td><%= time_with_tooltip(sample.recorded_at) %></td>
+          <td class="mono"><%= format_duration(sample.duration) %></td>
+          <td><%= status_badge(ctx["status"] || ctx[:status]) %></td>
+          <td class="mono"><%= sample.bucket&.target || "—" %></td>
+          <td class="mono text-muted"><%= segment_count_summary(ctx["segment_summary"] || ctx[:segment_summary]).presence || "—" %></td>
+        </tr>
+      <% end %>
+    </tbody>
+  </table>
+  </div>
+<% end %>
+
+<%# ─── Legacy Occurrences (for errors without linked samples) ─── %>
+<% if @samples.empty? && @contexts.any? %>
+  <h2>Last <%= @contexts.size %> Captured Occurrences</h2>
+  <div class="table-scroll">
+  <table>
+    <thead>
+      <tr>
+        <th>Time</th>
+        <th>Duration</th>
+        <th>Status</th>
+        <th>Target</th>
+      </tr>
+    </thead>
+    <tbody>
+      <% @contexts.each do |ctx| %>
+        <tr>
           <td><%= time_with_tooltip(ctx["occurred_at"] || ctx[:occurred_at]) %></td>
           <td class="mono"><%= (ctx["duration"] || ctx[:duration]) ? format_duration((ctx["duration"] || ctx[:duration]).to_f) : "—" %></td>
           <td><%= status_badge(ctx["status"] || ctx[:status]) %></td>
           <td class="mono"><%= ctx["target"] || ctx[:target] || "—" %></td>
-          <td class="mono text-muted"><%= segment_count_summary(ctx["segment_summary"] || ctx[:segment_summary]).presence || "—" %></td>
         </tr>
-        <% if has_detail %>
-          <tr id="detail-<%= i %>" style="display:none">
-            <td colspan="6" style="padding:14px; background:var(--bg-1)">
-              <%= render "catpm/shared/segments_waterfall", segments: segments, total_duration: (ctx["duration"] || ctx[:duration] || 1), segments_capped: ctx["segments_capped"] || ctx[:segments_capped], table_id: "segments-table-#{i}" %>
-            </td>
-          </tr>
-        <% end %>
       <% end %>
     </tbody>
   </table>

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

@@ -28,6 +28,10 @@
   <span class="mono"><%= format_duration(@sample.duration) %></span>
   <span class="sep">&middot;</span>
   <span class="text-muted"><%= time_with_tooltip(@sample.recorded_at) %></span>
+  <% if @error_record %>
+    <span class="sep">&middot;</span>
+    <a href="<%= catpm.error_path(@error_record) %>" class="badge badge-error" style="text-decoration:none">Error: <%= @error_record.error_class %></a>
+  <% end %>
 </div>
 
 <%# ─── Request Context + Full JSON side by side ─── %>

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

@@ -131,7 +131,11 @@
             </td>
             <td>
               <div class="bar-container">
-                <div class="bar-fill" style="margin-left:<%= left_pct %>%; width:<%= width_pct %>%; background:<%= bar_color %>"></div>
+                <% if type == 'error' %>
+                  <div style="position:absolute; left:<%= left_pct %>%; top:2px; bottom:2px; width:3px; background:#dc2626; border-radius:2px"></div>
+                <% else %>
+                  <div class="bar-fill" style="margin-left:<%= left_pct %>%; width:<%= width_pct %>%; background:<%= bar_color %>"></div>
+                <% end %>
               </div>
             </td>
           </tr>

data/db/migrate/20250601000001_create_catpm_tables.rb

@@ -32,10 +32,12 @@ class CreateCatpmTables < ActiveRecord::Migration[8.0]
       t.datetime :recorded_at, null: false
       t.float :duration, null: false
       t.json :context
+      t.string :error_fingerprint, limit: 64
     end
 
     add_index :catpm_samples, :recorded_at, name: 'idx_catpm_samples_time'
     add_index :catpm_samples, [:kind, :recorded_at], name: 'idx_catpm_samples_kind_time'
+    add_index :catpm_samples, :error_fingerprint, name: 'idx_catpm_samples_error_fp'
 
     create_table :catpm_errors do |t|
       t.string :fingerprint, null: false, limit: 64
@@ -46,6 +48,7 @@ class CreateCatpmTables < ActiveRecord::Migration[8.0]
       t.datetime :first_occurred_at, null: false
       t.datetime :last_occurred_at, null: false
       t.json :contexts
+      t.json :occurrence_buckets
       t.datetime :resolved_at
     end
 

data/lib/catpm/adapter/base.rb

@@ -32,7 +32,8 @@ module Catpm
                 sample_type: sample_data[:sample_type],
                 recorded_at: sample_data[:recorded_at],
                 duration: sample_data[:duration],
-                context: sample_data[:context]
+                context: sample_data[:context],
+                error_fingerprint: sample_data[:error_fingerprint]
               }
             end
 
@@ -68,8 +69,49 @@ module Catpm
         combined.last(Catpm.config.max_error_contexts)
       end
 
+      # Merge new occurrence timestamps into the multi-resolution bucket structure.
+      # Structure: { "m" => {epoch => count}, "h" => {epoch => count}, "d" => {epoch => count} }
+      # - "m" (minute): kept for 48 hours
+      # - "h" (hour): kept for 90 days
+      # - "d" (day): kept for 2 years
+      def merge_occurrence_buckets(existing, new_times)
+        buckets = parse_occurrence_buckets(existing)
+
+        (new_times || []).each do |t|
+          ts = t.to_i
+          m_key = ((ts / 60) * 60).to_s
+          h_key = ((ts / 3600) * 3600).to_s
+          d_key = ((ts / 86400) * 86400).to_s
+
+          buckets['m'][m_key] = (buckets['m'][m_key] || 0) + 1
+          buckets['h'][h_key] = (buckets['h'][h_key] || 0) + 1
+          buckets['d'][d_key] = (buckets['d'][d_key] || 0) + 1
+        end
+
+        # Compact old entries
+        now = Time.current.to_i
+        cutoff_m = now - 48 * 3600
+        cutoff_h = now - 90 * 86400
+        cutoff_d = now - 2 * 365 * 86400
+
+        buckets['m'].reject! { |k, _| k.to_i < cutoff_m }
+        buckets['h'].reject! { |k, _| k.to_i < cutoff_h }
+        buckets['d'].reject! { |k, _| k.to_i < cutoff_d }
+
+        buckets
+      end
+
       private
 
+      def parse_occurrence_buckets(value)
+        raw = parse_json(value)
+        {
+          'm' => (raw['m'].is_a?(Hash) ? raw['m'] : {}),
+          'h' => (raw['h'].is_a?(Hash) ? raw['h'] : {}),
+          'd' => (raw['d'].is_a?(Hash) ? raw['d'] : {})
+        }
+      end
+
       def parse_json(value)
         case value
         when Hash then value.transform_keys(&:to_s)

data/lib/catpm/adapter/postgresql.rb

@@ -144,16 +144,22 @@ module Catpm
                     merged_contexts = merge_contexts(
                       existing.parsed_contexts, error_data[:new_contexts]
                     )
+                    merged_buckets = merge_occurrence_buckets(
+                      existing.occurrence_buckets, error_data[:occurrence_times]
+                    )
 
                     attrs = {
                       occurrences_count: existing.occurrences_count + error_data[:occurrences_count],
                       last_occurred_at: [existing.last_occurred_at, error_data[:last_occurred_at]].max,
-                      contexts: merged_contexts
+                      contexts: merged_contexts,
+                      occurrence_buckets: merged_buckets
                     }
                     attrs[:resolved_at] = nil if existing.resolved?
 
                     existing.update!(attrs)
                   else
+                    initial_buckets = merge_occurrence_buckets(nil, error_data[:occurrence_times])
+
                     Catpm::ErrorRecord.create!(
                       fingerprint: error_data[:fingerprint],
                       kind: error_data[:kind],
@@ -162,7 +168,8 @@ module Catpm
                       occurrences_count: error_data[:occurrences_count],
                       first_occurred_at: error_data[:first_occurred_at],
                       last_occurred_at: error_data[:last_occurred_at],
-                      contexts: error_data[:new_contexts]
+                      contexts: error_data[:new_contexts],
+                      occurrence_buckets: initial_buckets
                     )
                   end
                 end

data/lib/catpm/adapter/sqlite.rb

@@ -116,16 +116,22 @@ module Catpm
                 merged_contexts = merge_contexts(
                   existing.parsed_contexts, error_data[:new_contexts]
                 )
+                merged_buckets = merge_occurrence_buckets(
+                  existing.occurrence_buckets, error_data[:occurrence_times]
+                )
 
                 attrs = {
                   occurrences_count: existing.occurrences_count + error_data[:occurrences_count],
                   last_occurred_at: [existing.last_occurred_at, error_data[:last_occurred_at]].max,
-                  contexts: merged_contexts.to_json
+                  contexts: merged_contexts.to_json,
+                  occurrence_buckets: merged_buckets.to_json
                 }
                 attrs[:resolved_at] = nil if existing.resolved?
 
                 existing.update!(attrs)
               else
+                initial_buckets = merge_occurrence_buckets(nil, error_data[:occurrence_times])
+
                 Catpm::ErrorRecord.create!(
                   fingerprint: error_data[:fingerprint],
                   kind: error_data[:kind],
@@ -134,7 +140,8 @@ module Catpm
                   occurrences_count: error_data[:occurrences_count],
                   first_occurred_at: error_data[:first_occurred_at],
                   last_occurred_at: error_data[:last_occurred_at],
-                  contexts: error_data[:new_contexts].to_json
+                  contexts: error_data[:new_contexts].to_json,
+                  occurrence_buckets: initial_buckets.to_json
                 )
               end
             end

data/lib/catpm/collector.rb

@@ -8,7 +8,7 @@ module Catpm
 
         payload = event.payload
         target = "#{payload[:controller]}##{payload[:action]}"
-        return if target.start_with?('Catpm::')
+        return if !Catpm.config.track_own_requests && target.start_with?('Catpm::')
         return if Catpm.config.ignored?(target)
 
         duration = event.duration # milliseconds
@@ -95,6 +95,26 @@ module Catpm
 
           # Use full request duration (including middleware) for the event
           duration = total_request_duration
+
+          # 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
+
+            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
         end
 
         ev = Event.new(
@@ -205,6 +225,26 @@ module Catpm
           segment_data[:segment_summary]&.each do |k, v|
             metadata[k] = v
           end
+
+          # 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
 
         ev = Event.new(

data/lib/catpm/configuration.rb

@@ -31,6 +31,7 @@ module Catpm
                   :random_sample_rate,
                   :max_random_samples_per_endpoint,
                   :max_slow_samples_per_endpoint,
+                  :max_error_samples_per_fingerprint,
                   :cleanup_interval,
                   :circuit_breaker_failure_threshold,
                   :circuit_breaker_recovery_timeout,
@@ -39,7 +40,8 @@ module Catpm
                   :backtrace_lines,
                   :shutdown_timeout,
                   :events_enabled,
-                  :events_max_samples_per_name
+                  :events_max_samples_per_name,
+                  :track_own_requests
 
     def initialize
       @enabled = true
@@ -71,15 +73,17 @@ module Catpm
       @random_sample_rate = 20
       @max_random_samples_per_endpoint = 5
       @max_slow_samples_per_endpoint = 5
+      @max_error_samples_per_fingerprint = 20
       @cleanup_interval = 1.hour
       @circuit_breaker_failure_threshold = 5
       @circuit_breaker_recovery_timeout = 60 # seconds
       @sqlite_busy_timeout = 5_000 # milliseconds
       @persistence_batch_size = 100
-      @backtrace_lines = 10
+      @backtrace_lines = nil
       @shutdown_timeout = 5 # seconds
       @events_enabled = false
       @events_max_samples_per_name = 20
+      @track_own_requests = false
     end
 
     def slow_threshold_for(kind)

data/lib/catpm/event.rb

@@ -45,7 +45,7 @@ module Catpm
     end
 
     def success?
-      !error? && (status.nil? || (200..399).cover?(status.to_i))
+      !error?
     end
 
     def bucket_start

data/lib/catpm/flusher.rb

@@ -12,28 +12,54 @@ module Catpm
       @last_cleanup_at = Time.now
       @running = false
       @thread = nil
+      @pid = nil
+      @mutex = Mutex.new
     end
 
     def start
-      return if @running
+      @mutex.synchronize do
+        # After fork(), threads are dead but @running may still be true
+        if @pid && @pid != Process.pid
+          @running = false
+          @thread = nil
+        end
+
+        return if @running
 
-      @running = true
-      @thread = Thread.new do
-        while @running
-          sleep(effective_interval)
-          flush_cycle if @running
+        @running = true
+        @pid = Process.pid
+        @thread = Thread.new do
+          while @running
+            sleep(effective_interval)
+            flush_cycle if @running
+          end
+        rescue => e
+          Catpm.config.error_handler.call(e)
+          retry if @running
         end
-      rescue => e
-        Catpm.config.error_handler.call(e)
-        retry if @running
       end
     end
 
+    # Cheap check called from middleware on every request.
+    # Detects fork (Puma, Unicorn, etc.) and restarts the thread.
+    def ensure_running!
+      return if @running && @thread&.alive? && @pid == Process.pid
+
+      start
+    end
+
     def stop(timeout: Catpm.config.shutdown_timeout)
-      return unless @running
+      thread = nil
 
-      @running = false
-      @thread&.join(timeout)
+      @mutex.synchronize do
+        return unless @running
+
+        @running = false
+        thread = @thread
+        @thread = nil
+      end
+
+      thread&.join(timeout)
       flush_cycle # Final flush
     end
 
@@ -45,26 +71,28 @@ module Catpm
       return if events.empty?
 
       ActiveRecord::Base.connection_pool.with_connection do
-        perf_events, custom_events = events.partition { |e| e.is_a?(Catpm::Event) }
+        ActiveRecord::Base.transaction do
+          perf_events, custom_events = events.partition { |e| e.is_a?(Catpm::Event) }
 
-        if perf_events.any?
-          buckets, samples, errors = aggregate(perf_events)
+          if perf_events.any?
+            buckets, samples, errors = aggregate(perf_events)
 
-          adapter = Catpm::Adapter.current
-          adapter.persist_buckets(buckets)
+            adapter = Catpm::Adapter.current
+            adapter.persist_buckets(buckets)
 
-          bucket_map = build_bucket_map(buckets)
-          samples = rotate_samples(samples)
-          adapter.persist_samples(samples, bucket_map)
-          adapter.persist_errors(errors)
-        end
+            bucket_map = build_bucket_map(buckets)
+            samples = rotate_samples(samples)
+            adapter.persist_samples(samples, bucket_map)
+            adapter.persist_errors(errors)
+          end
 
-        if custom_events.any?
-          event_buckets, event_samples = aggregate_custom_events(custom_events)
+          if custom_events.any?
+            event_buckets, event_samples = aggregate_custom_events(custom_events)
 
-          adapter = Catpm::Adapter.current
-          adapter.persist_event_buckets(event_buckets)
-          adapter.persist_event_samples(event_samples)
+            adapter = Catpm::Adapter.current
+            adapter.persist_event_buckets(event_buckets)
+            adapter.persist_event_samples(event_samples)
+          end
         end
       end
 
@@ -127,10 +155,20 @@ module Catpm
         # TDigest
         bucket[:tdigest].add(event.duration)
 
+        # Compute error fingerprint (used for both samples and error grouping)
+        error_fp = nil
+        if event.error?
+          error_fp = Catpm::Fingerprint.generate(
+            kind: event.kind,
+            error_class: event.error_class,
+            backtrace: event.backtrace
+          )
+        end
+
         # Collect samples
         sample_type = determine_sample_type(event)
         if sample_type
-          samples << {
+          sample_hash = {
             bucket_key: key,
             kind: event.kind,
             sample_type: sample_type,
@@ -138,29 +176,27 @@ module Catpm
             duration: event.duration,
             context: event.context
           }
+          sample_hash[:error_fingerprint] = error_fp if error_fp
+          samples << sample_hash
         end
 
         # Error grouping
-        if event.error?
-          fp = Catpm::Fingerprint.generate(
-            kind: event.kind,
-            error_class: event.error_class,
-            backtrace: event.backtrace
-          )
-
-          error = error_groups[fp] ||= {
-            fingerprint: fp,
+        if error_fp
+          error = error_groups[error_fp] ||= {
+            fingerprint: error_fp,
             kind: event.kind,
             error_class: event.error_class,
             message: event.error_message,
             occurrences_count: 0,
             first_occurred_at: event.started_at,
             last_occurred_at: event.started_at,
-            new_contexts: []
+            new_contexts: [],
+            occurrence_times: []
           }
 
           error[:occurrences_count] += 1
           error[:last_occurred_at] = [ error[:last_occurred_at], event.started_at ].max
+          error[:occurrence_times] << event.started_at
 
           if error[:new_contexts].size < Catpm.config.max_error_contexts
             error[:new_contexts] << build_error_context(event)
@@ -237,6 +273,14 @@ module Catpm
               sample[:_skip] = true
             end
           end
+        when 'error'
+          fp = sample[:error_fingerprint]
+          if fp
+            existing = Catpm::Sample.where(sample_type: 'error', error_fingerprint: fp)
+            if existing.count >= Catpm.config.max_error_samples_per_fingerprint
+              existing.order(recorded_at: :asc).first.destroy
+            end
+          end
         end
       end
 
@@ -248,7 +292,11 @@ module Catpm
         occurred_at: event.started_at.iso8601,
         kind: event.kind,
         operation: event.context.slice(:method, :path, :params, :job_class, :job_id, :queue, :target, :metadata),
-        backtrace: (event.backtrace || []).first(Catpm.config.backtrace_lines),
+        backtrace: begin
+          bt = event.backtrace || []
+          limit = Catpm.config.backtrace_lines
+          limit ? bt.first(limit) : bt
+        end,
         duration: event.duration,
         status: event.status
       }

data/lib/catpm/lifecycle.rb

@@ -10,17 +10,11 @@ module Catpm
         initialize_flusher
         apply_patches
 
-        # Always start the flusher in the current process.
-        # For forking servers, also register post-fork hooks
-        # so each worker restarts its own flusher.
+        # Start the flusher in the current process.
+        # For forking servers (Puma, Passenger, Unicorn, etc.),
+        # the middleware detects fork via PID and restarts automatically.
         Catpm.flusher&.start
 
-        if defined?(::PhusionPassenger)
-          register_passenger_hook
-        elsif defined?(::Pitchfork)
-          register_pitchfork_hook
-        end
-
         register_shutdown_hooks
       end
 
@@ -57,20 +51,6 @@ module Catpm
           jitter: Catpm.config.flush_jitter
         )
       end
-
-      def register_passenger_hook
-        flusher = Catpm.flusher
-        ::PhusionPassenger.on_event(:starting_worker_process) do |forked|
-          flusher&.start if forked
-        end
-      end
-
-      def register_pitchfork_hook
-        flusher = Catpm.flusher
-        ::Pitchfork.configure do |server|
-          server.after_worker_fork { flusher&.start }
-        end
-      end
     end
   end
 end

data/lib/catpm/middleware.rb

@@ -9,6 +9,8 @@ module Catpm
     def call(env)
       return @app.call(env) unless Catpm.enabled?
 
+      Catpm.flusher&.ensure_running!
+
       env['catpm.request_start'] = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
       if Catpm.config.instrument_segments

data/lib/catpm/version.rb

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

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

@@ -20,6 +20,7 @@ Catpm.configure do |config|
   config.instrument_http = true              # Track HTTP requests (default: true)
   config.instrument_jobs = false             # Track ActiveJob (default: false)
   config.instrument_segments = true          # Track SQL/view/cache segments (default: true)
+  # config.track_own_requests = false           # Track catpm dashboard requests (default: false)
   # config.instrument_net_http = false         # Patch Net::HTTP for outbound tracking (default: false)
   # config.instrument_middleware_stack = false # Decompose middleware into per-middleware segments (default: false)
   # config.max_segments_per_request = 50       # Cap segments per request (keeps slowest)

data/lib/tasks/catpm_tasks.rake

@@ -1,6 +1,23 @@
 # frozen_string_literal: true
 
-# desc "Explaining what the task does"
-# task :catpm do
-#   # Task goes here
-# end
+namespace :catpm do
+  desc 'Add missing columns to catpm tables (safe to run multiple times)'
+  task upgrade: :environment do
+    connection = ActiveRecord::Base.connection
+
+    unless connection.column_exists?(:catpm_samples, :error_fingerprint)
+      connection.add_column :catpm_samples, :error_fingerprint, :string, limit: 64
+      connection.add_index :catpm_samples, :error_fingerprint, name: 'idx_catpm_samples_error_fp'
+      puts '[catpm] Added error_fingerprint column to catpm_samples'
+    else
+      puts '[catpm] catpm_samples.error_fingerprint already exists, skipping'
+    end
+
+    unless connection.column_exists?(:catpm_errors, :occurrence_buckets)
+      connection.add_column :catpm_errors, :occurrence_buckets, :json
+      puts '[catpm] Added occurrence_buckets column to catpm_errors'
+    else
+      puts '[catpm] catpm_errors.occurrence_buckets already exists, skipping'
+    end
+  end
+end

metadata

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