solid_queue_monitor 1.0.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c553f4dcd107a4dbeeb008daa21593d2257ad6885d22da7dd98531fe2e91c0d
-  data.tar.gz: 641f2c00f74fb0bbcef85d22f3ad9d8cae809b3624bfb48f8366a03ed7ab924d
+  metadata.gz: bc739f10c21ca234c61c65a5b94d9c548cfc8d332dac0d1db3311d0d113fe035
+  data.tar.gz: 4a131b01c6c3e330b46413029278dbcee09e4f6410f1edf44b14da5902ec5b1a
 SHA512:
-  metadata.gz: fa09c1f8f00e1add829d6c77dc9acc81833ce247c504b4c0dd3f916b2fd399e6684c6b5dc9ceb1942ea19a42219ef2b2311e42fe069ece66cf897dc3062fa0d5
-  data.tar.gz: '079cffeabf96b8f22fef6a41acf074aba277ee6e65faf8a148f80b66ea8bad935cc80363f355b48dcd41200d2b360791a64dc7c2d0377882bce02ed12352e1f4'
+  metadata.gz: 02b79913620ac69eb63c15b2c92a1ba76f44f981036f977eb72fe684faa28ae2057ea187582e8bbd5cb09c0de9f030be89e07b8e8e8e754ee0ffebd6e7c33f84
+  data.tar.gz: 853dc16edd433afa568a7cef1efb78b295d54595a72e1e7c177e7991ff50b3e396d80ab1092754e65972dbe0fa9072e2a4563ab68b4785ebe7b5d77b5373e086

data/README.md

@@ -35,6 +35,8 @@ A lightweight, zero-dependency web interface for monitoring Solid Queue backgrou
 - **Failed Jobs**: Track and debug failed jobs, with the ability to retry or discard them
 - **Queue Management**: View and filter jobs by queue with pause/resume controls
 - **Pause/Resume Queues**: Temporarily stop processing jobs on specific queues for incident response
+- **Global Search**: Search across all job types by class name, queue, arguments, job ID, and error messages
+- **Sortable Columns**: Click column headers to sort job tables by any column with ascending/descending toggle
 - **Advanced Job Filtering**: Filter jobs by class name, queue, status, and job arguments
 - **Quick Actions**: Retry or discard failed jobs, execute or reject scheduled jobs directly from any view
 - **Performance Optimized**: Designed for high-volume applications with smart pagination
@@ -70,7 +72,7 @@ A lightweight, zero-dependency web interface for monitoring Solid Queue backgrou
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'solid_queue_monitor', '~> 1.0.1'
+gem 'solid_queue_monitor', '~> 1.2'
 ```
 
 Then execute:
@@ -116,9 +118,22 @@ SolidQueueMonitor.setup do |config|
 
   # Auto-refresh interval in seconds (default: 30)
   config.auto_refresh_interval = 30
+
+  # Disable the chart on the overview page to skip chart queries entirely
+  # config.show_chart = true
 end
 ```
 
+### Performance at Scale
+
+SolidQueueMonitor is optimized for large datasets (millions of rows in `solid_queue_jobs`). All dashboard queries are designed to stay fast regardless of table size.
+
+If you don't need the job activity chart, disable it to skip chart queries entirely:
+
+```ruby
+config.show_chart = false
+```
+
 ### Authentication
 
 By default, Solid Queue Monitor does not require authentication to access the dashboard. This makes it easy to get started in development environments.

data/app/controllers/solid_queue_monitor/base_controller.rb

@@ -6,7 +6,7 @@ module SolidQueueMonitor
       PaginationService.new(relation, current_page, per_page).paginate
     end
 
-    def render_page(title, content)
+    def render_page(title, content, search_query: nil)
       # Get flash message from instance variable (set by set_flash_message) or session
       message = @flash_message
       message_type = @flash_type
@@ -27,7 +27,8 @@ module SolidQueueMonitor
         title: title,
         content: content,
         message: message,
-        message_type: message_type
+        message_type: message_type,
+        search_query: search_query
       ).generate
 
       render html: html.html_safe
@@ -90,17 +91,13 @@ module SolidQueueMonitor
         when 'completed'
           relation = relation.where.not(finished_at: nil)
         when 'failed'
-          failed_job_ids = SolidQueue::FailedExecution.pluck(:job_id)
-          relation = relation.where(id: failed_job_ids)
+          relation = relation.where(id: SolidQueue::FailedExecution.select(:job_id))
         when 'scheduled'
