solid_queue_monitor 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1cadc5702b1a5de9167c64a48abfb6639362a3d4e765a3fb1bdf250f5ed4fa81
-  data.tar.gz: 9f76e05408872948070221edb908146e134bbf67d6be1bc5fe8e8cbbd6b181ea
+  metadata.gz: 264dd6a6542855e5209702c11fbb46c1c267b5c8d48d530887030f924bdb929f
+  data.tar.gz: 4d5a33c4152f29d0c3ba4c9fd6c59582e7af9694e85469a78cde9a9d173a4433
 SHA512:
-  metadata.gz: c27275ffbfc1c18e3c790abe1c6776f417af6c8684ffd33e392ae94dccb022b6465fe4754154aec86e6c2690f77e5ec674cf77893ce71c34e40a71498d9364e7
-  data.tar.gz: ebb05f940720c5f10aab733f2632584d274af3c786300ba56d9f208535610d5034bbd3b0e8554d55e9f2244e4c6a460f646ef68ad533f03edab038264d7c2c12
+  metadata.gz: 704927588ba7329d988a7533ab70e6b444254abc64a15684fbeccce47221c929c39701abd8fbb02dbebf444c0c3a9521cbcc84260d06d3c6fdafca6e01ad2be5
+  data.tar.gz: 8b0a608d0ae89c54719dd5286e9de77cb4145d1f1c3dc7c3f8c1b46a521ae1b2e0ad37d35e7c2796a187122fc38f401b423a46109cc81328cff6805274338357

data/README.md

