solid_queue_web 0.8.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6897882e9e9b87a677fe9c6af855b33395cbf4bf2d13fb55086f461d26255f7d
-  data.tar.gz: 1b6882dce3a746811ba9553d0fb2174257c3f13146d5a448fd793c8c60a76661
+  metadata.gz: 65caaec8c90225e3645116b206b9a3f81c4ff2389b2dd688e2e3fccca8a0121d
+  data.tar.gz: 217dd8f2c0dcdaf13fe69cff9f3bf1c0857a416e88de8643248fc54a85efe917
 SHA512:
-  metadata.gz: d19bc85fc4350e8ecb194111c87a7b882d1e5929142ec94211bcf6fef23840810ec4eb51ae4d957a3c2288263bba9955aabca9ea1874f4d3b7f6d34590f54a28
-  data.tar.gz: 3516ec14c55cd3839bf22d721a58d6a68016b0891b09088e5463e8f2e61e611b77d9eaca461ea49c6ffc225873589880b678fb829b53a877683e32de3d75456b
+  metadata.gz: ed20d5b71f733c2e7eea80a249ff42c45094507f129dd69899b5938bc9594f575cb0a5958fc3e94bbf7b28fda0c70256257ba1651738d42dfa5c0661e61a7b73
+  data.tar.gz: d7ab81704638739b1108e666d87797a0f4d21c690d428ec321ce04ae98a3af15e181d783e5a498fd9e892b8b1e8041648d9666c356c1aebc194dbc76173cfdfe

data/README.md

@@ -33,13 +33,14 @@ SolidQueueWeb surfaces all of this in a browser UI available at any route you ch
 
 ## Features
 
-- **Dashboard** — stat cards showing counts for ready, scheduled, running, blocked, and failed jobs, plus queues, recurring tasks, and processes; "Done (1h)" and "Done (24h)" throughput cards; a "Throughput — Last 12 Hours" bar chart showing completed-job counts per hour (pure CSS, no charting library); auto-refreshes every 5 seconds
-- **Queues** — all queues sorted by name with size; oldest ready job latency (color-coded, with UTC timestamp tooltip); Done (24h) and Failed (24h) throughput counts; pause/resume controls
-- **Jobs** — filterable by status (ready, scheduled, claimed, blocked, failed) and by queue; search by job class name with dynamic auto-submit; time-based period filter (1 h / 24 h / 7 d); discard individual or all jobs; Turbo Frame navigation so only the table updates on filter or search; auto-refreshes every 10 seconds
-- **Failed jobs** — list of failed executions with error details; search by class name; filter by queue; time-based period filter; retry or discard individually or in bulk
+- **Dashboard** — stat cards showing counts for ready, scheduled, running, blocked, and failed jobs, plus queues, recurring tasks, and processes; "Done (1h)" and "Done (24h)" throughput cards; a "Throughput — Last 12 Hours" bar chart (blue) and a "Queue Depth — Last 12 Hours" bar chart (purple) showing hourly snapshots of active job count; pure CSS, no charting library; auto-refreshes every 5 seconds
+- **Queues** — all queues sorted by name with size; oldest ready job latency (color-coded, with UTC timestamp tooltip); Done (24h) and Failed (24h) throughput counts; a mini 12-bar failure rate sparkline per queue showing failure % per hour over the last 12 hours; pause/resume controls
+- **Jobs** — filterable by status (ready, scheduled, claimed, blocked, failed), queue, and priority; search by job class name with dynamic auto-submit; time-based period filter (1 h / 24 h / 7 d); discard individual or all jobs; Turbo Frame navigation so only the table updates on filter or search; auto-refreshes every 10 seconds
+- **Scheduled job management** — reschedule a scheduled job to run immediately ("Run Now") or push its `scheduled_at` forward by 1 h, 24 h, or 7 d; Turbo Stream responses update the row in place; "Run All Now" bulk action promotes every scheduled job in the current filtered view in a single operation
+- **Failed jobs** — list of failed executions with error details; search by class name; filter by queue; time-based period filter; retry or discard individually or in bulk; bulk retry with configurable stagger (+5s / +10s / +30s / +1m) to avoid thundering herd on recovery
 - **Job detail** — full arguments, timestamps, blocked-until date, and error backtrace; action buttons based on job status
 - **Queue management** — pause and resume individual queues; queue-scoped job list with status filter, search, and discard
