inst-jobs 3.0.8 → 3.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f318e6929f6bf9ab751c02abddf2e89f118eec259bd88597812cc6c71e74aa67
-  data.tar.gz: a142ca5ca379e7278f5746becf058e7ae6e7de5351a0d4ba9ec8e8524ca3ce4f
+  metadata.gz: ee779fa187d057bce265940ca1c9c2944bdf096ab198060e0819ff40dd02358b
+  data.tar.gz: bc930f9dc0ca659df54388753dc9aa26402c866023b7f275155897ccca35ebf4
 SHA512:
-  metadata.gz: 4f819854ff0690e7f3eeb22fe098b1e0f69f06d0447540e40ce66ff4fa1db4c1e5d87fbe134121c8c795782825e2007d02349445b5d315d0afe8b10cf331cdb4
-  data.tar.gz: 880295f1cabdc681f022655a5a481476b204c08d6a21a4f2b36b01544d2d9b2bdac55354c3d972d88760e22d5603b876ed4d41252f1bb146f9399c295ff918c8
+  metadata.gz: bd24bd19e153cb7f48b33911e38fbd9657de396baad1c32286d5a4acb899d23f9d97c627914c095647006129f5c0ebc008e7e07b311f3d33b89819e400cce756
+  data.tar.gz: 005e7e0a637b1e5a3fcae2b7e22edfb2af604da2328e273f512b4747dacb4d723afc06bd4846246c3fc541f72ca7068123c98bf26b52e2964f7eaa45dba6b609

data/db/migrate/20220328152900_add_failed_jobs_indicies.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class AddFailedJobsIndicies < ActiveRecord::Migration[5.2]
+  disable_ddl_transaction!
+
+  def change
+    add_index :failed_jobs, :failed_at, algorithm: :concurrently
+    add_index :failed_jobs, :strand, where: "strand IS NOT NULL", algorithm: :concurrently
+    add_index :failed_jobs, :singleton, where: "singleton IS NOT NULL", algorithm: :concurrently
+    add_index :failed_jobs, :tag, algorithm: :concurrently
+  end
+end

data/lib/delayed/backend/active_record.rb

@@ -62,11 +62,21 @@ module Delayed
             _write_attribute(column, current_time) unless attribute_present?(column)
           end
 
-          attribute_names = attribute_names_for_partial_writes
+          attribute_names = if Rails.version < "7.0"
+                              attribute_names_for_partial_writes
+                            else
+                              attribute_names_for_partial_inserts
+                            end
           attribute_names = attributes_for_create(attribute_names)
           values = attributes_with_values(attribute_names)
 
-          im = self.class.arel_table.compile_insert(self.class.send(:_substitute_values, values))
+          im = if Rails.version < "7.0"
+                 self.class.arel_table.compile_insert(self.class.send(:_substitute_values, values))
+               else
+                 im = Arel::InsertManager.new(self.class.arel_table)
+                 im.insert(values.transform_keys { |name| self.class.arel_table[name] })
+                 im
+               end
 
           lock_and_insert = values["strand"] && instance_of?(Job)
           # can't use prepared statements if we're combining multiple statemenets
@@ -101,7 +111,8 @@ module Delayed
             # but we don't need to lock when inserting into Delayed::Failed
             if values["strand"] && instance_of?(Job)
               fn_name = connection.quote_table_name("half_md5_as_bigint")
-              sql = "SELECT pg_advisory_xact_lock(#{fn_name}(#{connection.quote(values['strand'])})); #{sql}"
+              quoted_strand = connection.quote(Rails.version < "7.0" ? values["strand"] : values["strand"].value)
+              sql = "SELECT pg_advisory_xact_lock(#{fn_name}(#{quoted_strand})); #{sql}"
             end
             result = connection.execute(sql, "#{self.class} Create")
             self.id = result.values.first&.first
@@ -471,7 +482,7 @@ module Delayed
           transaction do
             # for db performance reasons, we only need one process doing this at a time
             # so if we can't get an advisory lock, just abort. we'll try again soon
-            return unless attempt_advisory_lock(prefetch_jobs_lock_name)
+            next unless attempt_advisory_lock(prefetch_jobs_lock_name)
 
             horizon = db_time_now - (Settings.parent_process[:prefetched_jobs_timeout] * 4)
             where("locked_by LIKE 'prefetch:%' AND locked_at<?", horizon).update_all(locked_at: nil, locked_by: nil)
