job_harbor 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d596fee450350a33db1b229b2dcbab4cacde1cabfbb5bc6232c74438749678cf
+  data.tar.gz: 1ab3b9efa3d6e642b9a5f25fc26a1dfe16b689365858482c3799064162521d4d
+SHA512:
+  metadata.gz: 6aa86a5daea7137cadd0f68eb6c099beb4ba8aff739bf8a2cd88e839707a4c08d807a61cc386d809657f23574088213319d0f47a871beeef710d2dab5978ad1b
+  data.tar.gz: a4665fc176ee6afe8d794d195f9e3799cdecd56129383c6a616d4c572b5a27380542ca2186d89bf4f065ea7d62e9c573272a58a2a93cafbb0f5aafcd96ef8603

data/README.md

@@ -0,0 +1,98 @@
+# SolidQueue Dashboard
+
+A modern, self-contained dashboard for monitoring and managing [Solid Queue](https://github.com/rails/solid_queue) jobs. Built with ViewComponents and vanilla CSS for easy integration with any Rails application.
+
+## Features
+
+- **Dashboard Overview**: Real-time statistics for pending, scheduled, in-progress, failed, blocked, and finished jobs
+- **Job Management**: View, search, retry, and discard jobs with full argument and error inspection
+- **Queue Management**: Monitor queue health, pause/resume queues
+- **Worker Monitoring**: Track active workers with heartbeat status detection
+- **Recurring Tasks**: View and manually trigger recurring jobs
+- **Real-time Updates**: Auto-refresh with configurable polling interval
+- **Dark/Light Themes**: CSS variable-based theming with no external dependencies
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "solidqueue_dashboard"
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+## Configuration
+
+Create an initializer at `config/initializers/solidqueue_dashboard.rb`:
+
+```ruby
+SolidqueueDashboard.configure do |config|
+  # Authorization callback - must return true to allow access
+  config.authorize_with = -> { current_user&.admin? }
+
+  # Theme: :dark or :light
+  config.theme = :dark
+
+  # Primary accent color
+  config.primary_color = "amber"
+
+  # Jobs per page
+  config.jobs_per_page = 25
+
+  # Enable recurring tasks management
+  config.enable_recurring_tasks = true
+
+  # Enable auto-refresh
+  config.enable_real_time_updates = true
+
+  # Poll interval in seconds
+  config.poll_interval = 5
+end
+```
+
+## Mounting
+
+Mount the engine in your routes:
+
+```ruby
+# config/routes.rb
+Rails.application.routes.draw do
+  # Basic mount
+  mount SolidqueueDashboard::Engine, at: "/jobs"
+
+  # Or with authentication constraint
+  authenticated :user, ->(u) { u.admin? } do
+    mount SolidqueueDashboard::Engine, at: "/admin/jobs"
+  end
+end
+```
+
+## Authorization
+
+The dashboard uses a configurable authorization callback. Return `true` to allow access:
+
+```ruby
+# Allow all authenticated users
+config.authorize_with = -> { current_user.present? }
+
+# Require admin role
+config.authorize_with = -> { current_user&.admin? }
+
+# Use Pundit or similar
+config.authorize_with = -> { authorize(:solid_queue, :manage?) }
+```
+
+## Dependencies
+
+- Rails >= 7.1
+- Solid Queue >= 0.3
+- ViewComponent >= 3.0
+
+## License
+
+MIT License. See [LICENSE](LICENSE) for details.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+require "bundler/gem_tasks"

data/app/assets/stylesheets/solidqueue_dashboard/application.css

@@ -0,0 +1 @@
+/* Solid Queue Dashboard styles are inlined in the layout for self-containment */

data/app/components/job_harbor/application_component.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module JobHarbor
+  class ApplicationComponent < ViewComponent::Base
+    include JobHarbor::Engine.routes.url_helpers
+
+    private
+
+    def sq_config
+      JobHarbor.configuration
+    end
+  end
+end

data/app/components/job_harbor/badge_component.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module JobHarbor
+  class BadgeComponent < ApplicationComponent
+    VALID_STATUSES = %w[pending scheduled in_progress failed finished blocked active paused].freeze
+
+    def initialize(status:)
+      @status = status.to_s.downcase
+    end
+
+    def call
+      content_tag(:span, display_text, class: css_classes)
+    end
+
+    private
+
+    def css_classes
+      status_class = VALID_STATUSES.include?(@status) ? @status : "pending"
+      "sqd-badge sqd-badge-#{status_class}"
+    end
+
+    def display_text
+      @status.titleize.gsub("_", " ")
+    end
+  end
+end

data/app/components/job_harbor/chart_component.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module JobHarbor
+  class ChartComponent < ApplicationComponent
+    def initialize(series:, current_range:)
+      @series = series
+      @current_range = current_range
+    end
+
+    def call
+      content_tag(:div, class: "sqd-card sqd-chart-card") do
+        safe_join([
+          header,
+          body
+        ])
+      end
+    end
+
+    private
+
+    def header
+      content_tag(:div, class: "sqd-card-header sqd-chart-header") do
+        safe_join([
+          content_tag(:h3, "Job Activity", class: "sqd-card-title"),
+          range_selector
+        ])
+      end
+    end
+
+    def range_selector
+      content_tag(:div, class: "sqd-chart-ranges") do
+        safe_join(ChartData.available_ranges.map { |range| range_button(range) })
+      end
+    end
+
+    def range_button(range)
+      active = range[:value] == @current_range
+      css_class = "sqd-chart-range-btn#{' active' if active}"
+
+      link_to range[:label],
+        "#{root_path}?chart_range=#{range[:value]}",
+        class: css_class
+    end
+
+    def body
+      content_tag(:div, class: "sqd-card-body") do
+        safe_join([
+          legend,
+          chart_container
+        ])
+      end
+    end
+
+    def legend
+      content_tag(:div, class: "sqd-chart-legend") do
+        safe_join([
+          legend_item("Completed", "sqd-chart-completed"),
+          legend_item("Failed", "sqd-chart-failed"),
+          legend_item("Enqueued", "sqd-chart-enqueued")
+        ])
+      end
+    end
+
+    def legend_item(label, css_class)
+      content_tag(:div, class: "sqd-legend-item") do
+        safe_join([
+          content_tag(:span, "", class: "sqd-legend-color #{css_class}"),
+          content_tag(:span, label, class: "sqd-legend-label")
+        ])
+      end
+    end
+
+    def chart_container
+      content_tag(:div,
+        class: "sqd-chart",
+        data: { chart_data: @series.to_json }
+      ) do
+        content_tag(:canvas, "", id: "sqd-job-chart", width: "100%", height: "200")
+      end
+    end
+  end
+end

data/app/components/job_harbor/empty_state_component.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module JobHarbor
+  class EmptyStateComponent < ApplicationComponent
+    ICONS = {
+      jobs: '<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 11H5m14 0a2 2 0 012 2v6a2 2 0 01-2 2H5a2 2 0 01-2-2v-6a2 2 0 012-2m14 0V9a2 2 0 00-2-2M5 11V9a2 2 0 012-2m0 0V5a2 2 0 012-2h6a2 2 0 012 2v2M7 7h10"/>',
+      queues: '<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M4 6h16M4 10h16M4 14h16M4 18h16"/>',
+      workers: '<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 3v2m6-2v2M9 19v2m6-2v2M5 9H3m2 6H3m18-6h-2m2 6h-2M7 19h10a2 2 0 002-2V7a2 2 0 00-2-2H7a2 2 0 00-2 2v10a2 2 0 002 2zM9 9h6v6H9V9z"/>',
+      search: '<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M21 21l-6-6m2-5a7 7 0 11-14 0 7 7 0 0114 0z"/>'
+    }.freeze
+
+    def initialize(title:, description: nil, icon: :jobs)
+      @title = title
+      @description = description
+      @icon = icon.to_sym
+    end
+
+    def call
+      content_tag(:div, class: "sqd-empty-state") do
+        safe_join([
+          icon_svg,
+          content_tag(:h3, @title, class: "sqd-empty-title"),
+          description_tag
+        ].compact)
+      end
+    end
+
+    private
+
+    def icon_svg
+      icon_path = ICONS[@icon] || ICONS[:jobs]
+      content_tag(:svg, icon_path.html_safe, class: "sqd-empty-icon", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor")
+    end
+
+    def description_tag
+      return unless @description
+
+      content_tag(:p, @description, class: "sqd-empty-description")
+    end
+  end
+end

data/app/components/job_harbor/failure_rates_component.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module JobHarbor
+  class FailureRatesComponent < ApplicationComponent
+    def initialize(stats:)
+      @stats = stats
+    end
+
+    def call
+      content_tag(:div, class: "sqd-card sqd-failure-rates") do
+        safe_join([
+          header,
+          body
+        ])
+      end
+    end
+
+    private
+
+    def header
+      content_tag(:div, class: "sqd-card-header") do
+        content_tag(:h3, "Failure Rates (24h)", class: "sqd-card-title")
+      end
+    end
+
+    def body
+      content_tag(:div, class: "sqd-card-body") do
+        if @stats.empty?
+          empty_state
+        else
+          stats_table
+        end
+      end
+    end
+
+    def empty_state
+      content_tag(:p, "No jobs in the last 24 hours", class: "sqd-text-muted")
+    end
+
+    def stats_table
+      content_tag(:table, class: "sqd-table sqd-failure-table") do
+        safe_join([
+          table_header,
+          table_body
+        ])
+      end
+    end
+
+    def table_header
+      content_tag(:thead) do
+        content_tag(:tr) do
+          safe_join([
+            content_tag(:th, "Job Class"),
+            content_tag(:th, "Total"),
+            content_tag(:th, "Failed"),
+            content_tag(:th, "Rate")
+          ])
+        end
+      end
+    end
+
+    def table_body
+      content_tag(:tbody) do
+        safe_join(@stats.first(10).map { |stat| stat_row(stat) })
+      end
+    end
+
+    def stat_row(stat)
+      content_tag(:tr) do
+        safe_join([
+          content_tag(:td, content_tag(:code, stat[:class_name], class: "sqd-code")),
+          content_tag(:td, stat[:total]),
+          content_tag(:td, stat[:failed]),
+          content_tag(:td, rate_badge(stat[:rate]))
+        ])
+      end
+    end
+
+    def rate_badge(rate)
+      css_class = FailureStats.rate_badge_class(rate)
+      content_tag(:span, "#{rate}%", class: "sqd-rate-badge #{css_class}")
+    end
+  end
+end

data/app/components/job_harbor/job_filters_component.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module JobHarbor
+  class JobFiltersComponent < ApplicationComponent
+    def initialize(class_names:, queue_names:, current_class:, current_queue:, current_path:, params: {})
+      @class_names = class_names
+      @queue_names = queue_names
+      @current_class = current_class
+      @current_queue = current_queue
+      @current_path = current_path
+      @params = params.to_h.symbolize_keys.except(:class_name, :queue_name, :page, :controller, :action)
+    end
+
+    def call
+      content_tag(:div, class: "sqd-filters") do
+        safe_join([
+          class_filter,
+          queue_filter
+        ])
+      end
+    end
+
+    private
+
+    def class_filter
+      content_tag(:div, class: "sqd-filter-group") do
+        safe_join([
+          content_tag(:label, "Class", class: "sqd-filter-label", for: "class_filter"),
+          content_tag(:select,
+            class: "sqd-filter-select",
+            id: "class_filter",
+            data: { filter_type: "class_name" }
+          ) do
+            safe_join([
+              class_option_tag("All Classes", "", @current_class.blank?),
+              *@class_names.map { |name| class_option_tag(name, name, name == @current_class) }
+            ])
+          end
+        ])
+      end
+    end
+
+    def queue_filter
+      content_tag(:div, class: "sqd-filter-group") do
+        safe_join([
+          content_tag(:label, "Queue", class: "sqd-filter-label", for: "queue_filter"),
+          content_tag(:select,
+            class: "sqd-filter-select",
+            id: "queue_filter",
+            data: { filter_type: "queue_name" }
+          ) do
+            safe_join([
+              queue_option_tag("All Queues", "", @current_queue.blank?),
+              *@queue_names.map { |name| queue_option_tag(name, name, name == @current_queue) }
+            ])
+          end
+        ])
+      end
+    end
+
+    def class_option_tag(label, value, selected)
+      url = build_filter_url(:class_name, value)
+      content_tag(:option, label, value: url, selected: selected)
+    end
+
+    def queue_option_tag(label, value, selected)
+      url = build_filter_url(:queue_name, value)
+      content_tag(:option, label, value: url, selected: selected)
+    end
+
+    def build_filter_url(filter_key, value)
+      query_params = @params.dup
+
+      # Preserve the other filter if set
+      query_params[:class_name] = @current_class if @current_class.present? && filter_key != :class_name
+      query_params[:queue_name] = @current_queue if @current_queue.present? && filter_key != :queue_name
+
+      # Set the new filter value
+      if value.present?
+        query_params[filter_key] = value
+      else
+        query_params.delete(filter_key)
+      end
+
+      if query_params.empty?
+        @current_path
+      else
+        "#{@current_path}?#{query_params.to_query}"
+      end
+    end
+  end
+end

data/app/components/job_harbor/job_row_component.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module JobHarbor
+  class JobRowComponent < ApplicationComponent
+    def initialize(job:)
+      @job = job
+    end
+
+    def call
+      content_tag(:tr) do
+        safe_join([
+          id_cell,
+          class_cell,
+          queue_cell,
+          status_cell,
+          scheduled_cell,
+          actions_cell
+        ])
+      end
+    end
+
+    private
+
+    def id_cell
+      content_tag(:td) do
+        link_to @job.id, job_path(@job), class: "sqd-table-link"
+      end
+    end
+
+    def class_cell
+      content_tag(:td) do
+        safe_join([
+          content_tag(:code, @job.class_name, class: "sqd-code"),
+          retry_badge_tag
+        ].compact)
+      end
+    end
+
+    def retry_badge_tag
+      return nil unless @job.respond_to?(:retry_badge) && @job.retry_badge.present?
+
+      content_tag(:span, @job.retry_badge, class: "sqd-retry-badge")
+    end
+
+    def queue_cell
+      content_tag(:td) do
+        link_to @job.queue_name, queue_path(@job.queue_name), class: "sqd-table-link"
+      end
+    end
+
+    def status_cell
+      content_tag(:td) do
+        safe_join([
+          render(BadgeComponent.new(status: @job.status)),
+          running_duration_tag
+        ].compact)
+      end
+    end
+
+    def running_duration_tag
+      return nil unless @job.respond_to?(:running_duration) && @job.running_duration.present?
+
+      content_tag(:span, " (#{@job.running_duration})", class: "sqd-running-duration")
+    end
+
+    def scheduled_cell
+      content_tag(:td) do
+        if @job.scheduled_at
+          time_tag(@job.scheduled_at, @job.scheduled_at.strftime("%b %d, %H:%M:%S"))
+        else
+          relative_time_tag
+        end
+      end
+    end
+
+    def relative_time_tag
+      if @job.respond_to?(:relative_created_at)
+        content_tag(:span, @job.relative_created_at, class: "sqd-text-muted sqd-relative-time")
+      else
+        content_tag(:span, "—", class: "sqd-text-muted")
+      end
+    end
+
+    def actions_cell
+      content_tag(:td, class: "sqd-actions") do
+        safe_join([
+          retry_button,
+          discard_button
+        ].compact)
+      end
+    end
+
+    def retry_button
+      return unless @job.can_retry?
+
+      button_to "Retry", retry_job_path(@job), method: :post, class: "sqd-btn sqd-btn-sm sqd-btn-secondary"
+    end
+
+    def discard_button
+      return unless @job.can_discard?
+
+      button_to "Discard", discard_job_path(@job), method: :delete, class: "sqd-btn sqd-btn-sm sqd-btn-danger",
+        data: { confirm: "Are you sure you want to discard this job?" }
+    end
+  end
+end

data/app/components/job_harbor/nav_link_component.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module JobHarbor
+  class NavLinkComponent < ApplicationComponent
+    ICONS = {
+      dashboard: '<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M3 12l2-2m0 0l7-7 7 7M5 10v10a1 1 0 001 1h3m10-11l2 2m-2-2v10a1 1 0 01-1 1h-3m-6 0a1 1 0 001-1v-4a1 1 0 011-1h2a1 1 0 011 1v4a1 1 0 001 1m-6 0h6"/>',
+      jobs: '<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 11H5m14 0a2 2 0 012 2v6a2 2 0 01-2 2H5a2 2 0 01-2-2v-6a2 2 0 012-2m14 0V9a2 2 0 00-2-2M5 11V9a2 2 0 012-2m0 0V5a2 2 0 012-2h6a2 2 0 012 2v2M7 7h10"/>',
+      queues: '<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M4 6h16M4 10h16M4 14h16M4 18h16"/>',
+      workers: '<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 3v2m6-2v2M9 19v2m6-2v2M5 9H3m2 6H3m18-6h-2m2 6h-2M7 19h10a2 2 0 002-2V7a2 2 0 00-2-2H7a2 2 0 00-2 2v10a2 2 0 002 2zM9 9h6v6H9V9z"/>',
+      recurring: '<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 8v4l3 3m6-3a9 9 0 11-18 0 9 9 0 0118 0z"/>'
+    }.freeze
+
+    def initialize(path:, label:, icon:, active: false, badge: nil)
+      @path = path
+      @label = label
+      @icon = icon.to_sym
+      @active = active
+      @badge = badge
+    end
+
+    def call
+      link_to @path, class: css_classes do
+        safe_join([
+          icon_svg,
+          content_tag(:span, @label, class: "sqd-nav-label"),
+          badge_tag
+        ].compact)
+      end
+    end
+
+    private
+
+    def css_classes
+      classes = [ "sqd-nav-link" ]
+      classes << "active" if @active
+      classes.join(" ")
+    end
+
+    def icon_svg
+      icon_path = ICONS[@icon] || ICONS[:dashboard]
+      content_tag(:svg, icon_path.html_safe, class: "sqd-nav-icon", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor")
+    end
+
+    def badge_tag
+      return nil unless @badge.present? && @badge.to_i > 0
+
+      content_tag(:span, @badge, class: "sqd-nav-badge")
+    end
+  end
+end

data/app/components/job_harbor/pagination_component.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module JobHarbor
+  class PaginationComponent < ApplicationComponent
+    def initialize(pagy:)
+      @pagy = pagy
+    end
+
+    def render?
+      @pagy.pages > 1
+    end
+
+    def call
+      content_tag(:nav, class: "sqd-pagination") do
+        safe_join([
+          prev_link,
+          page_links,
+          next_link
+        ])
+      end
+    end
+
+    private
+
+    def prev_link
+      if @pagy.prev
+        link_to "← Prev", url_for(page: @pagy.prev), class: "sqd-pagination-link"
+      else
+        content_tag(:span, "← Prev", class: "sqd-pagination-link sqd-pagination-disabled")
+      end
+    end
+
+    def next_link
+      if @pagy.next
+        link_to "Next →", url_for(page: @pagy.next), class: "sqd-pagination-link"
+      else
+        content_tag(:span, "Next →", class: "sqd-pagination-link sqd-pagination-disabled")
+      end
+    end
+
+    def page_links
+      series.map do |item|
+        case item
+        when Integer
+          if item == @pagy.page
+            content_tag(:span, item, class: "sqd-pagination-current")
+          else
+            link_to item, url_for(page: item), class: "sqd-pagination-link"
+          end
+        when :gap
+          content_tag(:span, "…", class: "sqd-pagination-link sqd-pagination-disabled")
+        end
+      end
+    end
+
+    def series
+      # Generate page series with ellipsis for large page counts
+      pages = @pagy.pages
+      current = @pagy.page
+
+      if pages <= 7
+        (1..pages).to_a
+      elsif current <= 4
+        [ 1, 2, 3, 4, 5, :gap, pages ]
+      elsif current >= pages - 3
+        [ 1, :gap, pages - 4, pages - 3, pages - 2, pages - 1, pages ]
+      else
+        [ 1, :gap, current - 1, current, current + 1, :gap, pages ]
+      end
+    end
+  end
+end