good_job 2.3.1 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3d37e613a1bbc15da2a5245b19443a220a49d69e49abd616ceb34f25bfea0ecc
-  data.tar.gz: ab189fd086ad548dfaf0c71c39f30d9fd07a1c7fc72c3764794365ce69b027b5
+  metadata.gz: 5a173683ec5e5879728536005c7dfd11827ffe87c268c59315f540911277f2df
+  data.tar.gz: a5990d902838da25344ff96fc859bad39803f70f888dd95de8e3e6c201da4b0f
 SHA512:
-  metadata.gz: add7f07d52a89171eecad11d31e3bf1f504ec72522a6f093204ee6bad8ec32a3cfa802f5d86394b5d98980ce74d3e333ef6d0a513871f4af38b782a0cffee625
-  data.tar.gz: ddc8d64f20a5060512814676c07e647adf2711a3b1bcd0b1bfc8c8527841c9e2b1bea87a25b8e93e6b80176159d3c5fd65f54d1fa77b44e4baf1bf48fae6dc1f
+  metadata.gz: 92378343ecf6f3750a98ac1e146c748e7440b267fad30ac04eaf984649e5640fad8cfdd58b9c627bb7f7792202a849222ee7ed7583b7ac847f2d15839c25519f
+  data.tar.gz: f093bda085b00d82210e9bcf02ed6e39fec556aeeaa17c6f73a9465119867833f3145905482a20ec57840ae6bb6fa350f79e64209425cef8db9f45c0b59c4ea0

data/CHANGELOG.md

@@ -1,13 +1,102 @@
 # 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)
