good_job 1.13.1 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 945c5a01f5e0e936bbd863ce9cdcd8ca3956d1b0e8462932821ca3d502fc255f
-  data.tar.gz: e0503d0b3c89d43fd7a03be68f34f578100baf9b0ad01f1a7e40a6833c35a929
+  metadata.gz: 917d4630bb8be8ea639b3516e8c4fc5465c5dfd52e0ea361259cf68d58bafe90
+  data.tar.gz: 867861782ccd6cc20934162c3ca7c2c76ed09407d9e9a7d00ee4d33f9de120cf
 SHA512:
-  metadata.gz: 16326be1563033a3f94d64fa926a85d58cf9ec5026f1aed1fc1471d0b7e301c0e7f69101129964d91ca7cfafd51146fba71c5b7f2ce8643d152590ce8e826a05
-  data.tar.gz: ffdd7c4274c04a14d44af48d0f590fa10b984787e88e00359584911521c406451209ccd0525875ab80646bb7a9ea16fc062159b3a1513231106c7d0eb1a2e23a
+  metadata.gz: a45d3b4eb52724ef8faf8d86c74f7051500aa33b3a98c0482bfc1568df95b444088e9ead34820606abf8f2389f3dc6b8ca51f84e6c07421b861a5f49dd825e38
+  data.tar.gz: 11790854220ca578a92f8b3e4a37fe5cc2d23205cd41e4cb55acfe3e7db5547b091ea4d542b3c466aa12cc59da35903d1566cbf3911cae9c153b8ec1a547e293

data/CHANGELOG.md

@@ -1,5 +1,62 @@
 # Changelog
 
