catpm 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ac5b510824ed9364db9d541a92eb95b1b0339c1972e48c2cfc634817d36d2600
-  data.tar.gz: 6f7f990fd824795ea8b9ef66e51f28e120d45aa960a2d1fb1e42c85f31458021
+  metadata.gz: 30a794032ccb0fcb32152d5ae6c7285758260c6a80c5241c217924a887040885
+  data.tar.gz: 7691f6480aa62e4efd41d657fda9e1501a2765584a3d926a5d9ac3a8b6ac0c98
 SHA512:
-  metadata.gz: ca29621896898fcf69b876260bb27f68df164931986695905737fee23080e55183a6440292d3a8f60f2668c417d20cfb39d9219b2882adbaa764a94e1a3345ea
-  data.tar.gz: e8bc348a4c5fe4028403512a8c96f5b60dbc62676167fc41c56710440688aac206ec4b423c2ccd904a5bebef6428a19835af9e10dcc5961141459a9a0dce1073
+  metadata.gz: c902a837f12312f1f856d232b056eb3669c8648f5907e5088ced55972888d64682749f937a994d79b040688d1f59d929dccd11a1d28ffdcfe4e25f2458c02f49
+  data.tar.gz: 73dd36a0cb7ea32b405388bb62f54e9f327f30155b3b30794101feb056abe70b7b747cd5dda3dc67e6669e4289392964b37ae76385e6cb680c96e5a5bb550d55

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(remembered_range, extra_valid: ['all'])
+      @range, period, bucket_seconds = helpers.parse_range(remembered_range)
 
       scope = Catpm::Bucket
         .where(kind: @kind, target: @target, operation: @operation)
@@ -49,14 +49,38 @@ module Catpm
         end
       end
 
+      # Chart data — request volume, errors, avg duration
+      chart_buckets = scope.order(bucket_start: :asc).to_a
+      bucket_seconds = helpers.compute_bucket_seconds(chart_buckets) if @range == 'all'
+
+      if bucket_seconds
+        slots_count = {}
+        slots_errors = {}
+        slots_dur_sum = {}
+        slots_dur_count = {}
+        chart_buckets.each do |b|
+          slot_key = (b.bucket_start.to_i / bucket_seconds) * bucket_seconds
+          slots_count[slot_key] = (slots_count[slot_key] || 0) + b.count
+          slots_errors[slot_key] = (slots_errors[slot_key] || 0) + b.failure_count
+          slots_dur_sum[slot_key] = (slots_dur_sum[slot_key] || 0) + b.duration_sum
+          slots_dur_count[slot_key] = (slots_dur_count[slot_key] || 0) + b.count
+        end
+
+        now_slot = (Time.current.to_i / bucket_seconds) * bucket_seconds
+        @chart_requests = 60.times.map { |i| slots_count[now_slot - (59 - i) * bucket_seconds] || 0 }
+        @chart_errors = 60.times.map { |i| slots_errors[now_slot - (59 - i) * bucket_seconds] || 0 }
+        @chart_durations = 60.times.map do |i|
+          key = now_slot - (59 - i) * bucket_seconds
+          c = slots_dur_count[key] || 0
+          c > 0 ? (slots_dur_sum[key] / c).round(1) : 0
+        end
+        @chart_times = 60.times.map { |i| Time.at(now_slot - (59 - i) * bucket_seconds).strftime('%H:%M') }
+      end
+
       endpoint_samples = Catpm::Sample
         .joins(:bucket)
         .where(catpm_buckets: { kind: @kind, target: @target, operation: @operation })
 
-      if @range != 'all'
-        endpoint_samples = endpoint_samples.where('catpm_samples.recorded_at >= ?', period.ago)
-      end
-
       @slow_samples = endpoint_samples.where(sample_type: 'slow').order(duration: :desc).limit(10)
       @samples = endpoint_samples.where(sample_type: 'random').order(recorded_at: :desc).limit(10)
       @error_samples = endpoint_samples.where(sample_type: 'error').order(recorded_at: :desc).limit(10)

data/app/controllers/catpm/errors_controller.rb

@@ -66,12 +66,36 @@ module Catpm
       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
+      if @range == 'all'
+        # Collect all timestamps to compute dynamic bucket_seconds
+        all_timestamps = []
+        (ob[resolution] || {}).each do |ts_str, count|
+          ts = ts_str.to_i
+          all_timestamps << ts
+          slots[ts] = (slots[ts] || 0) + count
+        end
+        if all_timestamps.any?
+          span = all_timestamps.max - all_timestamps.min
+          span = 3600 if span < 3600
+          bucket_seconds = (span / 60.0).ceil
+        else
+          bucket_seconds = 60
+        end
+        # Re-bucket with computed bucket_seconds
+        rebucketed = {}
+        slots.each do |ts, count|
+          slot_key = (ts / bucket_seconds) * bucket_seconds
+          rebucketed[slot_key] = (rebucketed[slot_key] || 0) + count
+        end
+        slots = rebucketed
+      else
+        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
       end
 
       now_slot = (Time.current.to_i / bucket_seconds) * bucket_seconds

