solid_queue_monitor 1.0.1 → 1.2.0

data/app/presenters/solid_queue_monitor/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
@@ -73,11 +74,11 @@ module SolidQueueMonitor
             <thead>
               <tr>
                 <th>ID</th>
-                <th>Job</th>
-                <th>Queue</th>
+                #{sortable_header('class_name', 'Job')}
+                #{sortable_header('queue_name', 'Queue')}
                 <th>Arguments</th>
                 <th>Status</th>
-                <th>Created At</th>
+                #{sortable_header('created_at', 'Created At')}
                 <th>Actions</th>
               </tr>
             </thead>

data/app/presenters/solid_queue_monitor/queue_details_presenter.rb

@@ -2,7 +2,7 @@
 
 module SolidQueueMonitor
   class QueueDetailsPresenter < BasePresenter
-    def initialize(queue_name:, paused:, jobs:, counts:, current_page: 1, total_pages: 1, filters: {})
+    def initialize(queue_name:, paused:, jobs:, counts:, current_page: 1, total_pages: 1, filters: {}, sort: {})
       @queue_name = queue_name
       @paused = paused
       @jobs = jobs
@@ -10,6 +10,7 @@ module SolidQueueMonitor
       @current_page = current_page
       @total_pages = total_pages
       @filters = filters
+      @sort = sort
     end
 
     def render
@@ -129,10 +130,10 @@ module SolidQueueMonitor
             <thead>
               <tr>
                 <th>ID</th>
-                <th>Job</th>
+                #{sortable_header('class_name', 'Job')}
                 <th>Arguments</th>
                 <th>Status</th>
-                <th>Created At</th>
+                #{sortable_header('created_at', 'Created At')}
                 <th>Actions</th>
               </tr>
             </thead>

data/app/presenters/solid_queue_monitor/queues_presenter.rb

@@ -2,9 +2,11 @@
 
 module SolidQueueMonitor
   class QueuesPresenter < BasePresenter
-    def initialize(records, paused_queues = [])
-      @records = records
+    def initialize(records, paused_queues = [], sort: {}, queue_stats: {})
+      @records       = records
       @paused_queues = paused_queues
+      @sort          = sort
+      @queue_stats   = queue_stats
     end
 
     def render
@@ -19,9 +21,9 @@ module SolidQueueMonitor
           <table>
             <thead>
               <tr>
-                <th>Queue Name</th>
+                #{sortable_header('queue_name', 'Queue Name')}
                 <th>Status</th>
-                <th>Total Jobs</th>
+                #{sortable_header('job_count', 'Total Jobs')}
                 <th>Ready Jobs</th>
                 <th>Scheduled Jobs</th>
                 <th>Failed Jobs</th>
@@ -38,16 +40,16 @@ module SolidQueueMonitor
 
     def generate_row(queue)
       queue_name = queue.queue_name || 'default'
-      paused = @paused_queues.include?(queue_name)
+      paused     = @paused_queues.include?(queue_name)
 
       <<-HTML
         <tr class="#{paused ? 'queue-paused' : ''}">
           <td>#{queue_link(queue_name)}</td>
           <td>#{status_badge(paused)}</td>
           <td>#{queue.job_count}</td>
-          <td>#{ready_jobs_count(queue_name)}</td>
-          <td>#{scheduled_jobs_count(queue_name)}</td>
-          <td>#{failed_jobs_count(queue_name)}</td>
+          <td>#{@queue_stats.dig(:ready, queue_name) || 0}</td>
+          <td>#{@queue_stats.dig(:scheduled, queue_name) || 0}</td>
+          <td>#{@queue_stats.dig(:failed, queue_name) || 0}</td>
           <td class="actions-cell">#{action_button(queue_name, paused)}</td>
         </tr>
       HTML
@@ -83,19 +85,5 @@ module SolidQueueMonitor
         HTML
       end
     end
-
-    def ready_jobs_count(queue_name)
-      SolidQueue::ReadyExecution.where(queue_name: queue_name).count
-    end
-
-    def scheduled_jobs_count(queue_name)
-      SolidQueue::ScheduledExecution.where(queue_name: queue_name).count
-    end
-
-    def failed_jobs_count(queue_name)
-      SolidQueue::FailedExecution.joins(:job)
-                                 .where(solid_queue_jobs: { queue_name: queue_name })
-                                 .count
-    end
   end
 end

