good_job 1.99.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97662bae9e8ba65e5ed3e9ba52b8b987d77974866885a548a8a3b13878045c7a
-  data.tar.gz: 415d36696796cfb4c0ff1737c7c75e2b66bbfceea15f3a90aba55b49ee5da715
+  metadata.gz: 70c12a8c0e633dfc5f0ecb073c9a9993f1d7a4ab06df8f273e034b0ddf4513c1
+  data.tar.gz: f8d8ecd9ba7dd4cf0ad1687d519e4dd7eb87e06cb3c6a4ab1ed05586bcfe573a
 SHA512:
-  metadata.gz: 2d293eabb7b926386b30a1348c529de6a2252c1c734b7a92a81abad2fdd791a28abe5067850c9a4f7595182afd72d52eccc0c640d7596aaddcba467a995449ca
-  data.tar.gz: 4b981bda934dc7e58aab80bd998c16b9c8261309cf8f5ffce09253c45821f0106ef0db0249934a3649e735715d865ff6dd62232876afb7ffca76cfb4fe473179
+  metadata.gz: 1ff20a3ef1bf4e585d96094884cad5d682c11111d44a2d6ac61e1bb0773060cade2f4ced22008ef9dd01cb58cc477b695c02669c20505baf7f3515f42dde391d
+  data.tar.gz: e367c08cbf87a8203fd1d091401f49e1684fa247f86ab70fae782bbdbc826131ea0ef5b2c20589e7edfe580a257226686424c302c61fdc5d98010152ddbd52c4

data/CHANGELOG.md

@@ -1,32 +1,5 @@
 # Changelog
 
-## [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)
-
-**Merged pull requests:**
-
-- 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))
-
-## [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)
-
-**Implemented enhancements:**
-
-- Suppress backtrace of ConcurrencyExceededError [\#348](https://github.com/bensheldon/good_job/pull/348) ([reczy](https://github.com/reczy))
-
-**Closed issues:**
-
-- Is there any value in seeing a backtrace for ConcurrencyExceededError? [\#347](https://github.com/bensheldon/good_job/issues/347)
-- Release GoodJob 2.0 [\#307](https://github.com/bensheldon/good_job/issues/307)
-- Unhandled ActiveJob errors should trigger GoodJob.on\_thread\_error [\#247](https://github.com/bensheldon/good_job/issues/247)
-
 ## [v2.0.0](https://github.com/bensheldon/good_job/tree/v2.0.0) (2021-08-24)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v1.99.0...v2.0.0)

data/README.md

@@ -86,13 +86,6 @@ For more of the story of GoodJob, read the [introductory blog post](https://isla
     $ bin/rails db:migrate
     ```
 
-   Optional: If using Rails' multiple databases with the `migrations_paths` configuration option, use the `--database` option:
-
-    ```bash
-    bin/rails g good_job:install --database animals
-    bin/rails db:migrate:animals
-    ```
-
 1. Configure the ActiveJob adapter:
 
     ```ruby
@@ -132,7 +125,7 @@ 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.
@@ -220,7 +213,7 @@ 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
@@ -229,7 +222,7 @@ config.good_job.cron = { example: { cron: '0 * * * *', class: 'ExampleJob'  } }
 
 # ...or all at once.
 config.good_job = {
-  execution_mode: :async_server,
+  execution_mode: :async,
   max_threads: 5,
   poll_interval: 30,
   shutdown_timeout: 25,
@@ -248,11 +241,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 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_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 +257,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
@@ -426,12 +419,6 @@ To perform upgrades to the GoodJob database tables:
     bin/rails g good_job:update
     ```
 
-   Optional: If using Rails' multiple databases with the `migrations_paths` configuration option, use the `--database` option:
-
-    ```bash
-    $ bin/rails g good_job:update --database animals
-    ```
-
 1. Run the database migration locally
 
     ```bash
@@ -443,8 +430,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 +440,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:)`.
@@ -630,11 +617,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 +630,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:

data/lib/generators/good_job/install_generator.rb

@@ -1,23 +1,23 @@
 # frozen_string_literal: true
 require 'rails/generators'
 require 'rails/generators/active_record'
-
 module GoodJob
   #
   # Rails generator used for setting up GoodJob in a Rails application.
   # Run it with +bin/rails g good_job:install+ in your console.
   #
   class InstallGenerator < Rails::Generators::Base
-    include ActiveRecord::Generators::Migration
+    include Rails::Generators::Migration
 
-    TEMPLATES = File.join(File.dirname(__FILE__), "templates/install")
-    source_paths << TEMPLATES
+    class << self
+      delegate :next_migration_number, to: ActiveRecord::Generators::Base
+    end
 
-    class_option :database, type: :string, aliases: %i(--db), desc: "The database for your migration. By default, the current environment's primary database is used."
+    source_paths << File.join(File.dirname(__FILE__), "templates/install")
 
     # Generates monolithic migration file that contains all database changes.
     def create_migration_file
-      migration_template 'migrations/create_good_jobs.rb.erb', File.join(db_migrate_path, "create_good_jobs.rb")
+      migration_template 'migrations/create_good_jobs.rb.erb', 'db/migrate/create_good_jobs.rb'
     end
   end
 end

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/generators/good_job/update_generator.rb

@@ -8,20 +8,22 @@ module GoodJob
   # Run it with +bin/rails g good_job:update+ in your console.
   #
   class UpdateGenerator < Rails::Generators::Base
-    include ActiveRecord::Generators::Migration
+    include Rails::Generators::Migration
+
+    class << self
+      delegate :next_migration_number, to: ActiveRecord::Generators::Base
+    end
 
     TEMPLATES = File.join(File.dirname(__FILE__), "templates/update")
     source_paths << TEMPLATES
 
-    class_option :database, type: :string, aliases: %i(--db), desc: "The database for your migration. By default, the current environment's primary database is used."
-
     # Generates incremental migration files unless they already exist.
     # All migrations should be idempotent e.g. +add_index+ is guarded with +if_index_exists?+
     def update_migration_files
       migration_templates = Dir.children(File.join(TEMPLATES, 'migrations')).sort
       migration_templates.each do |template_file|
         destination_file = template_file.match(/^\d*_(.*\.rb)/)[1] # 01_create_good_jobs.rb.erb => create_good_jobs.rb
-        migration_template "migrations/#{template_file}", File.join(db_migrate_path, destination_file), skip: true
+        migration_template "migrations/#{template_file}", "db/migrate/#{destination_file}", skip: true
       end
     end
   end

data/lib/good_job/active_job_extensions/concurrency.rb

@@ -24,7 +24,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.
+    #  - +:async+ (or +: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_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/configuration.rb

@@ -12,6 +12,8 @@ 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}
@@ -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.0'
 end

data/lib/good_job.rb

@@ -55,25 +55,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 +77,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
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 1.99.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Ben Sheldon
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-08-27 00:00:00.000000000 Z
+date: 2021-08-24 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