solid_queue_web 0.8.0 → 1.0.0

data/app/controllers/solid_queue_web/scheduled_jobs_controller.rb

@@ -0,0 +1,54 @@
+module SolidQueueWeb
+  class ScheduledJobsController < ApplicationController
+    def create
+      @period = params[:period].presence_in(PERIOD_DURATIONS.keys)
+      job_ids = scheduled_scope.pluck("solid_queue_jobs.id")
+
+      SolidQueue::ScheduledExecution.where(job_id: job_ids).update_all(scheduled_at: 1.second.ago)
+      SolidQueue::Job.where(id: job_ids).update_all(scheduled_at: 1.second.ago)
+
+      redirect_to jobs_path(status: "scheduled", period: @period),
+        notice: "#{job_ids.size} #{"job".pluralize(job_ids.size)} scheduled to run immediately."
+    rescue => e
+      redirect_to jobs_path(status: "scheduled", period: @period),
+        alert: "Could not run jobs: #{e.message}"
+    end
+
+    def update
+      @execution = SolidQueue::ScheduledExecution.find(params[:id])
+      @period    = params[:period].presence_in(PERIOD_DURATIONS.keys)
+      @run_now   = params[:offset] == "now"
+      new_time   = resolve_new_time(@execution, params[:offset])
+
+      @execution.update!(scheduled_at: new_time)
+      @execution.job.update!(scheduled_at: new_time)
+
+      respond_to do |format|
+        format.turbo_stream
+        format.html do
+          notice = @run_now ? "Job scheduled to run immediately." : "Job rescheduled by +#{params[:offset]}."
+          redirect_to jobs_path(status: "scheduled", period: @period), notice: notice
+        end
+      end
+    rescue ArgumentError => e
+      redirect_to jobs_path(status: "scheduled"), alert: e.message
+    rescue => e
+      redirect_to jobs_path(status: "scheduled"), alert: "Could not reschedule job: #{e.message}"
+    end
+
+    private
+
+    def scheduled_scope
+      scope = SolidQueue::ScheduledExecution.joins(:job)
+      scope = scope.where("solid_queue_jobs.created_at >= ?", PERIOD_DURATIONS[@period].ago) if @period.present?
+      scope
+    end
+
+    def resolve_new_time(execution, offset)
+      return 1.second.ago if offset == "now"
+      raise ArgumentError, "Invalid offset." unless PERIOD_DURATIONS.key?(offset)
+
+      execution.scheduled_at + PERIOD_DURATIONS[offset]
+    end
+  end
+end

data/app/models/solid_queue_web/job.rb

@@ -1,6 +1,6 @@
 module SolidQueueWeb
   class Job
-    STATUSES = %w[ready scheduled claimed blocked failed].freeze
+    STATUSES    = %w[ready scheduled claimed blocked failed].freeze
     DISCARDABLE = %w[ready scheduled blocked].freeze
     EXECUTION_MODELS = {
       "ready"     => SolidQueue::ReadyExecution,
@@ -9,5 +9,21 @@ module SolidQueueWeb
       "blocked"   => SolidQueue::BlockedExecution,
       "failed"    => SolidQueue::FailedExecution
     }.freeze
+
+    def self.execution_model_for!(status)
+      raise ArgumentError, "Cannot discard #{status} jobs from this page." unless DISCARDABLE.include?(status)
+
+      EXECUTION_MODELS[status]
+    end
+
+    def self.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
   end
 end

data/app/services/solid_queue_web/alert_webhook.rb