@@ -568,6 +579,10 @@ module Delayed
         class Failed < Job
           include Delayed::Backend::Base
           self.table_name = :failed_jobs
+
+          def self.cleanup_old_jobs(before_date, batch_size: 10_000)
+            where("failed_at < ?", before_date).in_batches(of: batch_size).delete_all
+          end
         end
       end
     end

data/lib/delayed/periodic.rb

@@ -36,7 +36,7 @@ module Delayed
       Delayed::Job.transaction do
         # for db performance reasons, we only need one process doing this at a time
         # so if we can't get an advisory lock, just abort. we'll try again soon
-        return unless Delayed::Job.attempt_advisory_lock("Delayed::Periodic#audit_queue")
+        next unless Delayed::Job.attempt_advisory_lock("Delayed::Periodic#audit_queue")
 
         perform_audit!
       end

data/lib/delayed/settings.rb

@@ -135,7 +135,7 @@ module Delayed
     self.num_strands = ->(_strand_name) {}
     self.default_job_options = -> { {} }
     self.job_detailed_log_format = lambda { |job|
-      job.to_json(include_root: false, only: %w[tag strand priority attempts created_at max_attempts source])
+      job.to_json(include_root: false, only: %w[tag strand singleton priority attempts created_at max_attempts source])
     }
 
     # Send workers KILL after QUIT if they haven't exited within the

data/lib/delayed/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Delayed
-  VERSION = "3.0.8"
+  VERSION = "3.0.12"
 end

data/lib/delayed/worker/health_check.rb

@@ -34,7 +34,7 @@ module Delayed
             # no other worker is trying to do this right now (and if we abandon the
             # operation, the transaction will end, releasing the advisory lock).
             result = Delayed::Job.attempt_advisory_lock("Delayed::Worker::HealthCheck#reschedule_abandoned_jobs")
-            return unless result
+            next unless result
 
             horizon = 5.minutes.ago
 

data/spec/active_record_job_spec.rb

@@ -28,13 +28,13 @@ describe "Delayed::Backed::ActiveRecord::Job" do
 
     it "does not allow a second worker to get exclusive access if already successfully processed by worker1" do
       @job.destroy
-      expect(@job_copy_for_worker2.send(:lock_exclusively!, "worker2")).to eq(false)
+      expect(@job_copy_for_worker2.send(:lock_exclusively!, "worker2")).to be(false)
     end
 
     it "doesn't allow a second worker to get exclusive access if failed to be " \
        "processed by worker1 and run_at time is now in future (due to backing off behaviour)" do
       @job.update(attempts: 1, run_at: 1.day.from_now)
-      expect(@job_copy_for_worker2.send(:lock_exclusively!, "worker2")).to eq(false)
+      expect(@job_copy_for_worker2.send(:lock_exclusively!, "worker2")).to be(false)
     end
 
     it "selects the next job at random if enabled" do
@@ -55,13 +55,13 @@ describe "Delayed::Backed::ActiveRecord::Job" do
 
   it "unlocks a successfully locked job and persist the job's unlocked state" do
     job = Delayed::Job.create payload_object: SimpleJob.new
-    expect(job.send(:lock_exclusively!, "worker1")).to eq(true)
+    expect(job.send(:lock_exclusively!, "worker1")).to be(true)
     job.reload
     job.unlock
     job.save!
     job.reload
-    expect(job.locked_by).to eq(nil)
-    expect(job.locked_at).to eq(nil)
+    expect(job.locked_by).to be_nil
+    expect(job.locked_at).to be_nil
   end
 
   describe "bulk_update failed jobs" do
@@ -85,7 +85,7 @@ describe "Delayed::Backed::ActiveRecord::Job" do
       before do
         2.times do
           j = Delayed::Job.create(payload_object: SimpleJob.new)
-          expect(j.send(:lock_exclusively!, "worker1")).to eq(true)
+          expect(j.send(:lock_exclusively!, "worker1")).to be(true)
           j.fail!
         end
       end
@@ -100,6 +100,15 @@ describe "Delayed::Backed::ActiveRecord::Job" do
         failed_count = Delayed::Job::Failed.count
         expect(Delayed::Job.bulk_update("destroy", flavor: "failed", query: @query)).to eq(failed_count)
       end
