good_job 2.4.2 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f06b525450f56cf74ff31e06e11cbf3bf2ee7f20d753973e70ddb53d67eb48d1
-  data.tar.gz: d25d2037ae03eaea0ff8bd4ca1dfa52ba6a57d3420e53b4be265dc7c0be580cb
+  metadata.gz: 5a173683ec5e5879728536005c7dfd11827ffe87c268c59315f540911277f2df
+  data.tar.gz: a5990d902838da25344ff96fc859bad39803f70f888dd95de8e3e6c201da4b0f
 SHA512:
-  metadata.gz: 2f2be221d400f0dc7a1e7c2d262b717ecd9c88a5192771df2bd343d61e878cb777af7e067814e3e7c751aa28716c2bd487b4389ef4dbbea17cc2a6a0f23d0c9a
-  data.tar.gz: abfd020a2203bb573c5e801e7f278214ebe996b6e63970ec60313fcb37a3b21cb901d4cf57cfd6739b7c247ea692ff7de012df3668d7c551d7ced78cc48b79e6
+  metadata.gz: 92378343ecf6f3750a98ac1e146c748e7440b267fad30ac04eaf984649e5640fad8cfdd58b9c627bb7f7792202a849222ee7ed7583b7ac847f2d15839c25519f
+  data.tar.gz: f093bda085b00d82210e9bcf02ed6e39fec556aeeaa17c6f73a9465119867833f3145905482a20ec57840ae6bb6fa350f79e64209425cef8db9f45c0b59c4ea0