@@ -0,0 +1,58 @@
+require "net/http"
+require "json"
+require "uri"
+
+module SolidQueueWeb
+  class AlertWebhook
+    MUTEX = Mutex.new
+
+    class << self
+      def call(failure_count:)
+        return unless configured?
+        return if failure_count < SolidQueueWeb.alert_failure_threshold
+        return unless should_fire?
+
+        Thread.new { post(SolidQueueWeb.alert_webhook_url, failure_count) }
+      end
+
+      def reset!
+        MUTEX.synchronize { @last_fired_at = nil }
+      end
+
+      private
+
+      def configured?
+        SolidQueueWeb.alert_webhook_url.present? && SolidQueueWeb.alert_failure_threshold.present?
+      end
+
+      def should_fire?
+        MUTEX.synchronize do
+          cooldown = SolidQueueWeb.alert_webhook_cooldown
+          return false if @last_fired_at && Time.current - @last_fired_at < cooldown
+
+          @last_fired_at = Time.current
+          true
+        end
+      end
+
+      def post(url_string, failure_count)
+        uri = URI.parse(url_string)
+        payload = JSON.generate(
+          event:         "failure_threshold_exceeded",
+          failure_count: failure_count,
+          threshold:     SolidQueueWeb.alert_failure_threshold,
+          fired_at:      Time.current.iso8601
+        )
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.open_timeout = 5
+        http.read_timeout = 10
+        request = Net::HTTP::Post.new(uri.path.presence || "/", "Content-Type" => "application/json")
+        request.body = payload
+        http.request(request)
+      rescue => e
+        Rails.logger.error("[SolidQueueWeb] Alert webhook failed: #{e.message}")
+      end
+    end
+  end
+end

data/app/services/solid_queue_web/dashboard_stats.rb

@@ -0,0 +1,47 @@
+module SolidQueueWeb
+  class DashboardStats
+    attr_reader :counts, :throughput, :sparkline, :depth_sparkline, :slow_jobs_count
+
+    def initialize
+      @now = Time.current
+      compute
+    end
+
+    private
+
+    def compute
+      @counts = {
+        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
+      }
+
+      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
+
+      threshold = SolidQueueWeb.slow_job_threshold
+      @slow_jobs_count = threshold ? SolidQueue::ClaimedExecution.where("created_at <= ?", threshold.ago).count : 0
+
+      job_timestamps = SolidQueue::Job
+        .where("created_at >= ? OR finished_at IS NULL", 72.hours.ago)
+        .pluck(:created_at, :finished_at)
+      @depth_sparkline = 12.times.map do |i|
+        t = i == 11 ? @now : (12 - i).hours.ago
+        job_timestamps.count { |created, finished| created <= t && (finished.nil? || finished > t) }
+      end
+    end
+  end
+end

data/app/services/solid_queue_web/job_performance_stats.rb

@@ -0,0 +1,38 @@
+module SolidQueueWeb
+  class JobPerformanceStats
+    Row = Struct.new(:class_name, :count, :avg, :p50, :p95, :min, :max, keyword_init: true)
+
+    def initialize(scope)
+      @scope = scope
+    end
+
+    def rows
+      grouped = @scope.pluck(:class_name, :created_at, :finished_at)
+        .group_by(&:first)
+
+      grouped.map do |class_name, records|
+        durations = records.map { |_, created, finished| (finished - created).to_f }.sort
+        Row.new(
+          class_name: class_name,
+          count:      durations.size,
+          avg:        mean(durations),
+          p50:        percentile(durations, 50),
+          p95:        percentile(durations, 95),
+          min:        durations.first,
+          max:        durations.last
+        )
+      end.sort_by { |r| -r.p95 }
+    end
+
+    private
+
+    def mean(sorted)
+      sorted.sum / sorted.size
+    end
+
+    def percentile(sorted, pct)
+      idx = [(pct / 100.0 * sorted.size).ceil - 1, 0].max
+      sorted[idx]
+    end
+  end
+end

data/app/services/solid_queue_web/metrics_payload.rb

