roundhouse_ui 0.1.0

data/app/controllers/roundhouse_ui/busy_controller.rb

@@ -0,0 +1,29 @@
+module RoundhouseUi
+  # What's executing right now, from Sidekiq::WorkSet — the live in-flight jobs
+  # Sidekiq Web calls "Busy". Surfaces long-running (possibly hung) jobs, which
+  # the stock UI makes you eyeball.
+  class BusyController < ApplicationController
+    LONG_RUNNING = 60 # seconds
+
+    before_action :require_writable!, only: :cancel
+
+    def index
+      @threshold = LONG_RUNNING
+      @work = Sidekiq::WorkSet.new.map do |process_id, tid, work|
+        { process: process_id, tid: tid, queue: work.queue, run_at: work.run_at, job: work.job }
+      end
+    end
+
+    def cancel
+      RoundhouseUi::Cancellation.cancel!(params[:jid])
+      redirect_to busy_path, notice: "Cancellation requested for #{params[:jid]}."
+    end
+
+    private
+
+    def require_writable!
+      return unless RoundhouseUi.read_only
+      redirect_to busy_path, alert: "Roundhouse is in read-only mode — cancellation is disabled."
+    end
+  end
+end

data/app/controllers/roundhouse_ui/capsules_controller.rb

@@ -0,0 +1,27 @@
+module RoundhouseUi
+  # Sidekiq 7+ capsules — isolated concurrency pools, each with its own queues.
+  # Aggregated across the running processes so you can see which capsule serves
+  # which queues (and answer "why isn't this queue draining?").
+  class CapsulesController < ApplicationController
+    def index
+      @capsules = aggregate
+    end
+
+    private
+
+    def aggregate
+      capsules = Hash.new { |h, k| h[k] = { name: k, concurrency: 0, processes: 0, queues: {} } }
+
+      Sidekiq::ProcessSet.new.each do |process|
+        (process.capsules || {}).each do |name, data|
+          cap = capsules[name]
+          cap[:concurrency] += data["concurrency"].to_i
+          cap[:processes]   += 1
+          (data["weights"] || {}).each { |queue, weight| cap[:queues][queue] = weight }
+        end
+      end
+
+      capsules.values.sort_by { |c| c[:name] }
+    end
+  end
+end

data/app/controllers/roundhouse_ui/dashboard_controller.rb

@@ -0,0 +1,26 @@
+module RoundhouseUi
+  # The dashboard reads straight from Sidekiq's API — no database, no models.
+  # Everything here comes out of Redis via Sidekiq::Stats / Sidekiq::Queue.
+  class DashboardController < ApplicationController
+    def show
+      @stats  = Sidekiq::Stats.new
+      @queues = Sidekiq::Queue.all
+    end
+
+    # 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
+      render json: {
+        processed: s.processed,
+        failed:    s.failed,
+        enqueued:  s.enqueued,
+        busy:      s.workers_size,
+        scheduled: s.scheduled_size,
+        retries:   s.retry_size,
+        dead:      s.dead_size,
+        queues:    Sidekiq::Queue.all.size
+      }
+    end
+  end
+end

data/app/controllers/roundhouse_ui/dead_controller.rb

@@ -0,0 +1,46 @@
+module RoundhouseUi
+  class DeadController < ApplicationController
+    include JobSetBrowsing
+
+    before_action :require_writable!, only: %i[requeue destroy bulk]
+
+    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)
+    end
+
+    def requeue
+      entry = Sidekiq::DeadSet.new.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&.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
+      count = 0
+      Array(params[:jids]).each do |jid|
+        entry = set.find_job(jid) or next
+        params[:op] == "delete" ? entry.delete : entry.retry
+        count += 1
+      end
+      verb = params[:op] == "delete" ? "Deleted" : "Re-enqueued"
+      redirect_to dead_set_path, notice: "#{verb} #{count} job(s)."
+    end
+
+    private
+
+    def require_writable!
+      return unless RoundhouseUi.read_only
+      redirect_to dead_set_path, alert: "Roundhouse is in read-only mode — retry and delete are disabled."
+    end
+  end
+end

data/app/controllers/roundhouse_ui/errors_controller.rb

