switchman-inst-jobs 4.0.12 → 4.0.14

data/db/migrate/20211220113000_fix_singleton_race_condition_delete.rb

@@ -3,7 +3,7 @@
 class FixSingletonRaceConditionDelete < ActiveRecord::Migration[5.2]
   def up
     execute(<<~SQL)
-      CREATE OR REPLACE FUNCTION #{connection.quote_table_name('delayed_jobs_after_delete_row_tr_fn')} () RETURNS trigger AS $$
+      CREATE OR REPLACE FUNCTION #{connection.quote_table_name("delayed_jobs_after_delete_row_tr_fn")} () RETURNS trigger AS $$
       DECLARE
         next_strand varchar;
         running_count integer;
@@ -106,7 +106,7 @@ class FixSingletonRaceConditionDelete < ActiveRecord::Migration[5.2]
 
   def down
     execute(<<~SQL)
-      CREATE OR REPLACE FUNCTION #{connection.quote_table_name('delayed_jobs_after_delete_row_tr_fn')} () RETURNS trigger AS $$
+      CREATE OR REPLACE FUNCTION #{connection.quote_table_name("delayed_jobs_after_delete_row_tr_fn")} () RETURNS trigger AS $$
       DECLARE
         next_strand varchar;
         running_count integer;

data/db/migrate/20220127091200_fix_singleton_unique_constraint.rb

@@ -4,15 +4,15 @@ class FixSingletonUniqueConstraint < ActiveRecord::Migration[5.2]
   disable_ddl_transaction!
 
   def up
-    rename_index :delayed_jobs, 'index_delayed_jobs_on_singleton_not_running', 'index_delayed_jobs_on_singleton_not_running_old'
-    rename_index :delayed_jobs, 'index_delayed_jobs_on_singleton_running', 'index_delayed_jobs_on_singleton_running_old'
+    rename_index :delayed_jobs, "index_delayed_jobs_on_singleton_not_running", "index_delayed_jobs_on_singleton_not_running_old"
+    rename_index :delayed_jobs, "index_delayed_jobs_on_singleton_running", "index_delayed_jobs_on_singleton_running_old"
 
     # only one job can be queued in a singleton
     add_index :delayed_jobs,
               :singleton,
               where: "singleton IS NOT NULL AND (locked_by IS NULL OR locked_by = '#{::Delayed::Backend::Base::ON_HOLD_LOCKED_BY}')",
               unique: true,
-              name: 'index_delayed_jobs_on_singleton_not_running',
+              name: "index_delayed_jobs_on_singleton_not_running",
               algorithm: :concurrently
 
     # only one job can be running for a singleton
@@ -20,12 +20,12 @@ class FixSingletonUniqueConstraint < ActiveRecord::Migration[5.2]
               :singleton,
               where: "singleton IS NOT NULL AND locked_by IS NOT NULL AND locked_by <> '#{::Delayed::Backend::Base::ON_HOLD_LOCKED_BY}'",
               unique: true,
-              name: 'index_delayed_jobs_on_singleton_running',
+              name: "index_delayed_jobs_on_singleton_running",
               algorithm: :concurrently
   end
 
   def down
-    remove_index :delayed_jobs, name: 'index_delayed_jobs_on_singleton_not_running_old'
-    remove_index :delayed_jobs, name: 'index_delayed_jobs_on_singleton_running_old'
+    remove_index :delayed_jobs, name: "index_delayed_jobs_on_singleton_not_running_old"
+    remove_index :delayed_jobs, name: "index_delayed_jobs_on_singleton_running_old"
   end
 end

data/db/migrate/20220128084800_update_insert_trigger_for_singleton_unique_constraint_change.rb

@@ -5,7 +5,7 @@ class UpdateInsertTriggerForSingletonUniqueConstraintChange < ActiveRecord::Migr
     reversible do |direction|
       direction.up do
         execute(<<~SQL)
-          CREATE OR REPLACE FUNCTION #{connection.quote_table_name('delayed_jobs_before_insert_row_tr_fn')} () RETURNS trigger AS $$
+          CREATE OR REPLACE FUNCTION #{connection.quote_table_name("delayed_jobs_before_insert_row_tr_fn")} () RETURNS trigger AS $$
           BEGIN
             IF NEW.strand IS NOT NULL THEN
               PERFORM pg_advisory_xact_lock(half_md5_as_bigint(NEW.strand));
