solid_queue_monitor 0.1.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1cadc5702b1a5de9167c64a48abfb6639362a3d4e765a3fb1bdf250f5ed4fa81
-  data.tar.gz: 9f76e05408872948070221edb908146e134bbf67d6be1bc5fe8e8cbbd6b181ea
+  metadata.gz: d2911139409c2a387a2c425c0ef9927071a05dcf5f718e5aefc7bfb86cc4b7b6
+  data.tar.gz: 398de34669f64b9d4cab2cf1ed7e1f19da6fcd56b67df8da2c2682410308a905
 SHA512:
-  metadata.gz: c27275ffbfc1c18e3c790abe1c6776f417af6c8684ffd33e392ae94dccb022b6465fe4754154aec86e6c2690f77e5ec674cf77893ce71c34e40a71498d9364e7
-  data.tar.gz: ebb05f940720c5f10aab733f2632584d274af3c786300ba56d9f208535610d5034bbd3b0e8554d55e9f2244e4c6a460f646ef68ad533f03edab038264d7c2c12
+  metadata.gz: 9357fee483f20555b92b1fd913224c536ae934bb8442968f42470c672c1cc19a8388d13a5cd7741f36158a67c594913074b5cdafbeae8caaa6aa67e5161cc373
+  data.tar.gz: 32a1c6d65dbbcf9d837ded2fca261d0d715546c446a716073881c7a199d7ee3d561a94971880f5c144f270484199e265fd0b367230babd811891409b56849a2e

data/README.md

@@ -15,13 +15,16 @@ A lightweight, zero-dependency web interface for monitoring Solid Queue backgrou
 
 ## Features
 
-- **Dashboard Overview**: Get a quick snapshot of your job queue with statistics and counts
-- **Job Filtering**: Filter jobs by class name, queue name, and status
-- **Job Management**: Execute scheduled jobs on demand
-- **Failed Job Inspection**: View detailed error information for failed jobs
-- **Queue Monitoring**: Track job distribution across different queues
-- **Recurring Jobs**: Monitor and manage recurring background tasks
-- **Pagination**: Navigate through large job lists with ease
+- **Dashboard Overview**: Get a quick snapshot of your queue's health with statistics on all job types
+- **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
+- **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
+- **Advanced Job Filtering**: Filter jobs by class name, queue, status, and job arguments
+- **Quick Actions**: Retry or discard failed jobs directly from any view
+- **Performance Optimized**: Designed for high-volume applications with smart pagination
 - **Optional Authentication**: Secure your dashboard with HTTP Basic Authentication
 - **Responsive Design**: Works on desktop and mobile devices
 - **Zero Dependencies**: No additional JavaScript libraries or frameworks required
@@ -30,18 +33,18 @@ A lightweight, zero-dependency web interface for monitoring Solid Queue backgrou
 
 ### Dashboard Overview
 
-![Dashboard Overview](screenshots/dashboard.png)
+![Dashboard Overview](screenshots/dashboard-2.png)
 
-### Recurring Jobs
+### Failed Jobs
 
