solid_queue_monitor 0.5.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2597291a879f3f6720e783c6aae3fa203434a67652ba24c5e65a6fdd87081120
-  data.tar.gz: d01e77ac3c412bf2fcdab1c4f1a02aa072786f7d88ec42798758615159ddc67c
+  metadata.gz: 80a07917e201c33bfb207f22490ca2a3afdeb22a8c842b1a33f3c187afc4f28e
+  data.tar.gz: d773d2950d4be0f2b3852512a0bfd2e450206d5a6562eef4fa926cff7e7b32c5
 SHA512:
-  metadata.gz: 9f95324749998dd5c7a6e0598a25edd14f82bbc32610499dcf688592729f4cbf805bf3ac8da8ad3f776c0dc3231ebaa6fa710fac5537806553cc3cc50f3a7d66
-  data.tar.gz: be751aaa21b617d1ba1f09eb473a9bbd83eeccfbe79c918040fe2df420c76258b012fad5c26eefa1aaaafe50e62fdf6d566b08469042006a501d9f354cd49658
+  metadata.gz: fedc69f3858f7b5834ac3c0cbad61693fd1428800f3ff5a6d9be0d74473adc2695105594c2633168e42f328ec6f2298d15ea81e5e3dbf811984ce00c54a360b1
+  data.tar.gz: 41095950dce1063081f219558f8297e58c0346ffe034d36c991d51433697165465756e1468ebbcab25cff48b6337f65908f5968eea64fc5fc1714877b1f76354

data/README.md

@@ -16,6 +16,18 @@ 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
+- **Worker Monitoring**: Real-time view of all Solid Queue processes (workers, dispatchers, schedulers)
+  - Health status indicators (healthy, stale, dead) based on heartbeat
+  - Shows queues each worker is processing and jobs currently being executed
+  - Prune dead processes with one click
+- **Job Details Page**: Dedicated page for viewing complete job information
+  - Full job timeline showing created, scheduled, started, and finished states
+  - Timing breakdown with queue wait time and execution duration
+  - Complete error details with backtrace for failed jobs
+  - Job arguments displayed in formatted JSON
+- **Queue Details Page**: Detailed view for individual queues with job counts and filtering
 - **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
@@ -33,20 +45,32 @@ 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)
+
+### Worker Monitoring
+
+![Worker Monitoring](screenshots/workers.png)
+
+### Queue Management
+
+![Queue Management](screenshots/queues.png)
 
 ### Failed Jobs
 
