inst-jobs 0.16.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d1547b62f3c5fd86703cc209ec4b0feb6954db3c6fb4b58f4bcdbcf58dc9a9eb
-  data.tar.gz: 95ad1cacd71ac4511ee29eb0d3fda780037768234c232302b6fc10084de9e351
+  metadata.gz: 8c754ed71778d5b3f08641e133be947fae204a56dcee71aef08a7780a7d6afa5
+  data.tar.gz: 10949318e78e8e9d56b92ee7f2d14bfd647da20ff70578d894e4d1e85441d2fe
 SHA512:
-  metadata.gz: bd27fc7e6c0ca5a613ba98ea0928d7947f2344d05c57ab14f588ff615c69bab60a0b6f08e60d1b610b6746ad8a467d151237f1469129f6144d5e93ce20ea71ef
-  data.tar.gz: 25ce44b9f6eeedae9605c4bc2077a9e9b51a4b7df94ba4d68be1e78f70801af65273c332caba780c11bf523cff31daed9c44d8f068f697a8910781b09a2daf88
+  metadata.gz: 1a014e191bc0d6ccd083340b6d5c4bca0b7e03439aca459f79a5a704d93d16c42dd9e4855ca5985f7b1e4fb1fe62eead160cb6cb356c73b00ac297dc30112d8a
+  data.tar.gz: 53997c66017cf6db561104054379cb9e7e934fcc56c54d552b7629ff29eeb58de37c8674088661ba683e7e4d8b19234f26021819753ac06a6c738dd435c3f169

data/db/migrate/20101216224513_create_delayed_jobs.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class CreateDelayedJobs < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Backend::ActiveRecord::Job.connection

data/db/migrate/20110208031356_add_delayed_jobs_tag.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AddDelayedJobsTag < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Backend::ActiveRecord::Job.connection

data/db/migrate/20110426161613_add_delayed_jobs_max_attempts.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AddDelayedJobsMaxAttempts < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Backend::ActiveRecord::Job.connection

data/db/migrate/20110516225834_add_delayed_jobs_strand.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AddDelayedJobsStrand < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Backend::ActiveRecord::Job.connection

data/db/migrate/20110531144916_cleanup_delayed_jobs_indexes.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class CleanupDelayedJobsIndexes < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Backend::ActiveRecord::Job.connection

data/db/migrate/20110610213249_optimize_delayed_jobs.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class OptimizeDelayedJobs < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Backend::ActiveRecord::Job.connection

data/db/migrate/20110831210257_add_delayed_jobs_next_in_strand.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AddDelayedJobsNextInStrand < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Backend::ActiveRecord::Job.connection

data/db/migrate/20120510004759_delayed_jobs_delete_trigger_lock_for_update.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class DelayedJobsDeleteTriggerLockForUpdate < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Backend::ActiveRecord::Job.connection

data/db/migrate/20120531150712_drop_psql_jobs_pop_fn.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class DropPsqlJobsPopFn < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Backend::ActiveRecord::Job.connection

data/db/migrate/20120607164022_delayed_jobs_use_advisory_locks.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class DelayedJobsUseAdvisoryLocks < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Backend::ActiveRecord::Job.connection

data/db/migrate/20120607181141_index_jobs_on_locked_by.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class IndexJobsOnLockedBy < ActiveRecord::Migration[4.2]
   disable_ddl_transaction! if respond_to?(:disable_ddl_transaction!)
 

data/db/migrate/20120608191051_add_jobs_run_at_index.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AddJobsRunAtIndex < ActiveRecord::Migration[4.2]
   disable_ddl_transaction! if respond_to?(:disable_ddl_transaction!)
 

data/db/migrate/20120927184213_change_delayed_jobs_handler_to_text.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ChangeDelayedJobsHandlerToText < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Job.connection

data/db/migrate/20140505215131_add_failed_jobs_original_job_id.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AddFailedJobsOriginalJobId < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Backend::ActiveRecord::Job.connection

data/db/migrate/20140505215510_copy_failed_jobs_original_id.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class CopyFailedJobsOriginalId < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Backend::ActiveRecord::Job.connection

data/db/migrate/20140505223637_drop_failed_jobs_original_id.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class DropFailedJobsOriginalId < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Backend::ActiveRecord::Job.connection

