good_job 0.4.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5a3b5327b3b95b67901f3be13858f0bbf9cf1d0818793ed653f084a77b8e6ff9
-  data.tar.gz: 056fd886d26d7ee60fd63d7f45714c7b843f7f4e6661b58a00dc4c6ec17d9b9c
+  metadata.gz: 9d3f717a6ef87a75232173cd29e90842edc441808036116ced1355d0c51957a2
+  data.tar.gz: df7aaaab677397d52694697df2016bc9fa7c65db6bebe4f3a112432b5b9f3a96
 SHA512:
-  metadata.gz: 12221043ad332a684e062aae176d529bbd39da7998e9ae6d355bdb1f68f2f7ace21c4f4196ebe0306841a761161e564125f35c7522f30f3b2f718830bd15c788
-  data.tar.gz: 7d389ac1aafb614b813fdb1eb75ce7dceba40238111966d8031578ac88553d989cee08dcef03d72fd8e53ce3215692779e2e03c538ea90cb3a477361ef2442d8
+  metadata.gz: ec049cfa4441c5bfa61b70661ed6543cf22e9e3625036dd5ce824f528a2516347961dd95b1ecccc444587f5a31a353499f50a362005c43ea30263b9bb51d1524
+  data.tar.gz: 4e0c0adbee22e2e8ae825015917cb52fe15475d409d48eec0a43df659de5fca95447f611bcacddcb98095888f8a809136890bed0d1fa9465b7bed38b5b38295b

data/CHANGELOG.md

@@ -1,8 +1,49 @@
 # Changelog
 
-## [0.4.0](https://github.com/bensheldon/good_job/tree/0.4.0) (2020-03-30)
+## [v0.8.1](https://github.com/bensheldon/good_job/tree/v0.8.1) (2020-07-17)
 
-[Full Changelog](https://github.com/bensheldon/good_job/compare/v0.3.0...0.4.0)
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v0.6.0...v0.8.1)
+
+**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:**
+
+- 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))
+- Replace Adapter inline boolean kwarg with execution\_mode instead [\#41](https://github.com/bensheldon/good_job/pull/41) ([bensheldon](https://github.com/bensheldon))
+- 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:**
 
@@ -18,6 +59,7 @@
 - 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)
 
@@ -25,7 +67,6 @@
 
 **Merged pull requests:**
 
-- Configuration for maximum number of job execution threads [\#18](https://github.com/bensheldon/good_job/pull/18) ([bensheldon](https://github.com/bensheldon))
 - 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))
 

data/README.md

@@ -1,25 +1,25 @@
 # GoodJob
 
-GoodJob is a multithreaded, Postgres-based ActiveJob backend for Ruby on Rails.
+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’s design principles are:
+**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.**
 
