good_job 1.1.4 → 1.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7134108a565e8b1efaa825cec90630cab0965fcfca5ff02f09751730f8839bdc
-  data.tar.gz: d887e3b6cbb6d3d877793b186de2c0ca5a65178b968b2000821c6f9000c0fdd1
+  metadata.gz: 1f3fa6d323c18dfb49aaf3b87f0ca71492a935752e7ca140880b68daa72a60f9
+  data.tar.gz: 999b400b7e1dd22206898fb1cdc35f6255088ce94c3562fa48fe97fc20a23672
 SHA512:
-  metadata.gz: cce4a02b62ded08da0b2665cb346bfbeda6fdffa15182c8ab680962f6ba1f3534a8b9ac4cad8ecfa60d34b15cdfaabff5c8c80e4b3f7bdaa99c2d7a0e4208fe9
-  data.tar.gz: d9f13feb39a8700fe889c7b4250004095cdddeb5e1e9f06426610d10c13ce7c14d20db32810aa93dd4d1b7a075f585821bf4581634373a3585540bab0018f46c
+  metadata.gz: 1b9236562e20d4da1e5738d9b143fabe9377d854b392b6b0eb2d77c0009d9f8a0c82ef94b414446a7b5db0b2a43e477ad4b8a6c7bff737b69c9d8a744ee29151
+  data.tar.gz: cfcc994ea2f6e9a26c3b1115ccb2df6383e2897c3db891415745b86769dbdc411a62b7d60c89aa7ddb6880009c6124c795cef33efff55daa860ed7fd90e1b81d

data/CHANGELOG.md

@@ -1,5 +1,95 @@
 # Changelog
 
