inst-jobs 2.3.3 → 2.4.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cbfecef485b9884f4504d62b6e4d51345b1c729ae109e5dc619eeb5091dd9d22
-  data.tar.gz: e6bd8e6efe0f4a15d77645fe0f4f6b2bd5c2d13be723fba7a42ae72768c834ae
+  metadata.gz: 207f92edc1bf044fe040fac47e1eb3eff01d8d11ff66f3a5fa3ff3429ffca748
+  data.tar.gz: 0aa8bb0e7c81fe22eca78171b6827ba84f325e2981cda075691072f4305a355d
 SHA512:
-  metadata.gz: 8931e016e05ac54872c3053990402cb85818b53f031eeb0c0118f581a2f3cca73dda2613b99316b1b3bb37fa840b1401b73f02bf307700042f4dc451d2b14067
-  data.tar.gz: f301f6495d9854c0e8a53dfd22dd0e8db44994dda66aa22cbf920a7a18adf52170d523578ccd0f5a83971521a556074c270d531d626e216f1cf8af7e7bb0cae5
+  metadata.gz: d9278910b958ca2854c7b3d5e10a0b3911ee14938067897abb166929db2888f8577d8507622e372b12a5e5db53fbb09d50d5bdcea591364ca5b40ab7a46d1a27
+  data.tar.gz: 9b4b76b471d442e102a217d16d426dc0eed0e3e2a9bded47cc5d8505806264f189629cea337d084f0300398b96c52f9036a6670aa4b5ef426fff9f56775001a0

data/db/migrate/20101216224513_create_delayed_jobs.rb

@@ -6,19 +6,21 @@ class CreateDelayedJobs < ActiveRecord::Migration[4.2]
   end
 
   def up
-    raise("#{connection.adapter_name} is not supported for delayed jobs queue") unless connection.adapter_name == 'PostgreSQL'
+    unless connection.adapter_name == "PostgreSQL"
+      raise("#{connection.adapter_name} is not supported for delayed jobs queue")
+    end
 
     create_table :delayed_jobs do |table|
       # Allows some jobs to jump to the front of the queue
-      table.integer  :priority, :default => 0
+      table.integer  :priority, default: 0
       # Provides for retries, but still fail eventually.
-      table.integer  :attempts, :default => 0
+      table.integer  :attempts, default: 0
       # YAML-encoded string of the object that will do work
-      table.text     :handler, :limit => (500 * 1024)
+      table.text     :handler, limit: (500 * 1024)
       # reason for last failure (See Note below)
       table.text     :last_error
       # The queue that this job is in
-      table.string   :queue, :default => nil
+      table.string   :queue, default: nil
       # When to run.
       # Could be Time.zone.now for immediately, or sometime in the future.
       table.datetime :run_at
@@ -32,8 +34,8 @@ class CreateDelayedJobs < ActiveRecord::Migration[4.2]
       table.timestamps
     end
 
-    add_index :delayed_jobs, [:priority, :run_at], :name => 'delayed_jobs_priority'
-    add_index :delayed_jobs, [:queue], :name => 'delayed_jobs_queue'
+    add_index :delayed_jobs, %i[priority run_at], name: "delayed_jobs_priority"
+    add_index :delayed_jobs, [:queue], name: "delayed_jobs_queue"
   end
 
   def down

data/db/migrate/20110531144916_cleanup_delayed_jobs_indexes.rb

@@ -6,23 +6,18 @@ class CleanupDelayedJobsIndexes < ActiveRecord::Migration[4.2]
   end
 
   def up
-    case connection.adapter_name
-    when 'PostgreSQL'
-      # "nulls first" syntax is postgresql specific, and allows for more
-      # efficient querying for the next job
-      connection.execute("CREATE INDEX get_delayed_jobs_index ON delayed_jobs (priority, run_at, failed_at nulls first, locked_at nulls first, queue)")
-    else
-      add_index :delayed_jobs, %w(priority run_at locked_at failed_at queue), :name => 'get_delayed_jobs_index'
-    end
+    # "nulls first" syntax is postgresql specific, and allows for more
+    # efficient querying for the next job
+    connection.execute("CREATE INDEX get_delayed_jobs_index ON delayed_jobs (priority, run_at, failed_at nulls first, locked_at nulls first, queue)")
 
     # unused indexes
