roundhouse_ui 0.7.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5064ee74f5aea444f5762d2f466f0b4c05d9c7af6c44a48045e6703d48b72587
-  data.tar.gz: 3b5a08f1769a5bd5ee66bdbe5ccd586842373b45530b95cbc4ff6340fe17796e
+  metadata.gz: 913330ea311e66bcb5eb717852a73c0c4eb51a281acbd5899fac33f623b609a2
+  data.tar.gz: 8fdaff5a284e27d7df7a63ade47294f9d5f156a14e9133f7a40a24ca194ad828
 SHA512:
-  metadata.gz: 6d3cf1e161baec06cb4b899d9f97065fb216341716719756c062a140a811bf51997748f9bcc322dc78aaa8ec36d56311decc511b70eea8d53a07a57a5b317b8c
-  data.tar.gz: 15a01ddaa5fa81c37c67516c369d1dac2b795b011e5dad1927b3b70aeed47b365a4938765e78f9eae910da0a39e36fe174d6170ba0226d1eeab404a700f4c218
+  metadata.gz: ae78d8ec53e92eaac58308a7701abfc11f71ad2d89f1ffe05b40611df458a6121a97f831d16770dfb0f9d37a3bdffe50905498bba41e7c86c7b74fe4bbc211d3
+  data.tar.gz: 446a6fa76c6f2cf70f2b3ec5e83d5eb06dbe6e6a393bebfab7414f3bd1e87d8fa96c6bf9ae180c284e2ae50e63ee1e1f3516a827591ab58d686fccdd8ebaf195

data/README.md

@@ -1,7 +1,6 @@
-<img width="3532" height="1956" alt="CleanShot 2026-06-27 at 21 07 23@2x" src="https://github.com/user-attachments/assets/7c27c997-d8d1-4e8e-b982-94c624ebfa2a" />
 # Roundhouse