@@ -0,0 +1,66 @@
+module SolidQueueWeb
+  class MetricsPayload
+    def initialize
+      @now = Time.current
+    end
+
+    def to_h
+      payload = {
+        generated_at: @now.iso8601,
+        jobs:         job_counts,
+        throughput:   throughput,
+        queues:       queue_list,
+        processes:    process_summary
+      }
+      slow = slow_jobs_count
+      payload[:slow_jobs] = slow unless slow.nil?
+      payload
+    end
+
+    private
+
+    def job_counts
+      {
+        ready:     SolidQueue::ReadyExecution.count,
+        scheduled: SolidQueue::ScheduledExecution.count,
+        claimed:   SolidQueue::ClaimedExecution.count,
+        blocked:   SolidQueue::BlockedExecution.count,
+        failed:    SolidQueue::FailedExecution.count
+      }
+    end
+
+    def throughput
+      finished_times = SolidQueue::Job.where(finished_at: 24.hours.ago..@now).pluck(:finished_at)
+      {
+        completed_1h:  finished_times.count { |t| t >= 1.hour.ago },
+        completed_24h: finished_times.size
+      }
+    end
+
+    def queue_list
+      depths = SolidQueue::ReadyExecution
+        .joins(:job)
+        .group("solid_queue_jobs.queue_name")
+        .count
+      SolidQueue::Queue.all.sort_by(&:name).map do |q|
+        { name: q.name, depth: depths[q.name] || 0, paused: q.paused? }
+      end
+    end
+
+    def process_summary
+      processes = SolidQueue::Process.all.to_a
+      threshold = SolidQueue.process_alive_threshold.ago
+      {
+        total:   processes.size,
+        healthy: processes.count { |p| p.last_heartbeat_at >= threshold },
+        stale:   processes.count { |p| p.last_heartbeat_at < threshold },
+        by_kind: processes.group_by(&:kind).transform_values(&:size)
+      }
+    end
+
+    def slow_jobs_count
+      threshold = SolidQueueWeb.slow_job_threshold
+      SolidQueue::ClaimedExecution.where("created_at <= ?", threshold.ago).count if threshold
+    end
+  end
+end

data/app/services/solid_queue_web/queue_stats.rb

@@ -0,0 +1,52 @@
+module SolidQueueWeb
+  class QueueStats
+    attr_reader :completed_24h, :failed_24h, :oldest_ready, :failure_sparklines
+
+    def initialize(queues)
+      @queues = queues
+      @now    = Time.current
+      compute
+    end
+
+    private
+
+    def compute
+      @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")
+
+      failed_raw = SolidQueue::FailedExecution
+        .joins(:job)
+        .where(created_at: 12.hours.ago..@now)
+        .pluck("solid_queue_jobs.queue_name", "solid_queue_failed_executions.created_at")
+      done_raw = SolidQueue::Job
+        .where(finished_at: 12.hours.ago..@now)
+        .pluck(:queue_name, :finished_at)
+
+      @failure_sparklines = @queues.each_with_object({}) do |queue, h|
+        failed_times = failed_raw.filter_map { |q, t| t if q == queue.name }
+        done_times   = done_raw.filter_map   { |q, t| t if q == queue.name }
+        h[queue.name] = 12.times.map do |i|
+          from = (12 - i).hours.ago
+          to   = i == 11 ? @now : (11 - i).hours.ago
+          f = failed_times.count { |t| t >= from && t < to }
+          d = done_times.count   { |t| t >= from && t < to }
+          total = f + d
+          total > 0 ? (f.to_f / total * 100).round : nil
+        end
+      end
+    end
+  end
+end

data/app/views/layouts/solid_queue_web/application.html.erb

@@ -21,6 +21,7 @@
           <li><%= link_to "Queues", queues_path, class: current_page?(queues_path) ? "active" : "", aria: { current: current_page?(queues_path) ? "page" : nil } %></li>
           <li><%= link_to "Jobs", jobs_path, class: current_page?(jobs_path) ? "active" : "", aria: { current: current_page?(jobs_path) ? "page" : nil } %></li>
           <li><%= link_to "History", history_path, class: current_page?(history_path) ? "active" : "", aria: { current: current_page?(history_path) ? "page" : nil } %></li>
+          <li><%= link_to "Performance", performance_path, class: current_page?(performance_path) ? "active" : "", aria: { current: current_page?(performance_path) ? "page" : nil } %></li>
           <li><%= link_to "Failed", failed_jobs_path, class: current_page?(failed_jobs_path) ? "active" : "", aria: { current: current_page?(failed_jobs_path) ? "page" : nil } %></li>
           <li><%= link_to "Recurring", recurring_tasks_path, class: current_page?(recurring_tasks_path) ? "active" : "", aria: { current: current_page?(recurring_tasks_path) ? "page" : nil } %></li>
           <li><%= link_to "Processes", processes_path, class: current_page?(processes_path) ? "active" : "", aria: { current: current_page?(processes_path) ? "page" : nil } %></li>

data/app/views/solid_queue_web/dashboard/index.html.erb