-    remove_index :delayed_jobs, :name => 'delayed_jobs_queue'
-    remove_index :delayed_jobs, :name => 'delayed_jobs_priority'
+    remove_index :delayed_jobs, name: "delayed_jobs_queue"
+    remove_index :delayed_jobs, name: "delayed_jobs_priority"
   end
 
   def down
-    remove_index :delayed_jobs, :name => 'get_delayed_jobs_index'
-    add_index :delayed_jobs, [:priority, :run_at], :name => 'delayed_jobs_priority'
-    add_index :delayed_jobs, [:queue], :name => 'delayed_jobs_queue'
+    remove_index :delayed_jobs, name: "get_delayed_jobs_index"
+    add_index :delayed_jobs, %i[priority run_at], name: "delayed_jobs_priority"
+    add_index :delayed_jobs, [:queue], name: "delayed_jobs_queue"
   end
 end

data/db/migrate/20110610213249_optimize_delayed_jobs.rb

@@ -7,10 +7,10 @@ class OptimizeDelayedJobs < ActiveRecord::Migration[4.2]
 
   def up
     create_table :failed_jobs do |t|
-      t.integer  "priority",    :default => 0
-      t.integer  "attempts",    :default => 0
-      t.string   "handler",     :limit => 512000
-      t.integer  "original_id", :limit => 8
+      t.integer  "priority",    default: 0
+      t.integer  "attempts",    default: 0
+      t.string   "handler",     limit: 512_000
+      t.integer  "original_id", limit: 8
       t.text     "last_error"
       t.string   "queue"
       t.datetime "run_at"
@@ -24,14 +24,14 @@ class OptimizeDelayedJobs < ActiveRecord::Migration[4.2]
       t.string   "strand"
     end
 
-    remove_index :delayed_jobs, :name => 'get_delayed_jobs_index'
+    remove_index :delayed_jobs, name: "get_delayed_jobs_index"
     remove_index :delayed_jobs, [:strand]
 
-    add_index :delayed_jobs, %w(run_at queue locked_at strand priority), :name => 'index_delayed_jobs_for_get_next'
-    add_index :delayed_jobs, %w(strand id), :name => 'index_delayed_jobs_on_strand'
+    add_index :delayed_jobs, %w[run_at queue locked_at strand priority], name: "index_delayed_jobs_for_get_next"
+    add_index :delayed_jobs, %w[strand id], name: "index_delayed_jobs_on_strand"
 
     # move all failed jobs to the new failed table
-    Delayed::Backend::ActiveRecord::Job.where("failed_at IS NOT NULL").find_each do |job|
+    Delayed::Backend::ActiveRecord::Job.where.not(failed_at: nil).find_each do |job|
       job.fail! unless job.on_hold?
     end
   end

data/db/migrate/20110831210257_add_delayed_jobs_next_in_strand.rb

@@ -6,49 +6,49 @@ class AddDelayedJobsNextInStrand < ActiveRecord::Migration[4.2]
   end
 
   def up
-    remove_index :delayed_jobs, :name => 'index_delayed_jobs_for_get_next'
+    remove_index :delayed_jobs, name: "index_delayed_jobs_for_get_next"
 
-    add_column :delayed_jobs, :next_in_strand, :boolean, :default => true, :null => false
+    add_column :delayed_jobs, :next_in_strand, :boolean, default: true, null: false
 
     # create the new index
     connection.execute("CREATE INDEX get_delayed_jobs_index ON delayed_jobs (priority, run_at, queue) WHERE locked_at IS NULL AND next_in_strand = 't'")
 
     # create the insert trigger
