solid_queue_monitor 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3bed1180e7bb59bb8741c6fd8607cfcec9e9b604143f4f96c3d4e6f91ae045c6
-  data.tar.gz: 5fe88544f47d2146ec5e8034aa476032bba8fbfae2fbb7bf5aa283b66650dfb8
+  metadata.gz: 385e4d7ff7dc636b9448cefef256495f8c7aefd2e3318c57a6637c69d4cb5c1e
+  data.tar.gz: c4f7d1ee427a0cd5255b345bcff159fc88f3120b893fe103fb94701c8a33f446
 SHA512:
-  metadata.gz: c59ad8d48e9414e12e86d848f029b9ad31437b6f41c842b787876ce1ae4a348d35ea6808904305c3212ec29124783b02cc7896a039a0ba7e43625842b127c552
-  data.tar.gz: 55554c085582dd57bd884b50bfebaa59e2dffa5758646e49e2744e83ea28b4c7d23d347335c5cd08df0909e312d926a6070371e5474911d52d93256585d7e96f
+  metadata.gz: 29410fb9b7d8dfba02eb65f673462c822fdef643701c637fa7531aa11cac3e5ce9530146127b32a68f2128666e71f23fd9ecd2df8de924752193274393b03b18
+  data.tar.gz: c01b1718f58067a0488d75f359d33c6ef1802105f528410f03ac52b17f1944adcc767fc7fb46500a5e88f33004497ab980328f5c948eb25d2b477c44e6c19cdf

data/README.md

@@ -16,12 +16,15 @@ A lightweight, zero-dependency web interface for monitoring Solid Queue backgrou
 ## Features
 
 - **Dashboard Overview**: Get a quick snapshot of your queue's health with statistics on all job types
+- **Job Activity Chart**: Visual line chart showing jobs created, completed, and failed over time with 9 time range options (15m to 1 week)
+- **Dark Theme**: Toggle between light and dark themes with system preference detection and localStorage persistence
 - **Ready Jobs**: View jobs that are ready to be executed
 - **In Progress Jobs**: Monitor jobs currently being processed by workers
 - **Scheduled Jobs**: See upcoming jobs scheduled for future execution with ability to execute immediately or reject permanently
 - **Recurring Jobs**: Manage periodic jobs that run on a schedule
 - **Failed Jobs**: Track and debug failed jobs, with the ability to retry or discard them
-- **Queue Management**: View and filter jobs by queue
+- **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
 - **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
@@ -32,9 +35,13 @@ A lightweight, zero-dependency web interface for monitoring Solid Queue backgrou
 
 ## Screenshots
 
-### Dashboard Overview
+### Dashboard Overview (Light Theme)
 
-![Dashboard Overview](screenshots/dashboard-3.png)
+![Dashboard Overview - Light Theme](screenshots/dashboard-light.png)
+
+### Dashboard Overview (Dark Theme)
+
+![Dashboard Overview - Dark Theme](screenshots/dashboard-dark.png)
 
 ### Failed Jobs
 
