job_harbor 0.1.0

data/app/models/job_harbor/chart_data.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module JobHarbor
+  class ChartData
+    RANGES = {
+      "15m" => { duration: 15.minutes, interval: 1.minute, label: "15 min" },
+      "1h" => { duration: 1.hour, interval: 5.minutes, label: "1 hour" },
+      "6h" => { duration: 6.hours, interval: 30.minutes, label: "6 hours" },
+      "24h" => { duration: 24.hours, interval: 1.hour, label: "24 hours" },
+      "7d" => { duration: 7.days, interval: 6.hours, label: "7 days" }
+    }.freeze
+
+    def initialize(range: "24h")
+      @range = RANGES[range] || RANGES["24h"]
+      @duration = @range[:duration]
+      @interval = @range[:interval]
+      @cutoff = Time.current - @duration
+    end
+
+    def self.available_ranges
+      RANGES.map { |key, config| { value: key, label: config[:label] } }
+    end
+
+    def series
+      @series ||= calculate_series
+    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
+      }
+    end
+
+    def generate_time_buckets
+      buckets = []
+      current = @cutoff
+      while current <= Time.current
+        buckets << current
+        current += @interval
+      end
+      buckets
+    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
+    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)
+
+      # 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
+    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
+
+    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) }
+    end
+  end
+end

data/app/models/job_harbor/dashboard_stats.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module JobHarbor
+  class DashboardStats
+    attr_reader :pending_count, :scheduled_count, :in_progress_count,
+                :failed_count, :blocked_count, :finished_count,
+                :workers_count, :queues_count, :throughput_per_hour,
+                :recent_failures
+
+    def initialize
+      calculate_stats
+    end
+
+    def total_jobs
+      pending_count + scheduled_count + in_progress_count + failed_count + blocked_count
+    end
+
+    private
+
+    def calculate_stats
+      @pending_count = ready_executions_count
+      @scheduled_count = scheduled_executions_count
+      @in_progress_count = claimed_executions_count
+      @failed_count = failed_executions_count
+      @blocked_count = blocked_executions_count
+      @finished_count = finished_jobs_count
+      @workers_count = active_workers_count
+      @queues_count = queues_count_calc
+      @throughput_per_hour = calculate_throughput
+      @recent_failures = fetch_recent_failures
+    end
+
+    def ready_executions_count
+      SolidQueue::ReadyExecution.count
+    end
+
+    def scheduled_executions_count
+      SolidQueue::ScheduledExecution.count
+    end
+
+    def claimed_executions_count
+      SolidQueue::ClaimedExecution.count
+    end
+
+    def failed_executions_count
+      SolidQueue::FailedExecution.count
+    end
+
+    def blocked_executions_count
+      SolidQueue::BlockedExecution.count
+    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
+    end
+
+    def active_workers_count
+      SolidQueue::Process.where("last_heartbeat_at > ?", 5.minutes.ago).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
+    end
+
+    def fetch_recent_failures
+      SolidQueue::FailedExecution
+        .includes(:job)
+        .order(created_at: :desc)
+        .limit(5)
+        .map { |fe| JobPresenter.new(fe.job, failed_execution: fe) }
+    end
+  end
+end

data/app/models/job_harbor/failure_stats.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+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)
+
+      failed_counts = SolidQueue::Job
+        .where(id: failed_job_ids)
+        .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
+
+        {
+          class_name: class_name,
+          total: total,
+          failed: failed,
+          rate: rate
+        }
+      end.sort_by { |s| -s[:rate] }
+    end
+  end
+end

