roundhouse_ui 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11537f41a49c350dbd057961b82994fdc7524afdf3285961a28fa13701daaf57
-  data.tar.gz: aedef27c3202b3d2eaf25a2b9fefb9290df222c66d1fde4ae8414152f3a477cf
+  metadata.gz: 913330ea311e66bcb5eb717852a73c0c4eb51a281acbd5899fac33f623b609a2
+  data.tar.gz: 8fdaff5a284e27d7df7a63ade47294f9d5f156a14e9133f7a40a24ca194ad828
 SHA512:
-  metadata.gz: f4b22e1a716bbbdfdbab62cc5b0dcb10094a3cefbefd7ad1f1a24367e1f383f4c4c1467d1aa840600f860b1bc65b433fbdbdc56da5e1f1c1545f1756a99ed83c
-  data.tar.gz: cbe28c835c0e6413ee88658242e455e39a47cbd124a1e06ee0a9d40106ea9eb3ba49e2491f8dbd6f3a757ad71c0a24f5ead03b0b263b8a96237db3d2f8732b74
+  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.
@@ -105,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
@@ -220,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/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

@@ -7,25 +7,25 @@ module RoundhouseUi
     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
@@ -40,7 +40,7 @@ module RoundhouseUi
     # 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])
+      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

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/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

@@ -7,19 +7,19 @@ module RoundhouseUi
     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
@@ -27,7 +27,7 @@ module RoundhouseUi
     # 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])
+      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

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

@@ -357,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 %>
@@ -448,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 %>
@@ -463,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>

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/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.8.0"
+  VERSION = "0.9.0"
 end

data/lib/roundhouse_ui.rb

@@ -13,6 +13,8 @@ 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`).
@@ -87,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)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: roundhouse_ui
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - R.J. Robinson
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-01 00:00:00.000000000 Z
+date: 2026-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -94,6 +94,8 @@ 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