job_board 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bea67d509d907e2592ab52afa1b5416ddec7493cbdab455d67b9f9ac4aa3e66e
-  data.tar.gz: 38f1c58ef928b9d40253aa5f9e37f1b5bd4073899cd3a641a1d467455f8c541c
+  metadata.gz: 18b3b4aa806ccbda04e2bd2100e4561eefec8b1ec665975b3d34d22d9ababadf
+  data.tar.gz: 31ba104259fe986f5c2eceee2f335d153246d7d21f6c9baf22764420091fbfa2
 SHA512:
-  metadata.gz: 688e4fd719017cad90493adcfcbe9e8629c06d939a7f58d28cc9a32b119ec4a01ba90942604dbfb9fb218f6bb931dfc44ee760f0b0d6448f664a9d7eb27f2663
-  data.tar.gz: 0436d97db91c3ac1071145936ea3c41f4396fca772407324c8349369af7343da0cb4783552f9bca4d8b2786c7ce1e22a1cc9256364c05836c8a850a9e1debb0f
+  metadata.gz: 746ddd882343564e9cec4dfe8a621b84e8410dc5aaac35adbce9a6adc8223fdddbf3a392ed6a9486fa5208268829a6daa470304dea9a27ec06aec300d2d9f8a3
+  data.tar.gz: 13bae2092fa89294028c00c03bbd528fbab80c2cef3156bfb1d6a09177dc1629b5898b58db93df75091508bef54e0d1adecd7a64e2b83b3aa7861bdbcbea35ef

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.5.0
+
+- Queues (home) page: new **Running** column showing how many jobs are currently
+  claimed by a worker and in progress for each queue. Positive counts link to that
+  queue's in-progress jobs; the count refreshes live with the page's auto-refresh.
+
+  ![Queues table with a Running column](doc/running-count-0.5.0.png)
+
+## 0.4.0
+
+- Queues (home) page: a real-time **Throughput** line chart at the top, plotting jobs
+  that became ready to run against jobs that finished, one point per poll interval.
+  It tracks only what happens after the page loads (no history), keeps a rolling
+  10-minute window scrolling right-to-left, and is fed by a small JSON `metrics`
+  endpoint so the SVG state survives the auto-refresh swap.
+
+  ![Throughput chart with enqueued and completed lines](doc/throughput-0.4.0.png)
+
 ## 0.3.0
 
 - Recurring tasks page: **Run now** button to trigger a task outside its schedule

data/app/controllers/job_board/application_controller.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JobBoard
   class ApplicationController < ActionController::Base
     protect_from_forgery with: :exception
@@ -7,18 +9,19 @@ module JobBoard
     layout "job_board/application"
 
     private
-      def authenticate
-        credentials = JobBoard.config.http_basic_auth
-        return unless credentials
 
-        authenticate_or_request_with_http_basic("JobBoard") do |name, password|
-          ActiveSupport::SecurityUtils.secure_compare(name, credentials[:name].to_s) &
-            ActiveSupport::SecurityUtils.secure_compare(password, credentials[:password].to_s)
-        end
-      end
+    def authenticate
+      credentials = JobBoard.config.http_basic_auth
+      return unless credentials
 
-      def stale_threshold
-        JobBoard.config.stale_process_threshold || SolidQueue.process_alive_threshold
+      authenticate_or_request_with_http_basic("JobBoard") do |name, password|
+        ActiveSupport::SecurityUtils.secure_compare(name, credentials[:name].to_s) &
+          ActiveSupport::SecurityUtils.secure_compare(password, credentials[:password].to_s)
       end
+    end
+
+    def stale_threshold
+      JobBoard.config.stale_process_threshold || SolidQueue.process_alive_threshold
+    end
   end
 end

data/app/controllers/job_board/assets_controller.rb

@@ -1,10 +1,14 @@
+# frozen_string_literal: true
+
 module JobBoard
   class AssetsController < ApplicationController
     skip_forgery_protection
 
     ASSETS = {
       "application.css" => "text/css",
-      "application.js" => "text/javascript"
+      "throughput_chart.css" => "text/css",
+      "application.js" => "text/javascript",
+      "throughput_chart.js" => "text/javascript"
     }.freeze
 
     def show
@@ -13,7 +17,7 @@ module JobBoard
 
       expires_in 1.year, public: true
       send_file JobBoard::Engine.root.join("lib/job_board/assets", name),