-          scheduled_job_ids = SolidQueue::ScheduledExecution.pluck(:job_id)
-          relation = relation.where(id: scheduled_job_ids)
+          relation = relation.where(id: SolidQueue::ScheduledExecution.select(:job_id))
         when 'pending'
-          # Pending jobs are those that are not completed, failed, or scheduled
-          failed_job_ids = SolidQueue::FailedExecution.pluck(:job_id)
-          scheduled_job_ids = SolidQueue::ScheduledExecution.pluck(:job_id)
           relation = relation.where(finished_at: nil)
-                             .where.not(id: failed_job_ids + scheduled_job_ids)
+                             .where.not(id: SolidQueue::FailedExecution.select(:job_id))
+                             .where.not(id: SolidQueue::ScheduledExecution.select(:job_id))
         end
       end
 
@@ -116,16 +113,13 @@ module SolidQueueMonitor
       return relation unless params[:class_name].present? || params[:queue_name].present? || params[:arguments].present?
 
       if params[:class_name].present?
-        job_ids = SolidQueue::Job.where('class_name LIKE ?', "%#{params[:class_name]}%").pluck(:id)
-        relation = relation.where(job_id: job_ids)
+        relation = relation.where(job_id: SolidQueue::Job.where('class_name LIKE ?', "%#{params[:class_name]}%").select(:id))
       end
 
       relation = relation.where('queue_name LIKE ?', "%#{params[:queue_name]}%") if params[:queue_name].present?
 
-      # Add arguments filtering
       if params[:arguments].present?
-        job_ids = SolidQueue::Job.where('arguments::text ILIKE ?', "%#{params[:arguments]}%").pluck(:id)
-        relation = relation.where(job_id: job_ids)
+        relation = relation.where(job_id: SolidQueue::Job.where('arguments::text ILIKE ?', "%#{params[:arguments]}%").select(:id))
       end
 
       relation
@@ -135,16 +129,13 @@ module SolidQueueMonitor
       return relation unless params[:class_name].present? || params[:queue_name].present? || params[:arguments].present?
 
       if params[:class_name].present?
-        job_ids = SolidQueue::Job.where('class_name LIKE ?', "%#{params[:class_name]}%").pluck(:id)
-        relation = relation.where(job_id: job_ids)
+        relation = relation.where(job_id: SolidQueue::Job.where('class_name LIKE ?', "%#{params[:class_name]}%").select(:id))
       end
 
       relation = relation.where('queue_name LIKE ?', "%#{params[:queue_name]}%") if params[:queue_name].present?
 
-      # Add arguments filtering
       if params[:arguments].present?
-        job_ids = SolidQueue::Job.where('arguments::text ILIKE ?', "%#{params[:arguments]}%").pluck(:id)
-        relation = relation.where(job_id: job_ids)
+        relation = relation.where(job_id: SolidQueue::Job.where('arguments::text ILIKE ?', "%#{params[:arguments]}%").select(:id))
       end
 
       relation
@@ -169,25 +160,19 @@ module SolidQueueMonitor
       return relation unless params[:class_name].present? || params[:queue_name].present? || params[:arguments].present?
 
       if params[:class_name].present?
-        job_ids = SolidQueue::Job.where('class_name LIKE ?', "%#{params[:class_name]}%").pluck(:id)
-        relation = relation.where(job_id: job_ids)
+        relation = relation.where(job_id: SolidQueue::Job.where('class_name LIKE ?', "%#{params[:class_name]}%").select(:id))
       end
 
       if params[:queue_name].present?
-        # Check if FailedExecution has queue_name column
-        if relation.column_names.include?('queue_name')
-          relation = relation.where('queue_name LIKE ?', "%#{params[:queue_name]}%")
-        else
-          # If not, filter by job's queue_name
-          job_ids = SolidQueue::Job.where('queue_name LIKE ?', "%#{params[:queue_name]}%").pluck(:id)
-          relation = relation.where(job_id: job_ids)
-        end
+        relation = if relation.column_names.include?('queue_name')
+                     relation.where('queue_name LIKE ?', "%#{params[:queue_name]}%")
+                   else
+                     relation.where(job_id: SolidQueue::Job.where('queue_name LIKE ?', "%#{params[:queue_name]}%").select(:id))
+                   end
       end
 
