job_board 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bea67d509d907e2592ab52afa1b5416ddec7493cbdab455d67b9f9ac4aa3e66e
-  data.tar.gz: 38f1c58ef928b9d40253aa5f9e37f1b5bd4073899cd3a641a1d467455f8c541c
+  metadata.gz: bfca59214924a123a70c43a88852ea184782d00ca60107c07808b79cf6c3c3ac
+  data.tar.gz: 0e64e1a67b82fb40227e2f9d87729fb647fe2b7d00bfc6bb9cab0ecf331ba3c6
 SHA512:
-  metadata.gz: 688e4fd719017cad90493adcfcbe9e8629c06d939a7f58d28cc9a32b119ec4a01ba90942604dbfb9fb218f6bb931dfc44ee760f0b0d6448f664a9d7eb27f2663
-  data.tar.gz: 0436d97db91c3ac1071145936ea3c41f4396fca772407324c8349369af7343da0cb4783552f9bca4d8b2786c7ce1e22a1cc9256364c05836c8a850a9e1debb0f
+  metadata.gz: da74ce333cc798a40a50f3ee1cafae15d7e882713eb7a8e2afa6b80773d1f0a31bcd47ad88a88e43fb321053a0ca8a8242642a3a2bc90282fee16c447d2e8224
+  data.tar.gz: 7e979f3d406ef8038fddc553e47cb72a0af08320a3da0a936d5319e929f8177fa067ec2323093273fa0fee9adb4d24d28886e11b0cace363f6591636039f6360

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 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

@@ -7,18 +7,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

@@ -4,7 +4,9 @@ module JobBoard
 
     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

data/app/controllers/job_board/jobs_controller.rb

@@ -53,36 +53,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(&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 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,15 @@
+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/models/job_board/jobs_query.rb

@@ -49,38 +49,39 @@ 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 = 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
+    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/throughput.rb

@@ -0,0 +1,22 @@
+module JobBoard
+  class Throughput
+    READY_AT = "COALESCE(scheduled_at, created_at)".freeze
+
+    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/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

@@ -24,5 +24,7 @@ JobBoard::Engine.routes.draw 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/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/version.rb

@@ -1,3 +1,3 @@
 module JobBoard
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: job_board
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.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