good_job 1.99.1 → 2.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97662bae9e8ba65e5ed3e9ba52b8b987d77974866885a548a8a3b13878045c7a
-  data.tar.gz: 415d36696796cfb4c0ff1737c7c75e2b66bbfceea15f3a90aba55b49ee5da715
+  metadata.gz: d4c1686f53ec7019417a342069c499c829dccb4f8cfcbd7396623b96e9edd2fe
+  data.tar.gz: de4e3d7a20e47c63aad25dd167a640b83a9349f0b8933d4692afc6f8b12d16d3
 SHA512:
-  metadata.gz: 2d293eabb7b926386b30a1348c529de6a2252c1c734b7a92a81abad2fdd791a28abe5067850c9a4f7595182afd72d52eccc0c640d7596aaddcba467a995449ca
-  data.tar.gz: 4b981bda934dc7e58aab80bd998c16b9c8261309cf8f5ffce09253c45821f0106ef0db0249934a3649e735715d865ff6dd62232876afb7ffca76cfb4fe473179
+  metadata.gz: dfe017b7ea652b134c009622e5a7b1d83e7d502a4f066b49538ffca138555f4395d6279f7256a10c872e1967aa127bb82eba17a72fbf8930adcd12da9650dbf4
+  data.tar.gz: 1e5178b1d9ddf492347e6f25b10bae710dc25454974436fad322b306698a25bdf29d777f54de5c988479b56a21d2b0a8cfdc7b7f87799ae5cf6f7df4c76f4b6b

data/CHANGELOG.md

@@ -1,18 +1,39 @@
 # Changelog
 
-## [v1.99.1](https://github.com/bensheldon/good_job/tree/v1.99.1) (2021-08-27)
+## [v2.0.3](https://github.com/bensheldon/good_job/tree/v2.0.3) (2021-08-31)
 
-[Full Changelog](https://github.com/bensheldon/good_job/compare/v2.0.1...v1.99.1)
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v2.0.2...v2.0.3)
 
 **Closed issues:**
 