-      # Add arguments filtering
       if params[:arguments].present?
-        job_ids = SolidQueue::Job.where('arguments::text ILIKE ?', "%#{params[:arguments]}%").pluck(:id)
-        relation = relation.where(job_id: job_ids)
+        relation = relation.where(job_id: SolidQueue::Job.where('arguments::text ILIKE ?', "%#{params[:arguments]}%").select(:id))
       end
 
       relation
@@ -201,5 +186,36 @@ module SolidQueueMonitor
         status: params[:status]
       }
     end
+
+    def sort_params
+      {
+        sort_by: params[:sort_by],
+        sort_direction: params[:sort_direction]
+      }
+    end
+
+    def apply_sorting(relation, allowed_columns, default_column, default_direction = :desc)
+      column = sort_params[:sort_by]
+      direction = sort_params[:sort_direction]
+      column = default_column unless allowed_columns.include?(column)
+      direction = %w[asc desc].include?(direction) ? direction.to_sym : default_direction
+      relation.order(column => direction)
+    end
+
+    def apply_execution_sorting(relation, allowed_columns, default_column, default_direction = :desc)
+      column = sort_params[:sort_by]
+      direction = sort_params[:sort_direction]
+      column = default_column unless allowed_columns.include?(column)
+      direction = %w[asc desc].include?(direction) ? direction.to_sym : default_direction
+
+      # Columns that exist on the jobs table, not on execution tables
+      job_table_columns = %w[class_name queue_name]
+
+      if job_table_columns.include?(column)
+        relation.joins(:job).order("solid_queue_jobs.#{column}" => direction)
+      else
+        relation.order(column => direction)
+      end
+    end
   end
 end

data/app/controllers/solid_queue_monitor/failed_jobs_controller.rb

@@ -2,14 +2,18 @@
 
 module SolidQueueMonitor
   class FailedJobsController < BaseController
+    SORTABLE_COLUMNS = %w[class_name queue_name created_at].freeze
+
     def index
-      base_query = SolidQueue::FailedExecution.includes(:job).order(created_at: :desc)
-      @failed_jobs = paginate(filter_failed_jobs(base_query))
+      base_query = SolidQueue::FailedExecution.includes(:job)
+      sorted_query = apply_execution_sorting(filter_failed_jobs(base_query), SORTABLE_COLUMNS, 'created_at', :desc)
+      @failed_jobs = paginate(sorted_query)
 
       render_page('Failed Jobs', SolidQueueMonitor::FailedJobsPresenter.new(@failed_jobs[:records],
                                                                             current_page: @failed_jobs[:current_page],
                                                                             total_pages: @failed_jobs[:total_pages],
-                                                                            filters: filter_params).render)
+                                                                            filters: filter_params,
+                                                                            sort: sort_params).render)
     end
 
     def retry

data/app/controllers/solid_queue_monitor/in_progress_jobs_controller.rb

@@ -2,14 +2,18 @@
 
 module SolidQueueMonitor
   class InProgressJobsController < BaseController
+    SORTABLE_COLUMNS = %w[class_name queue_name created_at].freeze
+
     def index
-      base_query = SolidQueue::ClaimedExecution.includes(:job).order(created_at: :desc)
-      @in_progress_jobs = paginate(filter_in_progress_jobs(base_query))
+      base_query = SolidQueue::ClaimedExecution.includes(:job)
+      sorted_query = apply_execution_sorting(filter_in_progress_jobs(base_query), SORTABLE_COLUMNS, 'created_at', :desc)
+      @in_progress_jobs = paginate(sorted_query)
 
       render_page('In Progress Jobs', SolidQueueMonitor::InProgressJobsPresenter.new(@in_progress_jobs[:records],
                                                                                      current_page: @in_progress_jobs[:current_page],
                                                                                      total_pages: @in_progress_jobs[:total_pages],
-                                                                                     filters: filter_params).render)
+                                                                                     filters: filter_params,
+                                                                                     sort: sort_params).render)
     end
 
     private
@@ -18,13 +22,11 @@ module SolidQueueMonitor
       return relation if params[:class_name].blank? && params[:arguments].blank?
 
       if params[:class_name].present?
-        job_ids = SolidQueue::Job.where('class_name LIKE ?', "%#{params[:class_name]}%").pluck(:id)
-        relation = relation.where(job_id: job_ids)
+        relation = relation.where(job_id: SolidQueue::Job.where('class_name LIKE ?', "%#{params[:class_name]}%").select(:id))
       end
 
       if params[:arguments].present?
