good_job 2.4.0 → 2.6.0

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
@@ -174,13 +187,7 @@ module GoodJob
         break if execution.blank?
         break :unlocked unless execution&.executable?
 
-        begin
-          execution.with_advisory_lock(key: "good_jobs-#{execution.active_job_id}") do
-            execution.perform
-          end
-        rescue RecordAlreadyAdvisoryLockedError => e
-          ExecutionResult.new(value: nil, handled_error: e)
-        end
+        execution.perform
       end
     end
 
@@ -228,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
 
@@ -239,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
@@ -259,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!
@@ -279,29 +294,39 @@ 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
+      GoodJob::CurrentThread.within do |current_thread|
+        current_thread.reset
+        current_thread.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: current_thread.process_id, thread_name: current_thread.thread_name }) do
+          value = ActiveJob::Base.execute(active_job_data)
 
-      # 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)
+          if value.is_a?(Exception)
+            handled_error = value
+            value = nil
+          end
+          handled_error ||= current_thread.error_on_retry || current_thread.error_on_discard
 
-        if value.is_a?(Exception)
-          handled_error = value
-          value = nil
+          ExecutionResult.new(value: value, handled_error: handled_error)
+        rescue StandardError => e
+          ExecutionResult.new(value: nil, unhandled_error: e)
         end
-        handled_error ||= GoodJob::CurrentThread.error_on_retry || GoodJob::CurrentThread.error_on_discard
-
-        ExecutionResult.new(value: value, handled_error: handled_error)
-      rescue StandardError => e
-        ExecutionResult.new(value: nil, unhandled_error: e)
       end
     end
   end

data/lib/good_job/lockable.rb

@@ -149,7 +149,7 @@ module GoodJob
 
         records = advisory_lock(column: column, function: function).to_a
         begin
-          yield(records)
+          unscoped { yield(records) }
         ensure
           if unlock_session
             advisory_unlock_session

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,6 +230,7 @@ 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|
+        Thread.current.name = Thread.current.name.sub("-worker-", "-thread-") if Thread.current.name
         Rails.application.reloader.wrap do
           thr_performer.next
         end

data/lib/good_job/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 2.4.0
+  version: 2.6.0
 platform: ruby
 authors:
 - Ben Sheldon
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-10-02 00:00:00.000000000 Z
+date: 2021-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
@@ -126,16 +126,16 @@ dependencies:
   name: capybara
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.35.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.35.0
 - !ruby/object:Gem::Dependency
   name: database_cleaner
   requirement: !ruby/object:Gem::Requirement
@@ -351,26 +351,31 @@ 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/assets/vendor/rails_ujs.js
 - 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/cron_entries_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/models/good_job/active_job_job.rb
-- engine/app/views/good_job/cron_schedules/index.html.erb
+- engine/app/views/good_job/cron_entries/index.html.erb
+- engine/app/views/good_job/cron_entries/show.html.erb
+- engine/app/views/good_job/executions/_table.erb
 - engine/app/views/good_job/executions/index.html.erb
+- engine/app/views/good_job/jobs/_table.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/_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/_play.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
@@ -379,14 +384,18 @@ files:
 - lib/active_job/queue_adapters/good_job_adapter.rb
 - 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
+- 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
 - lib/good_job/active_job_extensions/concurrency.rb
+- lib/good_job/active_job_job.rb
 - 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/cron_schedules_controller.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-module GoodJob
-  class CronSchedulesController < GoodJob::BaseController
-    def index
-      configuration = GoodJob::Configuration.new({})
-      @cron_schedules = configuration.cron
-    end
-  end
-end

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

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

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

@@ -1,50 +0,0 @@
-<% if @cron_schedules.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_schedules.map { |job_key, _| "##{job_key.to_param}" }.join(" ") }
-            %>
-          </th>
-          <th>Class</th>
-          <th>Description</th>
-          <th>Next scheduled</th>
-        </thead>
-        <tbody>
-          <% @cron_schedules.each do |job_key, job| %>
-            <tr>
-              <td class="font-monospace"><%= job_key %></td>
-              <td class="font-monospace"><%= job[:cron] %></td>
-              <td>
-                <%=
-                  case job[: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: "##{job_key.to_param}" },
-                        aria: { expanded: false, controls: job_key.to_param }) +
-                      tag.pre(JSON.pretty_generate(job[:set]), id: job_key.to_param, class: "collapse job-properties")
-                  end
-                %>
-              </td>
-              <td class="font-monospace"><%= job[:class] %></td>
-              <td><%= job[:description] %></td>
-              <td><%= Fugit.parse_cron(job[:cron]).next_time.to_local_time %></td>
-            </tr>
-          <% end %>
-        </tbody>
-      </table>
-    </div>
-  </div>
-<% else %>
-  <em>No cron jobs present.</em>
-<% end %>