-![Failed Jobs](screenshots/failed-jobs-2.png)
+![Failed Jobs](screenshots/failed-jobs.png)
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'solid_queue_monitor', '~> 0.4.0'
+gem 'solid_queue_monitor', '~> 1.0'
 ```
 
 Then execute:
@@ -110,12 +134,15 @@ After installation, visit `/solid_queue` in your browser to access the dashboard
 
 The dashboard provides several views:
 
-- **Overview**: Shows statistics and recent jobs
+- **Overview**: Shows statistics, recent jobs, and job activity chart
 - **Ready Jobs**: Jobs that are ready to be executed
 - **Scheduled Jobs**: Jobs scheduled for future execution with execute and reject actions
 - **Recurring Jobs**: Jobs that run on a recurring schedule
 - **Failed Jobs**: Jobs that have failed with error details and retry/discard actions
-- **Queues**: Distribution of jobs across different queues
+- **Queues**: Distribution of jobs across different queues with pause/resume controls
+- **Workers**: Real-time monitoring of all Solid Queue processes with health status
+
+Click on any job class name to view detailed information including timeline, timing breakdown, arguments, and error details (for failed jobs).
 
 ### API-only Applications
 
@@ -135,9 +162,11 @@ This makes it easy to find specific jobs when debugging issues in your applicati
 ## Use Cases
 
 - **Production Monitoring**: Keep an eye on your background job processing in production environments
-- **Debugging**: Quickly identify and troubleshoot failed jobs
+- **Worker Health Monitoring**: Track the health of your Solid Queue processes and identify dead workers
+- **Debugging**: Quickly identify and troubleshoot failed jobs with detailed error information and backtraces
 - **Job Management**: Execute scheduled jobs on demand or reject unwanted jobs permanently
-- **Performance Analysis**: Track job distribution and identify bottlenecks
+- **Incident Response**: Pause queues during incidents to prevent job processing while investigating issues
+- **Performance Analysis**: Track job distribution, timing metrics, and identify bottlenecks
 - **DevOps Integration**: Easily integrate with your monitoring stack
 
 ## Compatibility

data/app/controllers/solid_queue_monitor/jobs_controller.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module SolidQueueMonitor
+  class JobsController < BaseController
+    def show
+      @job = SolidQueue::Job.find_by(id: params[:id])
+
+      unless @job
+        set_flash_message('Job not found.', 'error')
+        redirect_to root_path
+        return
+      end
+
+      job_data = load_job_data(@job)
+
+      render_page("Job ##{@job.id}", SolidQueueMonitor::JobDetailsPresenter.new(
+        @job,
+        **job_data
+      ).render)
+    end
+
+    private
+
+    def load_job_data(job)
+      {
+        failed_execution: SolidQueue::FailedExecution.find_by(job_id: job.id),
+        claimed_execution: load_claimed_execution(job),
+        scheduled_execution: SolidQueue::ScheduledExecution.find_by(job_id: job.id),
+        recent_executions: load_recent_executions(job),
+        back_path: determine_back_path
+      }
+    end
+
+    def load_claimed_execution(job)
+      claimed = SolidQueue::ClaimedExecution.find_by(job_id: job.id)
+      return nil unless claimed
+
+      # Preload process info
+      claimed.instance_variable_set(:@process, SolidQueue::Process.find_by(id: claimed.process_id))
+      claimed
+    end
+
+    def load_recent_executions(job)
+      SolidQueue::Job
+        .where(class_name: job.class_name)
+        .where.not(id: job.id)
+        .order(created_at: :desc)
+        .limit(10)
+        .includes(:failed_execution, :claimed_execution, :ready_execution, :scheduled_execution)
+    end
+
+    def determine_back_path
+      referer = request.referer
+      return root_path unless referer
+
+      # Extract path from referer
+      uri = URI.parse(referer)
+      path = uri.path
+
+      # Return referer if it's within the engine
+      if path.include?('/failed_jobs') || path.include?('/ready_jobs') ||
+         path.include?('/scheduled_jobs') || path.include?('/in_progress_jobs') ||
+         path.include?('/recurring_jobs')
+        referer
+      else
+        root_path
+      end
+    rescue URI::InvalidURIError
+      root_path
+    end
+  end
+end

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

@@ -11,12 +11,36 @@ module SolidQueueMonitor
       render_page('Queues', SolidQueueMonitor::QueuesPresenter.new(@queues, @paused_queues).render)
     end
 
+    def show
+      @queue_name = params[:queue_name]
+      @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)
+      preload_job_statuses(@jobs[:records])
+
+      @counts = calculate_queue_counts(@queue_name)
+
+      render_page("Queue: #{@queue_name}",
+                  SolidQueueMonitor::QueueDetailsPresenter.new(
+                    queue_name: @queue_name,
+                    paused: @paused,
+                    jobs: @jobs[:records],
+                    counts: @counts,
+                    current_page: @jobs[:current_page],
+                    total_pages: @jobs[:total_pages],
+                    filters: queue_filter_params
+                  ).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
+      redirect_to params[:redirect_to] || queues_path
     end
 
     def resume
@@ -24,7 +48,54 @@ module SolidQueueMonitor
       result = QueuePauseService.new(queue_name).resume
 
       set_flash_message(result[:message], result[:success] ? 'success' : 'error')
-      redirect_to queues_path
+      redirect_to params[:redirect_to] || queues_path
+    end
+
+    private
+
+    def calculate_queue_counts(queue_name)
+      {
+        total: SolidQueue::Job.where(queue_name: queue_name).count,
+        ready: SolidQueue::ReadyExecution.where(queue_name: queue_name).count,
+        scheduled: SolidQueue::ScheduledExecution.where(queue_name: queue_name).count,
+        in_progress: SolidQueue::ClaimedExecution.joins(:job).where(solid_queue_jobs: { queue_name: queue_name }).count,
+        failed: SolidQueue::FailedExecution.joins(:job).where(solid_queue_jobs: { queue_name: queue_name }).count,
+        completed: SolidQueue::Job.where(queue_name: queue_name).where.not(finished_at: nil).count
+      }
+    end
+
+    def filter_queue_jobs(relation)
+      relation = relation.where('class_name LIKE ?', "%#{params[:class_name]}%") if params[:class_name].present?
+      relation = filter_by_arguments(relation) if params[:arguments].present?
+
+      if params[:status].present?
+        case params[:status]
+        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)
+        when 'scheduled'
+          scheduled_job_ids = SolidQueue::ScheduledExecution.pluck(:job_id)
+          relation = relation.where(id: scheduled_job_ids)
+        when 'pending'
+          ready_job_ids = SolidQueue::ReadyExecution.pluck(:job_id)
+          relation = relation.where(id: ready_job_ids)
+        when 'in_progress'
+          claimed_job_ids = SolidQueue::ClaimedExecution.pluck(:job_id)
+          relation = relation.where(id: claimed_job_ids)
+        end
+      end
+
+      relation
+    end
+
+    def queue_filter_params
+      {
+        class_name: params[:class_name],
+        arguments: params[:arguments],
+        status: params[:status]
+      }
     end
   end
 end

data/app/controllers/solid_queue_monitor/scheduled_jobs_controller.rb

@@ -22,6 +22,15 @@ module SolidQueueMonitor
       redirect_to scheduled_jobs_path
     end
 
+    def execute
+      SolidQueueMonitor::ExecuteJobService.new.call(params[:id])
+      set_flash_message('Job moved to ready queue', 'success')
+      redirect_to params[:redirect_to] || scheduled_jobs_path
+    rescue ActiveRecord::RecordNotFound
+      set_flash_message('Job not found', 'error')
+      redirect_to scheduled_jobs_path
+    end
+
     def reject_all
       result = SolidQueueMonitor::RejectJobService.new.reject_many(params[:job_ids])
 

data/app/controllers/solid_queue_monitor/workers_controller.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module SolidQueueMonitor
+  class WorkersController < BaseController
+    def index
+      base_query = SolidQueue::Process.order(created_at: :desc)
+      filtered_query = filter_workers(base_query)
+      @processes = paginate(filtered_query)
+
+      render_page('Workers', SolidQueueMonitor::WorkersPresenter.new(
+        @processes[:records],
+        current_page: @processes[:current_page],
+        total_pages: @processes[:total_pages],
+        filters: worker_filter_params
+      ).render)
+    end
+
+    def remove
+      process = SolidQueue::Process.find_by(id: params[:id])
+
+      if process
+        process.destroy
+        set_flash_message('Process removed successfully.', 'success')
+      else
+        set_flash_message('Process not found.', 'error')
+      end
+
+      redirect_to workers_path
+    end
+
+    def prune
+      dead_threshold = 10.minutes.ago
+      dead_processes = SolidQueue::Process.where(last_heartbeat_at: ..dead_threshold)
+      count = dead_processes.count
+
+      if count.positive?
+        dead_processes.destroy_all
+        set_flash_message("Successfully removed #{count} dead process#{'es' if count > 1}.", 'success')
+      else
+        set_flash_message('No dead processes to remove.', 'success')
+      end
+
+      redirect_to workers_path
+    end
+
+    private
+
+    def filter_workers(relation)
+      relation = relation.where(kind: params[:kind]) if params[:kind].present?
+      relation = relation.where('hostname LIKE ?', "%#{params[:hostname]}%") if params[:hostname].present?
+
+      if params[:status].present?
+        case params[:status]
+        when 'healthy'
+          relation = relation.where('last_heartbeat_at > ?', 5.minutes.ago)
+        when 'stale'
+          relation = relation.where('last_heartbeat_at <= ? AND last_heartbeat_at > ?', 5.minutes.ago, 10.minutes.ago)
+        when 'dead'
+          relation = relation.where(last_heartbeat_at: ..10.minutes.ago)
+        end
+      end
+
+      relation
+    end
+
+    def worker_filter_params
+      {
+        kind: params[:kind],
+        hostname: params[:hostname],
+        status: params[:status]
+      }
+    end
+  end
+end

data/app/presenters/solid_queue_monitor/base_presenter.rb

@@ -111,6 +111,13 @@ module SolidQueueMonitor
       "<code>#{formatted}</code>"
     end
 
+    def queue_link(queue_name, css_class: nil)
+      return '-' if queue_name.blank?
+
+      classes = ['queue-link', css_class].compact.join(' ')
+      "<a href=\"#{queue_details_path(queue_name: queue_name)}\" class=\"#{classes}\">#{queue_name}</a>"
+    end
+
     def request_path
       if defined?(controller) && controller.respond_to?(:request)
         controller.request.path

data/app/presenters/solid_queue_monitor/failed_jobs_presenter.rb

@@ -251,23 +251,19 @@ module SolidQueueMonitor
         <tr>
           <td><input type="checkbox" class="job-checkbox" value="#{failed_execution.id}"></td>
           <td>
-            <div class="job-class">#{job.class_name}</div>
+            <div class="job-class"><a href="#{job_path(job)}" class="job-class-link">#{job.class_name}</a></div>
             <div class="job-meta">
               <span class="job-timestamp">Queued at: #{format_datetime(job.created_at)}</span>
             </div>
           </td>
           <td>
-            <div class="job-queue">#{job.queue_name}</div>
+            <div class="job-queue">#{queue_link(job.queue_name)}</div>
           </td>
           <td>
-            <div class="error-message">#{error[:message]}</div>
+            <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>
-            <details>
-              <summary>Backtrace</summary>
-              <pre class="error-backtrace">#{error[:backtrace]}</pre>
-            </details>
           </td>
           <td>#{format_arguments(job.arguments)}</td>
           <td class="actions-cell">

data/app/presenters/solid_queue_monitor/in_progress_jobs_presenter.rb

@@ -67,11 +67,12 @@ module SolidQueueMonitor
       <<-HTML
         <tr>
           <td>
-            <div class="job-class">#{job.class_name}</div>
+            <div class="job-class"><a href="#{job_path(job)}" class="job-class-link">#{job.class_name}</a></div>
             <div class="job-meta">
               <span class="job-timestamp">Queued at: #{format_datetime(job.created_at)}</span>
             </div>
           </td>
+          <td>#{queue_link(job.queue_name)}</td>
           <td>#{format_arguments(job.arguments)}</td>
           <td>#{format_datetime(execution.created_at)}</td>
           <td>#{execution.process_id}</td>