good_job 2.5.0 → 2.7.0

data/engine/config/routes.rb

@@ -1,7 +1,13 @@
 # frozen_string_literal: true
 GoodJob::Engine.routes.draw do
   root to: 'executions#index'
-  resources :cron_schedules, only: %i[index]
+
+  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
@@ -14,13 +20,14 @@ GoodJob::Engine.routes.draw do
   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/{engine/app/models → lib}/good_job/active_job_job.rb

@@ -8,7 +8,8 @@ module GoodJob
   # @!parse
   #   class ActiveJob < ActiveRecord::Base; end
   class ActiveJobJob < Object.const_get(GoodJob.active_record_parent_class)
-    include GoodJob::Lockable
+    include Filterable
+    include Lockable
 
     # Raised when an inappropriate action is applied to a Job based on its state.
     ActionForStateMismatchError = Class.new(StandardError)
@@ -47,24 +48,6 @@ module GoodJob
     # 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)
-
     # The job's ActiveJob UUID
     # @return [String]
     def id

data/lib/good_job/cli.rb

@@ -79,6 +79,9 @@ module GoodJob
     method_option :pidfile,
                   type: :string,
                   desc: "Path to write daemonized Process ID (env var: GOOD_JOB_PIDFILE, default: tmp/pids/good_job.pid)"
+    method_option :probe_port,
+                  type: :numeric,
+                  desc: "Port for http health check (env var: GOOD_JOB_PROBE_PORT, default: nil)"
 
     def start
       set_up_application!
@@ -93,6 +96,10 @@ module GoodJob
       poller.recipients << [scheduler, :create_thread]
 
       cron_manager = GoodJob::CronManager.new(configuration.cron_entries, start_on_initialize: true) if configuration.enable_cron?
+      if configuration.probe_port
+        probe_server = GoodJob::ProbeServer.new(port: configuration.probe_port)
+        probe_server.start
+      end
 
       @stop_good_job_executable = false
       %w[INT TERM].each do |signal|
@@ -106,6 +113,7 @@ module GoodJob
 
       executors = [notifier, poller, cron_manager, scheduler].compact
       GoodJob._shutdown_all(executors, timeout: configuration.shutdown_timeout)
+      probe_server&.stop
     end
 
     default_task :start

data/lib/good_job/configuration.rb

@@ -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] ||
@@ -195,6 +195,13 @@ module GoodJob
         Rails.application.root.join('tmp', 'pids', 'good_job.pid')
     end
 
+    # Port of the probe server
+    # @return [nil,Integer]
+    def probe_port
+      options[:probe_port] ||
+        env['GOOD_JOB_PROBE_PORT']
+    end
+
     private
 
     def rails_config

data/lib/good_job/cron_entry.rb

@@ -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,16 +57,61 @@ module GoodJob # :nodoc:
     end
 
     def next_at
-      fugit = Fugit::Cron.parse(cron)
       fugit.next_time.to_t
     end
 
-    def enqueue
-      job_class.constantize.set(set_value).perform_later(*args_value)
+    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(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
 
     def set_value
@@ -63,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

@@ -89,11 +89,7 @@ module GoodJob # :nodoc:
         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
+          cron_entry.enqueue(thr_cron_at)
         end
       end
 

data/lib/good_job/current_thread.rb

@@ -5,6 +5,15 @@ 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
@@ -36,13 +45,20 @@ module GoodJob
     thread_mattr_accessor :execution
 
     # Resets attributes
+    # @param [Hash] values to assign
     # @return [void]
-    def self.reset
-      self.cron_at = nil
-      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
@@ -60,12 +76,14 @@ module GoodJob
       (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
-      reset
+      original_values = to_h
       yield(self)
     ensure
-      reset
+      reset(original_values)
     end
   end
 end

data/lib/good_job/execution.rb

@@ -6,6 +6,7 @@ module GoodJob
   #   class Execution < ActiveRecord::Base; end
   class Execution < Object.const_get(GoodJob.active_record_parent_class)
     include Lockable
+    include Filterable
 
     # Raised if something attempts to execute a previously completed Execution again.
     PreviouslyPerformedError = Class.new(StandardError)
@@ -156,24 +157,6 @@ module GoodJob
       end
     end)
 
-    # 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)
-
     # Finds the next eligible Execution, acquire an advisory lock related to it, and
     # executes the job.
     # @return [ExecutionResult, nil]
@@ -309,22 +292,24 @@ module GoodJob
 
     # @return [ExecutionResult]
     def execute
-      GoodJob::CurrentThread.reset
-      GoodJob::CurrentThread.execution = self
+      GoodJob::CurrentThread.within do |current_thread|
+        current_thread.reset
+        current_thread.execution = self
 
-      # 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(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: current_thread.process_id, thread_name: current_thread.thread_name }) do
+          value = ActiveJob::Base.execute(active_job_data)
 
-        if value.is_a?(Exception)
-          handled_error = value
-          value = nil
-        end
-        handled_error ||= GoodJob::CurrentThread.error_on_retry || GoodJob::CurrentThread.error_on_discard
+          if value.is_a?(Exception)
+            handled_error = value
+            value = nil
+          end
+          handled_error ||= current_thread.error_on_retry || current_thread.error_on_discard
 
-        ExecutionResult.new(value: value, handled_error: handled_error)
-      rescue StandardError => e
-        ExecutionResult.new(value: nil, unhandled_error: e)
+          ExecutionResult.new(value: value, handled_error: handled_error)
+        rescue StandardError => e
+          ExecutionResult.new(value: nil, unhandled_error: e)
+        end
       end
     end
   end

data/lib/good_job/filterable.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+module GoodJob
+  # Shared methods for filtering Execution/Job records from the +good_jobs+ table.
+  module Filterable
+    extend ActiveSupport::Concern
+
+    included do
+      # Get records 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)
+
+      # Search records by text query.
+      # @!method search_text(query)
+      # @!scope class
+      # @param query [String]
+      #   Search Query
+      # @return [ActiveRecord::Relation]
+      scope :search_text, (lambda do |query|
+        query = query.to_s.strip
+        next if query.blank?
+
+        tsvector = "(to_tsvector('english', serialized_params) || to_tsvector('english', id::text) || to_tsvector('english', COALESCE(error, '')::text))"
+        where("#{tsvector} @@ to_tsquery(?)", query)
+          .order(sanitize_sql_for_order([Arel.sql("ts_rank(#{tsvector}, to_tsquery(?))"), query]) => 'DESC')
+      end)
+    end
+  end
+end

data/lib/good_job/notifier.rb

@@ -25,10 +25,17 @@ module GoodJob # :nodoc:
       max_queue: 1,
       fallback_policy: :discard,
     }.freeze
