solid_stack_web 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0adcafbdcb32ea6e96f982efc8d44502ea31e75e9f25138558ba58a8952719c8
-  data.tar.gz: a0e5b5695d620e4d616535e5f7b394df10c756ee712584a7de7c7ef489ded759
+  metadata.gz: c446164425203124cb715d09c520cfa7b2cc03a6abeefb4eb27ca0514327160a
+  data.tar.gz: ef9abaa3fe16c5ffc1e019dfff0ce97d7541950db9f6f25ae5ce034f4780efb5
 SHA512:
-  metadata.gz: 42c74a1cbc74acf3485ce0649e7f894bbbc1fdb4172037dbac4edb6e6805c8571c3731efb5acaa774763ae979ae8bb632e81e16f7f36e51faed447c8eb3bd81d
-  data.tar.gz: e35fb81b13d2f4cfa2d43f2e9ee223ef32c9605a69c98cf38e94f193d037f284efae651922ace035e04ad0ac1129361825345d5a64b97d91809caad1201351b9
+  metadata.gz: 30b738bcc2e57c4f81fb03d7b4a74bf88e18a1b69d4b71bc646357703006d6a1b639090a77a11d258427b7ad080f0b93b317cd949ff9b3b3353f77caa3e69066
+  data.tar.gz: 37f9a4d50e42360411c4213be03ce5c343874314a048b5f09b13b450bfc2ccf3568a2033cf5d4d137ee59723658f9a3cccbcd6353cf7f2f677159bd2b04fba73

data/README.md