data/app/controllers/catpm/events_controller.rb

@@ -7,11 +7,23 @@ module Catpm
     def index
       @range, period, bucket_seconds = helpers.parse_range(remembered_range)
 
-      recent_buckets = Catpm::EventBucket.recent(period).to_a
+      recent_buckets = if @range == 'all'
+        Catpm::EventBucket.all.to_a
+      else
+        Catpm::EventBucket.recent(period).to_a
+      end
+
+      bucket_seconds = helpers.compute_bucket_seconds(recent_buckets) if @range == 'all'
 
       # Hero metrics
       @total_events = recent_buckets.sum(&:count)
-      period_minutes = period.to_f / 60
+      effective_period = if @range == 'all'
+        earliest = recent_buckets.min_by(&:bucket_start)&.bucket_start
+        earliest ? [Time.current - earliest, 60].max : 3600
+      else
+        period
+      end
+      period_minutes = effective_period.to_f / 60
       @events_per_min = (period_minutes > 0 ? @total_events / period_minutes : 0).round(1)
 
       # Group by name for table
@@ -61,11 +73,23 @@ module Catpm
       @name = params[:name]
       @range, period, bucket_seconds = helpers.parse_range(remembered_range)
 
-      recent_buckets = Catpm::EventBucket.by_name(@name).recent(period).to_a
+      recent_buckets = if @range == 'all'
+        Catpm::EventBucket.by_name(@name).all.to_a
+      else
+        Catpm::EventBucket.by_name(@name).recent(period).to_a
+      end
+
+      bucket_seconds = helpers.compute_bucket_seconds(recent_buckets) if @range == 'all'
 
       # Hero metrics
       @total_count = recent_buckets.sum(&:count)
-      period_minutes = period.to_f / 60
+      effective_period = if @range == 'all'
+        earliest = recent_buckets.min_by(&:bucket_start)&.bucket_start
+        earliest ? [Time.current - earliest, 60].max : 3600
+      else
+        period
+      end
+      period_minutes = effective_period.to_f / 60
       @events_per_min = (period_minutes > 0 ? @total_count / period_minutes : 0).round(1)
       @last_seen = recent_buckets.map(&:bucket_start).max
 

data/app/controllers/catpm/status_controller.rb

@@ -8,7 +8,13 @@ module Catpm
       # Time range (parsed first — everything below uses this)
       @range, period, bucket_seconds = helpers.parse_range(remembered_range)
 
-      recent_buckets = Catpm::Bucket.recent(period).to_a
+      recent_buckets = if @range == 'all'
+        Catpm::Bucket.all.to_a
+      else
+        Catpm::Bucket.recent(period).to_a
+      end
+
+      bucket_seconds = helpers.compute_bucket_seconds(recent_buckets) if @range == 'all'
 
       # Sparkline data
       slots = {}
@@ -31,7 +37,13 @@ module Catpm
 
       recent_count = recent_buckets.sum(&:count)
       recent_failures = recent_buckets.sum(&:failure_count)
-      period_minutes = period.to_f / 60
+      earliest_bucket = recent_buckets.min_by(&:bucket_start)&.bucket_start
+      effective_period = if @range == 'all'
+        earliest_bucket ? [Time.current - earliest_bucket, 60].max : 3600
+      else
+        earliest_bucket ? [[period, Time.current - earliest_bucket].min, 60].max : period
+      end
+      period_minutes = effective_period.to_f / 60
       @recent_avg_duration = recent_count > 0 ? (recent_buckets.sum(&:duration_sum) / recent_count).round(1) : 0.0
       @error_rate = recent_count > 0 ? (recent_failures.to_f / recent_count * 100).round(1) : 0.0
       @requests_per_min = (recent_count / period_minutes).round(1)

data/app/helpers/catpm/application_helper.rb

@@ -116,10 +116,14 @@ module Catpm
       circles = parsed.map.with_index do |(x, y, val), i|
         label = labels ? labels[i] : val.is_a?(Float) ? ('%.1f' % val) : val
         time_attr = time_labels ? %( data-time="#{time_labels[i]}") : ''