+## [v1.2.4](https://github.com/bensheldon/good_job/tree/v1.2.4) (2020-09-01)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v1.2.3...v1.2.4)
+
+**Implemented enhancements:**
+
+- Add environment variable to mirror `cleanup\_preserved\_jobs --before-seconds-ago=SECONDS` [\#110](https://github.com/bensheldon/good_job/issues/110)
+
+**Closed issues:**
+
+- Remove unused PgLocks class [\#121](https://github.com/bensheldon/good_job/issues/121)
+- Fix minor issue with CommandLine option links in README.md [\#116](https://github.com/bensheldon/good_job/issues/116)
+- Unused .advisory\_lock\_details in PgLocks [\#105](https://github.com/bensheldon/good_job/issues/105)
+
+**Merged pull requests:**
+
+- Remove unused PgLocks class [\#120](https://github.com/bensheldon/good_job/pull/120) ([gadimbaylisahil](https://github.com/gadimbaylisahil))
+- Better table name detection for Job queries [\#119](https://github.com/bensheldon/good_job/pull/119) ([gadimbaylisahil](https://github.com/gadimbaylisahil))
+- Fix readme CommandLine option links [\#115](https://github.com/bensheldon/good_job/pull/115) ([gadimbaylisahil](https://github.com/gadimbaylisahil))
+- Allow env variable config for cleanups [\#114](https://github.com/bensheldon/good_job/pull/114) ([gadimbaylisahil](https://github.com/gadimbaylisahil))
+- Have YARD render markdown files with GFM \(Github Flavored Markdown\) [\#113](https://github.com/bensheldon/good_job/pull/113) ([bensheldon](https://github.com/bensheldon))
+- Add markdownlint to lint readme [\#109](https://github.com/bensheldon/good_job/pull/109) ([bensheldon](https://github.com/bensheldon))
+- Remove unused method in PgLocks [\#107](https://github.com/bensheldon/good_job/pull/107) ([gadimbaylisahil](https://github.com/gadimbaylisahil))
+- Re-organize Readme: frontload configuration, add Table of Contents  [\#106](https://github.com/bensheldon/good_job/pull/106) ([bensheldon](https://github.com/bensheldon))
+
+## [v1.2.3](https://github.com/bensheldon/good_job/tree/v1.2.3) (2020-08-27)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v1.2.2...v1.2.3)
+
+**Closed issues:**
+
+- requiring more dependencies in then needed [\#103](https://github.com/bensheldon/good_job/issues/103)
+
+**Merged pull requests:**
+
+- stop depending on all rails libs [\#104](https://github.com/bensheldon/good_job/pull/104) ([thilo](https://github.com/thilo))
+
+## [v1.2.2](https://github.com/bensheldon/good_job/tree/v1.2.2) (2020-08-27)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v1.2.1...v1.2.2)
+
+**Implemented enhancements:**
+
+- Run Github Action tests against Ruby 2.5, 2.6, 2.7 [\#100](https://github.com/bensheldon/good_job/issues/100)
+
+**Fixed bugs:**
+
+- Freezes puma on code change [\#95](https://github.com/bensheldon/good_job/issues/95)
+- Ruby 2.7 keyword arguments warning [\#93](https://github.com/bensheldon/good_job/issues/93)
+
+**Closed issues:**
+
+- Add test for `rails g good\_job:install` [\#57](https://github.com/bensheldon/good_job/issues/57)
+
+**Merged pull requests:**
+
+- Use more ActiveRecord in Lockable and not connection.execute [\#102](https://github.com/bensheldon/good_job/pull/102) ([bensheldon](https://github.com/bensheldon))
+- Run CI tests on Ruby 2.5, 2.6, and 2.7 [\#101](https://github.com/bensheldon/good_job/pull/101) ([arku](https://github.com/arku))
+- Return to using executor.wrap around Scheduler execution task [\#99](https://github.com/bensheldon/good_job/pull/99) ([bensheldon](https://github.com/bensheldon))
+- Fix Ruby 2.7 keyword arguments warning [\#98](https://github.com/bensheldon/good_job/pull/98) ([arku](https://github.com/arku))
+- Remove executor/reloader for less interlocking [\#97](https://github.com/bensheldon/good_job/pull/97) ([sj26](https://github.com/sj26))
+- Name the thread pools [\#96](https://github.com/bensheldon/good_job/pull/96) ([sj26](https://github.com/sj26))
+- Add test for `rails g good\_job:install` [\#94](https://github.com/bensheldon/good_job/pull/94) ([arku](https://github.com/arku))
+
+## [v1.2.1](https://github.com/bensheldon/good_job/tree/v1.2.1) (2020-08-21)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v1.2.0...v1.2.1)
+
+**Fixed bugs:**
+
+- undefined method `thread\_mattr\_accessor' when not requiring the Sprockets Railstie [\#85](https://github.com/bensheldon/good_job/issues/85)
+
+**Closed issues:**
+
+- Document comparison of GoodJob with other backends [\#51](https://github.com/bensheldon/good_job/issues/51)
+
+**Merged pull requests:**
+
+- Explicitly require thread\_mattr\_accessor from ActiveSupport [\#86](https://github.com/bensheldon/good_job/pull/86) ([bensheldon](https://github.com/bensheldon))
+- Add comparison of other backends to Readme [\#84](https://github.com/bensheldon/good_job/pull/84) ([bensheldon](https://github.com/bensheldon))
+
+## [v1.2.0](https://github.com/bensheldon/good_job/tree/v1.2.0) (2020-08-20)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v1.1.4...v1.2.0)
+
+**Merged pull requests:**
+
+- Document GoodJob module [\#83](https://github.com/bensheldon/good_job/pull/83) ([bensheldon](https://github.com/bensheldon))
+- Add Postgres LISTEN/NOTIFY support [\#82](https://github.com/bensheldon/good_job/pull/82) ([bensheldon](https://github.com/bensheldon))
+
 ## [v1.1.4](https://github.com/bensheldon/good_job/tree/v1.1.4) (2020-08-19)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v1.1.3...v1.1.4)
@@ -11,7 +101,6 @@
 
 **Merged pull requests:**
 
-- Add Postgres LISTEN/NOTIFY support [\#82](https://github.com/bensheldon/good_job/pull/82) ([bensheldon](https://github.com/bensheldon))
 - Allow Schedulers to filter \#create\_thread to avoid flood of queries when running async with multiple schedulers [\#81](https://github.com/bensheldon/good_job/pull/81) ([bensheldon](https://github.com/bensheldon))
 - Fully name scheduler threadpools and thread names; refactor CLI STDOUT [\#80](https://github.com/bensheldon/good_job/pull/80) ([bensheldon](https://github.com/bensheldon))
 
@@ -51,6 +140,7 @@
 **Merged pull requests:**
 
 - Allow instantiation of multiple schedulers via --queues [\#76](https://github.com/bensheldon/good_job/pull/76) ([bensheldon](https://github.com/bensheldon))
+- Extract options parsing to Configuration object [\#74](https://github.com/bensheldon/good_job/pull/74) ([bensheldon](https://github.com/bensheldon))
 
 ## [v1.1.0](https://github.com/bensheldon/good_job/tree/v1.1.0) (2020-08-10)
 
@@ -85,7 +175,6 @@
 
 **Merged pull requests:**
 
-- Extract options parsing to Configuration object [\#74](https://github.com/bensheldon/good_job/pull/74) ([bensheldon](https://github.com/bensheldon))
 - Re-perform a job if a StandardError bubbles up; better document job reliability [\#62](https://github.com/bensheldon/good_job/pull/62) ([bensheldon](https://github.com/bensheldon))
 - Update the setup documentation to use correct bin setup command [\#61](https://github.com/bensheldon/good_job/pull/61) ([jm96441n](https://github.com/jm96441n))
 
@@ -93,10 +182,6 @@
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v1.0.1...v1.0.2)
 
-**Fixed bugs:**
-
-- Fix counting of available execution threads [\#58](https://github.com/bensheldon/good_job/pull/58) ([bensheldon](https://github.com/bensheldon))
-
 **Merged pull requests:**
 
 - Add migration generator [\#56](https://github.com/bensheldon/good_job/pull/56) ([thedanbob](https://github.com/thedanbob))
@@ -108,7 +193,7 @@
 
 **Merged pull requests:**
 
-- Allow preservation of finished job records [\#46](https://github.com/bensheldon/good_job/pull/46) ([bensheldon](https://github.com/bensheldon))
+- Change threadpool idletime default to 60 seconds from 0 [\#49](https://github.com/bensheldon/good_job/pull/49) ([bensheldon](https://github.com/bensheldon))
 
 ## [v1.0.0](https://github.com/bensheldon/good_job/tree/v1.0.0) (2020-07-20)
 
@@ -118,6 +203,14 @@
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v0.8.2...v0.9.0)
 
+**Fixed bugs:**
+
+- Fix counting of available execution threads [\#58](https://github.com/bensheldon/good_job/pull/58) ([bensheldon](https://github.com/bensheldon))
+
+**Merged pull requests:**
+
+- Allow preservation of finished job records [\#46](https://github.com/bensheldon/good_job/pull/46) ([bensheldon](https://github.com/bensheldon))
+
 ## [v0.8.2](https://github.com/bensheldon/good_job/tree/v0.8.2) (2020-07-18)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v0.8.1...v0.8.2)
@@ -145,7 +238,6 @@
 
 **Merged pull requests:**
 
-- Change threadpool idletime default to 60 seconds from 0 [\#49](https://github.com/bensheldon/good_job/pull/49) ([bensheldon](https://github.com/bensheldon))
 - Replace Adapter inline boolean kwarg with execution\_mode instead [\#41](https://github.com/bensheldon/good_job/pull/41) ([bensheldon](https://github.com/bensheldon))
 
 ## [v0.7.0](https://github.com/bensheldon/good_job/tree/v0.7.0) (2020-07-16)
@@ -195,6 +287,7 @@
 
 - Improve ActiveRecord usage for advisory locking [\#24](https://github.com/bensheldon/good_job/pull/24) ([bensheldon](https://github.com/bensheldon))
 - Remove support for Rails 5.1 [\#23](https://github.com/bensheldon/good_job/pull/23) ([bensheldon](https://github.com/bensheldon))
+- Clean up Gemspec [\#15](https://github.com/bensheldon/good_job/pull/15) ([bensheldon](https://github.com/bensheldon))
 
 ## [v0.3.0](https://github.com/bensheldon/good_job/tree/v0.3.0) (2020-03-22)
 
@@ -222,7 +315,6 @@
 
 **Merged pull requests:**
 
-- Clean up Gemspec [\#15](https://github.com/bensheldon/good_job/pull/15) ([bensheldon](https://github.com/bensheldon))
 - Set up Rubocop [\#14](https://github.com/bensheldon/good_job/pull/14) ([bensheldon](https://github.com/bensheldon))
 - Add pg gem as explicit dependency [\#13](https://github.com/bensheldon/good_job/pull/13) ([bensheldon](https://github.com/bensheldon))
 - Bump nokogiri from 1.10.7 to 1.10.9 [\#12](https://github.com/bensheldon/good_job/pull/12) ([dependabot[bot]](https://github.com/apps/dependabot))

data/README.md

@@ -4,197 +4,281 @@ GoodJob is a multithreaded, Postgres-based, ActiveJob backend for Ruby on Rails.
 
 **Inspired by [Delayed::Job](https://github.com/collectiveidea/delayed_job) and [Que](https://github.com/que-rb/que), GoodJob is designed for maximum compatibility with Ruby on Rails, ActiveJob, and Postgres to be simple and performant for most workloads.**
 
-- **Designed for ActiveJob.** Complete support for [async, queues, delays, priorities, timeouts, and retries](https://edgeguides.rubyonrails.org/active_job_basics.html) with near-zero configuration. 
-- **Built for Rails.** Fully adopts Ruby on Rails [threading and code execution guidelines](https://guides.rubyonrails.org/threading_and_code_execution.html) with [Concurrent::Ruby](https://github.com/ruby-concurrency/concurrent-ruby). 
+- **Designed for ActiveJob.** Complete support for [async, queues, delays, priorities, timeouts, and retries](https://edgeguides.rubyonrails.org/active_job_basics.html) with near-zero configuration.
+- **Built for Rails.** Fully adopts Ruby on Rails [threading and code execution guidelines](https://guides.rubyonrails.org/threading_and_code_execution.html) with [Concurrent::Ruby](https://github.com/ruby-concurrency/concurrent-ruby).
 - **Backed by Postgres.** Relies upon Postgres integrity, session-level Advisory Locks to provide run-once safety and stay within the limits of `schema.rb`, and LISTEN/NOTIFY to reduce queuing latency.
 - **For most workloads.** Targets full-stack teams, economy-minded solo developers, and applications that enqueue less than 1-million jobs/day.
 
 For more of the story of GoodJob, read the [introductory blog post](https://island94.org/2020/07/introducing-goodjob-1-0).
 
-## Installation
+<details markdown="1">
+<summary><strong>📊 Comparison of GoodJob with other job queue backends (click to expand)</strong></summary>
+
+|                 | Queues, priority, retries | Database                              | Concurrency       | Reliability/Integrity  | Latency                  |
+|-----------------|---------------------------|---------------------------------------|-------------------|------------------------|--------------------------|
+| **GoodJob**     | ✅ Yes                     | ✅ Postgres                            | ✅ Multithreaded   | ✅ ACID, Advisory Locks | ✅ Postgres LISTEN/NOTIFY |
+| **Que**         | ✅ Yes                     | 🔶️ Postgres, requires  `structure.sql` | ✅ Multithreaded   | ✅ ACID, Advisory Locks | ✅ Postgres LISTEN/NOTIFY |
+| **Delayed Job** | ✅ Yes                     | ✅ Postgres                            | 🔴 Single-threaded | ✅ ACID, record-based   | 🔶 Polling                |
+| **Sidekiq**     | ✅ Yes                     | 🔴 Redis                               | ✅ Multithreaded   | 🔴 Crashes lose jobs    | ✅ Redis BRPOP            |
+| **Sidekiq Pro** | ✅ Yes                     | 🔴 Redis                               | ✅ Multithreaded   | ✅ Redis RPOPLPUSH      | ✅ Redis RPOPLPUSH        |
+
+</details>
+
+## Table of contents
+
+- [Set up](#set-up)
+- [Configuration](#configuration)
+    - [Command-line options](#command-line-options)
+        - [`good_job start`](#good_job-start)
+        - [`good_job cleanup_preserved_jobs`](#good_job-cleanup_preserved_jobs)
+    - [Adapter options](#adapter-options)
+    - [Global options](#global-options)
+- [Going deeper](#going-deeper)
+    - [Exceptions, retries, and reliability](#exceptions-retries-and-reliability)
+        - [Exceptions](#exceptions)
+        - [Retries](#retries)
+        - [ActionMailer retries](#actionmailer-retries)
+    - [Timeouts](#timeouts)
+    - [Optimize queues, threads, and processes](#optimize-queues-threads-and-processes)
+    - [Database connections](#database-connections)
+    - [Executing jobs async / in-process](#executing-jobs-async--in-process)
+    - [Migrating to GoodJob from a different ActiveJob backend](#migrating-to-goodjob-from-a-different-activejob-backend)
+    - [Monitoring and preserving worked jobs](#monitoring-and-preserving-worked-jobs)
+- [Contributing](#contributing)
+    - [Gem development](#gem-development)
+    - [Releasing](#releasing)
+- [License](#license)
+
+## Set up
+
+1. Add `good_job` to your application's Gemfile:
 
-Add this line to your application's Gemfile:
+    ```ruby
+    gem 'good_job'
+    ```
 
-```ruby
-gem 'good_job'
-```
+1. Install the gem:
 
-And then execute:
-```bash
-$ bundle install
-```
+    ```bash
+    $ bundle install
+    ```
 
-## Usage
+1. Run the GoodJob install generator. This will generate a database migration to create a table for GoodJob's job records:
 
-1. Create a database migration:
-    
-   ```bash
+    ```bash
     $ bin/rails g good_job:install
     ```
 
     Run the migration:
-    
+
     ```bash
     $ bin/rails db:migrate
     ```
-    
+
 1. Configure the ActiveJob adapter:
-    
-   ```ruby
+
+    ```ruby
     # config/application.rb
     config.active_job.queue_adapter = :good_job
     ```
-    
-    By default, using `:good_job` is equivalent to manually configuring the adapter:
-    
+
+1. Inside of your application, queue your job 🎉:
+
     ```ruby
-    # config/environments/development.rb
-    config.active_job.queue_adapter = GoodJob::Adapter.new(execution_mode: :inline)
-   
-    # config/environments/test.rb
-    config.active_job.queue_adapter = GoodJob::Adapter.new(execution_mode: :inline)
-   
-    # config/environments/production.rb
-    config.active_job.queue_adapter = GoodJob::Adapter.new(execution_mode: :external)
+    YourJob.perform_later
     ```
 
-1. Queue your job 🎉: 
-    
+    GoodJob supports all ActiveJob features:
+
     ```ruby
     YourJob.set(queue: :some_queue, wait: 5.minutes, priority: 10).perform_later
     ```
 
-1. In production, the scheduler is designed to run in its own process:
-    
-    ```bash
-    $ bundle exec good_job
-    ```
-   
-   Configuration options available with `help`:
+1. In development, GoodJob executes jobs immediately. In production, GoodJob provides different options:
 
-    ```bash
-    $ bundle exec good_job help start
-   
-    Usage:
-      good_job start
-    
-    Options:
-      [--max-threads=N]                                          # Maximum number of threads to use for working jobs (default: ActiveRecord::Base.connection_pool.size)
-      [--queues=queue1,queue2(;queue3,queue4:5;-queue1,queue2)]  # Queues to work from. Separate multiple queues with commas; exclude queues with a leading minus; separate isolated execution pools with semicolons and threads with colons (default: *)
-      [--poll-interval=N]                                        # Interval between polls for available jobs in seconds (default: 1)    
-    
-    Start job worker
-    ```
+    - By default, GoodJob separates job enqueuing from job execution so that jobs can be scaled independently of the web server.  Use the GoodJob command-line tool to execute jobs:
 
-1. Optimize execution to reduce congestion and execution latency. 
+        ```bash
+        $ bundle exec good_job start
+        ```
 
-    By default, GoodJob creates a single thread execution pool that will execute jobs from any queue. Depending on your application's workload, job types, and service level objectives, you may wish to optimize execution resources; for example, providing dedicated execution resources for transactional emails so they are not delayed by long-running batch jobs. Some options:
+        Ideally the command-line tool should be run on a separate machine or container from the web process. For example, on Heroku:
 
-    - Multiple execution pools within a single process:
-        
-        ```bash
-        $ bundle exec good_job --queues=transactional_messages:2;batch_processing:1;-transactional_messages,batch_processing:2;* --max-threads=5
+        ```Procfile
+        web: rails server
+        worker: bundle exec good_job start
         ```
-      
-        This configuration will result in a single process with 4 isolated thread execution pools. Isolated execution pools are separated with a semicolon (`;`) and queue names and thread counts with a colon (`:`)
-        
-        - `transactional_messages:2`: execute jobs enqueued on `transactional_messages` with up to 2 threads.
-        - `batch_processing:1` execute jobs enqueued on `batch_processing` with a single thread.
-        - `-transactional_messages,batch_processing`: execute jobs enqueued on _any_ queue _excluding_ `transactional_messages` or `batch_processing` with up to 2 threads.
-        - `*`: execute jobs on any queue on up to 5 threads, as configured by `--max-threads=5`
-        
-        For moderate workloads, multiple isolated thread execution pools offers a good balance between congestion management and economy. 
-        
-        Configuration can be injected by environment variables too:
-        
-        ```bash
-        $ GOOD_JOB_QUEUES="transactional_messages:2;batch_processing:1;-transactional_messages,batch_processing:2;*" GOOD_JOB_MAX_THREADS=5 bundle exec good_job
+
+        The command-line tool supports a variety of options, see the reference below for command-line configuration.
+
+    - 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.
+
         ```
-        
-    - Multiple processes; for example, on Heroku:
-    
-        ```procfile
-        # Procfile
-        
-        # Separate dyno types
-        worker: bundle exec good_job --max-threads=5
-        transactional_worker: bundle exec good_job --queues=transactional_messages --max-threads=2
-        batch_worker: bundle exec good_job --queues=batch_processing --max-threads=1
-      
-        # Combined multi-process dyno
-        combined_worker: bundle exec good_job --max-threads=5 & bundle exec good_job --queues=transactional_messages --max-threads=2 & bundle exec good_job --queues=batch_processing --max-threads=1 & wait -n
+        $ GOOD_JOB_EXECUTION_MODE=async rails server
         ```
-      
-      Running multiple processes can optimize for CPU performance at the expense of greater memory and system resource usage.
 
-    _Keep in mind, queue operations and management is an advanced discipline. This stuff is complex, especially for heavy workloads and unique processing requirements. Good job 👍_
+        Additional configuration is likely necessary, see the reference below for async configuration.
 
-### Error handling, retries, and reliability
+## Configuration
 
-GoodJob guarantees that a completely-performed job will run once and only once. GoodJob fully supports ActiveJob's built-in functionality for error handling, retries and timeouts. Writing reliable, transactional, and idempotent `ActiveJob#perform` methods is outside the scope of GoodJob.
+### Command-line options
 
-#### Error handling
+There several top-level commands available through the `good_job` command-line tool.
 
-By default, if a job raises an error while it is being performed, _and it bubbles up to the GoodJob backend_, GoodJob will be immediately re-perform the job until it finishes successfully.
+Configuration options are available with `help`.
 
-- `Exception`-type errors, such as a SIGINT, will always cause a job to be re-performed.
-- `StandardError`-type errors, by default, will cause a job to be re-performed, though this is configurable:
-   
-    ```ruby
-    # config/initializers/good_job.rb
-    GoodJob.reperform_jobs_on_standard_error = true # => default
-    ```
+#### `good_job start`
+
+`good_job start` executes queued jobs.
+
+```bash
+$ bundle exec good_job help start
+
+Usage:
+  good_job start
+
+Options:
+  [--max-threads=COUNT]      # Maximum number of threads to use for working jobs. (env var: GOOD_JOB_MAX_THREADS, default: 5)
+  [--queues=QUEUE_LIST]      # Queues to work from. (env var: GOOD_JOB_QUEUES, default: *)
+  [--poll-interval=SECONDS]  # Interval between polls for available jobs in seconds (env var: GOOD_JOB_POLL_INTERVAL, default: 1)
+
+Executes queued jobs.
+
+All options can be configured with environment variables.
+See option descriptions for the matching environment variable name.
+
+== Configuring queues
+Separate multiple queues with commas; exclude queues with a leading minus;
+separate isolated execution pools with semicolons and threads with colons.
+```
+
+#### `good_job cleanup_preserved_jobs`
+
+`good_job cleanup_preserved_jobs` deletes preserved job records. See [`GoodJob.preserve_job_records` for when this command is useful.
+
+```bash
+$ bundle exec good_job help cleanup_preserved_jobs
+
+Usage:
+  good_job cleanup_preserved_jobs
+
+Options:
+  [--before-seconds-ago=SECONDS] # Delete records finished more than this many seconds ago (env var:  GOOD_JOB_CLEANUP_PRESERVED_JOBS_BEFORE_SECONDS_AGO, default: 86400)
+
+Deletes preserved job records.
+
+By default, GoodJob deletes job records when the job is performed and this
+command is not necessary.
+
+However, when `GoodJob.preserve_job_records = true`, the jobs will be
+preserved in the database. This is useful when wanting to analyze or
+inspect job performance.
+
+If you are preserving job records this way, use this command regularly
+to delete old records and preserve space in your database.
+```
+
+### Adapter options
+
+To use GoodJob, you can set `config.active_job.queue_adapter` to a `:good_job` or to an instance of `GoodJob::Adapter`, which you can configure with several options:
+
+- `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 equeue 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` causes the adapter to execute you jobs in separate threads in whatever process queued them (usually the web process). This is akin to running the command-line tool’s code inside your web server. It can be more economical for small workloads (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.
+- `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`.
+
+Using the symbol instead of explicitly configuring the options above (i.e. setting `config.active_job.queue_adapter = :good_job`) is equivalent to:
+
+```ruby
+# config/environments/development.rb
+config.active_job.queue_adapter = GoodJob::Adapter.new(execution_mode: :inline)
+
+# config/environments/test.rb
+config.active_job.queue_adapter = GoodJob::Adapter.new(execution_mode: :inline)
+
+# config/environments/production.rb
+config.active_job.queue_adapter = GoodJob::Adapter.new(execution_mode: :external)
+```
+
+### Global options
+
+Good Job’s general behavior can also be configured via several attributes directly on the `GoodJob` module:
+
+- **`GoodJob.logger`** ([Rails Logger](https://api.rubyonrails.org/classes/ActiveSupport/Logger.html)) lets you set a custom logger for GoodJob. It should be an instance of a Rails `Logger`.
+- **`GoodJob.preserve_job_records`** (boolean) keeps job records in your database even after jobs are completed. (Default: `false`)
+- **`GoodJob.reperform_jobs_on_standard_error`** (boolean) causes jobs to be re-queued and retried if they raise an instance of `StandardError`. Instances of `Exception`, like SIGINT, will *always* be retried, regardless of this attribute’s value. (Default: `true`)
+- **`GoodJob.on_thread_error`** (proc, lambda, or callable) will be called when a job raises an error. It can be useful for logging errors to bug tracking services, like Sentry or Airbrake.
 
-To report errors that _do_ bubble up to the GoodJob backend, assign a callable to `GoodJob.on_thread_error`. For example:
+You’ll generally want to configure these in `config/initializers/good_job.rb`, like so:
 
 ```ruby
 # config/initializers/good_job.rb
+GoodJob.preserve_job_records = true
+GoodJob.reperform_jobs_on_standard_error = false
+GoodJob.on_thread_error = -> (exception) { Raven.capture_exception(exception) }
+```
 
-# With Sentry (or Bugsnag, Airbrake, Honeybadger, etc.)
+## Going deeper
+
+### Exceptions, retries, and reliability
+
+GoodJob guarantees that a completely-performed job will run once and only once. GoodJob fully supports ActiveJob's built-in functionality for error handling, retries and timeouts.
+
+#### Exceptions
+
+ActiveJob provides [tools for rescuing and retrying exceptions](https://guides.rubyonrails.org/active_job_basics.html#exceptions), including `retry_on`, `discard_on`, `rescue_from` that will rescue exceptions before they get to GoodJob.
+
+If errors do reach GoodJob, you can assign a callable to `GoodJob.on_thread_error` to be notified. For example, to log errors to an exception monitoring service like Sentry (or Bugsnag, Airbrake, Honeybadger, etc.):
+
+```ruby
+# config/initializers/good_job.rb
 GoodJob.on_thread_error = -> (exception) { Raven.capture_exception(exception) }
 ```
 
-### Retrying jobs
+#### Retries
 
-ActiveJob can be configured to retry an infinite number of times, with an exponential backoff. Using ActiveJob's `retry_on` will ensure that errors do not bubble up to the GoodJob backend:
+By default, GoodJob will automatically and immediately retry a job when an exception is raised to GoodJob.
+
+However, ActiveJob can be configured to retry an infinite number of times, with an exponential backoff. Using ActiveJob's `retry_on` prevents exceptions from reaching GoodJob:
 
 ```ruby
-class ApplicationJob < ActiveJob::Base  
+class ApplicationJob < ActiveJob::Base
   retry_on StandardError, wait: :exponentially_longer, attempts: Float::INFINITY
   # ...
 end
 ```
 
-When specifying a limited number of retries, care must be taken to ensure that an error does not bubble up to the GoodJob backend because that will result in the job being re-performed:
+When using `retry_on` with _a limited number of retries_, the final exception will not be rescued and will raise to GoodJob. GoodJob can be configured to discard un-handled exceptions instead of retrying them:
 
 ```ruby
-class ApplicationJob < ActiveJob::Base  
+# config/initializers/good_job.rb
+GoodJob.reperform_jobs_on_standard_error = false
+```
+
+Alternatively, pass a block to `retry_on` to handle the final exception instead of raising it to GoodJob:
+
+```ruby
+class ApplicationJob < ActiveJob::Base
   retry_on StandardError, attempts: 5 do |_job, _exception|
-    # Log error, etc.
-    # You must implement this block, otherwise, 
-    #   Active Job will re-raise the error.
-    # Do not re-raise the error, otherwise 
-    #   GoodJob will immediately re-perform the job. 
+    # Log error, do nothing, etc.
   end
   # ...
 end
 ```
 
-GoodJob can be configured to allow omitting `retry_on`'s block argument and implicitly discard un-handled errors:
+When using `retry_on` with an infinite number of retries, exceptions will never be raised to GoodJob, which means `GoodJob.on_thread_error` will never be called. To report log or report exceptions to an exception monitoring service (e.g. Sentry, Bugsnag, Airbrake, Honeybadger, etc), create an explicit exception wrapper. For example:
 
 ```ruby
-# config/initializers/good_job.rb
-
-# Do NOT re-perform a job if a StandardError bubbles up to the GoodJob backend
-GoodJob.reperform_jobs_on_standard_error = false 
-```
+class ApplicationJob < ActiveJob::Base
+  retry_on StandardError, wait: :exponentially_longer, attempts: Float::INFINITY
 
-When using an exception monitoring service (e.g. Sentry, Bugsnag, Airbrake, Honeybadger, etc), the use of `rescue_on` may be incompatible with their ActiveJob integration. It's safest to explicitly wrap jobs with an exception reporter. For example:
+  retry_on SpecialError, attempts: 5 do |_job, exception|
+    Raven.capture_exception(exception)
+  end
 
-```ruby
-class ApplicationJob < ActiveJob::Base  
-  retry_on StandardError, wait: :exponentially_longer, attempts: Float::INFINITY
-  
   around_perform do |_job, block|
     block.call
   rescue StandardError => e
@@ -205,12 +289,11 @@ class ApplicationJob < ActiveJob::Base
 end
 ```
 
-
-ActiveJob's `discard_on` functionality is supported too.
-
 #### ActionMailer retries
 
-Using a Mailer's `#deliver_later` will enqueue an instance of `ActionMailer::DeliveryJob` which inherits from `ActiveJob::Base` rather than your applications `ApplicationJob`. You can use an initializer to configure retries on `ActionMailer::DeliveryJob`:
+Any configuration in `ApplicationJob` will have to be duplicated on `ActionMailer::DeliveryJob` because ActionMailer uses a custom class, `ActionMailer::DeliveryJob`, which inherits from `ActiveJob::Base`,  rather than your applications `ApplicationJob`.
+
+You can use an initializer to configure `ActionMailer::DeliveryJob`, for example:
 
 ```ruby
 # config/initializers/good_job.rb
@@ -225,14 +308,14 @@ rescue StandardError => e
 end
 ```
 
-#### Timeouts
+### Timeouts
 
 Job timeouts can be configured with an `around_perform`:
 
 ```ruby
-class ApplicationJob < ActiveJob::Base  
+class ApplicationJob < ActiveJob::Base
   JobTimeoutError = Class.new(StandardError)
-  
+
   around_perform do |_job, block|
     # Timeout jobs after 10 minutes
     Timeout.timeout(10.minutes, JobTimeoutError) do
@@ -242,20 +325,61 @@ class ApplicationJob < ActiveJob::Base
 end
 ```
 
-### Configuring job execution threads
-    
-GoodJob executes enqueued jobs using threads. There is a lot than can be said about [multithreaded behavior in Ruby on Rails](https://guides.rubyonrails.org/threading_and_code_execution.html), but briefly:
+### Optimize queues, threads, and processes
+
+By default, GoodJob creates a single thread execution pool that will execute jobs from any queue. Depending on your application's workload, job types, and service level objectives, you may wish to optimize execution resources. For example, providing dedicated execution resources for transactional emails so they are not delayed by long-running batch jobs. Some options:
+
+- Multiple execution pools within a single process:
 
-- Each GoodJob execution thread requires its own database connection, which are automatically checked out from Rails’s connection pool. _Allowing GoodJob to schedule more threads than are available in the database connection pool can lead to timeouts and is not recommended._ 
-- The maximum number of GoodJob threads can be configured, in decreasing precedence:
-    1. `$ bundle exec good_job --max_threads 4`
-    2. `$ GOOD_JOB_MAX_THREADS=4 bundle exec good_job`
-    3. `$ RAILS_MAX_THREADS=4 bundle exec good_job`
-    4. Implicitly via Rails's database connection pool size (`ActiveRecord::Base.connection_pool.size`)
+    ```bash
+    $ bundle exec good_job --queues=transactional_messages:2;batch_processing:1;-transactional_messages,batch_processing:2;* --max-threads=5
+    ```
+
+    This configuration will result in a single process with 4 isolated thread execution pools. Isolated execution pools are separated with a semicolon (`;`) and queue names and thread counts with a colon (`:`)
+
+    - `transactional_messages:2`: execute jobs enqueued on `transactional_messages` with up to 2 threads.
+    - `batch_processing:1` execute jobs enqueued on `batch_processing` with a single thread.
+    - `-transactional_messages,batch_processing`: execute jobs enqueued on _any_ queue _excluding_ `transactional_messages` or `batch_processing` with up to 2 threads.
+    - `*`: execute jobs on any queue on up to 5 threads, as configured by `--max-threads=5`
+
+    For moderate workloads, multiple isolated thread execution pools offers a good balance between congestion management and economy.
+
+    Configuration can be injected by environment variables too:
+
+    ```bash
+    $ GOOD_JOB_QUEUES="transactional_messages:2;batch_processing:1;-transactional_messages,batch_processing:2;*" GOOD_JOB_MAX_THREADS=5 bundle exec good_job
+    ```
+
+- Multiple processes; for example, on Heroku:
+
+    ```procfile
+    # Procfile
+
+    # Separate dyno types
+    worker: bundle exec good_job --max-threads=5
+    transactional_worker: bundle exec good_job --queues=transactional_messages --max-threads=2
+    batch_worker: bundle exec good_job --queues=batch_processing --max-threads=1
+
+    # Combined multi-process dyno
+    combined_worker: bundle exec good_job --max-threads=5 & bundle exec good_job --queues=transactional_messages --max-threads=2 & bundle exec good_job --queues=batch_processing --max-threads=1 & wait -n
+    ```
+
+    Running multiple processes can optimize for CPU performance at the expense of greater memory and system resource usage.
+
+Keep in mind, queue operations and management is an advanced discipline. This stuff is complex, especially for heavy workloads and unique processing requirements. Good job 👍
+
+### Database connections
+
+Each GoodJob execution thread requires its own database connection that is automatically checked out from Rails’s connection pool. _Allowing GoodJob to create more threads than available database connections can lead to timeouts and is not recommended._ For example:
+
+```yaml
+# config/database.yml
+pool: <%= [ENV.fetch("RAILS_MAX_THREADS", 5).to_i, ENV.fetch("GOOD_JOB_MAX_THREADS", 4).to_i].max %>
+```
 
 ### Executing jobs async / in-process
 
-GoodJob is able to run "async" in the same process as the webserver (e.g. `bin/rail s`). GoodJob's async execution mode offers benefits of economy by not requiring a separate job worker process, but with the tradeoff of increased complexity. Async mode can be configured in two ways:
+GoodJob can execute jobs "async" in the same process as the webserver (e.g. `bin/rail s`). GoodJob's async execution mode offers benefits of economy by not requiring a separate job worker process, but with the tradeoff of increased complexity. Async mode can be configured in two ways:
 
 - Directly configure the ActiveJob adapter:
 
@@ -263,12 +387,13 @@ GoodJob is able to run "async" in the same process as the webserver (e.g. `bin/r
     # config/environments/production.rb
     config.active_job.queue_adapter = GoodJob::Adapter.new(execution_mode: :async, max_threads: 4, poll_interval: 30)
     ```
+
 - Or, when using `...queue_adapter = :good_job`, via environment variables:
 
     ```bash
     $ 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:
 
 - Ensure that you have enough database connections for both web and job execution threads:
@@ -282,27 +407,27 @@ Depending on your application configuration, you may need to take additional ste
 
     ```ruby
     # config/puma.rb
-  
+
     before_fork do
       GoodJob.shutdown
     end
-    
+
     on_worker_boot do
       GoodJob.restart
     end
-    
+
     on_worker_shutdown do
       GoodJob.shutdown
     end
-  
+
     MAIN_PID = Process.pid
     at_exit do
       GoodJob.shutdown if Process.pid == MAIN_PID
     end
     ```
-  
+
   GoodJob is compatible with Puma's `preload_app!` method.
-  
+
 ### Migrating to GoodJob from a different ActiveJob backend
 
 If your application is already using an ActiveJob backend, you will need to install GoodJob to enqueue and perform newly created jobs _and_ finish performing pre-existing jobs on the previous backend.
@@ -318,7 +443,7 @@ If your application is already using an ActiveJob backend, you will need to inst
     ```
 
 1. Continue running executors for both backends. For example, on Heroku it's possible to run [two processes](https://help.heroku.com/CTFS2TJK/how-do-i-run-multiple-processes-on-a-dyno) within the same dyno:
-    
+
    ```procfile
     # Procfile
     # ...
@@ -331,7 +456,7 @@ If your application is already using an ActiveJob backend, you will need to inst
 
 GoodJob is fully instrumented with [`ActiveSupport::Notifications`](https://edgeguides.rubyonrails.org/active_support_instrumentation.html#introduction-to-instrumentation).
 
-By default, GoodJob will delete job records after they are run, regardless of whether they succeed or not (raising a kind of `StandardError`), unless they are interrupted (raising a kind of `Exception`). 
+By default, GoodJob will delete job records after they are run, regardless of whether they succeed or not (raising a kind of `StandardError`), unless they are interrupted (raising a kind of `Exception`).
 
 To preserve job records for later inspection, set an initializer:
 
@@ -343,7 +468,7 @@ GoodJob.preserve_job_records = true
 It is also necessary to delete these preserved jobs from the database after a certain time period:
 
 - For example, in a Rake task:
-  
+
     ```ruby
     GoodJob::Job.finished(1.day.ago).delete_all
     ```
@@ -413,7 +538,7 @@ $ gem signin
 # Update version number, changelog, and create git commit:
 $ bundle exec rake release[minor] # major,minor,patch
 
-# ..and follow subsequent directions. 
+# ..and follow subsequent directions.
 ```
 
 ## License

data/lib/good_job.rb

@@ -8,20 +8,44 @@ require 'good_job/job'
 require 'good_job/scheduler'
 require 'good_job/multi_scheduler'
 require 'good_job/adapter'
-require 'good_job/pg_locks'
 require 'good_job/performer'
 require 'good_job/current_execution'
 require 'good_job/notifier'
 
 require 'active_job/queue_adapters/good_job_adapter'
 
+# GoodJob is a multithreaded, Postgres-based, ActiveJob backend for Ruby on Rails.
+#
+# +GoodJob+ is the top-level namespace and exposes configuration attributes.
 module GoodJob
+  # @!attribute [rw] logger
+  #   @!scope class
+  #   The logger used by GoodJob
+  #   @return [Logger]
   mattr_accessor :logger, default: ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new(STDOUT))
+
+  # @!attribute [rw] preserve_job_records
+  #   @!scope class
+  #   Whether to preserve job records in the database after they have finished for inspection
+  #   @return [Boolean]
   mattr_accessor :preserve_job_records, default: false
+
+  # @!attribute [rw] reperform_jobs_on_standard_error
+  #   @!scope class
+  #   Whether to re-perform a job when a type of +StandardError+ is raised and bubbles up to the GoodJob backend
+  #   @return [Boolean]
   mattr_accessor :reperform_jobs_on_standard_error, default: true
-  mattr_accessor :on_thread_error, default: nil
 
-  ActiveSupport.run_load_hooks(:good_job, self)
+  # @!attribute [rw] on_thread_error
+  #   @!scope class
+  #   Called when a thread raises an error
+  #   @example Send errors to Sentry
+  #     # config/initializers/good_job.rb
+  #
+  #     # With Sentry (or Bugsnag, Airbrake, Honeybadger, etc.)
+  #     GoodJob.on_thread_error = -> (exception) { Raven.capture_exception(exception) }
+  #   @return [#call, nil]
+  mattr_accessor :on_thread_error, default: nil
 
   # Shuts down all execution pools
   # @param wait [Boolean] whether to wait for shutdown
@@ -43,4 +67,6 @@ module GoodJob
     Notifier.instances.each(&:restart)
     Scheduler.instances.each(&:restart)
   end
+
+  ActiveSupport.run_load_hooks(:good_job, self)
 end

data/lib/good_job/adapter.rb

@@ -9,10 +9,12 @@ module GoodJob
       end
 
       configuration = GoodJob::Configuration.new(
-        execution_mode: execution_mode,
-        queues: queues,
-        max_threads: max_threads,
-        poll_interval: poll_interval
+        {
+          execution_mode: execution_mode,
+          queues: queues,
+          max_threads: max_threads,
+          poll_interval: poll_interval,
+        }
       )
 
       @execution_mode = configuration.execution_mode

data/lib/good_job/cli.rb

@@ -4,17 +4,29 @@ module GoodJob
   class CLI < Thor
     RAILS_ENVIRONMENT_RB = File.expand_path("config/environment.rb")
 
-    desc :start, "Start job worker"
+    desc :start, <<~DESCRIPTION
+      Executes queued jobs.
+
+      All options can be configured with environment variables. 
+      See option descriptions for the matching environment variable name.
+
+      == Configuring queues
+      Separate multiple queues with commas; exclude queues with a leading minus; 
+      separate isolated execution pools with semicolons and threads with colons.
+
+    DESCRIPTION
     method_option :max_threads,
                   type: :numeric,
-                  desc: "Maximum number of threads to use for working jobs (default: ActiveRecord::Base.connection_pool.size)"
+                  banner: 'COUNT',
+                  desc: "Maximum number of threads to use for working jobs. (env var: GOOD_JOB_MAX_THREADS, default: 5)"
     method_option :queues,
                   type: :string,
-                  banner: "queue1,queue2(;queue3,queue4:5;-queue1,queue2)",
-                  desc: "Queues to work from. Separate multiple queues with commas; exclude queues with a leading minus; separate isolated execution pools with semicolons and threads with colons (default: *)"
+                  banner: "QUEUE_LIST",
+                  desc: "Queues to work from. (env var: GOOD_JOB_QUEUES, default: *)"
     method_option :poll_interval,
                   type: :numeric,
-                  desc: "Interval between polls for available jobs in seconds (default: 1)"
+                  banner: 'SECONDS',
+                  desc: "Interval between polls for available jobs in seconds (env var: GOOD_JOB_POLL_INTERVAL, default: 1)"
     def start
       set_up_application!
 
@@ -39,17 +51,35 @@ module GoodJob
 
     default_task :start
 
-    desc :cleanup_preserved_jobs, "Delete preserved job records"
+    desc :cleanup_preserved_jobs, <<~DESCRIPTION
+      Deletes preserved job records. 
+
+      By default, GoodJob deletes job records when the job is performed and this
+      command is not necessary.
+
+      However, when `GoodJob.preserve_job_records = true`, the jobs will be
+      preserved in the database. This is useful when wanting to analyze or
+      inspect job performance.
+
+      If you are preserving job records this way, use this command regularly
+      to delete old records and preserve space in your database.
+
+    DESCRIPTION
     method_option :before_seconds_ago,
                   type: :numeric,
-                  default: 24 * 60 * 60,
-                  desc: "Delete records finished more than this many seconds ago"
-
+                  banner: 'SECONDS',
+                  desc: "Delete records finished more than this many seconds ago (env var: GOOD_JOB_CLEANUP_PRESERVED_JOBS_BEFORE_SECONDS_AGO, default: 86400)"
     def cleanup_preserved_jobs
       set_up_application!
 
-      timestamp = Time.current - options[:before_seconds_ago]
-      ActiveSupport::Notifications.instrument("cleanup_preserved_jobs.good_job", { before_seconds_ago: options[:before_seconds_ago], timestamp: timestamp }) do |payload|
+      configuration = GoodJob::Configuration.new(options)
+
+      timestamp = Time.current - configuration.cleanup_preserved_jobs_before_seconds_ago
+
+      ActiveSupport::Notifications.instrument(
+        "cleanup_preserved_jobs.good_job",
+        { before_seconds_ago: configuration.cleanup_preserved_jobs_before_seconds_ago, timestamp: timestamp }
+      ) do |payload|
         deleted_records_count = GoodJob::Job.finished(timestamp).delete_all
 
         payload[:deleted_records_count] = deleted_records_count

data/lib/good_job/configuration.rb

@@ -51,5 +51,13 @@ module GoodJob
         1
       ).to_i
     end
+
+    def cleanup_preserved_jobs_before_seconds_ago
+      (
+        options[:before_seconds_ago] ||
+        env['GOOD_JOB_CLEANUP_PRESERVED_JOBS_BEFORE_SECONDS_AGO'] ||
+        24 * 60 * 60
+      ).to_i
+    end
   end
 end

data/lib/good_job/current_execution.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/module/attribute_accessors_per_thread'
+
 module GoodJob
   # Thread-local attributes for passing values from Instrumentation.
   # (Cannot use ActiveSupport::CurrentAttributes because ActiveJob resets it)

data/lib/good_job/job.rb

@@ -58,7 +58,8 @@ module GoodJob
 
       unfinished.priority_ordered.only_scheduled.limit(1).with_advisory_lock do |good_jobs|
         good_job = good_jobs.first
-        break unless good_job
+        # TODO: Determine why some records are fetched without an advisory lock at all
+        break unless good_job&.owns_advisory_lock?
 
         result, error = good_job.perform
       end

data/lib/good_job/lockable.rb

@@ -25,8 +25,8 @@ module GoodJob
         join_sql = <<~SQL
           LEFT JOIN pg_locks ON pg_locks.locktype = 'advisory'
             AND pg_locks.objsubid = 1
-            AND pg_locks.classid = ('x'||substr(md5(:table_name || "#{table_name}"."#{primary_key}"::text), 1, 16))::bit(32)::int
-            AND pg_locks.objid = (('x'||substr(md5(:table_name || "#{table_name}"."#{primary_key}"::text), 1, 16))::bit(64) << 32)::bit(32)::int
+            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
         SQL
 
         joins(sanitize_sql_for_conditions([join_sql, { table_name: table_name }]))
@@ -55,19 +55,17 @@ module GoodJob
     end
 
     def advisory_lock
-      query = <<~SQL
-        SELECT 1 AS one
-        WHERE pg_try_advisory_lock(('x'||substr(md5(:table_name || :id::text), 1, 16))::bit(64)::bigint)
+      where_sql = <<~SQL
+        pg_try_advisory_lock(('x'||substr(md5(:table_name || :id::text), 1, 16))::bit(64)::bigint)
       SQL
-      self.class.connection.execute(sanitize_sql_for_conditions([query, { table_name: self.class.table_name, id: send(self.class.primary_key) }])).ntuples.positive?
+      self.class.unscoped.where(where_sql, { table_name: self.class.table_name, id: send(self.class.primary_key) }).exists?
     end
 
     def advisory_unlock
-      query = <<~SQL
-        SELECT 1 AS one
-        WHERE pg_advisory_unlock(('x'||substr(md5(:table_name || :id::text), 1, 16))::bit(64)::bigint)
+      where_sql = <<~SQL
+        pg_advisory_unlock(('x'||substr(md5(:table_name || :id::text), 1, 16))::bit(64)::bigint)
       SQL
-      self.class.connection.execute(sanitize_sql_for_conditions([query, { table_name: self.class.table_name, id: send(self.class.primary_key) }])).ntuples.positive?
+      self.class.unscoped.where(where_sql, { table_name: self.class.table_name, id: send(self.class.primary_key) }).exists?
     end
 
     def advisory_lock!
@@ -85,11 +83,11 @@ module GoodJob
     end
 
     def advisory_locked?
-      self.class.advisory_locked.where(id: send(self.class.primary_key)).any?
+      self.class.unscoped.advisory_locked.where(id: send(self.class.primary_key)).exists?
     end
 
     def owns_advisory_lock?
-      self.class.owns_advisory_locked.where(id: send(self.class.primary_key)).any?
+      self.class.unscoped.owns_advisory_locked.where(id: send(self.class.primary_key)).exists?
     end
 
     def advisory_unlock!

data/lib/good_job/notifier.rb

@@ -7,6 +7,7 @@ module GoodJob # :nodoc:
   class Notifier
     CHANNEL = 'good_job'.freeze
     POOL_OPTIONS = {
+      name: name,
       min_threads: 0,
       max_threads: 1,
       auto_terminate: true,
@@ -69,13 +70,12 @@ module GoodJob # :nodoc:
 
     def listen
       future = Concurrent::Future.new(args: [@recipients, @pool, @listening], executor: @pool) do |recipients, pool, listening|
-        Rails.application.reloader.wrap do
-          conn = ActiveRecord::Base.connection.raw_connection
-          ActiveSupport::Notifications.instrument("notifier_listen.good_job") do
-            conn.async_exec "LISTEN #{CHANNEL}"
-          end
+        begin
+          with_listen_connection do |conn|
+            ActiveSupport::Notifications.instrument("notifier_listen.good_job") do
+              conn.async_exec "LISTEN #{CHANNEL}"
+            end
 
-          begin
             ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
               while pool.running?
                 listening.make_true
@@ -93,14 +93,14 @@ module GoodJob # :nodoc:
                 listening.make_false
               end
             end
-          rescue StandardError => e
-            ActiveSupport::Notifications.instrument("notifier_notify_error.good_job", { error: e })
-            raise
-          ensure
-            @listening.make_false
-            ActiveSupport::Notifications.instrument("notifier_unlisten.good_job") do
-              conn.async_exec "UNLISTEN *"
-            end
+          end
+        rescue StandardError => e
+          ActiveSupport::Notifications.instrument("notifier_notify_error.good_job", { error: e })
+          raise
+        ensure
+          @listening.make_false
+          ActiveSupport::Notifications.instrument("notifier_unlisten.good_job") do
+            conn.async_exec "UNLISTEN *"
           end
         end
       end
@@ -112,5 +112,16 @@ module GoodJob # :nodoc:
     def listen_observer(_time, _result, _thread_error)
       listen unless shutdown?
     end
+
+    def with_listen_connection
+      ar_conn = ActiveRecord::Base.connection_pool.checkout.tap do |conn|
+        ActiveRecord::Base.connection_pool.remove(conn)
+      end
+      pg_conn = ar_conn.raw_connection
+      pg_conn.exec("SET application_name = #{pg_conn.escape_identifier(self.class.name)}")
+      yield pg_conn
+    ensure
+      ar_conn.disconnect!
+    end
   end
 end

data/lib/good_job/scheduler.rb

@@ -21,6 +21,7 @@ module GoodJob # :nodoc:
 
     # Defaults for instance of Concurrent::ThreadPoolExecutor
     DEFAULT_POOL_OPTIONS = {
+      name: name,
       min_threads: 0,
       max_threads: Concurrent.processor_count,
       auto_terminate: true,

data/lib/good_job/version.rb

@@ -1,3 +1,3 @@
 module GoodJob
-  VERSION = '1.1.4'.freeze
+  VERSION = '1.2.4'.freeze
 end

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 1.1.4
+  version: 1.2.4
 platform: ruby
 authors:
 - Ben Sheldon
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-08-19 00:00:00.000000000 Z
+date: 2020-09-01 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activejob
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.1.0
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.1.0
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -39,7 +67,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 1.0.0
 - !ruby/object:Gem::Dependency
-  name: rails
+  name: railties
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -150,6 +178,48 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: kramdown
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: kramdown-parser-gfm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mdl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: pry-rails
   requirement: !ruby/object:Gem::Requirement
@@ -319,7 +389,6 @@ files:
 - lib/good_job/multi_scheduler.rb
 - lib/good_job/notifier.rb
 - lib/good_job/performer.rb
-- lib/good_job/pg_locks.rb
 - lib/good_job/railtie.rb
 - lib/good_job/scheduler.rb
 - lib/good_job/version.rb

data/lib/good_job/pg_locks.rb

@@ -1,21 +0,0 @@
-module GoodJob
-  class PgLocks < ActiveRecord::Base
-    self.table_name = 'pg_locks'.freeze
-
-    # https://www.postgresql.org/docs/9.6/view-pg-locks.html
-    # Advisory locks can be acquired on keys consisting of either a single bigint value or two integer values.
-    # A bigint key is displayed with its high-order half in the classid column, its low-order half in the objid column, and objsubid equal to 1.
-    # The original bigint value can be reassembled with the expression (classid::bigint << 32) | objid::bigint.
-    # Integer keys are displayed with the first key in the classid column, the second key in the objid column, and objsubid equal to 2.
-    # The actual meaning of the keys is up to the user. Advisory locks are local to each database, so the database column is meaningful for an advisory lock.
-    def self.advisory_lock_details
-      connection.select <<~SQL
-        SELECT *
-        FROM pg_locks
-        WHERE
-          locktype = 'advisory' AND
-          objsubid = 1
-      SQL
-    end
-  end
-end