job_harbor 0.6.0 → 0.7.0

data/app/controllers/job_harbor/jobs_controller.rb

@@ -2,13 +2,16 @@
 
 module JobHarbor
   class JobsController < ApplicationController
+    BULK_BATCH_SIZE = 500
+
     before_action :set_job, only: [ :show, :retry, :discard ]
+    before_action :reject_malformed_filters, only: [ :retry_all, :discard_all ]
 
     def index
       @status = params[:status]
       @per_page = per_page_param
-      @class_name = params[:class_name]
-      @queue_name = params[:queue_name]
+      @class_name = filter_param(:class_name)
+      @queue_name = filter_param(:queue_name)
 
       @pagy, @jobs = JobPresenter.all_with_status(
         @status,
@@ -18,6 +21,7 @@ module JobHarbor
         queue_name: @queue_name
       )
       @counts = job_counts
+      @bulk_count = bulk_scope(@status)&.count
       @filter_data = filter_data
       set_page_title @status ? "#{@status.titleize} Jobs" : "All Jobs"
     end
@@ -47,24 +51,23 @@ module JobHarbor
     end
 
     def discard
-      if @job.can_discard?
-        perform_discard(@job)
+      if @job.can_discard? && @job.discard
         redirect_to jobs_path(status: params[:return_status]), notice: "Job has been discarded."
       else
         redirect_to job_path(@job), alert: "This job cannot be discarded."
       end
+    rescue SolidQueue::Execution::UndiscardableError
+      redirect_to job_path(@job), alert: "This job cannot be discarded."
     end
 
     def retry_all
-      status = params[:status]
-      count = retry_all_jobs(status)
-      redirect_to jobs_path(status: status), notice: "#{count} jobs queued for retry."
+      count = retry_all_jobs(params[:status])
+      redirect_to bulk_redirect_path, notice: "#{helpers.pluralize(count, "job")} queued for retry."
     end
 
     def discard_all
-      status = params[:status]
-      count = discard_all_jobs(status)
-      redirect_to jobs_path(status: status), notice: "#{count} jobs discarded."
+      count = discard_all_jobs(params[:status])
+      redirect_to bulk_redirect_path, notice: "#{helpers.pluralize(count, "job")} discarded."
     end
 
     private
@@ -107,44 +110,48 @@ module JobHarbor
       failed_execution.retry
     end
 
-    def perform_discard(job)
-      # Remove from any execution tables
-      SolidQueue::FailedExecution.where(job_id: job.id).delete_all
-      SolidQueue::BlockedExecution.where(job_id: job.id).delete_all
-      SolidQueue::ScheduledExecution.where(job_id: job.id).delete_all
-      SolidQueue::ReadyExecution.where(job_id: job.id).delete_all
+    # Nil for tabs without bulk actions.
+    def bulk_scope(status)
+      executions = case status
+      when "failed" then SolidQueue::FailedExecution
+      when "blocked" then SolidQueue::BlockedExecution
+      end
+      return unless executions
+
+      JobPresenter.apply_filters(
+        SolidQueue::Job.where(id: executions.select(:job_id)),
+        class_name: filter_param(:class_name),
+        queue_name: filter_param(:queue_name)
+      )
+    end
 
-      # Mark job as finished (discarded)
-      SolidQueue::Job.where(id: job.id).update_all(finished_at: Time.current)
+    def reject_malformed_filters
+      head :bad_request unless %i[ class_name queue_name ].all? { |key| params[key].nil? || params[key].is_a?(String) }
+    end
+
+    def filter_param(key)
+      params[key] if params[key].is_a?(String)
+    end
+
+    def bulk_redirect_path
+      jobs_path(status: params[:status], class_name: filter_param(:class_name).presence, queue_name: filter_param(:queue_name).presence)
     end
 
     def retry_all_jobs(status)
       return 0 unless status == "failed"
 
-      count = 0
-      SolidQueue::FailedExecution.find_each do |fe|
-        fe.retry
-        count += 1
-      end
-      count
+      bulk_scope(status).in_batches(of: BULK_BATCH_SIZE).sum { |jobs| SolidQueue::FailedExecution.retry_all(jobs) }
     end
 
     def discard_all_jobs(status)