-        job_ids = SolidQueue::Job.where('arguments::text ILIKE ?', "%#{params[:arguments]}%").pluck(:id)
-        relation = relation.where(job_id: job_ids)
+        relation = relation.where(job_id: SolidQueue::Job.where('arguments::text ILIKE ?', "%#{params[:arguments]}%").select(:id))
       end
 
       relation

data/app/controllers/solid_queue_monitor/overview_controller.rb

@@ -2,12 +2,15 @@
 
 module SolidQueueMonitor
   class OverviewController < BaseController
+    SORTABLE_COLUMNS = %w[class_name queue_name created_at].freeze
+
     def index
       @stats = SolidQueueMonitor::StatsCalculator.calculate
-      @chart_data = SolidQueueMonitor::ChartDataService.new(time_range: time_range_param).calculate
+      @chart_data = SolidQueueMonitor.show_chart ? SolidQueueMonitor::ChartDataService.new(time_range: time_range_param).calculate : nil
 
-      recent_jobs_query = SolidQueue::Job.order(created_at: :desc).limit(100)
-      @recent_jobs = paginate(filter_jobs(recent_jobs_query))
+      recent_jobs_query = SolidQueue::Job.limit(100)
+      sorted_query = apply_sorting(filter_jobs(recent_jobs_query), SORTABLE_COLUMNS, 'created_at', :desc)
+      @recent_jobs = paginate(sorted_query)
 
       preload_job_statuses(@recent_jobs[:records])
 
@@ -26,12 +29,13 @@ module SolidQueueMonitor
     end
 
     def generate_overview_content
-      SolidQueueMonitor::StatsPresenter.new(@stats).render +
-        SolidQueueMonitor::ChartPresenter.new(@chart_data).render +
-        SolidQueueMonitor::JobsPresenter.new(@recent_jobs[:records],
-                                             current_page: @recent_jobs[:current_page],
-                                             total_pages: @recent_jobs[:total_pages],
-                                             filters: filter_params).render
+      html = SolidQueueMonitor::StatsPresenter.new(@stats).render
+      html += SolidQueueMonitor::ChartPresenter.new(@chart_data).render if @chart_data
+      html + SolidQueueMonitor::JobsPresenter.new(@recent_jobs[:records],
+                                                  current_page: @recent_jobs[:current_page],
+                                                  total_pages: @recent_jobs[:total_pages],
+                                                  filters: filter_params,
+                                                  sort: sort_params).render
     end
   end
 end

data/app/controllers/solid_queue_monitor/queues_controller.rb

@@ -2,13 +2,21 @@
 
 module SolidQueueMonitor
   class QueuesController < BaseController
+    SORTABLE_COLUMNS = %w[queue_name job_count].freeze
+    QUEUE_DETAILS_SORTABLE_COLUMNS = %w[class_name created_at].freeze
+
     def index
-      @queues = SolidQueue::Job.group(:queue_name)
-                               .select('queue_name, COUNT(*) as job_count')
-                               .order('job_count DESC')
+      base_query = SolidQueue::Job.group(:queue_name)
+                                  .select('queue_name, COUNT(*) as job_count')
+      @queues = apply_queue_sorting(base_query)
       @paused_queues = QueuePauseService.paused_queues
+      @queue_stats = aggregate_queue_stats
 
-      render_page('Queues', SolidQueueMonitor::QueuesPresenter.new(@queues, @paused_queues).render)
+      render_page('Queues', SolidQueueMonitor::QueuesPresenter.new(
+        @queues, @paused_queues,
+        queue_stats: @queue_stats,
+        sort: sort_params
+      ).render)
     end
 
     def show
@@ -16,9 +24,9 @@ module SolidQueueMonitor
       @paused = QueuePauseService.paused_queues.include?(@queue_name)
 
       # Get all jobs for this queue with filtering and pagination
-      base_query = SolidQueue::Job.where(queue_name: @queue_name).order(created_at: :desc)
-      filtered_query = filter_queue_jobs(base_query)
-      @jobs = paginate(filtered_query)
+      base_query = SolidQueue::Job.where(queue_name: @queue_name)
+      sorted_query = apply_sorting(filter_queue_jobs(base_query), QUEUE_DETAILS_SORTABLE_COLUMNS, 'created_at', :desc)
+      @jobs = paginate(sorted_query)
       preload_job_statuses(@jobs[:records])
 
       @counts = calculate_queue_counts(@queue_name)
