good_job 2.2.0 → 2.4.1

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,18 +23,18 @@
         <% 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>
             <td><%= execution.serialized_params['job_class'] %></td>
             <td><%= execution.queue_name %></td>
-            <td><%= execution.scheduled_at || execution.created_at %></td>
+            <td><%= relative_time(execution.scheduled_at || execution.created_at) %></td>
             <td class="text-break"><%= truncate(execution.error, length: 1_000) %></td>
             <td>
               <%= tag.button "Preview", type: "button", class: "btn btn-sm btn-outline-primary", role: "button",

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><%= relative_time(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>
@@ -46,6 +49,7 @@
             </li>
           -->
         </ul>
+        <div class="text-muted" title="Now is <%= Time.current %>">Times are displayed in <%= Time.current.zone %> timezone</div>
       </div>
     </div>
   </nav>
@@ -65,7 +69,7 @@
       </div>
     <% elsif alert %>
       <div class="alert alert-warning alert-dismissible fade show d-flex align-items-center offset-md-3 col-6" role="alert">
-        <%= render "good_job/shared/icons/check", class: "flex-shrink-0 me-2" %>
+        <%= render "good_job/shared/icons/exclamation", class: "flex-shrink-0 me-2" %>
         <div><%= alert %></div>
         <button type="button" class="btn-close" data-bs-dismiss="alert" aria-label="Close"></button>
       </div>

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

@@ -38,7 +38,7 @@ module GoodJob
         @notifier.recipients << [@scheduler, :create_thread]
         @poller.recipients << [@scheduler, :create_thread]
 
-        @cron_manager = GoodJob::CronManager.new(@configuration.cron, start_on_initialize: Rails.application.initialized?) if @configuration.enable_cron?
+        @cron_manager = GoodJob::CronManager.new(@configuration.cron_entries, start_on_initialize: Rails.application.initialized?) if @configuration.enable_cron?
       end
     end
 
@@ -64,10 +64,12 @@ module GoodJob
 
       if execute_inline?
         begin
-          execution.perform
+          result = execution.perform
         ensure
           execution.advisory_unlock
         end
+
+        raise result.unhandled_error if result.unhandled_error
       else
         job_state = { queue_name: execution.queue_name }
         job_state[:scheduled_at] = execution.scheduled_at if execution.scheduled_at
@@ -101,14 +103,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/cli.rb

@@ -91,7 +91,9 @@ module GoodJob
       scheduler = GoodJob::Scheduler.from_configuration(configuration, warm_cache_on_initialize: true)
       notifier.recipients << [scheduler, :create_thread]
       poller.recipients << [scheduler, :create_thread]
-      cron_manager = GoodJob::CronManager.new(configuration.cron, start_on_initialize: true) if configuration.enable_cron?
+
+      cron_manager = GoodJob::CronManager.new(configuration.cron_entries, start_on_initialize: true) if configuration.enable_cron?
+
       @stop_good_job_executable = false
       %w[INT TERM].each do |signal|
         trap(signal) { @stop_good_job_executable = true }

data/lib/good_job/configuration.rb

@@ -165,6 +165,10 @@ module GoodJob
         {}
     end
 
+    def cron_entries
+      cron.map { |cron_key, params| GoodJob::CronEntry.new(params.merge(key: cron_key)) }
+    end
+
     # Number of seconds to preserve jobs when using the +good_job cleanup_preserved_jobs+ CLI command.
     # This configuration is only used when {GoodJob.preserve_job_records} is +true+.
     # @return [Integer]

data/lib/good_job/cron_entry.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+require "concurrent/hash"
+require "concurrent/scheduled_task"
+require "fugit"
+
+module GoodJob # :nodoc:
+  #
+  # A CronEntry represents a single scheduled item's properties.
+  #
+  class CronEntry
+    include ActiveModel::Model
+
+    attr_reader :params
+
+    def initialize(params = {})
+      @params = params.with_indifferent_access
+    end
+
+    def key
+      params.fetch(:key)
+    end
+    alias id key
+
+    def job_class
+      params.fetch(:class)
+    end
+
+    def cron
+      params.fetch(:cron)
+    end
+
+    def set
+      params[:set]
+    end
+
+    def args
+      params[:args]
+    end
+
+    def description
+      params[:description]
+    end
+
+    def next_at
+      fugit = Fugit::Cron.parse(cron)
+      fugit.next_time
+    end
+
+    def enqueue
+      job_class.constantize.set(set_value).perform_later(*args_value)
+    end
+
+    private
+
+    def set_value
+      value = set || {}
+      value.respond_to?(:call) ? value.call : value
+    end
+
+    def args_value
+      value = args || []
+      value.respond_to?(:call) ? value.call : value
+    end
+  end
+end

data/lib/good_job/cron_manager.rb

@@ -11,7 +11,7 @@ module GoodJob # :nodoc:
     # @!attribute [r] instances
     #   @!scope class
     #   List of all instantiated CronManagers in the current process.
-    #   @return [Array<GoodJob::CronManagers>, nil]
+    #   @return [Array<GoodJob::CronManager>, nil]
     cattr_reader :instances, default: [], instance_reader: false
 
     # Task observer for cron task
@@ -26,13 +26,13 @@ module GoodJob # :nodoc:
 
     # Execution configuration to be scheduled
     # @return [Hash]
-    attr_reader :schedules
+    attr_reader :cron_entries
 
-    # @param schedules [Hash]
+    # @param cron_entries [Array<CronEntry>]
     # @param start_on_initialize [Boolean]
-    def initialize(schedules = {}, start_on_initialize: false)
+    def initialize(cron_entries = [], start_on_initialize: false)
       @running = false
-      @schedules = schedules
+      @cron_entries = cron_entries
       @tasks = Concurrent::Hash.new
 
       self.class.instances << self
@@ -42,9 +42,11 @@ module GoodJob # :nodoc:
 
     # Schedule tasks that will enqueue jobs based on their schedule
     def start
-      ActiveSupport::Notifications.instrument("cron_manager_start.good_job", cron_jobs: @schedules) do
+      ActiveSupport::Notifications.instrument("cron_manager_start.good_job", cron_entries: cron_entries) do
         @running = true
-        schedules.each_key { |cron_key| create_task(cron_key) }
+        cron_entries.each do |cron_entry|
+          create_task(cron_entry)
+        end
       end
     end
 
@@ -78,36 +80,22 @@ module GoodJob # :nodoc:
     end
 
     # Enqueues a scheduled task
-    # @param cron_key [Symbol, String] the key within the schedule to use
-    def create_task(cron_key)
-      schedule = @schedules[cron_key]
-      return false if schedule.blank?
-
-      fugit = Fugit::Cron.parse(schedule.fetch(:cron))
-      delay = [(fugit.next_time - Time.current).to_f, 0].max
-
-      future = Concurrent::ScheduledTask.new(delay, args: [self, cron_key]) do |thr_scheduler, thr_cron_key|
+    # @param cron_entry [CronEntry] the CronEntry object to schedule
+    def create_task(cron_entry)
+      delay = [(cron_entry.next_at - Time.current).to_f, 0].max
+      future = Concurrent::ScheduledTask.new(delay, args: [self, cron_entry]) do |thr_scheduler, thr_cron_entry|
         # Re-schedule the next cron task before executing the current task
-        thr_scheduler.create_task(thr_cron_key)
-
-        CurrentThread.reset
-        CurrentThread.cron_key = thr_cron_key
+        thr_scheduler.create_task(thr_cron_entry)
 
         Rails.application.executor.wrap do
-          schedule = thr_scheduler.schedules.fetch(thr_cron_key).with_indifferent_access
-          job_class = schedule.fetch(:class).constantize
-
-          job_set_value = schedule.fetch(:set, {})
-          job_set = job_set_value.respond_to?(:call) ? job_set_value.call : job_set_value
-
-          job_args_value = schedule.fetch(:args, [])
-          job_args = job_args_value.respond_to?(:call) ? job_args_value.call : job_args_value
+          CurrentThread.reset
+          CurrentThread.cron_key = thr_cron_entry.key
 
-          job_class.set(job_set).perform_later(*job_args)
+          cron_entry.enqueue
         end
       end
 
-      @tasks[cron_key] = future
+      @tasks[cron_entry.key] = future
       future.add_observer(self.class, :task_observer)
       future.execute
     end

data/lib/good_job/log_subscriber.rb

@@ -59,11 +59,11 @@ module GoodJob
 
     # @!macro notification_responder
     def cron_manager_start(event)
-      cron_jobs = event.payload[:cron_jobs]
-      cron_jobs_count = cron_jobs.size
+      cron_entries = event.payload[:cron_entries]
+      cron_jobs_count = cron_entries.size
 
       info do
-        "GoodJob started cron with #{cron_jobs_count} #{'jobs'.pluralize(cron_jobs_count)}."
+        "GoodJob started cron with #{cron_jobs_count} #{'job'.pluralize(cron_jobs_count)}."
       end
     end
 

data/lib/good_job/scheduler.rb

@@ -230,7 +230,8 @@ module GoodJob # :nodoc:
     # @return [void]
     def create_task(delay = 0)
       future = Concurrent::ScheduledTask.new(delay, args: [performer], executor: executor, timer_set: timer_set) do |thr_performer|
-        Rails.application.executor.wrap do
+        Thread.current.name = Thread.current.name.sub("-worker-", "-thread-") if Thread.current.name
+        Rails.application.reloader.wrap do
           thr_performer.next
         end
       end

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.4.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.4.1
 platform: ruby
 authors:
 - Ben Sheldon
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-09-15 00:00:00.000000000 Z
+date: 2021-10-11 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
@@ -381,6 +387,7 @@ files:
 - lib/good_job/adapter.rb
 - lib/good_job/cli.rb
 - lib/good_job/configuration.rb
+- lib/good_job/cron_entry.rb
 - lib/good_job/cron_manager.rb
 - lib/good_job/current_thread.rb
 - lib/good_job/daemon.rb

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