@@ -0,0 +1,50 @@
+module RoundhouseUi
+  # Groups failing jobs across the retry + dead sets by a fingerprint of
+  # (job class + error class) — so one bad deploy reads as a single issue with
+  # a count, not five thousand identical rows. The aggregation Sidekiq Web lacks.
+  class ErrorsController < ApplicationController
+    SCAN_LIMIT = 1_000 # cap entries scanned per pass; shown honestly in the view
+
+    def index
+      @query = params[:q].to_s.strip
+      @scan_limit = SCAN_LIMIT
+      @groups, @scanned, @truncated = aggregate
+    end
+
+    private
+
+    def aggregate
+      groups = {}
+      scanned = 0
+      truncated = false
+
+      { "retry" => Sidekiq::RetrySet.new, "dead" => Sidekiq::DeadSet.new }.each do |source, set|
+        set.each do |entry|
+          scanned += 1
+          if scanned > SCAN_LIMIT
+            truncated = true
+            break
+          end
+          record(groups, source, entry)
+        end
+        break if truncated
+      end
+
+      list = groups.values.sort_by { |g| -g[:count] }
+      list = list.select { |g| "#{g[:klass]} #{g[:error]}".downcase.include?(@query.downcase) } if @query.present?
+      [ list, scanned, truncated ]
+    end
+
+    def record(groups, source, entry)
+      error = entry.item["error_class"] || "UnknownError"
+      group = (groups["#{entry.klass}|#{error}"] ||= {
+        klass: entry.klass, error: error, count: 0, last_at: nil, queues: [], sources: []
+      })
+      group[:count]  += 1
+      group[:queues] |= [ entry.queue ]
+      group[:sources] |= [ source ]
+      at = entry.at
+      group[:last_at] = at if at && (group[:last_at].nil? || at > group[:last_at])
+    end
+  end
+end

data/app/controllers/roundhouse_ui/jobs_controller.rb

@@ -0,0 +1,94 @@
+module RoundhouseUi
+  # Enqueue new jobs and edit/re-enqueue existing ones. Opt-in via
+  # RoundhouseUi.allow_job_editing (off by default — a sharp tool).
+  #
+  # 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
+
+    # Read-only inspection — available without allow_job_editing.
+    def show
+      @set = params[:set]
+      @entry = find_entry or return redirect_to(root_path, alert: "Job not found.")
+    end
+
+    def new
+      @mode = :new
+      @job  = { "class" => "", "queue" => "default", "args" => "[]" }
+      @action_path = jobs_path
+    end
+
+    def create
+      args  = parse_args!(params[:args])
+      klass = params[:job_class].to_s.strip
+      raise ArgumentError, "Job class is required" if klass.empty?
+
+      queue = params[:queue].presence || "default"
+      Sidekiq::Client.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)
+    end
+
+    def edit
+      @entry = find_entry or return redirect_to(root_path, alert: "Job not found.")
+      @mode = :edit
+      @job = {
+        "class" => @entry.item["class"],
+        "queue" => @entry.queue,
+        "args"  => JSON.pretty_generate(@entry.item["args"] || [])
+      }
+      @action_path = job_path(set: params[:set], jid: params[:jid])
+    end
+
+    def update
+      entry = find_entry or return redirect_to(root_path, alert: "Job not found.")
+      args  = parse_args!(params[:args])
+      klass = params[:job_class].presence || entry.item["class"]
+      queue = params[:queue].presence || entry.queue
+
+      entry.delete
+      Sidekiq::Client.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])
+      render_form_error(:edit, @action_path, e)
+    end
+
+    private
+
+    def find_entry
+      builder = SET_BUILDERS[params[:set]] or return nil
+      builder.call.find_job(params[:jid])
+    end
+
+    def parse_args!(raw)
+      parsed = JSON.parse(raw.to_s)
+      raise ArgumentError, 'Arguments must be a JSON array, e.g. [123, "abc"]' unless parsed.is_a?(Array)
+      parsed
+    rescue JSON::ParserError
+      raise ArgumentError, "Arguments must be valid JSON"
+    end
+
+    def render_form_error(mode, action_path, error)
+      flash.now[:alert] = error.message
+      @mode = mode
+      @action_path = action_path
+      @job = { "class" => params[:job_class], "queue" => params[:queue], "args" => params[:args] }
+      render mode, status: :unprocessable_entity
+    end
+
+    def require_editing_enabled!
+      return if RoundhouseUi.allow_job_editing && !RoundhouseUi.read_only
+      redirect_to root_path, alert: "Job editing is off — set RoundhouseUi.allow_job_editing = true (and disable read-only)."
+    end
+  end
+end

