good_job 2.6.1 → 2.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a413bcbddac29378e8fb0de0cc9305b57bd2e31041973f5db2a9dac6f04b7b1
-  data.tar.gz: d99f0e37ad2c99ac0d69337fefccff11bc522ad370f02ae1ac12d59adab619d8
+  metadata.gz: e4843101f6fce50527e8d0157ff7ced91fabb0ae41c3c92006abd49e9005ea78
+  data.tar.gz: f8f243fb7f9e3ea2ec17fc795ad5bbd79b017f68665d98b911dfe27177e13389
 SHA512:
-  metadata.gz: 3d6cddf9581a852f72f4c8b337149afc7fc4d2189d6304e510f19ca101cb661c1452b3eca3a123e28750c9729d9f6ca9224855a020296f68693246104864eb4f
-  data.tar.gz: a042a1f1c29525e4c101b512f74a06cb4f2405a790d5e199e1dac87029e220b404d1b310683a151ef67ed7c50c8d94ae8e28c578b270175085d4c7e60f9040d3
+  metadata.gz: f2dbdd1c1811bfc09153a8eed32b95f337919d22434b004622a0ab78eb6803e68f5a66761e828bf2054421d5d5f9b798be54e7f60cc486602a997c804ab9fb2d
+  data.tar.gz: 953672a066c27a231fb76c3c9839b4cb9685deb0ed4f25a3e153f4ede0833afa0a263f4d37532715a62ed7a96825384b8f7d6fef7352416d0c64068864798fee

data/CHANGELOG.md

@@ -1,5 +1,61 @@
 # Changelog
 