@@ -32,16 +32,16 @@ A lightweight, zero-dependency web interface for monitoring Solid Queue backgrou
 
 ![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', '~> 0.1.2'
+gem 'solid_queue_monitor', '~> 0.2.0'
 ```
 
 Then execute:
@@ -151,4 +151,4 @@ Everyone interacting in the SolidQueueMonitor project's codebases, issue tracker
 
 - [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 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/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 

data/app/presenters/solid_queue_monitor/base_presenter.rb

@@ -32,8 +32,12 @@ module SolidQueueMonitor
       end
       
       # Page links
-      (1..total_pages).each do |page|
-        if page == current_page
+      visible_pages = calculate_visible_pages(current_page, total_pages)
+      
+      visible_pages.each do |page|
+        if page == :gap
+          html += "<span class=\"pagination-gap\">...</span>"
+        elsif page == current_page
           html += "<span class=\"pagination-current\">#{page}</span>"
         else
           html += "<a href=\"?page=#{page}#{query_params}\" class=\"pagination-link\">#{page}</a>"

data/app/presenters/solid_queue_monitor/failed_jobs_presenter.rb

@@ -302,9 +302,5 @@ module SolidQueueMonitor
       # If there's an error accessing queue_name, fall back to job's queue_name
       job.queue_name
     end
-    
-    def default_url_options
-      { only_path: true }
-    end
   end
 end

data/app/presenters/solid_queue_monitor/in_progress_jobs_presenter.rb

@@ -0,0 +1,71 @@
+module SolidQueueMonitor
+  class InProgressJobsPresenter < BasePresenter
+    include SolidQueueMonitor::Engine.routes.url_helpers
+
+    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('In Progress 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="#{in_progress_jobs_path}" 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-actions">
+              <button type="submit" class="filter-button">Apply Filters</button>
+              <a href="#{in_progress_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>Started At</th>
+                <th>Process ID</th>
+              </tr>
+            </thead>
+            <tbody>
+              #{@jobs.map { |execution| generate_row(execution) }.join}
+            </tbody>
+          </table>
+        </div>
+      HTML
+    end
+
+    def generate_row(execution)
+      job = execution.job
+      <<-HTML
+        <tr>
+          <td>
+            <div class="job-class">#{job.class_name}</div>
+            <div class="job-meta">
+              <span class="job-timestamp">Queued at: #{format_datetime(job.created_at)}</span>
+            </div>
+          </td>
+          <td>#{format_datetime(execution.created_at)}</td>
+          <td>#{execution.process_id}</td>
+        </tr>
+      HTML
+    end
+  end
+end 

data/app/presenters/solid_queue_monitor/jobs_presenter.rb

@@ -70,6 +70,7 @@ module SolidQueueMonitor
                 <th>Queue</th>
                 <th>Status</th>
                 <th>Created At</th>
+                <th>Actions</th>
               </tr>
             </thead>
             <tbody>
@@ -82,15 +83,48 @@ module SolidQueueMonitor
 
     def generate_row(job)
       status = job_status(job)
-      <<-HTML
+
+      # Build the row HTML
+      row_html = <<-HTML
         <tr>
           <td>#{job.id}</td>
           <td>#{job.class_name}</td>
           <td>#{job.queue_name}</td>
           <td><span class='status-badge status-#{status}'>#{status}</span></td>
           <td>#{format_datetime(job.created_at)}</td>
-        </tr>
       HTML
+
+      # Add actions column only for failed jobs
+      if status == 'failed'
+        # Find the failed execution record for this job
+        failed_execution = SolidQueue::FailedExecution.find_by(job_id: job.id)
+
+        if failed_execution
+          row_html += <<-HTML
+            <td class="actions-cell">
+              <div class="job-actions">
+                <form method="post" action="#{retry_failed_job_path(id: failed_execution.id)}" class="inline-form">
+                  <input type="hidden" name="redirect_to" value="#{root_path}">
+                  <button type="submit" class="action-button retry-button">Retry</button>
+                </form>
+
+                <form method="post" action="#{discard_failed_job_path(id: failed_execution.id)}" class="inline-form"
+                      onsubmit="return confirm('Are you sure you want to discard this job?');">
+                  <input type="hidden" name="redirect_to" value="#{root_path}">
+                  <button type="submit" class="action-button discard-button">Discard</button>
+                </form>
+              </div>
+            </td>
+          HTML
+        else
+          row_html += "<td></td>"
+        end
+      else
+        row_html += "<td></td>"
+      end
+
+      row_html += "</tr>"
+      row_html
     end
 
     def job_status(job)

data/app/presenters/solid_queue_monitor/stats_presenter.rb

@@ -10,12 +10,12 @@ module SolidQueueMonitor
           <h3>Queue Statistics</h3>
           <div class="stats">
             #{generate_stat_card('Total Jobs', @stats[:total_jobs])}
-            #{generate_stat_card('Unique Queues', @stats[:unique_queues])}
             #{generate_stat_card('Ready', @stats[:ready])}
+            #{generate_stat_card('In Progress', @stats[:in_progress])}
             #{generate_stat_card('Scheduled', @stats[:scheduled])}
+            #{generate_stat_card('Recurring', @stats[:recurring])}
             #{generate_stat_card('Failed', @stats[:failed])}
             #{generate_stat_card('Completed', @stats[:completed])}
-            #{generate_stat_card('Recurring', @stats[:recurring])}
           </div>
         </div>
       HTML

data/app/services/solid_queue_monitor/failed_job_service.rb

@@ -8,14 +8,12 @@ module SolidQueueMonitor
       return { success: false, message: "Associated job not found" } unless job
       
       ActiveRecord::Base.transaction do
-        # Create a ready execution for the job
         SolidQueue::ReadyExecution.create!(
           job_id: job.id,
           queue_name: get_queue_name(failed_execution, job),
           priority: job.priority
         )
         
-        # Delete the failed execution
         failed_execution.destroy!
       end
       
@@ -30,10 +28,8 @@ module SolidQueueMonitor
       return { success: false, message: "Associated job not found" } unless job
       
       ActiveRecord::Base.transaction do
-        # Mark the job as finished
         job.update!(finished_at: Time.current)
         
-        # Delete the failed execution
         failed_execution.destroy!
       end
       
@@ -91,11 +87,9 @@ module SolidQueueMonitor
     private
     
     def get_queue_name(failed_execution, job)
-      # Try to get queue_name from failed_execution if the method exists
       if failed_execution.respond_to?(:queue_name) && failed_execution.queue_name.present?
         failed_execution.queue_name
       else
-        # Fall back to job's queue_name
         job.queue_name
       end
     end

data/app/services/solid_queue_monitor/html_generator.rb

@@ -89,8 +89,9 @@ module SolidQueueMonitor
           <nav class="navigation">
             <a href="#{root_path}" class="nav-link">Overview</a>
             <a href="#{ready_jobs_path}" class="nav-link">Ready Jobs</a>
-            <a href="#{recurring_jobs_path}" class="nav-link">Recurring Jobs</a>
+            <a href="#{in_progress_jobs_path}" class="nav-link">In Progress Jobs</a>
             <a href="#{scheduled_jobs_path}" class="nav-link">Scheduled Jobs</a>
+            <a href="#{recurring_jobs_path}" class="nav-link">Recurring Jobs</a>
             <a href="#{failed_jobs_path}" class="nav-link">Failed Jobs</a>
             <a href="#{queues_path}" class="nav-link">Queues</a>
           </nav>

data/app/services/solid_queue_monitor/stats_calculator.rb

@@ -7,6 +7,7 @@ module SolidQueueMonitor
         scheduled: SolidQueue::ScheduledExecution.count,
         ready: SolidQueue::ReadyExecution.count,
         failed: SolidQueue::FailedExecution.count,
+        in_progress: SolidQueue::ClaimedExecution.count,
         completed: SolidQueue::Job.where.not(finished_at: nil).count,
         recurring: SolidQueue::RecurringTask.count
       }

data/config/routes.rb

@@ -1,17 +1,17 @@
 SolidQueueMonitor::Engine.routes.draw do
-  root to: 'monitor#index'
+  root to: 'overview#index', as: :root
   
-  get 'ready_jobs', to: 'monitor#ready_jobs', as: 'ready_jobs'
-  get 'scheduled_jobs', to: 'monitor#scheduled_jobs', as: 'scheduled_jobs'
-  get 'failed_jobs', to: 'monitor#failed_jobs', as: 'failed_jobs'
-  get 'recurring_jobs', to: 'monitor#recurring_jobs', as: 'recurring_jobs'
-  get 'queues', to: 'monitor#queues', as: 'queues'
+  resources :ready_jobs, only: [:index]
+  resources :scheduled_jobs, only: [:index]
+  resources :recurring_jobs, only: [:index]
+  resources :failed_jobs, only: [:index]
+  resources :in_progress_jobs, only: [:index]
+  resources :queues, only: [:index]
   
-  post 'execute_jobs', to: 'monitor#execute_jobs', as: 'execute_jobs'
+  post 'execute_jobs', to: 'scheduled_jobs#create', as: :execute_jobs
   
-  # Failed job actions
-  post 'retry_failed_job/:id', to: 'monitor#retry_failed_job', as: 'retry_failed_job'
-  post 'discard_failed_job/:id', to: 'monitor#discard_failed_job', as: 'discard_failed_job'
-  post 'retry_failed_jobs', to: 'monitor#retry_failed_jobs', as: 'retry_failed_jobs'
-  post 'discard_failed_jobs', to: 'monitor#discard_failed_jobs', as: 'discard_failed_jobs'
+  post 'retry_failed_job/:id', to: 'failed_jobs#retry', as: :retry_failed_job
+  post 'discard_failed_job/:id', to: 'failed_jobs#discard', as: :discard_failed_job
+  post 'retry_failed_jobs', to: 'failed_jobs#retry_all', as: :retry_failed_jobs
+  post 'discard_failed_jobs', to: 'failed_jobs#discard_all', as: :discard_failed_jobs
 end

data/lib/solid_queue_monitor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SolidQueueMonitor
-  VERSION = "0.1.2"
-end
+  VERSION = "0.2.0"
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: solid_queue_monitor
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Vishal Sadriya
 bindir: exe
 cert_chain: []
-date: 2025-03-18 00:00:00.000000000 Z
+date: 2025-03-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -187,9 +187,18 @@ extra_rdoc_files: []
 files:
 - README.md
 - Rakefile
+- app/controllers/solid_queue_monitor/base_controller.rb
+- app/controllers/solid_queue_monitor/failed_jobs_controller.rb
+- app/controllers/solid_queue_monitor/in_progress_jobs_controller.rb
 - app/controllers/solid_queue_monitor/monitor_controller.rb
+- app/controllers/solid_queue_monitor/overview_controller.rb
+- app/controllers/solid_queue_monitor/queues_controller.rb
+- app/controllers/solid_queue_monitor/ready_jobs_controller.rb
+- app/controllers/solid_queue_monitor/recurring_jobs_controller.rb
+- app/controllers/solid_queue_monitor/scheduled_jobs_controller.rb
 - app/presenters/solid_queue_monitor/base_presenter.rb
 - app/presenters/solid_queue_monitor/failed_jobs_presenter.rb
+- app/presenters/solid_queue_monitor/in_progress_jobs_presenter.rb
 - app/presenters/solid_queue_monitor/jobs_presenter.rb
 - app/presenters/solid_queue_monitor/queues_presenter.rb
 - app/presenters/solid_queue_monitor/ready_jobs_presenter.rb