solid_queue_monitor 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 21024cd4e55a7bc73fde9161c68186a293976fe9fe6149dde1e0c48c0638f1b0
+  data.tar.gz: b0bfa87b894001e9a14e8666a26073334302b34e89f9e723ed0266c9ced4cfd9
+SHA512:
+  metadata.gz: 82e972e2209c95dcc4693f7a1bc0ac0794743f1ccd02405708730005164c3a652a648bb816f0eaf15ccae92da2ca0ca7d1498877502428fc9e6d6c78698f98fc
+  data.tar.gz: c695e22c0957ba4b3449c9a0fe46e503f6d32d4e2282bd52ee2d7271a13880e16829cae7b8c4ee74d2fb2422f44f4d4a50ba39e79b3c20d46d9907458d2e79ab

data/README.md

@@ -0,0 +1,128 @@
+# SolidQueueMonitor
+
+A lightweight, zero-dependency web interface for monitoring Solid Queue jobs in Rails applications.
+
+## Key Advantages
+
+- **Works in API-only Rails Applications**: Unlike other monitoring gems that require a full Rails application with asset pipeline or webpacker, SolidQueueMonitor works seamlessly in API-only Rails applications.
+- **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.
+
+## 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
+- **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
+- **Zero Dependencies**: No additional JavaScript libraries or frameworks required
+
+## Screenshots
+
+### Dashboard Overview
+
+![Dashboard Overview](screenshots/dashboard.png)
+
+### Recurring Jobs
+
+![Recurring Jobs](screenshots/recurring_jobs.png)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'solid_queue_monitor'
+```
+
+Then execute:
+
+```bash
+$ bundle install
+```
+
+After bundling, run the generator:
+
+```bash
+rails generate solid_queue_monitor:install
+```
+
+This will:
+
+1. Create an initializer at `config/initializers/solid_queue_monitor.rb`
+2. Add required routes to your `config/routes.rb`
+
+## Configuration
+
+You can configure Solid Queue Monitor by editing the initializer:
+
+```ruby
+# config/initializers/solid_queue_monitor.rb
+SolidQueueMonitor.setup do |config|
+  # Enable or disable authentication
+  # By default, authentication is disabled for ease of setup
+  config.authentication_enabled = false
+
+  # Set the username for HTTP Basic Authentication (only used if authentication is enabled)
+  config.username = 'admin'
+
+  # Set the password for HTTP Basic Authentication (only used if authentication is enabled)
+  config.password = 'password'
+
+  # Number of jobs to display per page
+  config.jobs_per_page = 25
+end
+```
+
+### Authentication
+
+By default, Solid Queue Monitor does not require authentication to access the dashboard. This makes it easy to get started in development environments.
+
+For production environments, it's strongly recommended to enable authentication:
+
+1. **Enable authentication**: Set `config.authentication_enabled = true` in the initializer
+2. **Configure secure credentials**: Set `username` and `password` to strong values in the initializer
+
+## Usage
+
+After installation, visit `/solid_queue` in your browser to access the dashboard.
+
+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
+- **Failed Jobs**: Jobs that have failed with error details
+- **Queues**: Distribution of jobs across different queues
+
+### API-only Applications
+
+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.
+
+## Contributing
+
+Contributions are welcome! Here's how you can contribute:
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+Please make sure to update tests as appropriate and follow the existing code style.
+
+### Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## 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).

data/Rakefile

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec
+
+namespace :db do
+  task :setup 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")
+  end
+end
+
+task :prepare_test_env do
+  Rake::Task["db:setup"].invoke
+end
+
+task :spec => :prepare_test_env

data/app/controllers/solid_queue_monitor/monitor_controller.rb

@@ -0,0 +1,250 @@
+module SolidQueueMonitor
+  class MonitorController < ActionController::Base
+    include ActionController::HttpAuthentication::Basic::ControllerMethods
+
+    before_action :authenticate, if: -> { SolidQueueMonitor::AuthenticationService.authentication_required? }
+    layout false
+    skip_before_action :verify_authenticity_token, only: [:execute_jobs]
+
+    def index
+      @stats = SolidQueueMonitor::StatsCalculator.calculate
+      
+      # Get all jobs with pagination
+      @recent_jobs = paginate(filter_jobs(SolidQueue::Job.order(created_at: :desc)))
+      
+      # Preload failed job information
+      preload_job_statuses(@recent_jobs[:records])
+      
+      render_page('Overview', generate_overview_content)
+    end
+
+    def ready_jobs
+      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
+
+    def scheduled_jobs
+      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 recurring_jobs
+      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
+
+    def failed_jobs
+      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 queues
+      @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
+
+    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"
+      else
+        redirect_url = "#{scheduled_jobs_path}?message=No jobs selected&message_type=error"
+      end
+      redirect_to redirect_url
+    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)
+      html = SolidQueueMonitor::HtmlGenerator.new(
+        title: title,
+        content: content,
+        message: params[:notice] || params[:alert],
+        message_type: params[:notice] ? 'success' : 'error'
+      ).generate
+      
+      render html: html.html_safe
+    end
+
+    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
+
+    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?
+        relation = relation.where("queue_name LIKE ?", "%#{params[:queue_name]}%")
+      end
+      
+      relation
+    end
+
+    def filter_params
+      {
+        class_name: params[:class_name],
+        queue_name: params[:queue_name],
+        status: params[:status]
+      }
+    end
+  end
+end

data/app/presenters/solid_queue_monitor/base_presenter.rb

@@ -0,0 +1,136 @@
+module SolidQueueMonitor
+  class BasePresenter
+    include ActionView::Helpers::DateHelper
+    include ActionView::Helpers::TextHelper
+    include Rails.application.routes.url_helpers
+    include SolidQueueMonitor::Engine.routes.url_helpers
+
+    def default_url_options
+      { only_path: true }
+    end
+
+    def section_wrapper(title, content)
+      <<-HTML
+        <div class="section-wrapper">
+          <div class="section">
+            #{content}
+          </div>
+        </div>
+      HTML
+    end
+
+    def generate_pagination(current_page, total_pages)
+      return '' if total_pages <= 1
+      
+      links = []
+      
+      # Previous page link
+      if current_page > 1
+        links << "<a href='?page=#{current_page - 1}#{query_params}' class='pagination-link'>&laquo; Previous</a>"
+      else
+        links << "<span class='pagination-link disabled'>&laquo; Previous</span>"
+      end
+      
+      # Page number links
+      if total_pages <= 7
+        # Show all pages if there are 7 or fewer
+        (1..total_pages).each do |page|
+          links << page_link(page, current_page)
+        end
+      else
+        # Show first page, last page, and pages around current
+        links << page_link(1, current_page)
+        
+        if current_page > 3
+          links << "<span class='pagination-gap'>...</span>"
+        end
+        
+        start_page = [current_page - 1, 2].max
+        end_page = [current_page + 1, total_pages - 1].min
+        
+        (start_page..end_page).each do |page|
+          links << page_link(page, current_page)
+        end
+        
+        if current_page < total_pages - 2
+          links << "<span class='pagination-gap'>...</span>"
+        end
+        
+        links << page_link(total_pages, current_page)
+      end
+      
+      # Next page link
+      if current_page < total_pages
+        links << "<a href='?page=#{current_page + 1}#{query_params}' class='pagination-link'>Next &raquo;</a>"
+      else
+        links << "<span class='pagination-link disabled'>Next &raquo;</span>"
+      end
+      
+      <<-HTML
+        <div class="pagination">
+          #{links.join}
+        </div>
+      HTML
+    end
+
+    def calculate_visible_pages(current_page, total_pages)
+      if total_pages <= 7
+        (1..total_pages).to_a
+      else
+        case current_page
+        when 1..3
+          [1, 2, 3, 4, :gap, total_pages]
+        when (total_pages - 2)..total_pages
+          [1, :gap, total_pages - 3, total_pages - 2, total_pages - 1, total_pages]
+        else
+          [1, :gap, current_page - 1, current_page, current_page + 1, :gap, total_pages]
+        end
+      end
+    end
+
+    def format_datetime(datetime)
+      return '-' unless datetime
+      datetime.strftime('%Y-%m-%d %H:%M:%S')
+    end
+
+    def format_arguments(arguments)
+      return '-' unless arguments.present?
+      
+      if arguments.is_a?(Array) && arguments.length == 1 && arguments[0].is_a?(Hash)
+        # Handle ActiveJob-style arguments
+        format_hash(arguments[0])
+      else
+        "<code>#{arguments.to_json}</code>"
+      end
+    end
+
+    def format_hash(hash)
+      return '-' unless hash.present?
+      
+      formatted = hash.map do |key, value|
+        "<strong>#{key}:</strong> #{value.to_s.truncate(50)}"
+      end.join(', ')
+      
+      "<code>#{formatted}</code>"
+    end
+
+    private
+
+    def page_link(page, current_page)
+      if page == current_page
+        "<span class='pagination-current'>#{page}</span>"
+      else
+        "<a href='?page=#{page}#{query_params}' class='pagination-link'>#{page}</a>"
+      end
+    end
+
+    def query_params
+      params = []
+      params << "class_name=#{CGI.escape(@filters[:class_name])}" if @filters && @filters[:class_name].present?
+      params << "queue_name=#{CGI.escape(@filters[:queue_name])}" if @filters && @filters[:queue_name].present?
+      params << "status=#{CGI.escape(@filters[:status])}" if @filters && @filters[:status].present?
+      
+      params.empty? ? '' : "&#{params.join('&')}"
+    end
+  end
+end

data/app/presenters/solid_queue_monitor/failed_jobs_presenter.rb

@@ -0,0 +1,70 @@
+module SolidQueueMonitor
+  class FailedJobsPresenter < BasePresenter
+    def initialize(jobs, current_page: 1, total_pages: 1, filters: {})
+      @jobs = jobs
+      @current_page = current_page
+      @total_pages = total_pages
+      @filters = filters
+    end
+
+    def render
+      section_wrapper('Failed Jobs', generate_filter_form + generate_table + generate_pagination(@current_page, @total_pages))
+    end
+
+    private
+
+    def generate_filter_form
+      <<-HTML
+        <div class="filter-form-container">
+          <form method="get" action="" class="filter-form">
+            <div class="filter-group">
+              <label for="class_name">Job Class:</label>
+              <input type="text" name="class_name" id="class_name" value="#{@filters[:class_name]}" placeholder="Filter by class name">
+            </div>
+
+            <div class="filter-group">
+              <label for="queue_name">Queue:</label>
+              <input type="text" name="queue_name" id="queue_name" value="#{@filters[:queue_name]}" placeholder="Filter by queue">
+            </div>
+
+            <div class="filter-actions">
+              <button type="submit" class="filter-button">Apply Filters</button>
+              <a href="#{failed_jobs_path}" class="reset-button">Reset</a>
+            </div>
+          </form>
+        </div>
+      HTML
+    end
+
+    def generate_table
+      <<-HTML
+        <div class="table-container">
+          <table>
+            <thead>
+              <tr>
+                <th>Job</th>
+                <th>Error</th>
+                <th>Failed At</th>
+                <th>Arguments</th>
+              </tr>
+            </thead>
+            <tbody>
+              #{@jobs.map { |execution| generate_row(execution) }.join}
+            </tbody>
+          </table>
+        </div>
+      HTML
+    end
+
+    def generate_row(execution)
+      <<-HTML
+        <tr>
+          <td>#{execution.job.class_name}</td>
+          <td class="error-message">#{execution.error['message']}</td>
+          <td>#{format_datetime(execution.created_at)}</td>
+          <td>#{format_arguments(execution.job.arguments)}</td>
+        </tr>
+      HTML
+    end
+  end
+end