RubyGems - good_job - Versions diffs - 2.4.2 → 2.6.2 - Mend

good_job 2.4.2 → 2.6.2

Files changed (47) hide show

checksums.yaml +4 -4
data/CHANGELOG.md +79 -0
data/README.md +12 -4
data/engine/app/assets/scripts.js +1 -0
data/engine/app/assets/style.css +5 -0
data/engine/app/assets/vendor/chartjs/chart.min.js +13 -0
data/engine/app/assets/vendor/rails_ujs.js +747 -0
data/engine/app/charts/good_job/scheduled_by_queue_chart.rb +69 -0
data/engine/app/controllers/good_job/assets_controller.rb +8 -4
data/engine/app/controllers/good_job/cron_entries_controller.rb +19 -0
data/engine/app/controllers/good_job/jobs_controller.rb +36 -0
data/engine/app/filters/good_job/base_filter.rb +18 -56
data/engine/app/filters/good_job/executions_filter.rb +9 -8
data/engine/app/filters/good_job/jobs_filter.rb +12 -9
data/engine/app/views/good_job/cron_entries/index.html.erb +51 -0
data/engine/app/views/good_job/cron_entries/show.html.erb +4 -0
data/engine/app/views/good_job/{shared/_executions_table.erb → executions/_table.erb} +1 -1
data/engine/app/views/good_job/executions/index.html.erb +2 -2
data/engine/app/views/good_job/{shared/_jobs_table.erb → jobs/_table.erb} +18 -6
data/engine/app/views/good_job/jobs/index.html.erb +15 -2
data/engine/app/views/good_job/jobs/show.html.erb +2 -2
data/engine/app/views/good_job/shared/_chart.erb +19 -46
data/engine/app/views/good_job/shared/_filter.erb +27 -13
data/engine/app/views/good_job/shared/icons/_arrow_clockwise.html.erb +5 -0
data/engine/app/views/good_job/shared/icons/_play.html.erb +4 -0
data/engine/app/views/good_job/shared/icons/_skip_forward.html.erb +4 -0
data/engine/app/views/good_job/shared/icons/_stop.html.erb +4 -0
data/engine/app/views/layouts/good_job/base.html.erb +6 -4
data/engine/config/routes.rb +17 -4
data/lib/generators/good_job/templates/install/migrations/create_good_jobs.rb.erb +2 -0
data/lib/generators/good_job/templates/update/migrations/02_add_cron_at_to_good_jobs.rb.erb +14 -0
data/lib/generators/good_job/templates/update/migrations/03_add_cron_key_cron_at_index_to_good_jobs.rb.erb +20 -0
data/lib/good_job/active_job_job.rb +228 -0
data/lib/good_job/configuration.rb +1 -1
data/lib/good_job/cron_entry.rb +78 -5
data/lib/good_job/cron_manager.rb +4 -6
data/lib/good_job/current_thread.rb +38 -5
data/lib/good_job/execution.rb +53 -39
data/lib/good_job/filterable.rb +42 -0
data/lib/good_job/notifier.rb +17 -7
data/lib/good_job/version.rb +1 -1
metadata +31 -21
data/engine/app/assets/vendor/chartist/chartist.css +0 -613
data/engine/app/assets/vendor/chartist/chartist.js +0 -4516
data/engine/app/controllers/good_job/cron_schedules_controller.rb +0 -9
data/engine/app/models/good_job/active_job_job.rb +0 -127
data/engine/app/views/good_job/cron_schedules/index.html.erb +0 -72

data/engine/app/views/good_job/shared/icons/_play.html.erb ADDED Viewed

@@ -0,0 +1,4 @@
+<!-- https://icons.getbootstrap.com/icons/play/ -->
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" class="bi bi-play" viewBox="0 0 16 16">
+  <path d="M10.804 8 5 4.633v6.734L10.804 8zm.792-.696a.802.802 0 0 1 0 1.392l-6.363 3.692C4.713 12.69 4 12.345 4 11.692V4.308c0-.653.713-.998 1.233-.696l6.363 3.692z" />
+</svg>

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

@@ -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 ADDED Viewed

@@ -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/app/views/layouts/good_job/base.html.erb CHANGED Viewed

@@ -1,16 +1,18 @@
 <!DOCTYPE html>