-- **Recurring tasks** — all configured recurring tasks with cron schedule, next run time, last run time, and static/dynamic classification
+- **Recurring tasks** — all configured recurring tasks with cron schedule, next run time, last run time, and static/dynamic classification; "Run Now" button enqueues a task immediately without waiting for its next scheduled run
 - **Processes** — workers, dispatchers, and supervisors with heartbeat health status; auto-refreshes every 10 seconds
 - **Global search** — search across all job statuses at once by class name substring; results grouped by status with match count and direct links to filtered views; native datalist autocomplete pre-populated from all known job classes; auto-submits on selection
 - **Targeted bulk actions** — checkboxes on the jobs and failed jobs lists for selecting individual rows; selection bar shows count and action buttons ("Discard Selected" for jobs, "Retry Selected" / "Discard Selected" for failed jobs); select-all checkbox in the table header
@@ -47,6 +48,10 @@ SolidQueueWeb surfaces all of this in a browser UI available at any route you ch
 - **Dark mode** — ☽/☀ toggle in the header; preference persists to `localStorage` and defaults to the OS `prefers-color-scheme` on first visit; zero extra dependencies — implemented via CSS custom properties and a small Stimulus controller
 - **Dashboard quick actions** — "Retry All Failed" and "Discard All Blocked" cards appear on the dashboard only when the respective count is non-zero; one-click bulk operations with confirm dialogs, keeping the dashboard clean when everything is healthy
 - **CSV export** — "Export CSV" button on the jobs, failed jobs, and history pages downloads all records matching the current filters; columns are tailored per view
+- **Slow job detection** — when `slow_job_threshold` is configured, claimed jobs running longer than the threshold are flagged with an orange row, a "slow" badge, and a "Running For" duration column on the Running tab; a "Slow Jobs" warning card appears on the dashboard with a link to the Running tab
+- **Webhook alerts** — set `alert_webhook_url` and `alert_failure_threshold` to receive a POST request whenever the failed job count meets or exceeds the threshold; fires asynchronously so dashboard performance is unaffected; a configurable cooldown (default 1 h) prevents repeated alerts while the count stays elevated
+- **Performance analytics** — per-job-class statistics at `/jobs/performance` showing run count, average, p50, p95, min, and max duration; sorted by p95 descending so the slowest classes surface first; period filter scopes to 1h / 24h / 7d or all time; each class name links to the filtered History view
+- **Metrics / health endpoint** — `GET /jobs/metrics.json` returns a machine-readable JSON document with job counts, throughput, per-queue depth and pause state, and process health summary; suitable for Prometheus scraping, uptime monitors, or external dashboards; `slow_jobs` count included when `slow_job_threshold` is configured
 
 ## Screenshots
 
@@ -96,6 +101,11 @@ SolidQueueWeb.configure do |config|
   config.dashboard_refresh_interval = 10_000 # dashboard auto-refresh in ms (default: 5_000)
   config.default_refresh_interval   = 30_000 # jobs/processes/history auto-refresh in ms (default: 10_000)
   config.search_results_limit       = 10     # max results per status in global search (default: 25)
+  config.slow_job_threshold         = 5.minutes # flag claimed jobs running longer than this (default: nil = disabled)
+  config.alert_webhook_url          = "https://hooks.example.com/solid-queue" # POST target (default: nil = disabled)
+  config.alert_failure_threshold    = 10         # fire when failed count >= this (default: nil = disabled)
+  config.alert_webhook_cooldown     = 1800       # seconds between repeated alerts (default: 3600)
+  config.connects_to                = { reading: :reading, writing: :writing } # read replica (default: nil)
 end
 
 SolidQueueWeb.authenticate do