@@ -7,17 +7,6 @@
 
 A mountable Rails engine that provides a unified web dashboard for the full [Solid Stack](https://github.com/rails/solid_queue) — **Solid Queue**, **Solid Cache**, and **Solid Cable** — in a single interface with no asset pipeline dependency and no JavaScript runtime requirement.
 
-## Features
-
-- **Overview dashboard** with live counts across all three Solid Stack components; cards are clickable and link directly to each section
-- **Solid Queue** — browse jobs by status (ready, scheduled, claimed, blocked) with filtering by job class, queue name, priority, and time period; manage failed jobs (retry / discard / bulk retry / bulk discard), pause/resume queues, and inspect worker processes; **Bulk selection** checkbox-selects individual jobs for discard or retry; **Discard All** bulk-discards every job matching the current filters in one request; **CSV export** downloads jobs or failed jobs as a CSV file respecting active filters
-- **Job detail page** — drill into any job to see full arguments (pretty-printed JSON), queue, priority, enqueued time, Active Job ID, concurrency key, scheduled/blocked-until metadata, and a Discard button
-- **Solid Cache** — entry count and total byte size at a glance
-- **Solid Cable** — active message count and distinct channel count
-- **Turbo Stream** job discard — removes the row inline without a full page reload
-- **Authentication hook** — plug in your own auth logic (Devise, Basic Auth, custom) via a one-line initializer
-- **Zero asset pipeline coupling** — CSS is injected inline; safe to mount in any host app
-
 ## Installation
 
 Add the gem to your application's `Gemfile`:
@@ -40,24 +29,55 @@ mount SolidStackWeb::Engine, at: "/solid_stack"
 
 The dashboard will be available at `/solid_stack` (or whatever path you choose).
 
-## Configuration
+---
 
-Create an initializer at `config/initializers/solid_stack_web.rb`:
+## Solid Queue
+
+### Features
+
+- **Overview dashboard** — live counts across all queue statuses; done (1h/24h), healthy/stale process counts, and optionally slow jobs (when `slow_job_threshold` is configured); 12-hour throughput sparkline with per-bar hover tooltips
+- **Job browser** — browse jobs by status (ready, scheduled, claimed, blocked) with filtering by job class, queue name, priority, and time period; **Discard All** bulk-discards every job matching the current filters in one request; **CSV export** downloads jobs respecting active filters
+- **Bulk selection** — checkbox-select individual jobs for discard; select-all support
+- **Per-queue browser** — click any queue name or size to drill into its ready jobs with per-row and bulk discard; pause/resume controls on the queue page
+- **Queue depth sparklines** — Queues index shows a 12-hour depth chart per queue; each bar is the ready-job count at an hourly snapshot with an instant hover tooltip
+- **Job detail page** — full arguments (pretty-printed JSON), queue, priority, enqueued time, Active Job ID, concurrency key, scheduled/blocked-until metadata, and a Discard button
+- **Failed jobs** — list with retry / discard / bulk retry / bulk discard; **Failed job detail page** — full error, backtrace, and an inline JSON argument editor; submit to update arguments and retry in one action
+- **Scheduled job management** — "Run Now" and offset buttons (+1h / +24h / +7d) per row update the scheduled time inline via Turbo Stream; "Run All Now (N)" back-dates all matching executions at once
+- **Recurring task list** — enumerates all `SolidQueue::RecurringTask` records with cron schedule, job class or command, queue, next-run and last-run times, and a static/dynamic badge; each row has a "Run Now" button
+- **Performance statistics page** — `GET /stats` aggregates finished jobs by class name with execution count, avg, p50, p95, min, and max duration; click any column header to sort; defaults to p95 descending
+- **Job history view** — paginated list of all finished jobs with class name, queue, duration, and finished-at time; filterable by queue (click a badge), class substring, and time period; CSV export respects active filters
+- **Auto-refresh** — dashboard, jobs, processes, and history views poll automatically; pauses when the tab is hidden or a checkbox is checked; intervals configurable via `dashboard_refresh_interval` and `default_refresh_interval`
+- **Turbo Stream** job discard — removes the row inline without a full page reload
+
+### Configuration
 
 ```ruby
 SolidStackWeb.configure do |config|
-  # Number of items per paginated page (default: 25)
-  config.page_size = 50
-
-  # Authentication — block runs in controller context.
-  # Return a truthy value to allow access; falsy falls back to HTTP Basic.
-  config.authenticate do
-    current_user&.admin?
-  end
+  # Slow job threshold in seconds (default: nil — stat hidden).
+  # When set, the dashboard shows a "Slow (24h)" count of finished jobs
+  # whose wall time exceeded this value. Links to the Stats page.
+  config.slow_job_threshold = 30
+
+  # Alert webhooks — fired on every GET /metrics poll when a threshold is met.
+  # Delivery failures are silently swallowed; cooldown prevents alert storms.
+  config.alert_webhook_url       = "https://hooks.example.com/my-alert"
+  config.alert_failure_threshold = 10          # POST when failed jobs >= this
+  config.alert_queue_thresholds  = {           # POST when a queue's ready depth >= value
+    "critical" => 50,
+    "default"  => 500
+  }
+  config.alert_webhook_cooldown  = 3600        # seconds between alerts (default: 3600)
+
+  # Auto-refresh intervals in milliseconds.
+  config.dashboard_refresh_interval = 5_000   # overview dashboard (default: 5000)
+  config.default_refresh_interval   = 10_000  # jobs, processes, history (default: 10000)
+
+  # Maximum results shown by the search feature (default: 25).
+  config.search_results_limit = 25
 end
 ```
 
-### Job Filtering
+#### Job Filtering
 
 The jobs list supports four independent filters, all driven by query params:
 
@@ -70,10 +90,71 @@ The jobs list supports four independent filters, all driven by query params:
 
 Filters are preserved when switching between status tabs (Ready / Scheduled / Running / Blocked) and when discarding a job. They can be combined freely.
 
+---
+
+## Solid Cache
+
+_Deep cache monitoring coming in v0.5.0. Currently shows entry count and total byte size on the overview dashboard._
+
+---
+
+## Solid Cable
+
+_Channel monitoring coming in v0.6.0. Currently shows active message count and distinct channel count on the overview dashboard._
+
+---
+
+## Metrics endpoint
+
+`GET /metrics` (relative to your mount path) returns a JSON payload suitable for external monitoring tools, uptime checkers, or custom alerting:
+
+```json
+{
+  "queue": {
+    "ready": 4,
+    "scheduled": 1,
+    "claimed": 2,
+    "blocked": 0,
+    "failed": 3,
+    "done_1h": 45,
+    "done_24h": 312,
+    "processes_healthy": 2,
+    "processes_stale": 0,
+    "slow_jobs": 7
+  },
+  "cache": { "entries": 1024, "byte_size": 2097152 },
+  "cable": { "messages": 50, "channels": 3 },
+  "generated_at": "2026-05-26T10:00:00Z"
+}
+```
+
+`slow_jobs` is only present when `slow_job_threshold` is configured. The endpoint is protected by the same authentication as the rest of the dashboard.
+
+---
+
+## General configuration
+
+Create an initializer at `config/initializers/solid_stack_web.rb`:
+
+```ruby
+SolidStackWeb.configure do |config|
+  # Number of items per paginated page (default: 25)
+  config.page_size = 50
+
+  # Authentication — block runs in controller context.
+  # Return a truthy value to allow access; falsy falls back to HTTP Basic.
+  config.authenticate do
+    current_user&.admin?
+  end
+end
+```
+
 ### Authentication
 
 The `authenticate` block is evaluated in the context of each request's controller instance, so any helper method available to controllers (e.g. `current_user` from Devise) works directly. If the block returns `false` or `nil`, the engine falls back to HTTP Basic authentication. If no `authenticate` block is configured, the dashboard is open.
 
+---
+
 ## Requirements
 
 - Ruby >= 3.3
@@ -82,6 +163,7 @@ The `authenticate` block is evaluated in the context of each request's controlle
 - [solid_cache](https://github.com/rails/solid_cache) >= 1.0
 - [solid_cable](https://github.com/rails/solid_cable) >= 1.0
 - [turbo-rails](https://github.com/hotwired/turbo-rails) >= 2.0
+- [importmap-rails](https://github.com/rails/importmap-rails) >= 1.2
 
 ## Contributing
 

data/app/assets/stylesheets/solid_stack_web/_02_layout.css

@@ -72,12 +72,20 @@
 
 .sqw-page-header { margin-bottom: 1.25rem; }
 .sqw-page-title  { font-size: 20px; font-weight: 600; }
+.sqw-page-title-row { display: flex; align-items: center; gap: 0.5rem; }
+
+@keyframes sqw-flash-dismiss {
+  0%, 86%  { opacity: 1; max-height: 200px; margin-bottom: 1rem; }
+  100%     { opacity: 0; max-height: 0;   margin-bottom: 0; padding: 0; }
+}
 
 .sqw-flash {
   padding: 0.75rem 1rem;
   border-radius: var(--radius);
   margin-bottom: 1rem;
   font-size: 13px;
+  animation: sqw-flash-dismiss 7s ease forwards;
+  overflow: hidden;
 }
 .sqw-flash--notice { background: #d1e7dd; color: #0a3622; border: 1px solid #a3cfbb; }
 .sqw-flash--alert  { background: #f8d7da; color: #58151c; border: 1px solid #f1aeb5; }

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

@@ -30,6 +30,10 @@
 .sqw-actions { text-align: right; white-space: nowrap; }
 .sqw-actions form { display: inline; }
 
+.sqw-table th a { color: inherit; text-decoration: none; }
+.sqw-table th a:hover { color: var(--text); }
+.sqw-sort-indicator { margin-left: 0.2rem; }
+
 .sqw-empty {
   background: var(--surface);
   border: 1px solid var(--border);

data/app/assets/stylesheets/solid_stack_web/_07_dashboard.css

@@ -12,7 +12,6 @@
   border-radius: var(--radius);
   box-shadow: var(--shadow);
   overflow: hidden;
-  position: relative;
   transition: box-shadow 0.15s;
 }
 .sqw-gem-card:hover { box-shadow: 0 3px 8px rgba(0,0,0,.12); }
@@ -44,16 +43,6 @@
 }
 .sqw-gem-card__link:hover { color: var(--primary); text-decoration: none; }
 
-/* Stretch the header link to cover the whole card */
-.sqw-gem-card__link::after {
-  content: "";
-  position: absolute;
-  inset: 0;
-}
-
-/* Stat links and other interactive elements sit above the overlay */
-.sqw-inline-stat { position: relative; z-index: 1; }
-
 .sqw-gem-card__body {
   display: grid;
   grid-template-columns: repeat(auto-fill, minmax(90px, 1fr));
@@ -68,6 +57,7 @@
   color: var(--text);
   transition: opacity 0.15s;
 }
+
 a.sqw-inline-stat:hover { opacity: 0.7; text-decoration: none; }
 
 .sqw-inline-stat__label {
@@ -87,4 +77,66 @@ a.sqw-inline-stat:hover { opacity: 0.7; text-decoration: none; }
 .sqw-inline-stat--failed    .sqw-inline-stat__value { color: var(--danger); }
 .sqw-inline-stat--cache     .sqw-inline-stat__value { color: var(--purple); }
 .sqw-inline-stat--cable     .sqw-inline-stat__value { color: var(--info); }
-.sqw-inline-stat--neutral   .sqw-inline-stat__value { color: var(--muted); }
+.sqw-inline-stat--neutral   .sqw-inline-stat__value { color: var(--muted); }
+
+.sqw-sparkline-wrap {
+  padding: 0.75rem 1.25rem 1rem;
+  border-top: 1px solid var(--border);
+  color: var(--primary);
+}
+
+.sqw-sparkline-label {
+  display: block;
+  font-size: 10px;
+  font-weight: 500;
+  text-transform: uppercase;
+  letter-spacing: .06em;
+  color: var(--muted);
+  margin-bottom: 0.5rem;
+}
+
+.sqw-sparkline-positioner {
+  position: relative;
+}
+
+.sqw-sparkline {
+  display: block;
+  width: 100%;
+  height: 40px;
+}
+
+.sqw-sparkline--sm {
+  height: 24px;
+}
+
+.sqw-queue-sparkline {
+  width: 120px;
+  color: var(--primary);
+}
+
+.sqw-sparkline rect {
+  cursor: pointer;
+}
+
+.sqw-sparkline-tip {
+  position: fixed;
+  transform: translate(-50%, -100%);
+  background: var(--text);
+  color: var(--surface);
+  font-size: 11px;
+  font-weight: 500;
+  white-space: nowrap;
+  padding: 3px 7px;
+  border-radius: 4px;
+  pointer-events: none;
+  z-index: 100;
+}
+
+.sqw-sparkline-axis {
+  display: flex;
+  justify-content: space-between;
+  font-size: 9px;
+  color: var(--muted);
+  margin-top: 3px;
+  opacity: 0.7;
+}

data/app/controllers/solid_stack_web/application_controller.rb

@@ -15,7 +15,7 @@ module SolidStackWeb
 
     def current_section
       case controller_name
-      when "jobs", "failed_jobs", "queues", "processes" then :queue
+      when "jobs", "failed_jobs", "queues", "processes", "history", "scheduled_jobs", "recurring_tasks" then :queue
       when "cache" then :cache
       when "cable" then :cable
       else :overview

data/app/controllers/solid_stack_web/dashboard_controller.rb

@@ -1,22 +1,10 @@
 module SolidStackWeb
   class DashboardController < ApplicationController
     def index
-      @queue_stats = {
-        ready:     ::SolidQueue::ReadyExecution.count,
-        scheduled: ::SolidQueue::ScheduledExecution.count,
-        claimed:   ::SolidQueue::ClaimedExecution.count,
-        blocked:   ::SolidQueue::BlockedExecution.count,
-        failed:    ::SolidQueue::FailedExecution.count,
-        processes: ::SolidQueue::Process.count
-      }
-      @cache_stats = {
-        entries:   ::SolidCache::Entry.count,
-        byte_size: ::SolidCache::Entry.sum(:byte_size)
-      }
-      @cable_stats = {
-        messages: ::SolidCable::Message.count,
-        channels: ::SolidCable::Message.distinct.count(:channel)
-      }
+      @queue_stats = QueueStats.new.to_h
+      @cache_stats = CacheStats.new.to_h
+      @cable_stats = CableStats.new.to_h
+      @throughput  = ThroughputSparkline.new
     end
   end
 end

data/app/controllers/solid_stack_web/failed_jobs/selections_controller.rb

@@ -1,22 +1,28 @@
 module SolidStackWeb
   module FailedJobs
     class SelectionsController < ApplicationController
+      before_action :set_ids
+
       def create
-        ids = Array(params[:job_ids]).map(&:to_i).reject(&:zero?)
-        SolidQueue::FailedExecution.where(id: ids).each(&:retry)
+        SolidQueue::FailedExecution.where(id: @ids).each(&:retry)
         redirect_to failed_jobs_path
       rescue => e
         redirect_to failed_jobs_path, alert: "Could not retry jobs: #{e.message}"
       end
 
       def destroy
-        ids     = Array(params[:job_ids]).map(&:to_i).reject(&:zero?)
-        job_ids = SolidQueue::FailedExecution.where(id: ids).pluck(:job_id)
+        job_ids = SolidQueue::FailedExecution.where(id: @ids).pluck(:job_id)
         SolidQueue::Job.where(id: job_ids).destroy_all
         redirect_to failed_jobs_path
       rescue => e
         redirect_to failed_jobs_path, alert: "Could not discard jobs: #{e.message}"
       end
+
+      private
+
+      def set_ids
+        @ids = Array(params[:job_ids]).map(&:to_i).reject(&:zero?)
+      end
     end
   end
 end

data/app/controllers/solid_stack_web/history_controller.rb

@@ -0,0 +1,42 @@
+module SolidStackWeb
+  class HistoryController < ApplicationController
+    before_action :set_filters
+
+    def index
+      respond_to do |format|
+        format.html { @pagy, @jobs = pagy(filtered_scope) }
+        format.csv do
+          send_data history_csv(filtered_scope),
+                    filename: "job-history-#{Date.today}.csv",
+                    type: "text/csv", disposition: "attachment"
+        end
+      end
+    end
+
+    private
+
+    def set_filters
+      @queue  = params[:queue].presence
+      @search = params[:q].presence
+      @period = params[:period].presence_in(PERIOD_DURATIONS.keys)
+    end
+
+    def filtered_scope
+      scope = SolidQueue::Job.where.not(finished_at: nil).order(finished_at: :desc)
+      scope = scope.where(queue_name: @queue)                                 if @queue.present?
+      scope = scope.where("class_name LIKE ?", "%#{@search}%")               if @search.present?
+      scope = scope.where("finished_at >= ?", PERIOD_DURATIONS[@period].ago) if @period.present?
+      scope
+    end
+
+    def history_csv(scope)
+      CSV.generate(headers: true) do |csv|
+        csv << %w[id class_name queue_name duration_seconds finished_at]
+        scope.order(finished_at: :desc).each do |job|
+          duration = job.finished_at && job.created_at ? (job.finished_at - job.created_at).round : nil
+          csv << [job.id, job.class_name, job.queue_name, duration, job.finished_at.iso8601]
+        end
+      end
+    end
+  end
+end

data/app/controllers/solid_stack_web/metrics_controller.rb

@@ -0,0 +1,15 @@
+module SolidStackWeb
+  class MetricsController < ApplicationController
+    def index
+      queue_stats = QueueStats.new.to_h
+      AlertWebhook.check(queue_stats)
+
+      render json: {
+        queue:        queue_stats,
+        cache:        CacheStats.new.to_h,
+        cable:        CableStats.new.to_h,
+        generated_at: Time.current.iso8601
+      }
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module SolidStackWeb
+  class Queues::PausesController < ApplicationController
+    def create
+      ::SolidQueue::Pause.find_or_create_by!(queue_name: params[:queue_id])
+      redirect_back_or_to queues_path
+    end
+
+    def destroy
+      ::SolidQueue::Pause.find_by(queue_name: params[:queue_id])&.destroy
+      redirect_back_or_to queues_path
+    end
+  end
+end

data/app/controllers/solid_stack_web/queues_controller.rb

@@ -11,16 +11,21 @@ module SolidStackWeb
           paused: paused.include?(name)
         }
       end
-    end
 
-    def pause
-      ::SolidQueue::Pause.find_or_create_by!(queue_name: params[:id])
-      redirect_to queues_path
+      @sparklines = @queues.each_with_object({}) do |queue, h|
+        h[queue[:name]] = QueueDepthSparkline.new(queue[:name])
+      end
     end
 
-    def resume
-      ::SolidQueue::Pause.find_by(queue_name: params[:id])&.destroy
-      redirect_to queues_path
+    def show
+      @queue_name = params[:id]
+      @paused     = ::SolidQueue::Pause.exists?(queue_name: @queue_name)
+      @pagy, @executions = pagy(
+        ::SolidQueue::ReadyExecution
+          .where(queue_name: @queue_name)
+          .includes(:job)
+          .order(created_at: :desc)
+      )
     end
   end
 end

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

@@ -0,0 +1,18 @@
+module SolidStackWeb
+  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_stack_web/recurring_tasks_controller.rb

@@ -0,0 +1,7 @@
+module SolidStackWeb
+  class RecurringTasksController < ApplicationController
+    def index
+      @recurring_tasks = SolidQueue::RecurringTask.includes(:recurring_executions).order(:key)
+    end
+  end
+end

data/app/controllers/solid_stack_web/scheduled_jobs_controller.rb

@@ -0,0 +1,52 @@
+module SolidStackWeb
+  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/controllers/solid_stack_web/stats_controller.rb

@@ -0,0 +1,39 @@
+module SolidStackWeb
+  class StatsController < ApplicationController
+    SORTABLE_COLUMNS = %w[class_name count avg p50 p95 min max].freeze
+
+    def index
+      @sort      = params[:sort].presence_in(SORTABLE_COLUMNS) || "p95"
+      @direction = params[:direction] == "asc" ? "asc" : "desc"
+
+      jobs   = SolidQueue::Job.where.not(finished_at: nil).select(:class_name, :created_at, :finished_at)
+      @stats = build_stats(jobs)
+      @stats.sort_by! { |row| row[@sort.to_sym] || 0 }
+      @stats.reverse! if @direction == "desc"
+    end
+
+    private
+
+    def build_stats(jobs)
+      jobs.group_by(&:class_name).map do |class_name, group|
+        durations = group.map { |j| (j.finished_at - j.created_at).to_f }.sort
+        count     = durations.size
+        {
+          class_name: class_name,
+          count:      count,
+          avg:        durations.sum / count,
+          min:        durations.first,
+          max:        durations.last,
+          p50:        percentile(durations, 50),
+          p95:        percentile(durations, 95)
+        }
+      end
+    end
+
+    def percentile(sorted, pct)
+      return 0.0 if sorted.empty?
+      k = (sorted.size - 1) * pct / 100.0
+      sorted[k.floor] + (sorted[k.ceil] - sorted[k.floor]) * (k - k.floor)
+    end
+  end
+end