-<html>
+<html lang="en">
 <head>
   <title>Good Job Dashboard</title>
   <%= csrf_meta_tags %>
   <%= csp_meta_tag %>
   <%= stylesheet_link_tag bootstrap_path(format: :css, v: GoodJob::VERSION) %>
-  <%= stylesheet_link_tag chartist_path(format: :css, v: GoodJob::VERSION) %>
   <%= stylesheet_link_tag style_path(format: :css, v: GoodJob::VERSION) %>
   <%= javascript_include_tag bootstrap_path(format: :js, v: GoodJob::VERSION) %>
-  <%= javascript_include_tag chartist_path(format: :js, v: GoodJob::VERSION) %>
+  <%= javascript_include_tag chartjs_path(format: :js, v: GoodJob::VERSION) %>
+  <%= javascript_include_tag scripts_path(format: :js, v: GoodJob::VERSION) %>
+  <%= javascript_include_tag rails_ujs_path(format: :js, v: GoodJob::VERSION) %>
 </head>
 <body>
   <nav class="navbar navbar-expand-lg navbar-light bg-light">
@@ -29,7 +31,7 @@
             <%= 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))] %>
+            <%= link_to "Cron Schedules", cron_entries_path, class: ["nav-link", ("active" if current_page?(cron_entries_path))] %>
           </li>
           <li class="nav-item">
             <div class="nav-link">

data/engine/config/routes.rb CHANGED Viewed

@@ -1,20 +1,33 @@
 # frozen_string_literal: true
 GoodJob::Engine.routes.draw do
   root to: 'executions#index'
-  resources :cron_schedules, only: %i[index]
-  resources :jobs, only: %i[index show]
+  resources :cron_entries, only: %i[index show] do
+    member do
+      post :enqueue
+    end
+  end
+  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
     constraints(format: :css) do
       get :bootstrap, action: :bootstrap_css
-      get :chartist, action: :chartist_css
       get :style, action: :style_css
     end
     constraints(format: :js) do
       get :bootstrap, action: :bootstrap_js
-      get :chartist, action: :chartist_js
+      get :rails_ujs, action: :rails_ujs_js
+      get :chartjs, action: :chartjs_js
+      get :scripts, action: :scripts_js
     end
   end
 end

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

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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/active_job_job.rb ADDED Viewed

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+module GoodJob
+  # ActiveRecord model that represents an +ActiveJob+ job.
+  # 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 Filterable
+    include 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'
+    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) }
+    # The job's ActiveJob UUID
+    # @return [String]
+    def id
+      active_job_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
+      execution = head_execution
+      if execution.finished_at.present?
+        if execution.error.present?
+          :discarded
+        else
+          :finished
+        end
+      elsif (execution.scheduled_at || execution.created_at) > DateTime.current
+        if execution.serialized_params.fetch('executions', 0) > 1
+          :retried
+        else
+          :scheduled
+        end
+      elsif running?
+        :running
+      else
+        :queued
+      end
+    end
+    # 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 = 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]
+        aj_count + 1
+      else
+        aj_count
+      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
+      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)
+        self['locktype'].present?
+      else
+        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/lib/good_job/configuration.rb CHANGED Viewed

@@ -157,7 +157,7 @@ module GoodJob
     alias enable_cron? enable_cron
     def cron
-      env_cron = JSON.parse(ENV['GOOD_JOB_CRON']) if ENV['GOOD_JOB_CRON'].present?
+      env_cron = JSON.parse(ENV['GOOD_JOB_CRON'], symbolize_names: true) if ENV['GOOD_JOB_CRON'].present?
       options[:cron] ||
         rails_config[:cron] ||

data/lib/good_job/cron_entry.rb CHANGED Viewed

@@ -12,14 +12,29 @@ module GoodJob # :nodoc:
     attr_reader :params
+    def self.all(configuration: nil)
+      configuration ||= GoodJob::Configuration.new({})
+      configuration.cron_entries
+    end
+    def self.find(key, configuration: nil)
+      all(configuration: configuration).find { |entry| entry.key == key.to_sym }.tap do |cron_entry|
+        raise ActiveRecord::RecordNotFound unless cron_entry
+      end
+    end
     def initialize(params = {})
