roundhouse_ui 0.8.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11537f41a49c350dbd057961b82994fdc7524afdf3285961a28fa13701daaf57
-  data.tar.gz: aedef27c3202b3d2eaf25a2b9fefb9290df222c66d1fde4ae8414152f3a477cf
+  metadata.gz: 6ee71201b4424c59d9450b7eea1fec5b7447e9e40ee419a4ebc03c39bf8189d6
+  data.tar.gz: 8a33d51ba920fd11b64ae9a28160ce40e87ff0b8c315a04136b64c7aa8427bb7
 SHA512:
-  metadata.gz: f4b22e1a716bbbdfdbab62cc5b0dcb10094a3cefbefd7ad1f1a24367e1f383f4c4c1467d1aa840600f860b1bc65b433fbdbdc56da5e1f1c1545f1756a99ed83c
-  data.tar.gz: cbe28c835c0e6413ee88658242e455e39a47cbd124a1e06ee0a9d40106ea9eb3ba49e2491f8dbd6f3a757ad71c0a24f5ead03b0b263b8a96237db3d2f8732b74
+  metadata.gz: 7494f64a2e7cea227f13ac6037e390775f068726f81e3962ecf0bf62a87d6dffaa7c613bef9c0d2b47bf4bdc5d410e6a2073e35c3a67723485af99fd30b43691
+  data.tar.gz: 2ff606ac7ca4797069b7cbb875313fd7988a962845f4c738765a8816a48280f5c889167a31d43452342389c3d122d798b15b782ac2219ba0cfb99d4125431bc0

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.
@@ -84,29 +107,52 @@ RoundhouseUi.configure do |c|
   # No-op unless the sidekiq-failures gem is loaded. Default: off.
   c.show_sidekiq_failures = true
 