data/app/controllers/roundhouse_ui/metrics_controller.rb

@@ -0,0 +1,8 @@
+module RoundhouseUi
+  # Derived metrics, kept off the dashboard so the at-a-glance view stays lean.
+  class MetricsController < ApplicationController
+    def show
+      @metrics = Metrics.new
+    end
+  end
+end

data/app/controllers/roundhouse_ui/queues_controller.rb

@@ -0,0 +1,40 @@
+module RoundhouseUi
+  class QueuesController < ApplicationController
+    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?
+    end
+
+    # Real, OSS-supported destructive action: empties the queue in Redis.
+    def purge
+      Sidekiq::Queue.new(params[:name]).clear
+      redirect_to queues_path, notice: "Purged queue “#{params[:name]}”."
+    end
+
+    def pause
+      RoundhouseUi::Pause.pause!(params[:name])
+      redirect_to queues_path, notice: "Paused “#{params[:name]}”."
+    end
+
+    def resume
+      RoundhouseUi::Pause.unpause!(params[:name])
+      redirect_to queues_path, notice: "Resumed “#{params[:name]}”."
+    end
+
+    # Non-destructive backup — allowed even in read-only mode.
+    def snapshot
+      snap = RoundhouseUi::Snapshots.take(params[:name])
+      redirect_to queues_path, notice: "Snapshot saved — #{snap[:count]} job(s) from “#{params[:name]}”."
+    end
+
+    private
+
+    def require_writable!
+      return unless RoundhouseUi.read_only
+      redirect_to queues_path, alert: "Roundhouse is in read-only mode — queue actions are disabled."
+    end
+  end
+end

data/app/controllers/roundhouse_ui/redis_controller.rb

@@ -0,0 +1,21 @@
+module RoundhouseUi
+  # Redis health from INFO — the "is Redis about to silently drop my jobs?" view
+  # that Sidekiq Web doesn't have. The headline signal: an eviction policy other
+  # than noeviction (with a memory cap) means Sidekiq data can be evicted.
+  class RedisController < ApplicationController
+    def show
+      @info = parse_info(Sidekiq.redis { |conn| conn.call("INFO") })
+    end
+
+    private
+
+    def parse_info(raw)
+      raw.to_s.each_line.each_with_object({}) do |line, info|
+        line = line.strip
+        next if line.empty? || line.start_with?("#")
+        key, value = line.split(":", 2)
+        info[key] = value if key && value
+      end
+    end
+  end
+end

data/app/controllers/roundhouse_ui/retries_controller.rb

@@ -0,0 +1,34 @@
+module RoundhouseUi
+  class RetriesController < ApplicationController
+    include JobSetBrowsing
+
+    before_action :require_writable!, only: %i[requeue destroy]
+
+    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)
+    end
+
+    # Retry now — moves the job back to its queue immediately.
+    def requeue
+      entry = Sidekiq::RetrySet.new.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&.delete
+      redirect_to retries_path, notice: entry ? "Deleted #{params[:jid]}." : "Job is no longer in the retry set."
+    end
+
+    private
+
+    def require_writable!
+      return unless RoundhouseUi.read_only
+      redirect_to retries_path, alert: "Roundhouse is in read-only mode — retry and delete are disabled."
+    end
+  end
+end

data/app/controllers/roundhouse_ui/scheduled_controller.rb

@@ -0,0 +1,34 @@
+module RoundhouseUi
+  class ScheduledController < ApplicationController
+    include JobSetBrowsing
+
+    before_action :require_writable!, only: %i[enqueue destroy]
+
+    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)
+    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&.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&.delete
+      redirect_to scheduled_path, notice: entry ? "Deleted #{params[:jid]}." : "Job is no longer scheduled."
+    end
+
+    private
+
+    def require_writable!
+      return unless RoundhouseUi.read_only
+      redirect_to scheduled_path, alert: "Roundhouse is in read-only mode — enqueue and delete are disabled."
+    end
+  end
+end