data/app/presenters/solid_queue_monitor/ready_jobs_presenter.rb

@@ -2,11 +2,12 @@
 
 module SolidQueueMonitor
   class ReadyJobsPresenter < BasePresenter
-    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
@@ -50,11 +51,11 @@ module SolidQueueMonitor
           <table>
             <thead>
               <tr>
-                <th>Job</th>
-                <th>Queue</th>
-                <th>Priority</th>
+                #{sortable_header('class_name', 'Job')}
+                #{sortable_header('queue_name', 'Queue')}
+                #{sortable_header('priority', 'Priority')}
                 <th>Arguments</th>
-                <th>Created At</th>
+                #{sortable_header('created_at', 'Created At')}
               </tr>
             </thead>
             <tbody>

data/app/presenters/solid_queue_monitor/recurring_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
@@ -48,11 +49,11 @@ module SolidQueueMonitor
           <table>
             <thead>
               <tr>
-                <th>Key</th>
-                <th>Job</th>
+                #{sortable_header('key', 'Key')}
+                #{sortable_header('class_name', 'Job')}
                 <th>Schedule</th>
-                <th>Queue</th>
-                <th>Priority</th>
+                #{sortable_header('queue_name', 'Queue')}
+                #{sortable_header('priority', 'Priority')}
                 <th>Last Updated</th>
               </tr>
             </thead>

data/app/presenters/solid_queue_monitor/scheduled_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
@@ -140,9 +141,9 @@ module SolidQueueMonitor
             <thead>
               <tr>
                 <th width="50"><input type="checkbox"></th>
-                <th>Job</th>
-                <th>Queue</th>
-                <th>Scheduled At</th>
+                #{sortable_header('class_name', 'Job')}
+                #{sortable_header('queue_name', 'Queue')}
+                #{sortable_header('scheduled_at', 'Scheduled At')}
                 <th>Arguments</th>
               </tr>
             </thead>

data/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, &block)
+      <<-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(&block).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

data/app/presenters/solid_queue_monitor/stats_presenter.rb

@@ -11,13 +11,12 @@ module SolidQueueMonitor
         <div class="stats-container">
           <h3>Queue Statistics</h3>
           <div class="stats">
-            #{generate_stat_card('Total Jobs', @stats[:total_jobs])}
+            #{generate_stat_card('Active Jobs', @stats[:active_jobs])}
             #{generate_stat_card('Ready', @stats[:ready])}
             #{generate_stat_card('In Progress', @stats[:in_progress])}
             #{generate_stat_card('Scheduled', @stats[:scheduled])}
             #{generate_stat_card('Recurring', @stats[:recurring])}
             #{generate_stat_card('Failed', @stats[:failed])}
-            #{generate_stat_card('Completed', @stats[:completed])}
           </div>
         </div>
       HTML

data/app/presenters/solid_queue_monitor/workers_presenter.rb

@@ -5,11 +5,12 @@ module SolidQueueMonitor
     HEARTBEAT_STALE_THRESHOLD = 5.minutes
     HEARTBEAT_DEAD_THRESHOLD = 10.minutes
 
-    def initialize(processes, current_page: 1, total_pages: 1, filters: {})
+    def initialize(processes, current_page: 1, total_pages: 1, filters: {}, sort: {})
       @processes = processes.to_a # Load records once to avoid multiple queries
       @current_page = current_page
       @total_pages = total_pages
       @filters = filters
+      @sort = sort
       preload_claimed_data
       calculate_summary_stats
     end
@@ -140,10 +141,10 @@ module SolidQueueMonitor
             <thead>
               <tr>
                 <th>Kind</th>
-                <th>Hostname</th>
+                #{sortable_header('hostname', 'Hostname')}
                 <th>PID</th>
                 <th>Queues</th>
-                <th>Last Heartbeat</th>
+                #{sortable_header('last_heartbeat_at', 'Last Heartbeat')}
                 <th>Status</th>
                 <th>Jobs Processing</th>
                 <th>Actions</th>

