good_job 1.9.5 → 1.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba4287705b5c3537dca930a07b02597d5c58b807346f811221c7adf6bfdd12a1
-  data.tar.gz: 6032005f621e9c796850c18db098be248764b76ce822f2e5135e105d381d2770
+  metadata.gz: 91a09f77d3cb46eb91c4673732e1c52ea752f8d94f95c23c81d3457dc63aa051
+  data.tar.gz: ef21168d4aa96f3dfbf50ebed2339132bea52542209d5732d84ac23028227537
 SHA512:
-  metadata.gz: 53ac0b6e5a4729cf96338cb67dc7e599656aff108e24d8e01f8545fb8439f2a708db61764fb1bb5a83853a2e63b0879729c0b89ec4b302d20916a91befd506ee
-  data.tar.gz: 8e1c6d319bf63b68715bfe6fbcc7bd30ca66531dbafcfd27ca3ef920d573d9b2d2454745a582501a0b845f7474c427e0493371f8ff2eb83031d16f8c4a9b67f1
+  metadata.gz: 8140a558ee43eeb2e3673462b7279f25cbed256bac385b131aa48c2f0ff59106d2038a39c65f3f1fd11f65cbcf7d3fb232bbfd20c790e7de629047a8eaed742b
+  data.tar.gz: 9daf8d432f5a013fbe5af10176b788c6c2e8c89e0f9b5e12568cbef7a7ecddda2b9296968e1076f71e5f26ed35a2f37d987227e7ad260030807f95404c7dbdeb

data/CHANGELOG.md

@@ -1,9 +1,90 @@
 # Changelog
 