-      case status
-      when "failed"
-        count = SolidQueue::FailedExecution.count
-        job_ids = SolidQueue::FailedExecution.pluck(:job_id)
-        SolidQueue::FailedExecution.delete_all
-        SolidQueue::Job.where(id: job_ids).update_all(finished_at: Time.current)
-        count
-      when "blocked"
-        count = SolidQueue::BlockedExecution.count
-        job_ids = SolidQueue::BlockedExecution.pluck(:job_id)
-        SolidQueue::BlockedExecution.delete_all
-        SolidQueue::Job.where(id: job_ids).update_all(finished_at: Time.current)
-        count
-      else
-        0
+      scope = bulk_scope(status)
+      return 0 unless scope
+
+      executions = status == "failed" ? SolidQueue::FailedExecution : SolidQueue::BlockedExecution
+      scope.in_batches(of: BULK_BATCH_SIZE).sum do |jobs|
+        ids = jobs.ids
+        executions.discard_all_from_jobs(jobs)
+        ids.size - SolidQueue::Job.where(id: ids).count
       end
     end
   end

data/app/controllers/job_harbor/queues_controller.rb

@@ -13,20 +13,19 @@ module JobHarbor
       @pagy, @jobs = JobPresenter.all_with_status(
         nil,
         page: params[:page],
-        per_page: sq_config.jobs_per_page
+        per_page: sq_config.jobs_per_page,
+        queue_name: @queue.name
       )
-      # Filter to only jobs in this queue
-      @jobs = @jobs.select { |j| j.queue_name == @queue.name }
       set_page_title "Queue: #{@queue.name}"
     end
 
     def pause
-      @queue.pause!
+      @queue.pause
       redirect_to queues_path, notice: "Queue '#{@queue.name}' has been paused."
     end
 
     def resume
-      @queue.resume!
+      @queue.resume
       redirect_to queues_path, notice: "Queue '#{@queue.name}' has been resumed."
     end
 

data/app/controllers/job_harbor/recurring_tasks_controller.rb

@@ -2,7 +2,10 @@
 
 module JobHarbor
   class RecurringTasksController < ApplicationController
+    RECENT_EXECUTIONS_LIMIT = 20
+
     before_action :set_task, only: [ :show, :enqueue_now ]
+    before_action :ensure_job_class_defined, only: :enqueue_now
 
     def index
       @tasks = SolidQueue::RecurringTask.order(:key)
@@ -10,22 +13,47 @@ module JobHarbor
     end
 
     def show
-      @recent_executions = SolidQueue::RecurringExecution
-        .where(task_key: @task.key)
-        .order(created_at: :desc)
-        .limit(20)
+      executions = SolidQueue::RecurringExecution.where(task_key: @task.key)
+      @task_arguments = RecurringTaskArguments.new(@task)
+      @executions_count = executions.count
+      @last_run_at = executions.maximum(:run_at)
+      @recent_executions = executions.order(run_at: :desc).limit(RECENT_EXECUTIONS_LIMIT)
       set_page_title "Task: #{@task.key}"
     end
 
     def enqueue_now
-      @task.enqueue(at: Time.current)
-      redirect_to recurring_task_path(@task), notice: "Task '#{@task.key}' has been enqueued."
-    rescue => e
-      redirect_to recurring_task_path(@task), alert: "Failed to enqueue task: #{e.message}"
+      if enqueued?(at: Time.current.change(usec: 0))
+        redirect_to recurring_task_path(@task), notice: "Task '#{@task.key}' has been enqueued."
+      else
+        redirect_to recurring_task_path(@task),
+          alert: "Task '#{@task.key}' was not enqueued. It may have just run, or the job refused to enqueue; check the logs."
+      end
     end
 
     private
 
+    # Whole seconds, like cron ticks, so same-second clicks hit SQ's unique (task_key, run_at).
+    # SQ 1.0.x records a halted job with a nil job_id; the NotNullViolation rolls back.
+    def enqueued?(at:)
+      job = @task.enqueue(at: at)
+      job.present? && job.successfully_enqueued?
+    rescue ActiveRecord::NotNullViolation => error
+      Rails.error.report(error, handled: true)
+      false
+    end
+
+    # SQ's job_class is nil for an undefined class; blank class_name uses SQ's default job.
+    def ensure_job_class_defined
+      class_name = @task.class_name
+      return if class_name.blank?
+
+      job_class = class_name.safe_constantize
+      return if job_class.is_a?(Class) && job_class < ActiveJob::Base
+
+      redirect_to recurring_task_path(@task),
+        alert: "Task '#{@task.key}' can't run: #{class_name} isn't a job class defined in this app."
+    end
+
     def set_task
       @task = SolidQueue::RecurringTask.find(params[:id])
     rescue ActiveRecord::RecordNotFound