-![Recurring Jobs](screenshots/recurring_jobs.png)
+![Failed Jobs](screenshots/failed_jobs.png)
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'solid_queue_monitor', '~> 0.1.2'
+gem 'solid_queue_monitor', '~> 0.3.0'
 ```
 
 Then execute:
@@ -109,6 +112,17 @@ The dashboard provides several views:
 
 For API-only Rails applications, SolidQueueMonitor works out of the box without requiring you to enable the asset pipeline or webpacker. This makes it an ideal choice for monitoring background jobs in modern API-based architectures.
 
+### Job Filtering
+
+You can filter jobs by:
+
+- **Class Name**: Filter by job class name
+- **Queue Name**: Filter by queue name
+- **Job Arguments**: Search within job arguments using case-insensitive partial matching
+- **Status**: Filter by job status (completed, failed, scheduled, pending)
+
+This makes it easy to find specific jobs when debugging issues in your application.
+
 ## Use Cases
 
 - **Production Monitoring**: Keep an eye on your background job processing in production environments

data/Rakefile

@@ -1,23 +1,23 @@
 # frozen_string_literal: true
 
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
 task default: :spec
 
 namespace :db do
-  task :setup do
+  task setup: :environment do
     require 'fileutils'
     FileUtils.mkdir_p 'spec/dummy/db'
-    system("cd spec/dummy && bundle exec rails db:environment:set RAILS_ENV=test")
-    system("cd spec/dummy && bundle exec rails db:schema:load RAILS_ENV=test")
+    system('cd spec/dummy && bundle exec rails db:environment:set RAILS_ENV=test')
+    system('cd spec/dummy && bundle exec rails db:schema:load RAILS_ENV=test')
   end
 end
 
-task :prepare_test_env do
-  Rake::Task["db:setup"].invoke
+task prepare_test_env: :environment do
+  Rake::Task['db:setup'].invoke
 end
 
-task :spec => :prepare_test_env
+task spec: :prepare_test_env

data/app/controllers/solid_queue_monitor/application_controller.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module SolidQueueMonitor
+  class ApplicationController < ActionController::Base
+    include ActionController::HttpAuthentication::Basic::ControllerMethods
+    include ActionController::Flash
+
+    before_action :authenticate, if: -> { SolidQueueMonitor::AuthenticationService.authentication_required? }
+    layout false
+    skip_before_action :verify_authenticity_token
+
+    def set_flash_message(message, type)
+      session[:flash_message] = message
+      session[:flash_type] = type
+    end
+
+    private
+
+    def authenticate
+      authenticate_or_request_with_http_basic do |username, password|
+        SolidQueueMonitor::AuthenticationService.authenticate(username, password)
+      end
+    end
+  end
+end

data/app/controllers/solid_queue_monitor/base_controller.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module SolidQueueMonitor
+  class BaseController < SolidQueueMonitor::ApplicationController
+    def paginate(relation)
+      PaginationService.new(relation, current_page, per_page).paginate
+    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)
+
+      html = SolidQueueMonitor::HtmlGenerator.new(
+        title: title,
+        content: content,
+        message: message,
+        message_type: message_type
+      ).generate
+
+      render html: html.html_safe
+    end
+
+    def current_page
+      (params[:page] || 1).to_i
+    end
+
+    def per_page
+      SolidQueueMonitor.jobs_per_page
+    end
+
+    # Preload job statuses to avoid N+1 queries
+    def preload_job_statuses(jobs)
+      return if jobs.empty?
+
+      # Get all job IDs
+      job_ids = jobs.map(&:id)
+
+      # Find all failed jobs in a single query
+      failed_job_ids = SolidQueue::FailedExecution.where(job_id: job_ids).pluck(:job_id)
+
+      # Find all scheduled jobs in a single query
+      scheduled_job_ids = SolidQueue::ScheduledExecution.where(job_id: job_ids).pluck(:job_id)
+
+      # Attach the status information to each job
+      jobs.each do |job|
+        job.instance_variable_set(:@failed, failed_job_ids.include?(job.id))
+        job.instance_variable_set(:@scheduled, scheduled_job_ids.include?(job.id))
+      end
+
+      # Define the method to check if a job is failed
+      SolidQueue::Job.class_eval do
+        def failed?
+          if instance_variable_defined?(:@failed)
+            @failed
+          else
+            SolidQueue::FailedExecution.exists?(job_id: id)
+          end
+        end
+
+        def scheduled?
+          if instance_variable_defined?(:@scheduled)
+            @scheduled
+          else
+            SolidQueue::ScheduledExecution.exists?(job_id: id)
+          end
+        end
+      end
+    end
+
+    def filter_jobs(relation)
+      relation = relation.where('class_name LIKE ?', "%#{params[:class_name]}%") if params[:class_name].present?
+      relation = relation.where('queue_name LIKE ?', "%#{params[:queue_name]}%") if params[:queue_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'
+          # 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)
+        end
+      end
+
+      relation
+    end
+
+    def filter_by_arguments(relation)
+      # Use ILIKE for case-insensitive search in PostgreSQL
+      relation.where('arguments::text ILIKE ?', "%#{params[:arguments]}%")
+    end
+
+    def filter_ready_jobs(relation)
+      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)
+      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)
+      end
+
+      relation
+    end
+
+    def filter_scheduled_jobs(relation)
+      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)
+      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)
+      end
+
+      relation
+    end
+
+    def filter_recurring_jobs(relation)
+      return relation unless params[:class_name].present? || params[:queue_name].present? || params[:arguments].present?
+
+      relation = relation.where('class_name LIKE ?', "%#{params[:class_name]}%") if params[:class_name].present?
+      relation = relation.where('queue_name LIKE ?', "%#{params[:queue_name]}%") if params[:queue_name].present?
+
+      # Add arguments filtering if the model has arguments column
+      if params[:arguments].present? && relation.column_names.include?('arguments')
+        relation = relation.where('arguments::text ILIKE ?',
+                                  "%#{params[:arguments]}%")
+      end
+
+      relation
+    end
+
+    def filter_failed_jobs(relation)
+      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)
+      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
+      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)
+      end
+
+      relation
+    end
+
+    def filter_params
+      {
+        class_name: params[:class_name],
+        queue_name: params[:queue_name],
+        arguments: params[:arguments],
+        status: params[:status]
+      }
+    end
+  end
+end

data/app/controllers/solid_queue_monitor/failed_jobs_controller.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module SolidQueueMonitor
+  class FailedJobsController < BaseController
+    def index
+      base_query = SolidQueue::FailedExecution.includes(:job).order(created_at: :desc)
+      @failed_jobs = paginate(filter_failed_jobs(base_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)
+    end
+
+    def retry
+      id = params[:id]
+      service = SolidQueueMonitor::FailedJobService.new
+
+      if service.retry_job(id)
+        set_flash_message("Job #{id} has been queued for retry.", 'success')
+      else
+        set_flash_message("Failed to retry job #{id}.", 'error')
+      end
+
+      redirect_to(params[:redirect_to].presence || failed_jobs_path)
+    end
+
+    def discard
+      id = params[:id]
+      service = SolidQueueMonitor::FailedJobService.new
+
+      if service.discard_job(id)
+        set_flash_message("Job #{id} has been discarded.", 'success')
+      else
+        set_flash_message("Failed to discard job #{id}.", 'error')
+      end
+
+      redirect_to(params[:redirect_to].presence || failed_jobs_path)
+    end
+
+    def retry_all
+      result = SolidQueueMonitor::FailedJobService.new.retry_all(params[:job_ids])
+
+      if result[:success]
+        set_flash_message(result[:message], 'success')
+      else
+        set_flash_message(result[:message], 'error')
+      end
+      redirect_to failed_jobs_path
+    end
+
+    def discard_all
+      result = SolidQueueMonitor::FailedJobService.new.discard_all(params[:job_ids])
+
+      if result[:success]
+        set_flash_message(result[:message], 'success')
+      else
+        set_flash_message(result[:message], 'error')
+      end
+      redirect_to failed_jobs_path
+    end
+  end
+end

data/app/controllers/solid_queue_monitor/in_progress_jobs_controller.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module SolidQueueMonitor
+  class InProgressJobsController < BaseController
+    def index
+      base_query = SolidQueue::ClaimedExecution.includes(:job).order(created_at: :desc)
+      @in_progress_jobs = paginate(filter_in_progress_jobs(base_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)
+    end
+
+    private
+
+    def filter_in_progress_jobs(relation)
+      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)
+      end
+
+      if params[:arguments].present?
+        job_ids = SolidQueue::Job.where('arguments::text ILIKE ?', "%#{params[:arguments]}%").pluck(:id)
+        relation = relation.where(job_id: job_ids)
+      end
+
+      relation
+    end
+  end
+end

data/app/controllers/solid_queue_monitor/overview_controller.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module SolidQueueMonitor
+  class OverviewController < BaseController
+    def index
+      @stats = SolidQueueMonitor::StatsCalculator.calculate
+
+      recent_jobs_query = SolidQueue::Job.order(created_at: :desc).limit(100)
+      @recent_jobs = paginate(filter_jobs(recent_jobs_query))
+
+      preload_job_statuses(@recent_jobs[:records])
+
+      render_page('Overview', generate_overview_content)
+    end
+
+    private
+
+    def generate_overview_content
+      SolidQueueMonitor::StatsPresenter.new(@stats).render +
+        SolidQueueMonitor::JobsPresenter.new(@recent_jobs[:records],
+                                             current_page: @recent_jobs[:current_page],
+                                             total_pages: @recent_jobs[:total_pages],
+                                             filters: filter_params).render
+    end
+  end
+end

data/app/controllers/solid_queue_monitor/queues_controller.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SolidQueueMonitor
+  class QueuesController < BaseController
+    def index
+      @queues = SolidQueue::Job.group(:queue_name)
+                               .select('queue_name, COUNT(*) as job_count')
+                               .order('job_count DESC')
+
+      render_page('Queues', SolidQueueMonitor::QueuesPresenter.new(@queues).render)
+    end
+  end
+end

data/app/controllers/solid_queue_monitor/ready_jobs_controller.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SolidQueueMonitor
+  class ReadyJobsController < BaseController
+    def index
+      base_query = SolidQueue::ReadyExecution.includes(:job).order(created_at: :desc)
+      @ready_jobs = paginate(filter_ready_jobs(base_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)
+    end
+  end
+end

data/app/controllers/solid_queue_monitor/recurring_jobs_controller.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SolidQueueMonitor
+  class RecurringJobsController < BaseController
+    def index
+      base_query = filter_recurring_jobs(SolidQueue::RecurringTask.order(:key))
+      @recurring_jobs = paginate(base_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)
+    end
+  end
+end

data/app/controllers/solid_queue_monitor/scheduled_jobs_controller.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module SolidQueueMonitor
+  class ScheduledJobsController < BaseController
+    def index
+      base_query = SolidQueue::ScheduledExecution.includes(:job).order(scheduled_at: :asc)
+      @scheduled_jobs = paginate(filter_scheduled_jobs(base_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)
+    end
+
+    def create
+      if params[:job_ids].present?
+        SolidQueueMonitor::ExecuteJobService.new.execute_many(params[:job_ids])
+        set_flash_message('Selected jobs moved to ready queue', 'success')
+      else
+        set_flash_message('No jobs selected', 'error')
+      end
+      redirect_to scheduled_jobs_path
+    end
+  end
+end