data/db/migrate/20140512213941_add_source_to_jobs.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AddSourceToJobs < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Job.connection

data/db/migrate/20150807133223_add_max_concurrent_to_jobs.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AddMaxConcurrentToJobs < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Job.connection

data/db/migrate/20151123210429_add_expires_at_to_jobs.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AddExpiresAtToJobs < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Job.connection

data/db/migrate/20151210162949_improve_max_concurrent.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ImproveMaxConcurrent < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Job.connection

data/db/migrate/20161206323555_add_back_default_string_limits_jobs.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AddBackDefaultStringLimitsJobs < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Job.connection

data/db/migrate/20181217155351_speed_up_max_concurrent_triggers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class SpeedUpMaxConcurrentTriggers  < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Job.connection

data/db/migrate/20190726154743_make_critical_columns_not_null.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class MakeCriticalColumnsNotNull < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Job.connection

data/db/migrate/20200330230722_add_id_to_get_delayed_jobs_index.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AddIdToGetDelayedJobsIndex < ActiveRecord::Migration[4.2]
   disable_ddl_transaction! if respond_to?(:disable_ddl_transaction!)
 

data/db/migrate/20200824222232_speed_up_max_concurrent_delete_trigger.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class SpeedUpMaxConcurrentDeleteTrigger < ActiveRecord::Migration[4.2]
   def connection
     Delayed::Job.connection

data/db/migrate/20200825011002_add_strand_order_override.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class AddStrandOrderOverride < ActiveRecord::Migration[4.2]
   disable_ddl_transaction! if respond_to?(:disable_ddl_transaction!)
 

data/lib/delayed/backend/active_record.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ActiveRecord::Base
   def self.load_for_delayed_job(id)
     if id
@@ -105,7 +107,7 @@ module Delayed
         # so rather than changing the strand and balancing at queue time,
         # this keeps the strand intact and uses triggers to limit the number running
         def self.n_strand_options(strand_name, num_strands)
-          {:strand => strand_name, :max_concurrent => num_strands}
+          { strand: strand_name, max_concurrent: num_strands }
         end
 
         def self.current
@@ -125,8 +127,8 @@ module Delayed
         end
 
         # a nice stress test:
-        # 10_000.times { |i| Kernel.send_later_enqueue_args(:system, { :strand => 's1', :run_at => (24.hours.ago + (rand(24.hours.to_i))) }, "echo #{i} >> test1.txt") }
-        # 500.times { |i| "ohai".send_later_enqueue_args(:reverse, { :run_at => (12.hours.ago + (rand(24.hours.to_i))) }) }
+        # 10_000.times { |i| Kernel.delay(strand: 's1', run_at: (24.hours.ago + (rand(24.hours.to_i))).system("echo #{i} >> test1.txt") }
+        # 500.times { |i| "ohai".delay(run_at: (12.hours.ago + (rand(24.hours.to_i))).reverse }
         # then fire up your workers
         # you can check out strand correctness: diff test1.txt <(sort -n test1.txt)
          def self.ready_to_run(forced_latency: nil)
@@ -288,7 +290,7 @@ module Delayed
                     lock(lock)
                 jobs_with_row_number = all.from(target_jobs).
                     select("id, ROW_NUMBER() OVER () AS row_number")
-                updates = "locked_by = CASE row_number "
+                updates = +"locked_by = CASE row_number "
                 effective_worker_names.each_with_index do |worker, i|
                   updates << "WHEN #{i + 1} THEN #{connection.quote(worker)} "
                 end

data/lib/delayed/backend/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Delayed
   module Backend
     class DeserializationError < StandardError
@@ -28,19 +30,31 @@ module Delayed
         # The first argument should be an object that respond_to?(:perform)
         # The rest should be named arguments, these keys are expected:
         # :priority, :run_at, :queue, :strand, :singleton