-        type: content_type, disposition: :inline
+                type: content_type, disposition: :inline
     end
   end
 end

data/app/controllers/job_board/jobs_controller.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module JobBoard
   class JobsController < ApplicationController
-    before_action :set_query, only: [:index, :retry_all, :discard_all]
+    before_action :set_query, only: %i[index retry_all discard_all]
 
     def index
       @page = @query.page(before: params[:before], limit: JobBoard.config.per_page)
@@ -53,36 +55,37 @@ module JobBoard
     end
 
     private
-      def set_query
-        status = params[:status].presence || "ready"
-        head :not_found and return unless JobsQuery::STATUSES.include?(status)
 
-        @query = JobsQuery.new(
-          status: status,
-          queue_name: params[:queue_name].presence,
-          class_name: params[:class_name].presence
-        )
-      end
+    def set_query
+      status = params[:status].presence || "ready"
+      head :not_found and return unless JobsQuery::STATUSES.include?(status)
 
-      def find_job
-        SolidQueue::Job
-          .includes(:ready_execution, :scheduled_execution, :claimed_execution,
-                    :blocked_execution, :failed_execution)
-          .find(params[:id])
-      end
+      @query = JobsQuery.new(
+        status: status,
+        queue_name: params[:queue_name].presence,
+        class_name: params[:class_name].presence
+      )
+    end
 
-      def failed_jobs_in_batches(&block)
-        query = JobsQuery.new(
-          status: "failed",
-          queue_name: params[:queue_name].presence,
-          class_name: params[:class_name].presence
-        )
-        query.failed_jobs_relation.find_in_batches(batch_size: 500, &block)
-      end
+    def find_job
+      SolidQueue::Job
+        .includes(:ready_execution, :scheduled_execution, :claimed_execution,
+                  :blocked_execution, :failed_execution)
+        .find(params[:id])
+    end
 
-      def failed_jobs_path
-        jobs_path(status: "failed", queue_name: params[:queue_name].presence,
-                  class_name: params[:class_name].presence)
-      end
+    def failed_jobs_in_batches(&)
+      query = JobsQuery.new(
+        status: "failed",
+        queue_name: params[:queue_name].presence,
+        class_name: params[:class_name].presence
+      )
+      query.failed_jobs_relation.find_in_batches(batch_size: 500, &)
+    end
+
+    def failed_jobs_path
+      jobs_path(status: "failed", queue_name: params[:queue_name].presence,
+                class_name: params[:class_name].presence)
+    end
   end
 end

data/app/controllers/job_board/metrics_controller.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module JobBoard
+  class MetricsController < ApplicationController
+    def show
+      render json: Throughput.snapshot(since: parse_time(params[:since]))
+    end
+
+    private
+
+    def parse_time(value)
+      Time.iso8601(value.to_s)
+    rescue ArgumentError
+      nil # blank or malformed cursor → treat as a fresh baseline
+    end
+  end
+end

data/app/controllers/job_board/processes_controller.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JobBoard
   class ProcessesController < ApplicationController
     def index

data/app/controllers/job_board/queues/pauses_controller.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JobBoard
   module Queues
     class PausesController < ApplicationController

data/app/controllers/job_board/queues_controller.rb

@@ -1,9 +1,13 @@
+# frozen_string_literal: true
+
 module JobBoard
   class QueuesController < ApplicationController
     def index
       @queue_list = QueueList.build
       @failed_counts = SolidQueue::FailedExecution.joins(:job)
-        .group("solid_queue_jobs.queue_name").count
+                                                  .group("solid_queue_jobs.queue_name").count
+      @running_counts = SolidQueue::ClaimedExecution.joins(:job)
+                                                    .group("solid_queue_jobs.queue_name").count
     end
   end
 end

data/app/controllers/job_board/recurring_tasks/runs_controller.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JobBoard
   module RecurringTasks
     class RunsController < ApplicationController
@@ -9,8 +11,9 @@ module JobBoard
         elsif task.enqueue(at: Time.current)
           redirect_to recurring_tasks_path, notice: "Enqueued \"#{task.key}\"."
         else
-          redirect_to recurring_tasks_path,
-            alert: "\"#{task.key}\" was not enqueued — it already ran at this exact time or the enqueue failed."
+          alert = "\"#{task.key}\" was not enqueued — it already ran at " \
+                  "this exact time or the enqueue failed."
+          redirect_to recurring_tasks_path, alert: alert
         end
       end
     end