@@ -3,61 +3,61 @@
 
 <div class="sqd-stats">
   <%= link_to jobs_path(status: "ready"), class: "sqd-stat sqd-stat--ready sqd-stat--link" do %>
-    <div class="sqd-stat__value"><%= @stats[:ready] %></div>
+    <div class="sqd-stat__value"><%= @stats.counts[:ready] %></div>
     <div class="sqd-stat__label">Ready</div>
   <% end %>
   <%= link_to jobs_path(status: "scheduled"), class: "sqd-stat sqd-stat--scheduled sqd-stat--link" do %>
-    <div class="sqd-stat__value"><%= @stats[:scheduled] %></div>
+    <div class="sqd-stat__value"><%= @stats.counts[:scheduled] %></div>
     <div class="sqd-stat__label">Scheduled</div>
   <% end %>
   <%= link_to jobs_path(status: "claimed"), class: "sqd-stat sqd-stat--claimed sqd-stat--link" do %>
-    <div class="sqd-stat__value"><%= @stats[:claimed] %></div>
+    <div class="sqd-stat__value"><%= @stats.counts[:claimed] %></div>
     <div class="sqd-stat__label">Running</div>
   <% end %>
   <%= link_to jobs_path(status: "blocked"), class: "sqd-stat sqd-stat--blocked sqd-stat--link" do %>
-    <div class="sqd-stat__value"><%= @stats[:blocked] %></div>
+    <div class="sqd-stat__value"><%= @stats.counts[:blocked] %></div>
     <div class="sqd-stat__label">Blocked</div>
   <% end %>
   <%= link_to failed_jobs_path, class: "sqd-stat sqd-stat--failed sqd-stat--link" do %>
-    <div class="sqd-stat__value"><%= @stats[:failed] %></div>
+    <div class="sqd-stat__value"><%= @stats.counts[:failed] %></div>
     <div class="sqd-stat__label">Failed</div>
   <% end %>
   <%= link_to queues_path, class: "sqd-stat sqd-stat--queues sqd-stat--link" do %>
-    <div class="sqd-stat__value"><%= @stats[:queues] %></div>
+    <div class="sqd-stat__value"><%= @stats.counts[:queues] %></div>
     <div class="sqd-stat__label">Queues</div>
   <% end %>
   <%= link_to recurring_tasks_path, class: "sqd-stat sqd-stat--recurring sqd-stat--link" do %>
-    <div class="sqd-stat__value"><%= @stats[:recurring] %></div>
+    <div class="sqd-stat__value"><%= @stats.counts[:recurring] %></div>
     <div class="sqd-stat__label">Recurring</div>
   <% end %>
   <%= link_to processes_path, class: "sqd-stat sqd-stat--processes sqd-stat--link" do %>
-    <div class="sqd-stat__value"><%= @stats[:processes] %></div>
+    <div class="sqd-stat__value"><%= @stats.counts[:processes] %></div>
     <div class="sqd-stat__label">Processes</div>
   <% end %>
   <%= link_to history_path(period: "1h"), class: "sqd-stat sqd-stat--done sqd-stat--link" do %>
-    <div class="sqd-stat__value"><%= @throughput[:completed_1h] %></div>
+    <div class="sqd-stat__value"><%= @stats.throughput[:completed_1h] %></div>
     <div class="sqd-stat__label">Done (1h)</div>
   <% end %>
   <%= link_to history_path(period: "24h"), class: "sqd-stat sqd-stat--done sqd-stat--link" do %>
-    <div class="sqd-stat__value"><%= @throughput[:completed_24h] %></div>
+    <div class="sqd-stat__value"><%= @stats.throughput[:completed_24h] %></div>
     <div class="sqd-stat__label">Done (24h)</div>
   <% end %>
 </div>
 
-<% max_val = [@sparkline.max, 1].max %>
+<% max_val = [@stats.sparkline.max, 1].max %>
 <div class="sqd-card" style="margin-bottom: 1rem;">
   <div class="sqd-card__header">
     <span class="sqd-card__title">Throughput &mdash; Last 12 Hours</span>
     <div class="sqd-throughput__summary">