data/app/controllers/job_harbor/workers_controller.rb

@@ -4,7 +4,7 @@ module JobHarbor
   class WorkersController < ApplicationController
     def index
       @workers = SolidQueue::Process.order(last_heartbeat_at: :desc)
-      @active_count = @workers.where("last_heartbeat_at > ?", 5.minutes.ago).count
+      @active_count = Processes.alive.count
       @stale_count = @workers.count - @active_count
       set_page_title "Workers"
     end

data/app/models/job_harbor/chart_data.rb

@@ -13,7 +13,7 @@ module JobHarbor
     def initialize(range: "24h")
       @range = RANGES[range] || RANGES["24h"]
       @duration = @range[:duration]
-      @interval = @range[:interval]
+      @interval = @range[:interval].to_i
       @cutoff = Time.current - @duration
     end
 
@@ -22,83 +22,42 @@ module JobHarbor
     end
 
     def series
-      @series ||= calculate_series
+      @series ||= {
+        labels: bucket_starts.map { |time| format_label(time) },
+        completed: counts_per_bucket(SolidQueue::Job, :finished_at),
+        failed: counts_per_bucket(SolidQueue::FailedExecution, :created_at),
+        enqueued: counts_per_bucket(SolidQueue::Job, :created_at)
+      }
     end
 
     private
 
-    def calculate_series
-      buckets = generate_time_buckets
-      labels = buckets.map { |t| format_label(t) }
-
-      completed = count_by_bucket(completed_jobs, :finished_at, buckets)
-      failed = count_by_bucket(failed_jobs, :created_at, buckets)
-      enqueued = count_by_bucket(enqueued_jobs, :created_at, buckets)
-
-      {
-        labels: labels,
-        completed: completed,
-        failed: failed,
-        enqueued: enqueued
-      }
+    def bucket_count
+      @duration.to_i / @interval
     end
 
-    def generate_time_buckets
-      buckets = []
-      current = @cutoff
-      while current <= Time.current
-        buckets << current
-        current += @interval
-      end
-      buckets
+    def bucket_starts
+      Array.new(bucket_count) { |index| @cutoff + index * @interval }
     end
 
     def format_label(time)
-      if @duration <= 1.hour
-        time.strftime("%H:%M")
-      elsif @duration <= 24.hours
-        time.strftime("%H:%M")
-      else
-        time.strftime("%b %d")
-      end
+      @duration <= 24.hours ? time.strftime("%H:%M") : time.strftime("%b %d")
     end
 
-    def count_by_bucket(scope, time_field, buckets)
-      # Get counts grouped by time bucket
-      counts = scope
-        .where("#{time_field} >= ?", @cutoff)
-        .group_by_period(@interval, time_field)
+    # One row of SUM(CASE ...) per series: ANSI SQL, so it needs no per-database date truncation.
+    def counts_per_bucket(model, time_field)
+      column = "#{model.quoted_table_name}.#{model.connection.quote_column_name(time_field)}"
+      sums = bucket_starts.each_with_index.map { |start, index| bucket_sum(model, column, start, last: index == bucket_count - 1) }
 
-      # Map to bucket array
-      buckets.map do |bucket_start|
-        bucket_end = bucket_start + @interval
-        counts.count { |time, _| time >= bucket_start && time < bucket_end }
-      end
-    rescue => e
-      # Fallback to simple counting if group_by_period isn't available
-      buckets.map do |bucket_start|
-        bucket_end = bucket_start + @interval
-        scope.where("#{time_field} >= ? AND #{time_field} < ?", bucket_start, bucket_end).count
-      end
+      model.where(time_field => @cutoff..).pick(*sums).map(&:to_i)
     end
 
-    def completed_jobs
-      SolidQueue::Job.where.not(finished_at: nil)
-    end
-
-    def failed_jobs
-      SolidQueue::FailedExecution.all
-    end
-
-    def enqueued_jobs
-      SolidQueue::Job.all
-    end
+    # The last bucket is open-ended so a job stamped at the instant of the query still counts.
+    def bucket_sum(model, column, start, last:)
+      within = last ? "#{column} >= ?" : "#{column} >= ? AND #{column} < ?"
+      binds = last ? [ start ] : [ start, start + @interval ]
 