@@ -107,24 +117,103 @@ end
 
 No authentication is enforced by default. When the `authenticate` block returns falsy, HTTP Basic auth is used as a fallback.
 
-## Roadmap
+## Webhook alerts
+
+Set `alert_webhook_url` and `alert_failure_threshold` to receive a POST request whenever the failed job count meets or exceeds the threshold. This is useful for paging an on-call team or triggering a Slack notification via an incoming webhook.
 
-Planned features, roughly ordered by priority:  
+```ruby
+SolidQueueWeb.configure do |config|
+  config.alert_webhook_url       = "https://hooks.slack.com/services/..."
+  config.alert_failure_threshold = 10    # fire when >= 10 jobs have failed
+  config.alert_webhook_cooldown  = 1800  # don't re-fire for 30 minutes (default: 3600)
+end
+```
+
+The request body is JSON:
+
+```json
+{
+  "event": "failure_threshold_exceeded",
+  "failure_count": 14,
+  "threshold": 10,
+  "fired_at": "2026-05-21T12:34:56Z"
+}
+```
+
+The webhook fires asynchronously in a background thread so dashboard page loads are never delayed. HTTP errors are logged to `Rails.logger` and swallowed. The cooldown window prevents repeated alerts while the count stays elevated — the clock resets on each app restart.
+
+## Metrics endpoint
+
+`GET /jobs/metrics.json` returns a machine-readable JSON document suitable for Prometheus scraping, uptime monitors, or external dashboards. No configuration is required — the endpoint is available as soon as the engine is mounted.
+
+```
+GET /jobs/metrics.json
+```
+
+Example response:
+
+```json
+{
+  "generated_at": "2026-05-21T12:00:00Z",
+  "jobs": {
+    "ready": 12,
+    "scheduled": 8,
+    "claimed": 3,
+    "blocked": 5,
+    "failed": 9
+  },
+  "throughput": {
+    "completed_1h": 15,
+    "completed_24h": 87
+  },
+  "queues": [
+    { "name": "critical", "depth": 2, "paused": false },
+    { "name": "default",  "depth": 4, "paused": false },
+    { "name": "mailers",  "depth": 3, "paused": true  }
+  ],
+  "processes": {
+    "total": 4,
+    "healthy": 4,
+    "stale": 0,
+    "by_kind": { "Dispatcher": 1, "Supervisor": 1, "Worker": 2 }
+  }
+}
+```
+
+When `slow_job_threshold` is configured, a `slow_jobs` integer is also included at the top level.
+
+The endpoint respects the same authentication and `connects_to` settings as the rest of the dashboard. A process is counted as **stale** when its `last_heartbeat_at` is older than `SolidQueue.process_alive_threshold` (default: 5 minutes).
+
+## Read replica support
+
+Set `connects_to` with both `reading:` and `writing:` keys to enable automatic role switching. GET requests are routed to the reading role; POST/DELETE/PATCH requests use the writing role.
+
+```ruby
+SolidQueueWeb.configure do |config|
+  # Route dashboard reads to the replica, writes to primary:
+  config.connects_to = { reading: :reading, writing: :writing }
+end
+```
+
+The role names must match what Solid Queue's models are configured with (set via `SolidQueue.connects_to` in your app). To pin all requests to a single role instead (e.g. to bypass automatic read/write splitting middleware), pass a plain `role:` or `shard:` hash:
+
+```ruby
+config.connects_to = { role: :writing }
+```
+
+When `connects_to` is `nil` (the default), no connection switching occurs and single-database apps are unaffected.
+
+## Roadmap
 
-**Observability**
-- Job failure rate chart — sparkline per queue showing failure percentage over time, mirroring the throughput chart
-- Queue depth trend — historical queue size over time, not just the current snapshot
-- Slow job detection — flag jobs exceeding a configurable duration threshold
+Post-1.0 planned features:
 
 **Operations**
-- Scheduled job management — reschedule a job to run immediately, or push its `scheduled_at` forward
-- Bulk retry with delay — retry all failed jobs with a configurable stagger to avoid thundering herd
 - Admin audit log — record who retried or discarded which jobs and when (requires host-app user identity)