-    execute(<<-CODE)
-    CREATE FUNCTION delayed_jobs_before_insert_row_tr_fn () RETURNS trigger AS $$
-    BEGIN
-      LOCK delayed_jobs IN SHARE ROW EXCLUSIVE MODE;
-      IF (SELECT 1 FROM delayed_jobs WHERE strand = NEW.strand LIMIT 1) = 1 THEN
-        NEW.next_in_strand := 'f';
-      END IF;
-      RETURN NEW;
-    END;
-    $$ LANGUAGE plpgsql;
-    CODE
+    execute(<<~SQL)
+      CREATE FUNCTION delayed_jobs_before_insert_row_tr_fn () RETURNS trigger AS $$
+      BEGIN
+        LOCK delayed_jobs IN SHARE ROW EXCLUSIVE MODE;
+        IF (SELECT 1 FROM delayed_jobs WHERE strand = NEW.strand LIMIT 1) = 1 THEN
+          NEW.next_in_strand := 'f';
+        END IF;
+        RETURN NEW;
+      END;
+      $$ LANGUAGE plpgsql;
+    SQL
     execute("CREATE TRIGGER delayed_jobs_before_insert_row_tr BEFORE INSERT ON delayed_jobs FOR EACH ROW WHEN (NEW.strand IS NOT NULL) EXECUTE PROCEDURE delayed_jobs_before_insert_row_tr_fn()")
 
     # create the delete trigger
-    execute(<<-CODE)
-    CREATE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
-    BEGIN
-      UPDATE delayed_jobs SET next_in_strand = 't' WHERE id = (SELECT id FROM delayed_jobs j2 WHERE j2.strand = OLD.strand ORDER BY j2.strand, j2.id ASC LIMIT 1);
-      RETURN OLD;
-    END;
-    $$ LANGUAGE plpgsql;
-    CODE
+    execute(<<~SQL)
+      CREATE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
+      BEGIN
+        UPDATE delayed_jobs SET next_in_strand = 't' WHERE id = (SELECT id FROM delayed_jobs j2 WHERE j2.strand = OLD.strand ORDER BY j2.strand, j2.id ASC LIMIT 1);
+        RETURN OLD;
+      END;
+      $$ LANGUAGE plpgsql;
+    SQL
     execute("CREATE TRIGGER delayed_jobs_after_delete_row_tr AFTER DELETE ON delayed_jobs FOR EACH ROW WHEN (OLD.strand IS NOT NULL AND OLD.next_in_strand = 't') EXECUTE PROCEDURE delayed_jobs_after_delete_row_tr_fn()")
 
     execute(%{UPDATE delayed_jobs SET next_in_strand = 'f' WHERE strand IS NOT NULL AND id <> (SELECT id FROM delayed_jobs j2 WHERE j2.strand = delayed_jobs.strand ORDER BY j2.strand, j2.id ASC LIMIT 1)})
   end
 
   def down
-    execute %{DROP TRIGGER delayed_jobs_before_insert_row_tr ON delayed_jobs}
+    execute %(DROP TRIGGER delayed_jobs_before_insert_row_tr ON delayed_jobs)
     execute %{DROP FUNCTION delayed_jobs_before_insert_row_tr_fn()}
-    execute %{DROP TRIGGER delayed_jobs_after_delete_row_tr ON delayed_jobs}
+    execute %(DROP TRIGGER delayed_jobs_after_delete_row_tr ON delayed_jobs)
     execute %{DROP FUNCTION delayed_jobs_after_delete_row_tr_fn()}
 
     remove_column :delayed_jobs, :next_in_strand
-    remove_index :delayed_jobs, :name => 'get_delayed_jobs_index'
-    add_index :delayed_jobs, %w(run_at queue locked_at strand priority), :name => 'index_delayed_jobs_for_get_next'
+    remove_index :delayed_jobs, name: "get_delayed_jobs_index"
+    add_index :delayed_jobs, %w[run_at queue locked_at strand priority], name: "index_delayed_jobs_for_get_next"
   end
 end

data/db/migrate/20120510004759_delayed_jobs_delete_trigger_lock_for_update.rb

@@ -6,28 +6,24 @@ class DelayedJobsDeleteTriggerLockForUpdate < ActiveRecord::Migration[4.2]
   end
 
   def up
-    if connection.adapter_name == 'PostgreSQL'
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         UPDATE delayed_jobs SET next_in_strand = 't' WHERE id = (SELECT id FROM delayed_jobs j2 WHERE j2.strand = OLD.strand ORDER BY j2.strand, j2.id ASC LIMIT 1 FOR UPDATE);
         RETURN OLD;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
-    end
+    SQL
   end
 
   def down