-      @params = params.with_indifferent_access
+      @params = params
+      raise ArgumentError, "Invalid cron format: '#{cron}'" unless fugit.instance_of?(Fugit::Cron)
     end
     def key
       params.fetch(:key)
     end
     alias id key
+    alias to_param key
     def job_class
       params.fetch(:class)
@@ -42,12 +57,59 @@ module GoodJob # :nodoc:
     end
     def next_at
-      fugit = Fugit::Cron.parse(cron)
-      fugit.next_time
+      fugit.next_time.to_t
+    end
+    def schedule
+      fugit.original
+    end
+    def fugit
+      @_fugit ||= Fugit.parse(cron)
+    end
+    def jobs
+      GoodJob::ActiveJobJob.where(cron_key: key)
+    end
+    def last_at
+      return if last_job.blank?
+      if GoodJob::ActiveJobJob.column_names.include?('cron_at')
+        (last_job.cron_at || last_job.created_at).localtime
+      else
+        last_job.created_at
+      end
     end
-    def enqueue
-      job_class.constantize.set(set_value).perform_later(*args_value)
+    def enqueue(cron_at = nil)
+      GoodJob::CurrentThread.within do |current_thread|
+        current_thread.cron_key = key
+        current_thread.cron_at = cron_at
+        job_class.constantize.set(set_value).perform_later(*args_value)
+      end
+    rescue ActiveRecord::RecordNotUnique
+      false
+    end
+    def last_job
+      if GoodJob::ActiveJobJob.column_names.include?('cron_at')
+        jobs.order("cron_at DESC NULLS LAST").first
+      else
+        jobs.order(created_at: :asc).last
+      end
+    end
+    def display_properties
+      {
+        key: key,
+        class: job_class,
+        cron: schedule,
+        set: display_property(set),
+        args: display_property(args),
+        description: display_property(description),
+      }
     end
     private
@@ -61,5 +123,16 @@ module GoodJob # :nodoc:
       value = args || []
       value.respond_to?(:call) ? value.call : value
     end
+    def display_property(value)
+      case value
+      when NilClass
+        "None"
+      when Proc
+        "Lambda/Callable"
+      else
+        value
+      end
+    end
   end
 end

data/lib/good_job/cron_manager.rb CHANGED Viewed

@@ -82,16 +82,14 @@ 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
-          cron_entry.enqueue
+          cron_entry.enqueue(thr_cron_at)
         end
       end

data/lib/good_job/current_thread.rb CHANGED Viewed

@@ -5,6 +5,21 @@ module GoodJob
   # Thread-local attributes for passing values from Instrumentation.
   # (Cannot use ActiveSupport::CurrentAttributes because ActiveJob resets it)
   module CurrentThread
+    # Resettable accessors for thread-local values.
+    ACCESSORS = %i[
+      cron_at
+      cron_key
+      error_on_discard
+      error_on_retry
+      execution
+    ].freeze
+    # @!attribute [rw] cron_at
+    #   @!scope class
+    #   Cron At
+    #   @return [DateTime, nil]
+    thread_mattr_accessor :cron_at
     # @!attribute [rw] cron_key
     #   @!scope class
     #   Cron Key
@@ -30,12 +45,20 @@ module GoodJob
     thread_mattr_accessor :execution
     # Resets attributes
+    # @param [Hash] values to assign
     # @return [void]
-    def self.reset
-      self.cron_key = nil
-      self.execution = nil
-      self.error_on_discard = nil
-      self.error_on_retry = nil
+    def self.reset(values = {})
+      ACCESSORS.each do |accessor|
+        send("#{accessor}=", values[accessor])
+      end
+    end
+    # Exports values to hash
+    # @return [Hash]
+    def self.to_h
+      ACCESSORS.each_with_object({}) do |accessor, hash|
+        hash[accessor] = send(accessor)
+      end
     end
     # @return [String] UUID of the currently executing GoodJob::Execution
@@ -52,5 +75,15 @@ module GoodJob
     def self.thread_name
       (Thread.current.name || Thread.current.object_id).to_s
     end
+    # Wrap the yielded block with CurrentThread values and reset after the block
+    # @yield [self]
+    # @return [void]
+    def self.within
+      original_values = to_h
+      yield(self)
+    ensure
+      reset(original_values)
+    end
   end
 end