+
+**Implemented enhancements:**
+
+- Add migration version to install/update generator templates [\#426](https://github.com/bensheldon/good_job/pull/426) ([bensheldon](https://github.com/bensheldon))
+
+**Fixed bugs:**
+
+- Explicitly unscope queries within block yielded to Lockable.within\_advisory\_lock [\#429](https://github.com/bensheldon/good_job/pull/429) ([bensheldon](https://github.com/bensheldon))
+- Fix Demo CleanupJob args [\#427](https://github.com/bensheldon/good_job/pull/427) ([bensheldon](https://github.com/bensheldon))
+
+**Merged pull requests:**
+
+- Remove v1.99/v2 transitional extra advisory lock [\#428](https://github.com/bensheldon/good_job/pull/428) ([bensheldon](https://github.com/bensheldon))
+
+## [v2.4.1](https://github.com/bensheldon/good_job/tree/v2.4.1) (2021-10-11)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v2.4.0...v2.4.1)
+
+**Implemented enhancements:**
+
+- Support Datadog APM / `dd-trace-rb` [\#323](https://github.com/bensheldon/good_job/issues/323)
+- Display info about used timezone. [\#398](https://github.com/bensheldon/good_job/pull/398) ([morgoth](https://github.com/morgoth))
+- Display cron schedules args in dashboard [\#396](https://github.com/bensheldon/good_job/pull/396) ([aried3r](https://github.com/aried3r))
+
+**Fixed bugs:**
+
+- Inline adapter should raise unhandled exceptions during execution [\#416](https://github.com/bensheldon/good_job/pull/416) ([bensheldon](https://github.com/bensheldon))
+- Enforce english locale in UI [\#407](https://github.com/bensheldon/good_job/pull/407) ([morgoth](https://github.com/morgoth))
+
+**Closed issues:**
+
+- Finished jobs don't show up as finished [\#415](https://github.com/bensheldon/good_job/issues/415)
+- Inline adapter should raise unhandled exceptions during execution [\#410](https://github.com/bensheldon/good_job/issues/410)
+- Rewrite Scheduler "worker" thread name to be `thread` [\#406](https://github.com/bensheldon/good_job/issues/406)
+- "WARNING: you don't own a lock of type ExclusiveLock" in Development [\#388](https://github.com/bensheldon/good_job/issues/388)
+- Improve Readme's "Optimize queues, threads, processes" section [\#132](https://github.com/bensheldon/good_job/issues/132)
+
+**Merged pull requests:**
+
+- Ignore Rails HEAD Appraisal until `rails new` fixed [\#419](https://github.com/bensheldon/good_job/pull/419) ([bensheldon](https://github.com/bensheldon))
+- Warn in Readme that configuration should not go into `config/initializers/*.rb` [\#418](https://github.com/bensheldon/good_job/pull/418) ([bensheldon](https://github.com/bensheldon))
+- Replace worker wording [\#409](https://github.com/bensheldon/good_job/pull/409) ([Hugo-Hache](https://github.com/Hugo-Hache))
+- Improve Readme's "Optimize queues, threads, processes" section [\#405](https://github.com/bensheldon/good_job/pull/405) ([Hugo-Hache](https://github.com/Hugo-Hache))
+- Update GH Test Matrix with more PG versions [\#401](https://github.com/bensheldon/good_job/pull/401) ([tedhexaflow](https://github.com/tedhexaflow))
+- Extract cron configuration hash into CronEntry ActiveModel objects [\#400](https://github.com/bensheldon/good_job/pull/400) ([bensheldon](https://github.com/bensheldon))
+- Remove errant copy-paste from app.json [\#397](https://github.com/bensheldon/good_job/pull/397) ([morgoth](https://github.com/morgoth))
+
+## [v2.4.0](https://github.com/bensheldon/good_job/tree/v2.4.0) (2021-10-02)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v2.3.1...v2.4.0)
+
+**Implemented enhancements:**
+
+- Display schedule time relative to now. [\#394](https://github.com/bensheldon/good_job/pull/394) ([morgoth](https://github.com/morgoth))
+- Display cron schedules properties in dashboard [\#391](https://github.com/bensheldon/good_job/pull/391) ([aried3r](https://github.com/aried3r))
+
+**Fixed bugs:**
+
+- Correct icon for alert flash [\#395](https://github.com/bensheldon/good_job/pull/395) ([morgoth](https://github.com/morgoth))
+
 ## [v2.3.1](https://github.com/bensheldon/good_job/tree/v2.3.1) (2021-09-30)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v2.3.0...v2.3.1)
 
+**Fixed bugs:**
+
+- Wrap Scheduler task execution with Rails `reloader` instead of `executor` to avoid database connection changing during code reload [\#389](https://github.com/bensheldon/good_job/pull/389) ([bensheldon](https://github.com/bensheldon))
+
 **Merged pull requests:**
 
 - Log Cleanup thread tests, introduce "Slow" ExampleJob type, refactor ExampleJob types, run cron and log Postgres warnings in GoodJob Development harness [\#390](https://github.com/bensheldon/good_job/pull/390) ([bensheldon](https://github.com/bensheldon))
-- Wrap Scheduler task execution with Rails `reloader` instead of `executor` to avoid database connection changing during code reload [\#389](https://github.com/bensheldon/good_job/pull/389) ([bensheldon](https://github.com/bensheldon))
 
 ## [v2.3.0](https://github.com/bensheldon/good_job/tree/v2.3.0) (2021-09-25)
 

data/README.md

@@ -212,7 +212,11 @@ to delete old records and preserve space in your database.
 
 To use GoodJob, you can set `config.active_job.queue_adapter` to a `:good_job`.
 
-Additional configuration can be provided via `config.good_job.OPTION = ...` for example:
+Additional configuration can be provided via `config.good_job.OPTION = ...`.
+
+_Configuration **must** be placed into `config/application.rb` or `config/environments/{RAILS_ENV}.rb`; configuration may not work correctly if placed into `config/initializers/*.rb` because application initializers run _after_ gem initialization (see [Rails#36650](https://github.com/rails/rails/issues/36650) and [GoodJob#380](https://github.com/bensheldon/good_job/issues/380))._
+
+Configuration examples:
 
 ```ruby
 # config/application.rb
@@ -359,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.
@@ -387,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. `* * * * * *`).
 
@@ -576,43 +588,62 @@ end
 
 By default, GoodJob creates a single thread execution pool that will execute jobs from any queue. Depending on your application's workload, job types, and service level objectives, you may wish to optimize execution resources. For example, providing dedicated execution resources for transactional emails so they are not delayed by long-running batch jobs. Some options:
 
-- Multiple execution pools within a single process:
+- Multiple isolated execution pools within a single process:
+
+    For moderate workloads, multiple isolated thread execution pools offers a good balance between congestion management and economy.
+
+    A pool is configured with the following syntax `<participating_queues>:<thread_count>`:
+
+    - `<participating_queues>`: either `queue1,queue2` (only those queues), `*` (all) or `-queue1,queue2` (all except those queues).
+    - `<thread_count>`: a count overriding for this specific pool the global `max-threads`.
+
+    Pool configurations are separated with a semicolon (;) in the `queues` configuration
 
     ```bash
-    $ bundle exec good_job --queues="transactional_messages:2;batch_processing:1;-transactional_messages,batch_processing:2;*" --max-threads=5
+    $ bundle exec good_job \
+        --queues="transactional_messages:2;batch_processing:1;-transactional_messages,batch_processing:2;*" \
+        --max-threads=5
     ```
 
-    This configuration will result in a single process with 4 isolated thread execution pools. Isolated execution pools are separated with a semicolon (`;`) and queue names and thread counts with a colon (`:`)
+    This configuration will result in a single process with 4 isolated thread execution pools.
 
-    - `transactional_messages:2`: execute jobs enqueued on `transactional_messages` with up to 2 threads.
-    - `batch_processing:1` execute jobs enqueued on `batch_processing` with a single thread.
-    - `-transactional_messages,batch_processing`: execute jobs enqueued on _any_ queue _excluding_ `transactional_messages` or `batch_processing` with up to 2 threads.
-    - `*`: execute jobs on any queue on up to 5 threads, as configured by `--max-threads=5`
-
-    For moderate workloads, multiple isolated thread execution pools offers a good balance between congestion management and economy.
+    - `transactional_messages:2`: execute jobs enqueued on `transactional_messages`, with up to 2 threads.
+    - `batch_processing:1` execute jobs enqueued on `batch_processing`, with a single thread.
+    - `-transactional_messages,batch_processing`: execute jobs enqueued on _any_ queue _excluding_ `transactional_messages` or `batch_processing`, with up to 2 threads.
+    - `*`: execute jobs on any queue, with up to 5 threads (as configured by `--max-threads=5`).
 
     Configuration can be injected by environment variables too:
 
     ```bash
-    $ GOOD_JOB_QUEUES="transactional_messages:2;batch_processing:1;-transactional_messages,batch_processing:2;*" GOOD_JOB_MAX_THREADS=5 bundle exec good_job
+    $ GOOD_JOB_QUEUES="transactional_messages:2;batch_processing:1;-transactional_messages,batch_processing:2;*" \
+      GOOD_JOB_MAX_THREADS=5 \
+      bundle exec good_job
     ```
 
-- Multiple processes; for example, on Heroku:
+- Multiple processes:
+
+    While multiple isolated thread execution pools offer a way to provide dedicated execution resources, those resources are bound to a single machine. To scale them independently, define several processes.
+
+    For example, this configuration on Heroku allows to customize the dyno count (instances), or type (CPU/RAM), per process type:
 
     ```procfile
     # Procfile
 
-    # Separate dyno types
+    # Separate process types
     worker: bundle exec good_job --max-threads=5
     transactional_worker: bundle exec good_job --queues="transactional_messages" --max-threads=2
     batch_worker: bundle exec good_job --queues="batch_processing" --max-threads=1
+    ```
+
+    To optimize for CPU performance at the expense of greater memory and system resource usage, while keeping a single process type (and thus a single dyno), combine several processes and wait for them:
 
-    # Combined multi-process dyno
+    ```procfile
+    # Procfile
+
+    # Combined multi-process
     combined_worker: bundle exec good_job --max-threads=5 & bundle exec good_job --queues="transactional_messages" --max-threads=2 & bundle exec good_job --queues="batch_processing" --max-threads=1 & wait -n
     ```
 
-    Running multiple processes can optimize for CPU performance at the expense of greater memory and system resource usage.
-
 Keep in mind, queue operations and management is an advanced discipline. This stuff is complex, especially for heavy workloads and unique processing requirements. Good job 👍
 
 ### Database connections

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

@@ -2,5 +2,13 @@
 module GoodJob
   class BaseController < ActionController::Base # rubocop:disable Rails/ApplicationController
     protect_from_forgery with: :exception
+
+    around_action :switch_locale
+
+    private
+
+    def switch_locale(&action)
+      I18n.with_locale(:en, &action)
+    end
   end
 end

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

@@ -3,7 +3,7 @@ module GoodJob
   class CronSchedulesController < GoodJob::BaseController
     def index
       configuration = GoodJob::Configuration.new({})
-      @cron_schedules = configuration.cron
+      @cron_entries = configuration.cron_entries
     end
   end
 end

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/helpers/good_job/application_helper.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 module GoodJob
   module ApplicationHelper
+    def relative_time(timestamp)
+      text = timestamp.future? ? "in #{time_ago_in_words(timestamp)}" : "#{time_ago_in_words(timestamp)} ago"
+      tag.time(text, datetime: timestamp, title: timestamp)
+    end
   end
 end

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

@@ -1,22 +1,66 @@
-<% if @cron_schedules.present? %>
+<% if @cron_entries.present? %>
   <div class="card my-3">
     <div class="table-responsive">
       <table class="table card-table table-bordered table-hover table-sm mb-0">
         <thead>
           <th>Cron Job Name</th>
           <th>Configuration</th>
+          <th>
+            Set&nbsp;
+            <%= tag.button "Toggle", type: "button", class: "btn btn-sm btn-outline-primary", role: "button",
+                           data: { bs_toggle: "collapse", bs_target: ".job-properties" },
+                           aria: { expanded: false, controls: @cron_entries.map { |cron_entry| dom_id(cron_entry, 'properties') }.join(" ") }
+            %>
+          </th>
+          <th>
+            Args&nbsp;
+            <%= tag.button "Toggle", type: "button", class: "btn btn-sm btn-outline-primary", role: "button",
+                           data: { bs_toggle: "collapse", bs_target: ".job-args" },
+                           aria: { expanded: false, controls: @cron_entries.map { |cron_entry| dom_id(cron_entry, 'args') }.join(" ") }
+            %>
+          </th>
           <th>Class</th>
           <th>Description</th>
           <th>Next scheduled</th>
         </thead>
         <tbody>
-          <% @cron_schedules.each do |job_key, job| %>
+          <% @cron_entries.each do |cron_entry| %>
             <tr>
-              <td class="font-monospace"><%= job_key %></td>
-              <td class="font-monospace"><%= job[:cron] %></td>
-              <td class="font-monospace"><%= job[:class] %></td>
-              <td><%= job[:description] %></td>
-              <td><%= Fugit.parse_cron(job[:cron]).next_time.to_local_time %></td>
+              <td class="font-monospace"><%= cron_entry.key %></td>
+              <td class="font-monospace"><%= cron_entry.cron %></td>
+              <td>
+                <%=
+                  case cron_entry.set
+                  when NilClass
+                    "None"
+                  when Proc
+                    "Lambda/Callable"
+                  when Hash
+                    tag.button("Preview", type: "button", class: "btn btn-sm btn-outline-primary", role: "button",
+                        data: { bs_toggle: "collapse", bs_target: "##{dom_id(cron_entry, 'properties')}" },
+                        aria: { expanded: false, controls: dom_id(cron_entry, 'properties') }) +
+                      tag.pre(JSON.pretty_generate(cron_entry.set), id: dom_id(cron_entry, 'properties'), class: "collapse job-properties")
+                  end
+                %>
+              </td>
+              <td>
+                <%=
+                  case cron_entry.args
+                  when NilClass
+                    "None"
+                  when Proc
+                    "Lambda/Callable"
+                  when Hash
+                    tag.button("Preview", type: "button", class: "btn btn-sm btn-outline-primary", role: "button",
+                        data: { bs_toggle: "collapse", bs_target: "##{dom_id(cron_entry, 'args')}" },
+                        aria: { expanded: false, controls: dom_id(cron_entry, 'args') }) +
+                      tag.pre(JSON.pretty_generate(cron_entry.args), id: dom_id(cron_entry, 'args'), class: "collapse job-args")
+                  end
+                %>
+              </td>
+              <td class="font-monospace"><%= cron_entry.job_class %></td>
+              <td><%= cron_entry.description %></td>
+              <td><%= cron_entry.next_at %></td>
             </tr>
           <% end %>
         </tbody>