-  # Set false to hide queue pause/resume controls and the "not enforced" warning,
-  # e.g. when you run reliable fetch (super_fetch) instead of RoundhouseUi::Fetch.
-  # Default: true.
+  # Set false to hide queue pause/resume controls entirely. Rarely needed — on
+  # Sidekiq Pro and Solid Queue pause is enforced natively, and on OSS Sidekiq
+  # installing RoundhouseUi::Fetch enforces it. 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.
+  # Show the "slowest job classes" table on the Metrics page. The flag alone shows
+  # nothing — it also needs the DurationCollector middleware (see below).
+  # Default: false.
   # c.collect_durations = true
 end
 ```
 
-Every option is independent and has a safe default — set only what you need.
-`read_only`, `allow_job_editing`, and `show_sidekiq_failures` default to `false`;
-`redact_args` to `[]`; `observability` to a no-op adapter; `snapshot_store` to Redis.
+Every option is independent and has a safe default — **set only what you need**. Nothing
+here is required to mount Roundhouse.
+
+### When to turn each one on
+
+| Option | Default | Turn it on when | Leave it alone when |
+|---|---|---|---|
+| `read_only` | `false` | **Production, almost always.** Blocks purge/retry/delete/edit *server-side*, not just in the UI — so it holds even if someone hand-crafts a request. The usual shape is `!Rails.env.development?`. | You need operators to actually fix things from the UI, and you trust everyone behind the mount. |
+| `redact_args` | `[]` | **Any app whose job args carry secrets or PII** — args render in full on the job page. Matches keys case-insensitively as substrings, and walks nested hashes/arrays. | Args are all IDs and enum values. |
+| `actor_resolver` | `"anonymous"` | You want the audit log to name *who* did something. One line: `->(c) { c.current_user&.email }`. | Single-operator app, or you already audit at another layer. |
+| `allow_job_editing` | `false` | Development and debugging. **Sharp tool** — a bad edit creates an unrunnable job, and it lets the UI enqueue arbitrary classes. | Production, unless you specifically want that power and have `read_only` off anyway. |
+| `observability` | no-op | You run an APM and want per-job deep links out to it. Ships a Datadog adapter; duck-type `job_url`/`queue_url`/`error_url` for anything else. | No APM, or you'd rather not add links that only some people can open. |
+| `snapshot_store` | Redis | Your snapshots are large or need to outlive Redis (S3/disk). Duck-type `write`/`read`/`delete`/`ids`. | Redis is fine — which it usually is for occasional queue snapshots. |
+| `show_sidekiq_failures` | `false` | You use the `sidekiq-failures` gem **and** run jobs with `retry: false` — those never enter Sidekiq's retry/dead sets, so this is the only way to see them. | You don't have the gem (it's a no-op then anyway). |
+| `poll_interval` | `5` | **Raise it** if dashboard polling shows up in your traces — every poll re-runs your app's auth and routing on the mount, so a busy console adds real load. Lower it only for a livelier demo. | Default is fine for most apps. |
+| `collect_durations` | `false` | You want "slowest job classes" on Metrics, which Sidekiq doesn't track. **Also requires installing the `DurationCollector` middleware** — the flag alone shows nothing. Costs one pipelined Redis round-trip per job. | You already get per-job timing from your APM. |
+| `pause_enabled` | `true` | Leave it on. | **Rarely set this to `false`.** Pause is enforced natively on Sidekiq Pro and Solid Queue, and on OSS Sidekiq by installing `RoundhouseUi::Fetch` — so turning it off usually just hides a working feature. Only useful if you want the controls gone entirely. |
+
+Two that pair with a middleware rather than working alone: `collect_durations`
+(`DurationCollector`) and job cancellation (`CancelMiddleware`) — see
+[Cancelling jobs](#cancelling-jobs) and [Slowest job classes](#slowest-job-classes).
 
 ## 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:
+> Pause is **native** — enforced with nothing to install and no warning — on both
+> **Solid Queue** and **Sidekiq Pro/Enterprise** (see below). The fetch strategy
+> below is only needed on **OSS Sidekiq**.
+
+On OSS 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
@@ -120,11 +166,26 @@ all of Sidekiq's weighting/ordering. Until it's installed, the Queues page recor
 but **warns that they aren't enforced** (worker and web are separate processes, so
 Roundhouse detects whether a fetcher has reported in).
 
-> ⚠️ **Sidekiq Pro/Enterprise users:** super_fetch / reliable fetch sets its own
-> `fetch_class`, and Sidekiq allows only one. Installing `RoundhouseUi::Fetch` would
-> **replace reliable fetch and lose its crash-recovery guarantees** — don't. On those
-> tiers, leave the fetch strategy out and set `RoundhouseUi.pause_enabled = false` to
-> hide the pause controls and the (otherwise permanent) "not enforced" warning.
+### Sidekiq Pro / Enterprise — nothing to install
+
+Pro ships its own enforced pause, and Roundhouse uses it automatically. Pro reopens
+`Sidekiq::Queue` with `pause!`/`unpause!` and *prepends* pause support onto
+`Sidekiq::BasicFetch` (`super_fetch` honors it too), so **any Pro worker enforces
+pauses** whether or not a fetch strategy is configured.
+
+When Roundhouse detects Pro it delegates pause/resume to `Sidekiq::Queue#pause!`,
+reads paused state from Pro's registry, advertises `native_pause`, and drops the
+"not enforced" warning. So on Pro:
+
+- **Don't** install `RoundhouseUi::Fetch` — it isn't needed, and on `super_fetch`
+  installs it would displace reliable fetch and lose its crash-recovery guarantees.
+- **Don't** set `pause_enabled = false` — pause genuinely works; disabling it only
+  hides a feature you already have.
+
+Roundhouse always goes through `Sidekiq::Queue#pause!` rather than writing Pro's
+Redis key directly: Pro's fetchers read that set once at startup and afterwards
+only update on the `pro:config` pubsub message `pause!` publishes, so a raw write
+would leave running workers pulling the queue until they restarted.
 
 ## Surfacing sidekiq-failures
 