-    if connection.adapter_name == 'PostgreSQL'
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         UPDATE delayed_jobs SET next_in_strand = 't' WHERE id = (SELECT id FROM delayed_jobs j2 WHERE j2.strand = OLD.strand ORDER BY j2.strand, j2.id ASC LIMIT 1);
         RETURN OLD;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
-    end
+    SQL
   end
 end

data/db/migrate/20120531150712_drop_psql_jobs_pop_fn.rb

@@ -6,9 +6,7 @@ class DropPsqlJobsPopFn < ActiveRecord::Migration[4.2]
   end
 
   def up
-    if connection.adapter_name == 'PostgreSQL'
-      connection.execute("DROP FUNCTION IF EXISTS pop_from_delayed_jobs(varchar, varchar, integer, integer, timestamp without time zone)")
-    end
+    connection.execute("DROP FUNCTION IF EXISTS pop_from_delayed_jobs(varchar, varchar, integer, integer, timestamp without time zone)")
   end
 
   def down

data/db/migrate/20120607164022_delayed_jobs_use_advisory_locks.rb

@@ -10,8 +10,7 @@ class DelayedJobsUseAdvisoryLocks < ActiveRecord::Migration[4.2]
     # note that we're using half of the md5, so collisions are possible, but we don't really
     # care because that would just be the old behavior, whereas for the most part locking will
     # be much smaller
-    if connection.adapter_name == 'PostgreSQL'
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE FUNCTION half_md5_as_bigint(strand varchar) RETURNS bigint AS $$
       DECLARE
         strand_md5 bytea;
@@ -27,9 +26,9 @@ class DelayedJobsUseAdvisoryLocks < ActiveRecord::Migration[4.2]
                                    get_byte(strand_md5, 7);
       END;
       $$ LANGUAGE plpgsql;
-      CODE
+    SQL
 
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_before_insert_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         PERFORM pg_advisory_xact_lock(half_md5_as_bigint(NEW.strand));
@@ -39,9 +38,9 @@ class DelayedJobsUseAdvisoryLocks < ActiveRecord::Migration[4.2]
         RETURN NEW;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
+    SQL
 
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         PERFORM pg_advisory_xact_lock(half_md5_as_bigint(OLD.strand));
@@ -49,13 +48,11 @@ class DelayedJobsUseAdvisoryLocks < ActiveRecord::Migration[4.2]
         RETURN OLD;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
-    end
+    SQL
   end
 
   def down
-    if connection.adapter_name == 'PostgreSQL'
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_before_insert_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         LOCK delayed_jobs IN SHARE ROW EXCLUSIVE MODE;
@@ -65,18 +62,17 @@ class DelayedJobsUseAdvisoryLocks < ActiveRecord::Migration[4.2]
         RETURN NEW;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
+    SQL
 
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         UPDATE delayed_jobs SET next_in_strand = 't' WHERE id = (SELECT id FROM delayed_jobs j2 WHERE j2.strand = OLD.strand ORDER BY j2.strand, j2.id ASC LIMIT 1 FOR UPDATE);
         RETURN OLD;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
+    SQL
 
-      execute('DROP FUNCTION half_md5_as_bigint(varchar)')
-    end
+    execute("DROP FUNCTION half_md5_as_bigint(varchar)")
   end
 end

data/db/migrate/20120607181141_index_jobs_on_locked_by.rb

@@ -8,7 +8,7 @@ class IndexJobsOnLockedBy < ActiveRecord::Migration[4.2]
   end
 
   def up
-    add_index :delayed_jobs, :locked_by, :algorithm => :concurrently, :where => "locked_by IS NOT NULL"
+    add_index :delayed_jobs, :locked_by, algorithm: :concurrently, where: "locked_by IS NOT NULL"
   end
 
   def down

data/db/migrate/20120608191051_add_jobs_run_at_index.rb

@@ -8,10 +8,10 @@ class AddJobsRunAtIndex < ActiveRecord::Migration[4.2]
   end
 
   def up
-    add_index :delayed_jobs, %w[run_at tag], :algorithm => :concurrently
+    add_index :delayed_jobs, %w[run_at tag], algorithm: :concurrently
   end
 
   def down
-    remove_index :delayed_jobs, :name => "index_delayed_jobs_on_run_at_and_tag"
+    remove_index :delayed_jobs, name: "index_delayed_jobs_on_run_at_and_tag"
   end
 end

