karafka 2.5.1 → 2.5.3

data/lib/karafka/pro/processing/coordinator.rb

@@ -8,7 +8,7 @@ module Karafka
     module Processing
       # Pro coordinator that provides extra orchestration methods useful for parallel processing
       # within the same partition
-      class Coordinator < ::Karafka::Processing::Coordinator
+      class Coordinator < Karafka::Processing::Coordinator
         extend Forwardable
         include Helpers::ConfigImporter.new(
           errors_tracker_class: %i[internal processing errors_tracker_class]

data/lib/karafka/pro/processing/coordinators/errors_tracker.rb

@@ -79,9 +79,8 @@ module Karafka
           end
 
           # Iterates over errors
-          # @param block [Proc] code we want to run on each error
-          def each(&block)
-            @errors.each(&block)
+          def each(&)
+            @errors.each(&)
           end
 
           # @return [Array<StandardError>] array with all the errors that occurred

data/lib/karafka/pro/processing/coordinators/filters_applier.rb

@@ -68,7 +68,7 @@ module Karafka
           # @return [Integer] minimum timeout we need to pause. This is the minimum for all the
           #   filters to satisfy all of them.
           def timeout
-            applied.map(&:timeout).compact.min || 0
+            applied.filter_map(&:timeout).min || 0
           end
 
           # The first message we do need to get next time we poll. We use the minimum not to jump
@@ -78,7 +78,7 @@ module Karafka
           def cursor
             return nil unless active?
 
-            applied.map(&:cursor).compact.min_by(&:offset)
+            applied.filter_map(&:cursor).min_by(&:offset)
           end
 
           # @return [Boolean] did any of the filters requested offset storage during filter
@@ -106,7 +106,7 @@ module Karafka
           def marking_cursor
             return nil unless active?
 
-            applied.map(&:marking_cursor).compact.min_by(&:offset)
+            applied.filter_map(&:marking_cursor).min_by(&:offset)
           end
 
           private

data/lib/karafka/pro/processing/filters/base.rb

@@ -20,6 +20,7 @@ module Karafka
 
           include Karafka::Core::Helpers::Time
 
+          # Initializes the filter as not yet applied
           def initialize
             @applied = false
             @cursor = nil

data/lib/karafka/pro/processing/filters/delayer.rb

@@ -25,7 +25,7 @@ module Karafka
 
             # Time on message is in seconds with ms precision, so we need to convert the ttl that
             # is in ms to this format
-            border = ::Time.now.utc - @delay / 1_000.0
+            border = Time.now.utc - (@delay / 1_000.0)
 
             messages.delete_if do |message|
               too_young = message.timestamp > border

data/lib/karafka/pro/processing/filters/expirer.rb

@@ -26,7 +26,7 @@ module Karafka
 
             # Time on message is in seconds with ms precision, so we need to convert the ttl that
             # is in ms to this format
-            border = ::Time.now.utc - @ttl / 1_000.to_f
+            border = Time.now.utc - (@ttl / 1_000.to_f)
 
             messages.delete_if do |message|
               too_old = message.timestamp < border

data/lib/karafka/pro/processing/filters/inline_insights_delayer.rb

@@ -41,7 +41,7 @@ module Karafka
             # This can happen when we chain filters
             return unless @cursor
 
-            insights = ::Karafka::Processing::InlineInsights::Tracker.find(
+            insights = Karafka::Processing::InlineInsights::Tracker.find(
               @topic,
               @partition
             )

data/lib/karafka/pro/processing/filters/throttler.rb

@@ -67,7 +67,7 @@ module Karafka
           #   so we are no longer throttled and so we can process at least one message
           def timeout
             timeout = @interval - (monotonic_now - @time)
-            timeout <= 0 ? 0 : timeout
+            [timeout, 0].max
           end
         end
       end

data/lib/karafka/pro/processing/jobs/consume_non_blocking.rb

@@ -17,7 +17,7 @@ module Karafka
         #
         # @note It needs to be working with a proper consumer that will handle the partition
         #   management. This layer of the framework knows nothing about Kafka messages consumption.
-        class ConsumeNonBlocking < ::Karafka::Processing::Jobs::Consume
+        class ConsumeNonBlocking < Karafka::Processing::Jobs::Consume
           self.action = :consume
 
           # Makes this job non-blocking from the start

data/lib/karafka/pro/processing/jobs/eofed_non_blocking.rb

@@ -11,7 +11,7 @@ module Karafka
         # We use this version for LRJ topics for cases where saturated resources would not allow
         # to run this job for extended period of time. Under such scenarios, if we would not use
         # a non-blocking one, we would reach max.poll.interval.ms.
-        class EofedNonBlocking < ::Karafka::Processing::Jobs::Eofed
+        class EofedNonBlocking < Karafka::Processing::Jobs::Eofed
           self.action = :eofed
 
           # @param args [Array] any arguments accepted by `::Karafka::Processing::Jobs::Eofed`

data/lib/karafka/pro/processing/jobs/periodic.rb

@@ -9,7 +9,7 @@ module Karafka
       module Jobs
         # Job that represents a "ticking" work. Work that we run periodically for the Periodics
         # enabled topics.
-        class Periodic < ::Karafka::Processing::Jobs::Base
+        class Periodic < Karafka::Processing::Jobs::Base
           self.action = :tick
 
           # @param executor [Karafka::Pro::Processing::Executor] pro executor that is suppose to

data/lib/karafka/pro/processing/jobs/revoked_non_blocking.rb

@@ -15,7 +15,7 @@ module Karafka
         # It can be useful when having long lasting jobs that would exceed `max.poll.interval`
         # in scenarios where there are more jobs than threads, without this being async we
         # would potentially stop polling
-        class RevokedNonBlocking < ::Karafka::Processing::Jobs::Revoked
+        class RevokedNonBlocking < Karafka::Processing::Jobs::Revoked
           self.action = :revoked
 
           # Makes this job non-blocking from the start

data/lib/karafka/pro/processing/jobs_builder.rb

@@ -7,7 +7,7 @@ module Karafka
   module Pro
     module Processing
       # Pro jobs builder that supports lrj
-      class JobsBuilder < ::Karafka::Processing::JobsBuilder
+      class JobsBuilder < Karafka::Processing::JobsBuilder
         # @param executor [Karafka::Pro::Processing::Executor]
         def idle(executor)
           Karafka::Processing::Jobs::Idle.new(executor)

data/lib/karafka/pro/processing/offset_metadata/fetcher.rb

@@ -28,6 +28,7 @@ module Karafka
             def_delegators :instance, :register, :clear, :find
           end
 
+          # Initializes the fetcher with empty caches
           def initialize
             @mutexes = {}
             @clients = {}

data/lib/karafka/pro/processing/partitioner.rb

@@ -7,7 +7,7 @@ module Karafka
   module Pro
     module Processing
       # Pro partitioner that can distribute work based on the virtual partitioner settings
-      class Partitioner < ::Karafka::Processing::Partitioner
+      class Partitioner < Karafka::Processing::Partitioner
         # @param topic [String] topic name
         # @param messages [Array<Karafka::Messages::Message>] karafka messages
         # @param coordinator [Karafka::Pro::Processing::Coordinator] processing coordinator that

data/lib/karafka/pro/processing/schedulers/default.rb

@@ -29,10 +29,8 @@ module Karafka
           def on_schedule_consumption(jobs_array)
             perf_tracker = Instrumentation::PerformanceTracker.instance
 
-            ordered = []
-
-            jobs_array.each do |job|
-              ordered << [
+            ordered = jobs_array.map do |job|
+              [
                 job,
                 processing_cost(perf_tracker, job)
               ]

data/lib/karafka/pro/processing/strategies/base.rb

@@ -10,7 +10,7 @@ module Karafka
       module Strategies
         # Base strategy for Pro
         module Base
-          include ::Karafka::Processing::Strategies::Base
+          include Karafka::Processing::Strategies::Base
         end
       end
     end

data/lib/karafka/pro/processing/strategies/default.rb

@@ -14,7 +14,7 @@ module Karafka
         # Nothing. Just standard, automatic flow
         module Default
           include Base
-          include ::Karafka::Processing::Strategies::Default
+          include Karafka::Processing::Strategies::Default
 
           # Apply strategy for a non-feature based flow
           FEATURES = %i[].freeze
@@ -263,7 +263,7 @@ module Karafka
           # the post-user code execution marking with transactional producer to result in a
           # boolean state of marking for further framework flow. This is a normalization to make it
           # behave the same way as it would behave with a non-transactional one
-          rescue ::Rdkafka::RdkafkaError, Errors::AssignmentLostError
+          rescue Rdkafka::RdkafkaError, Errors::AssignmentLostError
             false
           ensure
             @_transaction_internal = false

data/lib/karafka/pro/processing/strategies/lrj/default.rb

@@ -78,10 +78,8 @@ module Karafka
             # Allows for LRJ to synchronize its work. It may be needed because LRJ can run
             # lifecycle events like revocation while the LRJ work is running and there may be a
             # need for a critical section.
-            #
-            # @param block [Proc] block we want to run in a mutex to prevent race-conditions
-            def synchronize(&block)
-              coordinator.shared_mutex.synchronize(&block)
+            def synchronize(&)
+              coordinator.shared_mutex.synchronize(&)
             end
           end
         end

data/lib/karafka/pro/processing/strategies/vp/default.rb

@@ -134,10 +134,8 @@ module Karafka
             # the end users. With LRJ it is needed and provided in the `LRJ::Default` strategy,
             # because lifecycle events on revocation can run in parallel to the LRJ job as it is
             # non-blocking.
-            #
-            # @param block [Proc] block we want to run in a mutex to prevent race-conditions
-            def synchronize(&block)
-              coordinator.shared_mutex.synchronize(&block)
+            def synchronize(&)
+              coordinator.shared_mutex.synchronize(&)
             end
 
             private

data/lib/karafka/pro/processing/strategy_selector.rb

@@ -23,6 +23,7 @@ module Karafka
           filtering
         ].freeze
 
+        # Initializes the strategy selector and preloads all strategies
         def initialize
           # Preload the strategies
           # We load them once for performance reasons not to do too many lookups

data/lib/karafka/pro/processing/subscription_groups_coordinator.rb

@@ -16,12 +16,11 @@ module Karafka
         #   want to pause
         # @param lock_id [Object] key we want to use if we want to set multiple locks on the same
         #   subscription group
-        # @param kwargs [Object] Any keyword arguments accepted by the jobs queue lock.
-        def pause(subscription_group, lock_id = nil, **kwargs)
+        def pause(subscription_group, lock_id = nil, **)
           jobs_queue.lock_async(
             subscription_group.id,
             lock_id,
-            **kwargs
+            **
           )
         end
 

data/lib/karafka/pro/processing/virtual_partitions/distributors/balanced.rb

@@ -11,8 +11,10 @@ module Karafka
           # Balanced distributor that groups messages by partition key
           # and processes larger groups first while maintaining message order within groups
           class Balanced < Base
-            # @param messages [Array<Karafka::Messages::Message>] messages to distribute
-            # @return [Hash<Integer, Array<Karafka::Messages::Message>>] hash with group ids as
+            # Distributes messages to virtual partitions ensuring balanced load across workers
+            # by grouping messages by partition key and assigning larger groups first
+            # @param messages [Array<Karafka::Messages::Message>]
+            # @return [Hash{Integer => Array<Karafka::Messages::Message>}] hash with group ids as
             #   keys and message groups as values
             def call(messages)
               # Group messages by partition key

data/lib/karafka/pro/processing/virtual_partitions/distributors/consistent.rb

@@ -11,8 +11,10 @@ module Karafka
           # Consistent distributor that ensures messages with the same partition key
           # are always processed in the same virtual partition
           class Consistent < Base
-            # @param messages [Array<Karafka::Messages::Message>] messages to distribute
-            # @return [Hash<Integer, Array<Karafka::Messages::Message>>] hash with group ids as
+            # Distributes messages ensuring consistent routing where messages with the same
+            # partition key always go to the same virtual partition
+            # @param messages [Array<Karafka::Messages::Message>]
+            # @return [Hash{Integer => Array<Karafka::Messages::Message>}] hash with group ids as
             #   keys and message groups as values
             def call(messages)
               messages

data/lib/karafka/pro/recurring_tasks/consumer.rb

@@ -11,13 +11,14 @@ module Karafka
       #   - we only run schedules that are of same or newer version
       #   - we always mark as consumed in such a way, that the first message received after
       #     assignment (if any) is a state
-      class Consumer < ::Karafka::BaseConsumer
+      class Consumer < Karafka::BaseConsumer
         # @param args [Array] all arguments accepted by the consumer
         def initialize(*args)
           super
           @executor = Executor.new
         end
 
+        # Consumes messages and manages recurring tasks execution
         def consume
           # There is nothing we can do if we operate on a newer schedule. In such cases we should
           # just wait and re-raise error hoping someone will notice or that this will be
@@ -54,7 +55,7 @@ module Karafka
               # that collectively have a different outcome
               @executor.call
             else
-              raise ::Karafka::Errors::UnsupportedCaseError, type
+              raise Karafka::Errors::UnsupportedCaseError, type
             end
           end
 

data/lib/karafka/pro/recurring_tasks/contracts/config.rb

@@ -9,17 +9,15 @@ module Karafka
       # Recurring Tasks related contracts
       module Contracts
         # Makes sure, all the expected config is defined as it should be
-        class Config < ::Karafka::Contracts::Base
+        class Config < Karafka::Contracts::Base
           configure do |config|
-            config.error_messages = YAML.safe_load(
-              File.read(
-                File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
-              )
+            config.error_messages = YAML.safe_load_file(
+              File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
             ).fetch('en').fetch('validations').fetch('setup').fetch('config')
           end
 
           nested(:recurring_tasks) do
-            required(:consumer_class) { |val| val < ::Karafka::BaseConsumer }
+            required(:consumer_class) { |val| val < Karafka::BaseConsumer }
             required(:deserializer) { |val| !val.nil? }
             required(:logging) { |val| [true, false].include?(val) }
             # Do not allow to run more often than every 5 seconds

data/lib/karafka/pro/recurring_tasks/contracts/task.rb

@@ -9,12 +9,10 @@ module Karafka
       # Recurring Tasks related contracts
       module Contracts
         # Ensures that task details are as expected
-        class Task < ::Karafka::Contracts::Base
+        class Task < Karafka::Contracts::Base
           configure do |config|
-            config.error_messages = YAML.safe_load(
-              File.read(
-                File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
-              )
+            config.error_messages = YAML.safe_load_file(
+              File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
             ).fetch('en').fetch('validations').fetch('recurring_tasks')
           end
 

data/lib/karafka/pro/recurring_tasks/deserializer.rb

@@ -16,7 +16,7 @@ module Karafka
         # @param message [::Karafka::Messages::Message]
         # @return [Hash] deserialized data
         def call(message)
-          ::JSON.parse(
+          JSON.parse(
             Zlib::Inflate.inflate(message.raw_payload),
             symbolize_names: true
           )

data/lib/karafka/pro/recurring_tasks/dispatcher.rb

@@ -8,6 +8,10 @@ module Karafka
     module RecurringTasks
       # Dispatches appropriate recurring tasks related messages to expected topics
       class Dispatcher
+        extend Helpers::ConfigImporter.new(
+          topics: %i[recurring_tasks topics]
+        )
+
         class << self
           # Snapshots to Kafka current schedule state
           def schedule
@@ -44,13 +48,10 @@ module Karafka
           private
 
           # @return [::WaterDrop::Producer] web ui producer
+          # @note We do not fetch it via the ConfigImporter not to cache it so we can re-use it
+          #   if needed
           def producer
-            ::Karafka::App.config.recurring_tasks.producer
-          end
-
-          # @return [String] consumers commands topic
-          def topics
-            ::Karafka::App.config.recurring_tasks.topics
+            Karafka::App.config.recurring_tasks.producer
           end
 
           # @return [Serializer]

data/lib/karafka/pro/recurring_tasks/executor.rb

@@ -17,6 +17,7 @@ module Karafka
           trigger
         ].freeze
 
+        # Initializes the executor in replaying mode
         def initialize
           @replaying = true
           @incompatible = false
@@ -131,7 +132,7 @@ module Karafka
 
         # @return [Karafka::Pro::RecurringTasks::Schedule] current in-memory schedule
         def schedule
-          ::Karafka::Pro::RecurringTasks.schedule
+          Karafka::Pro::RecurringTasks.schedule
         end
 
         # Dispatches the current schedule state to Kafka

data/lib/karafka/pro/recurring_tasks/schedule.rb

@@ -13,7 +13,7 @@ module Karafka
         # @return [String]
         attr_reader :version
 
-        # @return [Hash<String, Task>]
+        # @return [Hash{String => Task}]
         attr_reader :tasks
 
         # @param version [String] schedule version. In case of usage of versioning it is used to
@@ -32,9 +32,8 @@ module Karafka
         end
 
         # Iterates over tasks yielding them one after another
-        # @param block [Proc] block that will be executed with each task
-        def each(&block)
-          @tasks.each_value(&block)
+        def each(&)
+          @tasks.each_value(&)
         end
 
         # @param id [String] id of a particular recurring task
@@ -44,10 +43,12 @@ module Karafka
         end
 
         # Allows us to have a nice DSL for defining schedules
-        # @param args [Array] attributes accepted by the task initializer
-        # @param block [Proc] block to execute
-        def schedule(**args, &block)
-          self << Task.new(**args, &block)
+        # @param args [Hash] attributes accepted by the task initializer
+        # @option args [String] :id unique task identifier
+        # @option args [String] :cron cron expression for task scheduling
+        # @option args [Proc] :previous_time optional lambda returning previous execution time
+        def schedule(**args, &)
+          self << Task.new(**args, &)
         end
       end
     end

data/lib/karafka/pro/recurring_tasks/serializer.rb

@@ -11,7 +11,8 @@ module Karafka
         # Current recurring tasks related schema structure
         SCHEMA_VERSION = '1.0'
 
-        # @param schedule [Karafka::Pro::RecurringTasks::Schedule] schedule to serialize
+        # Serializes and compresses the schedule with all its tasks and their execution state
+        # @param schedule [Karafka::Pro::RecurringTasks::Schedule]
         # @return [String] serialized and compressed current schedule data with its tasks and their
         #   current state.
         def schedule(schedule)
@@ -46,7 +47,7 @@ module Karafka
         def command(command_name, task_id)
           data = {
             schema_version: SCHEMA_VERSION,
-            schedule_version: ::Karafka::Pro::RecurringTasks.schedule.version,
+            schedule_version: Karafka::Pro::RecurringTasks.schedule.version,
             dispatched_at: Time.now.to_f,
             type: 'command',
             command: {
@@ -69,7 +70,7 @@ module Karafka
 
           data = {
             schema_version: SCHEMA_VERSION,
-            schedule_version: ::Karafka::Pro::RecurringTasks.schedule.version,
+            schedule_version: Karafka::Pro::RecurringTasks.schedule.version,
             dispatched_at: Time.now.to_f,
             type: 'log',
             task: {
@@ -92,9 +93,9 @@ module Karafka
           hash.to_json
         end
 
-        # Compresses the provided data
+        # Compresses the provided data using Zlib deflate algorithm
         #
-        # @param data [String] data to compress
+        # @param data [String]
         # @return [String] compressed data
         def compress(data)
           Zlib::Deflate.deflate(data)

data/lib/karafka/pro/recurring_tasks/setup/config.rb

@@ -10,7 +10,7 @@ module Karafka
       module Setup
         # Config for recurring tasks
         class Config
-          extend ::Karafka::Core::Configurable
+          extend Karafka::Core::Configurable
 
           setting(:consumer_class, default: Consumer)
           setting(:deserializer, default: Deserializer.new)
@@ -27,7 +27,7 @@ module Karafka
           # a separate instance in case of heavy usage of the  transactional producer, etc.
           setting(
             :producer,
-            constructor: -> { ::Karafka.producer },
+            constructor: -> { Karafka.producer },
             lazy: true
           )
 

data/lib/karafka/pro/recurring_tasks/task.rb

@@ -31,7 +31,7 @@ module Karafka
         # @param block [Proc] code to execute.
         def initialize(id:, cron:, previous_time: 0, enabled: true, &block)
           @id = id
-          @cron = ::Fugit::Cron.do_parse(cron)
+          @cron = Fugit::Cron.do_parse(cron)
           @previous_time = previous_time
           @start_time = Time.now
           @executable = block

data/lib/karafka/pro/recurring_tasks.rb

@@ -7,16 +7,19 @@ module Karafka
   module Pro
     # Recurring tasks functionality
     module RecurringTasks
+      extend Helpers::ConfigImporter.new(
+        recurring_tasks_logging: %i[recurring_tasks logging]
+      )
+
       class << self
         # @return [Schedule, nil] current defined schedule or nil if not defined
         def schedule
-          @schedule || define('0.0.0') {}
+          @schedule || define('0.0.0') { nil }
         end
 
         # Simplified API for schedules definitions and validates the tasks data
         #
         # @param version [String]
-        # @param block [Proc]
         #
         # @example
         #   Karafka::Pro::RecurringTasks.define('1.0.1') do
@@ -24,9 +27,9 @@ module Karafka
         #       MailingJob.perform_async
         #     end
         #   end
-        def define(version = '1.0.0', &block)
+        def define(version = '1.0.0', &)
           @schedule = Schedule.new(version: version)
-          @schedule.instance_exec(&block)
+          @schedule.instance_exec(&)
 
           @schedule.each do |task|
             Contracts::Task.new.validate!(
@@ -75,7 +78,7 @@ module Karafka
           RecurringTasks.schedule
 
           # User can disable logging of executions, in which case we don't track them
-          return unless Karafka::App.config.recurring_tasks.logging
+          return unless recurring_tasks_logging
 
           Karafka.monitor.subscribe(Listener.new)
         end

data/lib/karafka/pro/routing/features/adaptive_iterator/contracts/topic.rb

@@ -13,10 +13,8 @@ module Karafka
             # Contract to validate configuration of the adaptive iterator feature
             class Topic < Karafka::Contracts::Base
               configure do |config|
-                config.error_messages = YAML.safe_load(
-                  File.read(
-                    File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
-                  )
+                config.error_messages = YAML.safe_load_file(
+                  File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
                 ).fetch('en').fetch('validations').fetch('routing').fetch('topic')
               end
 

data/lib/karafka/pro/routing/features/dead_letter_queue/contracts/topic.rb

@@ -13,10 +13,8 @@ module Karafka
             # Extended rules for dead letter queue settings
             class Topic < Karafka::Contracts::Base
               configure do |config|
-                config.error_messages = YAML.safe_load(
-                  File.read(
-                    File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
-                  )
+                config.error_messages = YAML.safe_load_file(
+                  File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
                 ).fetch('en').fetch('validations').fetch('routing').fetch('topic')
               end
 

data/lib/karafka/pro/routing/features/dead_letter_queue/topic.rb

@@ -22,6 +22,9 @@ module Karafka
             # @param strategy [#call, nil] Strategy we want to use or nil if a default strategy
             # (same as in OSS) should be applied
             # @param args [Hash] Pro DLQ arguments
+            # @option args [String, nil] :topic name of the dead letter queue topic
+            # @option args [Integer] :max_retries maximum number of retries before dispatch to DLQ
+            # @option args [Boolean] :independent whether DLQ runs independently
             def dead_letter_queue(strategy: nil, **args)
               return @dead_letter_queue if @dead_letter_queue
 

data/lib/karafka/pro/routing/features/delaying/contracts/topic.rb

@@ -13,10 +13,8 @@ module Karafka
             # Contract to validate configuration of the expiring feature
             class Topic < Karafka::Contracts::Base
               configure do |config|
-                config.error_messages = YAML.safe_load(
-                  File.read(
-                    File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
-                  )
+                config.error_messages = YAML.safe_load_file(
+                  File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
                 ).fetch('en').fetch('validations').fetch('routing').fetch('topic')
               end
 

data/lib/karafka/pro/routing/features/delaying/topic.rb

@@ -35,10 +35,8 @@ module Karafka
             end
 
             # Just an alias for nice API
-            #
-            # @param args [Array] Anything `#delaying` accepts
-            def delay_by(*args)
-              delaying(*args)
+            def delay_by(*)
+              delaying(*)
             end
 
             # @return [Boolean] is a given job delaying