-        # Example: Delayed::Job.enqueue(object, :priority => 0, :run_at => time, :queue => queue)
-        def enqueue(*args)
-          object = args.shift
+        # Example: Delayed::Job.enqueue(object, priority: 0, run_at: time, queue: queue)
+        def enqueue(object,
+          priority: default_priority,
+          run_at: nil,
+          expires_at: nil,
+          queue: Delayed::Settings.queue,
+          strand: nil,
+          singleton: nil,
+          n_strand: nil,
+          max_attempts: Delayed::Settings.max_attempts,
+          **kwargs)
+
           unless object.respond_to?(:perform)
             raise ArgumentError, 'Cannot enqueue items which do not respond to perform'
           end
 
-          options = Settings.default_job_options.merge(args.first || {})
-          options[:priority] ||= self.default_priority
-          options[:payload_object] = object
-          options[:queue] = Delayed::Settings.queue unless options.key?(:queue)
-          options[:max_attempts] ||= Delayed::Settings.max_attempts
-          options[:source] = Marginalia::Comment.construct_comment if defined?(Marginalia) && Marginalia::Comment.components
+          kwargs = Settings.default_job_options.merge(kwargs)
+          kwargs[:payload_object] = object
+          kwargs[:priority] = priority
+          kwargs[:run_at] = run_at if run_at
+          kwargs[:strand] = strand
+          kwargs[:max_attempts] = max_attempts
+          kwargs[:source] = Marginalia::Comment.construct_comment if defined?(Marginalia) && Marginalia::Comment.components
+          kwargs[:expires_at] = expires_at
+          kwargs[:queue] = queue
 
           # If two parameters are given to n_strand, the first param is used
           # as the strand name for looking up the Setting, while the second
@@ -49,8 +63,8 @@ module Delayed
           # For instance, you can pass ["my_job_type", # root_account.global_id]
           # to get a set of n strands per root account, and you can apply the
           # same default to all.
-          if options[:n_strand]
-            strand_name, ext = options.delete(:n_strand)
+          if n_strand
+            strand_name, ext = n_strand
 
             if ext
               full_strand_name = "#{strand_name}/#{ext}"
@@ -62,18 +76,18 @@ module Delayed
             num_strands ||= Delayed::Settings.num_strands.call(strand_name)
             num_strands = num_strands ? num_strands.to_i : 1
 
-            options.merge!(n_strand_options(full_strand_name, num_strands))
+            kwargs.merge!(n_strand_options(full_strand_name, num_strands))
           end
 
-          if options[:singleton]
-            options[:strand] = options.delete :singleton
-            job = self.create_singleton(options)
-          elsif batches && options.slice(:strand, :run_at).empty?
-            batch_enqueue_args = options.slice(*self.batch_enqueue_args)
-            batches[batch_enqueue_args] << options
+          if singleton
+            kwargs[:strand] = singleton
+            job = self.create_singleton(**kwargs)
+          elsif batches && strand.nil? && run_at.nil?
+            batch_enqueue_args = kwargs.slice(*self.batch_enqueue_args)
+            batches[batch_enqueue_args] << kwargs
             return true
           else
-            job = self.create(options)
+            job = self.create(**kwargs)
           end
 
           JobTracking.job_created(job)
@@ -87,7 +101,7 @@ module Delayed
         def n_strand_options(strand_name, num_strands)
           strand_num = num_strands > 1 ? rand(num_strands) + 1 : 1
           strand_name += ":#{strand_num}" if strand_num > 1
-          {:strand => strand_name}
+          { strand: strand_name }
         end
 
         def in_delayed_job?

data/lib/delayed/backend/redis/functions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'redis/scripting'
 
 # This module handles loading the Lua functions into Redis and running them

data/lib/delayed/backend/redis/job.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # This can't currently be made compatible with redis cluster, because the Lua functions
 # access keys that aren't in their keys argument list (since they pop jobs off
 # a queue and then update the job with that id).

data/lib/delayed/batch.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Delayed
   module Batch
     class PerformableBatch < Struct.new(:mode, :items)
@@ -18,7 +20,7 @@ module Delayed
       end
 
       def jobs
-        items.map { |opts| Delayed::Job.new(opts) }
+        items.map { |opts| Delayed::Job.new(**opts) }
       end
     end
 
@@ -45,9 +47,9 @@ module Delayed
           elsif batch.size == 1
             args = batch.first.merge(batch_args)
             payload_object = args.delete(:payload_object)
-            Delayed::Job.enqueue(payload_object, args)
+            Delayed::Job.enqueue(payload_object, **args)
           else
