solid_queue_monitor 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5d980b63b65c764dd6f0382f9072274f22a36f6906a56cdc888b081a3c3aeb5e
-  data.tar.gz: 223799c8891120a76776d4f702315f76033af176274bbcb5c2c7d6b30aa1053e
+  metadata.gz: 264dd6a6542855e5209702c11fbb46c1c267b5c8d48d530887030f924bdb929f
+  data.tar.gz: 4d5a33c4152f29d0c3ba4c9fd6c59582e7af9694e85469a78cde9a9d173a4433
 SHA512:
-  metadata.gz: 7b938b862ebd3b7d7e5c711f6b7dd5717ab70d4472641252f72d9bf1e96bb97596a65799e2adf17b27f2a119d07c3ee4d285d0925931b2c0e6ddc72ab57c4bd9
-  data.tar.gz: 84ad9d12a2c7c37610c610938958c60585aeea01c4d3797ea7c9d019f37c0581ba4843e104fa89cdc59e50087e3a7c4bbcdfdd2e95d2bccd09e10f8d11d85722
+  metadata.gz: 704927588ba7329d988a7533ab70e6b444254abc64a15684fbeccce47221c929c39701abd8fbb02dbebf444c0c3a9521cbcc84260d06d3c6fdafca6e01ad2be5
+  data.tar.gz: 8b0a608d0ae89c54719dd5286e9de77cb4145d1f1c3dc7c3f8c1b46a521ae1b2e0ad37d35e7c2796a187122fc38f401b423a46109cc81328cff6805274338357

data/README.md

@@ -1,6 +1,9 @@
 # SolidQueueMonitor
 