data/app/models/job_harbor/job_presenter.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+require "ostruct"
+
+module JobHarbor
+  class JobPresenter
+    include ActionView::Helpers::DateHelper
+
+    delegate :id, :created_at, :updated_at, :queue_name, :priority,
+             :active_job_id, :arguments, :scheduled_at, :finished_at,
+             to: :@job
+
+    def initialize(job, failed_execution: nil, claimed_execution: nil)
+      @job = job
+      @failed_execution = failed_execution
+      @claimed_execution = claimed_execution
+    end
+
+    def class_name
+      @job.class_name
+    end
+
+    def status
+      @status ||= determine_status
+    end
+
+    def arguments_preview
+      args = parsed_arguments
+      return "No arguments" if args.empty?
+
+      preview = args.to_json
+      preview.length > 100 ? "#{preview[0..100]}..." : preview
+    end
+
+    def parsed_arguments
+      JSON.parse(@job.arguments.to_s)
+    rescue JSON::ParserError
+      @job.arguments
+    end
+
+    def error_message
+      @failed_execution&.error&.dig("message")
+    end
+
+    def error_class
+      @failed_execution&.error&.dig("exception_class")
+    end
+
+    def error_backtrace
+      @failed_execution&.error&.dig("backtrace")&.join("\n")
+    end
+
+    def failed_at
+      @failed_execution&.created_at
+    end
+
+    def worker_name
+      @claimed_execution&.process&.name
+    end
+
+    def execution_count
+      args = parsed_arguments
+      return 1 unless args.is_a?(Hash)
+
+      (args["executions"] || args[:executions] || 1).to_i
+    end
+
+    def running_duration
+      return nil unless status == "in_progress"
+
+      claimed = @claimed_execution || SolidQueue::ClaimedExecution.find_by(job_id: @job.id)
+      return nil unless claimed
+
+      distance_of_time_in_words(claimed.created_at, Time.current)
+    end
+
+    def relative_created_at
+      time_ago_in_words(@job.created_at) + " ago"
+    end
+
+    def retry_badge
+      count = execution_count
+      return nil if count <= 1
+
+      "(x#{count})"
+    end
+
+    def can_retry?
+      status == "failed"
+    end
+
+    def can_discard?
+      %w[pending scheduled failed blocked].include?(status)
+    end
+
+    def to_param
+      id.to_s
+    end
+
+    # ActiveModel compatibility
+    def model_name
+      ActiveModel::Name.new(self.class, nil, "Job")
+    end
+
+    def persisted?
+      true
+    end
+
+    private
+
+    def determine_status
+      return "failed" if has_failed_execution?
+      return "in_progress" if has_claimed_execution?
+      return "blocked" if has_blocked_execution?
+      return "scheduled" if has_scheduled_execution?
+      return "pending" if has_ready_execution?
+      return "finished" if @job.finished_at.present?
+
+      "unknown"
+    end
+
+    def has_failed_execution?
+      @failed_execution.present? || SolidQueue::FailedExecution.exists?(job_id: @job.id)
+    end
+
+    def has_claimed_execution?
+      @claimed_execution.present? || SolidQueue::ClaimedExecution.exists?(job_id: @job.id)
+    end
+
+    def has_blocked_execution?
+      SolidQueue::BlockedExecution.exists?(job_id: @job.id)
+    end
+
+    def has_scheduled_execution?
+      SolidQueue::ScheduledExecution.exists?(job_id: @job.id)
+    end
+
+    def has_ready_execution?
+      SolidQueue::ReadyExecution.exists?(job_id: @job.id)
+    end
+
+    class << self
+      def find(id)
+        job = SolidQueue::Job.find(id)
+        failed = SolidQueue::FailedExecution.find_by(job_id: id)
+        claimed = SolidQueue::ClaimedExecution.find_by(job_id: id)
+        new(job, failed_execution: failed, claimed_execution: claimed)
+      end
+
+      def all_with_status(status = nil, page: 1, per_page: 25, class_name: nil, queue_name: nil)
+        jobs = case status&.to_s
+        when "pending"
+          pending_jobs
+        when "scheduled"
+          scheduled_jobs
+        when "in_progress"
+          in_progress_jobs
+        when "failed"
+          failed_jobs
+        when "blocked"
+          blocked_jobs
+        when "finished"
+          finished_jobs
+        else
+          all_jobs
+        end
+
+        jobs = apply_filters(jobs, class_name: class_name, queue_name: queue_name)
+        jobs = jobs.order(created_at: :desc)
+        paginate(jobs, page: page, per_page: per_page)
+      end
+
+      def apply_filters(scope, class_name: nil, queue_name: nil)
+        scope = scope.where(class_name: class_name) if class_name.present?
+        scope = scope.where(queue_name: queue_name) if queue_name.present?
+        scope
+      end
+
+      def search(query, page: 1, per_page: 25)
+        jobs = SolidQueue::Job
+          .where("class_name LIKE ? OR arguments LIKE ? OR CAST(id AS TEXT) LIKE ?",
+                 "%#{query}%", "%#{query}%", "%#{query}%")
+          .order(created_at: :desc)
+
+        paginate(jobs, page: page, per_page: per_page)
+      end
+
+      private
+
+      def pending_jobs
+        SolidQueue::Job.joins(
+          "INNER JOIN solid_queue_ready_executions ON solid_queue_ready_executions.job_id = solid_queue_jobs.id"
+        )
+      end
+
+      def scheduled_jobs
+        SolidQueue::Job.joins(
+          "INNER JOIN solid_queue_scheduled_executions ON solid_queue_scheduled_executions.job_id = solid_queue_jobs.id"
+        )
+      end
+
+      def in_progress_jobs
+        SolidQueue::Job.joins(
+          "INNER JOIN solid_queue_claimed_executions ON solid_queue_claimed_executions.job_id = solid_queue_jobs.id"
+        )
+      end
+
+      def failed_jobs
+        SolidQueue::Job.joins(
+          "INNER JOIN solid_queue_failed_executions ON solid_queue_failed_executions.job_id = solid_queue_jobs.id"
+        )
+      end
+
+      def blocked_jobs
+        SolidQueue::Job.joins(
+          "INNER JOIN solid_queue_blocked_executions ON solid_queue_blocked_executions.job_id = solid_queue_jobs.id"
+        )
+      end
+
+      def finished_jobs
+        SolidQueue::Job.where.not(finished_at: nil)
+      end
+
+      def all_jobs
+        SolidQueue::Job.all
+      end
+
+      def paginate(scope, page:, per_page:)
+        page = [ page.to_i, 1 ].max
+        offset = (page - 1) * per_page
+        total = scope.count
+
+        jobs = scope.limit(per_page).offset(offset).map { |job| new(job) }
+        pagy = OpenStruct.new(
+          page: page,
+          pages: (total.to_f / per_page).ceil,
+          count: total,
+          prev: page > 1 ? page - 1 : nil,
+          next: page < (total.to_f / per_page).ceil ? page + 1 : nil
+        )
+
+        [ pagy, jobs ]
+      end
+    end
+  end
+end