@@ -31,7 +31,7 @@ class UpdateInsertTriggerForSingletonUniqueConstraintChange < ActiveRecord::Migr
       end
       direction.down do
         execute(<<~SQL)
-          CREATE OR REPLACE FUNCTION #{connection.quote_table_name('delayed_jobs_before_insert_row_tr_fn')} () RETURNS trigger AS $$
+          CREATE OR REPLACE FUNCTION #{connection.quote_table_name("delayed_jobs_before_insert_row_tr_fn")} () RETURNS trigger AS $$
           BEGIN
             IF NEW.strand IS NOT NULL THEN
               PERFORM pg_advisory_xact_lock(half_md5_as_bigint(NEW.strand));

data/db/migrate/20220128084900_update_delete_trigger_for_singleton_unique_constraint_change.rb

@@ -3,7 +3,7 @@
 class UpdateDeleteTriggerForSingletonUniqueConstraintChange < ActiveRecord::Migration[5.2]
   def up
     execute(<<~SQL)
-      CREATE OR REPLACE FUNCTION #{connection.quote_table_name('delayed_jobs_after_delete_row_tr_fn')} () RETURNS trigger AS $$
+      CREATE OR REPLACE FUNCTION #{connection.quote_table_name("delayed_jobs_after_delete_row_tr_fn")} () RETURNS trigger AS $$
       DECLARE
         next_strand varchar;
         running_count integer;
@@ -106,7 +106,7 @@ class UpdateDeleteTriggerForSingletonUniqueConstraintChange < ActiveRecord::Migr
 
   def down
     execute(<<~SQL)
-      CREATE OR REPLACE FUNCTION #{connection.quote_table_name('delayed_jobs_after_delete_row_tr_fn')} () RETURNS trigger AS $$
+      CREATE OR REPLACE FUNCTION #{connection.quote_table_name("delayed_jobs_after_delete_row_tr_fn")} () RETURNS trigger AS $$
       DECLARE
         next_strand varchar;
         running_count integer;

data/db/migrate/20220203063200_remove_old_singleton_index.rb

@@ -4,28 +4,28 @@ class RemoveOldSingletonIndex < ActiveRecord::Migration[5.2]
   disable_ddl_transaction!
 
   def up
-    remove_index :delayed_jobs, name: 'index_delayed_jobs_on_singleton_not_running_old'
-    remove_index :delayed_jobs, name: 'index_delayed_jobs_on_singleton_running_old'
+    remove_index :delayed_jobs, name: "index_delayed_jobs_on_singleton_not_running_old"
+    remove_index :delayed_jobs, name: "index_delayed_jobs_on_singleton_running_old"
   end
 
   def down
-    rename_index :delayed_jobs, 'index_delayed_jobs_on_singleton_not_running', 'index_delayed_jobs_on_singleton_not_running_old'
-    rename_index :delayed_jobs, 'index_delayed_jobs_on_singleton_running', 'index_delayed_jobs_on_singleton_running_old'
+    rename_index :delayed_jobs, "index_delayed_jobs_on_singleton_not_running", "index_delayed_jobs_on_singleton_not_running_old"
+    rename_index :delayed_jobs, "index_delayed_jobs_on_singleton_running", "index_delayed_jobs_on_singleton_running_old"
 
     # only one job can be queued in a singleton
     add_index :delayed_jobs,
               :singleton,
-              where: 'singleton IS NOT NULL AND locked_by IS NULL',
+              where: "singleton IS NOT NULL AND locked_by IS NULL",
               unique: true,
-              name: 'index_delayed_jobs_on_singleton_not_running',
+              name: "index_delayed_jobs_on_singleton_not_running",
               algorithm: :concurrently
 
     # only one job can be running for a singleton
     add_index :delayed_jobs,
               :singleton,
-              where: 'singleton IS NOT NULL AND locked_by IS NOT NULL',
+              where: "singleton IS NOT NULL AND locked_by IS NOT NULL",
               unique: true,
-              name: 'index_delayed_jobs_on_singleton_running',
+              name: "index_delayed_jobs_on_singleton_running",
               algorithm: :concurrently
   end
 end

data/db/migrate/20220328152900_add_failed_jobs_indicies.rb