-        %(<circle cx="#{x}" cy="#{y}" r="6" fill="transparent" data-value="#{label}"#{time_attr} class="sparkline-dot"/>)
+        %(<circle cx="#{x}" cy="#{y}" r="0" data-value="#{label}"#{time_attr} class="sparkline-dot"/>)
       end.join
 
-      %(<svg width="#{width}" height="#{height}" viewBox="0 0 #{width} #{height}" xmlns="http://www.w3.org/2000/svg" style="display:block;position:relative">#{fill_el}<polyline points="#{coords_str.join(" ")}" fill="none" stroke="#{color}" stroke-width="1.5" stroke-linejoin="round" stroke-linecap="round"/>#{circles}</svg>).html_safe
+      capture = %(<rect width="#{width}" height="#{height}" fill="transparent"/>)
+      highlight = %(<circle cx="0" cy="0" r="3" fill="#{color}" class="sparkline-highlight" style="display:none"/>)
+      vline = %(<line x1="0" y1="0" x2="0" y2="#{height}" stroke="#{color}" stroke-width="0.5" opacity="0.4" class="sparkline-vline" style="display:none"/>)
+
+      %(<svg class="sparkline-chart" width="#{width}" height="#{height}" viewBox="0 0 #{width} #{height}" xmlns="http://www.w3.org/2000/svg" style="display:block">#{capture}#{fill_el}<polyline points="#{coords_str.join(" ")}" fill="none" stroke="#{color}" stroke-width="1.5" stroke-linejoin="round" stroke-linecap="round"/>#{circles}#{vline}#{highlight}</svg>).html_safe
     end
 
     def bar_chart_svg(data_points, width: 600, height: 200, color: 'var(--accent)', time_labels: nil)
@@ -207,16 +211,16 @@ module Catpm
       %(<span class="status-dot"><span class="dot" style="background:#{color}"></span> #{label}</span>).html_safe
     end
 
-    def parse_range(range_str, extra_valid: [])
-      valid = RANGE_KEYS + extra_valid
-      key = valid.include?(range_str) ? range_str : '1h'
-      return [key, nil, nil] if extra_valid.include?(key) && !RANGES.key?(key)
+    def parse_range(range_str)
+      key = (RANGE_KEYS + ['all']).include?(range_str) ? range_str : 'all'
+      return [key, nil, nil] if key == 'all'
       period, bucket_seconds = RANGES[key]
       [key, period, bucket_seconds]
     end
 
     def range_label(range)
       case range
+      when 'all' then 'All time'
       when '6h'  then 'Last 6 hours'
       when '24h' then 'Last 24 hours'
       when '1w'  then 'Last week'
@@ -227,6 +231,14 @@ module Catpm
       end
     end
 
+    def compute_bucket_seconds(buckets)
+      return 60 if buckets.empty?
+      times = buckets.map { |b| b.bucket_start.to_i }
+      span = times.max - times.min
+      span = 3600 if span < 3600
+      (span / 60.0).ceil
+    end
+
     def pagination_nav(current_page, total_count, per_page, extra_params: {})
       total_pages = (total_count.to_f / per_page).ceil
       return '' if total_pages <= 1

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

@@ -21,7 +21,7 @@
 
 <% ep_params = { kind: @kind, target: @target, operation: @operation } %>
 <div class="time-range">
-  <% (Catpm::ApplicationHelper::RANGE_KEYS + ["all"]).each do |r| %>
+  <% (["all"] + Catpm::ApplicationHelper::RANGE_KEYS).each do |r| %>
     <a href="<%= catpm.endpoint_path(ep_params.merge(range: r)) %>" class="<%= 'active' if @range == r %>"><%= r == "all" ? "All" : r %></a>
   <% end %>
 </div>
@@ -106,19 +106,36 @@
     </div>
   </div>
 
-  <div class="grid">
-    <% type_data.each do |d| %>
-      <div class="card">
-        <div class="label">Avg <%= d[:label] %></div>
-        <div class="value"><%= "%.0f" % d[:avg_count] %></div>
-        <div class="detail"><%= format_duration(d[:avg_dur]) %> avg</div>
+<% end %>
+
+<% has_requests = @chart_requests&.any? { |v| v > 0 } %>
+<% has_errors = @chart_errors&.any? { |v| v > 0 } %>
+<% has_durations = @chart_durations&.any? { |v| v > 0 } %>
+<% if has_requests || has_errors || has_durations %>
+  <div class="charts-row">
+    <% if has_requests %>
+      <div class="chart-card">
+        <div class="label">Request Volume</div>
+        <div class="value"><%= @chart_requests.sum %></div>
+        <div class="detail"><%= range_label(@range) %></div>
+        <div class="sparkline"><%= sparkline_svg(@chart_requests, width: 500, height: 64, color: "var(--accent)", fill: true, time_labels: @chart_times) %></div>
       </div>
     <% end %>
-    <% if avg_other > 0 %>
-      <div class="card">
-        <div class="label">Avg Other</div>
-        <div class="value"><%= format_duration(avg_other) %></div>
-        <div class="detail">App code, middleware, etc.</div>
+    <% if has_errors %>
+      <div class="chart-card">
+        <div class="label">Error Volume</div>
+        <div class="value"><%= @chart_errors.sum %></div>
+        <div class="detail"><%= range_label(@range) %></div>
+        <div class="sparkline"><%= sparkline_svg(@chart_errors, width: 500, height: 64, color: "var(--red)", fill: true, time_labels: @chart_times) %></div>
+      </div>
+    <% end %>
+    <% if has_durations %>
+      <div class="chart-card">
+        <div class="label">Avg Duration</div>
+        <% nonzero = @chart_durations.select { |v| v > 0 } %>
+        <div class="value"><%= nonzero.any? ? format_duration(nonzero.sum / nonzero.size) : "—" %></div>
+        <div class="detail"><%= range_label(@range) %></div>
+        <div class="sparkline"><%= sparkline_svg(@chart_durations, width: 500, height: 64, color: "var(--accent)", fill: true, labels: @chart_durations.map { |d| format_duration(d) }, time_labels: @chart_times) %></div>
       </div>
     <% end %>
   </div>

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

@@ -50,16 +50,21 @@
 
 <%# ─── 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>
+  <% (["all"] + Catpm::ApplicationHelper::RANGE_KEYS).each do |r| %>
+    <a href="<%= catpm.error_path(@error, range: r) %>" class="<%= 'active' if @range == r %>"><%= r == "all" ? "All" : 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>
+<% if @chart_data&.any? { |v| v > 0 } %>
+  <div class="charts-row">
+    <div class="chart-card">
+      <div class="label">Error Frequency</div>
+      <div class="value"><%= @chart_data.sum %></div>
+      <div class="detail">occurrences &middot; <%= range_label(@range) %></div>
+      <div class="sparkline"><%= sparkline_svg(@chart_data, width: 500, height: 64, color: "var(--red)", fill: true, time_labels: @chart_times) %></div>
+    </div>
+  </div>
+<% end %>
 
 <%# ─── Backtrace ─── %>
 <% first_bt = @contexts.first && (@contexts.first["backtrace"] || @contexts.first[:backtrace] || []) %>

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

@@ -5,8 +5,8 @@
 
 <%# ─── Time Range ─── %>
 <div class="time-range">
-  <% Catpm::ApplicationHelper::RANGE_KEYS.each do |r| %>
-    <a href="<%= catpm.events_path(range: r) %>" class="<%= 'active' if @range == r %>"><%= r %></a>
+  <% (["all"] + Catpm::ApplicationHelper::RANGE_KEYS).each do |r| %>
+    <a href="<%= catpm.events_path(range: r) %>" class="<%= 'active' if @range == r %>"><%= r == "all" ? "All" : r %></a>
   <% end %>
   <span style="margin-left:auto; font-size:12px; color:var(--text-2)">
     Updated <%= Time.current.strftime("%H:%M:%S") %>

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

@@ -11,8 +11,8 @@
 
 <%# ─── Time Range ─── %>
 <div class="time-range">
-  <% Catpm::ApplicationHelper::RANGE_KEYS.each do |r| %>
-    <a href="<%= catpm.event_path(name: @name, range: r) %>" class="<%= 'active' if @range == r %>"><%= r %></a>
+  <% (["all"] + Catpm::ApplicationHelper::RANGE_KEYS).each do |r| %>
+    <a href="<%= catpm.event_path(name: @name, range: r) %>" class="<%= 'active' if @range == r %>"><%= r == "all" ? "All" : r %></a>
   <% end %>
 </div>
 
@@ -34,12 +34,16 @@
   </div>
 </div>
 
-<%# ─── Bar Chart ─── %>
-<h2>Event Volume</h2>
-<%= section_description("Events 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(--accent)", time_labels: @chart_times) %>
-</div>
+<% if @chart_data&.any? { |v| v > 0 } %>
+  <div class="charts-row">
+    <div class="chart-card">
+      <div class="label">Event Volume</div>
+      <div class="value"><%= @chart_data.sum %></div>
+      <div class="detail"><%= range_label(@range) %></div>
+      <div class="sparkline"><%= sparkline_svg(@chart_data, width: 500, height: 64, color: "var(--accent)", fill: true, time_labels: @chart_times) %></div>
+    </div>
+  </div>
+<% end %>
 
 <%# ─── Recent Samples ─── %>
 <h2>Recent Samples</h2>

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

@@ -5,8 +5,8 @@
 
 <%# ─── Time Range ─── %>
 <div class="time-range">
-  <% Catpm::ApplicationHelper::RANGE_KEYS.each do |r| %>
-    <a href="<%= catpm.status_index_path(range: r) %>" class="<%= 'active' if @range == r %>"><%= r %></a>
+  <% (["all"] + Catpm::ApplicationHelper::RANGE_KEYS).each do |r| %>
+    <a href="<%= catpm.status_index_path(range: r) %>" class="<%= 'active' if @range == r %>"><%= r == "all" ? "All" : r %></a>
   <% end %>
   <span style="margin-left:auto; font-size:12px; color:var(--text-2)">
     Updated <%= Time.current.strftime("%H:%M:%S") %> ·

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

@@ -230,7 +230,17 @@
     .bar-chart-wrap { position: relative; }
     .bar-chart-max { position: absolute; top: 2px; left: 4px; font-size: 11px; color: var(--text-2); font-family: var(--font-sans); pointer-events: none; line-height: 1; }
 
+    /* ─── Charts Row (2-up on wide screens) ─── */
+    .charts-row { display: grid; grid-template-columns: 1fr; gap: 12px; margin-bottom: 20px; }
+    @media (min-width: 900px) { .charts-row { grid-template-columns: 1fr 1fr; } }
+    .chart-card { border: 1px solid var(--border); border-radius: var(--radius); padding: 14px 16px; }
+    .chart-card .label { color: var(--text-1); font-size: 11px; text-transform: uppercase; letter-spacing: 0.5px; font-weight: 500; }
+    .chart-card .value { color: var(--text-0); font-size: 20px; font-weight: 600; margin-top: 2px; line-height: 1.2; }
+    .chart-card .detail { color: var(--text-2); font-size: 12px; margin-top: 4px; }
+    .chart-card .sparkline { margin-top: 8px; }
+
     /* ─── Sparkline Interaction ─── */
+    .sparkline-chart { cursor: default; }
     .sparkline-tip { position: absolute; background: #ffffff; color: var(--text-0); font-size: 11px; font-family: var(--font-sans); padding: 4px 8px; border-radius: 4px; border: 1px solid var(--border); box-shadow: 0 2px 8px rgba(0,0,0,0.12); pointer-events: none; white-space: nowrap; z-index: 10; display: none; line-height: 1.3; }
 
     /* ─── Error Hero ─── */
@@ -344,29 +354,65 @@
       });
     }
 
-    /* Sparkline hover */
+    /* Sparkline hover — snap to nearest point by X */
     var sparkTip = null;
-    var sparkTarget = null;
-    document.addEventListener('mouseover', function(e) {
-      if (!e.target.classList.contains('sparkline-dot')) return;
-      var dot = e.target;
-      sparkTarget = dot;
+    var activeSvg = null;
+
+    function hideSparkline() {
+      if (activeSvg) {
+        var hl = activeSvg.querySelector('.sparkline-highlight');
+        var vl = activeSvg.querySelector('.sparkline-vline');
+        if (hl) hl.style.display = 'none';
+        if (vl) vl.style.display = 'none';
+        activeSvg = null;
+      }
+      if (sparkTip) sparkTip.style.display = 'none';
+    }
+
+    document.addEventListener('mousemove', function(e) {
+      var svg = e.target.closest('.sparkline-chart');
+      if (!svg) { hideSparkline(); return; }
+
+      var rect = svg.getBoundingClientRect();
+      var vb = svg.viewBox.baseVal;
+      var scaleX = vb.width / rect.width;
+      var mouseX = (e.clientX - rect.left) * scaleX;
+
+      var dots = svg.querySelectorAll('.sparkline-dot');
+      var nearest = null, nearestDist = Infinity;
+      for (var i = 0; i < dots.length; i++) {
+        var cx = parseFloat(dots[i].getAttribute('cx'));
+        var dist = Math.abs(cx - mouseX);
+        if (dist < nearestDist) { nearestDist = dist; nearest = dots[i]; }
+      }
+      if (!nearest) { hideSparkline(); return; }
+
+      var nx = nearest.getAttribute('cx');
+      var ny = nearest.getAttribute('cy');
+
+      // Highlight dot
+      var hl = svg.querySelector('.sparkline-highlight');
+      if (hl) { hl.setAttribute('cx', nx); hl.setAttribute('cy', ny); hl.style.display = ''; }
+
+      // Vertical guide line
+      var vl = svg.querySelector('.sparkline-vline');
+      if (vl) { vl.setAttribute('x1', nx); vl.setAttribute('x2', nx); vl.style.display = ''; }
+
+      activeSvg = svg;
+
+      // Tooltip
       if (!sparkTip) { sparkTip = document.createElement('div'); sparkTip.className = 'sparkline-tip'; document.body.appendChild(sparkTip); }
-      var val = dot.dataset.value || '';
-      var time = dot.dataset.time || '';
+      var val = nearest.dataset.value || '';
+      var time = nearest.dataset.time || '';
       sparkTip.innerHTML = '<strong>' + val + '</strong>' + (time ? '<br>' + time : '');
       sparkTip.style.display = 'block';
-    });
-    document.addEventListener('mousemove', function(e) {
-      if (!sparkTip || sparkTip.style.display === 'none') return;
       sparkTip.style.left = (e.pageX) + 'px';
       sparkTip.style.top = (e.pageY + 16) + 'px';
     });
-    document.addEventListener('mouseout', function(e) {
-      if (!e.target.classList.contains('sparkline-dot')) return;
-      sparkTarget = null;
-      if (sparkTip) sparkTip.style.display = 'none';
-    });
+
+    document.addEventListener('mouseleave', function(e) {
+      if (e.target.closest && e.target.closest('.sparkline-chart')) hideSparkline();
+    }, true);
 
     document.addEventListener('keydown', function(e) {
       if (e.target.tagName === 'INPUT' || e.target.tagName === 'TEXTAREA') return;

data/lib/catpm/configuration.rb

@@ -41,7 +41,9 @@ module Catpm
                   :shutdown_timeout,
                   :events_enabled,
                   :events_max_samples_per_name,
-                  :track_own_requests
+                  :track_own_requests,
+                  :stack_sample_interval,
+                  :max_stack_samples_per_request
 
     def initialize
       @enabled = true
@@ -58,7 +60,7 @@ module Catpm
       @slow_threshold_per_kind = {}
       @ignored_targets = []
       @retention_period = nil # nil = keep forever (data is downsampled, not deleted)
-      @max_buffer_memory = 32.megabytes
+      @max_buffer_memory = 8.megabytes
       @flush_interval = 30 # seconds
       @flush_jitter = 5 # ±seconds
       @max_error_contexts = 5
@@ -84,6 +86,8 @@ module Catpm
       @events_enabled = false
       @events_max_samples_per_name = 20
       @track_own_requests = false
+      @stack_sample_interval = 0.005 # seconds (5ms)
+      @max_stack_samples_per_request = 200
     end
 
     def slow_threshold_for(kind)

data/lib/catpm/event.rb

@@ -10,18 +10,24 @@ module Catpm
                   :metadata, :error_class, :error_message, :backtrace,
                   :sample_type, :context, :status
 
+    EMPTY_HASH = {}.freeze
+    private_constant :EMPTY_HASH
+
     def initialize(kind:, target:, operation: '', duration: 0.0, started_at: nil,
-                   metadata: {}, error_class: nil, error_message: nil, backtrace: nil,
-                   sample_type: nil, context: {}, status: nil)
+                   metadata: nil, error_class: nil, error_message: nil, backtrace: nil,
+                   sample_type: nil, context: nil, status: nil)
       @kind = kind.to_s
       @target = target.to_s
       @operation = (operation || '').to_s
       @duration = duration.to_f
       @started_at = started_at || Time.current
-      @metadata = metadata || {}
+      @metadata = metadata || EMPTY_HASH
       @error_class = error_class
       @error_message = error_message
-      @backtrace = backtrace
+      @backtrace = if backtrace
+        limit = Catpm.config.backtrace_lines
+        limit ? backtrace.first(limit) : backtrace
+      end
       @sample_type = sample_type
       @context = context
       @status = status
@@ -67,7 +73,7 @@ module Catpm
     end
 
     def metadata_bytes
-      return 0 if metadata.empty?
+      return 0 if metadata.nil? || metadata.empty?
 
       metadata.to_json.bytesize + REF_SIZE
     end

data/lib/catpm/flusher.rb

@@ -225,23 +225,49 @@ module Catpm
 
 
     def rotate_samples(samples)
+      return samples if samples.empty?
+
+      # Pre-fetch counts for all endpoints and types in bulk
+      endpoint_keys = samples.map { |s| s[:bucket_key][0..2] }.uniq
+      error_fps = samples.filter_map { |s| s[:error_fingerprint] }.uniq
+
+      # Build counts cache: { [kind, target, op, type] => count }
+      counts_cache = {}
+      if endpoint_keys.any?
+        Catpm::Sample.joins(:bucket)
+          .where(catpm_buckets: { kind: endpoint_keys.map(&:first), target: endpoint_keys.map { |k| k[1] }, operation: endpoint_keys.map { |k| k[2] } })
+          .where(sample_type: %w[random slow])
+          .group('catpm_buckets.kind', 'catpm_buckets.target', 'catpm_buckets.operation', 'catpm_samples.sample_type')
+          .count
+          .each { |(kind, target, op, type), cnt| counts_cache[[kind, target, op, type]] = cnt }
+      end
+
+      error_counts = {}
+      if error_fps.any?
+        Catpm::Sample.where(sample_type: 'error', error_fingerprint: error_fps)
+          .group(:error_fingerprint).count
+          .each { |fp, cnt| error_counts[fp] = cnt }
+      end
+
       samples.each do |sample|
-        kind, target, operation = sample[:bucket_key][0], sample[:bucket_key][1], sample[:bucket_key][2]
-        endpoint_samples = Catpm::Sample
-          .joins(:bucket)
-          .where(catpm_buckets: { kind: kind, target: target, operation: operation })
+        kind, target, operation = sample[:bucket_key][0..2]
 
         case sample[:sample_type]
         when 'random'
-          existing = endpoint_samples.where(sample_type: 'random')
-          if existing.count >= Catpm.config.max_random_samples_per_endpoint
-            existing.order(recorded_at: :asc).first.destroy
+          cache_key = [kind, target, operation, 'random']
+          if (counts_cache[cache_key] || 0) >= Catpm.config.max_random_samples_per_endpoint
+            oldest = Catpm::Sample.joins(:bucket)
+              .where(catpm_buckets: { kind: kind, target: target, operation: operation })
+              .where(sample_type: 'random').order(recorded_at: :asc).first
+            oldest&.destroy
           end
         when 'slow'
-          existing = endpoint_samples.where(sample_type: 'slow')
-          if existing.count >= Catpm.config.max_slow_samples_per_endpoint
-            weakest = existing.order(duration: :asc).first
-            if sample[:duration] > weakest.duration
+          cache_key = [kind, target, operation, 'slow']
+          if (counts_cache[cache_key] || 0) >= Catpm.config.max_slow_samples_per_endpoint
+            weakest = Catpm::Sample.joins(:bucket)
+              .where(catpm_buckets: { kind: kind, target: target, operation: operation })
+              .where(sample_type: 'slow').order(duration: :asc).first
+            if weakest && sample[:duration] > weakest.duration
               weakest.destroy
             else
               sample[:_skip] = true
@@ -249,11 +275,10 @@ module Catpm
           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
+          if fp && (error_counts[fp] || 0) >= Catpm.config.max_error_samples_per_fingerprint
+            oldest = Catpm::Sample.where(sample_type: 'error', error_fingerprint: fp)
+              .order(recorded_at: :asc).first
+            oldest&.destroy
           end
         end
       end
@@ -267,11 +292,7 @@ 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: begin
-          bt = event.backtrace || []
-          limit = Catpm.config.backtrace_lines
-          limit ? bt.first(limit) : bt
-        end,
+        backtrace: event.backtrace || [],
         duration: event.duration,
         status: event.status
       }
@@ -377,60 +398,61 @@ module Catpm
       cutoff = age_threshold.ago
       target_seconds = target_interval.to_i
 
-      # Find all buckets older than cutoff
-      source_buckets = Catpm::Bucket.where(bucket_start: ...cutoff).to_a
-      return if source_buckets.empty?
-
-      # Group by (kind, target, operation) + target-aligned bucket_start
-      groups = source_buckets.group_by do |bucket|
-        epoch = bucket.bucket_start.to_i
-        aligned_epoch = epoch - (epoch % target_seconds)
-        aligned_start = Time.at(aligned_epoch).utc
-
-        [bucket.kind, bucket.target, bucket.operation, aligned_start]
-      end
-
-      groups.each do |(kind, target, operation, aligned_start), buckets|
-        # Skip if only one bucket already at the target alignment
-        next if buckets.size == 1 && buckets.first.bucket_start.to_i % target_seconds == 0
+      # Process in batches to avoid loading all old buckets into memory
+      Catpm::Bucket.where(bucket_start: ...cutoff)
+        .select(:id, :kind, :target, :operation, :bucket_start)
+        .group_by { |b| [b.kind, b.target, b.operation] }
+        .each do |(_kind, _target, _operation), endpoint_buckets|
+          groups = endpoint_buckets.group_by do |bucket|
+            epoch = bucket.bucket_start.to_i
+            aligned_epoch = epoch - (epoch % target_seconds)
+            Time.at(aligned_epoch).utc
+          end
 
-        merged = {
-          kind: kind,
-          target: target,
-          operation: operation,
-          bucket_start: aligned_start,
-          count: buckets.sum(&:count),
-          success_count: buckets.sum(&:success_count),
-          failure_count: buckets.sum(&:failure_count),
-          duration_sum: buckets.sum(&:duration_sum),
-          duration_max: buckets.map(&:duration_max).max,
-          duration_min: buckets.map(&:duration_min).min,
-          metadata_sum: merge_bucket_metadata(buckets, adapter),
-          p95_digest: merge_bucket_digests(buckets)
-        }
-
-        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 non-survivor source buckets (now sample-free)
-        Catpm::Bucket.where(id: source_ids - [survivor.id]).delete_all
-
-        # 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
+          groups.each do |aligned_start, stub_buckets|
+            next if stub_buckets.size == 1 && stub_buckets.first.bucket_start.to_i % target_seconds == 0
+
+            # Load full records only for groups that need merging
+            bucket_ids = stub_buckets.map(&:id)
+            buckets = Catpm::Bucket.where(id: bucket_ids).to_a
+
+            merged = {
+              kind: buckets.first.kind,
+              target: buckets.first.target,
+              operation: buckets.first.operation,
+              bucket_start: aligned_start,
+              count: buckets.sum(&:count),
+              success_count: buckets.sum(&:success_count),
+              failure_count: buckets.sum(&:failure_count),
+              duration_sum: buckets.sum(&:duration_sum),
+              duration_max: buckets.map(&:duration_max).max,
+              duration_min: buckets.map(&:duration_min).min,
+              metadata_sum: merge_bucket_metadata(buckets, adapter),
+              p95_digest: merge_bucket_digests(buckets)
+            }
+
+            survivor = buckets.first
+
+            # Reassign all samples to the survivor bucket
+            Catpm::Sample.where(bucket_id: bucket_ids).update_all(bucket_id: survivor.id)
+
+            # Delete non-survivor source buckets (now sample-free)
+            Catpm::Bucket.where(id: bucket_ids - [survivor.id]).delete_all
+
+            # 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
     end
 
     def downsample_event_tier(target_interval:, age_threshold:, adapter:)

data/lib/catpm/segment_subscribers.rb

@@ -171,6 +171,8 @@ module Catpm
 
         duration = event.duration
         sql = payload[:sql].to_s
+        max_len = Catpm.config.max_sql_length
+        sql = sql.truncate(max_len) if max_len && sql.length > max_len
         source = duration >= Catpm.config.segment_source_threshold ? extract_source_location : nil
 
         req_segments.add(

data/lib/catpm/stack_sampler.rb

@@ -2,7 +2,7 @@
 
 module Catpm
   class StackSampler
-    SAMPLE_INTERVAL = 0.005 # 5ms
+    MS_PER_SECOND = 1000.0
 
     # Single global thread that samples all active requests.
     # Avoids creating a thread per request.
@@ -29,7 +29,7 @@ module Catpm
       def start_thread
         @thread = Thread.new do
           loop do
-            sleep(SAMPLE_INTERVAL)
+            sleep(Catpm.config.stack_sample_interval)
             sample_all
           end
         end
@@ -65,6 +65,9 @@ module Catpm
 
     # Called by SamplingLoop from the global thread
     def capture(now)
+      max = Catpm.config.max_stack_samples_per_request
+      return if max && @samples.size >= max
+
       locs = @target.backtrace_locations
       @samples << [now, locs] if locs
     end
@@ -117,7 +120,7 @@ module Catpm
         duration = estimate_duration(group)
         next if duration < 1.0
 
-        offset = ((group[:start_time] - @request_start) * 1000.0).round(2)
+        offset = ((group[:start_time] - @request_start) * MS_PER_SECOND).round(2)
         app_frame = group[:app_frame]
         leaf = group[:leaves].first&.last
 
@@ -199,8 +202,8 @@ module Catpm
 
       spans.filter_map do |span|
         duration = [
-          (span[:end_time] - span[:start_time]) * 1000.0,
-          span[:count] * SAMPLE_INTERVAL * 1000.0
+          (span[:end_time] - span[:start_time]) * MS_PER_SECOND,
+          span[:count] * Catpm.config.stack_sample_interval * MS_PER_SECOND
         ].max
         next if duration < 1.0
 
@@ -211,7 +214,7 @@ module Catpm
           type: classify_path(path),
           detail: build_gem_detail(frame),
           duration: duration.round(2),
-          offset: ((span[:start_time] - @request_start) * 1000.0).round(2),
+          offset: ((span[:start_time] - @request_start) * MS_PER_SECOND).round(2),
           started_at: span[:start_time]
         }
       end
@@ -219,8 +222,8 @@ module Catpm
 
     def estimate_duration(group)
       [
-        (group[:end_time] - group[:start_time]) * 1000.0,
-        group[:count] * SAMPLE_INTERVAL * 1000.0
+        (group[:end_time] - group[:start_time]) * MS_PER_SECOND,
+        group[:count] * Catpm.config.stack_sample_interval * MS_PER_SECOND
       ].max
     end
 

data/lib/catpm/tdigest.rb

@@ -12,6 +12,7 @@ module Catpm
     Centroid = Struct.new(:mean, :weight)
 
     COMPRESSION = 100 # Controls accuracy vs. memory trade-off
+    BUFFER_FLUSH_FACTOR = 2 # Lower = more frequent flushes (better accuracy), higher = fewer flushes (better performance)
 
     attr_reader :count
 
@@ -22,7 +23,7 @@ module Catpm
       @min = Float::INFINITY
       @max = -Float::INFINITY
       @buffer = []
-      @buffer_limit = @compression * 5
+      @buffer_limit = @compression * BUFFER_FLUSH_FACTOR
     end
 
     def add(value, weight = 1)

data/lib/catpm/version.rb

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

metadata

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