-      <span>1h: <strong><%= @throughput[:completed_1h] %></strong></span>
-      <span>24h: <strong><%= @throughput[:completed_24h] %></strong></span>
+      <span>1h: <strong><%= @stats.throughput[:completed_1h] %></strong></span>
+      <span>24h: <strong><%= @stats.throughput[:completed_24h] %></strong></span>
     </div>
   </div>
-  <% if @throughput[:completed_24h] == 0 %>
+  <% if @stats.throughput[:completed_24h] == 0 %>
     <div class="sqd-sparkline__empty">No completed jobs in the last 24 hours</div>
   <% else %>
     <div class="sqd-sparkline" aria-label="Jobs completed per hour over the last 12 hours">
-      <% @sparkline.each_with_index do |count, i| %>
+      <% @stats.sparkline.each_with_index do |count, i| %>
         <% pct = (count.to_f / max_val * 100).round %>
         <% hour_start = (12 - i).hours.ago %>
         <% show_tick = [0, 3, 6, 9, 11].include?(i) %>
@@ -74,6 +74,36 @@
   <% end %>
 </div>
 
+<% current_depth = @stats.counts[:ready] + @stats.counts[:scheduled] + @stats.counts[:claimed] + @stats.counts[:blocked] + @stats.counts[:failed] %>
+<% max_depth = [@stats.depth_sparkline.max, 1].max %>
+<div class="sqd-card" style="margin-bottom: 1rem;">
+  <div class="sqd-card__header">
+    <span class="sqd-card__title">Queue Depth &mdash; Last 12 Hours</span>
+    <div class="sqd-throughput__summary">
+      <span>Now: <strong><%= current_depth %></strong></span>
+    </div>
+  </div>
+  <% if @stats.depth_sparkline.all?(&:zero?) %>
+    <div class="sqd-sparkline__empty">No active jobs in the last 12 hours</div>
+  <% else %>
+    <div class="sqd-sparkline" aria-label="Queue depth over the last 12 hours">
+      <% @stats.depth_sparkline.each_with_index do |depth, i| %>
+        <% pct = (depth.to_f / max_depth * 100).round %>
+        <% t = i == 11 ? Time.current : (12 - i).hours.ago %>
+        <% show_tick = [0, 3, 6, 9, 11].include?(i) %>
+        <div class="sqd-sparkline__col">
+          <div class="sqd-sparkline__bar-wrap">
+            <div class="sqd-sparkline__bar sqd-sparkline__bar--depth"
+                 style="height: <%= [pct, 3].max %>%"
+                 title="<%= i == 11 ? "now" : t.strftime("%-I%p").downcase %>: <%= depth %> <%= "job".pluralize(depth) %> in queue"></div>
+          </div>
+          <div class="sqd-sparkline__tick"><%= show_tick ? (i == 11 ? "now" : t.strftime("%-I%p").downcase) : "" %></div>
+        </div>
+      <% end %>
+    </div>
+  <% end %>
+</div>
+
 <div style="display:grid; grid-template-columns: repeat(auto-fit, minmax(240px, 1fr)); gap: 1rem;">
   <div class="sqd-card">
     <div class="sqd-card__header">
@@ -88,37 +118,51 @@
     </div>
   </div>
 
-  <% if @stats[:failed] > 0 %>
+  <% if @stats.counts[:failed] > 0 %>
     <div class="sqd-card">
       <div class="sqd-card__header">
         <span class="sqd-card__title">Failed Jobs</span>
       </div>
       <div style="padding: 1rem; display: flex; flex-direction: column; gap: 0.5rem;">
         <p style="color: var(--danger); font-size: 13px;">
-          <%= pluralize(@stats[:failed], "failed job") %> need attention.
+          <%= pluralize(@stats.counts[:failed], "failed job") %> need attention.
         </p>
-        <%= button_to "Retry All Failed", retry_all_failed_path,
+        <%= button_to "Retry All Failed", retry_all_failed_jobs_path,
               method: :post,
               class: "sqd-btn sqd-btn--primary",
-              data: { confirm: "Retry all #{@stats[:failed]} failed #{"job".pluralize(@stats[:failed])}?" } %>
+              data: { confirm: "Retry all #{@stats.counts[:failed]} failed #{"job".pluralize(@stats.counts[:failed])}?" } %>
         <%= link_to "Review →", failed_jobs_path, class: "sqd-btn sqd-btn--muted" %>
       </div>
     </div>
   <% end %>
 