@@ -31,7 +39,8 @@ module SolidQueueMonitor
                     counts: @counts,
                     current_page: @jobs[:current_page],
                     total_pages: @jobs[:total_pages],
-                    filters: queue_filter_params
+                    filters: queue_filter_params,
+                    sort: sort_params
                   ).render)
     end
 
@@ -53,6 +62,15 @@ module SolidQueueMonitor
 
     private
 
+    def aggregate_queue_stats
+      {
+        ready: SolidQueue::ReadyExecution.group(:queue_name).count,
+        scheduled: SolidQueue::ScheduledExecution.group(:queue_name).count,
+        failed: SolidQueue::FailedExecution.joins(:job)
+                                           .group('solid_queue_jobs.queue_name').count
+      }
+    end
+
     def calculate_queue_counts(queue_name)
       {
         total: SolidQueue::Job.where(queue_name: queue_name).count,
@@ -73,17 +91,13 @@ module SolidQueueMonitor
         when 'completed'
           relation = relation.where.not(finished_at: nil)
         when 'failed'
-          failed_job_ids = SolidQueue::FailedExecution.pluck(:job_id)
-          relation = relation.where(id: failed_job_ids)
+          relation = relation.where(id: SolidQueue::FailedExecution.select(:job_id))
         when 'scheduled'
-          scheduled_job_ids = SolidQueue::ScheduledExecution.pluck(:job_id)
-          relation = relation.where(id: scheduled_job_ids)
+          relation = relation.where(id: SolidQueue::ScheduledExecution.select(:job_id))
         when 'pending'
-          ready_job_ids = SolidQueue::ReadyExecution.pluck(:job_id)
-          relation = relation.where(id: ready_job_ids)
+          relation = relation.where(id: SolidQueue::ReadyExecution.select(:job_id))
         when 'in_progress'
-          claimed_job_ids = SolidQueue::ClaimedExecution.pluck(:job_id)
-          relation = relation.where(id: claimed_job_ids)
+          relation = relation.where(id: SolidQueue::ClaimedExecution.select(:job_id))
         end
       end
 
@@ -97,5 +111,14 @@ module SolidQueueMonitor
         status: params[:status]
       }
     end
+
+    def apply_queue_sorting(relation)
+      column = sort_params[:sort_by]
+      direction = sort_params[:sort_direction]
+      column = 'job_count' unless SORTABLE_COLUMNS.include?(column)
+      direction = 'desc' unless %w[asc desc].include?(direction)
+
+      relation.order("#{column} #{direction}")
+    end
   end
 end

data/app/controllers/solid_queue_monitor/ready_jobs_controller.rb

@@ -2,14 +2,18 @@
 
 module SolidQueueMonitor
   class ReadyJobsController < BaseController
+    SORTABLE_COLUMNS = %w[class_name queue_name priority created_at].freeze
+
     def index
-      base_query = SolidQueue::ReadyExecution.includes(:job).order(created_at: :desc)
-      @ready_jobs = paginate(filter_ready_jobs(base_query))
+      base_query = SolidQueue::ReadyExecution.includes(:job)
+      sorted_query = apply_execution_sorting(filter_ready_jobs(base_query), SORTABLE_COLUMNS, 'created_at', :desc)
+      @ready_jobs = paginate(sorted_query)
 
       render_page('Ready Jobs', SolidQueueMonitor::ReadyJobsPresenter.new(@ready_jobs[:records],
                                                                           current_page: @ready_jobs[:current_page],
                                                                           total_pages: @ready_jobs[:total_pages],
-                                                                          filters: filter_params).render)
+                                                                          filters: filter_params,
+                                                                          sort: sort_params).render)
     end
   end
 end

data/app/controllers/solid_queue_monitor/recurring_jobs_controller.rb

@@ -2,14 +2,18 @@
 
 module SolidQueueMonitor
   class RecurringJobsController < BaseController
+    SORTABLE_COLUMNS = %w[key class_name queue_name priority].freeze
+
     def index
