job_board 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0a2428d3806231d3051a64d1ed7f693e51341cbbc12a4a2fe8240f1f1c56d73
-  data.tar.gz: 59cb3f9a17d3ae3cc0b9ac69adb11ec5c1c27838391d559c2c6f9a23e2a65306
+  metadata.gz: bfca59214924a123a70c43a88852ea184782d00ca60107c07808b79cf6c3c3ac
+  data.tar.gz: 0e64e1a67b82fb40227e2f9d87729fb647fe2b7d00bfc6bb9cab0ecf331ba3c6
 SHA512:
-  metadata.gz: fc936decbae3e1e9457ac3a6d6643f67907e4b0314ee3368e22516040779381f549af59c7b60fffa28f026b1edb88feddfa62cdd32772b9e4571eb413ad1e46f
-  data.tar.gz: c7f69762ffd1695bb6fc3dd64d59a8248f3d445255cc8f2276d9c7ddfb3a0b2008898c8557988fe4c76455389fbe213e752b36bdf1d4ccbdf56393e5c74ef4b0
+  metadata.gz: da74ce333cc798a40a50f3ee1cafae15d7e882713eb7a8e2afa6b80773d1f0a31bcd47ad88a88e43fb321053a0ca8a8242642a3a2bc90282fee16c447d2e8224
+  data.tar.gz: 7e979f3d406ef8038fddc553e47cb72a0af08320a3da0a936d5319e929f8177fa067ec2323093273fa0fee9adb4d24d28886e11b0cace363f6591636039f6360

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 # 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
+  (recorded as a run, so "Last run" reflects it), and tasks are now sorted by next
+  run time instead of by key.
+- Hovering a cron schedule shows a plain-English description of when it runs
+  (e.g. `30 9 * * 1-5` → "At 09:30 on Monday through Friday").
+
 ## 0.2.0
 
 - Queues page: new **Last enqueued** column showing when each queue last received a job.

data/README.md

@@ -15,7 +15,9 @@ queue latency at a glance, jobs by status, failed-job management, worker health,
 - **Workers** — the supervisor → worker/dispatcher/scheduler tree with heartbeat freshness,
   stale-process badges, per-worker in-progress jobs, and a warning when claimed jobs have been
   orphaned by a dead process.
-- **Recurring tasks** — each task's cron schedule, last run, and next run.
+- **Recurring tasks** — each task's cron schedule (hover for a plain-English description),
+  last run, and next run, sorted soonest-first, with a **Run now** button to trigger any
+  task outside its schedule.
 - **Zero dependencies** — the engine serves its own CSS and ~40 lines of vanilla JS. No
   importmap, sprockets, propshaft, or Node requirement. Pages auto-refresh every few seconds.
 

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/controllers/job_board/recurring_tasks/runs_controller.rb

@@ -0,0 +1,18 @@
+module JobBoard
+  module RecurringTasks
+    class RunsController < ApplicationController
+      def create
+        task = SolidQueue::RecurringTask.find_by(key: params[:key])
+
+        if task.nil?
+          redirect_to recurring_tasks_path, alert: "Recurring task \"#{params[:key]}\" no longer exists."
+        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."
+        end
+      end
+    end
+  end
+end

data/app/controllers/job_board/recurring_tasks_controller.rb

@@ -1,7 +1,8 @@
 module JobBoard
   class RecurringTasksController < ApplicationController
     def index
-      @tasks = SolidQueue::RecurringTask.order(:key)
+      # next_time is derived from the cron schedule, not stored, so sort in Ruby.
+      @tasks = SolidQueue::RecurringTask.all.sort_by { |task| [task.next_time, task.key] }
     end
   end
 end

data/app/helpers/job_board/application_helper.rb

@@ -30,6 +30,13 @@ module JobBoard
       LatencySla.threshold_for(queue_name)
     end
 
+    # <code> tag for a cron schedule, with an English description of the
+    # schedule as a hover tooltip when we can produce one.
+    def cron_schedule(schedule)
+      description = CronDescription.describe(schedule)
+      tag.code(schedule, title: description, class: ("cron" if description))
+    end
+
     def format_json(value)
       value = JSON.parse(value) if value.is_a?(String)
       JSON.pretty_generate(value)

data/app/models/job_board/cron_description.rb