data/app/controllers/job_board/recurring_tasks_controller.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JobBoard
   class RecurringTasksController < ApplicationController
     def index

data/app/helpers/job_board/application_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JobBoard
   module ApplicationHelper
     def status_badge(status)
@@ -9,14 +11,14 @@ module JobBoard
 
       time = Time.zone.parse(time) if time.is_a?(String)
       tag.time("#{duration((Time.current - time).abs)} #{time.future? ? "from now" : "ago"}",
-        title: time.iso8601, datetime: time.iso8601)
+               title: time.iso8601, datetime: time.iso8601)
     end
 
     def duration(seconds)
       seconds = seconds.to_i
       return "0s" if seconds <= 0
 
-      parts = { "d" => 86400, "h" => 3600, "m" => 60, "s" => 1 }.filter_map do |unit, size|
+      parts = { "d" => 86_400, "h" => 3600, "m" => 60, "s" => 1 }.filter_map do |unit, size|
         value, seconds = seconds.divmod(size)
         "#{value}#{unit}" if value.positive?
       end

data/app/models/job_board/cron_description.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "fugit"
 
 module JobBoard
@@ -44,6 +46,7 @@ module JobBoard
       if (step = seconds_step)
         # Sub-minute schedules only describe cleanly when nothing else is constrained.
         return nil unless cron.minutes.nil? && cron.hours.nil?
+
         "Every #{step} seconds"
       elsif cron.seconds && cron.seconds != [0]
         nil
@@ -60,7 +63,7 @@ module JobBoard
       else
         times = cron.hours.product(cron.minutes || [0]).sort
         if times.size <= 4
-          "At #{join_and(times.map { |h, m| format("%02d:%02d", h, m) })}"
+          "At #{join_and(times.map { |h, m| format("%<h>02d:%<m>02d", h: h, m: m) })}"
         else
           "At #{numbers("minute", cron.minutes)} past #{numbers("hour", cron.hours)}"
         end
@@ -79,17 +82,19 @@ module JobBoard
       return nil if cron.weekdays.nil?
 
       plain = cron.weekdays.select { |_, nth| nth.nil? }.map { |day,| day % 7 }.sort.uniq
-      nth = cron.weekdays.reject { |_, nth| nth.nil? }.map do |day, n|
+      nth = cron.weekdays.filter_map do |day, n|
+        next if n.nil?
+
         "the #{n == -1 ? "last" : n.ordinalize} #{DAYS[day % 7]} of the month"
       end
 
       phrases = []
       if plain.any?
         phrases << if plain.size > 2 && consecutive?(plain)
-          "#{DAYS[plain.first]} through #{DAYS[plain.last]}"
-        else
-          join_and(plain.map { |day| DAYS[day] })
-        end
+                     "#{DAYS[plain.first]} through #{DAYS[plain.last]}"
+                   else
+                     join_and(plain.map { |day| DAYS[day] })
+                   end
       end
       "on #{join_and(phrases + nth)}"
     end
@@ -99,7 +104,7 @@ module JobBoard
 
       # "0 0 1 1 *" reads better as "on January 1" than "on day 1 of the month in January".
       if cron.monthdays.size == 1 && cron.monthdays.first.positive? &&
-          cron.months&.size == 1 && cron.weekdays.nil?
+         cron.months&.size == 1 && cron.weekdays.nil?
         @month_consumed = true
         return "on #{MONTHS[cron.months.first - 1]} #{cron.monthdays.first}"
       end

data/app/models/job_board/job_presenter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JobBoard
   # Detail-page wrapper around a SolidQueue::Job loaded with all five
   # has_one execution associations preloaded.

data/app/models/job_board/job_row.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JobBoard
   # Uniform row facade so the jobs table doesn't care whether a row came from
   # an execution record or a finished job.

data/app/models/job_board/jobs_query.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JobBoard
   # Status-scoped job finder. Each status is driven by its execution table so a
   # row's status is known without calling Job#status (which needs 5 preloads).
@@ -49,38 +51,42 @@ module JobBoard
     end
 
     private