-      base_query = filter_recurring_jobs(SolidQueue::RecurringTask.order(:key))
-      @recurring_jobs = paginate(base_query)
+      base_query = filter_recurring_jobs(SolidQueue::RecurringTask.all)
+      sorted_query = apply_sorting(base_query, SORTABLE_COLUMNS, 'key', :asc)
+      @recurring_jobs = paginate(sorted_query)
 
       render_page('Recurring Jobs', SolidQueueMonitor::RecurringJobsPresenter.new(@recurring_jobs[:records],
                                                                                   current_page: @recurring_jobs[:current_page],
                                                                                   total_pages: @recurring_jobs[:total_pages],
-                                                                                  filters: filter_params).render)
+                                                                                  filters: filter_params,
+                                                                                  sort: sort_params).render)
     end
   end
 end

data/app/controllers/solid_queue_monitor/scheduled_jobs_controller.rb

@@ -2,14 +2,18 @@
 
 module SolidQueueMonitor
   class ScheduledJobsController < BaseController
+    SORTABLE_COLUMNS = %w[class_name queue_name scheduled_at].freeze
+
     def index
-      base_query = SolidQueue::ScheduledExecution.includes(:job).order(scheduled_at: :asc)
-      @scheduled_jobs = paginate(filter_scheduled_jobs(base_query))
+      base_query = SolidQueue::ScheduledExecution.includes(:job)
+      sorted_query = apply_execution_sorting(filter_scheduled_jobs(base_query), SORTABLE_COLUMNS, 'scheduled_at', :asc)
+      @scheduled_jobs = paginate(sorted_query)
 
       render_page('Scheduled Jobs', SolidQueueMonitor::ScheduledJobsPresenter.new(@scheduled_jobs[:records],
                                                                                   current_page: @scheduled_jobs[:current_page],
                                                                                   total_pages: @scheduled_jobs[:total_pages],
-                                                                                  filters: filter_params).render)
+                                                                                  filters: filter_params,
+                                                                                  sort: sort_params).render)
     end
 
     def create

data/app/controllers/solid_queue_monitor/search_controller.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module SolidQueueMonitor
+  class SearchController < BaseController
+    def index
+      query = params[:q]
+      results = SearchService.new(query).search
+
+      render_page('Search', SearchResultsPresenter.new(query, results).render, search_query: query)
+    end
+  end
+end

data/app/controllers/solid_queue_monitor/workers_controller.rb

@@ -2,16 +2,19 @@
 
 module SolidQueueMonitor
   class WorkersController < BaseController
+    SORTABLE_COLUMNS = %w[hostname last_heartbeat_at].freeze
+
     def index
-      base_query = SolidQueue::Process.order(created_at: :desc)
-      filtered_query = filter_workers(base_query)
-      @processes = paginate(filtered_query)
+      base_query = SolidQueue::Process.all
+      sorted_query = apply_sorting(filter_workers(base_query), SORTABLE_COLUMNS, 'last_heartbeat_at', :desc)
+      @processes = paginate(sorted_query)
 
       render_page('Workers', SolidQueueMonitor::WorkersPresenter.new(
         @processes[:records],
         current_page: @processes[:current_page],
         total_pages: @processes[:total_pages],
-        filters: worker_filter_params
+        filters: worker_filter_params,
+        sort: sort_params
       ).render)
     end
 

data/app/presenters/solid_queue_monitor/base_presenter.rb

@@ -118,6 +118,34 @@ module SolidQueueMonitor
       "<a href=\"#{queue_details_path(queue_name: queue_name)}\" class=\"#{classes}\">#{queue_name}</a>"
     end
 
+    def sortable_header(column, label)
+      return "<th>#{label}</th>" unless @sort
+
+      column_str = column.to_s
+      is_active = @sort[:sort_by] == column_str
+      next_direction = is_active && @sort[:sort_direction] == 'asc' ? 'desc' : 'asc'
+      arrow = sort_arrow(is_active)
+      css_class = is_active ? 'sortable-header active' : 'sortable-header'
+
+      "<th><a href=\"?sort_by=#{column}&sort_direction=#{next_direction}#{filter_query_string}\" class=\"#{css_class}\">#{label}#{arrow}</a></th>"
+    end
+
+    def sort_arrow(is_active)
+      return ' &udarr;' unless is_active
+
+      @sort[:sort_direction] == 'asc' ? ' &uarr;' : ' &darr;'
+    end
+
+    def filter_query_string
+      params = []
+      params << "class_name=#{@filters[:class_name]}" if @filters && @filters[:class_name].present?
+      params << "queue_name=#{@filters[:queue_name]}" if @filters && @filters[:queue_name].present?
+      params << "arguments=#{@filters[:arguments]}" if @filters && @filters[:arguments].present?
+      params << "status=#{@filters[:status]}" if @filters && @filters[:status].present?
+
+      params.empty? ? '' : "&#{params.join('&')}"
+    end
+
     def request_path
       if defined?(controller) && controller.respond_to?(:request)
         controller.request.path