@@ -5,8 +5,8 @@ class AddFailedJobsIndicies < ActiveRecord::Migration[5.2]
 
   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, :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/switchman-inst-jobs.rb

@@ -1 +1,3 @@
-require 'switchman_inst_jobs'
+# frozen_string_literal: true
+
+require "switchman_inst_jobs"

data/lib/switchman_inst_jobs/active_record/connection_adapters/postgresql_adapter.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module SwitchmanInstJobs
   module ActiveRecord
     module ConnectionAdapters
       module PostgreSQLAdapter
-        def set_search_path(function, args = '()', path = ::Switchman::Shard.current.name)
+        def set_search_path(function, args = "()", path = ::Switchman::Shard.current.name)
           execute <<-SQL
             ALTER FUNCTION #{quote_table_name(function)}#{args}
               SET search_path TO #{path}

data/lib/switchman_inst_jobs/active_record/migration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SwitchmanInstJobs
   module ActiveRecord
     module Migration
@@ -19,10 +21,10 @@ module SwitchmanInstJobs
       end
 
       def copy(destination, sources, options = {})
-        if sources.delete('delayed_engine')
+        if sources.delete("delayed_engine")
           # rubocop:disable Rails/Output
-          puts 'NOTE: Not installing delayed_engine migrations in an application using switchman-inst-jobs'
-          puts '(use rake switchman_inst_jobs:install:migrations instead)'
+          puts "NOTE: Not installing delayed_engine migrations in an application using switchman-inst-jobs"
+          puts "(use rake switchman_inst_jobs:install:migrations instead)"
           # rubocop:enable Rails/Output
         end
         super

data/lib/switchman_inst_jobs/delayed/backend/active_record/abstract_job.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SwitchmanInstJobs
   module Delayed
     module Backend

data/lib/switchman_inst_jobs/delayed/backend/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SwitchmanInstJobs
   class ShardNotFoundError < RuntimeError
     attr_reader :shard_id
@@ -65,7 +67,7 @@ module SwitchmanInstJobs
 
         def self.prepended(base)
           base.singleton_class.prepend(ClassMethods)
-          return unless base.name == 'Delayed::Backend::ActiveRecord::Job'
+          return unless base.name == "Delayed::Backend::ActiveRecord::Job"
 
           ::Delayed::Backend::ActiveRecord::AbstractJob.sharded_model
         end
@@ -79,7 +81,7 @@ module SwitchmanInstJobs
           self.shard_id = shard.id
           self.shard_id = nil if shard.is_a?(::Switchman::DefaultShard)
           # If jobs are held for a shard, enqueue new ones as held as well
-          return unless ::Switchman::Shard.columns_hash.key?('jobs_held') && shard.jobs_held
+          return unless ::Switchman::Shard.columns_hash.key?("jobs_held") && shard.jobs_held
 
           self.locked_by = ::Delayed::Backend::Base::ON_HOLD_LOCKED_BY
           self.locked_at = ::Delayed::Job.db_time_now
@@ -92,6 +94,12 @@ module SwitchmanInstJobs
           current_shard.activate { super }
         end
 
+        def invoke_payload_object_cb(...)
+          raise ShardNotFoundError, shard_id unless current_shard
+
+          current_shard.activate { super }
+        end
+
         def deserialize(source)
           raise ShardNotFoundError, shard_id unless current_shard
 

data/lib/switchman_inst_jobs/delayed/message_sending.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SwitchmanInstJobs
   module Delayed
     module MessageSending

data/lib/switchman_inst_jobs/delayed/pool.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SwitchmanInstJobs
   module Delayed
     module Pool

data/lib/switchman_inst_jobs/delayed/settings.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module SwitchmanInstJobs
   module Delayed
     module Settings
       def self.configured_shard_ids
-        (::Delayed::Settings.worker_config.try(:[], 'workers') || []).map { |w| w['shard'] }.compact.uniq
+        (::Delayed::Settings.worker_config.try(:[], "workers") || []).pluck("shard").compact.uniq
       end
     end
   end

data/lib/switchman_inst_jobs/delayed/worker/health_check.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SwitchmanInstJobs
   module Delayed
     module Worker
@@ -9,13 +11,13 @@ module SwitchmanInstJobs
         module ClassMethods
           def munge_service_name(shard)
             # munge the name to add the current shard