-      def relation
-        case status
-        when "ready"
-          filtered(SolidQueue::ReadyExecution.includes(:job), own_queue_column: true)
-        when "scheduled"
-          filtered(SolidQueue::ScheduledExecution.includes(:job), own_queue_column: true)
-        when "in_progress"
-          filtered(SolidQueue::ClaimedExecution.includes(:process, :job), own_queue_column: false)
-        when "blocked"
-          filtered(SolidQueue::BlockedExecution.includes(:job), own_queue_column: true)
-        when "failed"
-          filtered(SolidQueue::FailedExecution.includes(:job), own_queue_column: false)
-        when "finished"
-          filtered_jobs(SolidQueue::Job.finished)
-        else
-          raise ArgumentError, "unknown status #{status.inspect}"
-        end
-      end
 
-      def filtered(scope, own_queue_column:)
-        if queue_name
-          scope = own_queue_column ? scope.where(queue_name: queue_name)
-                                   : scope.joins(:job).where(solid_queue_jobs: { queue_name: queue_name })
-        end
-        scope = scope.joins(:job).where(solid_queue_jobs: { class_name: class_name }) if class_name
-        scope
+    def relation
+      case status
+      when "ready"
+        filtered(SolidQueue::ReadyExecution.includes(:job), own_queue_column: true)
+      when "scheduled"
+        filtered(SolidQueue::ScheduledExecution.includes(:job), own_queue_column: true)
+      when "in_progress"
+        filtered(SolidQueue::ClaimedExecution.includes(:process, :job), own_queue_column: false)
+      when "blocked"
+        filtered(SolidQueue::BlockedExecution.includes(:job), own_queue_column: true)
+      when "failed"
+        filtered(SolidQueue::FailedExecution.includes(:job), own_queue_column: false)
+      when "finished"
+        filtered_jobs(SolidQueue::Job.finished)
+      else
+        raise ArgumentError, "unknown status #{status.inspect}"
       end
+    end
 
-      def filtered_jobs(scope)
-        scope = scope.where(queue_name: queue_name) if queue_name
-        scope = scope.where(class_name: class_name) if class_name
-        scope
+    def filtered(scope, own_queue_column:)
+      if queue_name
+        scope = if own_queue_column
+                  scope.where(queue_name: queue_name)
+                else
+                  scope.joins(:job).where(solid_queue_jobs: { queue_name: queue_name })
+                end
       end
+      scope = scope.joins(:job).where(solid_queue_jobs: { class_name: class_name }) if class_name
+      scope
+    end
+
+    def filtered_jobs(scope)
+      scope = scope.where(queue_name: queue_name) if queue_name
+      scope = scope.where(class_name: class_name) if class_name
+      scope
+    end
   end
 end

data/app/models/job_board/latency_sla.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module JobBoard
   # Detects a queue's latency SLA from explicit configuration or from the
   # within_* naming convention (e.g. "within_5_minutes" => 300).
   module LatencySla
-    UNITS = { "second" => 1, "minute" => 60, "hour" => 3600, "day" => 86400 }.freeze
+    UNITS = { "second" => 1, "minute" => 60, "hour" => 3600, "day" => 86_400 }.freeze
 
     # Seconds, or nil when the queue has no detectable SLA.
     def self.detect(queue_name)
@@ -24,7 +26,7 @@ module JobBoard
 
     def self.from_name(queue_name)
       match = /\Awithin_(\d+)_(second|minute|hour|day)s?\z/i.match(queue_name.to_s)
-      match && match[1].to_i * UNITS.fetch(match[2].downcase)
+      match && (match[1].to_i * UNITS.fetch(match[2].downcase))
     end
     private_class_method :from_name
   end

data/app/models/job_board/page.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JobBoard
   # Keyset pagination over a relation ordered by id DESC.
   # Fetches limit + 1 records to detect whether an older page exists.
@@ -24,8 +26,8 @@ module JobBoard
       records.last&.id
     end
 
-    def each(&block)
-      rows.each(&block)
+    def each(&)
+      rows.each(&)
     end
 
     def empty?

data/app/models/job_board/process_tree.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JobBoard
   # Supervisor -> supervisee tree of SolidQueue processes with staleness flags,
   # claimed-job counts, and the in-progress jobs each worker holds.
@@ -12,11 +14,11 @@ module JobBoard
 
     def initialize(stale_threshold:)
       processes = SolidQueue::Process.order(:id).to_a
-      ids = processes.map(&:id).to_set
+      ids = processes.to_set(&:id)
       counts = SolidQueue::ClaimedExecution.group(:process_id).count
       @claimed_by_process =
         SolidQueue::ClaimedExecution.where(process_id: processes.map(&:id))