-
-**A modern, real-time web UI for Sidekiq.**
+<img width="4460" height="3152" alt="CleanShot 2026-07-01 at 09 42 17@2x" src="https://github.com/user-attachments/assets/3484709b-9c4f-449e-8776-53ad2de4781f" />
+**A modern, real-time web UI for Sidekiq and Solid Queue.**
 
 [![CI](https://github.com/rjrobinson/roundhouse_ui/actions/workflows/ci.yml/badge.svg)](https://github.com/rjrobinson/roundhouse_ui/actions/workflows/ci.yml)
 [![Gem Version](https://img.shields.io/gem/v/roundhouse_ui)](https://rubygems.org/gems/roundhouse_ui)
@@ -9,32 +8,34 @@
 [![Rails](https://img.shields.io/badge/rails-%3E%3D%207.0-D30001?logo=rubyonrails&logoColor=white)](https://rubyonrails.org)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](MIT-LICENSE)
 
-Roundhouse is a mountable Rails engine that replaces the stock Sidekiq Web UI with a
-control plane built for the way you actually operate background jobs: live stats,
-searchable sets, grouped errors, safe queue management, job inspection/editing, and
-Redis health — all server-rendered with Turbo (no build step), and **no Sidekiq Pro
-required**.
+Roundhouse is a mountable Rails engine — a control plane built for the way you
+actually operate background jobs: a high-signal dashboard, searchable sets, grouped
+errors, smart bulk actions, safe queue management, and job inspection/editing. It
+reads through a **backend port**, so the same UI drives **Sidekiq** or **Solid
+Queue** (see [Backends](#backends)). All server-rendered with Turbo — **no build
+step, no frontend dependency** — and **no Sidekiq Pro required**.
 
 > Gem name is `roundhouse_ui`; the brand and mount path are **Roundhouse**.
 
 ## Features
 
-- **Live dashboard** — throughput chart + stat cards refresh in place (no reload); polling pauses when the tab is hidden.
-- **Search** — find a job across the dead/retry/scheduled sets by class, JID, error, or argument value.
-- **Bulk actions** — select many dead jobs and retry/delete them at once (not 25-at-a-time).
-- **Grouped errors** — failures fingerprinted by `class + error`, so one bad deploy is a single issue with a count.
-- **Queue management** — pause/resume (OSS, see below), purge with an impact count, and **snapshot → restore**.
-- **Job inspection & editing** — view a job's full args (with redaction), error, and backtrace; edit & re-enqueue, or enqueue a brand-new job (opt-in).
-- **Workers** — process fleet with quiet/stop, threads, queues, and heartbeat.
-- **Redis pressure** — memory, ops/sec, and the eviction-policy check that flags silent job loss.
+- **High-signal dashboard** — a composite health verdict (error rate + queue latency + utilization, with a "why"), *top failing job classes* and *problem queues* panels, and a live throughput chart with a configurable interval — all refreshing in place (polling pauses when the tab is hidden).
+- **Grouped errors** — failures fingerprinted by `class + error`, so one bad deploy is a single issue with a count, not thousands of rows.
+- **Smart bulk actions** — retry/delete every job matching a filter (not just the visible page), plus select-and-act on Dead.
+- **Search** — across the dead/retry/scheduled sets by class, JID, error, or argument value.
+- **Queue management** — pause/resume, purge with an impact count, and **snapshot → restore**.
+- **Job inspection & editing** — full args (with redaction), error, and collapsible backtrace; edit & re-enqueue, or enqueue a new job (opt-in).
+- **Per-class durations** (opt-in) — the slowest job classes, which Sidekiq doesn't track.
 - **Audit log** — every state-changing action recorded and attributable.
-- **⌘K command palette**, light/dark themes, read-only mode, and a strict self-contained CSP.
+- **⌘K command palette**, light/dark themes, compact/full-width toggle, read-only mode, and a strict self-contained CSP.
+
+Sidekiq-specific extras: **Workers** (quiet/stop, threads, heartbeat), **Redis pressure** (eviction-policy check for silent job loss), and **Capsules**.
 
-Everything reads through Sidekiq's public API — **no database**.
+There's **no database of its own** — Roundhouse reads your job backend directly (Sidekiq via its API, Solid Queue via its tables).
 
 ## Requirements
 
-- Ruby >= 3.1 · Rails >= 7.0 · Sidekiq >= 7.0
+- Ruby >= 3.1 · Rails >= 7.0 · Sidekiq >= 6.5 (or Solid Queue — see Backends)
 
 ## Installation
 
@@ -43,6 +44,28 @@ Everything reads through Sidekiq's public API — **no database**.
 gem "roundhouse_ui"
 ```
 
+## Backends
+
+Roundhouse reads through a **backend port**, so the same UI can drive different
+job systems. It defaults to **Sidekiq**; point it at **Solid Queue** in an
+initializer:
+
+```ruby
+# config/initializers/roundhouse.rb
+RoundhouseUi.backend = RoundhouseUi::Backends::SolidQueue.new
+```
+
+The UI adapts to each backend's capabilities — on Solid Queue, queue **pause is
+native** (no fetcher, no warning), and the **Retries / Redis / Capsules / Workers**
+sections hide (Solid Queue has no distinct retry set, isn't Redis-backed, and
+processes are a follow-up). Dashboard, Queues, Scheduled, Dead, Busy, and the
+grouped Errors view all work on both. See
+[docs/adr/0001](docs/adr/0001-backend-port-multi-queue.md).
+
+> Running **both** Sidekiq and Solid Queue in one app (e.g. mid-migration)? That's
+> [#17](https://github.com/rjrobinson/roundhouse_ui/issues/17) — for now, one
+> backend per Roundhouse instance.
+
 ## Mounting
 
 Roundhouse is auth-agnostic — wrap the mount in whatever your app already uses.
@@ -88,6 +111,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
 ```
 
@@ -97,8 +128,11 @@ Every option is independent and has a safe default — set only what you need.
 
 ## Pausing queues
 
-Pause/resume is pure OSS. To make a pause actually stop a queue from being worked,
-install Roundhouse's fetch strategy in your Sidekiq **server** config:
+> On **Solid Queue**, pause is **native** — it's enforced by the backend, so there's
+> nothing to install and no warning. The rest of this section is Sidekiq-only.
+
+On Sidekiq, pause/resume is pure OSS. To make a pause actually stop a queue from being
+worked, install Roundhouse's fetch strategy in your Sidekiq **server** config:
 
 ```ruby
 # config/initializers/sidekiq.rb
@@ -150,6 +184,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
@@ -189,8 +246,10 @@ Redis and run `bin/rails server` to click around.
 
 ## Roadmap
 
+- Solid Queue: Workers view + enqueue, and the multi-DB (separate queue database) case.
+- Watch Sidekiq **and** Solid Queue from one install ([#17](https://github.com/rjrobinson/roundhouse_ui/issues/17)).
 - Multi-Redis / multi-cluster view (one pane across shards).
-- Capsules and cron/periodic views.
+- Cron/periodic (recurring) views.
 
 ## Contributing
 

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/application_controller.rb

@@ -36,6 +36,12 @@ module RoundhouseUi
 
     private
 
+    # The queue backend (Sidekiq by default). Controllers read through this
+    # rather than naming Sidekiq directly. See ADR 0001.
+    def backend
+      RoundhouseUi.backend
+    end
+
     def record_audit_event
       target = params[:name] || params[:jid] || params[:id] || params[:job_class] ||
                (params[:jids].presence && "#{Array(params[:jids]).size} jobs") || params[:op]

data/app/controllers/roundhouse_ui/busy_controller.rb

@@ -9,7 +9,7 @@ module RoundhouseUi
 
     def index
       @threshold = LONG_RUNNING
-      @work = Sidekiq::WorkSet.new.map { |process_id, tid, work| normalize(process_id, tid, work) }
+      @work = backend.busy
     end
 
     def cancel
@@ -19,18 +19,6 @@ module RoundhouseUi
 
     private
 
-    # Sidekiq 7+ yields a Sidekiq::Work (queue/run_at/job methods); Sidekiq 6.x
-    # yields a plain Hash (string keys, an epoch run_at, a JSON payload). Normalize
-    # both to the same shape the view expects (run_at as a Time, job as a JobRecord).
-    def normalize(process_id, tid, work)
-      if work.respond_to?(:queue)
-        { process: process_id, tid: tid, queue: work.queue, run_at: work.run_at, job: work.job }
-      else
-        { process: process_id, tid: tid, queue: work["queue"],
-          run_at: Time.at(work["run_at"]), job: Sidekiq::JobRecord.new(work["payload"]) }
-      end
-    end
-
     def require_writable!
       return unless RoundhouseUi.read_only
       redirect_to busy_path, alert: "Roundhouse is in read-only mode — cancellation is disabled."

data/app/controllers/roundhouse_ui/capsules_controller.rb

@@ -12,7 +12,7 @@ module RoundhouseUi
     def aggregate
       capsules = Hash.new { |h, k| h[k] = { name: k, concurrency: 0, processes: 0, queues: {} } }
 
-      Sidekiq::ProcessSet.new.each do |process|
+      backend.process_set.each do |process|
         # `capsules` is a Sidekiq 8.0.8+ Process attribute; absent on 6.x/early 7,
         # where calling it would raise NoMethodError. Skip → view shows empty state.
         next unless process.respond_to?(:capsules)

data/app/controllers/roundhouse_ui/dashboard_controller.rb

@@ -3,8 +3,8 @@ module RoundhouseUi
   # Everything here comes out of Redis via Sidekiq::Stats / Sidekiq::Queue.
   class DashboardController < ApplicationController
     def show
-      @stats  = Sidekiq::Stats.new
-      @queues = Sidekiq::Queue.all
+      @stats  = backend.stats
+      @queues = backend.queues
       @metrics = Metrics.new(stats: @stats)
       @health  = Health.new(stats: @stats, queues: @queues, metrics: @metrics)
       # Highest-signal slices for the overview, from data we already read.
@@ -15,7 +15,7 @@ module RoundhouseUi
     # Polled by the dashboard for live counts (same approach Sidekiq Web uses —
     # cheap JSON, no WebSocket/build step required).
     def stats
-      s = Sidekiq::Stats.new
+      s = backend.stats
       render json: {
         processed: s.processed,
         failed:    s.failed,
@@ -24,7 +24,7 @@ module RoundhouseUi
         scheduled: s.scheduled_size,
         retries:   s.retry_size,
         dead:      s.dead_size,
-        queues:    Sidekiq::Queue.all.size
+        queues:    backend.queues.size
       }
     end
   end

data/app/controllers/roundhouse_ui/dead_controller.rb

@@ -2,30 +2,30 @@ 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
       @page  = [ params[:page].to_i, 1 ].max
-      @total = Sidekiq::DeadSet.new.size
-      @jobs, @has_next = browse(Sidekiq::DeadSet.new, @query, @page)
+      @total = backend.dead_set.size
+      @jobs, @has_next = browse(backend.dead_set, @query, @page)
     end
 
     def requeue
-      entry = Sidekiq::DeadSet.new.find_job(params[:jid])
+      entry = backend.dead_set.find_job(params[:jid])
       entry&.retry
       redirect_to dead_set_path, notice: entry ? "Re-enqueued #{params[:jid]}." : "Job is no longer in the dead set."
     end
 
     def destroy
-      entry = Sidekiq::DeadSet.new.find_job(params[:jid])
+      entry = backend.dead_set.find_job(params[:jid])
       entry&.delete
       redirect_to dead_set_path, notice: entry ? "Deleted #{params[:jid]}." : "Job is no longer in the dead set."
     end
 
     # Act on many at once: retry or delete every selected job in one request.
     def bulk
-      set = Sidekiq::DeadSet.new
+      set = backend.dead_set
       count = 0
       Array(params[:jids]).each do |jid|
         entry = set.find_job(jid) or next
@@ -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(backend.dead_set, 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/jobs_controller.rb

@@ -5,11 +5,6 @@ module RoundhouseUi
   # Sidekiq has no in-place edit: a job in a set is keyed by its payload, so an
   # "edit" is delete-the-old + push-the-modified.
   class JobsController < ApplicationController
-    SET_BUILDERS = {
-      "dead"      => -> { Sidekiq::DeadSet.new },
-      "retry"     => -> { Sidekiq::RetrySet.new },
-      "scheduled" => -> { Sidekiq::ScheduledSet.new }
-    }.freeze
     REDIRECTS = { "dead" => :dead_set_path, "retry" => :retries_path, "scheduled" => :scheduled_path }.freeze
 
     before_action :require_editing_enabled!, except: :show
@@ -32,7 +27,7 @@ module RoundhouseUi
       raise ArgumentError, "Job class is required" if klass.empty?
 
       queue = params[:queue].presence || "default"
-      Sidekiq::Client.push("class" => klass, "queue" => queue, "args" => args)
+      backend.push("class" => klass, "queue" => queue, "args" => args)
       redirect_to queues_path, notice: "Enqueued #{klass} → #{queue}."
     rescue ArgumentError => e
       render_form_error(:new, jobs_path, e)
@@ -56,7 +51,7 @@ module RoundhouseUi
       queue = params[:queue].presence || entry.queue
 
       entry.delete
-      Sidekiq::Client.push("class" => klass, "queue" => queue, "args" => args)
+      backend.push("class" => klass, "queue" => queue, "args" => args)
       redirect_to send(REDIRECTS[params[:set]]), notice: "Edited & re-enqueued #{klass} → #{queue}."
     rescue ArgumentError => e
       @action_path = job_path(set: params[:set], jid: params[:jid])
@@ -66,8 +61,8 @@ module RoundhouseUi
     private
 
     def find_entry
-      builder = SET_BUILDERS[params[:set]] or return nil
-      builder.call.find_job(params[:jid])
+      set = backend.set(params[:set]) or return nil
+      set.find_job(params[:jid])
     end
 
     def parse_args!(raw)

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/queues_controller.rb

@@ -3,24 +3,27 @@ module RoundhouseUi
     before_action :require_writable!, only: %i[purge pause resume]
 
     def index
-      @queues = Sidekiq::Queue.all
-      @paused = RoundhouseUi::Pause.paused_set
-      @fetch_installed = RoundhouseUi::Pause.fetch_installed?
+      @queues = backend.queues
+      @paused = backend.paused_queues
+      # Native-pause backends (Solid Queue) enforce pauses without a fetcher, so
+      # they never trigger the "not enforced" warning.
+      @fetch_installed = backend.supports?(:native_pause) ||
+                         (backend.respond_to?(:fetch_installed?) && backend.fetch_installed?)
     end
 
     # Real, OSS-supported destructive action: empties the queue in Redis.
     def purge
-      Sidekiq::Queue.new(params[:name]).clear
+      backend.queue(params[:name]).clear
       redirect_to queues_path, notice: "Purged queue “#{params[:name]}”."
     end
 
     def pause
-      RoundhouseUi::Pause.pause!(params[:name])
+      backend.pause(params[:name])
       redirect_to queues_path, notice: "Paused “#{params[:name]}”."
     end
 
     def resume
-      RoundhouseUi::Pause.unpause!(params[:name])
+      backend.resume(params[:name])
       redirect_to queues_path, notice: "Resumed “#{params[:name]}”."
     end
 

data/app/controllers/roundhouse_ui/retries_controller.rb

@@ -2,28 +2,38 @@ 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
       @page  = [ params[:page].to_i, 1 ].max
-      @total = Sidekiq::RetrySet.new.size
-      @jobs, @has_next = browse(Sidekiq::RetrySet.new, @query, @page)
+      @total = backend.retry_set.size
+      @jobs, @has_next = browse(backend.retry_set, @query, @page)
     end
 
     # Retry now — moves the job back to its queue immediately.
     def requeue
-      entry = Sidekiq::RetrySet.new.find_job(params[:jid])
+      entry = backend.retry_set.find_job(params[:jid])
       entry&.retry
       redirect_to retries_path, notice: entry ? "Re-enqueued #{params[:jid]}." : "Job is no longer in the retry set."
     end
 
     def destroy
-      entry = Sidekiq::RetrySet.new.find_job(params[:jid])
+      entry = backend.retry_set.find_job(params[:jid])
       entry&.delete
       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(backend.retry_set, 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/controllers/roundhouse_ui/scheduled_controller.rb

@@ -7,19 +7,19 @@ module RoundhouseUi
     def index
       @query = params[:q].to_s.strip
       @page  = [ params[:page].to_i, 1 ].max
-      @total = Sidekiq::ScheduledSet.new.size
-      @jobs, @has_next = browse(Sidekiq::ScheduledSet.new, @query, @page)
+      @total = backend.scheduled_set.size
+      @jobs, @has_next = browse(backend.scheduled_set, @query, @page)
     end
 
     # Enqueue now — pulls the job out of the schedule and onto its queue.
     def enqueue
-      entry = Sidekiq::ScheduledSet.new.find_job(params[:jid])
+      entry = backend.scheduled_set.find_job(params[:jid])
       entry&.add_to_queue
       redirect_to scheduled_path, notice: entry ? "Enqueued #{params[:jid]} now." : "Job is no longer scheduled."
     end
 
     def destroy
-      entry = Sidekiq::ScheduledSet.new.find_job(params[:jid])
+      entry = backend.scheduled_set.find_job(params[:jid])
       entry&.delete
       redirect_to scheduled_path, notice: entry ? "Deleted #{params[:jid]}." : "Job is no longer scheduled."
     end

data/app/controllers/roundhouse_ui/workers_controller.rb

@@ -5,7 +5,7 @@ module RoundhouseUi
     before_action :require_writable!, only: %i[quiet stop]
 
     def index
-      @processes = Sidekiq::ProcessSet.new.to_a
+      @processes = backend.process_set.to_a
       @fetch_active = RoundhouseUi::Pause.fetch_installed?
     end
 
@@ -22,7 +22,7 @@ module RoundhouseUi
     private
 
     def find_process(identity)
-      Sidekiq::ProcessSet.new.find { |process| process.identity == identity }
+      backend.process_set.find { |process| process.identity == identity }
     end
 
     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() {
@@ -329,14 +357,14 @@
         { label: "Dashboard", path: "<%= root_path %>", icon: "▦" },
         { label: "Metrics", path: "<%= metrics_path %>", icon: "▤" },
         { label: "Busy", path: "<%= busy_path %>", icon: "◐" },
-        { label: "Workers", path: "<%= workers_path %>", icon: "◷" },
+        <% if RoundhouseUi.backend.supports?(:workers) %>{ label: "Workers", path: "<%= workers_path %>", icon: "◷" },<% end %>
         { label: "Queues", path: "<%= queues_path %>", icon: "≡" },
         { label: "Scheduled", path: "<%= scheduled_path %>", icon: "◔" },
-        { label: "Retries", path: "<%= retries_path %>", icon: "↻" },
+        <% if RoundhouseUi.backend.supports?(:retries) %>{ label: "Retries", path: "<%= retries_path %>", icon: "↻" },<% end %>
         { label: "Errors", path: "<%= errors_path %>", icon: "⚠" },
         { label: "Dead", path: "<%= dead_set_path %>", icon: "✕" },
-        <% if defined?(Sidekiq::Capsule) %>{ label: "Capsules", path: "<%= capsules_path %>", icon: "⊞" },<% end %>
-        { label: "Redis", path: "<%= redis_info_path %>", icon: "◈" },
+        <% if defined?(Sidekiq::Capsule) && RoundhouseUi.backend.supports?(:capsules) %>{ label: "Capsules", path: "<%= capsules_path %>", icon: "⊞" },<% end %>
+        <% if RoundhouseUi.backend.supports?(:redis) %>{ label: "Redis", path: "<%= redis_info_path %>", icon: "◈" },<% end %>
         { label: "Snapshots", path: "<%= snapshots_path %>", icon: "⛁" },
         { label: "Audit log", path: "<%= audit_log_path %>", icon: "☷" },
         <% if RoundhouseUi.allow_job_editing %>{ label: "Enqueue job", path: "<%= new_job_path %>", icon: "＋" },<% end %>
@@ -420,13 +448,17 @@
         <%= nav_link "Dashboard", root_path, icon: "▦" %>
         <%= nav_link "Metrics", metrics_path, icon: "▤" %>
         <%= nav_link "Busy", busy_path, icon: "◐", badge: "busy" %>
-        <%= nav_link "Workers", workers_path, icon: "◷" %>
+        <% if RoundhouseUi.backend.supports?(:workers) %>
+          <%= nav_link "Workers", workers_path, icon: "◷" %>
+        <% end %>
       </nav>
       <nav class="rh-grp">
         <div class="rh-grp-label">Work</div>
         <%= nav_link "Queues", queues_path, icon: "≡", badge: "queues" %>
         <%= nav_link "Scheduled", scheduled_path, icon: "◔", badge: "scheduled" %>
-        <%= nav_link "Retries", retries_path, icon: "↻", badge: "retries", badge_class: "warn" %>
+        <% if RoundhouseUi.backend.supports?(:retries) %>
+          <%= nav_link "Retries", retries_path, icon: "↻", badge: "retries", badge_class: "warn" %>
+        <% end %>
         <%= nav_link "Errors", errors_path, icon: "⚠" %>
         <%= nav_link "Dead", dead_set_path, icon: "✕", badge: "dead", badge_class: "crit" %>
         <% if RoundhouseUi.allow_job_editing %>
@@ -435,11 +467,13 @@
       </nav>
       <nav class="rh-grp">
         <div class="rh-grp-label">Infrastructure</div>
-        <%# Capsules are a Sidekiq 7+ concept — hide the nav entirely on 6.x. %>
-        <% if defined?(Sidekiq::Capsule) %>
+        <%# Capsules are a Sidekiq 7+ concept — hide on 6.x and on non-Sidekiq backends. %>
+        <% if defined?(Sidekiq::Capsule) && RoundhouseUi.backend.supports?(:capsules) %>
           <%= nav_link "Capsules", capsules_path, icon: "⊞" %>
         <% end %>
-        <%= nav_link "Redis", redis_info_path, icon: "◈" %>
+        <% if RoundhouseUi.backend.supports?(:redis) %>
+          <%= nav_link "Redis", redis_info_path, icon: "◈" %>
+        <% end %>
         <%= nav_link "Snapshots", snapshots_path, icon: "⛁" %>
         <%= nav_link "Audit log", audit_log_path, icon: "☷" %>
       </nav>
@@ -450,7 +484,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/backends/sidekiq.rb

@@ -0,0 +1,63 @@
+module RoundhouseUi
+  module Backends
+    # The Sidekiq implementation of the Roundhouse backend port. It is a thin
+    # seam over Sidekiq's own API objects — controllers ask the backend for a
+    # "set" or "stats" instead of naming `Sidekiq::*` directly, so a second
+    # backend (Solid Queue) can supply duck-typed equivalents without touching
+    # controllers or views.
+    #
+    # Deliberately thin for now: each method returns the same Sidekiq object the
+    # controllers used before, so this refactor changes no behavior. The contract
+    # (what a "set" / "entry" must respond to) will be firmed up as the Solid
+    # Queue backend is built against it.
+    class Sidekiq
+      def name = "Sidekiq"
+
+      # Capabilities let the UI hide what a backend can't do. Sidekiq supports
+      # all the sets/views; pause is NOT native (needs the fetcher), so it does
+      # not advertise :native_pause — the "not enforced" warning still applies.
+      CAPABILITIES = %i[retries dead scheduled busy workers redis capsules].freeze
+      def supports?(capability) = CAPABILITIES.include?(capability)
+
+      def stats        = ::Sidekiq::Stats.new
+      def queues       = ::Sidekiq::Queue.all
+      def queue(name)  = ::Sidekiq::Queue.new(name)
+      def retry_set    = ::Sidekiq::RetrySet.new
+      def dead_set     = ::Sidekiq::DeadSet.new
+      def scheduled_set = ::Sidekiq::ScheduledSet.new
+      def work_set     = ::Sidekiq::WorkSet.new
+      def process_set  = ::Sidekiq::ProcessSet.new
+
+      # The job set a given UI section maps to (used by the job-detail page).
+      # Lazy — only builds the requested set.
+      def set(kind)
+        case kind.to_s
+        when "dead"      then dead_set
+        when "retry"     then retry_set
+        when "scheduled" then scheduled_set
+        end
+      end
+
+      def push(payload) = ::Sidekiq::Client.push(payload)
+
+      # Currently-executing jobs, normalized to the Busy view's shape. (This
+      # normalization used to live in BusyController; it belongs to the backend.)
+      def busy
+        ::Sidekiq::WorkSet.new.map do |process_id, tid, work|
+          if work.respond_to?(:queue) # Sidekiq 7+: Sidekiq::Work struct
+            { process: process_id, tid: tid, queue: work.queue, run_at: work.run_at, job: work.job }
+          else                         # Sidekiq 6.x: a plain Hash
+            { process: process_id, tid: tid, queue: work["queue"],
+              run_at: Time.at(work["run_at"]), job: ::Sidekiq::JobRecord.new(work["payload"]) }
+          end
+        end
+      end
+
+      # --- pause (via the opt-in Roundhouse fetcher; not native) ---
+      def paused_queues     = RoundhouseUi::Pause.paused_set
+      def pause(name)       = RoundhouseUi::Pause.pause!(name)
+      def resume(name)      = RoundhouseUi::Pause.unpause!(name)
+      def fetch_installed?  = RoundhouseUi::Pause.fetch_installed?
+    end
+  end
+end

data/lib/roundhouse_ui/backends/solid_queue.rb

@@ -0,0 +1,133 @@
+require "json"
+
+module RoundhouseUi
+  module Backends
+    # Solid Queue implementation of the backend port. Reads Solid Queue's
+    # ActiveRecord tables and normalizes them to the same shape the Sidekiq
+    # backend exposes, so controllers/views don't change.
+    #
+    # Solid Queue has no "retry set" (retries are just re-scheduled executions),
+    # no Redis, and no capsules — the UI hides those via #supports?. Queue pause
+    # is native, so there's no fetcher to warn about.
+    class SolidQueue
+      def name = "Solid Queue"
+
+      # No retries/redis/capsules/workers (deferred); pause is native (no fetcher
+      # warning). dead/scheduled/busy are supported.
+      CAPABILITIES = %i[dead scheduled busy native_pause].freeze
+      def supports?(capability) = CAPABILITIES.include?(capability)
+
+      def stats
+        Stats.new(
+          processed: sq(:Job).where.not(finished_at: nil).count,
+          failed:    sq(:FailedExecution).count,
+          enqueued:  sq(:ReadyExecution).count,
+          scheduled: sq(:ScheduledExecution).count,
+          busy:      sq(:ClaimedExecution).count,
+          dead:      sq(:FailedExecution).count,
+          retries:   0
+        )
+      end
+
+      def queues = ::SolidQueue::Queue.all
+      def queue(name) = ::SolidQueue::Queue.new(name)
+
+      # No retry set in Solid Queue — surfaced via supports?(:retries) => false.
+      def retry_set = EMPTY_SET
+
+      # Workers view is deferred (supports?(:workers) == false), and Solid Queue
+      # processes don't report thread concurrency the way Metrics expects, so the
+      # utilization signal reads as "no workers reporting" rather than crashing.
+      def process_set = []
+
+      def dead_set      = JobSet.new(sq(:FailedExecution).includes(:job).order(created_at: :desc))
+      def scheduled_set = JobSet.new(sq(:ScheduledExecution).includes(:job).order(:scheduled_at))
+
+      # Currently-executing jobs, normalized to the Busy view's shape.
+      def busy
+        sq(:ClaimedExecution).includes(:job, :process).map do |claim|
+          e = Entry.new(claim)
+          { process: claim.process&.name, tid: claim.id, queue: e.queue, run_at: claim.created_at, job: e }
+        end
+      end
+
+      def set(kind)
+        case kind.to_s
+        when "dead"      then dead_set
+        when "scheduled" then scheduled_set
+        end
+      end
+
+      # --- pause (native) ---
+      def paused_queues = ::SolidQueue::Pause.pluck(:queue_name)
+      def pause(name)   = ::SolidQueue::Queue.new(name).pause
+      def resume(name)  = ::SolidQueue::Queue.new(name).resume
+
+      # ActiveJob enqueues via perform_later; a raw push has no direct analogue.
+      def push(_payload) = raise NotImplementedError, "enqueue is Sidekiq-only for now"
+
+      private
+
+      def sq(model) = ::SolidQueue.const_get(model)
+
+      # A collection matching the JobSet contract (each / find_job / size).
+      class JobSet
+        include Enumerable
+        def initialize(relation) = @relation = relation
+        def each(&blk) = @relation.each { |exec| blk.call(Entry.new(exec)) }
+        def size = @relation.count
+        def find_job(jid) = (exec = @relation.find_by(job_id: jid)) && Entry.new(exec)
+      end
+
+      EMPTY_SET = JobSet.new([]).freeze
+
+      # Wraps a Solid Queue execution + its job in the SortedEntry-like interface
+      # the views expect (klass / jid / args / item / at / queue / retry / delete).
+      class Entry
+        def initialize(execution)
+          @execution = execution
+          @job = execution.job
+        end
+
+        def jid   = @execution.job_id.to_s
+        def klass = @job&.class_name
+        def queue = @job&.queue_name
+        def args  = active_job_args
+        def at    = @execution.try(:scheduled_at) || @execution.try(:created_at)
+
+        def item
+          err = (@execution.respond_to?(:error) && @execution.error) || {}
+          {
+            "class" => klass, "args" => args, "queue" => queue,
+            "error_class"     => err["exception_class"],
+            "error_message"   => err["message"],
+            "error_backtrace" => err["backtrace"]
+          }
+        end
+
+        def retry = @execution.retry if @execution.respond_to?(:retry)
+        def delete = @execution.destroy
+
+        private
+
+        # Solid Queue stores the full ActiveJob payload; the caller-facing args
+        # live under "arguments".
+        def active_job_args
+          raw = @job&.arguments
+          data = raw.is_a?(String) ? JSON.parse(raw) : raw
+          data.is_a?(Hash) ? (data["arguments"] || []) : Array(data)
+        rescue JSON::ParserError
+          []
+        end
+      end
+
+      # Value object matching Sidekiq::Stats' reader surface.
+      Stats = Struct.new(:processed, :failed, :enqueued, :scheduled, :busy, :dead, :retries, keyword_init: true) do
+        def scheduled_size = scheduled
+        def retry_size     = retries
+        def dead_size      = dead
+        def workers_size   = busy
+      end
+    end
+  end
+end

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/error_groups.rb

@@ -43,7 +43,7 @@ module RoundhouseUi
     # Sidekiq's native sets, plus the sidekiq-failures `failed` set when opted in
     # and loaded. Its FailureSet is a Sidekiq::JobSet, so it iterates like the rest.
     def sources
-      sets = { "retry" => Sidekiq::RetrySet.new, "dead" => Sidekiq::DeadSet.new }
+      sets = { "retry" => RoundhouseUi.backend.retry_set, "dead" => RoundhouseUi.backend.dead_set }
       if RoundhouseUi.show_sidekiq_failures && defined?(Sidekiq::Failures::FailureSet)
         sets["failed"] = Sidekiq::Failures::FailureSet.new
       end

data/lib/roundhouse_ui/metrics.rb

@@ -7,7 +7,7 @@ module RoundhouseUi
   # client-side from the dashboard's poll stream; per-class durations need the
   # collector (a separate, opt-in piece).
   class Metrics
-    def initialize(stats: Sidekiq::Stats.new, processes: Sidekiq::ProcessSet.new)
+    def initialize(stats: RoundhouseUi.backend.stats, processes: RoundhouseUi.backend.process_set)
       @stats = stats
       @processes = processes
     end

data/lib/roundhouse_ui/version.rb

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

data/lib/roundhouse_ui.rb

@@ -12,6 +12,9 @@ require "roundhouse_ui/cancel_middleware"
 require "roundhouse_ui/metrics"
 require "roundhouse_ui/error_groups"
 require "roundhouse_ui/health"
+require "roundhouse_ui/duration_collector"
+require "roundhouse_ui/backends/sidekiq"
+require "roundhouse_ui/backends/solid_queue"
 
 # Brand name is "Roundhouse"; the gem and Ruby namespace are RoundhouseUi
 # (matching the published gem name `roundhouse_ui`).
@@ -59,6 +62,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.
@@ -80,6 +89,15 @@ module RoundhouseUi
       yield self
     end
 
+    # The queue backend the UI reads through. Defaults to Sidekiq; assign a
+    # different adapter (e.g. Solid Queue) to point Roundhouse at another system.
+    # See docs/adr/0001-backend-port-multi-queue.md.
+    attr_writer :backend
+
+    def backend
+      @backend ||= Backends::Sidekiq.new
+    end
+
     # Cooperative cancellation check for long-running jobs:
     #   raise SomeStop if RoundhouseUi.cancelled?(jid)
     def cancelled?(jid)
@@ -93,4 +111,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.9.0
 platform: ruby
 authors:
 - R.J. Robinson
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-30 00:00:00.000000000 Z
+date: 2026-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -94,8 +94,11 @@ files:
 - config/routes.rb
 - lib/roundhouse_ui.rb
 - lib/roundhouse_ui/audit.rb
+- lib/roundhouse_ui/backends/sidekiq.rb
+- lib/roundhouse_ui/backends/solid_queue.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