+## [v2.7.2](https://github.com/bensheldon/good_job/tree/v2.7.2) (2021-11-29)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v2.7.1...v2.7.2)
+
+**Implemented enhancements:**
+
+- Allow GoodJob global configuration accessors to also be set via Rails config hash [\#460](https://github.com/bensheldon/good_job/pull/460) ([bensheldon](https://github.com/bensheldon))
+
+**Merged pull requests:**
+
+- Use `ActiveRecord::Relation::QueryAttribute` when setting up bindings for `exec_query` [\#461](https://github.com/bensheldon/good_job/pull/461) ([bensheldon](https://github.com/bensheldon))
+- Configure RSpec `config.example_status_persistence_file_path` [\#459](https://github.com/bensheldon/good_job/pull/459) ([bensheldon](https://github.com/bensheldon))
+- Defer async initialization until Rails fully initialized [\#454](https://github.com/bensheldon/good_job/pull/454) ([bensheldon](https://github.com/bensheldon))
+
+## [v2.7.1](https://github.com/bensheldon/good_job/tree/v2.7.1) (2021-11-26)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v2.7.0...v2.7.1)
+
+**Fixed bugs:**
+
+- Unclear error when database can't be reached [\#457](https://github.com/bensheldon/good_job/issues/457)
+- Remove Concurrent::Delay wrapping of database-loading methods [\#458](https://github.com/bensheldon/good_job/pull/458) ([bensheldon](https://github.com/bensheldon))
+- Do not delete csp policies when checking csp policies [\#456](https://github.com/bensheldon/good_job/pull/456) ([JonathanFrias](https://github.com/JonathanFrias))
+
+**Closed issues:**
+
+- How to suppress job scheduler logs? [\#455](https://github.com/bensheldon/good_job/issues/455)
+- Configuration in environments/\*.rb overrides application.rb [\#453](https://github.com/bensheldon/good_job/issues/453)
+- Testing jobs synchronously [\#435](https://github.com/bensheldon/good_job/issues/435)
+- HTTP health check endpoint [\#403](https://github.com/bensheldon/good_job/issues/403)
+
+## [v2.7.0](https://github.com/bensheldon/good_job/tree/v2.7.0) (2021-11-10)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v2.6.2...v2.7.0)
+
+**Implemented enhancements:**
+
+- Add http probe for CLI healthcheck/readiness/liveliness [\#452](https://github.com/bensheldon/good_job/pull/452) ([bensheldon](https://github.com/bensheldon))
+- Add explicit Content Security Policy \(CSP\) for Dashboard [\#449](https://github.com/bensheldon/good_job/pull/449) ([bensheldon](https://github.com/bensheldon))
+
+**Closed issues:**
+
+- Add a default Content-Security-Policy for the Dashboard [\#420](https://github.com/bensheldon/good_job/issues/420)
+
+## [v2.6.2](https://github.com/bensheldon/good_job/tree/v2.6.2) (2021-11-05)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v2.6.1...v2.6.2)
+
+**Fixed bugs:**
+
+- Rename Filterable\#search to Filterable\#search\_text to avoid name collision [\#451](https://github.com/bensheldon/good_job/pull/451) ([bensheldon](https://github.com/bensheldon))
+
+**Closed issues:**
+
+- v2.6.1 is incompatible with gem thinking-sphinx [\#450](https://github.com/bensheldon/good_job/issues/450)
+
 ## [v2.6.1](https://github.com/bensheldon/good_job/tree/v2.6.1) (2021-11-05)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v2.6.0...v2.6.1)

data/README.md

@@ -55,6 +55,7 @@ For more of the story of GoodJob, read the [introductory blog post](https://isla
     - [Migrate to GoodJob from a different ActiveJob backend](#migrate-to-goodjob-from-a-different-activejob-backend)
     - [Monitor and preserve worked jobs](#monitor-and-preserve-worked-jobs)
     - [PgBouncer compatibility](#pgbouncer-compatibility)
+    - [CLI HTTP health check probes](#cli-http-health-check-probes)
 - [Contribute](#contribute)
     - [Gem development](#gem-development)
     - [Release](#release)
@@ -96,7 +97,7 @@ For more of the story of GoodJob, read the [introductory blog post](https://isla
 1. Configure the ActiveJob adapter:
 
     ```ruby
-    # config/application.rb
+    # config/application.rb or config/environments/{RAILS_ENV}.rb
     config.active_job.queue_adapter = :good_job
     ```
 
@@ -170,6 +171,7 @@ Options:
   [--enable-cron]              # Whether to run cron process (default: false)
   [--daemonize]                # Run as a background daemon (default: false)
   [--pidfile=PIDFILE]          # Path to write daemonized Process ID (env var: GOOD_JOB_PIDFILE, default: tmp/pids/good_job.pid)
+  [--probe-port=PORT]          # Port for http health check (env var: GOOD_JOB_PROBE_PORT, default: nil)
 
 Executes queued jobs.
 
@@ -210,43 +212,48 @@ to delete old records and preserve space in your database.
 
 ### Configuration options
 
-To use GoodJob, you can set `config.active_job.queue_adapter` to a `:good_job`.
+ActiveJob configuration depends on where the code is placed:
 
-Additional configuration can be provided via `config.good_job.OPTION = ...`.
+- `config.active_job.queue_adapter = :good_job` within `config/application.rb` or `config/environments/*.rb`.
+- `ActiveJob::Base.queue_adapter = :good_job` within an initializer (e.g. `config/initializers/active_job.rb`).
 
-_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))._
+GoodJob configuration can be placed within Rails `config` directory for all environments (`config/application.rb`), within a particular environment (e.g. `config/environments/development.rb`), or within an initializer (e.g. `config/initializers/good_job.rb`).
 
 Configuration examples:
 
 ```ruby
-# config/application.rb
-
-config.active_job.queue_adapter = :good_job
-
-# Configure options individually...
-config.good_job.execution_mode = :async
-config.good_job.max_threads = 5
-config.good_job.poll_interval = 30 # seconds
-config.good_job.shutdown_timeout = 25 # seconds
-config.good_job.enable_cron = true
-config.good_job.cron = { example: { cron: '0 * * * *', class: 'ExampleJob'  } }
-config.good_job.queues = '*'
-
-# ...or all at once.
-config.good_job = {
-  execution_mode: :async,
-  max_threads: 5,
-  poll_interval: 30,
-  shutdown_timeout: 25,
-  enable_cron: true,
-  cron: {
-    example: {
-      cron: '0 * * * *',
-      class: 'ExampleJob'
+Rails.application.configure do
+  # Configure options individually...
+  config.good_job.preserve_job_records = true
+  config.good_job.retry_on_unhandled_error = false
+  config.good_job.on_thread_error = -> (exception) { Raven.capture_exception(exception) }
+  config.good_job.execution_mode = :async
+  config.good_job.max_threads = 5
+  config.good_job.poll_interval = 30 # seconds
+  config.good_job.shutdown_timeout = 25 # seconds
+  config.good_job.enable_cron = true
+  config.good_job.cron = { example: { cron: '0 * * * *', class: 'ExampleJob'  } }
+  config.good_job.queues = '*'
+
+  # ...or all at once.
+  config.good_job = {
+    preserve_job_records: true,
+    retry_on_unhandled_error: false,
+    on_thread_error: -> (exception) { Raven.capture_exception(exception) },
+    execution_mode: :async,
+    max_threads: 5,
+    poll_interval: 30,
+    shutdown_timeout: 25,
+    enable_cron: true,
+    cron: {
+      example: {
+        cron: '0 * * * *',
+        class: 'ExampleJob'
+      },
     },
-  },
-  queues: '*',
-}
+    queues: '*',
+  }
+end
 ```
 
 Available configuration options are:
@@ -263,6 +270,14 @@ Available configuration options are:
 - `shutdown_timeout` (float) number of seconds to wait for jobs to finish when shutting down before stopping the thread. Defaults to forever: `-1`. You can also set this with the environment variable `GOOD_JOB_SHUTDOWN_TIMEOUT`.
 - `enable_cron` (boolean) whether to run cron process. Defaults to `false`. You can also set this with the environment variable `GOOD_JOB_ENABLE_CRON`.
 - `cron` (hash) cron configuration. Defaults to `{}`. You can also set this as a JSON string with the environment variable `GOOD_JOB_CRON`
+- `logger` ([Rails Logger](https://api.rubyonrails.org/classes/ActiveSupport/Logger.html)) lets you set a custom logger for GoodJob. It should be an instance of a Rails `Logger` (Default: `Rails.logger`).
+- `preserve_job_records` (boolean) keeps job records in your database even after jobs are completed. (Default: `false`)
+- `retry_on_unhandled_error` (boolean) causes jobs to be re-queued and retried if they raise an instance of `StandardError`. Instances of `Exception`, like SIGINT, will *always* be retried, regardless of this attribute’s value. (Default: `true`)
+- `on_thread_error` (proc, lambda, or callable) will be called when an Exception. It can be useful for logging errors to bug tracking services, like Sentry or Airbrake. Example:
+
+    ```ruby
+    config.good_job.on_thread_error = -> (exception) { Raven.capture_exception(exception) }
+    ```
 
 By default, GoodJob configures the following execution modes per environment:
 
@@ -283,7 +298,7 @@ config.good_job.execution_mode = :external
 
 ### Global options
 
-Good Job’s general behavior can also be configured via several attributes directly on the `GoodJob` module:
+Good Job’s general behavior can also be configured via attributes directly on the `GoodJob` module:
 
 - **`GoodJob.active_record_parent_class`** (string) The ActiveRecord parent class inherited by GoodJob's ActiveRecord model `GoodJob::Job` (defaults to `"ActiveRecord::Base"`). Configure this when using [multiple databases with ActiveRecord](https://guides.rubyonrails.org/active_record_multiple_databases.html) or when other custom configuration is necessary for the ActiveRecord model to connect to the Postgres database. _The value must be a String to avoid premature initialization of ActiveRecord._
 - **`GoodJob.logger`** ([Rails Logger](https://api.rubyonrails.org/classes/ActiveSupport/Logger.html)) lets you set a custom logger for GoodJob. It should be an instance of a Rails `Logger`.
@@ -837,6 +852,61 @@ A workaround to this limitation is to make a direct database connection availabl
     GoodJob.active_record_parent_class = "ApplicationDirectRecord"
     ```
 
+### CLI HTTP health check probes
+
+GoodJob's CLI offers an http health check probe to better manage process lifecycle in containerized environments like Kubernetes:
+
+```bash
+# Run the CLI with a health check on port 7001
+good_job start --probe-port=7001
+
+# or via an environment variable
+GOOD_JOB_PROBE_PORT=7001 good_job start
+
+# Probe the status
+curl localhost:7001/status
+curl localhost:7001/status/started
+curl localhost:7001/status/connected
+```
+
+Multiple health checks are available at different paths:
+
+- `/` or `/status`: the CLI process is running
+- `/status/started`: the multithreaded job executor is running
+- `/status/connected`: the database connection is established
+
+This can be configured, for example with Kubernetes:
+
+```yaml
+spec:
+  containers:
+    - name: good_job
+      image: my_app:latest
+      env:
+        - name: RAILS_ENV
+          value: production
+        - name: GOOD_JOB_PROBE_PORT
+          value: 7001
+      command:
+          - good_job
+          - start
+      ports:
+        - name: probe-port
+          containerPort: 7001
+      startupProbe:
+        httpGet:
+          path: "/status/started"
+          port: probe-port
+        failureThreshold: 30
+        periodSeconds: 10
+      livenessProbe:
+        httpGet:
+          path: "/status/connected"
+          port: probe-port
+        failureThreshold: 1
+        periodSeconds: 10
+```
+
 ## Contribute
 
 Contributions are welcomed and appreciated 🙏

data/engine/app/charts/good_job/scheduled_by_queue_chart.rb

@@ -30,7 +30,10 @@ module GoodJob
         ORDER BY timestamp ASC
       SQL
 
-      binds = [[nil, start_time], [nil, end_time]]
+      binds = [
+        ActiveRecord::Relation::QueryAttribute.new('start_time', start_time, ActiveRecord::Type::DateTime.new),
+        ActiveRecord::Relation::QueryAttribute.new('end_time', end_time, ActiveRecord::Type::DateTime.new),
+      ]
       executions_data = GoodJob::Execution.connection.exec_query(GoodJob::Execution.pg_or_jdbc_query(count_query), "GoodJob Dashboard Chart", binds)
 
       queue_names = executions_data.reject { |d| d['count'].nil? }.map { |d| d['queue_name'] || BaseFilter::EMPTY }.uniq

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

@@ -5,6 +5,25 @@ module GoodJob
 
     around_action :switch_locale
 
+    content_security_policy do |policy|
+      policy.default_src(:none) if policy.default_src(*policy.default_src).blank?
+      policy.connect_src(:self) if policy.connect_src(*policy.connect_src).blank?
+      policy.base_uri(:none) if policy.base_uri(*policy.base_uri).blank?
+      policy.font_src(:self) if policy.font_src(*policy.font_src).blank?
+      policy.img_src(:self, :data) if policy.img_src(*policy.img_src).blank?
+      policy.object_src(:none) if policy.object_src(*policy.object_src).blank?
+      policy.script_src(:self) if policy.script_src(*policy.script_src).blank?
+      policy.style_src(:self) if policy.style_src(*policy.style_src).blank?
+      policy.form_action(:self) if policy.form_action(*policy.form_action).blank?
+      policy.frame_ancestors(:none) if policy.frame_ancestors(*policy.frame_ancestors).blank?
+    end
+
+    before_action do
+      next if request.content_security_policy_nonce_generator
+
+      request.content_security_policy_nonce_generator = ->(_request) { SecureRandom.base64(16) }
+    end
+
     private
 
     def switch_locale(&action)

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

@@ -14,7 +14,7 @@ module GoodJob
       query = base_query
       query = query.job_class(params[:job_class]) if params[:job_class].present?
       query = query.where(queue_name: params[:queue_name]) if params[:queue_name].present?
-      query = query.search(params['query']) if params[:query].present?
+      query = query.search_text(params[:query]) if params[:query].present?
 
       if params[:state]
         case params[:state]

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

@@ -18,7 +18,7 @@ module GoodJob
 
       query = query.job_class(params[:job_class]) if params[:job_class].present?
       query = query.where(queue_name: params[:queue_name]) if params[:queue_name].present?
-      query = query.search(params['query']) if params[:query].present?
+      query = query.search_text(params[:query]) if params[:query].present?
 
       if params[:state]
         case params[:state]

data/lib/good_job/adapter.rb

@@ -4,6 +4,12 @@ module GoodJob
   # ActiveJob Adapter.
   #
   class Adapter
+    # @!attribute [r] instances
+    #   @!scope class
+    #   List of all instantiated Adapters in the current process.
+    #   @return [Array<GoodJob::Adapter>, nil]
+    cattr_reader :instances, default: [], instance_reader: false
+
     # @param execution_mode [Symbol, nil] specifies how and where jobs should be executed. You can also set this with the environment variable +GOOD_JOB_EXECUTION_MODE+.
     #
     #  - +:inline+ executes jobs immediately in whatever process queued them (usually the web server process). This should only be used in test and development environments.
@@ -20,7 +26,8 @@ module GoodJob
     # @param max_threads [Integer, nil] sets the number of threads per scheduler to use when +execution_mode+ is set to +:async+. The +queues+ parameter can specify a number of threads for each group of queues which will override this value. You can also set this with the environment variable +GOOD_JOB_MAX_THREADS+. Defaults to +5+.
     # @param queues [String, nil] determines which queues to execute jobs from when +execution_mode+ is set to +:async+. See {file:README.md#optimize-queues-threads-and-processes} for more details on the format of this string. You can also set this with the environment variable +GOOD_JOB_QUEUES+. Defaults to +"*"+.
     # @param poll_interval [Integer, nil] sets the number of seconds between polls for jobs when +execution_mode+ is set to +:async+. You can also set this with the environment variable +GOOD_JOB_POLL_INTERVAL+. Defaults to +1+.
-    def initialize(execution_mode: nil, queues: nil, max_threads: nil, poll_interval: nil)
+    # @param start_async_on_initialize [Boolean] whether to start the async scheduler when the adapter is initialized.
+    def initialize(execution_mode: nil, queues: nil, max_threads: nil, poll_interval: nil, start_async_on_initialize: Rails.application.initialized?)
       @configuration = GoodJob::Configuration.new(
         {
           execution_mode: execution_mode,
@@ -30,16 +37,9 @@ module GoodJob
         }
       )
       @configuration.validate!
+      self.class.instances << self
 
-      if execute_async? # rubocop:disable Style/GuardClause
-        @notifier = GoodJob::Notifier.new
-        @poller = GoodJob::Poller.new(poll_interval: @configuration.poll_interval)
-        @scheduler = GoodJob::Scheduler.from_configuration(@configuration, warm_cache_on_initialize: Rails.application.initialized?)
-        @notifier.recipients << [@scheduler, :create_thread]
-        @poller.recipients << [@scheduler, :create_thread]
-
-        @cron_manager = GoodJob::CronManager.new(@configuration.cron_entries, start_on_initialize: Rails.application.initialized?) if @configuration.enable_cron?
-      end
+      start_async if start_async_on_initialize
     end
 
     # Enqueues the ActiveJob job to be performed.
@@ -74,7 +74,7 @@ module GoodJob
         job_state = { queue_name: execution.queue_name }
         job_state[:scheduled_at] = execution.scheduled_at if execution.scheduled_at
 
-        executed_locally = execute_async? && @scheduler.create_thread(job_state)
+        executed_locally = execute_async? && @scheduler&.create_thread(job_state)
         Notifier.notify(job_state) unless executed_locally
       end
 
@@ -97,6 +97,7 @@ module GoodJob
 
       executables = [@notifier, @poller, @scheduler].compact
       GoodJob._shutdown_all(executables, timeout: timeout)
+      @_async_started = false
     end
 
     # Whether in +:async+ execution mode.
@@ -119,6 +120,28 @@ module GoodJob
       @configuration.execution_mode == :inline
     end
 
+    # Start async executors
+    # @return void
+    def start_async
+      return unless execute_async?
+
+      @notifier = GoodJob::Notifier.new
+      @poller = GoodJob::Poller.new(poll_interval: @configuration.poll_interval)
+      @scheduler = GoodJob::Scheduler.from_configuration(@configuration, warm_cache_on_initialize: true)
+      @notifier.recipients << [@scheduler, :create_thread]
+      @poller.recipients << [@scheduler, :create_thread]
+
+      @cron_manager = GoodJob::CronManager.new(@configuration.cron_entries, start_on_initialize: true) if @configuration.enable_cron?
+
+      @_async_started = true
+    end
+
+    # Whether the async executors are running
+    # @return [Boolean]
+    def async_started?
+      @_async_started
+    end
+
     private
 
     # Whether running in a web server process.

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!
@@ -94,6 +97,11 @@ module GoodJob
 
       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|
         trap(signal) { @stop_good_job_executable = true }
@@ -106,6 +114,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

@@ -50,24 +50,22 @@ module GoodJob
     # for more details on possible values.
     # @return [Symbol]
     def execution_mode
-      @_execution_mode ||= begin
-        mode = if GoodJob::CLI.within_exe?
-                 :external
-               else
-                 options[:execution_mode] ||
-                   rails_config[:execution_mode] ||
-                   env['GOOD_JOB_EXECUTION_MODE']
-               end
-
-        if mode
-          mode.to_sym
-        elsif Rails.env.development?
-          :async
-        elsif Rails.env.test?
-          :inline
-        else
-          :external
-        end
+      mode = if GoodJob::CLI.within_exe?
+               :external
+             else
+               options[:execution_mode] ||
+                 rails_config[:execution_mode] ||
+                 env['GOOD_JOB_EXECUTION_MODE']
+             end
+
+      if mode
+        mode.to_sym
+      elsif Rails.env.development?
+        :async
+      elsif Rails.env.test?
+        :inline
+      else
+        :external
       end
     end
 
@@ -195,6 +193,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_manager.rb

@@ -21,7 +21,7 @@ module GoodJob # :nodoc:
     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)
+      GoodJob._on_thread_error(thread_error) if thread_error
     end
 
     # Execution configuration to be scheduled

data/lib/good_job/filterable.rb

@@ -24,12 +24,12 @@ module GoodJob
       end)
 
       # Search records by text query.
-      # @!method search(query)
+      # @!method search_text(query)
       # @!scope class
       # @param query [String]
       #   Search Query
       # @return [ActiveRecord::Relation]
-      scope :search, (lambda do |query|
+      scope :search_text, (lambda do |query|
         query = query.to_s.strip
         next if query.blank?
 

data/lib/good_job/job_performer.rb

@@ -13,9 +13,6 @@ module GoodJob
     # @param queue_string [String] Queues to execute jobs from
     def initialize(queue_string)
       @queue_string = queue_string
-
-      @job_query = Concurrent::Delay.new { GoodJob::Execution.queue_string(queue_string) }
-      @parsed_queues = Concurrent::Delay.new { GoodJob::Execution.queue_parser(queue_string) }
     end
 
     # A meaningful name to identify the performer in logs and for debugging.
@@ -65,11 +62,11 @@ module GoodJob
     attr_reader :queue_string
 
     def job_query
-      @job_query.value
+      @_job_query ||= GoodJob::Execution.queue_string(queue_string)
     end
 
     def parsed_queues
-      @parsed_queues.value
+      @_parsed_queues ||= GoodJob::Execution.queue_parser(queue_string)
     end
   end
 end

data/lib/good_job/lockable.rb

@@ -24,7 +24,7 @@ module GoodJob
 
     included do
       # Default column to be used when creating Advisory Locks
-      class_attribute :advisory_lockable_column, instance_accessor: false, default: Concurrent::Delay.new { primary_key }
+      class_attribute :advisory_lockable_column, instance_accessor: false, default: nil
 
       # Default Postgres function to be used for Advisory Locks
       class_attribute :advisory_lockable_function, default: "pg_try_advisory_lock"
@@ -161,10 +161,8 @@ module GoodJob
         end
       end
 
-      # Allow advisory_lockable_column to be a `Concurrent::Delay`
       def _advisory_lockable_column
-        column = advisory_lockable_column
-        column.respond_to?(:value) ? column.value : column
+        advisory_lockable_column || primary_key
       end
 
       def supports_cte_materialization_specifiers?
@@ -217,7 +215,9 @@ module GoodJob
                 SQL
               end
 
-      binds = [[nil, key]]
+      binds = [
+        ActiveRecord::Relation::QueryAttribute.new('key', key, ActiveRecord::Type::String.new),
+      ]
       self.class.connection.exec_query(pg_or_jdbc_query(query), 'GoodJob::Lockable Advisory Lock', binds).first['locked']
     end
 
@@ -231,7 +231,9 @@ module GoodJob
       query = <<~SQL.squish
         SELECT #{function}(('x'||substr(md5($1::text), 1, 16))::bit(64)::bigint) AS unlocked
       SQL
-      binds = [[nil, key]]
+      binds = [
+        ActiveRecord::Relation::QueryAttribute.new('key', key, ActiveRecord::Type::String.new),
+      ]
       self.class.connection.exec_query(pg_or_jdbc_query(query), 'GoodJob::Lockable Advisory Unlock', binds).first['unlocked']
     end
 
@@ -281,7 +283,10 @@ module GoodJob
           AND pg_locks.classid = ('x' || substr(md5($1::text), 1, 16))::bit(32)::int
           AND pg_locks.objid = (('x' || substr(md5($2::text), 1, 16))::bit(64) << 32)::bit(32)::int
       SQL
-      binds = [[nil, key], [nil, key]]
+      binds = [
+        ActiveRecord::Relation::QueryAttribute.new('key', key, ActiveRecord::Type::String.new),
+        ActiveRecord::Relation::QueryAttribute.new('key', key, ActiveRecord::Type::String.new),
+      ]
       self.class.connection.exec_query(pg_or_jdbc_query(query), 'GoodJob::Lockable Advisory Locked?', binds).any?
     end
 
@@ -305,7 +310,10 @@ module GoodJob
           AND pg_locks.objid = (('x' || substr(md5($2::text), 1, 16))::bit(64) << 32)::bit(32)::int
           AND pg_locks.pid = pg_backend_pid()
       SQL
-      binds = [[nil, key], [nil, key]]
+      binds = [
+        ActiveRecord::Relation::QueryAttribute.new('key', key, ActiveRecord::Type::String.new),
+        ActiveRecord::Relation::QueryAttribute.new('key', key, ActiveRecord::Type::String.new),
+      ]
       self.class.connection.exec_query(pg_or_jdbc_query(query), 'GoodJob::Lockable Owns Advisory Lock?', binds).any?
     end
 

data/lib/good_job/notifier.rb

@@ -120,7 +120,7 @@ module GoodJob # :nodoc:
       return if thread_error.is_a? AdapterCannotListenError
 
       if thread_error
-        GoodJob.on_thread_error.call(thread_error) if GoodJob.on_thread_error.respond_to?(:call)
+        GoodJob._on_thread_error(thread_error)
         ActiveSupport::Notifications.instrument("notifier_notify_error.good_job", { error: thread_error })
 
         connection_error = CONNECTION_ERRORS.any? do |error_string|

data/lib/good_job/poller.rb

@@ -91,7 +91,7 @@ module GoodJob # :nodoc:
     # @param thread_error [Exception, nil]
     # @return [void]
     def timer_observer(time, executed_task, thread_error)
-      GoodJob.on_thread_error.call(thread_error) if thread_error && GoodJob.on_thread_error.respond_to?(:call)
+      GoodJob._on_thread_error(thread_error) if thread_error
       ActiveSupport::Notifications.instrument("finished_timer_task", { result: executed_task, error: thread_error, time: time })
     end
 

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(thread_error) if thread_error
+    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/railtie.rb

@@ -7,7 +7,7 @@ module GoodJob
 
     initializer "good_job.logger" do |_app|
       ActiveSupport.on_load(:good_job) do
-        self.logger = ::Rails.logger
+        self.logger = ::Rails.logger if GoodJob.logger == GoodJob::DEFAULT_LOGGER
       end
       GoodJob::LogSubscriber.attach_to :good_job
     end
@@ -22,9 +22,19 @@ module GoodJob
       end
     end
 
-    config.after_initialize do
-      GoodJob::Scheduler.instances.each(&:warm_cache)
-      GoodJob::CronManager.instances.each(&:start)
+    initializer 'good_job.rails_config' do
+      config.after_initialize do
+        GoodJob.logger = Rails.application.config.good_job.logger unless Rails.application.config.good_job.logger.nil?
+        GoodJob.on_thread_error = Rails.application.config.good_job.on_thread_error unless Rails.application.config.good_job.on_thread_error.nil?
+        GoodJob.preserve_job_records = Rails.application.config.good_job.preserve_job_records unless Rails.application.config.good_job.preserve_job_records.nil?
+        GoodJob.retry_on_unhandled_error = Rails.application.config.good_job.retry_on_unhandled_error unless Rails.application.config.good_job.retry_on_unhandled_error.nil?
+      end
+    end
+
+    initializer "good_job.start_async" do
+      config.after_initialize do
+        GoodJob::Adapter.instances.each(&:start_async)
+      end
     end
   end
 end

data/lib/good_job/scheduler.rb

@@ -169,7 +169,7 @@ module GoodJob # :nodoc:
     # @return [void]
     def task_observer(time, output, thread_error)
       error = thread_error || (output.is_a?(GoodJob::ExecutionResult) ? output.unhandled_error : nil)
-      GoodJob.on_thread_error.call(error) if error && GoodJob.on_thread_error.respond_to?(:call)
+      GoodJob._on_thread_error(error) if error
 
       instrument("finished_job_task", { result: output, error: thread_error, time: time })
       create_task if output
@@ -206,7 +206,7 @@ module GoodJob # :nodoc:
       end
 
       observer = lambda do |_time, _output, thread_error|
-        GoodJob.on_thread_error.call(thread_error) if thread_error && GoodJob.on_thread_error.respond_to?(:call)
+        GoodJob._on_thread_error(thread_error) if thread_error
         create_task # If cache-warming exhausts the threads, ensure there isn't an executable task remaining
       end
       future.add_observer(observer, :call)

data/lib/good_job/version.rb

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

data/lib/good_job.rb

@@ -18,6 +18,8 @@ require "good_job/railtie"
 #
 # +GoodJob+ is the top-level namespace and exposes configuration attributes.
 module GoodJob
+  DEFAULT_LOGGER = ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new($stdout))
+
   # @!attribute [rw] active_record_parent_class
   #   @!scope class
   #   The ActiveRecord parent class inherited by +GoodJob::Execution+ (default: +ActiveRecord::Base+).
@@ -34,7 +36,7 @@ module GoodJob
   #   @return [Logger, nil]
   #   @example Output GoodJob logs to a file:
   #     GoodJob.logger = ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new("log/my_logs.log"))
-  mattr_accessor :logger, default: ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new($stdout))
+  mattr_accessor :logger, default: DEFAULT_LOGGER
 
   # @!attribute [rw] preserve_job_records
   #   @!scope class
@@ -66,6 +68,13 @@ module GoodJob
   #   @return [Proc, nil]
   mattr_accessor :on_thread_error, default: nil
 
+  # Called with exception when a GoodJob thread raises an exception
+  # @param exception [Exception] Exception that was raised
+  # @return [void]
+  def self._on_thread_error(exception)
+    on_thread_error.call(exception) if on_thread_error.respond_to?(:call)
+  end
+
   # Stop executing jobs.
   # GoodJob does its work in pools of background threads.
   # When forking processes you should shut down these background threads before forking, and restart them after forking.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 2.6.1
+  version: 2.7.2
 platform: ruby
 authors:
 - Ben Sheldon
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-11-05 00:00:00.000000000 Z
+date: 2021-11-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
@@ -94,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.14.1
+- !ruby/object:Gem::Dependency
+  name: webrick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
@@ -410,6 +424,7 @@ files:
 - lib/good_job/multi_scheduler.rb
 - lib/good_job/notifier.rb
 - lib/good_job/poller.rb
+- lib/good_job/probe_server.rb
 - lib/good_job/railtie.rb
 - lib/good_job/scheduler.rb
 - lib/good_job/version.rb