-          .includes(:job).group_by(&:process_id)
+                                    .includes(:job).group_by(&:process_id)
 
       cutoff = stale_threshold.ago
       children = processes.group_by(&:supervisor_id)

data/app/models/job_board/queue_list.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JobBoard
   # Partitions queues into active and inactive based on when each queue last
   # had a job enqueued. A queue is inactive when its newest job is older than
@@ -9,8 +11,8 @@ module JobBoard
 
     def self.build(window: JobBoard.config.queue_activity_window)
       new(LatencySla.sort(SolidQueue::Queue.all),
-        last_enqueued_at: SolidQueue::Job.group(:queue_name).maximum(:created_at),
-        window: window)
+          last_enqueued_at: SolidQueue::Job.group(:queue_name).maximum(:created_at),
+          window: window)
     end
 
     def initialize(queues, last_enqueued_at:, window: nil)

data/app/models/job_board/throughput.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module JobBoard
+  class Throughput
+    READY_AT = "COALESCE(scheduled_at, created_at)"
+
+    class << self
+      def snapshot(since:)
+        now = Time.current
+        {
+          now: now.iso8601(3),
+          enqueued: since ? count_between(READY_AT, since, now) : 0,
+          completed: since ? count_between("finished_at", since, now) : 0
+        }
+      end
+
+      private
+
+      def count_between(expression, since, now)
+        SolidQueue::Job.where("#{expression} > ? AND #{expression} <= ?", since, now).count
+      end
+    end
+  end
+end

data/app/views/job_board/queues/_table.html.erb

@@ -3,6 +3,7 @@
     <tr>
       <th>Queue</th>
       <th class="num">Ready jobs</th>
+      <th class="num">Running</th>
       <th class="num">Failed</th>
       <th class="num">Latency</th>
       <th>Last enqueued</th>
@@ -15,6 +16,14 @@
       <tr>
         <td><%= link_to queue.name, jobs_path(status: "ready", queue_name: queue.name) %></td>
         <td class="num"><%= queue.size %></td>
+        <td class="num">
+          <% running = @running_counts[queue.name] || 0 %>
+          <% if running.positive? %>
+            <%= link_to running, jobs_path(status: "in_progress", queue_name: queue.name), class: "running-count" %>
+          <% else %>
+            <span class="muted">0</span>
+          <% end %>
+        </td>
         <td class="num">
           <% failed = @failed_counts[queue.name] || 0 %>
           <% if failed.positive? %>

data/app/views/job_board/queues/index.html.erb

@@ -1,5 +1,23 @@
 <h1>Queues</h1>
 
+<section id="throughput-chart" class="throughput-chart"
+         data-metrics-url="<%= metrics_path %>"
+         data-poll-interval="<%= JobBoard.config.poll_interval.to_i %>"
+         data-max-points="120">
+  <div class="throughput-chart__header">
+    <h2>Throughput</h2>
+    <div class="throughput-chart__legend">
+      <span class="tp-key tp-key--enqueued">Enqueued <b data-tp-latest="enqueued">0</b></span>
+      <span class="tp-key tp-key--completed">Completed <b data-tp-latest="completed">0</b></span>
+    </div>
+  </div>
+  <svg class="throughput-chart__svg" viewBox="0 0 600 160" preserveAspectRatio="none"
+       role="img" aria-label="Enqueued and completed jobs per interval">
+    <polyline class="tp-line tp-line--enqueued" fill="none" points=""></polyline>
+    <polyline class="tp-line tp-line--completed" fill="none" points=""></polyline>
+  </svg>
+</section>
+
 <div data-poll-region="queues">
   <% if @queue_list.active.empty? && @queue_list.inactive.empty? %>
     <p class="empty-state">No queues yet — queues appear once jobs are enqueued.</p>

data/app/views/layouts/job_board/application.html.erb

@@ -5,7 +5,9 @@
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <%= csrf_meta_tags %>
   <link rel="stylesheet" href="<%= static_asset_path("application.css", v: JobBoard::VERSION) %>">
+  <link rel="stylesheet" href="<%= static_asset_path("throughput_chart.css", v: JobBoard::VERSION) %>">
   <script src="<%= static_asset_path("application.js", v: JobBoard::VERSION) %>" defer></script>
+  <script src="<%= static_asset_path("throughput_chart.js", v: JobBoard::VERSION) %>" defer></script>
 </head>
 <body data-poll-interval="<%= JobBoard.config.poll_interval.to_i %>">
   <%= render "job_board/shared/nav" %>