@@ -0,0 +1,154 @@
+require "fugit"
+
+module JobBoard
+  # Turns a cron expression into an English frequency description,
+  # e.g. "30 9 * * 1-5" => "At 09:30 on Monday through Friday".
+  # Returns nil for anything it can't describe faithfully.
+  class CronDescription
+    DAYS = %w[Sunday Monday Tuesday Wednesday Thursday Friday Saturday].freeze
+    MONTHS = %w[January February March April May June
+                July August September October November December].freeze
+
+    def self.describe(schedule)
+      cron = Fugit.parse(schedule.to_s)
+      new(cron).to_s if cron.instance_of?(Fugit::Cron)
+    rescue StandardError
+      nil
+    end
+
+    def initialize(cron)
+      @cron = cron
+    end
+
+    def to_s
+      time = time_clause
+      return nil if time.nil?
+
+      days = day_clause
+      description =
+        if days
+          "#{time} #{days}"
+        elsif time.start_with?("At ")
+          "Every day #{time.sub(/\AAt /, "at ")}"
+        else
+          time
+        end
+      cron.zone ? "#{description} (#{cron.zone})" : description
+    end
+
+    private
+
+    attr_reader :cron
+
+    def time_clause
+      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
+      elsif cron.minutes.nil? && cron.hours.nil?
+        "Every minute"
+      elsif (step = minutes_step) && cron.hours.nil?
+        "Every #{step} minutes"
+      elsif cron.minutes == [0] && cron.hours.nil?
+        "Every hour"
+      elsif cron.hours.nil?
+        "Every hour at #{numbers("minute", cron.minutes)}"
+      elsif (step = hours_step)
+        cron.minutes == [0] ? "Every #{step} hours" : "Every #{step} hours at #{numbers("minute", cron.minutes)}"
+      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) })}"
+        else
+          "At #{numbers("minute", cron.minutes)} past #{numbers("hour", cron.hours)}"
+        end
+      end
+    end
+
+    # nil when there is no day-of-week/month restriction (i.e. runs every day).
+    def day_clause
+      day_parts = [weekday_clause, monthday_clause].compact
+      # Cron treats day-of-month and day-of-week as OR when both are restricted.
+      clause = day_parts.join(" or ").presence
+      [clause, month_clause].compact.join(" ").presence
+    end
+
+    def weekday_clause
+      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|
+        "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
+      end
+      "on #{join_and(phrases + nth)}"
+    end
+
+    def monthday_clause
+      return nil if cron.monthdays.nil?
+
+      # "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?
+        @month_consumed = true
+        return "on #{MONTHS[cron.months.first - 1]} #{cron.monthdays.first}"
+      end
+
+      positive, negative = cron.monthdays.partition(&:positive?)
+      phrases = []
+      phrases << numbers("day", positive) if positive.any?
+      phrases += negative.sort.reverse.map do |day|
+        day == -1 ? "the last day" : "the #{(-day).ordinalize}-to-last day"
+      end
+      "on #{join_and(phrases)} of the month"
+    end
+
+    def month_clause
+      return nil if cron.months.nil? || @month_consumed
+
+      names = cron.months.sort.map { |m| MONTHS[m - 1] }
+      if names.size > 2 && consecutive?(cron.months.sort)
+        "in #{names.first} through #{names.last}"
+      else
+        "in #{join_and(names)}"
+      end
+    end
+
+    def seconds_step = step_of(cron.seconds, 60)
+    def minutes_step = step_of(cron.minutes, 60)
+    def hours_step   = step_of(cron.hours, 24)
+
+    # [0, 15, 30, 45] within 60 => 15; anything not starting at 0 or unevenly spaced => nil.
+    def step_of(values, span)
+      return nil if values.nil? || values.size < 2 || values.first != 0
+
+      gap = values[1] - values[0]
+      values == (0...span).step(gap).to_a ? gap : nil
+    end
+
+    def consecutive?(values)
+      values.each_cons(2).all? { |a, b| b == a + 1 }
+    end
+
+    def numbers(noun, values)
+      "#{noun.pluralize(values.size)} #{join_and(values.sort)}"
+    end
+
+    def join_and(items)
+      items = items.map(&:to_s)
+      return items.join(" and ") if items.size <= 2
+
+      "#{items[0..-2].join(", ")}, and #{items.last}"
+    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/job_board/recurring_tasks/index.html.erb

@@ -15,6 +15,7 @@
           <th>Queue</th>
           <th>Last run</th>
           <th>Next run</th>
+          <th class="actions"></th>
         </tr>
       </thead>
       <tbody>
@@ -24,11 +25,15 @@
               <%= task.key %>
               <% unless task.static %><span class="badge badge--kind">dynamic</span><% end %>
             </td>
-            <td><code><%= task.schedule %></code></td>
+            <td><%= cron_schedule(task.schedule) %></td>
             <td><%= task.class_name.presence || task.command %></td>
             <td><%= task.queue_name.presence || "default" %></td>
             <td><%= time_ago(task.last_enqueued_time) %></td>
             <td><%= time_ago(task.next_time) %></td>
+            <td class="actions">
+              <%= button_to "Run now", recurring_task_run_path(task.key), class: "btn",
+                    form: { data: { confirm: "Enqueue \"#{task.key}\" now, outside its schedule?" } } %>
+            </td>
           </tr>
         <% end %>
       </tbody>

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

@@ -20,6 +20,11 @@ JobBoard::Engine.routes.draw do
 
   resources :processes, only: :index
   resources :recurring_tasks, only: :index
+  scope "recurring_tasks/:key", constraints: { key: /[^\/]+/ }, 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

@@ -70,6 +70,13 @@ code {
 
 .muted { color: var(--text-muted); }
 
+/* Cron schedules with a hover description */
+code.cron {
+  cursor: help;
+  text-decoration: underline dotted var(--text-muted);
+  text-underline-offset: 2px;
+}
+
 /* Nav */
 .nav {
   display: flex;

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.2.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.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Mike
@@ -51,11 +51,14 @@ 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
+- app/controllers/job_board/recurring_tasks/runs_controller.rb
 - app/controllers/job_board/recurring_tasks_controller.rb
 - app/helpers/job_board/application_helper.rb
+- app/models/job_board/cron_description.rb
 - app/models/job_board/job_presenter.rb
 - app/models/job_board/job_row.rb
 - app/models/job_board/jobs_query.rb
@@ -63,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
@@ -79,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