+
+      it "deletes all failed jobs before a given date" do
+        Delayed::Job::Failed.first.update!(failed_at: 3.hours.ago)
+        Delayed::Job::Failed.last.update!(failed_at: 1.hour.ago)
+
+        expect(Delayed::Job::Failed.count).to eq 2
+        Delayed::Job::Failed.cleanup_old_jobs(2.hours.ago)
+        expect(Delayed::Job::Failed.count).to eq 1
+      end
     end
   end
 
@@ -170,13 +179,13 @@ describe "Delayed::Backed::ActiveRecord::Job" do
       it "sets one job as next_in_strand at a time with max_concurrent of 1" do
         job1 = Delayed::Job.enqueue(SimpleJob.new, n_strand: ["njobs"])
         job1.reload
-        expect(job1.next_in_strand).to eq(true)
+        expect(job1.next_in_strand).to be(true)
         job2 = Delayed::Job.enqueue(SimpleJob.new, n_strand: ["njobs"])
         job2.reload
-        expect(job2.next_in_strand).to eq(false)
+        expect(job2.next_in_strand).to be(false)
         run_job(job1)
         job2.reload
-        expect(job2.next_in_strand).to eq(true)
+        expect(job2.next_in_strand).to be(true)
       end
 
       it "sets multiple jobs as next_in_strand at a time based on max_concurrent" do
@@ -187,16 +196,16 @@ describe "Delayed::Backed::ActiveRecord::Job" do
         }) do
           job1 = Delayed::Job.enqueue(SimpleJob.new, n_strand: ["njobs"])
           job1.reload
-          expect(job1.next_in_strand).to eq(true)
+          expect(job1.next_in_strand).to be(true)
           job2 = Delayed::Job.enqueue(SimpleJob.new, n_strand: ["njobs"])
           job2.reload
-          expect(job2.next_in_strand).to eq(true)
+          expect(job2.next_in_strand).to be(true)
           job3 = Delayed::Job.enqueue(SimpleJob.new, n_strand: ["njobs"])
           job3.reload
-          expect(job3.next_in_strand).to eq(false)
+          expect(job3.next_in_strand).to be(false)
           run_job(job1)
           job3.reload
-          expect(job3.next_in_strand).to eq(true)
+          expect(job3.next_in_strand).to be(true)
         end
       end
     end

data/spec/delayed/work_queue/in_process_spec.rb

@@ -26,6 +26,6 @@ RSpec.describe Delayed::WorkQueue::InProcess do
     end
     job = subject.get_and_lock_next_available(*args)
     expect(job).to eq(:job)
-    expect(called).to eq(true)
+    expect(called).to be(true)
   end
 end

data/spec/delayed/work_queue/parent_process/server_spec.rb

@@ -255,7 +255,7 @@ RSpec.describe Delayed::WorkQueue::ParentProcess::Server do
     subject.run_once
 
     expect(Marshal.load(client)).to eq(job)
-    expect(called).to eq(true)
+    expect(called).to be(true)
   end
 
   it "deletes the correct worker when transferring jobs" do

data/spec/delayed/worker_spec.rb

@@ -81,7 +81,7 @@ describe Delayed::Worker do
       short_log_format = subject.log_job(job, :short)
       expect(short_log_format).to eq("RSpec::Mocks::Double")
       long_format = subject.log_job(job, :long)
-      expect(long_format).to eq("RSpec::Mocks::Double {\"priority\":25,\"attempts\":0,\"created_at\":null,\"tag\":\"RSpec::Mocks::Double#perform\",\"max_attempts\":null,\"strand\":\"test_jobs\",\"source\":null}") # rubocop:disable Layout/LineLength
+      expect(long_format).to eq("RSpec::Mocks::Double {\"priority\":25,\"attempts\":0,\"created_at\":null,\"tag\":\"RSpec::Mocks::Double#perform\",\"max_attempts\":null,\"strand\":\"test_jobs\",\"source\":null,\"singleton\":null}") # rubocop:disable Layout/LineLength
     end
 
     it "logging format can be changed with settings" do

data/spec/shared/delayed_batch.rb

@@ -13,10 +13,10 @@ shared_examples_for "Delayed::Batch" do
       batch_jobs = Delayed::Job.find_available(5)
       regular_jobs = Delayed::Job.list_jobs(:future, 5)
       expect(regular_jobs.size).to eq(1)
-      expect(regular_jobs.first.batch?).to eq(false)
+      expect(regular_jobs.first.batch?).to be(false)
       expect(batch_jobs.size).to eq(1)
       batch_job = batch_jobs.first
