roundhouse_ui 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5064ee74f5aea444f5762d2f466f0b4c05d9c7af6c44a48045e6703d48b72587
-  data.tar.gz: 3b5a08f1769a5bd5ee66bdbe5ccd586842373b45530b95cbc4ff6340fe17796e
+  metadata.gz: 11537f41a49c350dbd057961b82994fdc7524afdf3285961a28fa13701daaf57
+  data.tar.gz: aedef27c3202b3d2eaf25a2b9fefb9290df222c66d1fde4ae8414152f3a477cf
 SHA512:
-  metadata.gz: 6d3cf1e161baec06cb4b899d9f97065fb216341716719756c062a140a811bf51997748f9bcc322dc78aaa8ec36d56311decc511b70eea8d53a07a57a5b317b8c
-  data.tar.gz: 15a01ddaa5fa81c37c67516c369d1dac2b795b011e5dad1927b3b70aeed47b365a4938765e78f9eae910da0a39e36fe174d6170ba0226d1eeab404a700f4c218
+  metadata.gz: f4b22e1a716bbbdfdbab62cc5b0dcb10094a3cefbefd7ad1f1a24367e1f383f4c4c1467d1aa840600f860b1bc65b433fbdbdc56da5e1f1c1545f1756a99ed83c
+  data.tar.gz: cbe28c835c0e6413ee88658242e455e39a47cbd124a1e06ee0a9d40106ea9eb3ba49e2491f8dbd6f3a757ad71c0a24f5ead03b0b263b8a96237db3d2f8732b74

data/README.md

@@ -88,6 +88,14 @@ RoundhouseUi.configure do |c|
   # e.g. when you run reliable fetch (super_fetch) instead of RoundhouseUi::Fetch.
   # Default: true.
   # c.pause_enabled = false