data/db/migrate/20120927184213_change_delayed_jobs_handler_to_text.rb

@@ -10,6 +10,6 @@ class ChangeDelayedJobsHandlerToText < ActiveRecord::Migration[4.2]
   end
 
   def down
-    change_column :delayed_jobs, :handler, :string, :limit => 500.kilobytes
+    change_column :delayed_jobs, :handler, :string, limit: 500.kilobytes
   end
 end

data/db/migrate/20140505215510_copy_failed_jobs_original_id.rb

@@ -7,9 +7,8 @@ class CopyFailedJobsOriginalId < ActiveRecord::Migration[4.2]
 
   def up
     # this is a smaller, less frequently accessed table, so we just update all at once
-    Delayed::Backend::ActiveRecord::Job::Failed.where("original_job_id is null").update_all("original_job_id = original_id")
+    Delayed::Backend::ActiveRecord::Job::Failed.where(original_job_id: nil).update_all("original_job_id = original_id")
   end
 
-  def down
-  end
+  def down; end
 end

data/db/migrate/20150807133223_add_max_concurrent_to_jobs.rb

@@ -6,10 +6,9 @@ class AddMaxConcurrentToJobs < ActiveRecord::Migration[4.2]
   end
 
   def up
-    add_column :delayed_jobs, :max_concurrent, :integer, :default => 1, :null => false
+    add_column :delayed_jobs, :max_concurrent, :integer, default: 1, null: false
 
-    if connection.adapter_name == 'PostgreSQL'
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_before_insert_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         IF NEW.strand IS NOT NULL THEN
@@ -21,9 +20,9 @@ class AddMaxConcurrentToJobs < ActiveRecord::Migration[4.2]
         RETURN NEW;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
+    SQL
 
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         IF OLD.strand IS NOT NULL THEN
@@ -38,15 +37,13 @@ class AddMaxConcurrentToJobs < ActiveRecord::Migration[4.2]
         RETURN OLD;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
-    end
+    SQL
   end
 
   def down
     remove_column :delayed_jobs, :max_concurrent
 
-    if connection.adapter_name == 'PostgreSQL'
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_before_insert_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         PERFORM pg_advisory_xact_lock(half_md5_as_bigint(NEW.strand));
@@ -56,9 +53,9 @@ class AddMaxConcurrentToJobs < ActiveRecord::Migration[4.2]
         RETURN NEW;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
+    SQL
 
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         PERFORM pg_advisory_xact_lock(half_md5_as_bigint(OLD.strand));
@@ -66,7 +63,6 @@ class AddMaxConcurrentToJobs < ActiveRecord::Migration[4.2]
         RETURN OLD;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
-    end
+    SQL
   end
 end

data/db/migrate/20151210162949_improve_max_concurrent.rb

@@ -6,8 +6,7 @@ class ImproveMaxConcurrent < ActiveRecord::Migration[4.2]
   end
 
   def up
-    if connection.adapter_name == 'PostgreSQL'
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
       DECLARE
         running_count integer;
@@ -25,13 +24,11 @@ class ImproveMaxConcurrent < ActiveRecord::Migration[4.2]
         RETURN OLD;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
-    end
+    SQL
   end
 
   def down
-    if connection.adapter_name == 'PostgreSQL'
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         IF OLD.strand IS NOT NULL THEN
@@ -46,7 +43,6 @@ class ImproveMaxConcurrent < ActiveRecord::Migration[4.2]
         RETURN OLD;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
-    end
+    SQL
   end
 end

data/db/migrate/20161206323555_add_back_default_string_limits_jobs.rb

@@ -24,8 +24,8 @@ class AddBackDefaultStringLimitsJobs < ActiveRecord::Migration[4.2]
   end
 
   def drop_triggers
-    execute %{DROP TRIGGER delayed_jobs_before_insert_row_tr ON delayed_jobs}
-    execute %{DROP TRIGGER delayed_jobs_after_delete_row_tr ON delayed_jobs}
+    execute %(DROP TRIGGER delayed_jobs_before_insert_row_tr ON delayed_jobs)
+    execute %(DROP TRIGGER delayed_jobs_after_delete_row_tr ON delayed_jobs)
   end
 
   def readd_triggers