-            original_service_name = ::Delayed::Settings.worker_health_check_config['service_name']
+            original_service_name = ::Delayed::Settings.worker_health_check_config["service_name"]
             consul_service_name = ::Delayed::Worker::ConsulHealthCheck::DEFAULT_SERVICE_NAME
-            ::Delayed::Settings.worker_health_check_config['service_name'] =
+            ::Delayed::Settings.worker_health_check_config["service_name"] =
               "#{original_service_name || consul_service_name}/#{shard.id}"
             yield
           ensure
-            ::Delayed::Settings.worker_health_check_config['service_name'] = original_service_name
+            ::Delayed::Settings.worker_health_check_config["service_name"] = original_service_name
           end
 
           def reschedule_abandoned_jobs

data/lib/switchman_inst_jobs/delayed/worker.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SwitchmanInstJobs
   module Delayed
     module Worker

data/lib/switchman_inst_jobs/engine.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 module SwitchmanInstJobs
   class Engine < ::Rails::Engine
     isolate_namespace SwitchmanInstJobs
 
-    initializer 'sharding.active_record', after: 'switchman.extend_connection_adapters' do
+    initializer "sharding.active_record", after: "switchman.extend_connection_adapters" do
       SwitchmanInstJobs.initialize_active_record
     end
 
-    initializer 'sharding.delayed' do
+    initializer "sharding.delayed" do
       SwitchmanInstJobs.initialize_inst_jobs
 
       ::Delayed::Worker.lifecycle.around(:work_queue_pop) do |worker, config, &block|
@@ -29,7 +31,7 @@ module SwitchmanInstJobs
             current_job_shard = ::Switchman::Shard.lookup(job.shard_id).delayed_jobs_shard
             if current_job_shard != ::Switchman::Shard.current(::Delayed::Backend::ActiveRecord::AbstractJob)
               current_job_shard.activate(::Delayed::Backend::ActiveRecord::AbstractJob) do
-                ::Delayed::Job.where(source: 'JobsMigrator::StrandBlocker', **{ column => job.try(column) }).delete_all
+                ::Delayed::Job.where(source: "JobsMigrator::StrandBlocker", **{ column => job.try(column) }).delete_all
 
                 j = ::Delayed::Job.where(**{ column => job.try(column) }).next_in_strand_order.first
                 j.update_column(:next_in_strand, true) if j && !j.next_in_strand
@@ -40,11 +42,11 @@ module SwitchmanInstJobs
       end
     end
 
-    initializer 'sharding.guard_rail', after: 'switchman.extend_guard_rail' do
+    initializer "sharding.guard_rail", after: "switchman.extend_guard_rail" do
       SwitchmanInstJobs.initialize_guard_rail
     end
 
-    initializer 'sharding.switchman' do
+    initializer "sharding.switchman" do
       SwitchmanInstJobs.initialize_switchman
     end
 

data/lib/switchman_inst_jobs/guard_rail.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SwitchmanInstJobs
   module GuardRail
     module ClassMethods

data/lib/switchman_inst_jobs/jobs_migrator.rb

@@ -1,5 +1,7 @@
-require 'set'
-require 'parallel'
+# frozen_string_literal: true
+
+require "set"
+require "parallel"
 
 module SwitchmanInstJobs
   class JobsMigrator
@@ -50,7 +52,7 @@ module SwitchmanInstJobs
         # Do the updates in batches and then just clear redis instead of clearing them one at a time
         target_shards.each do |target_shard, shards|
           updates = { delayed_jobs_shard_id: target_shard, block_stranded: true }
-          updates[:updated_at] = Time.zone.now if ::Switchman::Shard.column_names.include?('updated_at')
+          updates[:updated_at] = Time.zone.now if ::Switchman::Shard.column_names.include?("updated_at")
           ::Switchman::Shard.where(id: shards).update_all(updates)
         end
         clear_shard_cache(default: ::Switchman::Shard.exists?(id: target_shards.values.flatten, default: true))
@@ -85,8 +87,8 @@ module SwitchmanInstJobs
       end
 
       def clear_shard_cache(debug_message = nil, default:)