+## [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)
+
+**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)
+
+**Merged pull requests:**
+
+- Suppress backtrace of ConcurrencyExceededError [\#348](https://github.com/bensheldon/good_job/pull/348) ([reczy](https://github.com/reczy))
+
+## [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)
+
+**Implemented enhancements:**
+
+- Concurrency's enqueue\_limit should exclude performing jobs from count [\#317](https://github.com/bensheldon/good_job/issues/317)
+- Rename `:async` to `:async_all`; `:async_server` to `:async` and set as Development environment default; do not poll in async development [\#343](https://github.com/bensheldon/good_job/pull/343) ([bensheldon](https://github.com/bensheldon))
+- Exclude executing jobs from Concurrency's enqueue\_limit's count [\#342](https://github.com/bensheldon/good_job/pull/342) ([bensheldon](https://github.com/bensheldon))
+- Unhandled ActiveJob errors should trigger GoodJob.on\_thread\_error [\#312](https://github.com/bensheldon/good_job/pull/312) ([bensheldon](https://github.com/bensheldon))
+
+**Closed issues:**
+
+- Swap behavior of `async` with `async_server`; rename `async` execution mode to be `async_all`; default `async` in Development; [\#340](https://github.com/bensheldon/good_job/issues/340)
+- Add hyphen to lock key. e.g. "\[table\_name\]-\[column\]" instead of "\[table\_name\]\[column\]" [\#335](https://github.com/bensheldon/good_job/issues/335)
+- Use `async_server` as default execution mode in Development environment [\#139](https://github.com/bensheldon/good_job/issues/139)
+
+**Merged pull requests:**
+
+- Remove v1.0 deprecation notices and incremental migrations [\#338](https://github.com/bensheldon/good_job/pull/338) ([bensheldon](https://github.com/bensheldon))
+- Lock GoodJob::Job on active\_job\_id instead of the row id; adds separator hyphen to lock key [\#337](https://github.com/bensheldon/good_job/pull/337) ([bensheldon](https://github.com/bensheldon))
+
+## [v1.99.0](https://github.com/bensheldon/good_job/tree/v1.99.0) (2021-08-24)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v1.13.2...v1.99.0)
+
+**Closed issues:**
+
+- Set Advisory Lock on ActiveJob job uuid instead of GoodJob's job uuid [\#272](https://github.com/bensheldon/good_job/issues/272)
+
+**Merged pull requests:**
+
+- Add upgrade instructions for v1 to v2 [\#345](https://github.com/bensheldon/good_job/pull/345) ([bensheldon](https://github.com/bensheldon))
+- Add transitional/temporary additional lock on good\_jobs-\[active\_job\_id\] [\#336](https://github.com/bensheldon/good_job/pull/336) ([bensheldon](https://github.com/bensheldon))
+
+## [v1.13.2](https://github.com/bensheldon/good_job/tree/v1.13.2) (2021-08-18)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v1.13.1...v1.13.2)
+
+**Merged pull requests:**
+
+- Add deprecation notice that `async` mode will be renamed `async_all` in GoodJob v2.0 [\#339](https://github.com/bensheldon/good_job/pull/339) ([bensheldon](https://github.com/bensheldon))
+
 ## [v1.13.1](https://github.com/bensheldon/good_job/tree/v1.13.1) (2021-08-18)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v1.13.0...v1.13.1)

data/README.md

@@ -41,6 +41,8 @@ For more of the story of GoodJob, read the [introductory blog post](https://isla
     - [ActiveJob concurrency](#activejob-concurrency)
     - [Cron-style repeating/recurring jobs](#cron-style-repeatingrecurring-jobs)
     - [Updating](#updating)
+        - [Upgrading minor versions](#upgrading-minor-versions)
+        - [Upgrading v1 to v2](#upgrading-v1-to-v2)
 - [Go deeper](#go-deeper)
     - [Exceptions, retries, and reliability](#exceptions-retries-and-reliability)
         - [Exceptions](#exceptions)
@@ -123,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.
@@ -211,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
@@ -220,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,
@@ -239,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`.
@@ -255,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
@@ -405,17 +407,45 @@ config.good_job.cron = {
 
 GoodJob follows semantic versioning, though updates may be encouraged through deprecation warnings in minor versions.
 
-To apply updates:
+#### Upgrading minor versions
 
-```bash
-bin/rails g good_job:update
-```
+Upgrading between minor versions (e.g. v1.4 to v1.5) should not introduce breaking changes, but can introduce new deprecation warnings and database migration notices.
 
-...and run the resulting migration:
+To perform upgrades to the GoodJob database tables:
 
-```bash
-bin/rails db:migrate
-```
+1. Generate new database migration files:
+
+    ```bash
+    bin/rails g good_job:update
+    ```
+
+1. Run the database migration locally
+
+    ```bash
+    bin/rails db:migrate
+    ```
+
+1. Commit the migration files and resulting `db/schema.rb` changes.
+1. Deploy the code, run the migrations against the production database, and restart server/worker processes.
+
+#### 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 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`.
+1. Upgrade your production environment to `v1.99.x` to `v2.0.x` again following the _minor_ upgrade process.
+
+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:)`.
+- Changes Advisory Lock key format from `good_jobs[ROW_ID]` to `good_jobs-[ACTIVE_JOB_ID]`.
+- Expects presence of columns `good_jobs.active_job_id`, `good_jobs.concurrency_key`, `good_jobs.concurrency_key`, and `good_jobs.retried_good_job_id`.
 
 ## Go deeper
 
@@ -587,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
     }
@@ -600,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/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.
+    #  - +: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 == :async ||
-        @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

@@ -7,11 +7,13 @@ module GoodJob
   #
   class Configuration
     # Valid execution modes.
-    EXECUTION_MODES = [:async, :async_server, :external, :inline].freeze
+    EXECUTION_MODES = [:async, :async_all, :async_server, :external, :inline].freeze
     # Default number of threads to use per {Scheduler}
     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}
@@ -59,7 +61,9 @@ module GoodJob
 
         if mode
           mode.to_sym
-        elsif Rails.env.development? || Rails.env.test?
+        elsif Rails.env.development?
+          :async
+        elsif Rails.env.test?
           :inline
         else
           :external
@@ -98,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.
@@ -136,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).
@@ -189,7 +168,13 @@ module GoodJob
         break if good_job.blank?
         break :unlocked unless good_job&.executable?
 
-        good_job.perform
+        begin
+          good_job.with_advisory_lock(key: "good_jobs-#{good_job.active_job_id}") do
+            good_job.perform
+          end
+        rescue RecordAlreadyAdvisoryLockedError => e
+          ExecutionResult.new(value: nil, handled_error: e)
+        end
       end
     end
 
@@ -225,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,
@@ -232,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)
@@ -261,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
@@ -305,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.13.1'
+  VERSION = '2.0.1'
 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.13.1
+  version: 2.0.1
 platform: ruby
 authors:
 - Ben Sheldon
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-08-18 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,33 +0,0 @@
-# frozen_string_literal: true
-class AddActiveJobIdIndexAndConcurrencyKeyIndexToGoodJobs < ActiveRecord::Migration[5.2]
-  disable_ddl_transaction!
-
-  UPDATE_BATCH_SIZE = 1_000
-
-  class GoodJobJobs < ActiveRecord::Base
-    self.table_name = "good_jobs"
-  end
-
-  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
-
-    reversible do |dir|
-      dir.up do
-        start_time = Time.current
-        loop do
-          break if GoodJobJobs.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