-- Does Good job support delay method? [\#344](https://github.com/bensheldon/good_job/issues/344)
+- Expose CLI `cleanup_preserved_jobs` functionality via `GoodJob`? [\#351](https://github.com/bensheldon/good_job/issues/351)
 
 **Merged pull requests:**
 
+- Implement `GoodJob.cleanup_preserved_jobs`, fixes \#351 [\#356](https://github.com/bensheldon/good_job/pull/356) ([aried3r](https://github.com/aried3r))
+
+## [v2.0.2](https://github.com/bensheldon/good_job/tree/v2.0.2) (2021-08-27)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v1.99.1...v2.0.2)
+
+**Closed issues:**
+
+- Migrations generator assumes migrations are in db/migrate [\#352](https://github.com/bensheldon/good_job/issues/352)
+
+**Merged pull requests:**
+
+- v2.0: Generators support multiple databases: `--database` option, `migrations_paths`, custom `GoodJob.active_record_parent_class` [\#354](https://github.com/bensheldon/good_job/pull/354) ([bensheldon](https://github.com/bensheldon))
 - README style/typo fixes: "web server" and possessive "Rails'" [\#350](https://github.com/bensheldon/good_job/pull/350) ([aried3r](https://github.com/aried3r))
 - Add examples of setting config.good\_job.queues [\#349](https://github.com/bensheldon/good_job/pull/349) ([zachmargolis](https://github.com/zachmargolis))
 
+## [v1.99.1](https://github.com/bensheldon/good_job/tree/v1.99.1) (2021-08-27)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v2.0.1...v1.99.1)
+
+**Closed issues:**
+
+- Does Good job support delay method? [\#344](https://github.com/bensheldon/good_job/issues/344)
+
 ## [v2.0.1](https://github.com/bensheldon/good_job/tree/v2.0.1) (2021-08-24)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v2.0.0...v2.0.1)

data/README.md

@@ -132,10 +132,10 @@ For more of the story of GoodJob, read the [introductory blog post](https://isla
     - GoodJob can also be configured to execute jobs within the web server process to save on resources. This is useful for low-workloads when economy is paramount.
 
         ```
-        $ GOOD_JOB_EXECUTION_MODE=async_server rails server
+        $ GOOD_JOB_EXECUTION_MODE=async rails server
         ```
 
-        Additional configuration is likely necessary, see the reference below for f configuration.
+        Additional configuration is likely necessary, see the reference below for configuration.
 
 ## Compatibility
 
@@ -184,7 +184,7 @@ separate isolated execution pools with semicolons and threads with colons.
 
 #### `good_job cleanup_preserved_jobs`
 
-`good_job cleanup_preserved_jobs` deletes preserved job records. See [`GoodJob.preserve_job_records` for when this command is useful.
+`good_job cleanup_preserved_jobs` deletes preserved job records. See `GoodJob.preserve_job_records` for when this command is useful.
 
 ```bash
 $ bundle exec good_job help cleanup_preserved_jobs
@@ -220,16 +220,17 @@ Additional configuration can be provided via `config.good_job.OPTION = ...` for
 config.active_job.queue_adapter = :good_job
 
 # Configure options individually...
-config.good_job.execution_mode = :async_server
+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_server,
+  execution_mode: :async,
   max_threads: 5,
   poll_interval: 30,
   shutdown_timeout: 25,
@@ -240,6 +241,7 @@ config.good_job = {
       class: 'ExampleJob'
     },
   },
+  queues: '*',
 }
 ```
 
@@ -248,11 +250,11 @@ 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.
     - `:external` causes the adapter to enqueue jobs, but not execute them. When using this option (the default for production environments), you’ll need to use the command-line tool to actually execute your jobs.
-    - `:async_server` executes jobs in separate threads within the Rails webserver process (`bundle exec rails server`). It can be more economical for small workloads because you don’t need a separate machine or environment for running your jobs, but if your web server is under heavy load or your jobs require a lot of resources, you should choose `:external` instead.  When not in the Rails webserver, jobs will execute in `:external` mode to ensure jobs are not executed within `rails console`, `rails db:migrate`, `rails assets:prepare`, etc.
-    - `:async` executes jobs in separate threads in _any_ Rails process.
-- `max_threads` (integer) sets the maximum number of threads to use when `execution_mode` is set to `:async` or `:async_server`. You can also set this with the environment variable `GOOD_JOB_MAX_THREADS`.
-- `queues` (string) determines which queues to execute jobs from when `execution_mode` is set to `:async` or `:async_server`. 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` or `:async_server`. You can also set this with the environment variable `GOOD_JOB_POLL_INTERVAL`.
+    - `:async` (or `:async_server`) executes jobs in separate threads within the Rails web server process (`bundle exec rails server`). It can be more economical for small workloads because you don’t need a separate machine or environment for running your jobs, but if your web server is under heavy load or your jobs require a lot of resources, you should choose `:external` instead.  When not in the Rails web server, jobs will execute in `:external` mode to ensure jobs are not executed within `rails console`, `rails db:migrate`, `rails assets:prepare`, etc.
+    - `:async_all` executes jobs in separate threads in _any_ Rails process.
+- `max_threads` (integer) sets the maximum number of threads to use when `execution_mode` is set to `:async`. You can also set this with the environment variable `GOOD_JOB_MAX_THREADS`.
+- `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`.
 - `max_cache` (integer) sets the maximum number of scheduled jobs that will be stored in memory to reduce execution latency when also polling for scheduled jobs. Caching 10,000 scheduled jobs uses approximately 20MB of memory. You can also set this with the environment variable `GOOD_JOB_MAX_CACHE`.
 - `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`.
@@ -264,7 +266,7 @@ By default, GoodJob configures the following execution modes per environment:
 
 # config/environments/development.rb
 config.active_job.queue_adapter = :good_job
-config.good_job.execution_mode = :inline
+config.good_job.execution_mode = :async
 
 # config/environments/test.rb
 config.active_job.queue_adapter = :good_job
@@ -394,7 +396,7 @@ config.good_job.enable_cron = ENV['DYNO'] == 'worker.1' # or `true` or via $GOOD
 
 # Configure cron with a hash that has a unique key for each recurring job
 config.good_job.cron = {
-  # Every 15 minutes, enqueue `ExampleJob.set(priority: -10).perform_later(52, name: "Alice")`
+  # Every 15 minutes, enqueue `ExampleJob.set(priority: -10).perform_later(42, name: "Alice")`
   frequent_task: { # each recurring job must have a unique key
     cron: "*/15 * * * *", # cron-style scheduling format by fugit gem
     class: "ExampleJob", # reference the Job class with a string
@@ -443,8 +445,7 @@ To perform upgrades to the GoodJob database tables:
 
 #### Upgrading v1 to v2
 
-GoodJob v2 introduces a new Advisory Lock key format that is different than the v1 advisory lock key format; it's therefore necessary to perform a simple, but staged production upgrade. If you are already using `>= v1.12+` no other changes are likely44
-necessary.
+GoodJob v2 introduces a new Advisory Lock key format that is different than the v1 advisory lock key format; it's therefore necessary to perform a simple, but staged production upgrade. If you are already using `>= v1.12+` no other changes are necessary.
 
 1. Upgrade your production environment to `v1.99.x` following the minor version upgrade process, including database migrations. `v1.99` is a transitional release that is safely compatible with both `v1.x` and `v2.0.0` because it uses both `v1`- and `v2`-formatted advisory locks.
 1. Address any deprecation warnings generated by `v1.99`.
@@ -454,6 +455,7 @@ Notable changes:
 
 - Renames `:async_server` execution mode to `:async`; renames prior `:async` execution mode to `:async_all`.
 - Sets default Development environment's execution mode to `:async` with disabled polling.
+- Excludes performing jobs from `enqueue_limit`'s count in `GoodJob::ActiveJobExtensions::Concurrency`.
 - Triggers `GoodJob.on_thread_error` for unhandled ActiveJob exceptions.
 - Renames `GoodJob.reperform_jobs_on_standard_error` accessor to `GoodJob.retry_on_unhandled_error`.
 - Renames `GoodJob::Adapter.shutdown(wait:)` argument to `GoodJob::Adapter.shutdown(timeout:)`.
@@ -612,7 +614,7 @@ Keep in mind, queue operations and management is an advanced discipline. This st
 
 ### Database connections
 
-Each GoodJob execution thread requires its own database connection that is automatically checked out from Rails’s connection pool. _Allowing GoodJob to create more threads than available database connections can lead to timeouts and is not recommended._ For example:
+Each GoodJob execution thread requires its own database connection that is automatically checked out from Rails’ connection pool. _Allowing GoodJob to create more threads than available database connections can lead to timeouts and is not recommended._ For example:
 
 ```yaml
 # config/database.yml
@@ -621,7 +623,7 @@ pool: <%= [ENV.fetch("RAILS_MAX_THREADS", 5).to_i, ENV.fetch("GOOD_JOB_MAX_THREA
 
 ### Execute jobs async / in-process
 
-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:
+GoodJob can execute jobs "async" in the same process as the web server (e.g. `bin/rails 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:
 
 - Via Rails configuration:
 
@@ -630,11 +632,11 @@ GoodJob can execute jobs "async" in the same process as the webserver (e.g. `bin
     config.active_job.queue_adapter = :good_job
 
     # To change the execution mode
-    config.good_job.execution_mode = :async_server
+    config.good_job.execution_mode = :async
 
     # Or with more configuration
     config.good_job = {
-      execution_mode: :async_server,
+      execution_mode: :async,
       max_threads: 4,
       poll_interval: 30
     }
@@ -643,7 +645,7 @@ GoodJob can execute jobs "async" in the same process as the webserver (e.g. `bin
 - Or, with environment variables:
 
     ```bash
-    $ GOOD_JOB_EXECUTION_MODE=async_server GOOD_JOB_MAX_THREADS=4 GOOD_JOB_POLL_INTERVAL=30 bin/rails server
+    $ GOOD_JOB_EXECUTION_MODE=async GOOD_JOB_MAX_THREADS=4 GOOD_JOB_POLL_INTERVAL=30 bin/rails server
     ```
 
 Depending on your application configuration, you may need to take additional steps:
@@ -655,7 +657,7 @@ Depending on your application configuration, you may need to take additional ste
     pool: <%= ENV.fetch("RAILS_MAX_THREADS", 5).to_i + ENV.fetch("GOOD_JOB_MAX_THREADS", 4).to_i %>
     ```
 
-- When running Puma with workers (`WEB_CONCURRENCY > 0`) or another process-forking webserver, GoodJob's threadpool schedulers should be stopped before forking, restarted after fork, and cleanly shut down on exit. Stopping GoodJob's scheduler pre-fork is recommended to ensure that GoodJob does not continue executing jobs in the parent/controller process. For example, with Puma:
+- When running Puma with workers (`WEB_CONCURRENCY > 0`) or another process-forking web server, GoodJob's threadpool schedulers should be stopped before forking, restarted after fork, and cleanly shut down on exit. Stopping GoodJob's scheduler pre-fork is recommended to ensure that GoodJob does not continue executing jobs in the parent/controller process. For example, with Puma:
 
     ```ruby
     # config/puma.rb
@@ -722,7 +724,8 @@ It is also necessary to delete these preserved jobs from the database after a ce
 - For example, in a Rake task:
 
     ```ruby
-    GoodJob::Job.finished(1.day.ago).delete_all
+    GoodJob.cleanup_preserved_jobs # Will keep 1 day of job records by default.
+    GoodJob.cleanup_preserved_jobs(older_than: 7.days) # It also takes custom arguments.
     ```
 
 - For example, using the `good_job` command-line utility:

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 class CreateGoodJobs < ActiveRecord::Migration[5.2]
   def change
     enable_extension 'pgcrypto'

data/lib/generators/good_job/templates/update/migrations/01_create_good_jobs.rb

@@ -13,9 +13,17 @@ class CreateGoodJobs < ActiveRecord::Migration[5.2]
       t.text :error
 
       t.timestamps
+
+      t.uuid :active_job_id
+      t.text :concurrency_key
+      t.text :cron_key
+      t.uuid :retried_good_job_id
     end
 
     add_index :good_jobs, :scheduled_at, where: "(finished_at IS NULL)", name: "index_good_jobs_on_scheduled_at"
     add_index :good_jobs, [:queue_name, :scheduled_at], where: "(finished_at IS NULL)", name: :index_good_jobs_on_queue_name_and_scheduled_at
+    add_index :good_jobs, [:active_job_id, :created_at], name: :index_good_jobs_on_active_job_id_and_created_at
+    add_index :good_jobs, :concurrency_key, where: "(finished_at IS NULL)", name: :index_good_jobs_on_concurrency_key_when_unfinished
+    add_index :good_jobs, [:cron_key, :created_at], name: :index_good_jobs_on_cron_key_and_created_at
   end
 end

data/lib/good_job/active_job_extensions/concurrency.rb

@@ -4,7 +4,11 @@ module GoodJob
     module Concurrency
       extend ActiveSupport::Concern
 
-      ConcurrencyExceededError = Class.new(StandardError)
+      class ConcurrencyExceededError < StandardError
+        def backtrace
+          [] # suppress backtrace
+        end
+      end
 
       included do
         class_attribute :good_job_concurrency_config, instance_accessor: false, default: {}
@@ -24,7 +28,7 @@ module GoodJob
 
           GoodJob::Job.new.with_advisory_lock(key: key, function: "pg_advisory_lock") do
             # TODO: Why is `unscoped` necessary? Nested scope is bleeding into subsequent query?
-            enqueue_concurrency = GoodJob::Job.unscoped.where(concurrency_key: key).unfinished.count
+            enqueue_concurrency = GoodJob::Job.unscoped.where(concurrency_key: key).unfinished.advisory_unlocked.count
             # The job has not yet been enqueued, so check if adding it will go over the limit
             block.call unless enqueue_concurrency + 1 > limit
           end

data/lib/good_job/adapter.rb

@@ -4,16 +4,13 @@ module GoodJob
   # ActiveJob Adapter.
   #
   class Adapter
-    # Valid execution modes.
-    EXECUTION_MODES = [:async, :async_server, :external, :inline].freeze
-
     # @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.
     #  - +:external+ causes the adapter to enqueue jobs, but not execute them. When using this option (the default for production environments), you'll need to use the command-line tool to actually execute your jobs.
-    #  - +:async_server+ executes jobs in separate threads within the Rails webserver process (`bundle exec rails server`). It can be more economical for small workloads because you don't need a separate machine or environment for running your jobs, but if your web server is under heavy load or your jobs require a lot of resources, you should choose +:external+ instead.
-    #    When not in the Rails webserver, jobs will execute in +:external+ mode to ensure jobs are not executed within `rails console`, `rails db:migrate`, `rails assets:prepare`, etc.
-    #  - +:async+ executes jobs in any Rails process.
+    #  - +:async+ (or +:async_server+) executes jobs in separate threads within the Rails web server process (`bundle exec rails server`). It can be more economical for small workloads because you don't need a separate machine or environment for running your jobs, but if your web server is under heavy load or your jobs require a lot of resources, you should choose +:external+ instead.
+    #    When not in the Rails web server, jobs will execute in +:external+ mode to ensure jobs are not executed within `rails console`, `rails db:migrate`, `rails assets:prepare`, etc.
+    #  - +:async_all+ executes jobs in any Rails process.
     #
     #  The default value depends on the Rails environment:
     #
@@ -24,23 +21,6 @@ module GoodJob
     # @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)
-      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(
         {
           execution_mode: execution_mode,
@@ -105,18 +85,8 @@ module GoodJob
     #   * +-1+, the scheduler will wait until the shutdown is complete.
     #   * +0+, the scheduler will immediately shutdown and stop any threads.
     #   * A positive number will wait that many seconds before stopping any remaining active threads.
-    # @param wait [Boolean, nil] Deprecated. Use +timeout:+ instead.
     # @return [void]
-    def shutdown(timeout: :default, wait: nil)
-      timeout = if wait.nil?
-                  timeout
-                else
-                  ActiveSupport::Deprecation.warn(
-                    "Using `GoodJob::Adapter.shutdown` with `wait:` kwarg is deprecated; use `timeout:` kwarg instead e.g. GoodJob::Adapter.shutdown(timeout: #{wait ? '-1' : 'nil'})"
-                  )
-                  wait ? -1 : nil
-                end
-
+    def shutdown(timeout: :default)
       timeout = if timeout == :default
                   @configuration.shutdown_timeout
                 else
@@ -130,15 +100,15 @@ module GoodJob
     # Whether in +:async+ execution mode.
     # @return [Boolean]
     def execute_async?
-      @configuration.execution_mode.in?([:async, :async_all]) ||
-        @configuration.execution_mode == :async_server && in_server_process?
+      @configuration.execution_mode == :async_all ||
+        @configuration.execution_mode.in?([:async, :async_server]) && in_server_process?
     end
 
     # Whether in +:external+ execution mode.
     # @return [Boolean]
     def execute_externally?
       @configuration.execution_mode == :external ||
-        @configuration.execution_mode == :async_server && !in_server_process?
+        @configuration.execution_mode.in?([:async, :async_server]) && !in_server_process?
     end
 
     # Whether in +:inline+ execution mode.

data/lib/good_job/cli.rb

@@ -134,16 +134,7 @@ module GoodJob
 
       configuration = GoodJob::Configuration.new(options)
 
-      timestamp = Time.current - configuration.cleanup_preserved_jobs_before_seconds_ago
-
-      ActiveSupport::Notifications.instrument(
-        "cleanup_preserved_jobs.good_job",
-        { before_seconds_ago: configuration.cleanup_preserved_jobs_before_seconds_ago, timestamp: timestamp }
-      ) do |payload|
-        deleted_records_count = GoodJob::Job.finished(timestamp).delete_all
-
-        payload[:deleted_records_count] = deleted_records_count
-      end
+      GoodJob.cleanup_preserved_jobs(older_than: configuration.cleanup_preserved_jobs_before_seconds_ago)
     end
 
     no_commands do

data/lib/good_job/configuration.rb

@@ -12,9 +12,11 @@ module GoodJob
     DEFAULT_MAX_THREADS = 5
     # Default number of seconds between polls for jobs
     DEFAULT_POLL_INTERVAL = 10
+    # Default poll interval for async in development environment
+    DEFAULT_DEVELOPMENT_ASYNC_POLL_INTERVAL = -1
     # Default number of threads to use per {Scheduler}
     DEFAULT_MAX_CACHE = 10000
-    # Default number of seconds to preserve jobs for {CLI#cleanup_preserved_jobs}
+    # Default number of seconds to preserve jobs for {CLI#cleanup_preserved_jobs} and {GoodJob.cleanup_preserved_jobs}
     DEFAULT_CLEANUP_PRESERVED_JOBS_BEFORE_SECONDS_AGO = 24 * 60 * 60
     # Default to always wait for jobs to finish for {Adapter#shutdown}
     DEFAULT_SHUTDOWN_TIMEOUT = -1
@@ -58,19 +60,10 @@ module GoodJob
                end
 
         if mode
-          mode_sym = mode.to_sym
-          if mode_sym == :async
-            ActiveSupport::Deprecation.warn <<~DEPRECATION
-              The next major version of GoodJob will redefine the meaning of 'async'
-              execution mode to be equivalent to 'async_server' and only execute
-              within the webserver process.
-
-              To continue using the v1.0 semantics of 'async', use `async_all` instead.
-
-            DEPRECATION
-          end
-          mode_sym
-        elsif Rails.env.development? || Rails.env.test?
+          mode.to_sym
+        elsif Rails.env.development?
+          :async
+        elsif Rails.env.test?
           :inline
         else
           :external
@@ -109,12 +102,19 @@ module GoodJob
     # poll (using this interval) for new queued jobs to execute.
     # @return [Integer]
     def poll_interval
-      (
+      interval = (
         options[:poll_interval] ||
           rails_config[:poll_interval] ||
-          env['GOOD_JOB_POLL_INTERVAL'] ||
-          DEFAULT_POLL_INTERVAL
-      ).to_i
+          env['GOOD_JOB_POLL_INTERVAL']
+      )
+
+      if interval
+        interval.to_i
+      elsif Rails.env.development? && execution_mode.in?([:async, :async_all, :async_server])
+        DEFAULT_DEVELOPMENT_ASYNC_POLL_INTERVAL
+      else
+        DEFAULT_POLL_INTERVAL
+      end
     end
 
     # The maximum number of future-scheduled jobs to store in memory.
@@ -147,12 +147,13 @@ module GoodJob
     def enable_cron
       value = ActiveModel::Type::Boolean.new.cast(
         options[:enable_cron] ||
-        rails_config[:enable_cron] ||
-        env['GOOD_JOB_ENABLE_CRON'] ||
-        false
+          rails_config[:enable_cron] ||
+          env['GOOD_JOB_ENABLE_CRON'] ||
+          false
       )
       value && cron.size.positive?
     end
+
     alias enable_cron? enable_cron
 
     def cron

data/lib/good_job/job.rb

@@ -16,7 +16,7 @@ module GoodJob
     DEFAULT_PRIORITY = 0
 
     self.table_name = 'good_jobs'
-    self.advisory_lockable_column = 'id'
+    self.advisory_lockable_column = 'active_job_id'
 
     attr_readonly :serialized_params
 
@@ -52,20 +52,6 @@ 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 class name
     # @!method with_job_class
     # @!scope class
@@ -78,14 +64,7 @@ module GoodJob
     # @!method unfinished
     # @!scope class
     # @return [ActiveRecord::Relation]
-    scope :unfinished, (lambda do
-      if column_names.include?('finished_at')
-        where(finished_at: nil)
-      else
-        ActiveSupport::Deprecation.warn('GoodJob expects a good_jobs.finished_at column to exist. Please see the GoodJob README.md for migration instructions.')
-        nil
-      end
-    end)
+    scope :unfinished, -> { where(finished_at: nil) }
 
     # Get Jobs that are not scheduled for a later time than now (i.e. jobs that
     # are not scheduled or scheduled for earlier than the current time).
@@ -231,6 +210,7 @@ module GoodJob
     def self.enqueue(active_job, scheduled_at: nil, create_with_advisory_lock: false)
       ActiveSupport::Notifications.instrument("enqueue_job.good_job", { active_job: active_job, scheduled_at: scheduled_at, create_with_advisory_lock: create_with_advisory_lock }) do |instrument_payload|
         good_job_args = {
+          active_job_id: active_job.job_id,
           queue_name: active_job.queue_name.presence || DEFAULT_QUEUE_NAME,
           priority: active_job.priority || DEFAULT_PRIORITY,
           serialized_params: active_job.serialize,
@@ -238,26 +218,12 @@ module GoodJob
           create_with_advisory_lock: create_with_advisory_lock,
         }
 
-        if column_names.include?('active_job_id')
-          good_job_args[:active_job_id] = active_job.job_id
-        else
-          _migration_pending_warning
-        end
-
-        if column_names.include?('concurrency_key')
-          good_job_args[:concurrency_key] = active_job.good_job_concurrency_key if active_job.respond_to?(:good_job_concurrency_key)
-        else
-          _migration_pending_warning
-        end
+        good_job_args[:concurrency_key] = active_job.good_job_concurrency_key if active_job.respond_to?(:good_job_concurrency_key)
 
-        if column_names.include?('cron_key')
-          if CurrentExecution.cron_key
-            good_job_args[:cron_key] = CurrentExecution.cron_key
-          elsif CurrentExecution.active_job_id == active_job.job_id
-            good_job_args[:cron_key] = CurrentExecution.good_job.cron_key
-          end
-        else
-          _migration_pending_warning
+        if CurrentExecution.cron_key
+          good_job_args[:cron_key] = CurrentExecution.cron_key
+        elsif CurrentExecution.active_job_id == active_job.job_id
+          good_job_args[:cron_key] = CurrentExecution.good_job.cron_key
         end
 
         good_job = GoodJob::Job.new(**good_job_args)
@@ -267,11 +233,7 @@ module GoodJob
         good_job.save!
         active_job.provider_job_id = good_job.id
 
-        if column_names.include?('retried_good_job_id')
-          CurrentExecution.good_job.retried_good_job_id = good_job.id if CurrentExecution.good_job && CurrentExecution.good_job.active_job_id == active_job.job_id
-        else
-          _migration_pending_warning
-        end
+        CurrentExecution.good_job.retried_good_job_id = good_job.id if CurrentExecution.good_job && CurrentExecution.good_job.active_job_id == active_job.job_id
 
         good_job
       end
@@ -311,24 +273,6 @@ module GoodJob
       self.class.unscoped.unfinished.owns_advisory_locked.exists?(id: id)
     end
 
-    def active_job_id
-      if self.class.column_names.include?('active_job_id')
-        super
-      else
-        self.class._migration_pending_warning
-        serialized_params['job_id']
-      end
-    end
-
-    def cron_key
-      if self.class.column_names.include?('cron_key')
-        super
-      else
-        self.class._migration_pending_warning
-        nil
-      end
-    end
-
     private
 
     # @return [ExecutionResult]

data/lib/good_job/lockable.rb

@@ -51,7 +51,7 @@ module GoodJob
         composed_cte = Arel::Nodes::As.new(cte_table, Arel::Nodes::SqlLiteral.new([cte_type, "(", cte_query.to_sql, ")"].join(' ')))
         query = cte_table.project(cte_table[:id])
                          .with(composed_cte)
-                         .where(Arel.sql(sanitize_sql_for_conditions(["#{function}(('x' || substr(md5(:table_name || #{connection.quote_table_name(cte_table.name)}.#{connection.quote_column_name(column)}::text), 1, 16))::bit(64)::bigint)", { table_name: table_name }])))
+                         .where(Arel.sql(sanitize_sql_for_conditions(["#{function}(('x' || substr(md5(:table_name || '-' || #{connection.quote_table_name(cte_table.name)}.#{connection.quote_column_name(column)}::text), 1, 16))::bit(64)::bigint)", { table_name: table_name }])))
 
         limit = original_query.arel.ast.limit
         query.limit = limit.value if limit.present?
@@ -75,8 +75,8 @@ module GoodJob
         join_sql = <<~SQL.squish
           LEFT JOIN pg_locks ON pg_locks.locktype = 'advisory'
             AND pg_locks.objsubid = 1
-            AND pg_locks.classid = ('x' || substr(md5(:table_name || #{quoted_table_name}.#{connection.quote_column_name(column)}::text), 1, 16))::bit(32)::int
-            AND pg_locks.objid = (('x' || substr(md5(:table_name || #{quoted_table_name}.#{connection.quote_column_name(column)}::text), 1, 16))::bit(64) << 32)::bit(32)::int
+            AND pg_locks.classid = ('x' || substr(md5(:table_name || '-' || #{quoted_table_name}.#{connection.quote_column_name(column)}::text), 1, 16))::bit(32)::int
+            AND pg_locks.objid = (('x' || substr(md5(:table_name || '-' || #{quoted_table_name}.#{connection.quote_column_name(column)}::text), 1, 16))::bit(64) << 32)::bit(32)::int
         SQL
 
         joins(sanitize_sql_for_conditions([join_sql, { table_name: table_name }]))
@@ -315,7 +315,7 @@ module GoodJob
     # Default Advisory Lock key
     # @return [String]
     def lockable_key
-      [self.class.table_name, self[self.class._advisory_lockable_column]].join
+      "#{self.class.table_name}-#{self[self.class._advisory_lockable_column]}"
     end
 
     delegate :pg_or_jdbc_query, to: :class

data/lib/good_job/scheduler.rb

@@ -168,7 +168,9 @@ module GoodJob # :nodoc:
     # @!visibility private
     # @return [void]
     def task_observer(time, output, thread_error)
-      GoodJob.on_thread_error.call(thread_error) if thread_error && GoodJob.on_thread_error.respond_to?(:call)
+      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)
+
       instrument("finished_job_task", { result: output, error: thread_error, time: time })
       create_task if output
     end

data/lib/good_job/version.rb

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

data/lib/good_job.rb

@@ -42,7 +42,8 @@ module GoodJob
   #   By default, GoodJob deletes job records after the job is completed successfully.
   #   If you want to preserve jobs for latter inspection, set this to +true+.
   #   If you want to preserve only jobs that finished with error for latter inspection, set this to +:on_unhandled_error+.
-  #   If +true+, you will need to clean out jobs using the +good_job cleanup_preserved_jobs+ CLI command.
+  #   If +true+, you will need to clean out jobs using the +good_job cleanup_preserved_jobs+ CLI command or
+  #   by using +Goodjob.cleanup_preserved_jobs+.
   #   @return [Boolean, nil]
   mattr_accessor :preserve_job_records, default: false
 
@@ -55,25 +56,6 @@ module GoodJob
   #   @return [Boolean, nil]
   mattr_accessor :retry_on_unhandled_error, default: true
 
-  # @deprecated Use {GoodJob#retry_on_unhandled_error} instead.
-  # @return [Boolean, nil]
-  def self.reperform_jobs_on_standard_error
-    ActiveSupport::Deprecation.warn(
-      "Calling 'GoodJob.reperform_jobs_on_standard_error' is deprecated. Please use 'retry_on_unhandled_error'"
-    )
-    retry_on_unhandled_error
-  end
-
-  # @deprecated Use {GoodJob#retry_on_unhandled_error=} instead.
-  # @param value [Boolean]
-  # @return [Boolean]
-  def self.reperform_jobs_on_standard_error=(value)
-    ActiveSupport::Deprecation.warn(
-      "Setting 'GoodJob.reperform_jobs_on_standard_error=' is deprecated. Please use 'retry_on_unhandled_error='"
-    )
-    self.retry_on_unhandled_error = value
-  end
-
   # @!attribute [rw] on_thread_error
   #   @!scope class
   #   This callable will be called when an exception reaches GoodJob (default: +nil+).
@@ -96,16 +78,7 @@ module GoodJob
   #   * +1..+, the scheduler will wait that many seconds before stopping any remaining active tasks.
   # @param wait [Boolean] whether to wait for shutdown
   # @return [void]
-  def self.shutdown(timeout: -1, wait: nil)
-    timeout = if wait.nil?
-                timeout
-              else
-                ActiveSupport::Deprecation.warn(
-                  "Using `GoodJob.shutdown` with `wait:` kwarg is deprecated; use `timeout:` kwarg instead e.g. GoodJob.shutdown(timeout: #{wait ? '-1' : 'nil'})"
-                )
-                wait ? -1 : nil
-              end
-
+  def self.shutdown(timeout: -1)
     _shutdown_all(_executables, timeout: timeout)
   end
 
@@ -142,6 +115,26 @@ module GoodJob
     end
   end
 
+  # Deletes preserved job records.
+  # By default, GoodJob deletes job records when the job is performed and this
+  # method is not necessary. However, when `GoodJob.preserve_job_records = true`,
+  # the jobs will be preserved in the database. This is useful when wanting to
+  # analyze or inspect job performance.
+  # If you are preserving job records this way, use this method regularly to
+  # delete old records and preserve space in your database.
+  # @params older_than [nil,Numeric,ActiveSupport::Duration] Jobs olders than this will be deleted (default: +86400+).
+  # @return [Integer] Number of jobs that were deleted.
+  def self.cleanup_preserved_jobs(older_than: nil)
+    older_than ||= GoodJob::Configuration.new({}).cleanup_preserved_jobs_before_seconds_ago
+    timestamp = Time.current - older_than
+
+    ActiveSupport::Notifications.instrument("cleanup_preserved_jobs.good_job", { older_than: older_than, timestamp: timestamp }) do |payload|
+      deleted_records_count = GoodJob::Job.finished(timestamp).delete_all
+
+      payload[:deleted_records_count] = deleted_records_count
+    end
+  end
+
   def self._executables
     [].concat(
       CronManager.instances,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 1.99.1
+  version: 2.0.3
 platform: ruby
 authors:
 - Ben Sheldon
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-08-27 00:00:00.000000000 Z
+date: 2021-08-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
@@ -372,9 +372,6 @@ files:
 - 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/02_add_active_job_id_concurrency_key_cron_key_to_good_jobs.rb
-- lib/generators/good_job/templates/update/migrations/03_add_active_job_id_index_and_concurrency_key_index_to_good_jobs.rb
-- lib/generators/good_job/templates/update/migrations/04_add_retried_good_job_id_to_good_jobs.rb
 - lib/generators/good_job/update_generator.rb
 - lib/good_job.rb
 - lib/good_job/active_job_extensions.rb

data/lib/generators/good_job/templates/update/migrations/02_add_active_job_id_concurrency_key_cron_key_to_good_jobs.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-class AddActiveJobIdConcurrencyKeyCronKeyToGoodJobs < ActiveRecord::Migration[5.2]
-  def change
-    reversible do |dir|
-      dir.up do
-        # Ensure this incremental update migration is idempotent
-        # with monolithic install migration.
-        return if connection.column_exists?(:good_jobs, :active_job_id)
-      end
-    end
-
-    add_column :good_jobs, :active_job_id, :uuid
-    add_column :good_jobs, :concurrency_key, :text
-    add_column :good_jobs, :cron_key, :text
-  end
-end

data/lib/generators/good_job/templates/update/migrations/03_add_active_job_id_index_and_concurrency_key_index_to_good_jobs.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-class AddActiveJobIdIndexAndConcurrencyKeyIndexToGoodJobs < ActiveRecord::Migration[5.2]
-  disable_ddl_transaction!
-
-  UPDATE_BATCH_SIZE = 1_000
-
-  def change
-    reversible do |dir|
-      dir.up do
-        # Ensure this incremental update migration is idempotent
-        # with monolithic install migration.
-        return if connection.index_name_exists?(:good_jobs, :index_good_jobs_on_active_job_id_and_created_at)
-      end
-    end
-
-    add_index :good_jobs, [:active_job_id, :created_at], algorithm: :concurrently, name: :index_good_jobs_on_active_job_id_and_created_at
-    add_index :good_jobs, :concurrency_key, where: "(finished_at IS NULL)", algorithm: :concurrently, name: :index_good_jobs_on_concurrency_key_when_unfinished
-    add_index :good_jobs, [:cron_key, :created_at], algorithm: :concurrently, name: :index_good_jobs_on_cron_key_and_created_at
-
-    return unless defined? GoodJob::Job
-
-    reversible do |dir|
-      dir.up do
-        # Ensure that all `good_jobs` records have an active_job_id value
-        start_time = Time.current
-        loop do
-          break if GoodJob::Job.where(active_job_id: nil, finished_at: nil).where("created_at < ?", start_time).limit(UPDATE_BATCH_SIZE).update_all("active_job_id = (serialized_params->>'job_id')::uuid").zero?
-        end
-      end
-    end
-  end
-end

data/lib/generators/good_job/templates/update/migrations/04_add_retried_good_job_id_to_good_jobs.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-class AddRetriedGoodJobIdToGoodJobs < ActiveRecord::Migration[5.2]
-  def change
-    reversible do |dir|
-      dir.up do
-        # Ensure this incremental update migration is idempotent
-        # with monolithic install migration.
-        return if connection.column_exists?(:good_jobs, :retried_good_job_id)
-      end
-    end
-
-    add_column :good_jobs, :retried_good_job_id, :uuid
-  end
-end