+
+  # Seconds between dashboard stat polls (default 5). Raise it if polling shows
+  # up in your traces — each poll re-runs the host's auth/routing on the mount.
+  # c.poll_interval = 10
+
+  # Show the "slowest job classes" table on the Metrics page. Requires the
+  # DurationCollector middleware (see below). Default: false.
+  # c.collect_durations = true
 end
 ```
 
@@ -150,6 +158,29 @@ The **Busy** page's Cancel button flags a job's JID. A queued/scheduled/retrying
 is then skipped when it would next run; a *currently running* job stops only if it
 checks in — e.g. a long loop can `break if RoundhouseUi.cancelled?(jid)`.
 
+## Slowest job classes
+
+Sidekiq doesn't track per-class durations, so Roundhouse can record them itself.
+Install the opt-in server middleware and set `collect_durations = true`; the
+Metrics page then lists the slowest classes by total time (count + average).
+
+```ruby
+# config/initializers/sidekiq.rb
+Sidekiq.configure_server do |config|
+  config.server_middleware { |chain| chain.add RoundhouseUi::DurationCollector }
+end
+```
+
+It's two cheap Redis writes per job (a counter + a summed-ms float) into a single
+hash, and a job failure never propagates from the collector.
+
+## Bulk actions on a filter
+
+On **Retries** and **Dead**, searching narrows the set; with a filter active you
+can retry or delete **every** matching job in one action (not just the visible
+page), capped at 1,000 per run. Gated to when a filter is present so it can't
+become "retry everything", `read_only`-aware, and audit-logged.
+
 ## Observability deep-links
 
 The core depends on nothing — it asks the configured adapter for a URL and renders a link

data/app/controllers/concerns/roundhouse_ui/job_set_browsing.rb

@@ -5,6 +5,7 @@ module RoundhouseUi
     extend ActiveSupport::Concern
 
     PER_PAGE = 25
+    BULK_CAP = 1_000 # safety ceiling on a single match-set action
 
     # Returns [entries_for_page, has_next?]. Scans only far enough to fill the
     # requested page plus one (to know if a next page exists) — never loads the
@@ -32,6 +33,25 @@ module RoundhouseUi
       [ jobs, has_next ]
     end
 
+    # Apply an op ("retry"/"delete") to every entry matching the query, capped at
+    # BULK_CAP. Entries are collected first, then acted on — mutating a Sidekiq set
+    # mid-iteration skips entries. Returns [count_acted_on, capped?].
+    def bulk_apply(set, query, op, cap = BULK_CAP)
+      matches = []
+      capped = false
+      set.each do |entry|
+        next if query.present? && !entry_matches?(entry, query)
+
+        matches << entry
+        if matches.size >= cap
+          capped = true
+          break
+        end
+      end
+      matches.each { |entry| op == "delete" ? entry.delete : entry.retry }
+      [ matches.size, capped ]
+    end
+
     def entry_matches?(entry, query)
       needle = query.downcase
       [ entry.klass, entry.jid, entry.item["error_class"], entry.item["error_message"], entry.args.to_s ]

data/app/controllers/roundhouse_ui/dead_controller.rb

@@ -2,7 +2,7 @@ module RoundhouseUi
   class DeadController < ApplicationController
     include JobSetBrowsing
 
-    before_action :require_writable!, only: %i[requeue destroy bulk]
+    before_action :require_writable!, only: %i[requeue destroy bulk bulk_all]
 
     def index
       @query = params[:q].to_s.strip
@@ -36,6 +36,17 @@ module RoundhouseUi
       redirect_to dead_set_path, notice: "#{verb} #{count} job(s)."
     end
 
+    # Smart bulk: act on EVERY job matching the current filter (not just the
+    # selected/visible ones), capped for safety. Only offered when a filter is
+    # active, so it can't become "retry the entire dead set" by accident.
+    def bulk_all
+      count, capped = bulk_apply(Sidekiq::DeadSet.new, params[:q].to_s.strip, params[:op])
+      verb = params[:op] == "delete" ? "Deleted" : "Re-enqueued"
+      note = "#{verb} #{count} matching job(s)."
+      note += " Stopped at the #{JobSetBrowsing::BULK_CAP} cap — run again for more." if capped
+      redirect_to dead_set_path, notice: note
+    end
+
     private
 
     def require_writable!

data/app/controllers/roundhouse_ui/metrics_controller.rb

@@ -3,6 +3,7 @@ module RoundhouseUi
   class MetricsController < ApplicationController
     def show
       @metrics = Metrics.new
+      @durations = DurationCollector.summary if RoundhouseUi.collect_durations
     end
   end
 end

data/app/controllers/roundhouse_ui/retries_controller.rb

@@ -2,7 +2,7 @@ module RoundhouseUi
   class RetriesController < ApplicationController
     include JobSetBrowsing
 
-    before_action :require_writable!, only: %i[requeue destroy]
+    before_action :require_writable!, only: %i[requeue destroy bulk_all]
 
     def index
       @query = params[:q].to_s.strip
@@ -24,6 +24,16 @@ module RoundhouseUi
       redirect_to retries_path, notice: entry ? "Deleted #{params[:jid]}." : "Job is no longer in the retry set."
     end
 
+    # Smart bulk: retry/delete EVERY job matching the current filter, capped for
+    # safety. Offered only when a filter is active.
+    def bulk_all
+      count, capped = bulk_apply(Sidekiq::RetrySet.new, params[:q].to_s.strip, params[:op])
+      verb = params[:op] == "delete" ? "Deleted" : "Re-enqueued"
+      note = "#{verb} #{count} matching job(s)."
+      note += " Stopped at the #{JobSetBrowsing::BULK_CAP} cap — run again for more." if capped
+      redirect_to retries_path, notice: note
+    end
+
     private
 
     def require_writable!

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

@@ -163,6 +163,27 @@
     .rh-disclose summary::-webkit-details-marker { display:none; }
     .rh-disclose summary::before { content:"▸ "; }
     .rh-disclose[open] summary::before { content:"▾ "; }
+
+    /* connection state — poll failures surface here instead of silently going stale */
+    .rh-live.is-stale .rh-dot { background:var(--crit); }
+    .rh-live.is-stale .rh-dot::after { animation:none; }
+
+    /* keyboard focus — visible on every interactive control */
+    a:focus-visible, button:focus-visible, input:focus-visible, select:focus-visible,
+    summary:focus-visible, .rh-nav:focus-visible { outline:2px solid var(--accent); outline-offset:2px; border-radius:6px; }
+
+    /* on-call / mobile: stack the rail on top as a horizontal nav, collapse the grid */
+    @media (max-width:760px) {
+      .rh-app { grid-template-columns:1fr; }
+      .rh-rail { position:static; height:auto; flex-direction:row; flex-wrap:wrap; gap:6px 14px; align-items:center; border-right:none; border-bottom:1px solid var(--line-soft); }
+      .rh-rail .rh-grp { flex-direction:row; flex-wrap:wrap; gap:4px; }
+      .rh-rail .rh-grp-label { display:none; }
+      .rh-brand { width:100%; }
+      .rh-main { padding:16px 16px 60px; }
+      .rh-cards { grid-template-columns:1fr 1fr; }
+      .rh-top { flex-wrap:wrap; }
+    }
+    @media (max-width:440px) { .rh-cards { grid-template-columns:1fr; } }
     .rh-field { margin-bottom:16px; max-width:640px; }
     .rh-field label { display:block; font-size:12px; color:var(--muted); margin-bottom:6px; }
     .rh-field input, .rh-field textarea { width:100%; background:var(--panel); border:1px solid var(--line); border-radius:9px; padding:9px 12px; color:var(--text); font:13px var(--mono); }
@@ -254,6 +275,7 @@
         fetch("<%= dashboard_stats_path %>", { headers: { Accept: "application/json" } })
           .then(function (r) { return r.json(); })
           .then(function (d) {
+            setConn(true);
             apply(d);
             var now = Date.now();
             var backlog = d.enqueued + d.scheduled + d.retries;
@@ -285,7 +307,13 @@
             }
             lastProcessed = d.processed; lastFailed = d.failed; lastBacklog = backlog; lastT = now;
           })
-          .catch(function () {});
+          .catch(function () { setConn(false); });
+      }
+      // Surface a failed poll instead of letting the numbers silently go stale.
+      function setConn(ok) {
+        var el = document.getElementById("rh-live"), lbl = document.getElementById("rh-live-label");
+        if (el) el.classList.toggle("is-stale", !ok);
+        if (lbl) lbl.textContent = ok ? "live" : "reconnecting…";
       }
       function startOnce() { if (started) return; started = true; poll(); setInterval(poll, POLL_MS); }
       function wireChart() {
@@ -450,7 +478,7 @@
         <h1><%= yield :title %></h1>
         <span class="rh-crumb"><%= yield :crumb %></span>
         <span class="rh-spacer"></span>
-        <span class="rh-live"><span class="rh-dot"></span> live · <span class="num" data-stat="rate">—</span>/min</span>
+        <span class="rh-live" id="rh-live"><span class="rh-dot"></span> <span id="rh-live-label">live</span> · <span class="num" data-stat="rate">—</span>/min</span>
         <% if RoundhouseUi.read_only %><span class="rh-ro">read-only</span><% end %>
         <button class="rh-kbd" id="rh-palette-open" type="button" title="Command palette (⌘K)">⌘K</button>
         <button class="rh-iconbtn" id="rh-width" type="button" title="Toggle full width" aria-label="Toggle full width">⟷</button>

data/app/views/roundhouse_ui/dead/index.html.erb

@@ -6,6 +6,14 @@
 
 <h2 class="rh-h2">Dead set · <%= number_with_delimiter @total %> jobs</h2>
 
+<% if @query.present? %>
+  <div class="rh-bulkbar">
+    <%= button_to "↻ Retry all matching", bulk_all_dead_path, method: :post, params: { op: "retry", q: @query }, class: "rh-btn", form_class: "rh-inline", data: { turbo_confirm: "Retry every dead job matching “#{@query}” (up to #{RoundhouseUi::JobSetBrowsing::BULK_CAP})?" } %>
+    <%= button_to "✕ Delete all matching", bulk_all_dead_path, method: :post, params: { op: "delete", q: @query }, class: "rh-btn rh-btn-danger", form_class: "rh-inline", data: { turbo_confirm: "Permanently delete every dead job matching “#{@query}” (up to #{RoundhouseUi::JobSetBrowsing::BULK_CAP})?" } %>
+    <span class="rh-sub">acts on every match for “<%= @query %>”, not just this page</span>
+  </div>
+<% end %>
+
 <%= form_with url: bulk_dead_path, method: :post, data: { turbo: false } do %>
   <div class="rh-bulkbar">
     <button type="submit" name="op" value="retry" class="rh-btn">↻ Retry selected</button>

data/app/views/roundhouse_ui/metrics/show.html.erb

@@ -47,3 +47,24 @@
     <div class="d">backlog clears in, at current rate</div>
   </div>
 </div>
+
+<% if RoundhouseUi.collect_durations %>
+  <h2 class="rh-h2">Slowest job classes <span class="hint">by total time · from RoundhouseUi::DurationCollector</span></h2>
+  <% if @durations.blank? %>
+    <div class="rh-panel"><div class="rh-empty">No durations recorded yet — jobs need to run with the collector middleware installed.</div></div>
+  <% else %>
+    <table class="rh-table">
+      <thead><tr><th>Job class</th><th class="r">Runs</th><th class="r">Avg</th><th class="r">Total time</th></tr></thead>
+      <tbody>
+        <% @durations.each do |d| %>
+          <tr>
+            <td class="rh-mono"><%= d[:klass] %></td>
+            <td class="r rh-mono"><%= number_with_delimiter d[:count] %></td>
+            <td class="r rh-mono <%= "rh-lat-warn" if d[:avg_ms] >= 1000 %>"><%= d[:avg_ms] >= 1000 ? "#{(d[:avg_ms] / 1000).round(1)}s" : "#{d[:avg_ms].round}ms" %></td>
+            <td class="r rh-mono"><%= d[:total_ms] >= 1000 ? "#{(d[:total_ms] / 1000).round(1)}s" : "#{d[:total_ms].round}ms" %></td>
+          </tr>
+        <% end %>
+      </tbody>
+    </table>
+  <% end %>
+<% end %>

data/app/views/roundhouse_ui/retries/index.html.erb

@@ -5,6 +5,15 @@
 </form>
 
 <h2 class="rh-h2">Retries · <%= number_with_delimiter @total %> jobs</h2>
+
+<% if @query.present? %>
+  <div class="rh-bulkbar">
+    <%= button_to "↻ Run all matching now", bulk_all_retries_path, method: :post, params: { op: "retry", q: @query }, class: "rh-btn", form_class: "rh-inline", data: { turbo_confirm: "Run every retry matching “#{@query}” now (up to #{RoundhouseUi::JobSetBrowsing::BULK_CAP})?" } %>
+    <%= button_to "✕ Delete all matching", bulk_all_retries_path, method: :post, params: { op: "delete", q: @query }, class: "rh-btn rh-btn-danger", form_class: "rh-inline", data: { turbo_confirm: "Permanently delete every retry matching “#{@query}” (up to #{RoundhouseUi::JobSetBrowsing::BULK_CAP})?" } %>
+    <span class="rh-sub">acts on every match for “<%= @query %>”, not just this page</span>
+  </div>
+<% end %>
+
 <table class="rh-table">
   <thead><tr><th>Job</th><th>Last error</th><th class="r">Attempt</th><th class="r">Next try</th><th class="r">Actions</th></tr></thead>
   <tbody>

data/config/routes.rb

@@ -30,13 +30,15 @@ RoundhouseUi::Engine.routes.draw do
   post "scheduled/:jid/delete"  => "scheduled#destroy", as: :delete_scheduled
 
   get  "retries" => "retries#index", as: :retries
+  post "retries/bulk_all"    => "retries#bulk_all", as: :bulk_all_retries
   post "retries/:jid/run"    => "retries#requeue", as: :run_retry
   post "retries/:jid/delete" => "retries#destroy", as: :delete_retry
 
   get  "dead" => "dead#index", as: :dead_set
-  post "dead/bulk"        => "dead#bulk",    as: :bulk_dead
-  post "dead/:jid/retry"  => "dead#requeue", as: :retry_dead_job
-  post "dead/:jid/delete" => "dead#destroy", as: :delete_dead_job
+  post "dead/bulk"        => "dead#bulk",      as: :bulk_dead
+  post "dead/bulk_all"    => "dead#bulk_all",  as: :bulk_all_dead
+  post "dead/:jid/retry"  => "dead#requeue",   as: :retry_dead_job
+  post "dead/:jid/delete" => "dead#destroy",   as: :delete_dead_job
 
   get "errors" => "errors#index", as: :errors
   get "capsules" => "capsules#index", as: :capsules

data/lib/roundhouse_ui/duration_collector.rb

@@ -0,0 +1,53 @@
+module RoundhouseUi
+  # Opt-in server middleware that records per-class execution time, so the UI can
+  # answer "which job classes are slow?" — something Sidekiq doesn't track. Two
+  # cheap Redis writes per job (a counter + a summed-ms float). Off by default;
+  # enable in your Sidekiq server config:
+  #
+  #   Sidekiq.configure_server do |config|
+  #     config.server_middleware { |chain| chain.add RoundhouseUi::DurationCollector }
+  #   end
+  class DurationCollector
+    KEY = "roundhouse:durations".freeze
+
+    def call(_worker, job, _queue)
+      start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      yield
+    ensure
+      record(job["class"], (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000.0)
+    end
+
+    private
+
+    def record(klass, elapsed_ms)
+      return unless klass
+
+      Sidekiq.redis do |conn|
+        conn.call("HINCRBY", KEY, "#{klass}\x00count", 1)
+        conn.call("HINCRBYFLOAT", KEY, "#{klass}\x00ms", elapsed_ms)
+      end
+    rescue => e
+      # Metrics collection must never break a job.
+      Sidekiq.logger&.warn("[roundhouse] duration collect failed: #{e.message}")
+    end
+
+    # [{ klass:, count:, total_ms:, avg_ms: }], slowest (by total time) first.
+    def self.summary(limit: 20)
+      raw = Sidekiq.redis { |conn| conn.call("HGETALL", KEY) }
+      pairs = raw.is_a?(Hash) ? raw : raw.each_slice(2).to_a # redis-client: flat array; redis-rb: hash
+
+      by_class = Hash.new { |h, k| h[k] = { klass: k, count: 0, total_ms: 0.0 } }
+      pairs.each do |field, value|
+        klass, kind = field.split("\x00", 2)
+        next unless kind
+
+        kind == "count" ? by_class[klass][:count] = value.to_i : by_class[klass][:total_ms] = value.to_f
+      end
+
+      by_class.values
+              .map { |r| r.merge(avg_ms: r[:count].positive? ? r[:total_ms] / r[:count] : 0.0) }
+              .sort_by { |r| -r[:total_ms] }
+              .first(limit)
+    end
+  end
+end

data/lib/roundhouse_ui/version.rb

@@ -1,3 +1,3 @@
 module RoundhouseUi
-  VERSION = "0.7.0"
+  VERSION = "0.8.0"
 end

data/lib/roundhouse_ui.rb

@@ -12,6 +12,7 @@ require "roundhouse_ui/cancel_middleware"
 require "roundhouse_ui/metrics"
 require "roundhouse_ui/error_groups"
 require "roundhouse_ui/health"
+require "roundhouse_ui/duration_collector"
 
 # Brand name is "Roundhouse"; the gem and Ruby namespace are RoundhouseUi
 # (matching the published gem name `roundhouse_ui`).
@@ -59,6 +60,12 @@ module RoundhouseUi
     # Sidekiq's retry/dead sets, so this is the only way to surface them here.
     attr_accessor :show_sidekiq_failures
 
+    # Opt-in: record per-class job durations (via RoundhouseUi::DurationCollector
+    # server middleware) so the Metrics page can show the slowest job classes.
+    # Default false; reads/writes a single Redis hash. The flag gates the UI; the
+    # collection itself is enabled by installing the middleware.
+    attr_accessor :collect_durations
+
     # Seconds between dashboard stat polls. Lower = livelier, but each poll also
     # re-runs the host's auth/routing on the mount, so a busy console can add DB
     # load. Default 5s; raise it if polling shows up in your traces.
@@ -93,4 +100,5 @@ module RoundhouseUi
   self.show_sidekiq_failures = false
   self.pause_enabled = true
   self.poll_interval = 5
+  self.collect_durations = false
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: roundhouse_ui
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - R.J. Robinson
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-30 00:00:00.000000000 Z
+date: 2026-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -96,6 +96,7 @@ files:
 - lib/roundhouse_ui/audit.rb
 - lib/roundhouse_ui/cancel_middleware.rb
 - lib/roundhouse_ui/cancellation.rb
+- lib/roundhouse_ui/duration_collector.rb
 - lib/roundhouse_ui/engine.rb
 - lib/roundhouse_ui/error_groups.rb
 - lib/roundhouse_ui/fetch.rb