-    # Seconds to wait if database cannot be connected to
-    RECONNECT_INTERVAL = 5
     # Seconds to block while LISTENing for a message
     WAIT_INTERVAL = 1
+    # Seconds to wait if database cannot be connected to
+    RECONNECT_INTERVAL = 5
+    # Connection errors that will wait {RECONNECT_INTERVAL} before reconnecting
+    CONNECTION_ERRORS = %w[
+      ActiveRecord::ConnectionNotEstablished
+      ActiveRecord::StatementInvalid
+      PG::UnableToSend
+      PG::Error
+    ].freeze
 
     # @!attribute [r] instances
     #   @!scope class
@@ -115,15 +122,18 @@ module GoodJob # :nodoc:
       if thread_error
         GoodJob.on_thread_error.call(thread_error) if GoodJob.on_thread_error.respond_to?(:call)
         ActiveSupport::Notifications.instrument("notifier_notify_error.good_job", { error: thread_error })
+
+        connection_error = CONNECTION_ERRORS.any? do |error_string|
+          error_class = error_string.safe_constantize
+          next unless error_class
+
+          thread_error.is_a? error_class
+        end
       end
 
       return if shutdown?
 
-      if thread_error.is_a?(ActiveRecord::ConnectionNotEstablished) || thread_error.is_a?(ActiveRecord::StatementInvalid)
-        listen(delay: RECONNECT_INTERVAL)
-      else
-        listen
-      end
+      listen(delay: connection_error ? RECONNECT_INTERVAL : 0)
     end
 
     private

data/lib/good_job/probe_server.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module GoodJob
+  class ProbeServer
+    RACK_SERVER = 'webrick'
+
+    def self.task_observer(time, output, thread_error) # rubocop:disable Lint/UnusedMethodArgument
+      return if thread_error.is_a? Concurrent::CancelledOperationError
+
+      GoodJob.on_thread_error.call(thread_error) if thread_error && GoodJob.on_thread_error.respond_to?(:call)
+    end
+
+    def initialize(port:)
+      @port = port
+    end
+
+    def start
+      @handler = Rack::Handler.get(RACK_SERVER)
+      @future = Concurrent::Future.new(args: [@handler, @port, GoodJob.logger]) do |thr_handler, thr_port, thr_logger|
+        thr_handler.run(self, Port: thr_port, Logger: thr_logger, AccessLog: [])
+      end
+      @future.add_observer(self.class, :task_observer)
+      @future.execute
+    end
+
+    def running?
+      @handler&.instance_variable_get(:@server)&.status == :Running
+    end
+
+    def stop
+      @handler&.shutdown
+      @future&.value # wait for Future to exit
+    end
+
+    def call(env)
+      case Rack::Request.new(env).path
+      when '/', '/status'
+        [200, {}, ["OK"]]
+      when '/status/started'
+        started = GoodJob::Scheduler.instances.any? && GoodJob::Scheduler.instances.all?(&:running?)
+        started ? [200, {}, ["Started"]] : [503, {}, ["Not started"]]
+      when '/status/connected'
+        connected = GoodJob::Scheduler.instances.any? && GoodJob::Scheduler.instances.all?(&:running?) &&
+                    GoodJob::Notifier.instances.any? && GoodJob::Notifier.instances.all?(&:listening?)
+        connected ? [200, {}, ["Connected"]] : [503, {}, ["Not connected"]]
+      else
+        [404, {}, ["Not found"]]
+      end
+    end
+  end
+end

data/lib/good_job/version.rb

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