-            Delayed::Job.enqueue(Delayed::Batch::PerformableBatch.new(mode, batch), enqueue_args.merge(batch_args))
+            Delayed::Job.enqueue(Delayed::Batch::PerformableBatch.new(mode, batch), **enqueue_args.merge(batch_args))
           end
         end
       end

data/lib/delayed/cli.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'optparse'
 
 module Delayed

data/lib/delayed/daemon.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'fileutils'
 
 module Delayed

data/lib/delayed/engine.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Delayed
   class Engine < ::Rails::Engine
   end

data/lib/delayed/job_tracking.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Delayed
 # Used when a block of code wants to track what jobs are created,
 # for instance in tests.

data/lib/delayed/lifecycle.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Delayed
   class InvalidCallback < Exception; end
 

data/lib/delayed/log_tailer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Delayed
 class LogTailer
   def run

data/lib/delayed/logging.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'date'
 
 module Delayed

data/lib/delayed/message_sending.rb

@@ -1,109 +1,67 @@
+# frozen_string_literal: true
+
 module Delayed
   module MessageSending
-    def send_later(method, *args)
-      send_later_enqueue_args(method, {}, *args)
-    end
-
-    def send_later_enqueue_args(method, enqueue_args = {}, *args)
-      enqueue_args = enqueue_args.dup
-      # support procs/methods as enqueue arguments
-      enqueue_args.each do |k,v|
-        if v.respond_to?(:call)
-          enqueue_args[k] = v.call(self)
-        end
+    class DelayProxy < BasicObject
+      def initialize(object, enqueue_args)
+        @object = object
+        @enqueue_args = enqueue_args
       end
 
-      no_delay = enqueue_args.delete(:no_delay)
-      on_failure = enqueue_args.delete(:on_failure)
-      on_permanent_failure = enqueue_args.delete(:on_permanent_failure)
-      if !no_delay
-        # delay queuing up the job in another database until the results of the current
-        # transaction are visible
-        connection = self.class.connection if self.class.respond_to?(:connection)
-        connection ||= self.connection if respond_to?(:connection)
-        connection ||= ActiveRecord::Base.connection
-
-        if (Delayed::Job != Delayed::Backend::ActiveRecord::Job || connection != Delayed::Job.connection)
-          connection.after_transaction_commit do
-            Delayed::Job.enqueue(Delayed::PerformableMethod.new(self, method.to_sym, args,
-                                                                on_failure, on_permanent_failure), enqueue_args)
+      def method_missing(method, *args, **kwargs)
+        ignore_transaction = @enqueue_args.delete(:ignore_transaction)
+        on_failure = @enqueue_args.delete(:on_failure)
+        on_permanent_failure = @enqueue_args.delete(:on_permanent_failure)
+        if !ignore_transaction
+          # delay queuing up the job in another database until the results of the current
+          # transaction are visible
+          connection = @object.class.connection if @object.class.respond_to?(:connection)
+          connection ||= @object.connection if @object.respond_to?(:connection)
+          connection ||= ::ActiveRecord::Base.connection
+
+          if (::Delayed::Job != ::Delayed::Backend::ActiveRecord::Job || connection != ::Delayed::Job.connection)
+            connection.after_transaction_commit do
+              ::Delayed::Job.enqueue(::Delayed::PerformableMethod.new(@object, method,
+                                                                  args: args, kwargs: kwargs,
+                                                                  on_failure: on_failure,
+                                                                  on_permanent_failure: on_permanent_failure),
+                                                                  **@enqueue_args)
+            end
+            return nil
           end
-          return nil
         end
-      end
-
-      result = Delayed::Job.enqueue(Delayed::PerformableMethod.new(self, method.to_sym, args,
-                                                                   on_failure, on_permanent_failure), enqueue_args)
-      result = nil unless no_delay
-      result
-    end
-
-    def send_later_with_queue(method, queue, *args)
-      send_later_enqueue_args(method, { :queue => queue }, *args)
-    end
-
-    def send_at(time, method, *args)
-      send_later_enqueue_args(method,
-                          { :run_at => time }, *args)
-    end
-
-    def send_at_with_queue(time, method, queue, *args)
-      send_later_enqueue_args(method,
-                          { :run_at => time, :queue => queue },
-                          *args)
-    end
-
-    def send_later_unless_in_job(method, *args)
-      if Delayed::Job.in_delayed_job?
-        send(method, *args)
-      else
-        send_later(method, *args)
-      end
-      nil # can't rely on the type of return value, so return nothing
-    end
 