+- Failed job retry with modified arguments — edit the arguments JSON from the job detail page before retrying; useful for correcting bad payloads without redeploying
 
-**Infrastructure**
-- Webhook / alert config — POST to a URL when the failure count exceeds a threshold
-- Multi-database support — when Solid Queue runs on a separate database from the host app
-- Read replica support — route dashboard queries to a replica to avoid impacting the primary
+**Notifications**
+- Multiple webhook targets — support an array of `alert_webhook_url` values so alerts can fan out to Slack, PagerDuty, and custom endpoints simultaneously
+- Queue depth alert — fire a webhook when a queue's ready job count exceeds a configurable threshold (complements the existing failure-count alert)
 
 Pull requests for any of these are welcome. See [Contributing](#contributing) below.
 

data/Rakefile

@@ -3,11 +3,13 @@ require "bundler/setup"
 require "bundler/gem_tasks"
 require "rubocop/rake_task"
 require "rspec/core/rake_task"
+require "bundler/audit/task"
 
 RuboCop::RakeTask.new
 RSpec::Core::RakeTask.new(:spec)
+Bundler::Audit::Task.new
 
-task default: [:rubocop, :spec]
+task default: ["bundle:audit:update", "bundle:audit:check", :rubocop, :spec]
 
 namespace :dev do
   def dummy_env

data/app/assets/stylesheets/solid_queue_web/_04_table.css

@@ -44,9 +44,16 @@ td {
 
 tr:last-child td { border-bottom: none; }
 tbody tr:hover { background: var(--bg); }
+.sqd-table-link,
+.sqd-table-link:hover,
+.sqd-table-link:visited { text-decoration: none; color: var(--primary); }
 
 .sqd-empty {
   text-align: center;
   padding: 3rem 1rem;
   color: var(--muted);
-}
+}
+
+.sqd-row--slow { background: rgba(253, 126, 20, 0.07); }
+.sqd-row--slow:hover { background: rgba(253, 126, 20, 0.13); }
+.sqd-slow-duration { color: var(--warning); font-weight: 600; }

data/app/assets/stylesheets/solid_queue_web/_05_badges.css

@@ -21,6 +21,7 @@
 .sqd-badge--supervisor { background: #e0d7f5; color: #4a2c8a; }
 .sqd-badge--worker     { background: #d1e7dd; color: #0f5132; }
 .sqd-badge--dispatcher { background: #cff4fc; color: #055160; }
+.sqd-badge--slow       { background: #ffe8cc; color: #7c3d00; }
 
 .sqd-process-meta { font-size: 12px; color: var(--muted); }
 .sqd-process-meta span + span::before { content: " · "; }

data/app/assets/stylesheets/solid_queue_web/_07_forms.css

@@ -76,6 +76,23 @@
   color: #fff;
 }
 
+.sqd-select {
+  padding: 0.35rem 0.6rem;
+  border: 1px solid var(--border);
+  border-radius: 5px;
+  font-size: 13px;
+  background: var(--surface);
+  color: var(--text);
+  line-height: 1.5;
+  cursor: pointer;
+}
+
+.sqd-select:focus {
+  outline: 2px solid var(--primary);
+  outline-offset: -1px;
+  border-color: var(--primary);
+}
+
 .sqd-period-filter {
   display: flex;
   align-items: center;

data/app/assets/stylesheets/solid_queue_web/_11_throughput.css

@@ -65,4 +65,33 @@
   padding: 1rem 1.25rem;
 }
 
-.sqd-stat--done .sqd-stat__value { color: var(--success); }
+.sqd-stat--done .sqd-stat__value { color: var(--success); }
+
+.sqd-mini-sparkline {
+  display: flex;
+  align-items: flex-end;
+  gap: 2px;
+  height: 28px;
+  width: 88px;
+}
+
+.sqd-mini-sparkline__bar {
+  flex: 1;
+  background: var(--danger);
+  border-radius: 1px 1px 0 0;
+  opacity: 0.7;
+  transition: opacity 0.15s;
+}
+
+.sqd-mini-sparkline__bar:hover {
+  opacity: 1;
+}
+
+.sqd-mini-sparkline__bar--empty {
+  background: var(--border);
+  opacity: 0.5;
+}
+
+.sqd-sparkline__bar--depth {
+  background: var(--purple);
+}

data/app/controllers/solid_queue_web/application_controller.rb

@@ -4,12 +4,30 @@ module SolidQueueWeb
   class ApplicationController < ActionController::Base
     include Pagy::Method
 
-    PERIOD_DURATIONS = { "1h" => 1.hour, "24h" => 24.hours, "7d" => 7.days }.freeze
+    PERIOD_DURATIONS   = { "1h" => 1.hour, "24h" => 24.hours, "7d" => 7.days }.freeze
+    STAGGER_INTERVALS  = { "5s" => 5.seconds, "10s" => 10.seconds, "30s" => 30.seconds, "1m" => 1.minute }.freeze
 
     before_action :authenticate!
+    around_action :with_database_connection
 
     private
 
+    def with_database_connection
+      config = SolidQueueWeb.connects_to
+      return yield unless config
+
+      if replica_configured?(config)
+        role = request.get? ? config[:reading] : config[:writing]
+        ActiveRecord::Base.connected_to(role: role) { yield }
+      else
+        ActiveRecord::Base.connected_to(**config) { yield }
+      end
+    end
+
+    def replica_configured?(config)
+      config.key?(:reading) && config.key?(:writing)
+    end
+
     def authenticate!
       return unless (auth = SolidQueueWeb.authenticate)
 

data/app/controllers/solid_queue_web/blocked_jobs_controller.rb

@@ -0,0 +1,11 @@
+module SolidQueueWeb
+  class BlockedJobsController < ApplicationController
+    def destroy
+      jobs = SolidQueue::BlockedExecution.includes(:job).map(&:job)
+      SolidQueue::BlockedExecution.discard_all_from_jobs(jobs)
+      redirect_to root_path, notice: "#{jobs.size} blocked #{"job".pluralize(jobs.size)} discarded."
+    rescue => e
+      redirect_to root_path, alert: "Could not discard blocked jobs: #{e.message}"
+    end
+  end
+end

data/app/controllers/solid_queue_web/dashboard_controller.rb

@@ -1,44 +1,8 @@
 module SolidQueueWeb
   class DashboardController < ApplicationController
     def index
-      @stats = {
-        ready:     SolidQueue::ReadyExecution.count,
-        scheduled: SolidQueue::ScheduledExecution.count,
-        claimed:   SolidQueue::ClaimedExecution.count,
-        failed:    SolidQueue::FailedExecution.count,
-        blocked:   SolidQueue::BlockedExecution.count,
-        queues:    SolidQueue::Job.select(:queue_name).distinct.count,
-        processes: SolidQueue::Process.count,
-        recurring: SolidQueue::RecurringTask.count
-      }
-
-      now = Time.current
-      finished_times = SolidQueue::Job.where(finished_at: 24.hours.ago..now).pluck(:finished_at)
-      @throughput = {
-        completed_1h:  finished_times.count { |t| t >= 1.hour.ago },
-        completed_24h: finished_times.size
-      }
-      @sparkline = 12.times.map do |i|
-        from = (12 - i).hours.ago
-        to   = i == 11 ? now : (11 - i).hours.ago
-        finished_times.count { |t| t >= from && t < to }
-      end
-    end
-
-    def retry_all_failed
-      jobs = SolidQueue::FailedExecution.includes(:job).map(&:job)
-      SolidQueue::FailedExecution.retry_all(jobs)
-      redirect_to root_path, notice: "#{jobs.size} failed #{"job".pluralize(jobs.size)} queued for retry."
-    rescue => e
-      redirect_to root_path, alert: "Could not retry failed jobs: #{e.message}"
-    end
-
-    def discard_all_blocked
-      jobs = SolidQueue::BlockedExecution.includes(:job).map(&:job)
-      SolidQueue::BlockedExecution.discard_all_from_jobs(jobs)
-      redirect_to root_path, notice: "#{jobs.size} blocked #{"job".pluralize(jobs.size)} discarded."
-    rescue => e
-      redirect_to root_path, alert: "Could not discard blocked jobs: #{e.message}"
+      @stats = DashboardStats.new
+      AlertWebhook.call(failure_count: @stats.counts[:failed])
     end
   end
 end

data/app/controllers/solid_queue_web/jobs_controller.rb

@@ -1,16 +1,20 @@
 module SolidQueueWeb
   class JobsController < ApplicationController
-    before_action :set_status, only: [:destroy, :discard_selected]
-
     def index
-      @status = params[:status].presence_in(Job::STATUSES) || "ready"
-      @search = params[:q].presence
-      @period = params[:period].presence_in(PERIOD_DURATIONS.keys)
+      @status   = params[:status].presence_in(Job::STATUSES) || "ready"
+      @search   = params[:q].presence
+      @period   = params[:period].presence_in(PERIOD_DURATIONS.keys)
+      @priority = params[:priority].presence
+
       scope = Job::EXECUTION_MODELS[@status].includes(:job)
-      scope = scope.references(:job).where("solid_queue_jobs.class_name LIKE ?", "%#{@search}%") if @search.present?
+      scope = scope.references(:job).where("solid_queue_jobs.class_name LIKE ?", "%#{@search}%")         if @search.present?
       scope = scope.references(:job).where("solid_queue_jobs.created_at >= ?", PERIOD_DURATIONS[@period].ago) if @period.present?
+      scope = scope.references(:job).where("solid_queue_jobs.priority = ?", @priority.to_i)              if @priority.present?
       scope = scope.order(created_at: :desc)
 
+      @priority_options = Job::EXECUTION_MODELS[@status].joins(:job)
+        .distinct.pluck("solid_queue_jobs.priority").sort
+
       respond_to do |format|
         format.html { @pagy, @jobs = pagy(scope) }
         format.csv do
@@ -25,11 +29,14 @@ module SolidQueueWeb
       @job = SolidQueue::Job
         .includes(:ready_execution, :scheduled_execution, :claimed_execution, :blocked_execution, :failed_execution)
         .find(params[:id])
-      @execution_status = derive_status(@job)
+      @execution_status = Job.derive_status(@job)
     end
 
     def destroy
-      model = execution_model_for!(@status)
+      @status   = params[:status]
+      @period   = params[:period].presence_in(PERIOD_DURATIONS.keys)
+      @priority = params[:priority].presence
+      model = Job.execution_model_for!(@status)
       if params[:id]
         @execution = model.find(params[:id])
         @execution.discard
@@ -63,29 +70,11 @@ module SolidQueueWeb
       end
     end
 
-    def derive_status(job)
-      return "failed"    if job.failed_execution.present?
-      return "claimed"   if job.claimed_execution.present?
-      return "blocked"   if job.blocked_execution.present?
-      return "ready"     if job.ready_execution.present?
-      return "scheduled" if job.scheduled_execution.present?
-      "finished"
-    end
-
-    def set_status
-      @status = params[:status]
-      @period = params[:period].presence_in(PERIOD_DURATIONS.keys)
-    end
-
     def filtered_scope(model)
       scope = model.includes(:job)
       scope = scope.references(:job).where("solid_queue_jobs.created_at >= ?", PERIOD_DURATIONS[@period].ago) if @period.present?
+      scope = scope.references(:job).where("solid_queue_jobs.priority = ?", @priority.to_i)                  if @priority.present?
       scope
     end
-
-    def execution_model_for!(status)
-      raise ArgumentError, "Cannot discard #{status} jobs from this page." unless Job::DISCARDABLE.include?(status)
-      Job::EXECUTION_MODELS[status]
-    end
   end
 end

data/app/controllers/solid_queue_web/metrics_controller.rb

@@ -0,0 +1,7 @@
+module SolidQueueWeb
+  class MetricsController < ApplicationController
+    def index
+      render json: MetricsPayload.new.to_h
+    end
+  end
+end

data/app/controllers/solid_queue_web/performance_controller.rb

@@ -0,0 +1,12 @@
+module SolidQueueWeb
+  class PerformanceController < ApplicationController
+    def index
+      @period = params[:period].presence_in(PERIOD_DURATIONS.keys)
+
+      scope = SolidQueue::Job.where.not(finished_at: nil)
+      scope = scope.where("finished_at >= ?", PERIOD_DURATIONS[@period].ago) if @period.present?
+
+      @rows = JobPerformanceStats.new(scope).rows
+    end
+  end
+end

data/app/controllers/solid_queue_web/queues/jobs_controller.rb

@@ -2,7 +2,7 @@ module SolidQueueWeb
   module Queues
     class JobsController < ApplicationController
       before_action :set_queue
-      before_action :set_status, only: [:destroy, :discard_all]
+      before_action :set_status, only: [:destroy]
 
       def index
         @status = params[:status].presence_in(Job::STATUSES) || "ready"
@@ -15,29 +15,25 @@ module SolidQueueWeb
 
       def destroy
         model = execution_model_for!(@status)
-        @execution = model.find(params[:id])
-        @execution.discard
-        @remaining_count = filtered_scope(model).count
-        respond_to do |format|
-          format.turbo_stream
-          format.html { redirect_to queue_jobs_path(queue_name: @queue, status: @status), notice: "Job discarded." }
+        if params[:id]
+          @execution = model.find(params[:id])
+          @execution.discard
+          @remaining_count = filtered_scope(model).count
+          respond_to do |format|
+            format.turbo_stream
+            format.html { redirect_to queue_jobs_path(queue_name: @queue, status: @status), notice: "Job discarded." }
+          end
+        else
+          jobs = filtered_scope(model).map(&:job)
+          model.discard_all_from_jobs(jobs)
+          redirect_to queue_jobs_path(queue_name: @queue, status: @status),
+            notice: "#{jobs.size} #{"job".pluralize(jobs.size)} discarded."
         end
       rescue ArgumentError => e
         redirect_to queue_jobs_path(queue_name: @queue, status: @status), alert: e.message
       rescue => e
-        redirect_to queue_jobs_path(queue_name: @queue, status: @status), alert: "Could not discard job: #{e.message}"
-      end
-
-      def discard_all
-        model = execution_model_for!(@status)
-        jobs = filtered_scope(model).map(&:job)
-        model.discard_all_from_jobs(jobs)
         redirect_to queue_jobs_path(queue_name: @queue, status: @status),
-          notice: "#{jobs.size} #{"job".pluralize(jobs.size)} discarded."
-      rescue ArgumentError => e
-        redirect_to queue_jobs_path(queue_name: @queue, status: @status), alert: e.message
-      rescue => e
-        redirect_to queue_jobs_path(queue_name: @queue, status: @status), alert: "Could not discard jobs: #{e.message}"
+          alert: "Could not discard #{params[:id] ? "job" : "jobs"}: #{e.message}"
       end
 
       private

data/app/controllers/solid_queue_web/queues/pauses_controller.rb

@@ -0,0 +1,21 @@
+module SolidQueueWeb
+  module Queues
+    class PausesController < ApplicationController
+      def create
+        queue = SolidQueue::Queue.find_by_name(params[:queue_name])
+        queue.pause
+        redirect_to queues_path, notice: "Queue \"#{queue.name}\" paused."
+      rescue => e
+        redirect_to queues_path, alert: "Could not pause queue: #{e.message}"
+      end
+
+      def destroy
+        queue = SolidQueue::Queue.find_by_name(params[:queue_name])
+        queue.resume
+        redirect_to queues_path, notice: "Queue \"#{queue.name}\" resumed."
+      rescue => e
+        redirect_to queues_path, alert: "Could not resume queue: #{e.message}"
+      end
+    end
+  end
+end

data/app/controllers/solid_queue_web/queues_controller.rb

@@ -2,37 +2,11 @@ module SolidQueueWeb
   class QueuesController < ApplicationController
     def index
       @queues = SolidQueue::Queue.all.sort_by(&:name)
-
-      now = Time.current
-      @completed_24h = SolidQueue::Job
-        .where(finished_at: 24.hours.ago..now)
-        .group(:queue_name)
-        .count
-      @failed_24h = SolidQueue::FailedExecution
-        .joins(:job)
-        .where(created_at: 24.hours.ago..now)
-        .group("solid_queue_jobs.queue_name")
-        .count
-      @oldest_ready = SolidQueue::ReadyExecution
-        .joins(:job)
-        .group("solid_queue_jobs.queue_name")
-        .minimum("solid_queue_jobs.created_at")
-    end
-
-    def pause
-      queue = SolidQueue::Queue.find_by_name(params[:name])
-      queue.pause
-      redirect_to queues_path, notice: "Queue \"#{queue.name}\" paused."
-    rescue => e
-      redirect_to queues_path, alert: "Could not pause queue: #{e.message}"
-    end
-
-    def resume
-      queue = SolidQueue::Queue.find_by_name(params[:name])
-      queue.resume
-      redirect_to queues_path, notice: "Queue \"#{queue.name}\" resumed."
-    rescue => e
-      redirect_to queues_path, alert: "Could not resume queue: #{e.message}"
+      stats = QueueStats.new(@queues)
+      @completed_24h      = stats.completed_24h
+      @failed_24h         = stats.failed_24h
+      @oldest_ready       = stats.oldest_ready
+      @failure_sparklines = stats.failure_sparklines
     end
   end
 end

data/app/controllers/solid_queue_web/recurring_tasks/runs_controller.rb

@@ -0,0 +1,18 @@
+module SolidQueueWeb
+  class RecurringTasks::RunsController < ApplicationController
+    def create
+      task = SolidQueue::RecurringTask.find_by!(key: params[:recurring_task_key])
+      result = task.enqueue(at: Time.current)
+
+      if result
+        redirect_to recurring_tasks_path, notice: "\"#{task.key}\" queued for immediate execution."
+      else
+        redirect_to recurring_tasks_path, alert: "Could not enqueue \"#{task.key}\" — it may have just run."
+      end
+    rescue ActiveRecord::RecordNotFound
+      redirect_to recurring_tasks_path, alert: "Recurring task not found."
+    rescue => e
+      redirect_to recurring_tasks_path, alert: "Could not run task: #{e.message}"
+    end
+  end
+end

data/app/controllers/solid_queue_web/retry_failed_jobs_controller.rb

@@ -5,15 +5,36 @@ module SolidQueueWeb
     def create
       executions = params[:id] ? [SolidQueue::FailedExecution.find(params[:id])] : filtered_scope.to_a
       jobs = executions.map(&:job)
-      SolidQueue::FailedExecution.retry_all(jobs)
+
+      if params[:stagger].present? && executions.size > 1
+        interval = STAGGER_INTERVALS[params[:stagger]]
+        raise ArgumentError, "Invalid stagger interval." unless interval
+        executions.each_with_index do |execution, i|
+          execution.job.update!(scheduled_at: i.zero? ? nil : Time.current + (i * interval))
+          execution.retry
+        end
+      else
+        SolidQueue::FailedExecution.retry_all(jobs)
+      end
       redirect_to failed_jobs_path(queue: @queue, q: @search, period: @period),
-        notice: "#{jobs.size} #{"job".pluralize(jobs.size)} queued for retry."
+        notice: retry_notice(jobs.size)
+    rescue ArgumentError => e
+      redirect_to failed_jobs_path, alert: e.message
     rescue => e
       redirect_to failed_jobs_path, alert: "Could not retry job: #{e.message}"
     end
 
     private
 
+    def retry_notice(count)
+      label = "#{count} #{"job".pluralize(count)}"
+      if params[:stagger].present? && count > 1
+        "#{label} queued for retry, staggered #{params[:stagger]} apart."
+      else
+        "#{label} queued for retry."
+      end
+    end
+
     def set_filter_params
       @queue  = params[:queue].presence
       @search = params[:q].presence