data/app/models/job_harbor/queue_stats.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module JobHarbor
+  class QueueStats
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+    end
+
+    def pending_count
+      SolidQueue::ReadyExecution.where(queue_name: @name).count
+    end
+
+    def scheduled_count
+      SolidQueue::ScheduledExecution
+        .joins(:job)
+        .where(solid_queue_jobs: { queue_name: @name })
+        .count
+    end
+
+    def in_progress_count
+      SolidQueue::ClaimedExecution
+        .joins(:job)
+        .where(solid_queue_jobs: { queue_name: @name })
+        .count
+    end
+
+    def failed_count
+      SolidQueue::FailedExecution
+        .joins(:job)
+        .where(solid_queue_jobs: { queue_name: @name })
+        .count
+    end
+
+    def total_count
+      pending_count + scheduled_count + in_progress_count + failed_count
+    end
+
+    def paused?
+      SolidQueue::Pause.exists?(queue_name: @name)
+    end
+
+    def pause!
+      SolidQueue::Pause.create!(queue_name: @name) unless paused?
+    end
+
+    def resume!
+      SolidQueue::Pause.where(queue_name: @name).delete_all
+    end
+
+    def to_param
+      @name
+    end
+
+    class << self
+      def all
+        queue_names.map { |name| new(name) }
+      end
+
+      def find(name)
+        new(name) if queue_names.include?(name)
+      end
+
+      private
+
+      def queue_names
+        # Get all unique queue names from jobs and ready executions
+        job_queues = SolidQueue::Job.distinct.pluck(:queue_name)
+        ready_queues = SolidQueue::ReadyExecution.distinct.pluck(:queue_name)
+        paused_queues = SolidQueue::Pause.distinct.pluck(:queue_name)
+
+        (job_queues + ready_queues + paused_queues).uniq.compact.sort
+      end
+    end
+  end
+end

