good_job 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9e068306c80c1080f736520219cdf27230f9684bd69fa70cff0489ce37b1ed79
+  data.tar.gz: 8f10fb768248ca1ec1e14f44be2073f9c60069b2451c5858c571efbca84c0969
+SHA512:
+  metadata.gz: 8ebe33709d71b2254fa2fc0dbc1c991df739a67ba6ee3649000bada6c4618b2d958c58372818502b57211fb4694b28b16be513227220b262da2125b6f87b61bb
+  data.tar.gz: 40db6accac1448cef4cfff7516e68d401b25711520d479cf3af4c20f03a31526f2e084aed5dabc64adceb9b23ae75ac41ae74e25bb80a4bb80c320a31fc9fb25

data/CHANGELOG.md

@@ -0,0 +1,153 @@
+# Changelog
+
+## [v1.0.1](https://github.com/bensheldon/good_job/tree/v1.0.1) (2020-07-21)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v1.0.0...v1.0.1)
+
+**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))
+
+## [v1.0.0](https://github.com/bensheldon/good_job/tree/v1.0.0) (2020-07-20)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v0.9.0...v1.0.0)
+
+## [v0.9.0](https://github.com/bensheldon/good_job/tree/v0.9.0) (2020-07-20)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v0.8.2...v0.9.0)
+
+**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)
+
+**Closed issues:**
+
+- Add a job timeout configuration to time out jobs that have run too long [\#19](https://github.com/bensheldon/good_job/issues/19)
+
+**Merged pull requests:**
+
+- Run Github Action tests on PRs from forks [\#44](https://github.com/bensheldon/good_job/pull/44) ([bensheldon](https://github.com/bensheldon))
+- Fix Rubygems homepage URL [\#43](https://github.com/bensheldon/good_job/pull/43) ([joshmn](https://github.com/joshmn))
+- Move where\(scheduled\_at: Time.current\) into dynamic part of GoodJob::Job::Performer [\#42](https://github.com/bensheldon/good_job/pull/42) ([bensheldon](https://github.com/bensheldon))
+
+## [v0.8.1](https://github.com/bensheldon/good_job/tree/v0.8.1) (2020-07-18)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v0.8.0...v0.8.1)
+
+## [v0.8.0](https://github.com/bensheldon/good_job/tree/v0.8.0) (2020-07-17)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v0.7.0...v0.8.0)
+
+**Merged pull requests:**
+
+- 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)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v0.6.0...v0.7.0)
+
+**Closed issues:**
+
+- Always store a default priority \(0\) and scheduled\_at\(Time.current\) [\#30](https://github.com/bensheldon/good_job/issues/30)
+
+**Merged pull requests:**
+
+- Add more examples to Readme [\#39](https://github.com/bensheldon/good_job/pull/39) ([bensheldon](https://github.com/bensheldon))
+- Add additional Rubocops and lint [\#38](https://github.com/bensheldon/good_job/pull/38) ([bensheldon](https://github.com/bensheldon))
+- Always store a default queue\_name, priority and scheduled\_at; index by queue\_name and scheduled\_at [\#37](https://github.com/bensheldon/good_job/pull/37) ([bensheldon](https://github.com/bensheldon))
+
+## [v0.6.0](https://github.com/bensheldon/good_job/tree/v0.6.0) (2020-07-15)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v0.5.0...v0.6.0)
+
+**Closed issues:**
+
+- Improve the command line options [\#32](https://github.com/bensheldon/good_job/issues/32)
+- Allow config.active\_job.queue\_adapter = :good\_job to work [\#5](https://github.com/bensheldon/good_job/issues/5)
+
+**Merged pull requests:**
+
+- Improve generation of changelog [\#36](https://github.com/bensheldon/good_job/pull/36) ([bensheldon](https://github.com/bensheldon))
+- Update Github Action Workflow for Backlog Project Board [\#35](https://github.com/bensheldon/good_job/pull/35) ([bensheldon](https://github.com/bensheldon))
+- Add configuration options to good\_job executable [\#33](https://github.com/bensheldon/good_job/pull/33) ([bensheldon](https://github.com/bensheldon))
+- Extract Job querying behavior out of Scheduler [\#31](https://github.com/bensheldon/good_job/pull/31) ([bensheldon](https://github.com/bensheldon))
+- Allow configuration of Rails queue adapter with `:good\_job` [\#28](https://github.com/bensheldon/good_job/pull/28) ([bensheldon](https://github.com/bensheldon))
+
+## [v0.5.0](https://github.com/bensheldon/good_job/tree/v0.5.0) (2020-07-13)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v0.4.0...v0.5.0)
+
+**Merged pull requests:**
+
+- Update development Ruby to 2.6.6 and gems [\#29](https://github.com/bensheldon/good_job/pull/29) ([bensheldon](https://github.com/bensheldon))
+
+## [v0.4.0](https://github.com/bensheldon/good_job/tree/v0.4.0) (2020-03-31)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v0.3.0...v0.4.0)
+
+**Merged pull requests:**
+
+- 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))
+
+## [v0.3.0](https://github.com/bensheldon/good_job/tree/v0.3.0) (2020-03-22)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v0.2.2...v0.3.0)
+
+**Merged pull requests:**
+
+- Update development Ruby to 2.6.5 [\#22](https://github.com/bensheldon/good_job/pull/22) ([bensheldon](https://github.com/bensheldon))
+- Simplify the internal API, removing JobWrapper and InlineScheduler [\#21](https://github.com/bensheldon/good_job/pull/21) ([bensheldon](https://github.com/bensheldon))
+- Generate a new future for every executed job [\#20](https://github.com/bensheldon/good_job/pull/20) ([bensheldon](https://github.com/bensheldon))
+- Configuration for maximum number of job execution threads [\#18](https://github.com/bensheldon/good_job/pull/18) ([bensheldon](https://github.com/bensheldon))
+
+## [v0.2.2](https://github.com/bensheldon/good_job/tree/v0.2.2) (2020-03-08)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v0.2.1...v0.2.2)
+
+**Merged pull requests:**
+
+- Gracefully shutdown Scheduler when executable receives TERM or INT [\#17](https://github.com/bensheldon/good_job/pull/17) ([bensheldon](https://github.com/bensheldon))
+- Update Appraisals [\#16](https://github.com/bensheldon/good_job/pull/16) ([bensheldon](https://github.com/bensheldon))
+
+## [v0.2.1](https://github.com/bensheldon/good_job/tree/v0.2.1) (2020-03-07)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v0.2.0...v0.2.1)
+
+**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))
+- Add Appraisal with tests for Rails 5.1, 5.2, 6.0 [\#11](https://github.com/bensheldon/good_job/pull/11) ([bensheldon](https://github.com/bensheldon))
+
+## [v0.2.0](https://github.com/bensheldon/good_job/tree/v0.2.0) (2020-03-06)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v0.1.0...v0.2.0)
+
+**Merged pull requests:**
+
+- Use Rails.logger and ActiveSupport::Notifications for logging instead of puts [\#10](https://github.com/bensheldon/good_job/pull/10) ([bensheldon](https://github.com/bensheldon))
+- Remove minitest files [\#9](https://github.com/bensheldon/good_job/pull/9) ([bensheldon](https://github.com/bensheldon))
+- Use scheduled\_at and priority for scheduling [\#8](https://github.com/bensheldon/good_job/pull/8) ([bensheldon](https://github.com/bensheldon))
+- Create Github Action workflow for PRs and Issues [\#7](https://github.com/bensheldon/good_job/pull/7) ([bensheldon](https://github.com/bensheldon))
+
+## [v0.1.0](https://github.com/bensheldon/good_job/tree/v0.1.0) (2020-03-03)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/6866006239f1a6b7fcb7103f5df60d904952fb84...v0.1.0)
+
+**Merged pull requests:**
+
+- Add executable with Thor [\#4](https://github.com/bensheldon/good_job/pull/4) ([bensheldon](https://github.com/bensheldon))
+- Refactor adapter enqueing methods; expand Readme, tests, editorconfig [\#3](https://github.com/bensheldon/good_job/pull/3) ([bensheldon](https://github.com/bensheldon))
+- Fetch new jobs within the worker thread itself; incrementally grow worker threads [\#2](https://github.com/bensheldon/good_job/pull/2) ([bensheldon](https://github.com/bensheldon))
+- Set up Github Workflows for tests [\#1](https://github.com/bensheldon/good_job/pull/1) ([bensheldon](https://github.com/bensheldon))
+
+
+
+\* *This Changelog was automatically generated by [github_changelog_generator](https://github.com/github-changelog-generator/github-changelog-generator)*

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright 2020 Ben Sheldon
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,242 @@
+# GoodJob
+
+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). 
+- **Backed by Postgres.** Relies upon Postgres integrity and session-level Advisory Locks to provide run-once safety and stay within the limits of `schema.rb`.
+- **For most workloads.** Targets full-stack teams, economy-minded solo developers, and applications that enqueue less than 1-million jobs/day.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'good_job'
+```
+
+And then execute:
+```bash
+$ bundle install
+```
+
+## Usage
+
+1. Create a database migration:
+    ```bash
+    $ bin/rails g migration CreateGoodJobs
+    ```
+
+    Add to the newly created migration file:
+
+    ```ruby
+    class CreateGoodJobs < ActiveRecord::Migration[6.0]
+      def change
+        enable_extension 'pgcrypto'
+
+        create_table :good_jobs, id: :uuid do |t|
+          t.timestamps
+
+          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
+
+          add_index :good_jobs, :scheduled_at, where: "(finished_at IS NULL)"
+          add_index :good_jobs, [:queue_name, :scheduled_at], where: "(finished_at IS NULL)"
+        end
+      end
+    end
+    ```
+    
+    Run the migration:
+    
+    ```bash
+    $ bin/rails db:migrate
+    ```
+    
+1. Configure the ActiveJob adapter:
+    ```ruby
+    # config/application.rb
+    config.active_job.queue_adapter = :good_job
+    ```
+    
+    By default, using `:good_job` is equivalent to manually configuring the adapter:
+    
+    ```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)
+    ```
+
+1. Queue your job 🎉: 
+    ```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`:
+   ```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]  # Queues to work from. Separate multiple queues with commas (default: *)
+   #   [--poll-interval=N]       # Interval between polls for available jobs in seconds (default: 1)
+   ```
+
+### Taking advantage of ActiveJob
+
+ActiveJob has a rich set of built-in functionality for timeouts, error handling, and retrying. For example:
+
+```ruby
+class ApplicationJob < ActiveJob::Base  
+  # Retry errors an infinite number of times with exponential back-off
+  retry_on StandardError, wait: :exponentially_longer, attempts: Float::INFINITY
+
+  # Timeout jobs after 10 minutes
+  JobTimeoutError = Class.new(StandardError)
+  around_perform do |_job, block|
+    Timeout.timeout(10.minutes, JobTimeoutError) do
+      block.call
+    end
+  end
+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:
+
+- 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`)
+
+### 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.
+
+1. Enqueue newly created jobs on GoodJob either entirely by setting `ActiveJob::Base.queue_adapter = :good_job` or progressively via individual job classes:
+
+    ```ruby
+    # jobs/specific_job.rb
+    class SpecificJob < ApplicationJob
+      self.queue_adapter = :good_job
+      # ...
+    end
+    ```
+
+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
+    # ...
+    worker: bundle exec que ./config/environment.rb & bundle exec good_job & wait -n
+    ```
+
+1. Once you are confident that no unperformed jobs remain in the previous ActiveJob backend, code and configuration for that backend can be completely removed.
+
+### Monitoring and preserving worked jobs
+
+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`). 
+
+To preserve job records for later inspection, set an initializer:
+
+```ruby
+# config/initializers/good_job.rb
+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
+    ```
+- For example, using the `good_job` command-line utility:
+
+    ```bash
+    $ bundle exec good_job cleanup_preserved_jobs --before-seconds-ago=86400
+    ```
+
+## Development
+
+To run tests:
+
+```bash
+# Clone the repository locally
+$ git clone git@github.com:bensheldon/good_job.git
+
+# Set up the local environment
+$ bin/setup_test
+
+# Run the tests
+$ bin/rspec
+```
+
+This gem uses Appraisal to run tests against multiple versions of Rails:
+
+```bash
+# Install Appraisal(s) gemfiles
+$ bundle exec appraisal
+
+# Run tests
+$ bundle exec appraisal bin/rspec
+
+```
+
+For developing locally within another Ruby on Rails project:
+
+```bash
+# Within Ruby on Rails directory...
+$ bundle config local.good_job /path/to/local/git/repository
+
+# Confirm that the local copy is used
+$ bundle install
+
+# => Using good_job 0.1.0 from https://github.com/bensheldon/good_job.git (at /Users/You/Projects/good_job@dc57fb0)
+```
+
+## Releasing
+
+Package maintainers can release this gem with the following [gem-release](https://github.com/svenfuchs/gem-release) command:
+
+```bash
+# Sign into rubygems
+$ gem signin
+
+# Update version number, changelog, and create git commit:
+$ bundle exec rake commit_version[minor] # major,minor,patch
+
+# ..and follow subsequent directions. 
+```
+
+## Contributing
+
+Contribution directions go here.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/exe/good_job

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'good_job/cli'
+GoodJob::CLI.start(ARGV)

data/lib/active_job/queue_adapters/good_job_adapter.rb

@@ -0,0 +1,19 @@
+module ActiveJob
+  module QueueAdapters
+    class GoodJobAdapter < GoodJob::Adapter
+      def initialize(execution_mode: nil)
+        execution_mode = if execution_mode
+                           execution_mode
+                         elsif ENV['GOOD_JOB_EXECUTION_MODE'].present?
+                           ENV['GOOD_JOB_EXECUTION_MODE'].to_sym
+                         elsif Rails.env.development? || Rails.env.test?
+                           :inline
+                         else
+                           :external
+                         end
+
+        super(execution_mode: execution_mode)
+      end
+    end
+  end
+end

data/lib/good_job.rb

@@ -0,0 +1,19 @@
+require "rails"
+require 'good_job/railtie'
+
+require 'good_job/logging'
+require 'good_job/lockable'
+require 'good_job/job'
+require 'good_job/scheduler'
+require 'good_job/adapter'
+require 'good_job/pg_locks'
+require 'good_job/performer'
+
+require 'active_job/queue_adapters/good_job_adapter'
+
+module GoodJob
+  mattr_accessor :preserve_job_records, default: false
+  include Logging
+
+  ActiveSupport.run_load_hooks(:good_job, self)
+end

data/lib/good_job/adapter.rb

@@ -0,0 +1,57 @@
+module GoodJob
+  class Adapter
+    EXECUTION_MODES = [:inline, :external].freeze # TODO: async
+
+    def initialize(execution_mode: nil, inline: false)
+      if inline
+        ActiveSupport::Deprecation.warn('GoodJob::Adapter#new(inline: true) is deprecated; use GoodJob::Adapter.new(execution_mode: :inline) instead')
+        @execution_mode = :inline
+      elsif execution_mode
+        raise ArgumentError, "execution_mode: must be one of #{EXECUTION_MODES.join(', ')}." unless EXECUTION_MODES.include?(execution_mode)
+
+        @execution_mode = execution_mode
+      else
+        @execution_mode = :external
+      end
+    end
+
+    def enqueue(active_job)
+      enqueue_at(active_job, nil)
+    end
+
+    def enqueue_at(active_job, timestamp)
+      good_job = GoodJob::Job.enqueue(
+        active_job,
+        scheduled_at: timestamp ? Time.zone.at(timestamp) : nil,
+        create_with_advisory_lock: execute_inline?
+      )
+
+      if execute_inline?
+        begin
+          good_job.perform
+        ensure
+          good_job.advisory_unlock
+        end
+      end
+
+      good_job
+    end
+
+    def shutdown(wait: true) # rubocop:disable Lint/UnusedMethodArgument
+      nil
+    end
+
+    def execute_inline?
+      @execution_mode == :inline
+    end
+
+    def inline?
+      ActiveSupport::Deprecation.warn('GoodJob::Adapter::inline? is deprecated; use GoodJob::Adapter::execute_inline? instead')
+      execute_inline?
+    end
+
+    def execute_externally?
+      @execution_mode == :external
+    end
+  end
+end

data/lib/good_job/cli.rb

@@ -0,0 +1,91 @@
+require 'thor'
+
+module GoodJob
+  class CLI < Thor
+    RAILS_ENVIRONMENT_RB = File.expand_path("config/environment.rb")
+
+    desc :start, "Start job worker"
+    method_option :max_threads,
+                  type: :numeric,
+                  desc: "Maximum number of threads to use for working jobs (default: ActiveRecord::Base.connection_pool.size)"
+    method_option :queues,
+                  type: :string,
+                  banner: "queue1,queue2",
+                  desc: "Queues to work from. Separate multiple queues with commas (default: *)"
+    method_option :poll_interval,
+                  type: :numeric,
+                  desc: "Interval between polls for available jobs in seconds (default: 1)"
+    def start
+      require RAILS_ENVIRONMENT_RB
+
+      max_threads = (
+        options[:max_threads] ||
+        ENV['GOOD_JOB_MAX_THREADS'] ||
+        ENV['RAILS_MAX_THREADS'] ||
+        ActiveRecord::Base.connection_pool.size
+      ).to_i
+
+      queue_names = (
+        options[:queues] ||
+        ENV['GOOD_JOB_QUEUES'] ||
+        '*'
+      ).split(',').map(&:strip)
+
+      poll_interval = (
+        options[:poll_interval] ||
+        ENV['GOOD_JOB_POLL_INTERVAL']
+      ).to_i
+
+      job_query = GoodJob::Job.all.priority_ordered
+      queue_names_without_all = queue_names.reject { |q| q == '*' }
+      job_query = job_query.where(queue_name: queue_names_without_all) unless queue_names_without_all.size.zero?
+
+      performer_method = if GoodJob.preserve_job_records
+                           :perform_with_advisory_lock_and_preserve_job_records
+                         else
+                           :perform_with_advisory_lock_and_destroy_job_records
+                         end
+      job_performer = GoodJob::Performer.new(job_query, performer_method)
+
+      $stdout.puts "GoodJob worker starting with max_threads=#{max_threads} on queues=#{queue_names.join(',')}"
+
+      timer_options = {}
+      timer_options[:execution_interval] = poll_interval if poll_interval.positive?
+
+      pool_options = {
+        max_threads: max_threads,
+      }
+
+      scheduler = GoodJob::Scheduler.new(job_performer, timer_options: timer_options, pool_options: pool_options)
+
+      @stop_good_job_executable = false
+      %w[INT TERM].each do |signal|
+        trap(signal) { @stop_good_job_executable = true }
+      end
+
+      Kernel.loop do
+        sleep 0.1
+        break if @stop_good_job_executable || scheduler.shutdown?
+      end
+
+      $stdout.puts "\nFinishing GoodJob's current jobs before exiting..."
+      scheduler.shutdown
+      $stdout.puts "GoodJob's jobs finished, exiting..."
+    end
+
+    desc :cleanup_preserved_jobs, "Delete preserved job records"
+    method_option :before_seconds_ago,
+                  type: :numeric,
+                  default: 24 * 60 * 60,
+                  desc: "Delete records finished more than this many seconds ago"
+    def cleanup_preserved_jobs
+      require RAILS_ENVIRONMENT_RB
+
+      timestamp = Time.current - options[:before_seconds_ago]
+      result = GoodJob::Job.finished(timestamp).delete_all
+      $stdout.puts "Deleted #{result} preserved #{'job'.pluralize(result)} finished before #{timestamp}."
+    end
+
+    default_task :start
+  end
+end

data/lib/good_job/job.rb

@@ -0,0 +1,106 @@
+module GoodJob
+  class Job < ActiveRecord::Base
+    include Lockable
+
+    PreviouslyPerformedError = Class.new(StandardError)
+
+    DEFAULT_QUEUE_NAME = 'default'.freeze
+    DEFAULT_PRIORITY = 0
+
+    self.table_name = 'good_jobs'.freeze
+
+    scope :unfinished, (lambda do
+      if column_names.include?('finished_at')
+        where(finished_at: nil)
+      else
+        ActiveSupport::Deprecation.warn('GoodJob expects a good_jobs.finished_at column to exist. Please see the GoodJob README.md for migration instructions.')
+        nil
+      end
+    end)
+    scope :only_scheduled, -> { where(arel_table['scheduled_at'].lteq(Time.current)).or(where(scheduled_at: nil)) }
+    scope :priority_ordered, -> { order(priority: :desc) }
+    scope :finished, ->(timestamp = nil) { timestamp ? where(arel_table['finished_at'].lteq(timestamp)) : where.not(finished_at: nil) }
+
+    def self.perform_with_advisory_lock(destroy_after: !GoodJob.preserve_job_records)
+      good_job = nil
+      result = nil
+      error = nil
+
+      unfinished.only_scheduled.limit(1).with_advisory_lock do |good_jobs|
+        good_job = good_jobs.first
+        break unless good_job
+
+        result, error = good_job.perform(destroy_after: destroy_after)
+      end
+
+      [good_job, result, error] if good_job
+    end
+
+    def self.perform_with_advisory_lock_and_preserve_job_records
+      perform_with_advisory_lock(destroy_after: false)
+    end
+
+    def self.perform_with_advisory_lock_and_destroy_job_records
+      perform_with_advisory_lock(destroy_after: true)
+    end
+
+    def self.enqueue(active_job, scheduled_at: nil, create_with_advisory_lock: false)
+      good_job = nil
+      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(
+          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 || Time.current,
+          create_with_advisory_lock: create_with_advisory_lock
+        )
+
+        instrument_payload[:good_job] = good_job
+
+        good_job.save!
+        active_job.provider_job_id = good_job.id
+      end
+
+      good_job
+    end
+
+    def perform(destroy_after: true)
+      raise PreviouslyPerformedError, 'Cannot perform a job that has already been performed' if finished_at
+
+      result = nil
+      error = nil
+
+      ActiveSupport::Notifications.instrument("before_perform_job.good_job", { good_job: self })
+      self.performed_at = Time.current
+      save! unless destroy_after
+
+      ActiveSupport::Notifications.instrument("perform_job.good_job", { good_job: self }) do
+        params = serialized_params.merge(
+          "provider_job_id" => id
+        )
+        begin
+          result = ActiveJob::Base.execute(params)
+        rescue StandardError => e
+          error = e
+        end
+      end
+
+      if error.nil? && result.is_a?(Exception)
+        error = result
+        result = nil
+      end
+
+      error_message = "#{error.class}: #{error.message}" if error
+      self.error = error_message
+      self.finished_at = Time.current
+
+      if destroy_after
+        destroy!
+      else
+        save!
+      end
+
+      [result, error]
+    end
+  end
+end

data/lib/good_job/lockable.rb

@@ -0,0 +1,106 @@
+module GoodJob
+  module Lockable
+    extend ActiveSupport::Concern
+
+    RecordAlreadyAdvisoryLockedError = Class.new(StandardError)
+
+    included do
+      scope :advisory_lock, (lambda do
+        original_query = self
+
+        cte_table = Arel::Table.new(:rows)
+        composed_cte = Arel::Nodes::As.new(cte_table, original_query.select(primary_key).except(:limit).arel)
+
+        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 || \"#{cte_table.name}\".\"#{primary_key}\"::text), 1, 16))::bit(64)::bigint)", { table_name: table_name }])))
+
+        limit = original_query.arel.ast.limit
+        query.limit = limit.value if limit.present?
+
+        unscoped.where(arel_table[:id].in(query)).merge(original_query.only(:order))
+      end)
+
+      scope :joins_advisory_locks, (lambda do
+        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
+        SQL
+
+        joins(sanitize_sql_for_conditions([join_sql, { table_name: table_name }]))
+      end)
+
+      scope :advisory_unlocked, -> { joins_advisory_locks.where(pg_locks: { locktype: nil }) }
+      scope :advisory_locked, -> { joins_advisory_locks.where.not(pg_locks: { locktype: nil }) }
+      scope :owns_advisory_locked, -> { joins_advisory_locks.where('"pg_locks"."pid" = pg_backend_pid()') }
+
+      attr_accessor :create_with_advisory_lock
+
+      after_create -> { advisory_lock }, if: :create_with_advisory_lock
+    end
+
+    class_methods do
+      def with_advisory_lock
+        raise ArgumentError, "Must provide a block" unless block_given?
+
+        records = advisory_lock.to_a
+        begin
+          yield(records)
+        ensure
+          records.each(&:advisory_unlock)
+        end
+      end
+    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)
+      SQL
+      self.class.connection.execute(sanitize_sql_for_conditions([query, { table_name: self.class.table_name, id: send(self.class.primary_key) }])).ntuples.positive?
+    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)
+      SQL
+      self.class.connection.execute(sanitize_sql_for_conditions([query, { table_name: self.class.table_name, id: send(self.class.primary_key) }])).ntuples.positive?
+    end
+
+    def advisory_lock!
+      result = advisory_lock
+      result || raise(RecordAlreadyAdvisoryLockedError)
+    end
+
+    def with_advisory_lock
+      raise ArgumentError, "Must provide a block" unless block_given?
+
+      advisory_lock!
+      yield
+    ensure
+      advisory_unlock unless $ERROR_INFO.is_a? RecordAlreadyAdvisoryLockedError
+    end
+
+    def advisory_locked?
+      self.class.advisory_locked.where(id: send(self.class.primary_key)).any?
+    end
+
+    def owns_advisory_lock?
+      self.class.owns_advisory_locked.where(id: send(self.class.primary_key)).any?
+    end
+
+    def advisory_unlock!
+      advisory_unlock while advisory_locked?
+    end
+
+    private
+
+    def sanitize_sql_for_conditions(*args)
+      # Made public in Rails 5.2
+      self.class.send(:sanitize_sql_for_conditions, *args)
+    end
+  end
+end

data/lib/good_job/logging.rb

@@ -0,0 +1,70 @@
+module GoodJob
+  module Logging
+    extend ActiveSupport::Concern
+
+    included do
+      cattr_accessor :logger, default: ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new(STDOUT))
+
+      def self.tag_logger(*tags)
+        if logger.respond_to?(:tagged)
+          tags.unshift "GoodJob" unless logger.formatter.current_tags.include?("GoodJob")
+          logger.tagged(*tags) { yield }
+        else
+          yield
+        end
+      end
+    end
+
+    class LogSubscriber < ActiveSupport::LogSubscriber
+      def create(event)
+        good_job = event.payload[:good_job]
+
+        info do
+          "Created GoodJob resource with id #{good_job.id}"
+        end
+      end
+
+      def timer_task_finished(event)
+        exception = event.payload[:error]
+        return unless exception
+
+        error do
+          "ERROR: #{exception}\n #{exception.backtrace}"
+        end
+      end
+
+      def job_finished(event)
+        exception = event.payload[:error]
+        return unless exception
+
+        error do
+          "ERROR: #{exception}\n #{exception.backtrace}"
+        end
+      end
+
+      def scheduler_start_shutdown(_event)
+        info do
+          "Shutting down scheduler..."
+        end
+      end
+
+      def scheduler_shutdown(_event)
+        info do
+          "Scheduler is shut down."
+        end
+      end
+
+      private
+
+      def logger
+        GoodJob.logger
+      end
+
+      def thread_name
+        Thread.current.name || Thread.current.object_id
+      end
+    end
+  end
+end
+
+GoodJob::Logging::LogSubscriber.attach_to :good_job

data/lib/good_job/performer.rb

@@ -0,0 +1,12 @@
+module GoodJob
+  class Performer
+    def initialize(target, method_name)
+      @target = target
+      @method_name = method_name
+    end
+
+    def next
+      @target.public_send(@method_name)
+    end
+  end
+end

data/lib/good_job/pg_locks.rb

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

data/lib/good_job/railtie.rb

@@ -0,0 +1,7 @@
+module GoodJob
+  class Railtie < ::Rails::Railtie
+    initializer "good_job.logger" do
+      ActiveSupport.on_load(:good_job) { self.logger = ::Rails.logger }
+    end
+  end
+end

data/lib/good_job/scheduler.rb

@@ -0,0 +1,79 @@
+require "concurrent/executor/thread_pool_executor"
+require "concurrent/timer_task"
+require "concurrent/utility/processor_counter"
+
+module GoodJob
+  class Scheduler
+    DEFAULT_TIMER_OPTIONS = {
+      execution_interval: 1,
+      timeout_interval: 1,
+      run_now: true,
+    }.freeze
+
+    DEFAULT_POOL_OPTIONS = {
+      name: 'good_job',
+      min_threads: 0,
+      max_threads: Concurrent.processor_count,
+      auto_terminate: true,
+      idletime: 60,
+      max_queue: 0,
+      fallback_policy: :abort, # shouldn't matter -- 0 max queue
+    }.freeze
+
+    def initialize(performer, timer_options: {}, pool_options: {})
+      raise ArgumentError, "Performer argument must implement #next" unless performer.respond_to?(:next)
+
+      @performer = performer
+      @pool = Concurrent::ThreadPoolExecutor.new(DEFAULT_POOL_OPTIONS.merge(pool_options))
+      @timer = Concurrent::TimerTask.new(DEFAULT_TIMER_OPTIONS.merge(timer_options)) do
+        idle_threads = @pool.max_length - @pool.length
+        create_thread if idle_threads.positive?
+      end
+      @timer.add_observer(self, :timer_observer)
+      @timer.execute
+    end
+
+    def execute
+    end
+
+    def shutdown(wait: true)
+      @_shutdown = true
+
+      ActiveSupport::Notifications.instrument("scheduler_start_shutdown.good_job", { wait: wait })
+      ActiveSupport::Notifications.instrument("scheduler_shutdown.good_job", { wait: wait }) do
+        if @timer.running?
+          @timer.shutdown
+          @timer.wait_for_termination if wait
+        end
+
+        if @pool.running?
+          @pool.shutdown
+          @pool.wait_for_termination if wait
+        end
+      end
+    end
+
+    def shutdown?
+      @_shutdown
+    end
+
+    def create_thread
+      future = Concurrent::Future.new(args: [@performer], executor: @pool) do |performer|
+        output = nil
+        Rails.application.executor.wrap { output = performer.next }
+        output
+      end
+      future.add_observer(self, :task_observer)
+      future.execute
+    end
+
+    def timer_observer(time, executed_task, thread_error)
+      ActiveSupport::Notifications.instrument("finished_timer_task.good_job", { result: executed_task, error: thread_error, time: time })
+    end
+
+    def task_observer(time, output, thread_error)
+      ActiveSupport::Notifications.instrument("finished_job_task.good_job", { result: output, error: thread_error, time: time })
+      create_thread if output
+    end
+  end
+end

data/lib/good_job/version.rb

@@ -0,0 +1,3 @@
+module GoodJob
+  VERSION = '1.0.1'.freeze
+end

metadata

@@ -0,0 +1,285 @@
+--- !ruby/object:Gem::Specification
+name: good_job
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Ben Sheldon
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-07-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.2
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: rails
+  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: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.14.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.14.1
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  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: database_cleaner
+  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: foreman
+  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: gem-release
+  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: github_changelog_generator
+  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
+  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: rspec-rails
+  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: rubocop
+  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: rubocop-performance
+  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: rubocop-rails
+  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: rubocop-rspec
+  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'
+description: A multithreaded, Postgres-based ActiveJob backend for Ruby on Rails
+email:
+- bensheldon@gmail.com
+executables:
+- good_job
+extensions: []
+extra_rdoc_files:
+- README.md
+- CHANGELOG.md
+- LICENSE.txt
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- exe/good_job
+- lib/active_job/queue_adapters/good_job_adapter.rb
+- lib/good_job.rb
+- lib/good_job/adapter.rb
+- lib/good_job/cli.rb
+- lib/good_job/job.rb
+- lib/good_job/lockable.rb
+- lib/good_job/logging.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
+homepage: https://github.com/bensheldon/good_job
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/bensheldon/good_job/issues
+  changelog_uri: https://github.com/bensheldon/good_job/blob/master/CHANGELOG.md
+  documentation_uri: https://rdoc.info/github/bensheldon/good_job
+  homepage_uri: https://github.com/bensheldon/good_job
+  source_code_uri: https://github.com/bensheldon/good_job
+post_install_message: 
+rdoc_options:
+- "--title"
+- GoodJob - a multithreaded, Postgres-based ActiveJob backend for Ruby on Rails
+- "--main"
+- README.md
+- "--line-numbers"
+- "--inline-source"
+- "--quiet"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: A multithreaded, Postgres-based ActiveJob backend for Ruby on Rails
+test_files: []