data/app/services/solid_queue_monitor/chart_data_service.rb

@@ -5,47 +5,42 @@ module SolidQueueMonitor
     TIME_RANGES = {
       '15m' => { duration: 15.minutes, buckets: 15, label_format: '%H:%M', label: 'Last 15 minutes' },
       '30m' => { duration: 30.minutes, buckets: 15, label_format: '%H:%M', label: 'Last 30 minutes' },
-      '1h' => { duration: 1.hour, buckets: 12, label_format: '%H:%M', label: 'Last 1 hour' },
-      '3h' => { duration: 3.hours, buckets: 18, label_format: '%H:%M', label: 'Last 3 hours' },
-      '6h' => { duration: 6.hours, buckets: 24, label_format: '%H:%M', label: 'Last 6 hours' },
+      '1h' => { duration: 1.hour,     buckets: 12, label_format: '%H:%M', label: 'Last 1 hour' },
+      '3h' => { duration: 3.hours,    buckets: 18, label_format: '%H:%M', label: 'Last 3 hours' },
+      '6h' => { duration: 6.hours,    buckets: 24, label_format: '%H:%M', label: 'Last 6 hours' },
       '12h' => { duration: 12.hours, buckets: 24, label_format: '%H:%M', label: 'Last 12 hours' },
-      '1d' => { duration: 1.day, buckets: 24, label_format: '%H:%M', label: 'Last 24 hours' },
-      '3d' => { duration: 3.days, buckets: 36, label_format: '%m/%d %H:%M', label: 'Last 3 days' },
-      '1w' => { duration: 7.days, buckets: 28, label_format: '%m/%d', label: 'Last 7 days' }
+      '1d' => { duration: 1.day,      buckets: 24, label_format: '%H:%M', label: 'Last 24 hours' },
+      '3d' => { duration: 3.days,     buckets: 36, label_format: '%m/%d %H:%M', label: 'Last 3 days' },
+      '1w' => { duration: 7.days,     buckets: 28, label_format: '%m/%d', label: 'Last 7 days' }
     }.freeze
 
     DEFAULT_TIME_RANGE = '1d'
 
     def initialize(time_range: DEFAULT_TIME_RANGE)
       @time_range = TIME_RANGES.key?(time_range) ? time_range : DEFAULT_TIME_RANGE
-      @config = TIME_RANGES[@time_range]
+      @config     = TIME_RANGES[@time_range]
     end
 
     def calculate
-      end_time = Time.current
-      start_time = end_time - @config[:duration]
-      bucket_duration = @config[:duration] / @config[:buckets]
+      end_time       = Time.current
+      start_time     = end_time - @config[:duration]
+      bucket_seconds = (@config[:duration] / @config[:buckets]).to_i
+      buckets        = build_buckets(start_time, bucket_seconds)
 
-      buckets = build_buckets(start_time, bucket_duration)
+      created_data   = bucket_counts(SolidQueue::Job, :created_at,  start_time, end_time, bucket_seconds)
+      completed_data = bucket_counts(SolidQueue::Job, :finished_at, start_time, end_time, bucket_seconds, exclude_nil: true)
+      failed_data    = bucket_counts(SolidQueue::FailedExecution, :created_at, start_time, end_time, bucket_seconds)
 
