good_job 1.4.1 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ac71f85784bd491d995252ed498d55642ee511a402ad093cc056fd2e062a437b
-  data.tar.gz: 33f1a9ebf6952f3140046338bb616a4a81c469b4099f526e56d15b9aa1f8951d
+  metadata.gz: 89ef994e63adf5fe8dcbcdd230d9669d21c2cb6d9c62da622c8d8a197fcb3cef
+  data.tar.gz: 6ed6d2cc6f75c5b4dc6976f3e360a5aeb27e3488fbd8035d086058b40d693025
 SHA512:
-  metadata.gz: 1660dd44eca81ce42cbdb917253dfb340d5e5a4b371275f51eb919fc5aacb3485c6bbd87164d49d07547682efe311fb1a41bce35599ab5d45b8bd669d1e840c2
-  data.tar.gz: 1c2994d95046ea9f692539dffcb0bfa33d81daed73886a2fef7ab9c9c6063b4085c17f8cc7ed93bcfab999ca25ffef1db31fa82344e3a31a6dcbdc3a84c966ed
+  metadata.gz: f8d856f3797236bffecfffe5bcb58599aa0b2f843962fe09032eb0606d432d1f379dd564d00e29512bd6e3ca0c26c261401eed4b45806f21c660d9cd1a9a4838
+  data.tar.gz: cd223dc763e1bb56d746f957aec29403ed78b6d89619fd4d4b23148d2f78a86c452e29e48249cf408cc4fff7c0ee564eb7032d9b02b24239a2d0215f40df5194

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [v1.5.0](https://github.com/bensheldon/good_job/tree/v1.5.0) (2021-01-17)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v1.4.1...v1.5.0)
+
+**Implemented enhancements:**
+
+- Create Web UI Dashboard [\#50](https://github.com/bensheldon/good_job/issues/50)
+
+**Closed issues:**
+
+- JRuby Support [\#160](https://github.com/bensheldon/good_job/issues/160)
+
+**Merged pull requests:**
+
+- Update bundler version to 2.2.5 [\#200](https://github.com/bensheldon/good_job/pull/200) ([bensheldon](https://github.com/bensheldon))
+- Configure GoodJob via `Rails.application.config` instead of recommending `GoodJob::Adapter.new` [\#199](https://github.com/bensheldon/good_job/pull/199) ([bensheldon](https://github.com/bensheldon))
+- Update GH Test Matrix with minimum & latest JRuby version [\#197](https://github.com/bensheldon/good_job/pull/197) ([tedhexaflow](https://github.com/tedhexaflow))
+- Fix JRuby version number [\#193](https://github.com/bensheldon/good_job/pull/193) ([tedhexaflow](https://github.com/tedhexaflow))
+
 ## [v1.4.1](https://github.com/bensheldon/good_job/tree/v1.4.1) (2021-01-09)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v1.4.0...v1.4.1)
@@ -22,6 +41,7 @@
 
 **Implemented enhancements:**
 
+- Format serialized params to ease reading [\#170](https://github.com/bensheldon/good_job/pull/170) ([morgoth](https://github.com/morgoth))
 - Add JRuby support [\#167](https://github.com/bensheldon/good_job/pull/167) ([bensheldon](https://github.com/bensheldon))
 
 ## [v1.3.6](https://github.com/bensheldon/good_job/tree/v1.3.6) (2020-12-30)
@@ -97,7 +117,6 @@
 **Implemented enhancements:**
 
 - Extract polling from scheduler into Polling object [\#128](https://github.com/bensheldon/good_job/issues/128)
-- Format serialized params to ease reading [\#170](https://github.com/bensheldon/good_job/pull/170) ([morgoth](https://github.com/morgoth))
 
 **Fixed bugs:**
 
@@ -508,7 +527,6 @@
 - Add pg gem as explicit dependency [\#13](https://github.com/bensheldon/good_job/pull/13) ([bensheldon](https://github.com/bensheldon))
 - Bump nokogiri from 1.10.7 to 1.10.9 [\#12](https://github.com/bensheldon/good_job/pull/12) ([dependabot[bot]](https://github.com/apps/dependabot))
 - Add Appraisal with tests for Rails 5.1, 5.2, 6.0 [\#11](https://github.com/bensheldon/good_job/pull/11) ([bensheldon](https://github.com/bensheldon))
-- Use Rails.logger and ActiveSupport::Notifications for logging instead of puts [\#10](https://github.com/bensheldon/good_job/pull/10) ([bensheldon](https://github.com/bensheldon))
 
 ## [v0.2.0](https://github.com/bensheldon/good_job/tree/v0.2.0) (2020-03-06)
 
@@ -516,6 +534,7 @@
 
 **Merged pull requests:**
 
+- Use Rails.logger and ActiveSupport::Notifications for logging instead of puts [\#10](https://github.com/bensheldon/good_job/pull/10) ([bensheldon](https://github.com/bensheldon))
 - Remove minitest files [\#9](https://github.com/bensheldon/good_job/pull/9) ([bensheldon](https://github.com/bensheldon))
 - Use scheduled\_at and priority for scheduling [\#8](https://github.com/bensheldon/good_job/pull/8) ([bensheldon](https://github.com/bensheldon))
 - Create Github Action workflow for PRs and Issues [\#7](https://github.com/bensheldon/good_job/pull/7) ([bensheldon](https://github.com/bensheldon))

data/README.md

@@ -35,8 +35,8 @@ For more of the story of GoodJob, read the [introductory blog post](https://isla
     - [Command-line options](#command-line-options)
         - [`good_job start`](#good_job-start)
         - [`good_job cleanup_preserved_jobs`](#good_job-cleanup_preserved_jobs)
-    - [Adapter options](#adapter-options)
-    - [Global options](#global-options)
+    - [Configuration options](#configuration-options)
+    - [Global options](#global-options)pter
     - [Dashboard](#dashboard)
 - [Go deeper](#go-deeper)
     - [Exceptions, retries, and reliability](#exceptions-retries-and-reliability)
@@ -127,7 +127,7 @@ For more of the story of GoodJob, read the [introductory blog post](https://isla
 ## Compatibility
 
 - **Ruby on Rails:** 5.2+
-- **Ruby:** MRI 2.5+. JRuby 9.13+ (_JRuby's `activerecord-jdbcpostgresql-adapter` gem does not support Postgres LISTEN/NOTIFY)._
+- **Ruby:** MRI 2.5+. JRuby 9.2.13+ (_JRuby's `activerecord-jdbcpostgresql-adapter` gem does not support Postgres LISTEN/NOTIFY)._
 - **Postgres:** 9.6+
 
 ## Configuration
@@ -189,9 +189,31 @@ If you are preserving job records this way, use this command regularly
 to delete old records and preserve space in your database.
 ```
 
-### Adapter options
+### Configuration options
 
-To use GoodJob, you can set `config.active_job.queue_adapter` to a `:good_job` or to an instance of `GoodJob::Adapter`, which you can configure with several options:
+To use GoodJob, you can set `config.active_job.queue_adapter` to a `:good_job`.
+
+Additional configuration can be provided via `config.good_job.OPTION = ...` for example:
+
+```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
+
+# ...or all at once.
+config.good_job = {
+  execution_mode: :async,
+  max_threads: 5,
+  poll_interval: 30,
+}
+```
+
+Available configuration options are:
 
 - `execution_mode` (symbol) specifies how and where jobs should be executed. You can also set this with the environment variable `GOOD_JOB_EXECUTION_MODE`. It can be any one of:
     - `:inline` executes jobs immediately in whatever process queued them (usually the web server process). This should only be used in test and development environments.
@@ -201,17 +223,21 @@ To use GoodJob, you can set `config.active_job.queue_adapter` to a `:good_job` o
 - `queues` (string) determines which queues to execute jobs from when `execution_mode` is set to `:async`. See the description of `good_job start` for more details on the format of this string. You can also set this with the environment variable `GOOD_JOB_QUEUES`.
 - `poll_interval` (integer) 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`.
 
-Using the symbol instead of explicitly configuring the options above (i.e. setting `config.active_job.queue_adapter = :good_job`) is equivalent to:
+By default, GoodJob configures the following execution modes per environment:
 
 ```ruby
+
 # config/environments/development.rb
-config.active_job.queue_adapter = GoodJob::Adapter.new(execution_mode: :inline)
+config.active_job.queue_adapter = :good_job
+config.good_job.execution_mode = :inline
 
 # config/environments/test.rb
-config.active_job.queue_adapter = GoodJob::Adapter.new(execution_mode: :inline)
+config.active_job.queue_adapter = :good_job
+config.good_job.execution_mode = :inline
 
 # config/environments/production.rb
-config.active_job.queue_adapter = GoodJob::Adapter.new(execution_mode: :external)
+config.active_job.queue_adapter = :good_job
+config.good_job.execution_mode = :external
 ```
 
 ### Global options
@@ -442,14 +468,24 @@ pool: <%= [ENV.fetch("RAILS_MAX_THREADS", 5).to_i, ENV.fetch("GOOD_JOB_MAX_THREA
 
 GoodJob can execute jobs "async" in the same process as the webserver (e.g. `bin/rail s`). GoodJob's async execution mode offers benefits of economy by not requiring a separate job worker process, but with the tradeoff of increased complexity. Async mode can be configured in two ways:
 
-- Directly configure the ActiveJob adapter:
+- Via Rails configuration:
 
     ```ruby
     # config/environments/production.rb
-    config.active_job.queue_adapter = GoodJob::Adapter.new(execution_mode: :async, max_threads: 4, poll_interval: 30)
+    config.active_job.queue_adapter = :good_job
+
+    # To change the execution mode
+    config.good_job.execution_mode = :async
+
+    # Or with more configuration
+    config.good_job = {
+      execution_mode: :async,
+      max_threads: 4,
+      poll_interval: 30
+    }
     ```
 
-- Or, when using `...queue_adapter = :good_job`, via environment variables:
+- Or, with environment variables:
 
     ```bash
     $ GOOD_JOB_EXECUTION_MODE=async GOOD_JOB_MAX_THREADS=4 GOOD_JOB_POLL_INTERVAL=30 bin/rails server

data/lib/active_job/queue_adapters/good_job_adapter.rb

@@ -2,9 +2,9 @@ module ActiveJob # :nodoc:
   module QueueAdapters # :nodoc:
     # See {GoodJob::Adapter} for details.
     class GoodJobAdapter < GoodJob::Adapter
-      def initialize(execution_mode: nil, max_threads: nil, poll_interval: nil, scheduler: nil, inline: false)
-        configuration = GoodJob::Configuration.new({ execution_mode: execution_mode }, env: ENV)
-        super(execution_mode: configuration.rails_execution_mode, max_threads: max_threads, poll_interval: poll_interval, scheduler: scheduler, inline: inline)
+      def initialize(**options)
+        configuration = GoodJob::Configuration.new(options, env: ENV)
+        super(**options.merge(execution_mode: configuration.rails_execution_mode))
       end
     end
   end

data/lib/good_job/adapter.rb

@@ -20,13 +20,22 @@ module GoodJob
     # @param max_threads [nil, Integer] 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 [nil, String] 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 [nil, Integer] 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+.
-    # @param scheduler [nil, Scheduler] (deprecated) a scheduler to be managed by the adapter
-    # @param notifier [nil, Notifier] (deprecated) a notifier to be managed by the adapter
-    # @param inline [nil, Boolean] (deprecated) whether to run in inline execution mode
-    def initialize(execution_mode: nil, queues: nil, max_threads: nil, poll_interval: nil, scheduler: nil, notifier: nil, inline: false)
-      if inline && execution_mode.nil?
-        ActiveSupport::Deprecation.warn('GoodJob::Adapter#new(inline: true) is deprecated; use GoodJob::Adapter.new(execution_mode: :inline) instead')
-        execution_mode = :inline
+    def initialize(execution_mode: nil, queues: nil, max_threads: nil, poll_interval: nil)
+      if caller[0..4].find { |c| c.include?("/config/application.rb") || c.include?("/config/environments/") }
+        ActiveSupport::Deprecation.warn(<<~DEPRECATION)
+          GoodJob no longer recommends creating a GoodJob::Adapter instance:
+
+              config.active_job.queue_adapter = GoodJob::Adapter.new...
+
+          Instead, configure GoodJob through configuration:
+
+              config.active_job.queue_adapter = :good_job
+              config.good_job.execution_mode = :#{execution_mode}
+              config.good_job.max_threads = #{max_threads}
+              config.good_job.poll_interval = #{poll_interval}
+              # etc...
+
+        DEPRECATION
       end
 
       configuration = GoodJob::Configuration.new(
@@ -42,9 +51,9 @@ module GoodJob
       raise ArgumentError, "execution_mode: must be one of #{EXECUTION_MODES.join(', ')}." unless EXECUTION_MODES.include?(@execution_mode)
 
       if @execution_mode == :async # rubocop:disable Style/GuardClause
-        @notifier = notifier || GoodJob::Notifier.new
+        @notifier = GoodJob::Notifier.new
         @poller = GoodJob::Poller.new(poll_interval: configuration.poll_interval)
-        @scheduler = scheduler || GoodJob::Scheduler.from_configuration(configuration)
+        @scheduler = GoodJob::Scheduler.from_configuration(configuration)
         @notifier.recipients << [@scheduler, :create_thread]
         @poller.recipients << [@scheduler, :create_thread]
       end
@@ -108,11 +117,5 @@ module GoodJob
     def execute_inline?
       @execution_mode == :inline
     end
-
-    # (deprecated) Whether in +:inline+ execution mode.
-    def inline?
-      ActiveSupport::Deprecation.warn('GoodJob::Adapter::inline? is deprecated; use GoodJob::Adapter::execute_inline? instead')
-      execute_inline?
-    end
   end
 end

data/lib/good_job/configuration.rb

@@ -45,6 +45,8 @@ module GoodJob
     def execution_mode(default: :external)
       if options[:execution_mode]
         options[:execution_mode]
+      elsif rails_config[:execution_mode]
+        rails_config[:execution_mode]
       elsif env['GOOD_JOB_EXECUTION_MODE'].present?
         env['GOOD_JOB_EXECUTION_MODE'].to_sym
       else
@@ -72,6 +74,7 @@ module GoodJob
     def max_threads
       (
         options[:max_threads] ||
+        rails_config[:max_threads] ||
         env['GOOD_JOB_MAX_THREADS'] ||
         env['RAILS_MAX_THREADS'] ||
         DEFAULT_MAX_THREADS
@@ -85,6 +88,7 @@ module GoodJob
     # @return [String]
     def queue_string
       options[:queues] ||
+        rails_config[:queues] ||
         env['GOOD_JOB_QUEUES'] ||
         '*'
     end
@@ -96,6 +100,7 @@ module GoodJob
     def poll_interval
       (
         options[:poll_interval] ||
+        rails_config[:poll_interval] ||
         env['GOOD_JOB_POLL_INTERVAL'] ||
         DEFAULT_POLL_INTERVAL
       ).to_i
@@ -107,9 +112,16 @@ module GoodJob
     def cleanup_preserved_jobs_before_seconds_ago
       (
         options[:before_seconds_ago] ||
+        rails_config[:cleanup_preserved_jobs_before_seconds_ago] ||
         env['GOOD_JOB_CLEANUP_PRESERVED_JOBS_BEFORE_SECONDS_AGO'] ||
         DEFAULT_CLEANUP_PRESERVED_JOBS_BEFORE_SECONDS_AGO
       ).to_i
     end
+
+    private
+
+    def rails_config
+      Rails.application.config.good_job
+    end
   end
 end

data/lib/good_job/job_performer.rb

@@ -0,0 +1,63 @@
+require 'concurrent/delay'
+
+module GoodJob
+  #
+  # JobPerformer queries the database for jobs and performs them on behalf of a
+  # {Scheduler}. It mainly functions as glue between a {Scheduler} and the jobs
+  # it should be executing.
+  #
+  # The JobPerformer must be safe to execute across multiple threads.
+  #
+  class JobPerformer
+    # @param queue_string [String] Queues to execute jobs from
+    def initialize(queue_string)
+      @queue_string = queue_string
+
+      @job_query = Concurrent::Delay.new { GoodJob::Job.queue_string(queue_string) }
+      @parsed_queues = Concurrent::Delay.new { GoodJob::Job.queue_parser(queue_string) }
+    end
+
+    # A meaningful name to identify the performer in logs and for debugging.
+    # @return [String] The queues from which Jobs are worked
+    def name
+      @queue_string
+    end
+
+    # Perform the next eligible job
+    # @return [nil, Object] Returns job result or +nil+ if no job was found
+    def next
+      job_query.perform_with_advisory_lock
+    end
+
+    # Tests whether this performer should be used in GoodJob's current state.
+    #
+    # For example, state will be a LISTEN/NOTIFY message that is passed down
+    # from the Notifier to the Scheduler. The Scheduler is able to ask
+    # its performer "does this message relate to you?", and if not, ignore it
+    # to minimize thread wake-ups, database queries, and thundering herds.
+    #
+    # @return [Boolean] whether the performer's {#next} method should be
+    #   called in the current state.
+    def next?(state = {})
+      if parsed_queues[:exclude]
+        parsed_queues[:exclude].exclude?(state[:queue_name])
+      elsif parsed_queues[:include]
+        parsed_queues[:include].include?(state[:queue_name])
+      else
+        true
+      end
+    end
+
+    private
+
+    attr_reader :queue_string
+
+    def job_query
+      @job_query.value
+    end
+
+    def parsed_queues
+      @parsed_queues.value
+    end
+  end
+end

data/lib/good_job/railtie.rb

@@ -1,8 +1,12 @@
 module GoodJob
   # Ruby on Rails integration.
   class Railtie < ::Rails::Railtie
-    initializer "good_job.logger" do
-      ActiveSupport.on_load(:good_job) { self.logger = ::Rails.logger }
+    config.good_job = ActiveSupport::OrderedOptions.new
+
+    initializer "good_job.logger" do |_app|
+      ActiveSupport.on_load(:good_job) do
+        self.logger = ::Rails.logger
+      end
       GoodJob::LogSubscriber.attach_to :good_job
     end
 

data/lib/good_job/scheduler.rb

@@ -40,19 +40,7 @@ module GoodJob # :nodoc:
         queue_string, max_threads = queue_string_and_max_threads.split(':')
         max_threads = (max_threads || configuration.max_threads).to_i
 
-        job_query = GoodJob::Job.queue_string(queue_string)
-        parsed = GoodJob::Job.queue_parser(queue_string)
-        job_filter = proc do |state|
-          if parsed[:exclude]
-            parsed[:exclude].exclude?(state[:queue_name])
-          elsif parsed[:include]
-            parsed[:include].include? state[:queue_name]
-          else
-            true
-          end
-        end
-        job_performer = GoodJob::Performer.new(job_query, :perform_with_advisory_lock, name: queue_string, filter: job_filter)
-
+        job_performer = GoodJob::JobPerformer.new(queue_string)
         GoodJob::Scheduler.new(job_performer, max_threads: max_threads)
       end
 
@@ -63,7 +51,7 @@ module GoodJob # :nodoc:
       end
     end
 
-    # @param performer [GoodJob::Performer]
+    # @param performer [GoodJob::JobPerformer]
     # @param max_threads [Numeric, nil] number of seconds between polls for jobs
     def initialize(performer, max_threads: nil)
       raise ArgumentError, "Performer argument must implement #next" unless performer.respond_to?(:next)

data/lib/good_job/version.rb

@@ -1,4 +1,4 @@
 module GoodJob
   # GoodJob gem version.
-  VERSION = '1.4.1'.freeze
+  VERSION = '1.5.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 1.4.1
+  version: 1.5.0
 platform: ruby
 authors:
 - Ben Sheldon
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-09 00:00:00.000000000 Z
+date: 2021-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
@@ -358,11 +358,11 @@ files:
 - lib/good_job/configuration.rb
 - lib/good_job/current_execution.rb
 - lib/good_job/job.rb
+- lib/good_job/job_performer.rb
 - lib/good_job/lockable.rb
 - lib/good_job/log_subscriber.rb
 - lib/good_job/multi_scheduler.rb
 - lib/good_job/notifier.rb
-- lib/good_job/performer.rb
 - lib/good_job/poller.rb
 - lib/good_job/railtie.rb
 - lib/good_job/scheduler.rb

data/lib/good_job/performer.rb

@@ -1,60 +0,0 @@
-module GoodJob
-  #
-  # Performer queries the database for jobs and performs them on behalf of a
-  # {Scheduler}. It mainly functions as glue between a {Scheduler} and the jobs
-  # it should be executing.
-  #
-  # The Performer enforces a callable that does not rely on scoped/closure
-  # variables because they might not be available when executed in a different
-  # thread.
-  #
-  class Performer
-    # @!attribute [r] name
-    # @return [String]
-    #   a meaningful name to identify the performer in logs and for debugging.
-    #   This is usually set to the list of queues the performer will query,
-    #   e.g. +"-transactional_messages,batch_processing"+.
-    attr_reader :name
-
-    # @param target [Object]
-    #   An object that can perform jobs. It must respond to +method_name+ by
-    #   finding and performing jobs and is usually a {Job} query,
-    #   e.g. +GoodJob::Job.where(queue_name: ['queue1', 'queue2'])+.
-    # @param method_name [Symbol]
-    #   The name of a method on +target+ that finds and performs jobs.
-    # @param name [String]
-    #   A name for the performer to be used in logs and for debugging.
-    # @param filter [#call]
-    #   Used to determine whether the performer should be used in GoodJob's
-    #   current state. GoodJob state is a +Hash+ that will be passed as the
-    #   first argument to +filter+ and includes info like the current queue.
-    def initialize(target, method_name, name: nil, filter: nil)
-      @target = target
-      @method_name = method_name
-      @name = name
-      @filter = filter
-    end
-
-    # Find and perform any eligible jobs.
-    def next
-      @target.public_send(@method_name)
-    end
-
-    # Tests whether this performer should be used in GoodJob's current state by
-    # calling the +filter+ callable set in {#initialize}. Always returns +true+
-    # if there is no filter.
-    #
-    # For example, state will be a LISTEN/NOTIFY message that is passed down
-    # from the Notifier to the Scheduler. The Scheduler is able to ask
-    # its performer "does this message relate to you?", and if not, ignore it
-    # to minimize thread wake-ups, database queries, and thundering herds.
-    #
-    # @return [Boolean] whether the performer's {#next} method should be
-    #   called in the current state.
-    def next?(state = {})
-      return true unless @filter.respond_to?(:call)
-
-      @filter.call(state)
-    end
-  end
-end