-      expect(batch_job.batch?).to eq(true)
+      expect(batch_job.batch?).to be(true)
       expect(batch_job.payload_object.mode).to eq(:serial)
       expect(batch_job.payload_object.jobs.map do |j|
                [j.payload_object.object, j.payload_object.method, j.payload_object.args]
@@ -50,7 +50,7 @@ shared_examples_for "Delayed::Batch" do
       expect(Delayed::Job.jobs_count(:current)).to eq(1)
 
       batch_job = Delayed::Job.find_available(1).first
-      expect(batch_job.batch?).to eq(true)
+      expect(batch_job.batch?).to be(true)
       jobs = batch_job.payload_object.jobs
       expect(jobs.size).to eq(2)
       expect(jobs[0]).to be_new_record

data/spec/shared/delayed_method.rb

@@ -140,7 +140,7 @@ shared_examples_for "random ruby objects" do
         obj.test_method(7, synchronous: true)
         expect(obj.ran).to eq([7])
         obj.ran = nil
-        expect(obj.ran).to eq(nil)
+        expect(obj.ran).to be_nil
         obj.test_method(8, 9, synchronous: true)
         expect(obj.ran).to eq([8, 9])
       end

data/spec/shared/shared_backend.rb

@@ -233,7 +233,7 @@ shared_examples_for "a backend" do
   describe "#transfer_lock" do
     it "works" do
       job = create_job(locked_by: "worker", locked_at: Delayed::Job.db_time_now)
-      expect(job.transfer_lock!(from: "worker", to: "worker2")).to eq true
+      expect(job.transfer_lock!(from: "worker", to: "worker2")).to be true
       expect(Delayed::Job.find(job.id).locked_by).to eq "worker2"
     end
   end
@@ -243,13 +243,13 @@ shared_examples_for "a backend" do
       job1 = create_job(strand: "myjobs")
       job2 = create_job(strand: "myjobs")
       expect(Delayed::Job.get_and_lock_next_available("w1")).to eq(job1)
-      expect(Delayed::Job.get_and_lock_next_available("w2")).to eq(nil)
+      expect(Delayed::Job.get_and_lock_next_available("w2")).to be_nil
       job1.destroy
       # update time since the failed lock pushed it forward
       job2.run_at = 1.minute.ago
       job2.save!
       expect(Delayed::Job.get_and_lock_next_available("w3")).to eq(job2)
-      expect(Delayed::Job.get_and_lock_next_available("w4")).to eq(nil)
+      expect(Delayed::Job.get_and_lock_next_available("w4")).to be_nil
     end
 
     it "fails to lock if an earlier job gets locked" do
@@ -301,7 +301,7 @@ shared_examples_for "a backend" do
       locked = [Delayed::Job.get_and_lock_next_available("w1"),
                 Delayed::Job.get_and_lock_next_available("w2")]
       expect(jobs).to eq locked
-      expect(Delayed::Job.get_and_lock_next_available("w3")).to eq(nil)
+      expect(Delayed::Job.get_and_lock_next_available("w3")).to be_nil
     end
 
     it "does not interfere with jobs in other strands" do
@@ -309,7 +309,7 @@ shared_examples_for "a backend" do
       locked = [Delayed::Job.get_and_lock_next_available("w1"),
                 Delayed::Job.get_and_lock_next_available("w2")]
       expect(jobs).to eq locked
-      expect(Delayed::Job.get_and_lock_next_available("w3")).to eq(nil)
+      expect(Delayed::Job.get_and_lock_next_available("w3")).to be_nil
     end
 
     it "does not find next jobs when given no priority" do
@@ -317,7 +317,7 @@ shared_examples_for "a backend" do
       first = Delayed::Job.get_and_lock_next_available("w1", Delayed::Settings.queue, nil, nil)
       second = Delayed::Job.get_and_lock_next_available("w2", Delayed::Settings.queue, nil, nil)
       expect(first).to eq jobs.first
-      expect(second).to eq nil
+      expect(second).to be_nil
     end
 
     it "complains if you pass more than one strand-based option" do
@@ -389,7 +389,7 @@ shared_examples_for "a backend" do
         expect(job1.reload.handler).to include("ErrorJob")
       end
 
-      context "next_in_strand management - deadlocks and race conditions", non_transactional: true do
+      context "next_in_strand management - deadlocks and race conditions", non_transactional: true, slow: true do
         # The following unit tests are fairly slow and non-deterministic. It may be
         # easier to make them fail quicker and more consistently by adding a random
         # sleep into the appropriate trigger(s).
@@ -538,11 +538,11 @@ shared_examples_for "a backend" do
           Delayed::Job.get_and_lock_next_available("w1")
           @job2 = create_job(singleton: "myjobs")
 
-          expect(@job1.reload.next_in_strand).to eq true
-          expect(@job2.reload.next_in_strand).to eq false
+          expect(@job1.reload.next_in_strand).to be true
+          expect(@job2.reload.next_in_strand).to be false
 
           @job1.destroy
-          expect(@job2.reload.next_in_strand).to eq true
+          expect(@job2.reload.next_in_strand).to be true
         end
 
         it "handles transitions correctly when going from not stranded to stranded" do
@@ -552,13 +552,13 @@ shared_examples_for "a backend" do
           Delayed::Job.get_and_lock_next_available("w1")
           @job3 = create_job(singleton: "myjobs", strand: "myjobs2")
 
-          expect(@job1.reload.next_in_strand).to eq true
-          expect(@job2.reload.next_in_strand).to eq true
-          expect(@job3.reload.next_in_strand).to eq false
+          expect(@job1.reload.next_in_strand).to be true
+          expect(@job2.reload.next_in_strand).to be true
+          expect(@job3.reload.next_in_strand).to be false
 
           @job2.destroy
-          expect(@job1.reload.next_in_strand).to eq true
-          expect(@job3.reload.next_in_strand).to eq true
+          expect(@job1.reload.next_in_strand).to be true
+          expect(@job3.reload.next_in_strand).to be true
         end
 
         it "does not violate n_strand=1 constraints when going from not stranded to stranded" do
@@ -568,13 +568,13 @@ shared_examples_for "a backend" do
           Delayed::Job.get_and_lock_next_available("w1")
           @job3 = create_job(singleton: "myjobs", strand: "myjobs")
 
-          expect(@job1.reload.next_in_strand).to eq true
-          expect(@job2.reload.next_in_strand).to eq true
-          expect(@job3.reload.next_in_strand).to eq false
+          expect(@job1.reload.next_in_strand).to be true
+          expect(@job2.reload.next_in_strand).to be true
+          expect(@job3.reload.next_in_strand).to be false
 
           @job2.destroy
-          expect(@job1.reload.next_in_strand).to eq true
-          expect(@job3.reload.next_in_strand).to eq false
+          expect(@job1.reload.next_in_strand).to be true
+          expect(@job3.reload.next_in_strand).to be false
         end
 
         it "handles transitions correctly when going from stranded to another strand" do
@@ -582,11 +582,11 @@ shared_examples_for "a backend" do
           Delayed::Job.get_and_lock_next_available("w1")
           @job2 = create_job(singleton: "myjobs", strand: "myjobs2")
 
-          expect(@job1.reload.next_in_strand).to eq true
-          expect(@job2.reload.next_in_strand).to eq false
+          expect(@job1.reload.next_in_strand).to be true
+          expect(@job2.reload.next_in_strand).to be false
 
           @job1.destroy
-          expect(@job2.reload.next_in_strand).to eq true
+          expect(@job2.reload.next_in_strand).to be true
         end
 
         it "does not violate n_strand=1 constraints when going from stranded to another strand" do
@@ -596,24 +596,24 @@ shared_examples_for "a backend" do
           Delayed::Job.get_and_lock_next_available("w1")
           @job3 = create_job(singleton: "myjobs", strand: "myjobs2")
 
-          expect(@job1.reload.next_in_strand).to eq true
-          expect(@job2.reload.next_in_strand).to eq true
-          expect(@job3.reload.next_in_strand).to eq false
+          expect(@job1.reload.next_in_strand).to be true
+          expect(@job2.reload.next_in_strand).to be true
+          expect(@job3.reload.next_in_strand).to be false
 
           @job2.destroy
-          expect(@job1.reload.next_in_strand).to eq true
-          expect(@job3.reload.next_in_strand).to eq false
+          expect(@job1.reload.next_in_strand).to be true
+          expect(@job3.reload.next_in_strand).to be false
         end
 
         it "creates first as true, and second as false, then transitions to second when deleted" do
           @job1 = create_job(singleton: "myjobs")
           Delayed::Job.get_and_lock_next_available("w1")
           @job2 = create_job(singleton: "myjobs")
-          expect(@job1.reload.next_in_strand).to eq true
-          expect(@job2.reload.next_in_strand).to eq false
+          expect(@job1.reload.next_in_strand).to be true
+          expect(@job2.reload.next_in_strand).to be false
 
           @job1.destroy
-          expect(@job2.reload.next_in_strand).to eq true
+          expect(@job2.reload.next_in_strand).to be true
         end
 
         it "when combined with a strand" do
@@ -834,9 +834,9 @@ shared_examples_for "a backend" do
 
   it "sets in_delayed_job?" do
     job = InDelayedJobTest.delay(ignore_transaction: true).check_in_job
-    expect(Delayed::Job.in_delayed_job?).to eq(false)
+    expect(Delayed::Job.in_delayed_job?).to be(false)
     job.invoke_job
-    expect(Delayed::Job.in_delayed_job?).to eq(false)
+    expect(Delayed::Job.in_delayed_job?).to be(false)
   end
 
   it "fails on job creation if an unsaved AR object is used" do

data/spec/shared/worker.rb

@@ -244,7 +244,7 @@ shared_examples_for "Delayed::Worker" do
       end
 
       it "is failed if it failed more than Settings.max_attempts times" do
-        expect(@job.failed_at).to eq(nil)
+        expect(@job.failed_at).to be_nil
         Delayed::Settings.max_attempts.times { @job.reschedule }
         expect(Delayed::Job.list_jobs(:failed, 100).size).to eq(1)
       end
@@ -252,7 +252,7 @@ shared_examples_for "Delayed::Worker" do
       it "is not failed if it failed fewer than Settings.max_attempts times" do
         (Delayed::Settings.max_attempts - 1).times { @job.reschedule }
         @job = Delayed::Job.find(@job.id)
-        expect(@job.failed_at).to eq(nil)
+        expect(@job.failed_at).to be_nil
       end
 
       it "is failed if it has expired" do
@@ -396,7 +396,7 @@ shared_examples_for "Delayed::Worker" do
       expect(@worker).to receive(:exit?).and_return(true)
       Delayed::Worker.lifecycle.before(:execute) { |w| w == @worker && fired = true }
       @worker.start
-      expect(fired).to eq(true)
+      expect(fired).to be(true)
     end
   end
 

data/spec/spec_helper.rb

@@ -55,14 +55,16 @@ connection_config = {
   encoding: "utf8",
   username: ENV["TEST_DB_USERNAME"],
   database: ENV["TEST_DB_DATABASE"],
-  min_messages: "notice"
+  min_messages: "notice",
+  # Ensure the pool is big enough the deadlock tests don't get starved for connections by rails instead
+  pool: 20
 }
 
 def migrate(file)
   ActiveRecord::MigrationContext.new(file, ActiveRecord::SchemaMigration).migrate
 end
 
-# create the test db if it does not exist, to help out wwtd
+# create the test db if it does not exist
 ActiveRecord::Base.establish_connection(connection_config.merge(database: "postgres"))
 begin
   ActiveRecord::Base.connection.create_database(connection_config[:database])

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: inst-jobs
 version: !ruby/object:Gem::Version
-  version: 3.0.8
+  version: 3.0.12
 platform: ruby
 authors:
 - Cody Cutrer
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-02-03 00:00:00.000000000 Z
+date: 2022-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -32,14 +32,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: 0.4.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: 0.4.4
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -410,20 +410,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: wwtd
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.4.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.4.0
 description: 
 email:
 - cody@instructure.com
@@ -473,6 +459,7 @@ files:
 - db/migrate/20220128084800_update_insert_trigger_for_singleton_unique_constraint_change.rb
 - db/migrate/20220128084900_update_delete_trigger_for_singleton_unique_constraint_change.rb
 - db/migrate/20220203063200_remove_old_singleton_index.rb
+- db/migrate/20220328152900_add_failed_jobs_indicies.rb
 - exe/inst_jobs
 - lib/delayed/backend/active_record.rb
 - lib/delayed/backend/base.rb
@@ -538,7 +525,8 @@ files:
 - spec/spec_helper.rb
 homepage: https://github.com/instructure/inst-jobs
 licenses: []
-metadata: {}
+metadata:
+  rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -554,7 +542,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: Instructure-maintained fork of delayed_job