-      created_counts = fetch_created_counts(start_time, end_time)
-      completed_counts = fetch_completed_counts(start_time, end_time)
-      failed_counts = fetch_failed_counts(start_time, end_time)
-
-      created_data = assign_to_buckets(created_counts, buckets, bucket_duration)
-      completed_data = assign_to_buckets(completed_counts, buckets, bucket_duration)
-      failed_data = assign_to_buckets(failed_counts, buckets, bucket_duration)
+      created_arr   = fill_buckets(buckets, created_data)
+      completed_arr = fill_buckets(buckets, completed_data)
+      failed_arr    = fill_buckets(buckets, failed_data)
 
       {
         labels: buckets.map { |b| b[:label] }, # rubocop:disable Rails/Pluck
-        created: created_data,
-        completed: completed_data,
-        failed: failed_data,
-        totals: {
-          created: created_data.sum,
-          completed: completed_data.sum,
-          failed: failed_data.sum
-        },
+        created: created_arr,
+        completed: completed_arr,
+        failed: failed_arr,
+        totals: { created: created_arr.sum, completed: completed_arr.sum, failed: failed_arr.sum },
         time_range: @time_range,
         time_range_label: @config[:label],
         available_ranges: TIME_RANGES.transform_values { |v| v[:label] }
@@ -54,47 +49,48 @@ module SolidQueueMonitor
 
     private
 
-    def build_buckets(start_time, bucket_duration)
+    def build_buckets(start_time, bucket_seconds)
       @config[:buckets].times.map do |i|
-        bucket_start = start_time + (i * bucket_duration)
-        {
-          start: bucket_start,
-          end: bucket_start + bucket_duration,
-          label: bucket_start.strftime(@config[:label_format])
-        }
+        bucket_start = start_time + (i * bucket_seconds)
+        { index: i, start: bucket_start, label: bucket_start.strftime(@config[:label_format]) }
       end
     end
 
-    def fetch_created_counts(start_time, end_time)
-      SolidQueue::Job
-        .where(created_at: start_time..end_time)
-        .pluck(:created_at)
-    end
-
-    def fetch_completed_counts(start_time, end_time)
-      SolidQueue::Job
-        .where(finished_at: start_time..end_time)
-        .where.not(finished_at: nil)
-        .pluck(:finished_at)
+    # Returns a Hash of { bucket_index => count } using SQL GROUP BY.
+    # The bucket index is computed as: (epoch(column) - epoch(start_time)) / interval
+    # This works identically on PostgreSQL and SQLite.
+    def bucket_counts(model, column, start_time, end_time, interval, exclude_nil: false)
+      start_epoch = start_time.to_i
+      expr = bucket_index_expr(column, start_epoch, interval)
+
+      scope = model.where(column => start_time..end_time)
+      scope = scope.where.not(column => nil) if exclude_nil
+
+      # rubocop:disable Style/HashTransformKeys -- pluck returns Array<Array>, not Hash
+      scope
+        .group(Arel.sql(expr))
+        .pluck(Arel.sql("#{expr} AS bucket_idx, COUNT(*) AS cnt"))
+        .to_h { |idx, cnt| [idx.to_i, cnt] }
+      # rubocop:enable Style/HashTransformKeys
     end
 
-    def fetch_failed_counts(start_time, end_time)
-      SolidQueue::FailedExecution
-        .where(created_at: start_time..end_time)
-        .pluck(:created_at)
+    def fill_buckets(buckets, index_counts)
+      buckets.map { |b| index_counts.fetch(b[:index], 0) }
     end
 
-    def assign_to_buckets(timestamps, buckets, _bucket_duration)
-      counts = Array.new(buckets.size, 0)
-
-      timestamps.each do |timestamp|
-        bucket_index = buckets.find_index do |bucket|
-          timestamp >= bucket[:start] && timestamp < bucket[:end]
-        end
-        counts[bucket_index] += 1 if bucket_index
+    # Cross-DB bucket index expression.
+    # PostgreSQL: CAST((EXTRACT(EPOCH FROM col) - start) / interval AS INTEGER)
+    # SQLite:     CAST((CAST(strftime('%s', col) AS INTEGER) - start) / interval AS INTEGER)
+    def bucket_index_expr(column, start_epoch, interval_seconds)
+      if sqlite?
+        "CAST((CAST(strftime('%s', #{column}) AS INTEGER) - #{start_epoch}) / #{interval_seconds} AS INTEGER)"
+      else
+        "CAST((EXTRACT(EPOCH FROM #{column}) - #{start_epoch}) / #{interval_seconds} AS INTEGER)"
       end
+    end
 
-      counts
+    def sqlite?
+      ActiveRecord::Base.connection.adapter_name.downcase.include?('sqlite')
     end
   end
 end

data/app/services/solid_queue_monitor/html_generator.rb

@@ -5,11 +5,12 @@ module SolidQueueMonitor
     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 @@ module SolidQueueMonitor
       <<-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 @@ module SolidQueueMonitor
       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