data/config/routes.rb

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 JobBoard::Engine.routes.draw do
   root to: "queues#index"
 
   get "queues", to: "queues#index", as: :queues
-  scope "queues/:queue_name", constraints: { queue_name: /[^\/]+/ }, format: false do
+  scope "queues/:queue_name", constraints: { queue_name: %r{[^/]+} }, format: false do
     post   "pause", to: "queues/pauses#create", as: :queue_pause
     delete "pause", to: "queues/pauses#destroy"
   end
 
-  resources :jobs, only: [:index, :show] do
+  resources :jobs, only: %i[index show] do
     member do
       post :retry
       delete :discard
@@ -20,9 +22,11 @@ JobBoard::Engine.routes.draw do
 
   resources :processes, only: :index
   resources :recurring_tasks, only: :index
-  scope "recurring_tasks/:key", constraints: { key: /[^\/]+/ }, format: false do
+  scope "recurring_tasks/:key", constraints: { key: %r{[^/]+} }, format: false do
     post "run", to: "recurring_tasks/runs#create", as: :recurring_task_run
   end
 
+  get "metrics", to: "metrics#show", as: :metrics
+
   get "assets/:name", to: "assets#show", as: :static_asset, constraints: { name: /[a-z_]+\.(css|js)/ }
 end

data/lib/job_board/assets/application.css