-    def send_later_if_production(*args)
-      if Rails.env.production?
-        send_later(*args)
-      else
-        send(*args)
+        result = ::Delayed::Job.enqueue(::Delayed::PerformableMethod.new(@object, method,
+                                                                    args: args,
+                                                                    kwargs: kwargs,
+                                                                    on_failure: on_failure,
+                                                                    on_permanent_failure: on_permanent_failure),
+                                                                    **@enqueue_args)
+        result = nil unless ignore_transaction
+        result
       end
     end
 
-    def send_later_if_production_enqueue_args(method, enqueue_args, *args)
-      if Rails.env.production?
-        send_later_enqueue_args(method, enqueue_args, *args)
-      else
-        send(method, *args)
-      end
-    end
-
-    def send_now_or_later(_when, *args)
-      if _when == :now
-        send(*args)
-      else
-        send_later(*args)
+    def delay(**enqueue_args)
+      # support procs/methods as enqueue arguments
+      enqueue_args.each do |k,v|
+        if v.respond_to?(:call)
+          enqueue_args[k] = v.call(self)
+        end
       end
-    end
-
-    def send_now_or_later_if_production(_when, *args)
-      if _when == :now
-        send(*args)
-      else
-        send_later_if_production(*args)
+      if enqueue_args.delete(:synchronous)
+        return self
       end
+      DelayProxy.new(self, enqueue_args)
     end
 
     module ClassMethods
       KWARG_ARG_TYPES = %i{key keyreq keyrest}.freeze
       private_constant :KWARG_ARG_TYPES
 
-      def add_send_later_methods(method_name, enqueue_args={}, default_async=false)
+      def handle_asynchronously(method_name, **enqueue_args)
         aliased_method, punctuation = method_name.to_s.sub(/([?!=])$/, ''), $1
 
-        # we still need this for backwards compatibility
-        without_method = "#{aliased_method}_without_send_later#{punctuation}"
-
         if public_method_defined?(method_name)
           visibility = :public
         elsif private_method_defined?(method_name)
@@ -114,49 +72,28 @@ module Delayed
 
         if has_kwargs? method_name
           generated_delayed_methods.class_eval do
-            define_method without_method do |*args, **kwargs|
-              send(method_name, *args, synchronous: true, **kwargs)
-            end
-
-            define_method(method_name, -> (*args, synchronous: !default_async, **kwargs) do
+            define_method(method_name, -> (*args, synchronous: false, **kwargs) do
               if synchronous
                 super(*args, **kwargs)
               else
-                send_later_enqueue_args(method_name, enqueue_args, *args, synchronous: true, **kwargs)
+                delay(**enqueue_args).method_missing(method_name, *args, synchronous: true, **kwargs)
               end
             end)
           end
         else
           generated_delayed_methods.class_eval do
-            define_method without_method do |*args|
-              send(method_name, *args, synchronous: true)
-            end
-
-            define_method(method_name, -> (*args, synchronous: !default_async) do
+            define_method(method_name, -> (*args, synchronous: false) do
               if synchronous
                 super(*args)
               else
-                send_later_enqueue_args(method_name, enqueue_args, *args, synchronous: true)
+                delay(**enqueue_args).method_missing(method_name, *args, synchronous: true)
               end
             end)
           end
         end
-        generated_delayed_methods.send(visibility, without_method)
         generated_delayed_methods.send(visibility, method_name)
       end
 
-      def handle_asynchronously(method, enqueue_args={})
-        add_send_later_methods(method, enqueue_args, true)
-      end
-
-      def handle_asynchronously_with_queue(method, queue)
-        add_send_later_methods(method, {:queue => queue}, true)
-      end
-
-      def handle_asynchronously_if_production(method, enqueue_args={})
-        add_send_later_methods(method, enqueue_args, Rails.env.production?)
-      end
-
       private
 
       def generated_delayed_methods