data/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## [v2.5.0](https://github.com/bensheldon/good_job/tree/v2.5.0) (2021-10-25)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v2.4.2...v2.5.0)
+
+**Implemented enhancements:**
+
+- Add Reschedule, Discard, Retry Job buttons to Dashboard [\#425](https://github.com/bensheldon/good_job/pull/425) ([bensheldon](https://github.com/bensheldon))
+- Use unique index on \[cron\_key, cron\_at\] columns to prevent duplicate cron jobs from being enqueued [\#423](https://github.com/bensheldon/good_job/pull/423) ([bensheldon](https://github.com/bensheldon))
+
+**Fixed bugs:**
+
+- Dashboard fix preservation of `limit` and `queue_name` filter params; add pager to jobs [\#434](https://github.com/bensheldon/good_job/pull/434) ([bensheldon](https://github.com/bensheldon))
+
+**Closed issues:**
+
+- PgLock state inspection is not isolated to current database  [\#431](https://github.com/bensheldon/good_job/issues/431)
+- Race condition with concurency control [\#378](https://github.com/bensheldon/good_job/issues/378)
+
+**Merged pull requests:**
+
+- Add Readme note about race conditions in Concurrency's `enqueue\_limit` and `perform\_limit [\#433](https://github.com/bensheldon/good_job/pull/433) ([bensheldon](https://github.com/bensheldon))
+- Test harness should only force-unlock db connections for the current database [\#430](https://github.com/bensheldon/good_job/pull/430) ([bensheldon](https://github.com/bensheldon))
+
 ## [v2.4.2](https://github.com/bensheldon/good_job/tree/v2.4.2) (2021-10-19)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v2.4.1...v2.4.2)

data/README.md

@@ -363,11 +363,19 @@ class MyJob < ApplicationJob
     total_limit: 1,
 
     # Or, if more control is needed:
-    # Maximum number of jobs with the concurrency key to be concurrently enqueued (excludes performing jobs)
+    # Maximum number of jobs with the concurrency key to be
+    # concurrently enqueued (excludes performing jobs)
     enqueue_limit: 2,
-    # Maximum number of jobs with the concurrency key to be concurrently performed (excludes enqueued jobs)
+
+    # Maximum number of jobs with the concurrency key to be
+    # concurrently performed (excludes enqueued jobs)
     perform_limit: 1,
 
+    # Note: Under heavy load, the total number of jobs may exceed the
+    # sum of `enqueue_limit` and `perform_limit` because of race conditions
+    # caused by imperfectly disjunctive states. If you need to constrain
+    # the total number of jobs, use `total_limit` instead. See #378.
+
     # A unique key to be globally locked against.
     # Can be String or Lambda/Proc that is invoked in the context of the job.
     # Note: Arguments passed to #perform_later must be accessed through `arguments` method.
@@ -391,7 +399,7 @@ job.good_job_concurrency_key #=> "Unique-Alice"
 
 GoodJob can enqueue jobs on a recurring basis that can be used as a replacement for cron.
 
-Cron-style jobs are run on every GoodJob process (e.g. CLI or `async` execution mode) when `config.good_job.enable_cron = true`; use GoodJob's [ActiveJob concurrency](#activejob-concurrency) extension to limit the number of jobs that are enqueued.
+Cron-style jobs are run on every GoodJob process (e.g. CLI or `async` execution mode) when `config.good_job.enable_cron = true`, but GoodJob's cron uses unique indexes to ensure that only a single job is enqeued at the given time interval.
 
 Cron-format is parsed by the [`fugit`](https://github.com/floraison/fugit) gem, which has support for seconds-level resolution (e.g. `* * * * * *`).
 

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

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 module GoodJob
   class JobsController < GoodJob::BaseController
+    rescue_from GoodJob::ActiveJobJob::AdapterNotGoodJobError,
+                GoodJob::ActiveJobJob::ActionForStateMismatchError,
+                with: :redirect_on_error
+
     def index
       @filter = JobsFilter.new(params)
     end
@@ -10,5 +14,37 @@ module GoodJob
                                       .order(Arel.sql("COALESCE(scheduled_at, created_at) DESC"))
       redirect_to root_path, alert: "Executions for Active Job #{params[:id]} not found" if @executions.empty?
     end
+
+    def discard
+      @job = ActiveJobJob.find(params[:id])
+      @job.discard_job("Discarded through dashboard")
+      redirect_back(fallback_location: jobs_path, notice: "Job has been discarded")
+    end
+
+    def reschedule
+      @job = ActiveJobJob.find(params[:id])
+      @job.reschedule_job
+      redirect_back(fallback_location: jobs_path, notice: "Job has been rescheduled")
+    end
+
+    def retry
+      @job = ActiveJobJob.find(params[:id])
+      @job.retry_job
+      redirect_back(fallback_location: jobs_path, notice: "Job has been retried")
+    end
+
+    private
+
+    def redirect_on_error(exception)
+      alert = case exception
+              when GoodJob::ActiveJobJob::AdapterNotGoodJobError
+                "ActiveJob Queue Adapter must be GoodJob."
+              when GoodJob::ActiveJobJob::ActionForStateMismatchError
+                "Job is not in an appropriate state for this action."
+              else
+                exception.to_s
+              end
+      redirect_back(fallback_location: jobs_path, alert: alert)
+    end
   end
 end

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

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 module GoodJob
   class BaseFilter
+    DEFAULT_LIMIT = 25
+
     attr_accessor :params
 
     def initialize(params)
@@ -13,7 +15,7 @@ module GoodJob
       filtered_query.display_all(
         after_scheduled_at: after_scheduled_at,
         after_id: params[:after_id]
-      ).limit(params.fetch(:limit, 25))
+      ).limit(params.fetch(:limit, DEFAULT_LIMIT))
     end
 
     def last
@@ -38,8 +40,10 @@ module GoodJob
 
     def to_params(override)
       {
-        state: params[:state],
         job_class: params[:job_class],
+        limit: params[:limit],
+        queue_name: params[:queue_name],
+        state: params[:state],
       }.merge(override).delete_if { |_, v| v.nil? }
     end
 

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

@@ -19,7 +19,9 @@ module GoodJob
     end
 
     def filtered_query
-      query = base_query
+      query = base_query.includes(:executions)
+                        .joins_advisory_locks.select('good_jobs.*', 'pg_locks.locktype AS locktype')
+
       query = query.job_class(params[:job_class]) if params[:job_class]
       query = query.where(queue_name: params[:queue_name]) if params[:queue_name]
 

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

@@ -1,13 +1,22 @@
 # 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.
+  # There is not a table in the database whose discrete rows represents "Jobs".
+  # The +good_jobs+ table is a table of individual {GoodJob::Execution}s that share the same +active_job_id+.
+  # A single row from the +good_jobs+ table of executions is fetched to represent an ActiveJobJob
   # 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
 
+    # Raised when an inappropriate action is applied to a Job based on its state.
+    ActionForStateMismatchError = Class.new(StandardError)
+    # Raised when an action requires GoodJob to be the ActiveJob Queue Adapter but GoodJob is not.
+    AdapterNotGoodJobError = Class.new(StandardError)
+    # Attached to a Job's Execution when the Job is discarded.
+    DiscardJobError = Class.new(StandardError)
+
     self.table_name = 'good_jobs'
     self.primary_key = 'active_job_id'
     self.advisory_lockable_column = 'active_job_id'
@@ -56,27 +65,41 @@ module GoodJob
       query
     end)
 
+    # The job's ActiveJob UUID
+    # @return [String]
     def id
       active_job_id
     end
 
-    def _execution_id
-      attributes['id']
-    end
-
+    # The ActiveJob job class, as a string
+    # @return [String]
     def job_class
       serialized_params['job_class']
     end
 
+    # The status of the Job, based on the state of its most recent execution.
+    # There are 3 buckets of non-overlapping statuses:
+    #   1. The job will be executed
+    #     - queued: The job will execute immediately when an execution thread becomes available.
+    #     - scheduled: The job is scheduled to execute in the future.
+    #     - retried: The job previously errored on execution and will be re-executed in the future.
+    #   2. The job is being executed
+    #     - running: the job is actively being executed by an execution thread
+    #   3. The job will not execute
+    #     - finished: The job executed successfully
+    #     - discarded: The job previously errored on execution and will not be re-executed in the future.
+    #
+    # @return [Symbol]
     def status
-      if finished_at.present?
-        if error.present?
+      execution = head_execution
+      if execution.finished_at.present?
+        if execution.error.present?
           :discarded
         else
           :finished
         end
-      elsif (scheduled_at || created_at) > DateTime.current
-        if serialized_params.fetch('executions', 0) > 1
+      elsif (execution.scheduled_at || execution.created_at) > DateTime.current
+        if execution.serialized_params.fetch('executions', 0) > 1
           :retried
         else
           :scheduled
@@ -88,16 +111,25 @@ module GoodJob
       end
     end
 
-    def head_execution
+    # This job's most recent {Execution}
+    # @param reload [Booelan] whether to reload executions
+    # @return [Execution]
+    def head_execution(reload: false)
+      executions.reload if reload
+      executions.load # memoize the results
       executions.last
     end
 
+    # This job's initial/oldest {Execution}
+    # @return [Execution]
     def tail_execution
       executions.first
     end
 
+    # The number of times this job has been executed, according to ActiveJob's serialized state.
+    # @return [Numeric]
     def executions_count
-      aj_count = serialized_params.fetch('executions', 0)
+      aj_count = head_execution.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]
@@ -107,14 +139,21 @@ module GoodJob
       end
     end
 
+    # The number of times this job has been executed, according to the number of GoodJob {Execution} records.
+    # @return [Numeric]
     def preserved_executions_count
       executions.size
     end
 
+    # The most recent error message.
+    # If the job has been retried, the error will be fetched from the previous {Execution} record.
+    # @return [String]
     def recent_error
-      error.presence || executions[-2]&.error
+      head_execution.error || executions[-2]&.error
     end
 
+    # Tests whether the job is being executed right now.
+    # @return [Boolean]
     def running?
       # Avoid N+1 Query: `.joins_advisory_locks.select('good_jobs.*', 'pg_locks.locktype AS locktype')`
       if has_attribute?(:locktype)
@@ -123,5 +162,84 @@ module GoodJob
         advisory_locked?
       end
     end
+
+    # Retry a job that has errored and been discarded.
+    # This action will create a new job {Execution} record.
+    # @return [ActiveJob::Base]
+    def retry_job
+      with_advisory_lock do
+        execution = head_execution(reload: true)
+        active_job = execution.active_job
+
+        raise AdapterNotGoodJobError unless active_job.class.queue_adapter.is_a? GoodJob::Adapter
+        raise ActionForStateMismatchError unless status == :discarded
+
+        # Update the executions count because the previous execution will not have been preserved
+        # Do not update `exception_executions` because that comes from rescue_from's arguments
+        active_job.executions = (active_job.executions || 0) + 1
+
+        new_active_job = nil
+        GoodJob::CurrentThread.within do |current_thread|
+          current_thread.execution = execution
+
+          execution.class.transaction(joinable: false, requires_new: true) do
+            new_active_job = active_job.retry_job(wait: 0, error: error)
+            execution.save
+          end
+        end
+        new_active_job
+      end
+    end
+
+    # Discard a job so that it will not be executed further.
+    # This action will add a {DiscardJobError} to the job's {Execution} and mark it as finished.
+    # @return [void]
+    def discard_job(message)
+      with_advisory_lock do
+        raise ActionForStateMismatchError unless status.in? [:scheduled, :queued, :retried]
+
+        execution = head_execution(reload: true)
+        active_job = execution.active_job
+
+        job_error = GoodJob::ActiveJobJob::DiscardJobError.new(message)
+
+        update_execution = proc do
+          execution.update(
+            finished_at: Time.current,
+            error: [job_error.class, GoodJob::Execution::ERROR_MESSAGE_SEPARATOR, job_error.message].join
+          )
+        end
+
+        if active_job.respond_to?(:instrument)
+          active_job.send :instrument, :discard, error: job_error, &update_execution
+        else
+          update_execution.call
+        end
+      end
+    end
+
+    # Reschedule a scheduled job so that it executes immediately (or later) by the next available execution thread.
+    # @param scheduled_at [DateTime, Time] When to reschedule the job
+    # @return [void]
+    def reschedule_job(scheduled_at = Time.current)
+      with_advisory_lock do
+        raise ActionForStateMismatchError unless status.in? [:scheduled, :queued, :retried]
+
+        execution = head_execution(reload: true)
+        execution.update(scheduled_at: scheduled_at)
+      end
+    end
+
+    # Utility method to determine which execution record is used to represent this job
+    # @return [String]
+    def _execution_id
+      attributes['id']
+    end
+
+    # Utility method to test whether this job's underlying attributes represents its most recent execution.
+    # @return [Boolean]
+    def _head?
+      _execution_id == head_execution(reload: true).id
+    end
   end
 end

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

@@ -60,7 +60,7 @@
               </td>
               <td class="font-monospace"><%= cron_entry.job_class %></td>
               <td><%= cron_entry.description %></td>
-              <td><%= cron_entry.next_at.to_local_time %></td>
+              <td><%= cron_entry.next_at %></td>
             </tr>
           <% end %>
         </tbody>

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

@@ -4,4 +4,17 @@
 
 <%= render 'good_job/shared/filter', filter: @filter %>
 
-<%= render 'good_job/shared/jobs_table', jobs: @filter.records %>
+<% if @filter.records.present? %>
+  <%= render 'good_job/shared/jobs_table', jobs: @filter.records %>
+  <nav aria-label="Job pagination" class="mt-3">
+    <ul class="pagination">
+      <li class="page-item">
+        <%= link_to(@filter.to_params(after_scheduled_at: (@filter.last.scheduled_at || @filter.last.created_at), after_id: @filter.last.id), class: "page-link") do %>
+          Older jobs <span aria-hidden="true">&raquo;</span>
+        <% end %>
+      </li>
+    </ul>
+  </nav>
+<% else %>
+  <em>No jobs present.</em>
+<% end %>

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

@@ -43,11 +43,23 @@
               %>
               <%= 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>-->
+            <td>
+              <div class="text-nowrap">
+                <% job_reschedulable = job.status.in? [:scheduled, :retried, :queued] %>
+                <%= button_to reschedule_job_path(job.id), method: :put, class: "btn btn-sm #{job_reschedulable ? 'btn-outline-primary' : 'btn-outline-secondary'}", form_class: "d-inline-block", disabled: !job_reschedulable, aria: { label: "Reschedule job" }, title: "Reschedule job" do %>
+                  <%= render "good_job/shared/icons/skip_forward" %>
+                <% end %>
+
+                <% job_discardable = job.status.in? [:scheduled, :retried, :queued] %>
+                <%= button_to discard_job_path(job.id), method: :put, class: "btn btn-sm #{job_discardable ? 'btn-outline-primary' : 'btn-outline-secondary'}", form_class: "d-inline-block", disabled: !job_discardable, aria: { label: "Discard job" }, title: "Discard job" do %>
+                  <%= render "good_job/shared/icons/stop" %>
+                <% end %>
+
+                <%= button_to retry_job_path(job.id), method: :put, class: "btn btn-sm #{job.status == :discarded ? 'btn-outline-primary' : 'btn-outline-secondary'}", form_class: "d-inline-block", disabled: job.status != :discarded, aria: { label: "Retry job" }, title: "Retry job" do %>
+                  <%= render "good_job/shared/icons/arrow_clockwise" %>
+                <% end %>
+              </div>
+            </td>
           </tr>
         <% end %>
       </tbody>

data/engine/app/views/good_job/shared/icons/_arrow_clockwise.html.erb

@@ -0,0 +1,5 @@
+<!-- https://icons.getbootstrap.com/icons/arrow-clockwise/ -->
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" class="bi bi-arrow-clockwise" viewBox="0 0 16 16">
+  <path fill-rule="evenodd" d="M8 3a5 5 0 1 0 4.546 2.914.5.5 0 0 1 .908-.417A6 6 0 1 1 8 2v1z" />
+  <path d="M8 4.466V.534a.25.25 0 0 1 .41-.192l2.36 1.966c.12.1.12.284 0 .384L8.41 4.658A.25.25 0 0 1 8 4.466z" />
+</svg>

data/engine/app/views/good_job/shared/icons/_skip_forward.html.erb

@@ -0,0 +1,4 @@
+<!-- https://icons.getbootstrap.com/icons/skip-forward/ -->
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" class="bi bi-skip-forward" viewBox="0 0 16 16">
+  <path d="M15.5 3.5a.5.5 0 0 1 .5.5v8a.5.5 0 0 1-1 0V8.752l-6.267 3.636c-.52.302-1.233-.043-1.233-.696v-2.94l-6.267 3.636C.713 12.69 0 12.345 0 11.692V4.308c0-.653.713-.998 1.233-.696L7.5 7.248v-2.94c0-.653.713-.998 1.233-.696L15 7.248V4a.5.5 0 0 1 .5-.5zM1 4.633v6.734L6.804 8 1 4.633zm7.5 0v6.734L14.304 8 8.5 4.633z" />
+</svg>

data/engine/app/views/good_job/shared/icons/_stop.html.erb

@@ -0,0 +1,4 @@
+<!-- https://icons.getbootstrap.com/icons/stop/ -->
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" class="bi bi-stop" viewBox="0 0 16 16">
+  <path d="M3.5 5A1.5 1.5 0 0 1 5 3.5h6A1.5 1.5 0 0 1 12.5 5v6a1.5 1.5 0 0 1-1.5 1.5H5A1.5 1.5 0 0 1 3.5 11V5zM5 4.5a.5.5 0 0 0-.5.5v6a.5.5 0 0 0 .5.5h6a.5.5 0 0 0 .5-.5V5a.5.5 0 0 0-.5-.5H5z" />
+</svg>

data/engine/config/routes.rb

@@ -2,7 +2,13 @@
 GoodJob::Engine.routes.draw do
   root to: 'executions#index'
   resources :cron_schedules, only: %i[index]
-  resources :jobs, only: %i[index show]
+  resources :jobs, only: %i[index show] do
+    member do
+      put :discard
+      put :reschedule
+      put :retry
+    end
+  end
   resources :executions, only: %i[destroy]
 
   scope controller: :assets do

data/lib/generators/good_job/templates/install/migrations/create_good_jobs.rb.erb

@@ -18,6 +18,7 @@ class CreateGoodJobs < ActiveRecord::Migration<%= migration_version %>
       t.text :concurrency_key
       t.text :cron_key
       t.uuid :retried_good_job_id
+      t.timestamp :cron_at
     end
 
     add_index :good_jobs, :scheduled_at, where: "(finished_at IS NULL)", name: "index_good_jobs_on_scheduled_at"
@@ -25,5 +26,6 @@ class CreateGoodJobs < ActiveRecord::Migration<%= migration_version %>
     add_index :good_jobs, [:active_job_id, :created_at], name: :index_good_jobs_on_active_job_id_and_created_at
     add_index :good_jobs, :concurrency_key, where: "(finished_at IS NULL)", name: :index_good_jobs_on_concurrency_key_when_unfinished
     add_index :good_jobs, [:cron_key, :created_at], name: :index_good_jobs_on_cron_key_and_created_at
+    add_index :good_jobs, [:cron_key, :cron_at], name: :index_good_jobs_on_cron_key_and_cron_at, unique: true
   end
 end

data/lib/generators/good_job/templates/update/migrations/02_add_cron_at_to_good_jobs.rb.erb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+class AddCronAtToGoodJobs < ActiveRecord::Migration<%= migration_version %>
+  def change
+    reversible do |dir|
+      dir.up do
+        # Ensure this incremental update migration is idempotent
+        # with monolithic install migration.
+        return if connection.column_exists?(:good_jobs, :cron_at)
+      end
+    end
+
+    add_column :good_jobs, :cron_at, :timestamp
+  end
+end

data/lib/generators/good_job/templates/update/migrations/03_add_cron_key_cron_at_index_to_good_jobs.rb.erb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+class AddCronKeyCronAtIndexToGoodJobs < ActiveRecord::Migration<%= migration_version %>
+  disable_ddl_transaction!
+
+  def change
+    reversible do |dir|
+      dir.up do
+        # Ensure this incremental update migration is idempotent
+        # with monolithic install migration.
+        return if connection.index_name_exists?(:good_jobs, :index_good_jobs_on_cron_key_and_cron_at)
+      end
+    end
+
+    add_index :good_jobs,
+              [:cron_key, :cron_at],
+              algorithm: :concurrently,
+              name: :index_good_jobs_on_cron_key_and_cron_at,
+              unique: true
+  end
+end

data/lib/good_job/cron_entry.rb

@@ -43,11 +43,13 @@ module GoodJob # :nodoc:
 
     def next_at
       fugit = Fugit::Cron.parse(cron)
-      fugit.next_time
+      fugit.next_time.to_t
     end
 
     def enqueue
       job_class.constantize.set(set_value).perform_later(*args_value)
+    rescue ActiveRecord::RecordNotUnique
+      false
     end
 
     private

data/lib/good_job/cron_manager.rb

@@ -82,14 +82,16 @@ module GoodJob # :nodoc:
     # Enqueues a scheduled task
     # @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|
+      cron_at = cron_entry.next_at
+      delay = [(cron_at - Time.current).to_f, 0].max
+      future = Concurrent::ScheduledTask.new(delay, args: [self, cron_entry, cron_at]) do |thr_scheduler, thr_cron_entry, thr_cron_at|
         # Re-schedule the next cron task before executing the current task
         thr_scheduler.create_task(thr_cron_entry)
 
         Rails.application.executor.wrap do
           CurrentThread.reset
           CurrentThread.cron_key = thr_cron_entry.key
+          CurrentThread.cron_at = thr_cron_at
 
           cron_entry.enqueue
         end

data/lib/good_job/current_thread.rb

@@ -5,6 +5,12 @@ module GoodJob
   # Thread-local attributes for passing values from Instrumentation.
   # (Cannot use ActiveSupport::CurrentAttributes because ActiveJob resets it)
   module CurrentThread
+    # @!attribute [rw] cron_at
+    #   @!scope class
+    #   Cron At
+    #   @return [DateTime, nil]
+    thread_mattr_accessor :cron_at
+
     # @!attribute [rw] cron_key
     #   @!scope class
     #   Cron Key
@@ -32,6 +38,7 @@ module GoodJob
     # Resets attributes
     # @return [void]
     def self.reset
+      self.cron_at = nil
       self.cron_key = nil
       self.execution = nil
       self.error_on_discard = nil
@@ -52,5 +59,13 @@ module GoodJob
     def self.thread_name
       (Thread.current.name || Thread.current.object_id).to_s
     end
+
+    # @return [void]
+    def self.within
+      reset
+      yield(self)
+    ensure
+      reset
+    end
   end
 end

data/lib/good_job/execution.rb

@@ -10,6 +10,9 @@ module GoodJob
     # Raised if something attempts to execute a previously completed Execution again.
     PreviouslyPerformedError = Class.new(StandardError)
 
+    # String separating Error Class from Error Message
+    ERROR_MESSAGE_SEPARATOR = ": "
+
     # ActiveJob jobs without a +queue_name+ attribute are placed on this queue.
     DEFAULT_QUEUE_NAME = 'default'
     # ActiveJob jobs without a +priority+ attribute are given this priority.
@@ -50,6 +53,16 @@ module GoodJob
       end
     end
 
+    def self._migration_pending_warning
+      ActiveSupport::Deprecation.warn(<<~DEPRECATION)
+        GoodJob has pending database migrations. To create the migration files, run:
+            rails generate good_job:update
+        To apply the migration files, run:
+            rails db:migrate
+      DEPRECATION
+      nil
+    end
+
     # Get Jobs with given ActiveJob ID
     # @!method active_job_id
     # @!scope class
@@ -222,7 +235,15 @@ module GoodJob
 
         if CurrentThread.cron_key
           execution_args[:cron_key] = CurrentThread.cron_key
-        elsif CurrentThread.active_job_id == active_job.job_id
+
+          @cron_at_index = column_names.include?('cron_at') && connection.index_name_exists?(:good_jobs, :index_good_jobs_on_cron_key_and_cron_at) unless instance_variable_defined?(:@cron_at_index)
+
+          if @cron_at_index
+            execution_args[:cron_at] = CurrentThread.cron_at
+          else
+            _migration_pending_warning
+          end
+        elsif CurrentThread.active_job_id && CurrentThread.active_job_id == active_job.job_id
           execution_args[:cron_key] = CurrentThread.execution.cron_key
         end
 
@@ -233,7 +254,7 @@ module GoodJob
         execution.save!
         active_job.provider_job_id = execution.id
 
-        CurrentThread.execution.retried_good_job_id = execution.id if CurrentThread.execution && CurrentThread.execution.active_job_id == active_job.job_id
+        CurrentThread.execution.retried_good_job_id = execution.id if CurrentThread.active_job_id && CurrentThread.active_job_id == active_job.job_id
 
         execution
       end
@@ -253,7 +274,7 @@ module GoodJob
       result = execute
 
       job_error = result.handled_error || result.unhandled_error
-      self.error = "#{job_error.class}: #{job_error.message}" if job_error
+      self.error = [job_error.class, ERROR_MESSAGE_SEPARATOR, job_error.message].join if job_error
 
       if result.unhandled_error && GoodJob.retry_on_unhandled_error
         save!
@@ -273,19 +294,27 @@ module GoodJob
       self.class.unscoped.unfinished.owns_advisory_locked.exists?(id: id)
     end
 
+    def active_job
+      ActiveJob::Base.deserialize(active_job_data)
+    end
+
     private
 
+    def active_job_data
+      serialized_params.deep_dup
+                       .tap do |job_data|
+        job_data["provider_job_id"] = id
+      end
+    end
+
     # @return [ExecutionResult]
     def execute
       GoodJob::CurrentThread.reset
       GoodJob::CurrentThread.execution = self
 
-      job_data = serialized_params.deep_dup
-      job_data["provider_job_id"] = id
-
       # DEPRECATION: Remove deprecated `good_job:` parameter in GoodJob v3
       ActiveSupport::Notifications.instrument("perform_job.good_job", { good_job: self, execution: self, process_id: GoodJob::CurrentThread.process_id, thread_name: GoodJob::CurrentThread.thread_name }) do
-        value = ActiveJob::Base.execute(job_data)
+        value = ActiveJob::Base.execute(active_job_data)
 
         if value.is_a?(Exception)
           handled_error = value

data/lib/good_job/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 2.4.2
+  version: 2.5.0
 platform: ruby
 authors:
 - Ben Sheldon
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-10-19 00:00:00.000000000 Z
+date: 2021-10-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
@@ -369,8 +369,11 @@ files:
 - 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/_arrow_clockwise.html.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/_skip_forward.html.erb
+- engine/app/views/good_job/shared/icons/_stop.html.erb
 - engine/app/views/good_job/shared/icons/_trash.html.erb
 - engine/app/views/layouts/good_job/base.html.erb
 - engine/config/routes.rb
@@ -380,6 +383,8 @@ files:
 - lib/generators/good_job/install_generator.rb
 - lib/generators/good_job/templates/install/migrations/create_good_jobs.rb.erb
 - lib/generators/good_job/templates/update/migrations/01_create_good_jobs.rb.erb
+- lib/generators/good_job/templates/update/migrations/02_add_cron_at_to_good_jobs.rb.erb
+- lib/generators/good_job/templates/update/migrations/03_add_cron_key_cron_at_index_to_good_jobs.rb.erb
 - lib/generators/good_job/update_generator.rb
 - lib/good_job.rb
 - lib/good_job/active_job_extensions.rb