@@ -196,6 +196,7 @@ code.cron {
 .latency { font-weight: 600; }
 .latency--high { color: var(--danger); }
 .failed-count { color: var(--danger); font-weight: 600; }
+.running-count { color: var(--warning); font-weight: 600; }
 
 /* Tabs */
 .tabs {

data/lib/job_board/assets/throughput_chart.css

@@ -0,0 +1,64 @@
+/* Home-page throughput chart. Relies on the :root custom properties defined in
+   application.css, which the layout always loads alongside this file. */
+.throughput-chart {
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 10px;
+  padding: 0.75rem 1rem 1rem;
+  margin-bottom: 1.5rem;
+}
+
+.throughput-chart__header {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 1rem;
+}
+
+.throughput-chart__header h2 {
+  font-size: 0.95rem;
+  margin: 0;
+}
+
+.throughput-chart__legend {
+  display: flex;
+  gap: 1rem;
+  font-size: 0.82rem;
+  color: var(--text-muted);
+}
+
+.tp-key {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.4rem;
+}
+
+.tp-key b {
+  color: var(--text);
+  font-variant-numeric: tabular-nums;
+}
+
+.tp-key::before {
+  content: "";
+  width: 0.75rem;
+  height: 0.2rem;
+  border-radius: 2px;
+}
+
+.tp-key--enqueued::before { background: var(--accent); }
+.tp-key--completed::before { background: var(--success); }
+
+.throughput-chart__svg {
+  display: block;
+  width: 100%;
+  height: 160px;
+  margin-top: 0.5rem;
+}
+
+.tp-line {
+  stroke-width: 2;
+  vector-effect: non-scaling-stroke;
+}
+
+.tp-line--enqueued { stroke: var(--accent); }
+.tp-line--completed { stroke: var(--success); }

data/lib/job_board/assets/throughput_chart.js

@@ -0,0 +1,89 @@
+(function () {
+  "use strict";
+
+  var chart = document.getElementById("throughput-chart");
+  if (!chart) return;
+
+  var metricsUrl = chart.dataset.metricsUrl;
+  var pollIntervalMs = parseInt(chart.dataset.pollInterval, 10) * 1000;
+  var maxVisiblePoints = parseInt(chart.dataset.maxPoints, 10) || 120;
+  if (!metricsUrl || !pollIntervalMs || pollIntervalMs <= 0) return;
+
+  var viewBox = chart.querySelector(".throughput-chart__svg").viewBox.baseVal;
+  var enqueuedLine = chart.querySelector(".tp-line--enqueued");
+  var completedLine = chart.querySelector(".tp-line--completed");
+  var latestLabels = {
+    enqueued: chart.querySelector('[data-tp-latest="enqueued"]'),
+    completed: chart.querySelector('[data-tp-latest="completed"]')
+  };
+
+  var samplesOldestToNewest = [];
+  var previousServerTime = null;
+
+  function ignoreTransientError() {}
+
+  function fetchMetrics(query) {
+    return fetch(metricsUrl + query, {
+      headers: { "Accept": "application/json" },
+      credentials: "same-origin"
+    }).then(function (response) {
+      if (!response.ok) throw new Error("metrics fetch failed");
+      return response.json();
+    });
+  }
+
+  function resetBaselineWithoutPlotting() {
+    return fetchMetrics("").then(function (data) { previousServerTime = data.now; });
+  }
+
+  function highestValue() {
+    var peak = 1;
+    samplesOldestToNewest.forEach(function (sample) {
+      if (sample.enqueued > peak) peak = sample.enqueued;
+      if (sample.completed > peak) peak = sample.completed;
+    });
+    return peak;
+  }
+
+  function pointsFor(series) {
+    if (samplesOldestToNewest.length === 0) return "";
+    var peak = highestValue();
+    var horizontalStep = samplesOldestToNewest.length > 1 ? viewBox.width / (samplesOldestToNewest.length - 1) : 0;
+    return samplesOldestToNewest.map(function (sample, index) {
+      var stepsFromRightEdge = samplesOldestToNewest.length - 1 - index;
+      var x = viewBox.width - stepsFromRightEdge * horizontalStep;
+      var y = viewBox.height - (sample[series] / peak) * viewBox.height;
+      return x.toFixed(1) + "," + y.toFixed(1);
+    }).join(" ");
+  }
+
+  function redraw() {
+    enqueuedLine.setAttribute("points", pointsFor("enqueued"));
+    completedLine.setAttribute("points", pointsFor("completed"));
+    var newestSample = samplesOldestToNewest[samplesOldestToNewest.length - 1];
+    if (newestSample) {
+      latestLabels.enqueued.textContent = newestSample.enqueued;
+      latestLabels.completed.textContent = newestSample.completed;
+    }
+  }
+
+  function collectSample() {
+    var baselineReady = previousServerTime !== null;
+    if (document.hidden || !baselineReady) return;
+    fetchMetrics("?since=" + encodeURIComponent(previousServerTime)).then(function (data) {
+      samplesOldestToNewest.push({ enqueued: data.enqueued, completed: data.completed });
+      if (samplesOldestToNewest.length > maxVisiblePoints) samplesOldestToNewest.shift();
+      previousServerTime = data.now;
+      redraw();
+    }).catch(ignoreTransientError);
+  }
+
+  function reBaselineWhenTabBecomesVisible() {
+    if (!document.hidden) resetBaselineWithoutPlotting();
+  }
+
+  document.addEventListener("visibilitychange", reBaselineWhenTabBecomesVisible);
+
+  resetBaselineWithoutPlotting().catch(ignoreTransientError);
+  setInterval(collectSample, pollIntervalMs);
+})();

data/lib/job_board/configuration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JobBoard
   class Configuration
     # nil, or { name: "...", password: "..." } to protect the UI with HTTP Basic auth.

data/lib/job_board/engine.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JobBoard
   class Engine < ::Rails::Engine
     isolate_namespace JobBoard

data/lib/job_board/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JobBoard
-  VERSION = "0.3.0"
+  VERSION = "0.5.0"
 end

data/lib/job_board.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "solid_queue"
 
 require "job_board/version"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: job_board
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Mike
@@ -51,6 +51,7 @@ files:
 - app/controllers/job_board/application_controller.rb
 - app/controllers/job_board/assets_controller.rb
 - app/controllers/job_board/jobs_controller.rb
+- app/controllers/job_board/metrics_controller.rb
 - app/controllers/job_board/processes_controller.rb
 - app/controllers/job_board/queues/pauses_controller.rb
 - app/controllers/job_board/queues_controller.rb
@@ -65,6 +66,7 @@ files:
 - app/models/job_board/page.rb
 - app/models/job_board/process_tree.rb
 - app/models/job_board/queue_list.rb
+- app/models/job_board/throughput.rb
 - app/views/job_board/jobs/_filters.html.erb
 - app/views/job_board/jobs/_job_row.html.erb
 - app/views/job_board/jobs/index.html.erb
@@ -81,6 +83,8 @@ files:
 - lib/job_board.rb
 - lib/job_board/assets/application.css
 - lib/job_board/assets/application.js
+- lib/job_board/assets/throughput_chart.css
+- lib/job_board/assets/throughput_chart.js
 - lib/job_board/configuration.rb
 - lib/job_board/engine.rb
 - lib/job_board/version.rb