feat: add global search functionality

Add unified search feature that allows users to search across all job
types from a single search box in the header.

Features:
- Search box in header (accessible from any page)
- Searches across Ready, Scheduled, Failed, In Progress, Completed jobs
- Also searches Recurring Tasks
- Searchable fields: class name, queue name, arguments, job ID, error messages
- Case-insensitive search with SQL injection protection
- Results grouped by category with counts
- Clickable header title links to overview page

New files:
- SearchService: Core search logic
- SearchController: Handles /search route
- SearchResultsPresenter: Renders grouped results
- Comprehensive test coverage (53 new tests)

Author: vishaltps

app/controllers/solid_queue_monitor/base_controller.rb

@@ -6,7 +6,7 @@ def paginate(relation)
       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 @@ def render_page(title, content)
         title: title,
         content: content,
         message: message,
-        message_type: message_type
+        message_type: message_type,
+        search_query: search_query
       ).generate
 
       render html: html.html_safe

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

app/presenters/solid_queue_monitor/search_results_presenter.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module SolidQueueMonitor
+  class SearchResultsPresenter < BasePresenter
+    def initialize(query, results)
+      @query = query
+      @results = results
+    end
+
+    def render
+      section_wrapper('Search Results', generate_content)
+    end
+
+    private
+
+    def generate_content
+      if @query.blank?
+        generate_empty_query_message
+      elsif total_count.zero?
+        generate_no_results_message
+      else
+        generate_results_summary + generate_all_sections
+      end
+    end
+
+    def generate_empty_query_message
+      <<-HTML
+        <div class="empty-state">
+          <p>Enter a search term in the header to find jobs across all categories.</p>
+        </div>
+      HTML
+    end
+
+    def generate_no_results_message
+      <<-HTML
+        <div class="empty-state">
+          <p>No results found for "#{escape_html(@query)}"</p>
+          <p class="results-summary">0 results</p>
+        </div>
+      HTML
+    end
+
+    def generate_results_summary
+      <<-HTML
+        <div class="results-summary">
+          <p>Found #{total_count} #{total_count == 1 ? 'result' : 'results'} for "#{escape_html(@query)}"</p>
+        </div>
+      HTML
+    end
+
+    def generate_all_sections
+      sections = []
+      sections << generate_ready_section if @results[:ready].any?
+      sections << generate_scheduled_section if @results[:scheduled].any?
+      sections << generate_failed_section if @results[:failed].any?
+      sections << generate_in_progress_section if @results[:in_progress].any?
+      sections << generate_completed_section if @results[:completed].any?
+      sections << generate_recurring_section if @results[:recurring].any?
+      sections.join
+    end
+
+    def generate_ready_section
+      generate_section('Ready Jobs', @results[:ready]) do |execution|
+        generate_job_row(execution.job, execution.queue_name, execution.created_at)
+      end
+    end
+
+    def generate_scheduled_section
+      generate_section('Scheduled Jobs', @results[:scheduled]) do |execution|
+        generate_job_row(execution.job, execution.queue_name, execution.scheduled_at, 'Scheduled for')
+      end
+    end
+
+    def generate_failed_section
+      generate_section('Failed Jobs', @results[:failed]) do |execution|
+        generate_failed_row(execution)
+      end
+    end
+
+    def generate_in_progress_section
+      generate_section('In Progress Jobs', @results[:in_progress]) do |execution|
+        generate_job_row(execution.job, execution.job.queue_name, execution.created_at, 'Started at')
+      end
+    end
+
+    def generate_completed_section
+      generate_section('Completed Jobs', @results[:completed]) do |job|
+        generate_completed_row(job)
+      end
+    end
+
+    def generate_recurring_section
+      generate_section('Recurring Tasks', @results[:recurring]) do |task|
+        generate_recurring_row(task)
+      end
+    end
+
+    def generate_section(title, items)
+      <<-HTML
+        <div class="search-results-section">
+          <h3>#{title} (#{items.size})</h3>
+          <div class="table-container">
+            <table>
+              <thead>
+                <tr>
+                  #{section_headers(title)}
+                </tr>
+              </thead>
+              <tbody>
+                #{items.map { |item| yield(item) }.join}
+              </tbody>
+            </table>
+          </div>
+        </div>
+      HTML
+    end
+
+    def section_headers(title)
+      case title
+      when 'Recurring Tasks'
+        '<th>Key</th><th>Class</th><th>Schedule</th><th>Queue</th>'
+      when 'Failed Jobs'
+        '<th>Job</th><th>Queue</th><th>Error</th><th>Failed At</th>'
+      when 'Completed Jobs'
+        '<th>Job</th><th>Queue</th><th>Arguments</th><th>Completed At</th>'
+      else
+        '<th>Job</th><th>Queue</th><th>Arguments</th><th>Time</th>'
+      end
+    end
+
+    def generate_job_row(job, queue_name, time, time_label = 'Created at')
+      <<-HTML
+        <tr>
+          <td><a href="#{job_path(job)}" class="job-class-link">#{job.class_name}</a></td>
+          <td>#{queue_link(queue_name)}</td>
+          <td>#{format_arguments(job.arguments)}</td>
+          <td>
+            <span class="job-timestamp">#{time_label}: #{format_datetime(time)}</span>
+          </td>
+        </tr>
+      HTML
+    end
+
+    def generate_failed_row(execution)
+      job = execution.job
+      <<-HTML
+        <tr>
+          <td><a href="#{job_path(job)}" class="job-class-link">#{job.class_name}</a></td>
+          <td>#{queue_link(job.queue_name)}</td>
+          <td><div class="error-message">#{escape_html(execution.error.to_s.truncate(100))}</div></td>
+          <td>
+            <span class="job-timestamp">#{format_datetime(execution.created_at)}</span>
+          </td>
+        </tr>
+      HTML
+    end
+
+    def generate_completed_row(job)
+      <<-HTML
+        <tr>
+          <td><a href="#{job_path(job)}" class="job-class-link">#{job.class_name}</a></td>
+          <td>#{queue_link(job.queue_name)}</td>
+          <td>#{format_arguments(job.arguments)}</td>
+          <td>
+            <span class="job-timestamp">#{format_datetime(job.finished_at)}</span>
+          </td>
+        </tr>
+      HTML
+    end
+
+    def generate_recurring_row(task)
+      <<-HTML
+        <tr>
+          <td><strong>#{task.key}</strong></td>
+          <td>#{task.class_name || '-'}</td>
+          <td><code>#{task.schedule}</code></td>
+          <td>#{queue_link(task.queue_name)}</td>
+        </tr>
+      HTML
+    end
+
+    def total_count
+      @total_count ||= @results.values.sum(&:size)
+    end
+
+    def escape_html(text)
+      text.to_s.gsub('&', '&amp;').gsub('<', '&lt;').gsub('>', '&gt;').gsub('"', '&quot;')
+    end
+  end
+end