-- Stand on the shoulders of ActiveJob. For example, [exception](https://edgeguides.rubyonrails.org/active_job_basics.html#exceptions) and [retry](https://edgeguides.rubyonrails.org/active_job_basics.html#retrying-or-discarding-failed-jobs) behavior. 
-- Stand on the shoulders of Ruby on Rails. For example, ActiveRecord ORM, connection pools, and [multithreaded support](https://guides.rubyonrails.org/threading_and_code_execution.html) with [Concurrent-Ruby](https://github.com/ruby-concurrency/concurrent-ruby).
-- Stand on the shoulders of Postgres. For example, Advisory Locks.
-- Convention over simplicity over performance. 
+- **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', github: 'bensheldon/good_job'
+gem 'good_job'
 ```
 
 And then execute:
 ```bash
-$ bundle
+$ bundle install
 ```
 
 ## Usage
@@ -43,6 +43,9 @@ $ bundle
           t.integer :priority
           t.jsonb :serialized_params
           t.timestamp :scheduled_at
+   
+          t.index :scheduled_at
+          t.index [:queue_name, :scheduled_at]
         end
       end
     end
@@ -56,11 +59,26 @@ $ bundle
     
 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
+    config.active_job.queue_adapter = GoodJob::Adapter.new(execution_mode: :external)
+    ```
 
-    # config/environments/development.rb
-    config.active_job.queue_adapter = GoodJob::Adapter.new(inline: true)
+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:
@@ -68,6 +86,38 @@ $ bundle
     $ 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:
@@ -79,6 +129,29 @@ GoodJob executes enqueued jobs using threads. There is a lot than can be said ab
     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.
+
 ## Development
 
 To run tests:
@@ -94,6 +167,17 @@ $ bin/setup_test
 $ 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
@@ -115,7 +199,7 @@ Package maintainers can release this gem with the following [gem-release](https:
 $ gem signin
 
 # Update version number, changelog, and create git commit:
-$ bundle exec rake commit_version
+$ bundle exec rake commit_version[minor] # major,minor,patch
 
 # ..and follow subsequent directions. 
 ```

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

@@ -8,6 +8,8 @@ require "good_job/scheduler"
 require 'good_job/adapter'
 require 'good_job/pg_locks'
 
+require 'active_job/queue_adapters/good_job_adapter'
+
 module GoodJob
   include Logging
 

data/lib/good_job/adapter.rb

@@ -1,7 +1,18 @@
 module GoodJob
   class Adapter
-    def initialize(inline: false)
-      @inline = inline
+    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)
@@ -11,13 +22,16 @@ module GoodJob
     def enqueue_at(active_job, timestamp)
       good_job = GoodJob::Job.enqueue(
         active_job,
-        scheduled_at: timestamp ? Time.at(timestamp) : nil,
-        create_with_advisory_lock: inline?
+        scheduled_at: timestamp ? Time.zone.at(timestamp) : nil,
+        create_with_advisory_lock: execute_inline?
       )
 
-      if inline?
-        good_job.perform
-        good_job.advisory_unlock
+      if execute_inline?
+        begin
+          good_job.perform
+        ensure
+          good_job.advisory_unlock
+        end
       end
 
       good_job
@@ -27,10 +41,17 @@ module GoodJob
       nil
     end
 
-    private
+    def execute_inline?
+      @execution_mode == :inline
+    end
 
     def inline?
-      @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

@@ -4,23 +4,59 @@ module GoodJob
   class CLI < Thor
     RAILS_ENVIRONMENT_RB = File.expand_path("config/environment.rb")
 
-    desc :start, "Start jobs"
-    method_option :max_threads, type: :numeric
+    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
+      max_threads = (
+        options[:max_threads] ||
+        ENV['GOOD_JOB_MAX_THREADS'] ||
+        ENV['RAILS_MAX_THREADS'] ||
+        ActiveRecord::Base.connection_pool.size
+      ).to_i
 
-      $stdout.puts "GoodJob starting with max_threads=#{max_threads}"
-      scheduler = GoodJob::Scheduler.new(pool_options: { max_threads: max_threads })
+      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?
+
+      job_performer = job_query.to_performer
+
+      $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
-      @stop_good_job_executable = false
 
       Kernel.loop do
         sleep 0.1

data/lib/good_job/job.rb

@@ -2,16 +2,42 @@ module GoodJob
   class Job < ActiveRecord::Base
     include Lockable
 
-    self.table_name = 'good_jobs'
+    DEFAULT_QUEUE_NAME = 'default'.freeze
+    DEFAULT_PRIORITY = 0
+
+    self.table_name = 'good_jobs'.freeze
+
+    scope :only_scheduled, -> { where(arel_table['scheduled_at'].lteq(Time.current)).or(where(scheduled_at: nil)) }
+    scope :priority_ordered, -> { order(priority: :desc) }
+    scope :to_performer, -> { Performer.new(self) }
+
+    class Performer
+      def initialize(query)
+        @query = query
+      end
+
+      def next
+        good_job = nil
+
+        @query.only_scheduled.limit(1).with_advisory_lock do |good_jobs|
+          good_job = good_jobs.first
+          break unless good_job
+
+          good_job.perform
+        end
+
+        good_job
+      end
+    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,
-          priority: active_job.priority,
+          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,
+          scheduled_at: scheduled_at || Time.current,
           create_with_advisory_lock: create_with_advisory_lock
         )
 

data/lib/good_job/lockable.rb

@@ -37,14 +37,17 @@ module GoodJob
       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(&block)
+      def with_advisory_lock
+        raise ArgumentError, "Must provide a block" unless block_given?
+
         records = advisory_lock.to_a
         begin
-          block.call(records)
+          yield(records)
         ensure
           records.each(&:advisory_unlock)
         end
@@ -73,6 +76,8 @@ module GoodJob
     end
 
     def with_advisory_lock
+      raise ArgumentError, "Must provide a block" unless block_given?
+
       advisory_lock!
       yield
     ensure

data/lib/good_job/scheduler.rb

@@ -20,9 +20,10 @@ module GoodJob
       fallback_policy: :abort, # shouldn't matter -- 0 max queue
     }.freeze
 
-    def initialize(query = GoodJob::Job.all, timer_options: {}, pool_options: {})
-      @query = query
+    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
@@ -32,10 +33,6 @@ module GoodJob
       @timer.execute
     end
 
-    def ordered_query
-      @query.where("scheduled_at < ?", Time.current).or(@query.where(scheduled_at: nil)).order(priority: :desc)
-    end
-
     def execute
     end
 
@@ -61,19 +58,10 @@ module GoodJob
     end
 
     def create_thread
-      future = Concurrent::Future.new(args: [ordered_query], executor: @pool) do |query|
-        good_job = nil
-
-        Rails.application.executor.wrap do
-          query.limit(1).with_advisory_lock do |good_jobs|
-            good_job = good_jobs.first
-            break unless good_job
-
-            good_job.perform
-          end
-        end
-
-        good_job
+      future = Concurrent::Future.new(args: [@performer], executor: @pool) do |performer|
+        result = nil
+        Rails.application.executor.wrap { result = performer.next }
+        result
       end
       future.add_observer(self, :task_observer)
       future.execute
@@ -83,9 +71,9 @@ module GoodJob
       ActiveSupport::Notifications.instrument("finished_timer_task.good_job", { result: executed_task, error: error, time: time })
     end
 
-    def task_observer(time, performed_job, error)
-      ActiveSupport::Notifications.instrument("finished_job_task.good_job", { good_job: performed_job, error: error, time: time })
-      create_thread if performed_job
+    def task_observer(time, result, error)
+      ActiveSupport::Notifications.instrument("finished_job_task.good_job", { result: result, error: error, time: time })
+      create_thread if result
     end
   end
 end

data/lib/good_job/version.rb

@@ -1,3 +1,3 @@
 module GoodJob
-  VERSION = '0.4.0'.freeze
+  VERSION = '0.8.1'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.8.1
 platform: ruby
 authors:
 - Ben Sheldon
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-03-31 00:00:00.000000000 Z
+date: 2020-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -178,6 +178,34 @@ dependencies:
     - - ">="
       - !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
@@ -207,6 +235,7 @@ files:
 - 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