@@ -45,7 +52,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', '~> 0.4.0'
+gem 'solid_queue_monitor', '~> 0.6.0'
 ```
 
 Then execute:

data/app/controllers/solid_queue_monitor/application_controller.rb

@@ -10,8 +10,17 @@ module SolidQueueMonitor
     skip_before_action :verify_authenticity_token
 
     def set_flash_message(message, type)
-      session[:flash_message] = message
-      session[:flash_type] = type
+      # Store in instance variable for access in views
+      @flash_message = message
+      @flash_type = type
+
+      # Try to use Rails flash if available
+      begin
+        flash[:notice] = message if type == :success
+        flash[:alert] = message if type == :error
+      rescue StandardError
+        # Flash not available (e.g., no session middleware)
+      end
     end
 
     private

data/app/controllers/solid_queue_monitor/base_controller.rb

@@ -7,13 +7,21 @@ module SolidQueueMonitor
     end
 
     def render_page(title, content)
-      # Get flash message from session
-      message = session[:flash_message]
-      message_type = session[:flash_type]
-
-      # Clear the flash message from session after using it
-      session.delete(:flash_message)
-      session.delete(:flash_type)
+      # Get flash message from instance variable (set by set_flash_message) or session
+      message = @flash_message
+      message_type = @flash_type
+
+      # Try to get from session as fallback, but don't fail if session unavailable
+      begin
+        message ||= session[:flash_message]
+        message_type ||= session[:flash_type]
+
+        # Clear the flash message from session after using it
+        session.delete(:flash_message) if message
+        session.delete(:flash_type) if message_type
+      rescue StandardError
+        # Session not available (e.g., no session middleware in tests)
+      end
 
       html = SolidQueueMonitor::HtmlGenerator.new(
         title: title,

data/app/controllers/solid_queue_monitor/overview_controller.rb

@@ -4,6 +4,7 @@ module SolidQueueMonitor
   class OverviewController < BaseController
     def index
       @stats = SolidQueueMonitor::StatsCalculator.calculate
+      @chart_data = SolidQueueMonitor::ChartDataService.new(time_range: time_range_param).calculate
 
       recent_jobs_query = SolidQueue::Job.order(created_at: :desc).limit(100)
       @recent_jobs = paginate(filter_jobs(recent_jobs_query))
@@ -13,10 +14,20 @@ module SolidQueueMonitor
       render_page('Overview', generate_overview_content)
     end
 
+    def chart_data
+      chart_data = SolidQueueMonitor::ChartDataService.new(time_range: time_range_param).calculate
+      render json: chart_data
+    end
+
     private
 
+    def time_range_param
+      params[:time_range] || ChartDataService::DEFAULT_TIME_RANGE
+    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],

data/app/controllers/solid_queue_monitor/queues_controller.rb

@@ -6,8 +6,25 @@ module SolidQueueMonitor
       @queues = SolidQueue::Job.group(:queue_name)
                                .select('queue_name, COUNT(*) as job_count')
                                .order('job_count DESC')
+      @paused_queues = QueuePauseService.paused_queues
 
-      render_page('Queues', SolidQueueMonitor::QueuesPresenter.new(@queues).render)
+      render_page('Queues', SolidQueueMonitor::QueuesPresenter.new(@queues, @paused_queues).render)
+    end
+
+    def pause
+      queue_name = params[:queue_name]
+      result = QueuePauseService.new(queue_name).pause
+
+      set_flash_message(result[:message], result[:success] ? 'success' : 'error')
+      redirect_to queues_path
+    end
+
+    def resume
+      queue_name = params[:queue_name]
+      result = QueuePauseService.new(queue_name).resume
+
+      set_flash_message(result[:message], result[:success] ? 'success' : 'error')
+      redirect_to queues_path
     end
   end
 end

data/app/presenters/solid_queue_monitor/queues_presenter.rb

@@ -2,8 +2,9 @@
 
 module SolidQueueMonitor
   class QueuesPresenter < BasePresenter
-    def initialize(records)
+    def initialize(records, paused_queues = [])
       @records = records
+      @paused_queues = paused_queues
     end
 
     def render
@@ -19,10 +20,12 @@ module SolidQueueMonitor
             <thead>
               <tr>
                 <th>Queue Name</th>
+                <th>Status</th>
                 <th>Total Jobs</th>
                 <th>Ready Jobs</th>
                 <th>Scheduled Jobs</th>
                 <th>Failed Jobs</th>
+                <th>Actions</th>
               </tr>
             </thead>
             <tbody>
@@ -34,17 +37,53 @@ module SolidQueueMonitor
     end
 
     def generate_row(queue)
+      queue_name = queue.queue_name || 'default'
+      paused = @paused_queues.include?(queue_name)
+
       <<-HTML
-        <tr>
-          <td>#{queue.queue_name || 'default'}</td>
+        <tr class="#{paused ? 'queue-paused' : ''}">
+          <td>#{queue_name}</td>
+          <td>#{status_badge(paused)}</td>
           <td>#{queue.job_count}</td>
-          <td>#{ready_jobs_count(queue.queue_name)}</td>
-          <td>#{scheduled_jobs_count(queue.queue_name)}</td>
-          <td>#{failed_jobs_count(queue.queue_name)}</td>
+          <td>#{ready_jobs_count(queue_name)}</td>
+          <td>#{scheduled_jobs_count(queue_name)}</td>
+          <td>#{failed_jobs_count(queue_name)}</td>
+          <td class="actions-cell">#{action_button(queue_name, paused)}</td>
         </tr>
       HTML
     end
 
+    def status_badge(paused)
+      if paused
+        '<span class="status-badge status-paused">Paused</span>'
+      else
+        '<span class="status-badge status-active">Active</span>'
+      end
+    end
+
+    def action_button(queue_name, paused)
+      if paused
+        <<-HTML
+          <form action="#{resume_queue_path}" method="post" class="inline-form">
+            <input type="hidden" name="queue_name" value="#{queue_name}">
+            <button type="submit" class="action-button resume-button" title="Resume queue processing">
+              Resume
+            </button>
+          </form>
+        HTML
+      else
+        <<-HTML
+          <form action="#{pause_queue_path}" method="post" class="inline-form"
+                onsubmit="return confirm('Are you sure you want to pause the #{queue_name} queue? Workers will stop processing jobs from this queue.');">
+            <input type="hidden" name="queue_name" value="#{queue_name}">
+            <button type="submit" class="action-button pause-button" title="Pause queue processing">
+              Pause
+            </button>
+          </form>
+        HTML
+      end
+    end
+
     def ready_jobs_count(queue_name)
       SolidQueue::ReadyExecution.where(queue_name: queue_name).count
     end

data/app/services/solid_queue_monitor/chart_data_service.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module SolidQueueMonitor
+  class ChartDataService
+    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' },
+      '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' }
+    }.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]
+    end
+
+    def calculate
+      end_time = Time.current
+      start_time = end_time - @config[:duration]
+      bucket_duration = @config[:duration] / @config[:buckets]
+
+      buckets = build_buckets(start_time, bucket_duration)
+
+      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)
+
+      {
+        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
+        },
+        time_range: @time_range,
+        time_range_label: @config[:label],
+        available_ranges: TIME_RANGES.transform_values { |v| v[:label] }
+      }
+    end
+
+    private
+
+    def build_buckets(start_time, bucket_duration)
+      @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])
+        }
+      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)
+    end
+
+    def fetch_failed_counts(start_time, end_time)
+      SolidQueue::FailedExecution
+        .where(created_at: start_time..end_time)
+        .pluck(:created_at)
+    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
+      end
+
+      counts
+    end
+  end
+end

data/app/services/solid_queue_monitor/chart_presenter.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+module SolidQueueMonitor
+  class ChartPresenter
+    CHART_WIDTH = 1200
+    CHART_HEIGHT = 280
+    PADDING = { top: 40, right: 30, bottom: 60, left: 60 }.freeze
+    COLORS = {
+      created: '#3b82f6',   # Blue
+      completed: '#10b981', # Green
+      failed: '#ef4444'     # Red
+    }.freeze
+
+    def initialize(chart_data)
+      @data = chart_data
+      @plot_width = CHART_WIDTH - PADDING[:left] - PADDING[:right]
+      @plot_height = CHART_HEIGHT - PADDING[:top] - PADDING[:bottom]
+    end
+
+    def render
+      <<-HTML
+        <div class="chart-section" id="chart-section">
+          <div class="chart-header">
+            <div class="chart-header-left">
+              <button class="chart-toggle-btn" id="chart-toggle-btn" title="Toggle chart">
+                <svg class="chart-toggle-icon" id="chart-toggle-icon" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                  <polyline points="6 9 12 15 18 9"></polyline>
+                </svg>
+              </button>
+              <h3>Job Activity</h3>
+              #{render_summary}
+            </div>
+            #{render_time_select}
+          </div>
+          <div class="chart-collapsible" id="chart-collapsible">
+            <div class="chart-container">
+              #{render_svg}
+            </div>
+            #{render_legend}
+          </div>
+        </div>
+        #{render_tooltip}
+      HTML
+    end
+
+    private
+
+    def render_summary
+      totals = @data[:totals] || { created: 0, completed: 0, failed: 0 }
+      <<-HTML
+        <span class="chart-summary">
+          <span class="summary-item summary-created">#{totals[:created]} created</span>
+          <span class="summary-separator">·</span>
+          <span class="summary-item summary-completed">#{totals[:completed]} completed</span>
+          <span class="summary-separator">·</span>
+          <span class="summary-item summary-failed">#{totals[:failed]} failed</span>
+        </span>
+      HTML
+    end
+
+    def render_time_select
+      options = @data[:available_ranges].map do |key, label|
+        selected = key == @data[:time_range] ? 'selected' : ''
+        "<option value=\"#{key}\" #{selected}>#{label}</option>"
+      end.join
+
+      <<-HTML
+        <div class="chart-time-select-wrapper">
+          <select class="chart-time-select" id="chart-time-select" onchange="window.location.href='?time_range=' + this.value">
+            #{options}
+          </select>
+        </div>
+      HTML
+    end
+
+    def render_svg
+      return render_empty_state if all_series_empty?
+
+      max_value = calculate_max_value
+      max_value = 10 if max_value.zero?
+
+      <<-SVG
+        <svg viewBox="0 0 #{CHART_WIDTH} #{CHART_HEIGHT}" class="job-activity-chart" preserveAspectRatio="xMidYMid meet">
+          #{render_grid_lines(max_value)}
+          #{render_axes}
+          #{render_x_labels}
+          #{render_y_labels(max_value)}
+          #{render_series_line(:failed, max_value)}
+          #{render_series_line(:completed, max_value)}
+          #{render_series_line(:created, max_value)}
+          #{render_series_points(:failed, max_value)}
+          #{render_series_points(:completed, max_value)}
+          #{render_series_points(:created, max_value)}
+        </svg>
+      SVG
+    end
+
+    def all_series_empty?
+      %i[created completed failed].all? { |series| series_empty?(series) }
+    end
+
+    def series_empty?(series)
+      @data[series].nil? || @data[series].all?(&:zero?)
+    end
+
+    def render_empty_state
+      <<-HTML
+        <div class="chart-empty">
+          <span>No job activity in this time range</span>
+        </div>
+      HTML
+    end
+
+    def render_series_line(series, max_value)
+      return '' if series_empty?(series)
+
+      render_line(series, max_value)
+    end
+
+    def render_series_points(series, max_value)
+      return '' if series_empty?(series)
+
+      render_data_points(series, max_value)
+    end
+
+    def calculate_max_value
+      all_values = @data[:created] + @data[:completed] + @data[:failed]
+      max = all_values.max || 0
+      # Round up to nice number
+      return 10 if max <= 10
+
+      magnitude = 10**Math.log10(max).floor
+      ((max.to_f / magnitude).ceil * magnitude)
+    end
+
+    def render_grid_lines(_max_value)
+      lines = []
+      5.times do |i|
+        y = PADDING[:top] + (@plot_height * i / 4.0)
+        lines << "<line x1=\"#{PADDING[:left]}\" y1=\"#{y}\" x2=\"#{CHART_WIDTH - PADDING[:right]}\" y2=\"#{y}\" class=\"grid-line\"/>"
+      end
+      lines.join("\n")
+    end
+
+    def render_axes
+      <<-SVG
+        <line x1="#{PADDING[:left]}" y1="#{PADDING[:top]}" x2="#{PADDING[:left]}" y2="#{CHART_HEIGHT - PADDING[:bottom]}" class="axis-line"/>
+        <line x1="#{PADDING[:left]}" y1="#{CHART_HEIGHT - PADDING[:bottom]}" x2="#{CHART_WIDTH - PADDING[:right]}" y2="#{CHART_HEIGHT - PADDING[:bottom]}" class="axis-line"/>
+      SVG
+    end
+
+    def render_x_labels
+      labels = @data[:labels]
+      return '' if labels.empty?
+
+      # Show fewer labels if too many
+      step = labels.size > 12 ? (labels.size / 6.0).ceil : 1
+
+      label_elements = labels.each_with_index.map do |label, i|
+        next unless (i % step).zero? || i == labels.size - 1
+
+        x = PADDING[:left] + (@plot_width * i / (labels.size - 1).to_f)
+        "<text x=\"#{x}\" y=\"#{CHART_HEIGHT - PADDING[:bottom] + 20}\" class=\"axis-label x-label\">#{label}</text>"
+      end.compact
+
+      label_elements.join("\n")
+    end
+
+    def render_y_labels(max_value)
+      labels = []
+      5.times do |i|
+        value = (max_value * (4 - i) / 4.0).round
+        y = PADDING[:top] + (@plot_height * i / 4.0)
+        labels << "<text x=\"#{PADDING[:left] - 10}\" y=\"#{y + 4}\" class=\"axis-label y-label\">#{value}</text>"
+      end
+      labels.join("\n")
+    end
+
+    def render_line(series, max_value)
+      points = calculate_points(series, max_value)
+      return '' if points.empty?
+
+      points_str = points.map { |p| "#{p[:x]},#{p[:y]}" }.join(' ')
+
+      "<polyline points=\"#{points_str}\" class=\"chart-line chart-line-#{series}\" fill=\"none\" stroke=\"#{COLORS[series]}\" stroke-width=\"2\"/>"
+    end
+
+    def render_data_points(series, max_value)
+      points = calculate_points(series, max_value)
+      values = @data[series]
+
+      points.each_with_index.map do |point, i|
+        <<-SVG
+          <circle cx="#{point[:x]}" cy="#{point[:y]}" r="4" class="data-point data-point-#{series}" fill="#{COLORS[series]}"
+            data-series="#{series}" data-label="#{@data[:labels][i]}" data-value="#{values[i]}"/>
+        SVG
+      end.join("\n")
+    end
+
+    def calculate_points(series, max_value)
+      values = @data[series]
+      return [] if values.blank?
+
+      values.each_with_index.map do |value, i|
+        x = PADDING[:left] + (@plot_width * i / (values.size - 1).to_f)
+        y = CHART_HEIGHT - PADDING[:bottom] - (@plot_height * value / max_value.to_f)
+        { x: x.round(2), y: y.round(2) }
+      end
+    end
+
+    def render_legend
+      <<-HTML
+        <div class="chart-legend">
+          <span class="legend-item">
+            <span class="legend-color" style="background-color: #{COLORS[:created]}"></span>
+            Created
+          </span>
+          <span class="legend-item">
+            <span class="legend-color" style="background-color: #{COLORS[:completed]}"></span>
+            Completed
+          </span>
+          <span class="legend-item">
+            <span class="legend-color" style="background-color: #{COLORS[:failed]}"></span>
+            Failed
+          </span>
+        </div>
+      HTML
+    end
+
+    def render_tooltip
+      <<-HTML
+        <div id="chart-tooltip" class="chart-tooltip" style="display: none;">
+          <div class="tooltip-label"></div>
+          <div class="tooltip-value"></div>
+        </div>
+      HTML
+    end
+  end
+end