@@ -158,6 +219,15 @@ 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)`.
 
+**Timing and cost.** The middleware is close to free when nothing is cancelled: rather
+than checking each job's JID against Redis, it asks "is *anything* cancelled?" from a
+process-local gate refreshed at most every 2s, and only does the exact per-job lookup
+while cancellations are pending. The tradeoff is that a cancellation takes **up to ~2s
+to reach a worker process** — the UI and your workers are separate processes, so expect
+a brief lag after clicking Cancel. Jobs already in flight are unaffected either way
+(cancellation is cooperative), and `RoundhouseUi.cancelled?(jid)` — what a long-running
+job polls — is never gated, so it always reads current state.
+
 ## Slowest job classes
 
 Sidekiq doesn't track per-class durations, so Roundhouse can record them itself.
@@ -171,8 +241,8 @@ Sidekiq.configure_server do |config|
 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.
+It's two cheap Redis writes per job (a counter + a summed-ms float) into a single hash,
+pipelined into **one round-trip**, and a job failure never propagates from the collector.
 
 ## Bulk actions on a filter
 
@@ -220,8 +290,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,70 @@
+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. On OSS Sidekiq pause is NOT native (it needs our
+      # fetcher), so :native_pause is withheld and the "not enforced" warning
+      # applies — but Sidekiq Pro ships its own enforced pause, so there it is
+      # advertised and the warning drops away.
+      CAPABILITIES = %i[retries dead scheduled busy workers redis capsules].freeze
+
+      def supports?(capability)
+        return RoundhouseUi::Pause.native? if capability == :native_pause
+
+        CAPABILITIES.include?(capability)
+      end
+
+      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/cancel_middleware.rb

@@ -7,9 +7,15 @@ module RoundhouseUi
   #   Sidekiq.configure_server do |config|
   #     config.server_middleware { |chain| chain.add RoundhouseUi::CancelMiddleware }
   #   end
+  #
+  # Hot-path cost: near zero. Cancellation.pending? answers "anything cancelled
+  # at all?" from a process-local gate (one EXISTS per CHECK_EVERY seconds, not
+  # per job); the exact per-job SISMEMBER only runs while cancellations are
+  # actually pending. State lives on the Cancellation module because Sidekiq
+  # builds a fresh middleware instance per job — ivars here wouldn't survive.
   class CancelMiddleware
     def call(_worker, job, _queue)
-      if RoundhouseUi::Cancellation.cancelled?(job["jid"])
+      if RoundhouseUi::Cancellation.pending? && RoundhouseUi::Cancellation.cancelled?(job["jid"])
         RoundhouseUi::Cancellation.clear!(job["jid"])
         return # acknowledge without running
       end

data/lib/roundhouse_ui/cancellation.rb

@@ -12,6 +12,9 @@ module RoundhouseUi
   module Cancellation
     KEY = "roundhouse:cancelled"
     TTL = 86_400 # seconds
+    CHECK_EVERY = 2.0 # seconds — max staleness of the "nothing is cancelled" gate
+
+    @gate = Mutex.new # guards @pending / @checked_at (see .pending?)
 
     module_function
 
@@ -20,6 +23,12 @@ module RoundhouseUi
         conn.call("SADD", KEY, jid.to_s)
         conn.call("EXPIRE", KEY, TTL)
       end
+      # Bust the local gate: the cancelling process sees its own cancel
+      # immediately; other processes converge within CHECK_EVERY.
+      @gate.synchronize do
+        @pending = true
+        @checked_at = monotonic_now
+      end
     end
 
     def cancelled?(jid)
@@ -33,5 +42,39 @@ module RoundhouseUi
     def cancelled_jids
       Sidekiq.redis { |conn| conn.call("SMEMBERS", KEY) }
     end
+
+    # The middleware's hot-path gate: "is anything cancelled at all?" — almost
+    # always no, so answering it with one EXISTS per process per CHECK_EVERY
+    # (instead of a SISMEMBER per job) takes the common case to zero Redis
+    # round-trips. While cancellations are pending, the middleware still does
+    # the exact per-job SISMEMBER. A cancel issued by *another* process is
+    # invisible here for up to CHECK_EVERY — acceptable because cancellation
+    # is cooperative and racy by design (a job may already be running when the
+    # flag lands), and cancel! busts the local gate so the cancelling process
+    # itself is always exact.
+    def pending?
+      now = monotonic_now
+      @gate.synchronize do
+        if @checked_at.nil? || now - @checked_at >= CHECK_EVERY
+          @pending = any?
+          @checked_at = now
+        end
+        @pending
+      end
+    end
+
+    def any?
+      Sidekiq.redis { |conn| conn.call("EXISTS", KEY) } == 1
+    end
+
+    # Forget the cached gate state (tests; or after flushing Redis by hand).
+    def reset_gate!
+      @gate.synchronize do
+        @pending = nil
+        @checked_at = nil
+      end
+    end
+
+    def monotonic_now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
   end
 end

data/lib/roundhouse_ui/duration_collector.rb

@@ -1,8 +1,8 @@
 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:
+  # cheap Redis writes per job (a counter + a summed-ms float), pipelined into a
+  # single round-trip. Off by default; enable in your Sidekiq server config:
   #
   #   Sidekiq.configure_server do |config|
   #     config.server_middleware { |chain| chain.add RoundhouseUi::DurationCollector }
@@ -22,9 +22,16 @@ module RoundhouseUi
     def record(klass, elapsed_ms)
       return unless klass
 
+      commands = [
+        [ "HINCRBY", KEY, "#{klass}\x00count", 1 ],
+        [ "HINCRBYFLOAT", KEY, "#{klass}\x00ms", elapsed_ms ]
+      ]
       Sidekiq.redis do |conn|
-        conn.call("HINCRBY", KEY, "#{klass}\x00count", 1)
-        conn.call("HINCRBYFLOAT", KEY, "#{klass}\x00ms", elapsed_ms)
+        if conn.respond_to?(:pipelined) # redis-client and redis-rb 4.5+: one round-trip
+          conn.pipelined { |pipe| commands.each { |c| pipe.call(*c) } }
+        else
+          commands.each { |c| conn.call(*c) }
+        end
       end
     rescue => e
       # Metrics collection must never break a job.

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

@@ -7,30 +7,59 @@ module RoundhouseUi
   # Paused queue names live in a Redis set. RoundhouseUi::Fetch consults this set
   # and skips paused queues when pulling work, so a paused queue stops being
   # consumed without stopping the worker process.
+  #
+  # When Sidekiq Pro is loaded we defer to *its* registry instead (see .native?).
+  # Pro reopens Sidekiq::Queue with pause!/unpause!/paused? and prepends pause
+  # support onto Sidekiq::BasicFetch, so pausing is already enforced with no
+  # Roundhouse fetcher installed — and Pro's key ("paused") is not ours
+  # ("roundhouse:paused"), so writing our own set there would do nothing.
   module Pause
     KEY        = "roundhouse:paused"
     FETCH_FLAG = "roundhouse:fetch_alive" # liveness beacon set by the fetcher
+    PRO_KEY    = "paused" # Sidekiq Pro's own registry
 
     module_function
 
+    # True when Sidekiq Pro's queue-pause API is available. Feature-detected on
+    # the method rather than `defined?(Sidekiq::Pro)` so it tracks the actual
+    # capability across Pro versions. Cheap (no Redis), so it isn't memoized —
+    # loading Pro mid-process would otherwise be missed.
+    def native?
+      defined?(::Sidekiq::Queue) && ::Sidekiq::Queue.method_defined?(:pause!)
+    end
+
+    # Under Pro, go through Sidekiq::Queue#pause! rather than writing PRO_KEY
+    # ourselves: Pro's fetchers read that set once at startup and afterwards only
+    # update on the "pro:config" pubsub message that pause! publishes. A bare
+    # SADD would leave running workers pulling the queue until they restarted.
     def pause!(queue)
+      return ::Sidekiq::Queue.new(queue.to_s).pause! if native?
+
       Sidekiq.redis { |conn| conn.call("SADD", KEY, queue.to_s) }
     end
 
     def unpause!(queue)
+      return ::Sidekiq::Queue.new(queue.to_s).unpause! if native?
+
       Sidekiq.redis { |conn| conn.call("SREM", KEY, queue.to_s) }
     end
 
     def paused?(queue)
-      Sidekiq.redis { |conn| conn.call("SISMEMBER", KEY, queue.to_s) } == 1
+      Sidekiq.redis { |conn| conn.call("SISMEMBER", key, queue.to_s) } == 1
     end
 
     def paused_queues
-      Sidekiq.redis { |conn| conn.call("SMEMBERS", KEY) }.sort
+      Sidekiq.redis { |conn| conn.call("SMEMBERS", key) }.sort
     end
 
     def paused_set
-      Set.new(Sidekiq.redis { |conn| conn.call("SMEMBERS", KEY) })
+      Set.new(Sidekiq.redis { |conn| conn.call("SMEMBERS", key) })
+    end
+
+    # Which registry reads come from. Reads are plain set lookups in both cases
+    # (no pubsub involved), so they can share one implementation.
+    def key
+      native? ? PRO_KEY : KEY
     end
 
     # Given the redis queue keys BasicFetch would poll (e.g. "queue:default"),
@@ -52,7 +81,13 @@ module RoundhouseUi
 
     # True when a RoundhouseUi::Fetch has reported in recently — i.e. pausing
     # will take effect. When false, the UI warns instead of pretending.
+    #
+    # Under Pro no beacon is needed: Pro prepends pause support onto
+    # Sidekiq::BasicFetch (and SuperFetch honors it too), so any Pro worker
+    # enforces pauses whether or not our fetcher is installed.
     def fetch_installed?
+      return true if native?
+
       Sidekiq.redis { |conn| conn.call("EXISTS", FETCH_FLAG) } == 1
     end
   end

data/lib/roundhouse_ui/version.rb

@@ -1,3 +1,3 @@
 module RoundhouseUi
-  VERSION = "0.8.0"
+  VERSION = "0.9.1"
 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.1
 platform: ruby
 authors:
 - R.J. Robinson
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-01 00:00:00.000000000 Z
+date: 2026-07-31 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