-A lightweight, zero-dependency web interface for monitoring Solid Queue jobs in Rails applications.
+[![Gem Version](https://badge.fury.io/rb/solid_queue_monitor.svg)](https://badge.fury.io/rb/solid_queue_monitor)
+[![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+A lightweight, zero-dependency web interface for monitoring Solid Queue background jobs in Ruby on Rails applications. Perfect for Rails API-only applications and traditional Rails apps.
 
 ## Key Advantages
 
@@ -8,6 +11,7 @@ A lightweight, zero-dependency web interface for monitoring Solid Queue jobs in
 - **No External Dependencies**: No JavaScript frameworks, no CSS libraries, no additional gems required - just pure Rails.
 - **Self-contained UI**: All HTML, CSS, and JavaScript are generated server-side, making deployment simple and reliable.
 - **Minimal Footprint**: Adds minimal overhead to your application while providing powerful monitoring capabilities.
+- **Rails 7 Compatible**: Fully compatible with Rails 7.1+ and the latest Solid Queue versions.
 
 ## Features
 
@@ -16,6 +20,7 @@ A lightweight, zero-dependency web interface for monitoring Solid Queue jobs in
 - **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
 - **Optional Authentication**: Secure your dashboard with HTTP Basic Authentication
 - **Responsive Design**: Works on desktop and mobile devices
@@ -27,16 +32,16 @@ A lightweight, zero-dependency web interface for monitoring Solid Queue jobs in
 
 ![Dashboard Overview](screenshots/dashboard.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'
+gem 'solid_queue_monitor', '~> 0.2.0'
 ```
 
 Then execute:
@@ -96,6 +101,7 @@ The dashboard provides several views:
 - **Overview**: Shows statistics and recent jobs
 - **Ready Jobs**: Jobs that are ready to be executed
 - **Scheduled Jobs**: Jobs scheduled for future execution
+- **Recurring Jobs**: Jobs that run on a recurring schedule
 - **Failed Jobs**: Jobs that have failed with error details
 - **Queues**: Distribution of jobs across different queues
 
@@ -103,6 +109,20 @@ 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.
 
+## Use Cases
+
+- **Production Monitoring**: Keep an eye on your background job processing in production environments
+- **Debugging**: Quickly identify and troubleshoot failed jobs
+- **Job Management**: Execute scheduled jobs on demand when needed
+- **Performance Analysis**: Track job distribution and identify bottlenecks
+- **DevOps Integration**: Easily integrate with your monitoring stack
+
+## Compatibility
+
+- **Ruby**: 3.1.6 or higher
+- **Rails**: 7.1 or higher
+- **Solid Queue**: 0.1.0 or higher
+
 ## Contributing
 
 Contributions are welcome! Here's how you can contribute:
@@ -126,3 +146,9 @@ The gem is available as open source under the terms of the [MIT License](https:/
 ## Code of Conduct
 
 Everyone interacting in the SolidQueueMonitor project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/yourusername/solid_queue_monitor/blob/main/CODE_OF_CONDUCT.md).
+
+## Related Projects
+
+- [Solid Queue](https://github.com/rails/solid_queue) - The official Rails background job framework
+- [Rails](https://github.com/rails/rails) - The web application framework
+- [ActiveJob](https://github.com/rails/rails/tree/main/activejob) - Rails job frameworkk

data/app/controllers/solid_queue_monitor/base_controller.rb

@@ -0,0 +1,194 @@
+module SolidQueueMonitor
+  class BaseController < 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
+    
+    # Define a helper method for setting flash messages
+    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
+
+    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?
+      
+      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_ready_jobs(relation)
+      return relation unless params[:class_name].present? || params[:queue_name].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?
+        relation = relation.where("queue_name LIKE ?", "%#{params[:queue_name]}%")
+      end
+      
+      relation
+    end
+
+    def filter_scheduled_jobs(relation)
+      return relation unless params[:class_name].present? || params[:queue_name].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?
+        relation = relation.where("queue_name LIKE ?", "%#{params[:queue_name]}%")
+      end
+      
+      relation
+    end
+
+    def filter_recurring_jobs(relation)
+      return relation unless params[:class_name].present? || params[:queue_name].present?
+      
+      if params[:class_name].present?
+        relation = relation.where("class_name LIKE ?", "%#{params[:class_name]}%")
+      end
+      
+      if params[:queue_name].present?
+        relation = relation.where("queue_name LIKE ?", "%#{params[:queue_name]}%")
+      end
+      
+      relation
+    end
+
+    def filter_failed_jobs(relation)
+      return relation unless params[:class_name].present? || params[:queue_name].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
+      
+      relation
+    end
+
+    def filter_params
+      {
+        class_name: params[:class_name],
+        queue_name: params[:queue_name],
+        status: params[:status]
+      }
+    end
+  end
+end 

data/app/controllers/solid_queue_monitor/failed_jobs_controller.rb

@@ -0,0 +1,62 @@
+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].present? ? params[:redirect_to] : 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].present? ? params[:redirect_to] : 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,27 @@
+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 unless params[:class_name].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
+    end
+  end
+end 

data/app/controllers/solid_queue_monitor/monitor_controller.rb

@@ -1,10 +1,17 @@
 module SolidQueueMonitor
   class MonitorController < 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, only: [:execute_jobs]
+    skip_before_action :verify_authenticity_token, only: [:execute_jobs, :retry_failed_job, :discard_failed_job, :retry_failed_jobs, :discard_failed_jobs]
+
+    # Define a helper method for setting flash messages
+    def set_flash_message(message, type)
+      session[:flash_message] = message
+      session[:flash_type] = type
+    end
 
     def index
       @stats = SolidQueueMonitor::StatsCalculator.calculate
@@ -68,11 +75,57 @@ module SolidQueueMonitor
     def execute_jobs
       if params[:job_ids].present?
         SolidQueueMonitor::ExecuteJobService.new.execute_many(params[:job_ids])
-        redirect_url = "#{scheduled_jobs_path}?message=Selected jobs moved to ready queue&message_type=success"
+        set_flash_message('Selected jobs moved to ready queue', 'success')
       else
-        redirect_url = "#{scheduled_jobs_path}?message=No jobs selected&message_type=error"
+        set_flash_message('No jobs selected', 'error')
       end
-      redirect_to redirect_url
+      redirect_to scheduled_jobs_path
+    end
+
+    def retry_failed_job
+      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 failed_jobs_path
+    end
+    
+    def discard_failed_job
+      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 failed_jobs_path
+    end
+    
+    def retry_failed_jobs
+      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_failed_jobs
+      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
 
     private
@@ -88,11 +141,19 @@ 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)
+      
       html = SolidQueueMonitor::HtmlGenerator.new(
         title: title,
         content: content,
-        message: params[:notice] || params[:alert],
-        message_type: params[:notice] ? 'success' : 'error'
+        message: message,
+        message_type: message_type
       ).generate
       
       render html: html.html_safe
@@ -233,7 +294,14 @@ module SolidQueueMonitor
       end
       
       if params[:queue_name].present?
-        relation = relation.where("queue_name LIKE ?", "%#{params[:queue_name]}%")
+        # 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
       
       relation

data/app/controllers/solid_queue_monitor/overview_controller.rb

@@ -0,0 +1,25 @@
+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,11 @@
+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,14 @@
+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,14 @@
+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,24 @@
+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