-        ::Switchman.cache.delete_matched('shard/*')
-        ::Switchman.cache.delete('default_shard') if default
+        ::Switchman.cache.delete_matched("shard/*")
+        ::Switchman.cache.delete("default_shard") if default
         Rails.logger.debug { "Waiting for caches to clear #{debug_message}" }
         # Wait a little over the 60 second in-process shard cache clearing
         # threshold to ensure that all new stranded jobs are now being
@@ -96,9 +98,9 @@ module SwitchmanInstJobs
       end
 
       def acquire_advisory_lock(type, name)
-        @quoted_function_name ||= ::Delayed::Job.connection.quote_table_name('half_md5_as_bigint')
+        @quoted_function_name ||= ::Delayed::Job.connection.quote_table_name("half_md5_as_bigint")
 
-        value = type == :singleton ? "singleton:#{name}" : name
+        value = (type == :singleton) ? "singleton:#{name}" : name
         ::Delayed::Job.connection.execute(
           ::Delayed::Job.sanitize_sql_for_conditions(
             ["SELECT pg_advisory_xact_lock(#{@quoted_function_name}(?))", value]
@@ -162,8 +164,8 @@ module SwitchmanInstJobs
 
                     # the rest of 3) is taken care of here
                     # make sure that all the jobs moved over are NOT next in strand
-                    ::Delayed::Job.where(next_in_strand: true, locked_by: nil, **{ column => value }).
-                      update_all(next_in_strand: false)
+                    ::Delayed::Job.where(next_in_strand: true, locked_by: nil, **{ column => value })
+                                  .update_all(next_in_strand: false)
                   end
 
                   # 4) is taken care of here, by leaving next_in_strand alone and
@@ -184,8 +186,8 @@ module SwitchmanInstJobs
         }
 
         strand_scope = ::Delayed::Job.shard(source_shard).where.not(strand: nil)
-        singleton_scope = ::Delayed::Job.shard(source_shard).where('strand IS NULL AND singleton IS NOT NULL')
-        all_scope = ::Delayed::Job.shard(source_shard).where('strand IS NOT NULL OR singleton IS NOT NULL')
+        singleton_scope = ::Delayed::Job.shard(source_shard).where("strand IS NULL AND singleton IS NOT NULL")
+        all_scope = ::Delayed::Job.shard(source_shard).where("strand IS NOT NULL OR singleton IS NOT NULL")
 
         singleton_blocker_additional_kwargs = {
           locked_at: DateTime.now,
@@ -206,8 +208,8 @@ module SwitchmanInstJobs
         shard_map = build_shard_map(all_scope, source_shard)
         shard_map.each do |(target_shard, source_shard_ids)|
           target_shard.activate(::Delayed::Backend::ActiveRecord::AbstractJob) do
-            updated = ::Switchman::Shard.where(id: source_shard_ids, block_stranded: true).
-              update_all(block_stranded: false)
+            updated = ::Switchman::Shard.where(id: source_shard_ids, block_stranded: true)
+                                        .update_all(block_stranded: false)
             # If this is being manually re-run for some reason to clean something up, don't wait for nothing to happen
             unless updated.zero?
               clear_shard_cache("(#{source_shard.id} -> #{target_shard.id})",
@@ -227,16 +229,16 @@ module SwitchmanInstJobs
       def unblock_strands(target_shard, batch_size: 10_000)
         blocked_shard_ids = blocked_shards.pluck(:id)
         query = lambda { |column, scope|
-          ::Delayed::Job.
-            where(id: ::Delayed::Job.select("DISTINCT ON (#{column}) id").
-              where(scope).
-              where.not(shard_id: blocked_shard_ids).
-              where(
-                ::Delayed::Job.select(1).from("#{::Delayed::Job.quoted_table_name} dj2").
-                where("dj2.next_in_strand = true OR dj2.source = 'JobsMigrator::StrandBlocker'").
-                where("dj2.#{column} = delayed_jobs.#{column}").arel.exists.not
-              ).
-              order(column, :strand_order_override, :id)).limit(batch_size)
+          ::Delayed::Job
+            .where(id: ::Delayed::Job.select("DISTINCT ON (#{column}) id")
+              .where(scope)
+              .where.not(shard_id: blocked_shard_ids)
+              .where(
+                ::Delayed::Job.select(1).from("#{::Delayed::Job.quoted_table_name} dj2")
+                .where("dj2.next_in_strand = true OR dj2.source = 'JobsMigrator::StrandBlocker'")
+                .where("dj2.#{column} = delayed_jobs.#{column}").arel.exists.not
+              )
+              .order(column, :strand_order_override, :id)).limit(batch_size)
         }
 
         target_shard.activate(::Delayed::Backend::ActiveRecord::AbstractJob) do
@@ -247,12 +249,12 @@ module SwitchmanInstJobs
           # batches
 
           loop do
-            break if query.call(:strand, 'strand IS NOT NULL').update_all(next_in_strand: true).zero?
+            break if query.call(:strand, "strand IS NOT NULL").update_all(next_in_strand: true).zero?
           end
 
           loop do
             break if query.call(:singleton,
-                                'strand IS NULL AND singleton IS NOT NULL').update_all(next_in_strand: true).zero?
+                                "strand IS NULL AND singleton IS NOT NULL").update_all(next_in_strand: true).zero?
           end
         end
       end
@@ -277,16 +279,15 @@ module SwitchmanInstJobs
       end
 
       def blocked_by_migrator?(job_scope)
-        job_scope.exists?(source: 'JobsMigrator::StrandBlocker') ||
+        job_scope.exists?(source: "JobsMigrator::StrandBlocker") ||
           blocked_shards.exists?(id: job_scope.distinct.pluck(:shard_id))
       end
 
       def blocked_strands
-        ::Delayed::Job.
-          where.not(strand: nil).
-          group(:strand).
-          having('NOT BOOL_OR(next_in_strand)').
-          pluck(:strand)
+        ::Delayed::Job
+          .where.not(strand: nil)
+          .group(:strand)
+          .having("NOT BOOL_OR(next_in_strand)")
       end
 
       def unblock_strand!(strand, new_parallelism: nil)
@@ -296,13 +297,14 @@ module SwitchmanInstJobs
         ::Delayed::Job.transaction do
           acquire_advisory_lock(:strand, strand)
 
-          new_parallelism ||= job_scope.pick('MAX(max_concurrent)')
+          new_parallelism ||= job_scope.pick("MAX(max_concurrent)")
           if new_parallelism
             needed_jobs = new_parallelism - job_scope.where(next_in_strand: true).count
             if needed_jobs.positive?
-              job_scope.where(next_in_strand: false, locked_by: nil,
-                              singleton: nil).order(:strand_order_override, :id).
-                limit(needed_jobs).update_all(next_in_strand: true)
+              job_scope.where(next_in_strand: false,
+                              locked_by: nil,
+                              singleton: nil).order(:strand_order_override, :id)
+                       .limit(needed_jobs).update_all(next_in_strand: true)
             else
               0
             end
@@ -311,12 +313,11 @@ module SwitchmanInstJobs
       end
 
       def blocked_singletons
-        ::Delayed::Job.
-          where(strand: nil).
-          where.not(singleton: nil).
-          group(:singleton).
-          having('NOT BOOL_OR(next_in_strand)').
-          pluck(:singleton)
+        ::Delayed::Job
+          .where(strand: nil)
+          .where.not(singleton: nil)
+          .group(:singleton)
+          .having("NOT BOOL_OR(next_in_strand)")
       end
 
       def unblock_singleton!(singleton)
@@ -326,9 +327,9 @@ module SwitchmanInstJobs
         ::Delayed::Job.transaction do
           acquire_advisory_lock(:singleton, singleton)
 
-          id, next_in_strand = job_scope.
-            group(:singleton).
-            pick('MIN(id), BOOL_OR(next_in_strand)')
+          id, next_in_strand = job_scope
+                               .group(:singleton)
+                               .pick("MIN(id), BOOL_OR(next_in_strand)")
 
           if next_in_strand
             0
@@ -338,13 +339,19 @@ module SwitchmanInstJobs
         end
       end
 
+      def blocked_job_count
+        ::Delayed::Job.from(blocked_strands.select("count(id) AS ssize")).sum("ssize").to_i +
+          ::Delayed::Job.from(blocked_singletons.select("count(id) AS ssize")).sum("ssize").to_i +
+          ::Delayed::Job.where(strand: nil, singleton: nil, next_in_strand: false).count
+      end
+
       private
 
       def create_blocker_job(**kwargs)
         first_job = ::Delayed::Job.create!(**kwargs, next_in_strand: false)
         first_job.payload_object = ::Delayed::PerformableMethod.new(Kernel, :sleep, args: [0])
-        first_job.tag = 'Kernel.sleep'
-        first_job.source = 'JobsMigrator::StrandBlocker'
+        first_job.tag = "Kernel.sleep"
+        first_job.source = "JobsMigrator::StrandBlocker"
         first_job.max_attempts = 1
         # If we ever have jobs left over from 9999 jobs moves of a single shard,
         # something has gone terribly wrong
@@ -369,7 +376,7 @@ module SwitchmanInstJobs
       def batch_move_jobs(target_shard:, source_shard:, scope:, batch_size:)
         while scope.exists?
           # Adapted from get_and_lock_next_available in delayed/backend/active_record.rb
-          target_jobs = scope.limit(batch_size).lock('FOR UPDATE SKIP LOCKED')
+          target_jobs = scope.limit(batch_size).lock("FOR UPDATE SKIP LOCKED")
 
           query = source_shard.activate(::Delayed::Backend::ActiveRecord::AbstractJob) do
             <<~SQL
@@ -416,23 +423,23 @@ module SwitchmanInstJobs
       # Once we stop supporting rails 5.2 we can just use insert_all from activerecord
       def bulk_insert_jobs(objects)
         records = objects.map do |object|
-          object.attributes.map do |(name, value)|
+          object.attributes.filter_map do |(name, value)|
             next if name == ::Delayed::Job.primary_key
 
             if (type = ::Delayed::Job.attribute_types[name]).is_a?(::ActiveRecord::Type::Serialized)
               value = type.serialize(value)
             end
             [name, value]
-          end.compact.to_h
+          end.to_h
         end
-        return if records.length.zero?
+        return if records.empty?
 
         keys = records.first.keys
 
         connection = ::Delayed::Job.connection
-        quoted_keys = keys.map { |k| connection.quote_column_name(k) }.join(', ')
+        quoted_keys = keys.map { |k| connection.quote_column_name(k) }.join(", ")
 
-        connection.execute 'DROP TABLE IF EXISTS delayed_jobs_bulk_copy'
+        connection.execute "DROP TABLE IF EXISTS delayed_jobs_bulk_copy"
         connection.execute "CREATE TEMPORARY TABLE delayed_jobs_bulk_copy
           (LIKE #{::Delayed::Job.quoted_table_name} INCLUDING DEFAULTS)"
         connection.execute "COPY delayed_jobs_bulk_copy (#{quoted_keys}) FROM STDIN"
@@ -444,8 +451,8 @@ module SwitchmanInstJobs
         result = connection.raw_connection.get_result
         begin
           result.check
-        rescue StandardError => e
-          raise connection.send(:translate_exception, e, 'COPY FROM STDIN')
+        rescue => e
+          raise connection.send(:translate_exception, e, "COPY FROM STDIN")
         end
         connection.execute "INSERT INTO #{::Delayed::Job.quoted_table_name} (#{quoted_keys})
           SELECT #{quoted_keys} FROM delayed_jobs_bulk_copy
@@ -460,7 +467,7 @@ module SwitchmanInstJobs
         elsif value.is_a?(::ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array::Data)
           quote_text(encode_array(value))
         else
-          hash = { "\n" => '\\n', "\r" => '\\r', "\t" => '\\t', '\\' => '\\\\' }
+          hash = { "\n" => '\\n', "\r" => '\\r', "\t" => '\\t', "\\" => "\\\\" }
           value.to_s.gsub(/[\n\r\t\\]/) { |c| hash[c] }
         end
       end

data/lib/switchman_inst_jobs/new_relic.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SwitchmanInstJobs
   module NewRelic
     module FixNewRelicDelayedJobs

data/lib/switchman_inst_jobs/switchman/database_server.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module SwitchmanInstJobs
   module Switchman
     module DatabaseServer
       def delayed_jobs_shard(shard = nil)
-        return shard if config[:delayed_jobs_shard] == 'self'
+        return shard if config[:delayed_jobs_shard] == "self"
 
         dj_shard =
           config[:delayed_jobs_shard] &&

data/lib/switchman_inst_jobs/switchman/default_shard.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SwitchmanInstJobs
   module Switchman
     module DefaultShard