-  <% if @stats[:blocked] > 0 %>
+  <% if SolidQueueWeb.slow_job_threshold && @stats.slow_jobs_count > 0 %>
+    <div class="sqd-card">
+      <div class="sqd-card__header">
+        <span class="sqd-card__title">Slow Jobs</span>
+      </div>
+      <div style="padding: 1rem; display: flex; flex-direction: column; gap: 0.5rem;">
+        <p style="color: var(--warning); font-size: 13px;">
+          <%= pluralize(@stats.slow_jobs_count, "job") %> running longer than <%= distance_of_time_in_words(SolidQueueWeb.slow_job_threshold) %>.
+        </p>
+        <%= link_to "Review →", jobs_path(status: "claimed"), class: "sqd-btn sqd-btn--muted" %>
+      </div>
+    </div>
+  <% end %>
+
+  <% if @stats.counts[:blocked] > 0 %>
     <div class="sqd-card">
       <div class="sqd-card__header">
         <span class="sqd-card__title">Blocked Jobs</span>
       </div>
       <div style="padding: 1rem; display: flex; flex-direction: column; gap: 0.5rem;">
         <p style="color: var(--warning); font-size: 13px;">
-          <%= pluralize(@stats[:blocked], "blocked job") %>.
+          <%= pluralize(@stats.counts[:blocked], "blocked job") %>.
         </p>
-        <%= button_to "Discard All Blocked", discard_all_blocked_path,
-              method: :post,
+        <%= button_to "Discard All Blocked", blocked_jobs_path,
+              method: :delete,
               class: "sqd-btn sqd-btn--danger",
-              data: { confirm: "Discard all #{@stats[:blocked]} blocked #{"job".pluralize(@stats[:blocked])}? This cannot be undone." } %>
+              data: { confirm: "Discard all #{@stats.counts[:blocked]} blocked #{"job".pluralize(@stats.counts[:blocked])}? This cannot be undone." } %>
         <%= link_to "Review →", jobs_path(status: "blocked"), class: "sqd-btn sqd-btn--muted" %>
       </div>
     </div>

data/app/views/solid_queue_web/failed_jobs/index.html.erb

@@ -9,6 +9,16 @@
             params: { queue: @queue, q: @search, period: @period },
             class: "sqd-btn sqd-btn--primary",
             data: { confirm: "Retry all #{@failed_jobs.size} failed jobs?" } %>
+      <% if @failed_jobs.size > 1 %>
+        <% %w[5s 10s 30s 1m].each do |interval| %>
+          <%= button_to "+#{interval}", retry_all_failed_jobs_path,
+                method: :post,
+                params: { stagger: interval, queue: @queue, q: @search, period: @period },
+                class: "sqd-btn sqd-btn--muted sqd-btn--sm",
+                title: "Retry all, staggered #{interval} apart",
+                data: { confirm: "Retry #{@failed_jobs.size} failed jobs staggered #{interval} apart?" } %>
+        <% end %>
+      <% end %>
       <%= button_to "Discard All", discard_all_failed_jobs_path,
             method: :post,
             params: { queue: @queue, q: @search, period: @period },
@@ -92,7 +102,7 @@
                        data-action="change->selection#toggle"
                        aria-label="Select job <%= job.class_name %>">
               </td>
-              <td><%= link_to job.class_name, job_path(job) %></td>
+              <td><%= link_to job.class_name, job_path(job), class: "sqd-table-link" %></td>
               <td>
                 <%= link_to job.queue_name, failed_jobs_path(queue: job.queue_name, q: @search, period: @period),
                       class: "sqd-mono", style: "color: inherit;" %>

data/app/views/solid_queue_web/history/index.html.erb

@@ -49,7 +49,7 @@
       <tbody>
         <% @jobs.each do |job| %>
           <tr>
-            <td><%= link_to job.class_name, job_path(job) %></td>
+            <td><%= link_to job.class_name, job_path(job), class: "sqd-table-link" %></td>
             <td>
               <%= link_to job.queue_name, history_path(queue: job.queue_name, q: @search, period: @period),
                     class: "sqd-mono", style: "color: inherit;" %>