@@ -35,6 +35,7 @@ class AddBackDefaultStringLimitsJobs < ActiveRecord::Migration[4.2]
 
   def add_string_limit_if_missing(table, column)
     return if column_exists?(table, column, :string, limit: 255)
+
     change_column table, column, :string, limit: 255
   end
 end

data/db/migrate/20181217155351_speed_up_max_concurrent_triggers.rb

@@ -1,16 +1,15 @@
 # frozen_string_literal: true
 
-class SpeedUpMaxConcurrentTriggers  < ActiveRecord::Migration[4.2]
+class SpeedUpMaxConcurrentTriggers < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Job.connection
   end
 
   def up
-    if connection.adapter_name == 'PostgreSQL'
-      # tl;dr sacrifice some responsiveness to max_concurrent changes for faster performance
-      # don't get the count every single time - it's usually safe to just set the next one in line
-      # since the max_concurrent doesn't change all that often for a strand
-      execute(<<-CODE)
+    # tl;dr sacrifice some responsiveness to max_concurrent changes for faster performance
+    # don't get the count every single time - it's usually safe to just set the next one in line
+    # since the max_concurrent doesn't change all that often for a strand
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
       DECLARE
         running_count integer;
@@ -36,10 +35,10 @@ class SpeedUpMaxConcurrentTriggers  < ActiveRecord::Migration[4.2]
         RETURN OLD;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
+    SQL
 
-      # don't need the full count on insert
-      execute(<<-CODE)
+    # don't need the full count on insert
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_before_insert_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         IF NEW.strand IS NOT NULL THEN
@@ -53,13 +52,11 @@ class SpeedUpMaxConcurrentTriggers  < ActiveRecord::Migration[4.2]
         RETURN NEW;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
-    end
+    SQL
   end
 
   def down
-    if connection.adapter_name == 'PostgreSQL'
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_after_delete_row_tr_fn () RETURNS trigger AS $$
       DECLARE
         running_count integer;
@@ -77,9 +74,9 @@ class SpeedUpMaxConcurrentTriggers  < ActiveRecord::Migration[4.2]
         RETURN OLD;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
+    SQL
 
-      execute(<<-CODE)
+    execute(<<~SQL)
       CREATE OR REPLACE FUNCTION delayed_jobs_before_insert_row_tr_fn () RETURNS trigger AS $$
       BEGIN
         IF NEW.strand IS NOT NULL THEN
@@ -91,7 +88,6 @@ class SpeedUpMaxConcurrentTriggers  < ActiveRecord::Migration[4.2]
         RETURN NEW;
       END;
       $$ LANGUAGE plpgsql;
-      CODE
-    end
+    SQL
   end
 end

data/db/migrate/20200330230722_add_id_to_get_delayed_jobs_index.rb

@@ -9,19 +9,19 @@ class AddIdToGetDelayedJobsIndex < ActiveRecord::Migration[4.2]
 
   def up
     rename_index :delayed_jobs, "get_delayed_jobs_index", "get_delayed_jobs_index_old"
-    add_index :delayed_jobs, [:queue, :priority, :run_at, :id],
-      algorithm: :concurrently,
-      where: "locked_at IS NULL AND next_in_strand",
-      name: "get_delayed_jobs_index"
+    add_index :delayed_jobs, %i[queue priority run_at id],
+              algorithm: :concurrently,
+              where: "locked_at IS NULL AND next_in_strand",
+              name: "get_delayed_jobs_index"
     remove_index :delayed_jobs, name: "get_delayed_jobs_index_old"
   end
 
   def down
     rename_index :delayed_jobs, "get_delayed_jobs_index", "get_delayed_jobs_index_old"
-    add_index :delayed_jobs, [:priority, :run_at, :queue],
-      algorithm: :concurrently,
-      where: "locked_at IS NULL AND next_in_strand",
-      name: "get_delayed_jobs_index"
+    add_index :delayed_jobs, %i[priority run_at queue],
+              algorithm: :concurrently,
+              where: "locked_at IS NULL AND next_in_strand",
+              name: "get_delayed_jobs_index"
     remove_index :delayed_jobs, name: "get_delayed_jobs_index_old"
   end
 end