+## [v1.11.1](https://github.com/bensheldon/good_job/tree/v1.11.1) (2021-07-07)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v1.11.0...v1.11.1)
+
+**Closed issues:**
+
+- Database connection required while loading the code on 1.10.x [\#291](https://github.com/bensheldon/good_job/issues/291)
+
+**Merged pull requests:**
+
+- Defer accessing ActiveRecord `primary_key` in Lockable [\#293](https://github.com/bensheldon/good_job/pull/293) ([bensheldon](https://github.com/bensheldon))
+
+## [v1.11.0](https://github.com/bensheldon/good_job/tree/v1.11.0) (2021-07-07)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v1.10.1...v1.11.0)
+
+**Implemented enhancements:**
+
+- Add concurrency extension for ActiveJob [\#281](https://github.com/bensheldon/good_job/pull/281) ([bensheldon](https://github.com/bensheldon))
+
+**Closed issues:**
+
+- Investigate GoodJob concurrency [\#289](https://github.com/bensheldon/good_job/issues/289)
+- Problem with migrating database on 1.10.0 [\#287](https://github.com/bensheldon/good_job/issues/287)
+- Support migration --database option for install task? [\#267](https://github.com/bensheldon/good_job/issues/267)
+- Add GoodJob to Ruby Toolbox [\#243](https://github.com/bensheldon/good_job/issues/243)
+- Custom advisory locks to prevent certain jobs from being worked on concurrently? [\#206](https://github.com/bensheldon/good_job/issues/206)
+
+## [v1.10.1](https://github.com/bensheldon/good_job/tree/v1.10.1) (2021-06-30)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v1.10.0...v1.10.1)
+
+**Merged pull requests:**
+
+- Remove `FOR UPDATE SKIP LOCKED` from job locking sql statement [\#288](https://github.com/bensheldon/good_job/pull/288) ([bensheldon](https://github.com/bensheldon))
+- Update GH Test Matrix with latest JRuby 9.2.19.0 [\#283](https://github.com/bensheldon/good_job/pull/283) ([tedhexaflow](https://github.com/tedhexaflow))
+
+## [v1.10.0](https://github.com/bensheldon/good_job/tree/v1.10.0) (2021-06-29)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v1.9.6...v1.10.0)
+
+**Implemented enhancements:**
+
+- Add `rails g good_job:update` command to add idempotent migration files, including `active_job_id`, `concurrency_key`, `cron_key` columns [\#266](https://github.com/bensheldon/good_job/pull/266) ([bensheldon](https://github.com/bensheldon))
+
+**Fixed bugs:**
+
+- Use `pg_advisory_unlock_all` after each thread's job execution; fix Lockable return values; improve test stability [\#285](https://github.com/bensheldon/good_job/pull/285) ([bensheldon](https://github.com/bensheldon))
+- Dashboard AssetsController does not raise if verify\_authenticity\_token is not in the callback chain [\#284](https://github.com/bensheldon/good_job/pull/284) ([bensheldon](https://github.com/bensheldon))
+
+**Closed issues:**
+
+- \[Question\] Dashboard assets not showing [\#282](https://github.com/bensheldon/good_job/issues/282)
+
+**Merged pull requests:**
+
+- Separately cache Appraisal gems in GH Action [\#280](https://github.com/bensheldon/good_job/pull/280) ([bensheldon](https://github.com/bensheldon))
+- Use custom RSpec doc formatter to show spec examples that are running [\#279](https://github.com/bensheldon/good_job/pull/279) ([bensheldon](https://github.com/bensheldon))
+- Update development dependencies [\#278](https://github.com/bensheldon/good_job/pull/278) ([bensheldon](https://github.com/bensheldon))
+- Fix Scheduler integration spec to ensure jobs are run in the Scheduler under test [\#276](https://github.com/bensheldon/good_job/pull/276) ([bensheldon](https://github.com/bensheldon))
+- Add example benchmark for job throughput [\#275](https://github.com/bensheldon/good_job/pull/275) ([bensheldon](https://github.com/bensheldon))
+- Allow Lockable to be passed custom column, key, and Postgres advisory lock/unlock function [\#273](https://github.com/bensheldon/good_job/pull/273) ([bensheldon](https://github.com/bensheldon))
+
+## [v1.9.6](https://github.com/bensheldon/good_job/tree/v1.9.6) (2021-06-04)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v1.9.5...v1.9.6)
+
+**Implemented enhancements:**
+
+- Add deleting jobs from UI. [\#265](https://github.com/bensheldon/good_job/pull/265) ([morgoth](https://github.com/morgoth))
+- Collapse Dashboard params by default [\#263](https://github.com/bensheldon/good_job/pull/263) ([morgoth](https://github.com/morgoth))
+
+**Closed issues:**
+
+- Pause jobs during migration / maintenance? [\#257](https://github.com/bensheldon/good_job/issues/257)
+- How to properly report errors to error tracker service [\#159](https://github.com/bensheldon/good_job/issues/159)
+
 ## [v1.9.5](https://github.com/bensheldon/good_job/tree/v1.9.5) (2021-05-24)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v1.9.4...v1.9.5)
 
+**Implemented enhancements:**
+
+- Update Dashboard to Bootstrap 5 [\#260](https://github.com/bensheldon/good_job/pull/260) ([morgoth](https://github.com/morgoth))
+
 **Closed issues:**
 
 - Update from bootstrap 4 to bootstrap 5 [\#258](https://github.com/bensheldon/good_job/issues/258)
@@ -12,7 +93,6 @@
 
 - Serve Dashboard assets as discrete paths instead of inlining [\#262](https://github.com/bensheldon/good_job/pull/262) ([bensheldon](https://github.com/bensheldon))
 - Fix Gemfile.lock's missing JRuby dependencies; fix release script and add check [\#261](https://github.com/bensheldon/good_job/pull/261) ([bensheldon](https://github.com/bensheldon))
-- Update Dashboard to Bootstrap 5 [\#260](https://github.com/bensheldon/good_job/pull/260) ([morgoth](https://github.com/morgoth))
 
 ## [v1.9.4](https://github.com/bensheldon/good_job/tree/v1.9.4) (2021-05-18)
 

data/README.md

@@ -38,6 +38,8 @@ For more of the story of GoodJob, read the [introductory blog post](https://isla
     - [Configuration options](#configuration-options)
     - [Global options](#global-options)
     - [Dashboard](#dashboard)
+    - [ActiveJob Concurrency](#activejob-concurrency)
+    - [Updating](#updating)
 - [Go deeper](#go-deeper)
     - [Exceptions, retries, and reliability](#exceptions-retries-and-reliability)
         - [Exceptions](#exceptions)
@@ -318,6 +320,51 @@ GoodJob includes a Dashboard as a mountable `Rails::Engine`.
     end
     ```
 
+### ActiveJob Concurrency
+
+GoodJob can extend ActiveJob to provide limits on concurrently running jobs, either at time of _enqueue_ or at _perform_.
+
+**Note:** Limiting concurrency at _enqueue_ requires Rails 6.0+ because Rails 5.2 does not support `throw :abort` in ActiveJob callbacks.
+
+```ruby
+class MyJob < ApplicationJob
+  include GoodJob::ActiveJobExtensions::Concurrency
+
+  good_job_control_concurrency_with(
+    # Maximum number of jobs with the concurrency key to be concurrently enqueued
+    enqueue_limit: 2,
+
+    # Maximum number of jobs with the concurrency key to be concurrently performed
+    perform_limit: 1,
+
+    # A unique key to be globally locked against.
+    # Can be String or Lambda/Proc that is invoked in the context of the job.
+    # Note: Arguments passed to #perform_later must be accessed through `arguments` method.
+    key: -> { "Unique-#{arguments.first}" } #  MyJob.perform_later("Alice") => "Unique-Alice"
+  )
+
+  def perform(first_name)
+    # do work
+  end
+end
+```
+
+### Updating
+
+GoodJob follows semantic versioning, though updates may be encouraged through deprecation warnings in minor versions.
+
+To apply updates:
+
+```bash
+bin/rails g good_job:update
+```
+
+...and run the resulting migration:
+
+```bash
+bin/rails db:migrate
+```
+
 ## Go deeper
 
 ### Exceptions, retries, and reliability

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

@@ -1,6 +1,6 @@
 module GoodJob
   class AssetsController < ActionController::Base # rubocop:disable Rails/ApplicationController
-    skip_before_action :verify_authenticity_token
+    skip_before_action :verify_authenticity_token, raise: false
 
     before_action do
       expires_in 1.year, public: true

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

@@ -14,7 +14,7 @@ module GoodJob
       def jobs
         after_scheduled_at = params[:after_scheduled_at].present? ? Time.zone.parse(params[:after_scheduled_at]) : nil
         sql = GoodJob::Job.display_all(after_scheduled_at: after_scheduled_at, after_id: params[:after_id])
-                          .limit(params.fetch(:limit, 10))
+                          .limit(params.fetch(:limit, 25))
         sql = sql.with_job_class(params[:job_class]) if params[:job_class]
         if params[:state]
           case params[:state]

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

@@ -0,0 +1,9 @@
+module GoodJob
+  class JobsController < GoodJob::BaseController
+    def destroy
+      deleted_count = GoodJob::Job.where(id: params[:id]).delete_all
+      message = deleted_count.positive? ? { notice: "Job deleted" } : { alert: "Job not deleted" }
+      redirect_to root_path, **message
+    end
+  end
+end

data/engine/app/views/layouts/good_job/base.html.erb

@@ -51,6 +51,19 @@
       </div>
     </div>
 
+    <% if notice %>
+      <div class="alert alert-success alert-dismissible fade show d-flex align-items-center offset-md-3 col-6" role="alert">
+        <%= render "shared/icons/check", class: "flex-shrink-0 me-2" %>
+        <div><%= notice %></div>
+        <button type="button" class="btn-close" data-bs-dismiss="alert" aria-label="Close"></button>
+      </div>
+    <% elsif alert %>
+      <div class="alert alert-warning alert-dismissible fade show d-flex align-items-center offset-md-3 col-6" role="alert">
+        <%= render "shared/icons/check", class: "flex-shrink-0 me-2" %>
+        <div><%= alert %></div>
+        <button type="button" class="btn-close" data-bs-dismiss="alert" aria-label="Close"></button>
+      </div>
+    <% end %>
     <%= yield %>
   </div>
 </body>

data/engine/app/views/shared/_jobs_table.erb

@@ -9,6 +9,7 @@
         <th>Scheduled At</th>
         <th>Error</th>
         <th>ActiveJob Params</th>
+        <th>Actions</th>
       </thead>
       <tbody>
         <% jobs.each do |job| %>
@@ -19,7 +20,18 @@
             <td><%= job.queue_name %></td>
             <td><%= job.scheduled_at || job.created_at %></td>
             <td><%= job.error %></td>
-            <td><pre><%= JSON.pretty_generate(job.serialized_params) %></pre></td>
+            <td>
+              <%= tag.button "Preview", type: "button", class: "btn btn-sm btn-outline-primary", role: "button",
+                data: {bs_toggle: "collapse", bs_target: "##{dom_id(job, 'params')}"},
+                aria: {expanded: false, controls: dom_id(job, "params")}
+              %>
+              <%= tag.pre JSON.pretty_generate(job.serialized_params), id: dom_id(job, "params"), class: "collapse" %>
+            </td>
+            <td>
+              <%= button_to job_path(job.id), method: :delete, class: "btn btn-sm btn-outline-danger", title: "Delete job" do %>
+                <%= render "shared/icons/trash" %>
+              <% end %>
+            </td>
           </tr>
         <% end %>
       </tbody>

data/engine/app/views/shared/icons/_check.html.erb

@@ -0,0 +1,4 @@
+<!-- https://icons.getbootstrap.com/icons/check-circle-fill/ -->
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" class="bi bi-check-circle-fill <%= local_assigns[:class] %>" viewBox="0 0 16 16">
+  <path d="M16 8A8 8 0 1 1 0 8a8 8 0 0 1 16 0zm-3.97-3.03a.75.75 0 0 0-1.08.022L7.477 9.417 5.384 7.323a.75.75 0 0 0-1.06 1.06L6.97 11.03a.75.75 0 0 0 1.079-.02l3.992-4.99a.75.75 0 0 0-.01-1.05z" />
+</svg>

data/engine/app/views/shared/icons/_exclamation.html.erb

@@ -0,0 +1,4 @@
+<!-- https://icons.getbootstrap.com/icons/exclamation-triangle-fill/ -->
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" class="bi bi-exclamation-triangle-fill <%= local_assigns[:class] %>" viewBox="0 0 16 16">
+  <path d="M8.982 1.566a1.13 1.13 0 0 0-1.96 0L.165 13.233c-.457.778.091 1.767.98 1.767h13.713c.889 0 1.438-.99.98-1.767L8.982 1.566zM8 5c.535 0 .954.462.9.995l-.35 3.507a.552.552 0 0 1-1.1 0L7.1 5.995A.905.905 0 0 1 8 5zm.002 6a1 1 0 1 1 0 2 1 1 0 0 1 0-2z" />
+</svg>

data/engine/app/views/shared/icons/_trash.html.erb

@@ -0,0 +1,5 @@
+<!-- https://icons.getbootstrap.com/icons/trash/ -->
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" class="bi bi-trash" viewBox="0 0 16 16">
+  <path d="M5.5 5.5A.5.5 0 0 1 6 6v6a.5.5 0 0 1-1 0V6a.5.5 0 0 1 .5-.5zm2.5 0a.5.5 0 0 1 .5.5v6a.5.5 0 0 1-1 0V6a.5.5 0 0 1 .5-.5zm3 .5a.5.5 0 0 0-1 0v6a.5.5 0 0 0 1 0V6z" />
+  <path fill-rule="evenodd" d="M14.5 3a1 1 0 0 1-1 1H13v9a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V4h-.5a1 1 0 0 1-1-1V2a1 1 0 0 1 1-1H6a1 1 0 0 1 1-1h2a1 1 0 0 1 1 1h3.5a1 1 0 0 1 1 1v1zM4.118 4 4 4.059V13a1 1 0 0 0 1 1h6a1 1 0 0 0 1-1V4.059L11.882 4H4.118zM2.5 3V2h11v1h-11z" />
+</svg>

data/engine/config/routes.rb

@@ -1,6 +1,7 @@
 GoodJob::Engine.routes.draw do
   root to: 'dashboards#index'
-  resources :active_jobs, only: :show
+  resources :active_jobs, only: %i[show]
+  resources :jobs, only: %i[destroy]
 
   scope controller: :assets do
     get :bootstrap_css

data/lib/generators/good_job/install_generator.rb

@@ -1,13 +1,9 @@
 require 'rails/generators'
 require 'rails/generators/active_record'
-
 module GoodJob
   #
-  # Implements the Rails generator used for setting up GoodJob in a Rails
-  # application. Run it with +bin/rails g good_job:install+ in your console.
-  #
-  # This generator is primarily dedicated to stubbing out a migration that adds
-  # a table to hold GoodJob's queued jobs in your database.
+  # 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 Rails::Generators::Migration
@@ -16,17 +12,11 @@ module GoodJob
       delegate :next_migration_number, to: ActiveRecord::Generators::Base
     end
 
-    source_paths << File.join(File.dirname(__FILE__), "templates")
+    source_paths << File.join(File.dirname(__FILE__), "templates/install")
 
-    # Generates the actual migration file and places it on disk.
+    # Generates monolithic migration file that contains all database changes.
     def create_migration_file
-      migration_template 'migration.rb.erb', 'db/migrate/create_good_jobs.rb', migration_version: migration_version
-    end
-
-    private
-
-    def migration_version
-      "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+      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

@@ -0,0 +1,27 @@
+class CreateGoodJobs < ActiveRecord::Migration[5.2]
+  def change
+    enable_extension 'pgcrypto'
+
+    create_table :good_jobs, id: :uuid do |t|
+      t.text :queue_name
+      t.integer :priority
+      t.jsonb :serialized_params
+      t.timestamp :scheduled_at
+      t.timestamp :performed_at
+      t.timestamp :finished_at
+      t.text :error
+
+      t.timestamps
+
+      t.uuid :active_job_id
+      t.text :concurrency_key
+      t.text :cron_key
+    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/templates/{migration.rb.erb → update/migrations/01_create_good_jobs.rb}

@@ -1,4 +1,4 @@
-class CreateGoodJobs < ActiveRecord::Migration<%= migration_version %>
+class CreateGoodJobs < ActiveRecord::Migration[5.2]
   def change
     enable_extension 'pgcrypto'
 
@@ -14,7 +14,7 @@ class CreateGoodJobs < ActiveRecord::Migration<%= migration_version %>
       t.timestamps
     end
 
-    add_index :good_jobs, :scheduled_at, where: "(finished_at IS NULL)"
-    add_index :good_jobs, [:queue_name, :scheduled_at], where: "(finished_at IS NULL)"
+    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
   end
 end

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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,32 @@
+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/update_generator.rb

@@ -0,0 +1,29 @@
+require 'rails/generators'
+require 'rails/generators/active_record'
+
+module GoodJob
+  #
+  # Rails generator used for updating GoodJob in a Rails application.
+  # Run it with +bin/rails g good_job:update+ in your console.
+  #
+  class UpdateGenerator < Rails::Generators::Base
+    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
+
+    # 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}", "db/migrate/#{destination_file}", skip: true
+      end
+    end
+  end
+end

data/lib/good_job/active_job_extensions.rb

@@ -0,0 +1,4 @@
+module GoodJob
+  module ActiveJobExtensions
+  end
+end

data/lib/good_job/active_job_extensions/concurrency.rb

@@ -0,0 +1,68 @@
+module GoodJob
+  module ActiveJobExtensions
+    module Concurrency
+      extend ActiveSupport::Concern
+
+      ConcurrencyExceededError = Class.new(StandardError)
+
+      included do
+        class_attribute :good_job_concurrency_config, instance_accessor: false, default: {}
+
+        before_enqueue do |job|
+          # Always allow jobs to be retried because the current job's execution will complete momentarily
+          next if CurrentExecution.active_job_id == job.job_id
+
+          limit = job.class.good_job_concurrency_config.fetch(:enqueue_limit, Float::INFINITY)
+          next if limit.blank? || (0...Float::INFINITY).exclude?(limit)
+
+          key = job.good_job_concurrency_key
+          next if key.blank?
+
+          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
+            # The job has not yet been enqueued, so check if adding it will go over the limit
+            throw :abort if enqueue_concurrency + 1 > limit
+          end
+        end
+
+        retry_on(
+          GoodJob::ActiveJobExtensions::Concurrency::ConcurrencyExceededError,
+          attempts: Float::INFINITY,
+          wait: :exponentially_longer
+        )
+
+        before_perform do |job|
+          limit = job.class.good_job_concurrency_config.fetch(:perform_limit, Float::INFINITY)
+          next if limit.blank? || (0...Float::INFINITY).exclude?(limit)
+
+          key = job.good_job_concurrency_key
+          next if key.blank?
+
+          GoodJob::Job.new.with_advisory_lock(key: key, function: "pg_advisory_lock") do
+            perform_concurrency = GoodJob::Job.unscoped.where(concurrency_key: key).advisory_locked.count
+            # The current job has already been locked and will appear in the previous query
+            raise GoodJob::ActiveJobExtensions::Concurrency::ConcurrencyExceededError if perform_concurrency > limit
+          end
+        end
+      end
+
+      class_methods do
+        def good_job_control_concurrency_with(config)
+          self.good_job_concurrency_config = config
+        end
+      end
+
+      def good_job_concurrency_key
+        key = self.class.good_job_concurrency_config[:key]
+        return if key.blank?
+
+        if key.respond_to? :call
+          instance_exec(&key)
+        else
+          key
+        end
+      end
+    end
+  end
+end

data/lib/good_job/current_execution.rb

@@ -4,11 +4,11 @@ module GoodJob
   # Thread-local attributes for passing values from Instrumentation.
   # (Cannot use ActiveSupport::CurrentAttributes because ActiveJob resets it)
   module CurrentExecution
-    # @!attribute [rw] error_on_retry
+    # @!attribute [rw] active_job_id
     #   @!scope class
-    #   Error captured by retry_on
-    #   @return [Exception, nil]
-    thread_mattr_accessor :error_on_retry
+    #   ActiveJob ID
+    #   @return [String, nil]
+    thread_mattr_accessor :active_job_id
 
     # @!attribute [rw] error_on_discard
     #   @!scope class
@@ -16,11 +16,18 @@ module GoodJob
     #   @return [Exception, nil]
     thread_mattr_accessor :error_on_discard
 
+    # @!attribute [rw] error_on_retry
+    #   @!scope class
+    #   Error captured by retry_on
+    #   @return [Exception, nil]
+    thread_mattr_accessor :error_on_retry
+
     # Resets attributes
     # @return [void]
     def self.reset
-      self.error_on_retry = nil
+      self.active_job_id = nil
       self.error_on_discard = nil
+      self.error_on_retry = nil
     end
 
     # @return [Integer] Current process ID

data/lib/good_job/job.rb

@@ -156,10 +156,10 @@ module GoodJob
     #   raised, if any (if the job raised, then the second array entry will be
     #   +nil+). If there were no jobs to execute, returns +nil+.
     def self.perform_with_advisory_lock
-      unfinished.priority_ordered.only_scheduled.limit(1).with_advisory_lock do |good_jobs|
+      unfinished.priority_ordered.only_scheduled.limit(1).with_advisory_lock(unlock_session: true) do |good_jobs|
         good_job = good_jobs.first
-        # TODO: Determine why some records are fetched without an advisory lock at all
-        break unless good_job&.executable?
+        break if good_job.blank?
+        break :unlocked unless good_job&.executable?
 
         good_job.perform
       end
@@ -196,13 +196,45 @@ module GoodJob
     #   The new {Job} instance representing the queued ActiveJob job.
     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 = GoodJob::Job.new(
+        good_job_args = {
           queue_name: active_job.queue_name.presence || DEFAULT_QUEUE_NAME,
           priority: active_job.priority || DEFAULT_PRIORITY,
           serialized_params: active_job.serialize,
           scheduled_at: scheduled_at,
-          create_with_advisory_lock: create_with_advisory_lock
-        )
+          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
+          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
+        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
+          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
+        end
+
+        good_job = GoodJob::Job.new(**good_job_args)
 
         instrument_payload[:good_job] = good_job
 
@@ -247,6 +279,10 @@ module GoodJob
       self.class.unscoped.unfinished.owns_advisory_locked.exists?(id: id)
     end
 
+    def active_job_id
+      super || serialized_params['job_id']
+    end
+
     private
 
     # @return [ExecutionResult]
@@ -256,6 +292,7 @@ module GoodJob
       )
 
       GoodJob::CurrentExecution.reset
+      GoodJob::CurrentExecution.active_job_id = active_job_id
       ActiveSupport::Notifications.instrument("perform_job.good_job", { good_job: self, process_id: GoodJob::CurrentExecution.process_id, thread_name: GoodJob::CurrentExecution.thread_name }) do
         value = ActiveJob::Base.execute(params)
 

data/lib/good_job/lockable.rb

@@ -22,17 +22,25 @@ module GoodJob
     RecordAlreadyAdvisoryLockedError = Class.new(StandardError)
 
     included do
+      # Default column to be used when creating Advisory Locks
+      class_attribute :advisory_lockable_column, instance_accessor: false, default: Concurrent::Delay.new { primary_key }
+
+      # Default Postgres function to be used for Advisory Locks
+      class_attribute :advisory_lockable_function, default: "pg_try_advisory_lock"
+
       # Attempt to acquire an advisory lock on the selected records and
       # return only those records for which a lock could be acquired.
-      # @!method advisory_lock
+      # @!method advisory_lock(column: _advisory_lockable_column, function: advisory_lockable_function)
       # @!scope class
+      # @param column [String, Symbol] column values to Advisory Lock against
+      # @param function [String, Symbol]  Postgres Advisory Lock function name to use
       # @return [ActiveRecord::Relation]
       #   A relation selecting only the records that were locked.
-      scope :advisory_lock, (lambda do
+      scope :advisory_lock, (lambda do |column: _advisory_lockable_column, function: advisory_lockable_function|
         original_query = self
 
         cte_table = Arel::Table.new(:rows)
-        cte_query = original_query.select(primary_key).except(:limit)
+        cte_query = original_query.select(primary_key, column).except(:limit)
         cte_type = if supports_cte_materialization_specifiers?
                      'MATERIALIZED'
                    else
@@ -40,10 +48,9 @@ module GoodJob
                    end
 
         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(["pg_try_advisory_lock(('x' || substr(md5(:table_name || #{connection.quote_table_name(cte_table.name)}.#{quoted_primary_key}::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?
@@ -57,40 +64,44 @@ module GoodJob
       #
       # For details on +pg_locks+, see
       # {https://www.postgresql.org/docs/current/view-pg-locks.html}.
-      # @!method joins_advisory_locks
+      # @!method joins_advisory_locks(column: _advisory_lockable_column)
       # @!scope class
+      # @param column [String, Symbol] column values to Advisory Lock against
       # @return [ActiveRecord::Relation]
       # @example Get the records that have a session awaiting a lock:
       #   MyLockableRecord.joins_advisory_locks.where("pg_locks.granted = ?", false)
-      scope :joins_advisory_locks, (lambda do
+      scope :joins_advisory_locks, (lambda do |column: _advisory_lockable_column|
         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}.#{quoted_primary_key}::text), 1, 16))::bit(32)::int
-            AND pg_locks.objid = (('x' || substr(md5(:table_name || #{quoted_table_name}.#{quoted_primary_key}::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 }]))
       end)
 
       # Find records that do not have an advisory lock on them.
-      # @!method advisory_unlocked
+      # @!method advisory_unlocked(column: _advisory_lockable_column)
       # @!scope class
+      # @param column [String, Symbol] column values to Advisory Lock against
       # @return [ActiveRecord::Relation]
-      scope :advisory_unlocked, -> { joins_advisory_locks.where(pg_locks: { locktype: nil }) }
+      scope :advisory_unlocked, ->(column: _advisory_lockable_column) { joins_advisory_locks(column: column).where(pg_locks: { locktype: nil }) }
 
       # Find records that have an advisory lock on them.
-      # @!method advisory_locked
+      # @!method advisory_locked(column: _advisory_lockable_column)
       # @!scope class
+      # @param column [String, Symbol] column values to Advisory Lock against
       # @return [ActiveRecord::Relation]
-      scope :advisory_locked, -> { joins_advisory_locks.where.not(pg_locks: { locktype: nil }) }
+      scope :advisory_locked, ->(column: _advisory_lockable_column) { joins_advisory_locks(column: column).where.not(pg_locks: { locktype: nil }) }
 
       # Find records with advisory locks owned by the current Postgres
       # session/connection.
-      # @!method advisory_locked
+      # @!method advisory_locked(column: _advisory_lockable_column)
       # @!scope class
+      # @param column [String, Symbol] column values to Advisory Lock against
       # @return [ActiveRecord::Relation]
-      scope :owns_advisory_locked, -> { joins_advisory_locks.where('"pg_locks"."pid" = pg_backend_pid()') }
+      scope :owns_advisory_locked, ->(column: _advisory_lockable_column) { joins_advisory_locks(column: column).where('"pg_locks"."pid" = pg_backend_pid()') }
 
       # Whether an advisory lock should be acquired in the same transaction
       # that created the record.
@@ -122,6 +133,9 @@ module GoodJob
       # can (as in {Lockable.advisory_lock}) and only pass those that could be
       # locked to the block.
       #
+      # @param column [String, Symbol]  name of advisory lock or unlock function
+      # @param function [String, Symbol] Postgres Advisory Lock function name to use
+      # @param unlock_session [Boolean] Whether to unlock all advisory locks in the session afterwards
       # @yield [Array<Lockable>] the records that were successfully locked.
       # @return [Object] the result of the block.
       #
@@ -129,65 +143,115 @@ module GoodJob
       #   MyLockableRecord.order(created_at: :asc).limit(2).with_advisory_lock do |record|
       #     do_something_with record
       #   end
-      def with_advisory_lock
+      def with_advisory_lock(column: _advisory_lockable_column, function: advisory_lockable_function, unlock_session: false)
         raise ArgumentError, "Must provide a block" unless block_given?
 
-        records = advisory_lock.to_a
+        records = advisory_lock(column: column, function: function).to_a
         begin
           yield(records)
         ensure
-          records.each(&:advisory_unlock)
+          if unlock_session
+            advisory_unlock_session
+          else
+            records.each do |record|
+              key = [table_name, record[_advisory_lockable_column]].join
+              record.advisory_unlock(key: key, function: advisory_unlockable_function(function))
+            end
+          end
         end
       end
 
+      # Allow advisory_lockable_column to be a `Concurrent::Delay`
+      def _advisory_lockable_column
+        column = advisory_lockable_column
+        column.respond_to?(:value) ? column.value : column
+      end
+
       def supports_cte_materialization_specifiers?
         return @_supports_cte_materialization_specifiers if defined?(@_supports_cte_materialization_specifiers)
 
         @_supports_cte_materialization_specifiers = connection.postgresql_version >= 120000
       end
+
+      # Postgres advisory unlocking function for the class
+      # @param function [String, Symbol] name of advisory lock or unlock function
+      # @return [Boolean]
+      def advisory_unlockable_function(function = advisory_lockable_function)
+        function.to_s.sub("_lock", "_unlock").sub("_try_", "_")
+      end
+
+      # Unlocks all advisory locks active in the current database session/connection
+      # @return [void]
+      def advisory_unlock_session
+        connection.exec_query("SELECT pg_advisory_unlock_all()::text AS unlocked", 'GoodJob::Lockable Unlock Session').first[:unlocked]
+      end
+
+      # Converts SQL query strings between PG-compatible and JDBC-compatible syntax
+      # @param query [String]
+      # @return [Boolean]
+      def pg_or_jdbc_query(query)
+        if Concurrent.on_jruby?
+          # Replace $1 bind parameters with ?
+          query.gsub(/\$\d*/, '?')
+        else
+          query
+        end
+      end
     end
 
     # Acquires an advisory lock on this record if it is not already locked by
     # another database session. Be careful to ensure you release the lock when
     # you are done with {#advisory_unlock} (or {#advisory_unlock!} to release
     # all remaining locks).
+    # @param key [String, Symbol] Key to Advisory Lock against
+    # @param function [String, Symbol] Postgres Advisory Lock function name to use
     # @return [Boolean] whether the lock was acquired.
-    def advisory_lock
-      query = <<~SQL.squish
-        SELECT 1 AS one
-        WHERE pg_try_advisory_lock(('x'||substr(md5($1 || $2::text), 1, 16))::bit(64)::bigint)
-      SQL
-      binds = [[nil, self.class.table_name], [nil, send(self.class.primary_key)]]
-      self.class.connection.exec_query(pg_or_jdbc_query(query), 'GoodJob::Lockable Advisory Lock', binds).any?
+    def advisory_lock(key: lockable_key, function: advisory_lockable_function)
+      query = if function.include? "_try_"
+                <<~SQL.squish
+                  SELECT #{function}(('x'||substr(md5($1::text), 1, 16))::bit(64)::bigint) AS locked
+                SQL
+              else
+                <<~SQL.squish
+                  SELECT #{function}(('x'||substr(md5($1::text), 1, 16))::bit(64)::bigint)::text AS locked
+                SQL
+              end
+
+      binds = [[nil, key]]
+      self.class.connection.exec_query(pg_or_jdbc_query(query), 'GoodJob::Lockable Advisory Lock', binds).first['locked']
     end
 
     # Releases an advisory lock on this record if it is locked by this database
     # session. Note that advisory locks stack, so you must call
     # {#advisory_unlock} and {#advisory_lock} the same number of times.
+    # @param key [String, Symbol] Key to lock against
+    # @param function [String, Symbol] Postgres Advisory Lock function name to use
     # @return [Boolean] whether the lock was released.
-    def advisory_unlock
+    def advisory_unlock(key: lockable_key, function: self.class.advisory_unlockable_function(advisory_lockable_function))
       query = <<~SQL.squish
-        SELECT 1 AS one
-        WHERE pg_advisory_unlock(('x'||substr(md5($1 || $2::text), 1, 16))::bit(64)::bigint)
+        SELECT #{function}(('x'||substr(md5($1::text), 1, 16))::bit(64)::bigint) AS unlocked
       SQL
-      binds = [[nil, self.class.table_name], [nil, send(self.class.primary_key)]]
-      self.class.connection.exec_query(pg_or_jdbc_query(query), 'GoodJob::Lockable Advisory Unlock', binds).any?
+      binds = [[nil, key]]
+      self.class.connection.exec_query(pg_or_jdbc_query(query), 'GoodJob::Lockable Advisory Unlock', binds).first['unlocked']
     end
 
     # Acquires an advisory lock on this record or raises
     # {RecordAlreadyAdvisoryLockedError} if it is already locked by another
     # database session.
+    # @param key [String, Symbol] Key to lock against
+    # @param function [String, Symbol] Postgres Advisory Lock function name to use
     # @raise [RecordAlreadyAdvisoryLockedError]
     # @return [Boolean] +true+
-    def advisory_lock!
-      result = advisory_lock
+    def advisory_lock!(key: lockable_key, function: advisory_lockable_function)
+      result = advisory_lock(key: key, function: function)
       result || raise(RecordAlreadyAdvisoryLockedError)
     end
 
     # Acquires an advisory lock on this record and safely releases it after the
     # passed block is completed. If the record is locked by another database
     # session, this raises {RecordAlreadyAdvisoryLockedError}.
-    #
+    # @param key [String, Symbol] Key to lock against
+    # @param function [String, Symbol] Postgres Advisory Lock function name to use
     # @yield Nothing
     # @return [Object] The result of the block.
     #
@@ -196,64 +260,63 @@ module GoodJob
     #   record.with_advisory_lock do
     #     do_something_with record
     #   end
-    def with_advisory_lock
+    def with_advisory_lock(key: lockable_key, function: advisory_lockable_function)
       raise ArgumentError, "Must provide a block" unless block_given?
 
-      advisory_lock!
+      advisory_lock!(key: key, function: function)
       yield
     ensure
-      advisory_unlock unless $ERROR_INFO.is_a? RecordAlreadyAdvisoryLockedError
+      advisory_unlock(key: key, function: self.class.advisory_unlockable_function(function)) unless $ERROR_INFO.is_a? RecordAlreadyAdvisoryLockedError
     end
 
     # Tests whether this record has an advisory lock on it.
+    # @param key [String, Symbol] Key to test lock against
     # @return [Boolean]
-    def advisory_locked?
+    def advisory_locked?(key: lockable_key)
       query = <<~SQL.squish
         SELECT 1 AS one
         FROM pg_locks
         WHERE pg_locks.locktype = 'advisory'
           AND pg_locks.objsubid = 1
-          AND pg_locks.classid = ('x' || substr(md5($1 || $2::text), 1, 16))::bit(32)::int
-          AND pg_locks.objid = (('x' || substr(md5($3 || $4::text), 1, 16))::bit(64) << 32)::bit(32)::int
+          AND pg_locks.classid = ('x' || substr(md5($1::text), 1, 16))::bit(32)::int
+          AND pg_locks.objid = (('x' || substr(md5($2::text), 1, 16))::bit(64) << 32)::bit(32)::int
       SQL
-      binds = [[nil, self.class.table_name], [nil, send(self.class.primary_key)], [nil, self.class.table_name], [nil, send(self.class.primary_key)]]
+      binds = [[nil, key], [nil, key]]
       self.class.connection.exec_query(pg_or_jdbc_query(query), 'GoodJob::Lockable Advisory Locked?', binds).any?
     end
 
     # Tests whether this record is locked by the current database session.
+    # @param key [String, Symbol] Key to test lock against
     # @return [Boolean]
-    def owns_advisory_lock?
+    def owns_advisory_lock?(key: lockable_key)
       query = <<~SQL.squish
         SELECT 1 AS one
         FROM pg_locks
         WHERE pg_locks.locktype = 'advisory'
           AND pg_locks.objsubid = 1
-          AND pg_locks.classid = ('x' || substr(md5($1 || $2::text), 1, 16))::bit(32)::int
-          AND pg_locks.objid = (('x' || substr(md5($3 || $4::text), 1, 16))::bit(64) << 32)::bit(32)::int
+          AND pg_locks.classid = ('x' || substr(md5($1::text), 1, 16))::bit(32)::int
+          AND pg_locks.objid = (('x' || substr(md5($2::text), 1, 16))::bit(64) << 32)::bit(32)::int
           AND pg_locks.pid = pg_backend_pid()
       SQL
-      binds = [[nil, self.class.table_name], [nil, send(self.class.primary_key)], [nil, self.class.table_name], [nil, send(self.class.primary_key)]]
+      binds = [[nil, key], [nil, key]]
       self.class.connection.exec_query(pg_or_jdbc_query(query), 'GoodJob::Lockable Owns Advisory Lock?', binds).any?
     end
 
     # Releases all advisory locks on the record that are held by the current
     # database session.
+    # @param key [String, Symbol] Key to lock against
+    # @param function [String, Symbol] Postgres Advisory Lock function name to use
     # @return [void]
-    def advisory_unlock!
-      advisory_unlock while advisory_locked?
+    def advisory_unlock!(key: lockable_key, function: self.class.advisory_unlockable_function(advisory_lockable_function))
+      advisory_unlock(key: key, function: function) while advisory_locked?
     end
 
-    private
-
-    # @param query [String]
-    # @return [Boolean]
-    def pg_or_jdbc_query(query)
-      if Concurrent.on_jruby?
-        # Replace $1 bind parameters with ?
-        query.gsub(/\$\d*/, '?')
-      else
-        query
-      end
+    # Default Advisory Lock key
+    # @return [String]
+    def lockable_key
+      [self.class.table_name, self[self.class._advisory_lockable_column]].join
     end
+
+    delegate :pg_or_jdbc_query, to: :class
   end
 end

data/lib/good_job/poller.rb

@@ -5,11 +5,13 @@ module GoodJob # :nodoc:
   # Pollers regularly wake up execution threads to check for new work.
   #
   class Poller
+    TIMEOUT_INTERVAL = 5
+
     # Defaults for instance of Concurrent::TimerTask.
     # The timer controls how and when sleeping threads check for new work.
     DEFAULT_TIMER_OPTIONS = {
       execution_interval: Configuration::DEFAULT_POLL_INTERVAL,
-      timeout_interval: 1,
+      timeout_interval: TIMEOUT_INTERVAL,
       run_now: true,
     }.freeze
 
@@ -49,9 +51,11 @@ module GoodJob # :nodoc:
 
     # Tests whether the timer is shutdown.
     # @return [true, false, nil]
-    delegate :shutdown?, to: :timer, allow_nil: true
+    def shutdown?
+      timer ? timer.shutdown? : true
+    end
 
-    # Shut down the notifier.
+    # Shut down the poller.
     # Use {#shutdown?} to determine whether threads have stopped.
     # @param timeout [nil, Numeric] Seconds to wait for active threads.
     #   * +nil+, the scheduler will trigger a shutdown but not wait for it to complete.

data/lib/good_job/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 1.9.5
+  version: 1.11.1
 platform: ruby
 authors:
 - Ben Sheldon
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-05-24 00:00:00.000000000 Z
+date: 2021-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
@@ -94,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.8.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.8.4
 - !ruby/object:Gem::Dependency
   name: capybara
   requirement: !ruby/object:Gem::Requirement
@@ -327,19 +341,29 @@ files:
 - engine/app/controllers/good_job/assets_controller.rb
 - engine/app/controllers/good_job/base_controller.rb
 - engine/app/controllers/good_job/dashboards_controller.rb
+- engine/app/controllers/good_job/jobs_controller.rb
 - engine/app/helpers/good_job/application_helper.rb
 - engine/app/views/good_job/active_jobs/show.html.erb
 - engine/app/views/good_job/dashboards/index.html.erb
 - engine/app/views/layouts/good_job/base.html.erb
 - engine/app/views/shared/_chart.erb
 - engine/app/views/shared/_jobs_table.erb
+- engine/app/views/shared/icons/_check.html.erb
+- engine/app/views/shared/icons/_exclamation.html.erb
+- engine/app/views/shared/icons/_trash.html.erb
 - engine/config/routes.rb
 - engine/lib/good_job/engine.rb
 - exe/good_job
 - lib/active_job/queue_adapters/good_job_adapter.rb
 - lib/generators/good_job/install_generator.rb
-- lib/generators/good_job/templates/migration.rb.erb
+- 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/update_generator.rb
 - lib/good_job.rb
+- lib/good_job/active_job_extensions.rb
+- lib/good_job/active_job_extensions/concurrency.rb
 - lib/good_job/adapter.rb
 - lib/good_job/cli.rb
 - lib/good_job/configuration.rb