@@ -138,14 +166,28 @@ module SolidQueueMonitor
     private
 
     def query_params
-      params = []
-      params << "class_name=#{@filters[:class_name]}" if @filters && @filters[:class_name].present?
-      params << "queue_name=#{@filters[:queue_name]}" if @filters && @filters[:queue_name].present?
-      params << "status=#{@filters[:status]}" if @filters && @filters[:status].present?
-
+      params = build_filter_params + build_sort_params
       params.empty? ? '' : "&#{params.join('&')}"
     end
 
+    def build_filter_params
+      return [] unless @filters
+
+      filter_keys = %i[class_name queue_name status]
+      filter_keys.filter_map do |key|
+        "#{key}=#{@filters[key]}" if @filters[key].present?
+      end
+    end
+
+    def build_sort_params
+      return [] unless @sort
+
+      sort_keys = %i[sort_by sort_direction]
+      sort_keys.filter_map do |key|
+        "#{key}=#{@sort[key]}" if @sort[key].present?
+      end
+    end
+
     def full_path(route_name, *args)
       SolidQueueMonitor::Engine.routes.url_helpers.send(route_name, *args)
     rescue NoMethodError

data/app/presenters/solid_queue_monitor/failed_jobs_presenter.rb

@@ -5,11 +5,12 @@ module SolidQueueMonitor
     include Rails.application.routes.url_helpers
     include SolidQueueMonitor::Engine.routes.url_helpers
 
-    def initialize(jobs, current_page: 1, total_pages: 1, filters: {})
+    def initialize(jobs, current_page: 1, total_pages: 1, filters: {}, sort: {})
       @jobs = jobs
       @current_page = current_page
       @total_pages = total_pages
       @filters = filters
+      @sort = sort
     end
 
     def render
@@ -60,10 +61,11 @@ module SolidQueueMonitor
               <thead>
                 <tr>
                   <th><input type="checkbox" id="select-all" class="select-all-checkbox"></th>
-                  <th>Job</th>
-                  <th>Queue</th>
+                  #{sortable_header('class_name', 'Job')}
+                  #{sortable_header('queue_name', 'Queue')}
                   <th>Error</th>
                   <th>Arguments</th>
+                  #{sortable_header('created_at', 'Failed At')}
                   <th>Actions</th>
                 </tr>
               </thead>
@@ -261,11 +263,9 @@ module SolidQueueMonitor
           </td>
           <td>
             <div class="error-message">#{error[:message].to_s.truncate(100)}</div>
-            <div class="job-meta">
-              <span class="job-timestamp">Failed at: #{format_datetime(failed_execution.created_at)}</span>
-            </div>
           </td>
           <td>#{format_arguments(job.arguments)}</td>
+          <td>#{format_datetime(failed_execution.created_at)}</td>
           <td class="actions-cell">
             <div class="job-actions">
               <a href="javascript:void(0)"#{' '}

data/app/presenters/solid_queue_monitor/in_progress_jobs_presenter.rb

@@ -4,11 +4,12 @@ module SolidQueueMonitor
   class InProgressJobsPresenter < BasePresenter
     include SolidQueueMonitor::Engine.routes.url_helpers
 
-    def initialize(jobs, current_page: 1, total_pages: 1, filters: {})
+    def initialize(jobs, current_page: 1, total_pages: 1, filters: {}, sort: {})
       @jobs = jobs
       @current_page = current_page
       @total_pages = total_pages
       @filters = filters
+      @sort = sort
     end
 
     def render
@@ -47,10 +48,10 @@ module SolidQueueMonitor
           <table>
             <thead>
               <tr>
-                <th>Job</th>
-                <th>Queue</th>
+                #{sortable_header('class_name', 'Job')}
+                #{sortable_header('queue_name', 'Queue')}
                 <th>Arguments</th>
-                <th>Started At</th>
+                #{sortable_header('created_at', 'Started At')}
                 <th>Process ID</th>
               </tr>
             </thead>