data/app/controllers/roundhouse_ui/snapshots_controller.rb

@@ -0,0 +1,26 @@
+module RoundhouseUi
+  class SnapshotsController < ApplicationController
+    before_action :require_writable!, only: %i[restore destroy]
+
+    def index
+      @snapshots = RoundhouseUi::Snapshots.all
+    end
+
+    def restore
+      count = RoundhouseUi::Snapshots.restore(params[:id])
+      redirect_to snapshots_path, notice: "Restored #{count} job(s) to their queue."
+    end
+
+    def destroy
+      RoundhouseUi::Snapshots.delete(params[:id])
+      redirect_to snapshots_path, notice: "Snapshot deleted."
+    end
+
+    private
+
+    def require_writable!
+      return unless RoundhouseUi.read_only
+      redirect_to snapshots_path, alert: "Roundhouse is in read-only mode — restore and delete are disabled."
+    end
+  end
+end

data/app/controllers/roundhouse_ui/workers_controller.rb

@@ -0,0 +1,33 @@
+module RoundhouseUi
+  # The running Sidekiq process fleet, straight from Sidekiq::ProcessSet.
+  # "Quiet" stops a process from pulling new work; "Stop" begins shutdown.
+  class WorkersController < ApplicationController
+    before_action :require_writable!, only: %i[quiet stop]
+
+    def index
+      @processes = Sidekiq::ProcessSet.new.to_a
+      @fetch_active = RoundhouseUi::Pause.fetch_installed?
+    end
+
+    def quiet
+      find_process(params[:identity])&.quiet!
+      redirect_to workers_path, notice: "Sent quiet to #{params[:identity]}."
+    end
+
+    def stop
+      find_process(params[:identity])&.stop!
+      redirect_to workers_path, notice: "Sent stop to #{params[:identity]}."
+    end
+
+    private
+
+    def find_process(identity)
+      Sidekiq::ProcessSet.new.find { |process| process.identity == identity }
+    end
+
+    def require_writable!
+      return unless RoundhouseUi.read_only
+      redirect_to workers_path, alert: "Roundhouse is in read-only mode — quiet and stop are disabled."
+    end
+  end
+end

data/app/helpers/roundhouse_ui/application_helper.rb

@@ -0,0 +1,4 @@
+module RoundhouseUi
+  module ApplicationHelper
+  end
+end

data/app/helpers/roundhouse_ui/nav_helper.rb

@@ -0,0 +1,24 @@
+module RoundhouseUi
+  module NavHelper
+    # A sidebar nav item with active state and an optional live-updating badge
+    # (filled client-side from /stats via the poll in the layout).
+    def nav_link(label, path, icon:, badge: nil, badge_class: nil)
+      here = request.path == path || (path != root_path && request.path.start_with?(path))
+      link_to path, class: "rh-nav#{' is-active' if here}" do
+        safe_join([
+          content_tag(:span, icon, class: "rh-ico"),
+          content_tag(:span, label, class: "rh-lbl"),
+          badge ? content_tag(:span, "", class: "rh-badge #{badge_class}", data: { nav: badge }) : "".html_safe
+        ])
+      end
+    end
+
+    # Health label for a queue from its latency (oldest-job age, in seconds).
+    def queue_state(latency, paused: false)
+      return [ "Paused", "rh-st-paused" ] if paused
+      return [ "Stuck", "rh-st-crit" ]   if latency > 600
+      return [ "At risk", "rh-st-warn" ] if latency > 60
+      [ "Healthy", "rh-st-ok" ]
+    end
+  end
+end

data/app/helpers/roundhouse_ui/observability_helper.rb

@@ -0,0 +1,13 @@
+module RoundhouseUi
+  module ObservabilityHelper
+    # Renders a deep-link to the configured observability tool for a job, or
+    # nothing when no adapter is configured (the default).
+    def trace_link(klass:, jid:, queue: nil)
+      adapter = RoundhouseUi.observability
+      url = adapter.job_url(klass: klass, jid: jid, queue: queue)
+      return unless url
+
+      link_to "↗ #{adapter.label}", url, target: "_blank", rel: "noopener", class: "rh-trace"
+    end
+  end
+end