-    def group_by_period(scope, interval, time_field)
-      # Simple implementation - group records by time bucket
-      scope.pluck(time_field).group_by do |time|
-        time.to_i / interval.to_i * interval.to_i
-      end.transform_keys { |ts| Time.at(ts) }
+      Arel.sql(model.sanitize_sql_array([ "SUM(CASE WHEN #{within} THEN 1 ELSE 0 END)", *binds ]))
     end
   end
 end

data/app/models/job_harbor/dashboard_stats.rb

@@ -11,10 +11,6 @@ module JobHarbor
       calculate_stats
     end
 
-    def total_jobs
-      pending_count + scheduled_count + in_progress_count + failed_count + blocked_count
-    end
-
     private
 
     def calculate_stats
@@ -51,32 +47,19 @@ module JobHarbor
     end
 
     def finished_jobs_count
-      # Count jobs finished in the last 24 hours
-      if SolidQueue::Job.column_names.include?("finished_at")
-        SolidQueue::Job.where("finished_at > ?", 24.hours.ago).count
-      else
-        0
-      end
+      SolidQueue::Job.where("finished_at > ?", 24.hours.ago).count
     end
 
     def active_workers_count
-      SolidQueue::Process.where("last_heartbeat_at > ?", 5.minutes.ago).count
+      Processes.live_workers.count
     end
 
     def queues_count_calc
-      SolidQueue::Queue.count
-    rescue
-      # Fallback: count unique queue names from jobs
       SolidQueue::Job.distinct.count(:queue_name)
     end
 
     def calculate_throughput
-      # Jobs finished in the last hour
-      if SolidQueue::Job.column_names.include?("finished_at")
-        SolidQueue::Job.where("finished_at > ?", 1.hour.ago).count
-      else
-        0
-      end
+      SolidQueue::Job.where("finished_at > ?", 1.hour.ago).count
     end
 
     def fetch_recent_failures

data/app/models/job_harbor/failure_stats.rb

@@ -3,61 +3,25 @@
 module JobHarbor
   class FailureStats
     WINDOW = 24.hours
-    LOW_THRESHOLD = 5
-    MEDIUM_THRESHOLD = 20
-
-    def initialize(window: WINDOW)
-      @window = window
-      @cutoff = Time.current - @window
-    end
 
     def stats
       @stats ||= calculate_stats
     end
 
-    def self.rate_badge_class(rate)
-      case rate
-      when 0...LOW_THRESHOLD
-        "sqd-rate-low"
-      when LOW_THRESHOLD...MEDIUM_THRESHOLD
-        "sqd-rate-medium"
-      else
-        "sqd-rate-high"
-      end
-    end
-
     private
 
     def calculate_stats
-      # Get all jobs in the window period
-      recent_jobs = SolidQueue::Job.where("created_at >= ?", @cutoff)
-
-      # Group by class_name and calculate totals
-      job_counts = recent_jobs.group(:class_name).count
-
-      # Get failed job counts (jobs that have failed executions)
-      failed_job_ids = SolidQueue::FailedExecution
-        .joins(:job)
-        .where("solid_queue_jobs.created_at >= ?", @cutoff)
-        .pluck(:job_id)
+      since = Time.current - WINDOW
+      recent_jobs = SolidQueue::Job.where(created_at: since..)
 
-      failed_counts = SolidQueue::Job
-        .where(id: failed_job_ids)
-        .group(:class_name)
-        .count
+      totals = recent_jobs.group(:class_name).count
+      failures = recent_jobs.joins(:failed_execution).group(:class_name).count
 
-      # Build stats array
-      job_counts.map do |class_name, total|
-        failed = failed_counts[class_name] || 0
-        rate = total > 0 ? (failed.to_f / total * 100).round(1) : 0.0
+      totals.map do |class_name, total|
+        failed = failures.fetch(class_name, 0)
 
-        {
-          class_name: class_name,
-          total: total,
-          failed: failed,
-          rate: rate
-        }
-      end.sort_by { |s| -s[:rate] }
+        { class_name: class_name, total: total, failed: failed, rate: (failed.to_f / total * 100).round(1) }
+      end.sort_by { |stat| -stat[:rate] }
     end
   end
 end