app/services/solid_queue_monitor/html_generator.rb

@@ -5,11 +5,12 @@ class HtmlGenerator
     include Rails.application.routes.url_helpers
     include SolidQueueMonitor::Engine.routes.url_helpers
 
-    def initialize(title:, content:, message: nil, message_type: nil)
+    def initialize(title:, content:, message: nil, message_type: nil, search_query: nil)
       @title = title
       @content = content
       @message = message
       @message_type = message_type
+      @search_query = search_query
     end
 
     def generate
@@ -107,7 +108,8 @@ def generate_header
       <<-HTML
         <header>
           <div class="header-top">
-            <h1>Solid Queue Monitor</h1>
+            <h1><a href="#{root_path}" class="header-title-link">Solid Queue Monitor</a></h1>
+            #{generate_search_box}
             <div class="header-controls">
               #{generate_auto_refresh_controls}
               #{generate_theme_toggle}
@@ -128,6 +130,25 @@ def generate_footer
       HTML
     end
 
+    def generate_search_box
+      search_value = @search_query ? escape_html(@search_query) : ''
+      <<-HTML
+        <form method="get" action="#{search_path}" class="header-search-form">
+          <input type="text" name="q" value="#{search_value}" placeholder="Search by class, queue, job ID, or error..." class="header-search-input">
+          <button type="submit" class="header-search-button" title="Search">
+            <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+              <circle cx="11" cy="11" r="8"></circle>
+              <line x1="21" y1="21" x2="16.65" y2="16.65"></line>
+            </svg>
+          </button>
+        </form>
+      HTML
+    end
+
+    def escape_html(text)
+      text.to_s.gsub('&', '&amp;').gsub('<', '&lt;').gsub('>', '&gt;').gsub('"', '&quot;')
+    end
+
     def generate_auto_refresh_controls
       return '' unless SolidQueueMonitor.auto_refresh_enabled
 