data/app/views/job_harbor/dashboard/index.html.erb

@@ -0,0 +1,112 @@
+<div class="sqd-stats-grid">
+  <%= render JobHarbor::StatCardComponent.new(
+    label: "Pending",
+    value: @stats.pending_count,
+    type: :pending,
+    link: pending_jobs_path
+  ) %>
+
+  <%= render JobHarbor::StatCardComponent.new(
+    label: "Scheduled",
+    value: @stats.scheduled_count,
+    type: :scheduled,
+    link: scheduled_jobs_path
+  ) %>
+
+  <%= render JobHarbor::StatCardComponent.new(
+    label: "In Progress",
+    value: @stats.in_progress_count,
+    type: :in_progress,
+    link: in_progress_jobs_path
+  ) %>
+
+  <%= render JobHarbor::StatCardComponent.new(
+    label: "Failed",
+    value: @stats.failed_count,
+    type: :failed,
+    link: failed_jobs_path
+  ) %>
+
+  <%= render JobHarbor::StatCardComponent.new(
+    label: "Blocked",
+    value: @stats.blocked_count,
+    type: :blocked,
+    link: blocked_jobs_path
+  ) %>
+
+  <%= render JobHarbor::StatCardComponent.new(
+    label: "Finished (24h)",
+    value: @stats.finished_count,
+    type: :finished,
+    link: finished_jobs_path
+  ) %>
+
+  <%= render JobHarbor::StatCardComponent.new(
+    label: "Active Workers",
+    value: @stats.workers_count,
+    type: :workers,
+    link: workers_path
+  ) %>
+
+  <%= render JobHarbor::StatCardComponent.new(
+    label: "Queues",
+    value: @stats.queues_count,
+    type: :queues,
+    link: queues_path
+  ) %>
+
+  <%= render JobHarbor::StatCardComponent.new(
+    label: "Throughput",
+    value: "#{@stats.throughput_per_hour}/hr",
+    type: :throughput
+  ) %>
+</div>
+
+<% if @chart_data.present? %>
+  <div style="margin-top: 2rem;">
+    <%= render JobHarbor::ChartComponent.new(series: @chart_data, current_range: @chart_range) %>
+  </div>
+<% end %>
+
+<% if @failure_stats.present? && @failure_stats.any? %>
+  <div style="margin-top: 2rem;">
+    <%= render JobHarbor::FailureRatesComponent.new(stats: @failure_stats) %>
+  </div>
+<% end %>
+
+<% if @stats.recent_failures.any? %>
+  <div class="sqd-card" style="margin-top: 2rem;">
+    <div class="sqd-card-header">
+      <h2 class="sqd-card-title">Recent Failures</h2>
+    </div>
+    <div class="sqd-table-container">
+      <table class="sqd-table">
+        <thead>
+          <tr>
+            <th>ID</th>
+            <th>Job Class</th>
+            <th>Error</th>
+            <th>Failed At</th>
+            <th>Actions</th>
+          </tr>
+        </thead>
+        <tbody>
+          <% @stats.recent_failures.each do |job| %>
+            <tr>
+              <td><%= link_to job.id, job_path(job), class: "sqd-table-link" %></td>
+              <td><code class="sqd-code"><%= job.class_name %></code></td>
+              <td><%= truncate(job.error_message || "Unknown error", length: 60) %></td>
+              <td><%= job.failed_at&.strftime("%b %d, %H:%M:%S") || "—" %></td>
+              <td class="sqd-actions">
+                <%= button_to "Retry", retry_job_path(job), method: :post, class: "sqd-btn sqd-btn-sm sqd-btn-secondary" %>
+              </td>
+            </tr>
+          <% end %>
+        </tbody>
+      </table>
+    </div>
+    <div style="padding: 1rem; text-align: center;">
+      <%= link_to "View All Failed Jobs →", failed_jobs_path, class: "sqd-table-link" %>
+    </div>
+  </div>
+<% end %>