good_job 2.2.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd267297ac5f8e889d5af7d3efb0d12f3564ddedb8c645fde37bc044e18d48d0
-  data.tar.gz: 5fc5715400914b895fb38fc087bb7bb08ea63ffb4db8938cea9e2933b32ade36
+  metadata.gz: c2a09a86e822d7dfc09b5788c5790fe79fd418c5749e7ff716e79e35496d8574
+  data.tar.gz: d588ac1a06ea6b013834922c23de7157099f4a261b2e52422081d305f2e9e468
 SHA512:
-  metadata.gz: d3da94d9ad1b43e5102d0795d0c3909912ba90178678187d7340170a48c2df733ba7aba4bd33da8fdb50084f82fb4ff960c71dd4db0c23bc1a68278a1d1fbd21
-  data.tar.gz: 9810497b9bdef82a95e79bf98414e60652dc912ccb6cfe9ce0893a898708fe6e547b89d67530c62b721fff01cc2c7bfa679f450c511ca5f68d3a5ef0d0a387ca
+  metadata.gz: 8e21e8a4ded224874ac111aae669dcf2315dc63663b7942888ef22e8da9367f8b6fa973bfda86941564f6e35fff7ef22f7f403ae9f7414a48a3be2ae2cd7f2a3
+  data.tar.gz: 3ddcf93091ba3a221aadaf85790b8ff7edca2a317c9e23df45a5d69d07ebdcaf9143ada9bf5f157a9909aca4deb5f7ecc51c1abb80b98e90e51241e5fce0f450

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [v2.3.0](https://github.com/bensheldon/good_job/tree/v2.3.0) (2021-09-25)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v2.2.0...v2.3.0)
+
+**Implemented enhancements:**
+
+- Create an ActiveJobJob model and Dashboard [\#383](https://github.com/bensheldon/good_job/pull/383) ([bensheldon](https://github.com/bensheldon))
+- Preserve page filter when deleting execution [\#381](https://github.com/bensheldon/good_job/pull/381) ([morgoth](https://github.com/morgoth))
+
+**Merged pull requests:**
+
+- Update GH Test Matrix with latest JRuby 9.3.0.0 [\#387](https://github.com/bensheldon/good_job/pull/387) ([tedhexaflow](https://github.com/tedhexaflow))
+- Improve test support's ShellOut command's process termination and add test logs [\#385](https://github.com/bensheldon/good_job/pull/385) ([bensheldon](https://github.com/bensheldon))
+- @bensheldon Add Rails 7 alpha to Appraisal; update development dependencies [\#384](https://github.com/bensheldon/good_job/pull/384) ([bensheldon](https://github.com/bensheldon))
+
 ## [v2.2.0](https://github.com/bensheldon/good_job/tree/v2.2.0) (2021-09-15)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v2.1.0...v2.2.0)

data/engine/app/controllers/good_job/cron_schedules_controller.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-
 module GoodJob
   class CronSchedulesController < GoodJob::BaseController
     def index

data/engine/app/controllers/good_job/executions_controller.rb

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
 module GoodJob
   class ExecutionsController < GoodJob::BaseController
+    def index
+      @filter = ExecutionsFilter.new(params)
+    end
+
     def destroy
       deleted_count = GoodJob::Execution.where(id: params[:id]).delete_all
       message = deleted_count.positive? ? { notice: "Job execution deleted" } : { alert: "Job execution not deleted" }
-      redirect_to root_path, **message
+      redirect_back fallback_location: root_path, **message
     end
   end
 end

data/engine/app/controllers/good_job/{active_jobs_controller.rb → jobs_controller.rb}

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
 module GoodJob
-  class ActiveJobsController < GoodJob::BaseController
+  class JobsController < GoodJob::BaseController
+    def index
+      @filter = JobsFilter.new(params)
+    end
+
     def show
       @executions = GoodJob::Execution.active_job_id(params[:id])
                                       .order(Arel.sql("COALESCE(scheduled_at, created_at) DESC"))
-      raise ActiveRecord::RecordNotFound if @executions.empty?
+      redirect_to root_path, alert: "Executions for Active Job #{params[:id]} not found" if @executions.empty?
     end
   end
 end

data/engine/app/filters/good_job/base_filter.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+module GoodJob
+  class BaseFilter
+    attr_accessor :params
+
+    def initialize(params)
+      @params = params
+    end
+
+    def records
+      after_scheduled_at = params[:after_scheduled_at].present? ? Time.zone.parse(params[:after_scheduled_at]) : nil
+
+      filtered_query.display_all(
+        after_scheduled_at: after_scheduled_at,
+        after_id: params[:after_id]
+      ).limit(params.fetch(:limit, 25))
+    end
+
+    def last
+      @_last ||= records.last
+    end
+
+    def job_classes
+      base_query.group("serialized_params->>'job_class'").count
+                .sort_by { |name, _count| name }
+                .to_h
+    end
+
+    def queues
+      base_query.group(:queue_name).count
+                .sort_by { |name, _count| name }
+                .to_h
+    end
+
+    def states
+      raise NotImplementedError
+    end
+
+    def to_params(override)
+      {
+        state: params[:state],
+        job_class: params[:job_class],
+      }.merge(override).delete_if { |_, v| v.nil? }
+    end
+
+    def chart_data
+      count_query = Arel.sql(GoodJob::Execution.pg_or_jdbc_query(<<~SQL.squish))
+        SELECT *
+        FROM generate_series(
+          date_trunc('hour', $1::timestamp),
+          date_trunc('hour', $2::timestamp),
+          '1 hour'
+        ) timestamp
+        LEFT JOIN (
+          SELECT
+              date_trunc('hour', scheduled_at) AS scheduled_at,
+              queue_name,
+              count(*) AS count
+            FROM (
+              #{filtered_query.except(:select).select('queue_name', 'COALESCE(good_jobs.scheduled_at, good_jobs.created_at)::timestamp AS scheduled_at').to_sql}
+            ) sources
+            GROUP BY date_trunc('hour', scheduled_at), queue_name
+        ) sources ON sources.scheduled_at = timestamp
+        ORDER BY timestamp ASC
+      SQL
+
+      current_time = Time.current
+      binds = [[nil, current_time - 1.day], [nil, current_time]]
+      executions_data = GoodJob::Execution.connection.exec_query(count_query, "GoodJob Dashboard Chart", binds)
+
+      queue_names = executions_data.map { |d| d['queue_name'] }.uniq
+      labels = []
+      queues_data = executions_data.to_a.group_by { |d| d['timestamp'] }.each_with_object({}) do |(timestamp, values), hash|
+        labels << timestamp.in_time_zone.strftime('%H:%M %z')
+        queue_names.each do |queue_name|
+          (hash[queue_name] ||= []) << values.find { |d| d['queue_name'] == queue_name }&.[]('count')
+        end
+      end
+
+      {
+        labels: labels,
+        series: queues_data.map do |queue, data|
+          {
+            name: queue,
+            data: data,
+          }
+        end,
+      }
+    end
+
+    private
+
+    def base_query
+      raise NotImplementedError
+    end
+
+    def filtered_query
+      raise NotImplementedError
+    end
+  end
+end

data/engine/app/filters/good_job/executions_filter.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+module GoodJob
+  class ExecutionsFilter < BaseFilter
+    def states
+      {
+        'finished' => base_query.finished.count,
+        'unfinished' => base_query.unfinished.count,
+        'running' => base_query.running.count,
+        'errors' => base_query.where.not(error: nil).count,
+      }
+    end
+
+    private
+
+    def base_query
+      GoodJob::Execution.all
+    end
+
+    def filtered_query
+      query = base_query
+      query = query.job_class(params[:job_class]) if params[:job_class]
+      query = query.where(queue_name: params[:queue_name]) if params[:queue_name]
+
+      if params[:state]
+        case params[:state]
+        when 'finished'
+          query = query.finished
+        when 'unfinished'
+          query = query.unfinished
+        when 'running'
+          query = query.running
+        when 'errors'
+          query = query.where.not(error: nil)
+        end
+      end
+
+      query
+    end
+  end
+end

data/engine/app/filters/good_job/jobs_filter.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+module GoodJob
+  class JobsFilter < BaseFilter
+    def states
+      {
+        'scheduled' =>  base_query.scheduled.count,
+        'retried' => base_query.retried.count,
+        'queued' => base_query.queued.count,
+        'running' => base_query.running.count,
+        'finished' => base_query.finished.count,
+        'discarded' => base_query.discarded.count,
+      }
+    end
+
+    private
+
+    def base_query
+      GoodJob::ActiveJobJob.all
+    end
+
+    def filtered_query
+      query = base_query
+      query = query.job_class(params[:job_class]) if params[:job_class]
+      query = query.where(queue_name: params[:queue_name]) if params[:queue_name]
+
+      if params[:state]
+        case params[:state]
+        when 'discarded'
+          query = query.discarded
+        when 'finished'
+          query = query.finished
+        when 'retried'
+          query = query.retried
+        when 'scheduled'
+          query = query.scheduled
+        when 'running'
+          query = query.running.select('good_jobs.*', 'pg_locks.locktype')
+        when 'queued'
+          query = query.queued
+        end
+      end
+
+      query
+    end
+  end
+end

data/engine/app/models/good_job/active_job_job.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+module GoodJob
+  # ActiveRecord model that represents an +ActiveJob+ job.
+  # Is the same record data as a {GoodJob::Execution} but only the most recent execution.
+  # Parent class can be configured with +GoodJob.active_record_parent_class+.
+  # @!parse
+  #   class ActiveJob < ActiveRecord::Base; end
+  class ActiveJobJob < Object.const_get(GoodJob.active_record_parent_class)
+    include GoodJob::Lockable
+
+    self.table_name = 'good_jobs'
+    self.primary_key = 'active_job_id'
+    self.advisory_lockable_column = 'active_job_id'
+
+    has_many :executions, -> { order(created_at: :asc) }, class_name: 'GoodJob::Execution', foreign_key: 'active_job_id'
+
+    # Only the most-recent unretried execution represents a "Job"
+    default_scope { where(retried_good_job_id: nil) }
+
+    # Get Jobs with given class name
+    # @!method job_class
+    # @!scope class
+    # @param string [String]
+    #   Execution class name
+    # @return [ActiveRecord::Relation]
+    scope :job_class, ->(job_class) { where("serialized_params->>'job_class' = ?", job_class) }
+
+    # First execution will run in the future
+    scope :scheduled, -> { where(finished_at: nil).where('COALESCE(scheduled_at, created_at) > ?', DateTime.current).where("(serialized_params->>'executions')::integer < 2") }
+    # Execution errored, will run in the future
+    scope :retried, -> { where(finished_at: nil).where('COALESCE(scheduled_at, created_at) > ?', DateTime.current).where("(serialized_params->>'executions')::integer > 1") }
+    # Immediate/Scheduled time to run has passed, waiting for an available thread run
+    scope :queued, -> { where(finished_at: nil).where('COALESCE(scheduled_at, created_at) <= ?', DateTime.current).joins_advisory_locks.where(pg_locks: { locktype: nil }) }
+    # Advisory locked and executing
+    scope :running, -> { where(finished_at: nil).joins_advisory_locks.where.not(pg_locks: { locktype: nil }) }
+    # Completed executing successfully
+    scope :finished, -> { where.not(finished_at: nil).where(error: nil) }
+    # Errored but will not be retried
+    scope :discarded, -> { where.not(finished_at: nil).where.not(error: nil) }
+
+    # Get Jobs in display order with optional keyset pagination.
+    # @!method display_all(after_scheduled_at: nil, after_id: nil)
+    # @!scope class
+    # @param after_scheduled_at [DateTime, String, nil]
+    #   Display records scheduled after this time for keyset pagination
+    # @param after_id [Numeric, String, nil]
+    #   Display records after this ID for keyset pagination
+    # @return [ActiveRecord::Relation]
+    scope :display_all, (lambda do |after_scheduled_at: nil, after_id: nil|
+      query = order(Arel.sql('COALESCE(scheduled_at, created_at) DESC, id DESC'))
+      if after_scheduled_at.present? && after_id.present?
+        query = query.where(Arel.sql('(COALESCE(scheduled_at, created_at), id) < (:after_scheduled_at, :after_id)'), after_scheduled_at: after_scheduled_at, after_id: after_id)
+      elsif after_scheduled_at.present?
+        query = query.where(Arel.sql('(COALESCE(scheduled_at, created_at)) < (:after_scheduled_at)'), after_scheduled_at: after_scheduled_at)
+      end
+      query
+    end)
+
+    def id
+      active_job_id
+    end
+
+    def _execution_id
+      attributes['id']
+    end
+
+    def job_class
+      serialized_params['job_class']
+    end
+
+    def status
+      if finished_at.present?
+        if error.present?
+          :discarded
+        else
+          :finished
+        end
+      elsif (scheduled_at || created_at) > DateTime.current
+        if serialized_params.fetch('executions', 0) > 1
+          :retried
+        else
+          :scheduled
+        end
+      elsif running?
+        :running
+      else
+        :queued
+      end
+    end
+
+    def head_execution
+      executions.last
+    end
+
+    def tail_execution
+      executions.first
+    end
+
+    def executions_count
+      aj_count = serialized_params.fetch('executions', 0)
+      # The execution count within serialized_params is not updated
+      # once the underlying execution has been executed.
+      if status.in? [:discarded, :finished, :running]
+        aj_count + 1
+      else
+        aj_count
+      end
+    end
+
+    def preserved_executions_count
+      executions.size
+    end
+
+    def recent_error
+      error.presence || executions[-2]&.error
+    end
+
+    def running?
+      # Avoid N+1 Query: `.joins_advisory_locks.select('good_jobs.*', 'pg_locks.locktype AS locktype')`
+      if has_attribute?(:locktype)
+        self['locktype'].present?
+      else
+        advisory_locked?
+      end
+    end
+  end
+end

data/engine/app/views/good_job/executions/index.html.erb

@@ -0,0 +1,21 @@
+<div class="card my-3 p-6">
+  <%= render 'good_job/shared/chart', chart_data: @filter.chart_data %>
+</div>
+
+<%= render 'good_job/shared/filter', filter: @filter %>
+
+<% if @filter.records.present? %>
+  <%= render 'good_job/shared/executions_table', executions: @filter.records %>
+
+  <nav aria-label="Job pagination" class="mt-3">
+    <ul class="pagination">
+      <li class="page-item">
+        <%= link_to({ after_scheduled_at: (@filter.last.scheduled_at || @filter.last.created_at), after_id: @filter.last.id }, class: "page-link") do %>
+          Older executions <span aria-hidden="true">&raquo;</span>
+        <% end %>
+      </li>
+    </ul>
+  </nav>
+<% else %>
+  <em>No executions present.</em>
+<% end %>

data/engine/app/views/good_job/jobs/index.html.erb

@@ -0,0 +1,7 @@
+<div class="card my-3 p-6">
+  <%= render 'good_job/shared/chart', chart_data: @filter.chart_data %>
+</div>
+
+<%= render 'good_job/shared/filter', filter: @filter %>
+
+<%= render 'good_job/shared/jobs_table', jobs: @filter.records %>

data/engine/app/views/good_job/shared/_executions_table.erb

@@ -23,12 +23,12 @@
         <% executions.each do |execution| %>
           <tr id="<%= dom_id(execution) %>">
             <td>
-              <%= link_to active_job_path(execution.serialized_params['job_id']) do %>
+              <%= link_to job_path(execution.serialized_params['job_id']) do %>
                 <code><%= execution.active_job_id %></code>
               <% end %>
             </td>
             <td>
-              <%= link_to active_job_path(execution.active_job_id, anchor: dom_id(execution)) do %>
+              <%= link_to job_path(execution.active_job_id, anchor: dom_id(execution)) do %>
                 <code><%= execution.id %></code>
               <% end %>
             </td>

data/engine/app/views/good_job/shared/_filter.erb

@@ -0,0 +1,52 @@
+<div class='card mb-2'>
+  <div class='card-body d-flex flex-wrap'>
+
+    <div class='me-4'>
+      <small>Filter by job class</small>
+      <br>
+      <% @filter.job_classes.each do |name, count| %>
+        <% if params[:job_class] == name %>
+          <%= link_to(@filter.to_params(job_class: nil), class: 'btn btn-sm btn-outline-secondary active', role: "button", "aria-pressed": true)  do %>
+            <%= name %> (<%= count %>)
+          <% end %>
+        <% else %>
+          <%= link_to(@filter.to_params(job_class: name), class: 'btn btn-sm btn-outline-secondary', role: "button") do %>
+            <%= name %> (<%= count %>)
+          <% end %>
+        <% end %>
+      <% end %>
+    </div>
+
+    <div class='me-4'>
+      <small>Filter by state</small>
+      <br>
+      <% @filter.states.each do |name, count| %>
+        <% if params[:state] == name %>
+          <%= link_to(@filter.to_params(state: nil), class: 'btn btn-sm btn-outline-secondary active', role: "button", "aria-pressed": true)  do %>
+            <%= name %> (<%= count %>)
+          <% end %>
+        <% else %>
+          <%= link_to(@filter.to_params(state: name), class: 'btn btn-sm btn-outline-secondary', role: "button") do %>
+            <%= name %> (<%= count %>)
+          <% end %>
+        <% end %>
+      <% end %>
+    </div>
+
+    <div>
+      <small>Filter by queue</small>
+      <br>
+      <% @filter.queues.each do |name, count| %>
+        <% if params[:queue_name] == name %>
+          <%= link_to(@filter.to_params(queue_name: nil), class: 'btn btn-sm btn-outline-secondary active', role: "button", "aria-pressed": true)  do %>
+            <%= name %> (<%= count %>)
+          <% end %>
+        <% else %>
+          <%= link_to(@filter.to_params(queue_name: name), class: 'btn btn-sm btn-outline-secondary', role: "button") do %>
+            <%= name %> (<%= count %>)
+          <% end %>
+        <% end %>
+      <% end %>
+    </div>
+  </div>
+</div>

data/engine/app/views/good_job/shared/_jobs_table.erb

@@ -0,0 +1,56 @@
+<div class="card my-3">
+  <div class="table-responsive">
+    <table class="table card-table table-bordered table-hover table-sm mb-0">
+      <thead>
+        <tr>
+          <th>ActiveJob ID</th>
+          <th>State</th>
+          <th>Job Class</th>
+          <th>Queue</th>
+          <th>Scheduled At</th>
+          <th>Executions</th>
+          <th>Error</th>
+          <th>
+            ActiveJob Params&nbsp;
+            <%= tag.button "Toggle", type: "button", class: "btn btn-sm btn-outline-primary", role: "button",
+                           data: { bs_toggle: "collapse", bs_target: ".job-params" },
+                           aria: { expanded: false, controls: jobs.map { |job| "##{dom_id(job, "params")}" }.join(" ") }
+            %>
+          </th>
+          <th>Actions</th>
+        </tr>
+      </thead>
+      <tbody>
+        <% jobs.each do |job| %>
+          <tr id="<%= dom_id(job) %>">
+            <td>
+              <%= link_to job_path(job.id) do %>
+                <code><%= job.id %></code>
+              <% end %>
+            </td>
+            <td>
+              <span class="badge bg-secondary"><%= job.status %></span>
+            </td>
+            <td><%= job.job_class %></td>
+            <td><%= job.queue_name %></td>
+            <td><%= job.scheduled_at || job.created_at %></td>
+            <td><%= job.executions_count %></td>
+            <td class="text-break"><%= truncate(job.recent_error, length: 1_000) %></td>
+            <td>
+              <%= tag.button "Preview", type: "button", class: "btn btn-sm btn-outline-primary", role: "button",
+                data: { bs_toggle: "collapse", bs_target: "##{dom_id(job, 'params')}" },
+                aria: { expanded: false, controls: dom_id(job, "params") }
+              %>
+              <%= tag.pre JSON.pretty_generate(job.serialized_params), id: dom_id(job, "params"), class: "collapse job-params" %>
+            </td>
+<!--            <td>-->
+              <%#= button_to execution_path(execution.id), method: :delete, class: "btn btn-sm btn-outline-danger", title: "Delete execution" do %>
+                <%#= render "good_job/shared/icons/trash" %>
+              <%# end %>
+<!--            </td>-->
+          </tr>
+        <% end %>
+      </tbody>
+    </table>
+  </div>
+</div>

data/engine/app/views/layouts/good_job/base.html.erb

@@ -25,6 +25,9 @@
           <li class="nav-item">
             <%= link_to "All Executions", root_path, class: ["nav-link", ("active" if current_page?(root_path))] %>
           </li>
+          <li class="nav-item">
+            <%= link_to "All Jobs", jobs_path, class: ["nav-link", ("active" if current_page?(jobs_path))] %>
+          </li>
           <li class="nav-item">
             <%= link_to "Cron Schedules", cron_schedules_path, class: ["nav-link", ("active" if current_page?(cron_schedules_path))] %>
           </li>

data/engine/config/routes.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 GoodJob::Engine.routes.draw do
-  root to: 'dashboards#index'
+  root to: 'executions#index'
   resources :cron_schedules, only: %i[index]
-  resources :active_jobs, only: %i[show]
+  resources :jobs, only: %i[index show]
   resources :executions, only: %i[destroy]
 
   scope controller: :assets do

data/lib/good_job/adapter.rb

@@ -101,14 +101,14 @@ module GoodJob
     # @return [Boolean]
     def execute_async?
       @configuration.execution_mode == :async_all ||
-        @configuration.execution_mode.in?([:async, :async_server]) && in_server_process?
+        (@configuration.execution_mode.in?([:async, :async_server]) && in_server_process?)
     end
 
     # Whether in +:external+ execution mode.
     # @return [Boolean]
     def execute_externally?
       @configuration.execution_mode == :external ||
-        @configuration.execution_mode.in?([:async, :async_server]) && !in_server_process?
+        (@configuration.execution_mode.in?([:async, :async_server]) && !in_server_process?)
     end
 
     # Whether in +:inline+ execution mode.

data/lib/good_job/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 module GoodJob
   # GoodJob gem version.
-  VERSION = '2.2.0'
+  VERSION = '2.3.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.3.0
 platform: ruby
 authors:
 - Ben Sheldon
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-09-15 00:00:00.000000000 Z
+date: 2021-09-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
@@ -351,18 +351,24 @@ files:
 - engine/app/assets/vendor/bootstrap/bootstrap.min.css
 - engine/app/assets/vendor/chartist/chartist.css
 - engine/app/assets/vendor/chartist/chartist.js
-- engine/app/controllers/good_job/active_jobs_controller.rb
 - engine/app/controllers/good_job/assets_controller.rb
 - engine/app/controllers/good_job/base_controller.rb
 - engine/app/controllers/good_job/cron_schedules_controller.rb
-- engine/app/controllers/good_job/dashboards_controller.rb
 - engine/app/controllers/good_job/executions_controller.rb
+- engine/app/controllers/good_job/jobs_controller.rb
+- engine/app/filters/good_job/base_filter.rb
+- engine/app/filters/good_job/executions_filter.rb
+- engine/app/filters/good_job/jobs_filter.rb
 - engine/app/helpers/good_job/application_helper.rb
-- engine/app/views/good_job/active_jobs/show.html.erb
+- engine/app/models/good_job/active_job_job.rb
 - engine/app/views/good_job/cron_schedules/index.html.erb
-- engine/app/views/good_job/dashboards/index.html.erb
+- engine/app/views/good_job/executions/index.html.erb
+- engine/app/views/good_job/jobs/index.html.erb
+- engine/app/views/good_job/jobs/show.html.erb
 - engine/app/views/good_job/shared/_chart.erb
 - engine/app/views/good_job/shared/_executions_table.erb
+- engine/app/views/good_job/shared/_filter.erb
+- engine/app/views/good_job/shared/_jobs_table.erb
 - engine/app/views/good_job/shared/icons/_check.html.erb
 - engine/app/views/good_job/shared/icons/_exclamation.html.erb
 - engine/app/views/good_job/shared/icons/_trash.html.erb

data/engine/app/controllers/good_job/dashboards_controller.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-module GoodJob
-  class DashboardsController < GoodJob::BaseController
-    class ExecutionFilter
-      attr_accessor :params
-
-      def initialize(params)
-        @params = params
-      end
-
-      def last
-        @_last ||= executions.last
-      end
-
-      def executions
-        after_scheduled_at = params[:after_scheduled_at].present? ? Time.zone.parse(params[:after_scheduled_at]) : nil
-        sql = GoodJob::Execution.display_all(after_scheduled_at: after_scheduled_at, after_id: params[:after_id])
-                                .limit(params.fetch(:limit, 25))
-        sql = sql.job_class(params[:job_class]) if params[:job_class]
-        if params[:state]
-          case params[:state]
-          when 'finished'
-            sql = sql.finished
-          when 'unfinished'
-            sql = sql.unfinished
-          when 'running'
-            sql = sql.running
-          when 'errors'
-            sql = sql.where.not(error: nil)
-          end
-        end
-        sql
-      end
-
-      def states
-        {
-          'finished' => GoodJob::Execution.finished.count,
-          'unfinished' => GoodJob::Execution.unfinished.count,
-          'running' => GoodJob::Execution.running.count,
-          'errors' => GoodJob::Execution.where.not(error: nil).count,
-        }
-      end
-
-      def job_classes
-        GoodJob::Execution.group("serialized_params->>'job_class'").count
-                          .sort_by { |name, _count| name }
-      end
-
-      def to_params(override)
-        {
-          state: params[:state],
-          job_class: params[:job_class],
-        }.merge(override).delete_if { |_, v| v.nil? }
-      end
-    end
-
-    def index
-      @filter = ExecutionFilter.new(params)
-
-      count_query = Arel.sql(GoodJob::Execution.pg_or_jdbc_query(<<~SQL.squish))
-        SELECT *
-        FROM generate_series(
-          date_trunc('hour', $1::timestamp),
-          date_trunc('hour', $2::timestamp),
-          '1 hour'
-        ) timestamp
-        LEFT JOIN (
-          SELECT
-              date_trunc('hour', scheduled_at) AS scheduled_at,
-              queue_name,
-              count(*) AS count
-            FROM (
-              SELECT
-                COALESCE(scheduled_at, created_at)::timestamp AS scheduled_at,
-                queue_name
-              FROM good_jobs
-            ) sources
-            GROUP BY date_trunc('hour', scheduled_at), queue_name
-        ) sources ON sources.scheduled_at = timestamp
-        ORDER BY timestamp ASC
-      SQL
-
-      current_time = Time.current
-      binds = [[nil, current_time - 1.day], [nil, current_time]]
-      executions_data = GoodJob::Execution.connection.exec_query(count_query, "GoodJob Dashboard Chart", binds)
-
-      queue_names = executions_data.map { |d| d['queue_name'] }.uniq
-      labels = []
-      queues_data = executions_data.to_a.group_by { |d| d['timestamp'] }.each_with_object({}) do |(timestamp, values), hash|
-        labels << timestamp.in_time_zone.strftime('%H:%M %z')
-        queue_names.each do |queue_name|
-          (hash[queue_name] ||= []) << values.find { |d| d['queue_name'] == queue_name }&.[]('count')
-        end
-      end
-
-      @chart = {
-        labels: labels,
-        series: queues_data.map do |queue, data|
-          {
-            name: queue,
-            data: data,
-          }
-        end,
-      }
-    end
-  end
-end

data/engine/app/views/good_job/dashboards/index.html.erb

@@ -1,54 +0,0 @@
-<div class="card my-3 p-6">
-  <%= render 'good_job/shared/chart', chart_data: @chart %>
-</div>
-
-<div class='card mb-2'>
-  <div class='card-body d-flex flex-wrap'>
-    <div class='me-4'>
-      <small>Filter by job class</small>
-      <br>
-      <% @filter.job_classes.each do |(name, count)| %>
-        <% if params[:job_class] == name %>
-          <%= link_to(root_path(@filter.to_params(job_class: nil)), class: 'btn btn-sm btn-outline-secondary active', role: "button", "aria-pressed": true)  do %>
-            <%= name %> (<%= count %>)
-          <% end %>
-        <% else %>
-          <%= link_to(root_path(@filter.to_params(job_class: name)), class: 'btn btn-sm btn-outline-secondary', role: "button") do %>
-            <%= name %> (<%= count %>)
-          <% end %>
-        <% end %>
-      <% end %>
-    </div>
-    <div>
-      <small>Filter by state</small>
-      <br>
-      <% @filter.states.each do |name, count| %>
-        <% if params[:state] == name %>
-          <%= link_to(root_path(@filter.to_params(state: nil)), class: 'btn btn-sm btn-outline-secondary active', role: "button", "aria-pressed": true)  do %>
-            <%= name %> (<%= count %>)
-          <% end %>
-        <% else %>
-          <%= link_to(root_path(@filter.to_params(state: name)), class: 'btn btn-sm btn-outline-secondary', role: "button") do %>
-            <%= name %> (<%= count %>)
-          <% end %>
-        <% end %>
-      <% end %>
-    </div>
-  </div>
-</div>
-
-<% if @filter.executions.present? %>
-  <%= render 'good_job/shared/executions_table', executions: @filter.executions %>
-
-  <nav aria-label="Job pagination" class="mt-3">
-    <ul class="pagination">
-      <li class="page-item">
-        <%= link_to({ after_scheduled_at: (@filter.last.scheduled_at || @filter.last.created_at), after_id: @filter.last.id }, class: "page-link") do %>
-          Older executions <span aria-hidden="true">&raquo;</span>
-        <% end %>
-      </li>
-    </ul>
-  </nav>
-<% else %>
-  <em>No executions present.</em>
-<% end %>