app/services/solid_queue_monitor/search_service.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module SolidQueueMonitor
+  class SearchService
+    RESULTS_LIMIT = 25
+
+    def initialize(query)
+      @query = query
+    end
+
+    def search
+      return empty_results if @query.blank?
+
+      term = "%#{sanitize_query(@query)}%"
+
+      {
+        ready: search_ready_jobs(term),
+        scheduled: search_scheduled_jobs(term),
+        failed: search_failed_jobs(term),
+        in_progress: search_in_progress_jobs(term),
+        completed: search_completed_jobs(term),
+        recurring: search_recurring_tasks(term)
+      }
+    end
+
+    private
+
+    def empty_results
+      {
+        ready: [],
+        scheduled: [],
+        failed: [],
+        in_progress: [],
+        completed: [],
+        recurring: []
+      }
+    end
+
+    def sanitize_query(query)
+      # Escape % to prevent LIKE pattern injection
+      # We don't escape _ because it requires database-specific ESCAPE clauses
+      query.to_s.gsub('%', '\%')
+    end
+
+    def search_ready_jobs(term)
+      SolidQueue::ReadyExecution
+        .joins(:job)
+        .where(job_search_conditions, term: term)
+        .includes(:job)
+        .limit(RESULTS_LIMIT)
+    end
+
+    def search_scheduled_jobs(term)
+      SolidQueue::ScheduledExecution
+        .joins(:job)
+        .where(job_search_conditions, term: term)
+        .includes(:job)
+        .limit(RESULTS_LIMIT)
+    end
+
+    def search_failed_jobs(term)
+      SolidQueue::FailedExecution
+        .joins(:job)
+        .where(failed_job_search_conditions, term: term)
+        .includes(:job)
+        .limit(RESULTS_LIMIT)
+    end
+
+    def search_in_progress_jobs(term)
+      SolidQueue::ClaimedExecution
+        .joins(:job)
+        .where(job_search_conditions, term: term)
+        .includes(:job)
+        .limit(RESULTS_LIMIT)
+    end
+
+    def search_completed_jobs(term)
+      SolidQueue::Job
+        .where.not(finished_at: nil)
+        .where(completed_job_search_conditions, term: term)
+        .order(finished_at: :desc)
+        .limit(RESULTS_LIMIT)
+    end
+
+    def search_recurring_tasks(term)
+      SolidQueue::RecurringTask
+        .where(recurring_task_search_conditions, term: term)
+        .limit(RESULTS_LIMIT)
+    end
+
+    def job_search_conditions
+      <<~SQL.squish
+        solid_queue_jobs.class_name LIKE :term
+        OR solid_queue_jobs.queue_name LIKE :term
+        OR solid_queue_jobs.arguments LIKE :term
+        OR solid_queue_jobs.active_job_id LIKE :term
+      SQL
+    end
+
+    def failed_job_search_conditions
+      <<~SQL.squish
+        solid_queue_jobs.class_name LIKE :term
+        OR solid_queue_jobs.queue_name LIKE :term
+        OR solid_queue_jobs.arguments LIKE :term
+        OR solid_queue_jobs.active_job_id LIKE :term
+        OR solid_queue_failed_executions.error LIKE :term
+      SQL
+    end
+
+    def completed_job_search_conditions
+      <<~SQL.squish
+        class_name LIKE :term
+        OR queue_name LIKE :term
+        OR arguments LIKE :term
+        OR active_job_id LIKE :term
+      SQL
+    end
+
+    def recurring_task_search_conditions
+      <<~SQL.squish
+        solid_queue_recurring_tasks.key LIKE :term
+        OR solid_queue_recurring_tasks.class_name LIKE :term
+      SQL
+    end
+  end
+end