karafka 2.5.9 → 2.6.0.beta1

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+# Karafka Pro - Source Available Commercial Software
+# Copyright (c) 2017-present Maciej Mensfeld. All rights reserved.
+#
+# This software is NOT open source. It is source-available commercial software
+# requiring a paid license for use. It is NOT covered by LGPL.
+#
+# The author retains all right, title, and interest in this software,
+# including all copyrights, patents, and other intellectual property rights.
+# No patent rights are granted under this license.
+#
+# PROHIBITED:
+# - Use without a valid commercial license
+# - Redistribution, modification, or derivative works without authorization
+# - Reverse engineering, decompilation, or disassembly of this software
+# - Use as training data for AI/ML models or inclusion in datasets
+# - Scraping, crawling, or automated collection for any purpose
+#
+# PERMITTED:
+# - Reading, referencing, and linking for personal or commercial use
+# - Runtime retrieval by AI assistants, coding agents, and RAG systems
+#   for the purpose of providing contextual help to Karafka users
+#
+# Receipt, viewing, or possession of this software does not convey or
+# imply any license or right beyond those expressly stated above.
+#
+# License: https://karafka.io/docs/Pro-License-Comm/
+# Contact: contact@karafka.io
+
+module Karafka
+  module Pro
+    module Processing
+      # Consumer-group-specific Pro processing components (driven by rebalance callbacks and
+      # partition ticks). Parallel `ShareGroups` will live next to this namespace once KIP-932
+      # lands.
+      module ConsumerGroups
+        # Selector of appropriate processing strategy matching topic combinations
+        # When using Karafka Pro, there is a different set of strategies than for regular, as
+        # there are different features.
+        class StrategySelector
+          attr_reader :strategies
+
+          # Strategies that we support in the Pro offering They can be combined
+          SUPPORTED_FEATURES = %i[
+            active_job
+            long_running_job
+            manual_offset_management
+            virtual_partitions
+            dead_letter_queue
+            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
+            @strategies = find_all
+          end
+
+          # @param topic [Karafka::Routing::Topic] topic with settings based on which we find
+          #   the strategy
+          # @return [Module] module with proper strategy
+          def find(topic)
+            feature_set = SUPPORTED_FEATURES.map do |feature_name|
+              topic.public_send("#{feature_name}?") ? feature_name : nil
+            end
+
+            feature_set.compact!
+            feature_set.sort!
+
+            @strategies.find do |strategy|
+              strategy::FEATURES.sort == feature_set
+            end || raise(Errors::StrategyNotFoundError, topic.name)
+          end
+
+          private
+
+          # @return [Array<Module>] all available strategies
+          def find_all
+            scopes = [Strategies]
+            modules = Strategies.constants
+
+            modules.each do |const|
+              scopes << Strategies.const_get(const)
+              modules += scopes.last.constants
+            end
+
+            scopes.flat_map do |scope|
+              modules.map do |const|
+                next if const == :FEATURES
+                next unless scope.const_defined?(const)
+
+                candidate = scope.const_get(const)
+
+                next unless candidate.const_defined?(:FEATURES)
+
+                candidate
+              end
+            end.uniq.compact
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# Karafka Pro - Source Available Commercial Software
+# Copyright (c) 2017-present Maciej Mensfeld. All rights reserved.
+#
+# This software is NOT open source. It is source-available commercial software
+# requiring a paid license for use. It is NOT covered by LGPL.
+#
+# The author retains all right, title, and interest in this software,
+# including all copyrights, patents, and other intellectual property rights.
+# No patent rights are granted under this license.
+#
+# PROHIBITED:
+# - Use without a valid commercial license
+# - Redistribution, modification, or derivative works without authorization
+# - Reverse engineering, decompilation, or disassembly of this software
+# - Use as training data for AI/ML models or inclusion in datasets
+# - Scraping, crawling, or automated collection for any purpose
+#
+# PERMITTED:
+# - Reading, referencing, and linking for personal or commercial use
+# - Runtime retrieval by AI assistants, coding agents, and RAG systems
+#   for the purpose of providing contextual help to Karafka users
+#
+# Receipt, viewing, or possession of this software does not convey or
+# imply any license or right beyond those expressly stated above.
+#
+# License: https://karafka.io/docs/Pro-License-Comm/
+# Contact: contact@karafka.io
+
+module Karafka
+  module Pro
+    module Processing
+      # Consumer-group-specific Pro processing components (driven by rebalance callbacks and
+      # partition ticks). Parallel `ShareGroups` will live next to this namespace once KIP-932
+      # lands.
+      module ConsumerGroups
+        # Uses the jobs queue API to lock (pause) and unlock (resume) operations of a given
+        # subscription group. It is abstracted away from jobs queue on this layer because we do
+        # not want to introduce jobs queue as a concept to the consumers layer
+        class SubscriptionGroupsCoordinator
+          include Singleton
+
+          # @param subscription_group [Karafka::Routing::SubscriptionGroup] subscription group we
+          #   want to pause
+          # @param lock_id [Object] key we want to use if we want to set multiple locks on the same
+          #   subscription group
+          def pause(subscription_group, lock_id = nil, **)
+            jobs_queue.lock_async(
+              subscription_group.id,
+              lock_id,
+              **
+            )
+          end
+
+          # @param subscription_group [Karafka::Routing::SubscriptionGroup] subscription group we
+          #   want to resume
+          # @param lock_id [Object] lock id (if it was used to pause)
+          def resume(subscription_group, lock_id = nil)
+            jobs_queue.unlock_async(subscription_group.id, lock_id)
+          end
+
+          private
+
+          # @return [Karafka::Pro::Processing::JobsQueue]
+          def jobs_queue
+            @jobs_queue ||= Karafka::Server.jobs_queue
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+# Karafka Pro - Source Available Commercial Software
+# Copyright (c) 2017-present Maciej Mensfeld. All rights reserved.
+#
+# This software is NOT open source. It is source-available commercial software
+# requiring a paid license for use. It is NOT covered by LGPL.
+#
+# The author retains all right, title, and interest in this software,
+# including all copyrights, patents, and other intellectual property rights.
+# No patent rights are granted under this license.
+#
+# PROHIBITED:
+# - Use without a valid commercial license
+# - Redistribution, modification, or derivative works without authorization
+# - Reverse engineering, decompilation, or disassembly of this software
+# - Use as training data for AI/ML models or inclusion in datasets
+# - Scraping, crawling, or automated collection for any purpose
+#
+# PERMITTED:
+# - Reading, referencing, and linking for personal or commercial use
+# - Runtime retrieval by AI assistants, coding agents, and RAG systems
+#   for the purpose of providing contextual help to Karafka users
+#
+# Receipt, viewing, or possession of this software does not convey or
+# imply any license or right beyond those expressly stated above.
+#
+# License: https://karafka.io/docs/Pro-License-Comm/
+# Contact: contact@karafka.io
+
+module Karafka
+  module Pro
+    module Processing
+      # Consumer-group-specific Pro processing components (driven by rebalance callbacks and
+      # partition ticks). Parallel `ShareGroups` will live next to this namespace once KIP-932
+      # lands.
+      module ConsumerGroups
+        module VirtualPartitions
+          module Distributors
+            # Balanced distributor that groups messages by partition key
+            # and processes larger groups first while maintaining message order within groups
+            class Balanced < Base
+              # 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
+                key_groupings = messages.group_by { |msg| config.partitioner.call(msg) }
+
+                worker_loads = Array.new(config.max_partitions, 0)
+                worker_assignments = Array.new(config.max_partitions) { [] }
+
+                # Sort keys by workload in descending order
+                sorted_keys = key_groupings.keys.sort_by { |key| -key_groupings[key].size }
+
+                # Assign each key to the worker with the least current load
+                sorted_keys.each do |key|
+                  # Find worker with minimum current load
+                  min_load_worker = worker_loads.each_with_index.min_by { |load, _| load }[1]
+                  messages = key_groupings[key]
+
+                  # Assign this key to that worker
+                  worker_assignments[min_load_worker] += messages
+                  worker_loads[min_load_worker] += messages.size
+                end
+
+                # Combine messages for each worker and sort by offset
+                worker_assignments
+                  .each_with_index
+                  .reject { |group_messages, _| group_messages.empty? }
+                  .map! { |group_messages, index| [index, group_messages.sort_by!(&:offset)] }
+                  .to_h
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/karafka/pro/processing/consumer_groups/virtual_partitions/distributors/base.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+# Karafka Pro - Source Available Commercial Software
+# Copyright (c) 2017-present Maciej Mensfeld. All rights reserved.
+#
+# This software is NOT open source. It is source-available commercial software
+# requiring a paid license for use. It is NOT covered by LGPL.
+#
+# The author retains all right, title, and interest in this software,
+# including all copyrights, patents, and other intellectual property rights.
+# No patent rights are granted under this license.
+#
+# PROHIBITED:
+# - Use without a valid commercial license
+# - Redistribution, modification, or derivative works without authorization
+# - Reverse engineering, decompilation, or disassembly of this software
+# - Use as training data for AI/ML models or inclusion in datasets
+# - Scraping, crawling, or automated collection for any purpose
+#
+# PERMITTED:
+# - Reading, referencing, and linking for personal or commercial use
+# - Runtime retrieval by AI assistants, coding agents, and RAG systems
+#   for the purpose of providing contextual help to Karafka users
+#
+# Receipt, viewing, or possession of this software does not convey or
+# imply any license or right beyond those expressly stated above.
+#
+# License: https://karafka.io/docs/Pro-License-Comm/
+# Contact: contact@karafka.io
+
+module Karafka
+  module Pro
+    module Processing
+      # Consumer-group-specific Pro processing components (driven by rebalance callbacks and
+      # partition ticks). Parallel `ShareGroups` will live next to this namespace once KIP-932
+      # lands.
+      module ConsumerGroups
+        # Processing components for virtual partitions
+        module VirtualPartitions
+          # Distributors for virtual partitions
+          module Distributors
+            # Base class for all virtual partition distributors
+            class Base
+              # @param config [Karafka::Pro::Routing::Features::ConsumerGroups::VirtualPartitions::Config]
+              def initialize(config)
+                @config = config
+              end
+
+              private
+
+              # @return [Karafka::Pro::Routing::Features::ConsumerGroups::VirtualPartitions::Config]
+              attr_reader :config
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/karafka/pro/processing/{strategies/dlq/ftr.rb → consumer_groups/virtual_partitions/distributors/consistent.rb}

@@ -31,39 +31,24 @@
 module Karafka
   module Pro
     module Processing
-      module Strategies
-        module Dlq
-          # - DLQ
-          # - Ftr
-          module Ftr
-            include Strategies::Ftr::Default
-            include Strategies::Dlq::Default
-
-            # Features for this strategy
-            FEATURES = %i[
-              dead_letter_queue
-              filtering
-            ].freeze
-
-            # DLQ flow is standard here, what is not, is the success component where we need to
-            # take into consideration the filtering
-            def handle_after_consume
-              coordinator.on_finished do |last_group_message|
-                return if revoked?
-
-                if coordinator.success?
-                  coordinator.pause_tracker.reset
-
-                  return if coordinator.manual_pause?
-
-                  mark_as_consumed(last_group_message)
-
-                  handle_post_filtering
-                else
-                  apply_dlq_flow do
-                    dispatch_if_needed_and_mark_as_consumed
-                  end
-                end
+      # Consumer-group-specific Pro processing components (driven by rebalance callbacks and
+      # partition ticks). Parallel `ShareGroups` will live next to this namespace once KIP-932
+      # lands.
+      module ConsumerGroups
+        module VirtualPartitions
+          module Distributors
+            # Consistent distributor that ensures messages with the same partition key
+            # are always processed in the same virtual partition
+            class Consistent < Base
+              # 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
+                  .group_by { |msg| config.reducer.call(config.partitioner.call(msg)) }
+                  .to_h
               end
             end
           end

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

@@ -31,68 +31,10 @@
 module Karafka
   module Pro
     module Processing
+      # Backwards-compatible aliases for filter classes moved under ConsumerGroups.
       module Filters
-        # Base for all the filters.
-        # All filters (including custom) need to use this API.
-        #
-        # Due to the fact, that filters can limit data in such a way, that we need to pause or
-        # seek (throttling for example), the api is not just "remove some things from batch" but
-        # also provides ways to control the post-filtering operations that may be needed.
-        class Base
-          # @return [Karafka::Messages::Message, nil] the message that we want to use as a cursor
-          #   one to pause or seek or nil if not applicable.
-          attr_reader :cursor
-
-          include Karafka::Core::Helpers::Time
-
-          # Initializes the filter as not yet applied
-          def initialize
-            @applied = false
-            @cursor = nil
-          end
-
-          # @param messages [Array<Karafka::Messages::Message>] array with messages. Please keep
-          #   in mind, this may already be partial due to execution of previous filters.
-          def apply!(messages)
-            raise NotImplementedError, "Implement in a subclass"
-          end
-
-          # @return [Symbol] filter post-execution action on consumer. Either `:skip`, `:pause` or
-          #   `:seek`.
-          def action
-            :skip
-          end
-
-          # @return [Boolean] did this filter change messages in any way
-          def applied?
-            @applied
-          end
-
-          # @return [Integer, nil] default timeout for pausing (if applicable) or nil if not
-          # @note Please do not return `0` when your filter is not pausing as it may interact
-          #   with other filters that want to pause.
-          def timeout
-            nil
-          end
-
-          # @return [Boolean] should we use the cursor value to mark as consumed. If any of the
-          #   filters returns true, we return lowers applicable cursor value (if any)
-          def mark_as_consumed?
-            false
-          end
-
-          # @return [Symbol] `:mark_as_consumed` or `:mark_as_consumed!`. Applicable only if
-          #   marking is requested
-          def marking_method
-            :mark_as_consumed
-          end
-
-          # @return [Karafka::Messages::Message, nil] cursor message for marking or nil if no
-          #   marking
-          def marking_cursor
-            cursor
-          end
-        end
+        # @see ConsumerGroups::Filters::Base
+        Base = ConsumerGroups::Filters::Base
       end
     end
   end

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

@@ -31,63 +31,8 @@
 module Karafka
   module Pro
     module Processing
-      # Pro partitioner that can distribute work based on the virtual partitioner settings
-      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
-        #   will be used with those messages
-        # @yieldparam [Integer] group id
-        # @yieldparam [Array<Karafka::Messages::Message>] karafka messages
-        def call(topic, messages, coordinator)
-          ktopic = @subscription_group.topics.find(topic)
-
-          vps = ktopic.virtual_partitions
-
-          # We only partition work if we have:
-          # - a virtual partitioner
-          # - more than one thread to process the data
-          # - collective is not collapsed via coordinator
-          # - none of the partitioner executions raised an error
-          #
-          # With one thread it is not worth partitioning the work as the work itself will be
-          # assigned to one thread (pointless work)
-          #
-          # We collapse the partitioning on errors because we "regain" full ordering on a batch
-          # that potentially contains the data that caused the error.
-          #
-          # This is great because it allows us to run things without the parallelization that adds
-          # a bit of uncertainty and allows us to use DLQ and safely skip messages if needed.
-          if vps.active? && vps.max_partitions > 1 && !coordinator.collapsed?
-            # If we cannot virtualize even one message from a given batch due to user errors, we
-            # reduce the whole set into one partition and emit error. This should still allow for
-            # user flow but should mitigate damages by not virtualizing
-            begin
-              groupings = vps.distributor.call(messages)
-            rescue => e
-              # This should not happen. If you are seeing this it means your partitioner code
-              # failed and raised an error. We highly recommend mitigating partitioner level errors
-              # on the user side because this type of collapse should be considered a last resort
-              Karafka.monitor.instrument(
-                "error.occurred",
-                caller: self,
-                error: e,
-                messages: messages,
-                type: "virtual_partitions.partitioner.error"
-              )
-
-              groupings = { 0 => messages }
-            end
-
-            groupings.each do |key, messages_group|
-              yield(key, messages_group)
-            end
-          else
-            # When no virtual partitioner, works as regular one
-            yield(0, messages)
-          end
-        end
-      end
+      # @see ConsumerGroups::Partitioner
+      Partitioner = ConsumerGroups::Partitioner
     end
   end
 end

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

@@ -59,7 +59,8 @@ module Karafka
           # Runs the consumption jobs scheduling flow under a mutex
           #
           # @param jobs_array
-          #   [Array<Karafka::Processing::Jobs::Consume, Processing::Jobs::ConsumeNonBlocking>]
+          #   [Array<Karafka::Processing::ConsumerGroups::Jobs::Consume,
+          #   Karafka::Pro::Processing::ConsumerGroups::Jobs::ConsumeNonBlocking>]
           #   jobs for scheduling
           def on_schedule_consumption(jobs_array)
             @mutex.synchronize do
@@ -70,7 +71,8 @@ module Karafka
           # Should schedule the consumption jobs
           #
           # @param _jobs_array
-          #   [Array<Karafka::Processing::Jobs::Consume, Processing::Jobs::ConsumeNonBlocking>]
+          #   [Array<Karafka::Processing::ConsumerGroups::Jobs::Consume,
+          #   Karafka::Pro::Processing::ConsumerGroups::Jobs::ConsumeNonBlocking>]
           #   jobs for scheduling
           def schedule_consumption(_jobs_array)
             raise NotImplementedError, "Implement in a subclass"
@@ -79,7 +81,8 @@ module Karafka
           # Runs the revocation jobs scheduling flow under a mutex
           #
           # @param jobs_array
-          #   [Array<Karafka::Processing::Jobs::Revoked, Processing::Jobs::RevokedNonBlocking>]
+          #   [Array<Karafka::Processing::ConsumerGroups::Jobs::Revoked,
+          #   Karafka::Pro::Processing::ConsumerGroups::Jobs::RevokedNonBlocking>]
           #   jobs for scheduling
           def on_schedule_revocation(jobs_array)
             @mutex.synchronize do
@@ -89,7 +92,7 @@ module Karafka
 
           # Runs the shutdown jobs scheduling flow under a mutex
           #
-          # @param jobs_array [Array<Karafka::Processing::Jobs::Shutdown>] jobs for scheduling
+          # @param jobs_array [Array<Karafka::Processing::ConsumerGroups::Jobs::Shutdown>] jobs for scheduling
           def on_schedule_shutdown(jobs_array)
             @mutex.synchronize do
               schedule_shutdown(jobs_array)
@@ -98,7 +101,7 @@ module Karafka
 
           # Runs the idle jobs scheduling flow under a mutex
           #
-          # @param jobs_array [Array<Karafka::Processing::Jobs::Idle>] jobs for scheduling
+          # @param jobs_array [Array<Karafka::Processing::ConsumerGroups::Jobs::Idle>] jobs for scheduling
           def on_schedule_idle(jobs_array)
             @mutex.synchronize do
               schedule_idle(jobs_array)
@@ -108,7 +111,8 @@ module Karafka
           # Runs the periodic jobs scheduling flow under a mutex
           #
           # @param jobs_array
-          #   [Array<Processing::Jobs::Periodic, Processing::Jobs::PeriodicNonBlocking>]
+          #   [Array<Karafka::Pro::Processing::ConsumerGroups::Jobs::Periodic,
+          #   Karafka::Pro::Processing::ConsumerGroups::Jobs::PeriodicNonBlocking>]
           #   jobs for scheduling
           def on_schedule_periodic(jobs_array)
             @mutex.synchronize do

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

@@ -49,7 +49,8 @@ module Karafka
           # Schedules jobs in the LJF order for consumption
           #
           # @param jobs_array
-          #   [Array<Karafka::Processing::Jobs::Consume, Processing::Jobs::ConsumeNonBlocking>]
+          #   [Array<Karafka::Processing::ConsumerGroups::Jobs::Consume,
+          #   Karafka::Pro::Processing::ConsumerGroups::Jobs::ConsumeNonBlocking>]
           #   jobs for scheduling
           def on_schedule_consumption(jobs_array)
             perf_tracker = Instrumentation::PerformanceTracker.instance
@@ -85,8 +86,7 @@ module Karafka
           alias_method :on_schedule_periodic, :schedule_fifo
           alias_method :on_schedule_eofed, :schedule_fifo
 
-          # This scheduler does not have anything to manage as it is a pass through and has no
-          # state
+          # This scheduler does not have anything to manage as it is a pass through and has no state
           def on_manage
             nil
           end
@@ -101,10 +101,11 @@ module Karafka
           private
 
           # @param perf_tracker [PerformanceTracker]
-          # @param job [Karafka::Processing::Jobs::Consume] job we will be processing
+          # @param job [Karafka::Processing::ConsumerGroups::Jobs::Consume] job we will be
+          #   processing
           # @return [Numeric] estimated cost of processing this job
           def processing_cost(perf_tracker, job)
-            if job.is_a?(::Karafka::Processing::Jobs::Consume)
+            if job.is_a?(::Karafka::Processing::ConsumerGroups::Jobs::Consume)
               messages = job.messages
               message = messages.first
 

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

@@ -93,8 +93,7 @@ module Karafka
 
           @replaying = false
 
-          # When there is nothing to replay and synchronize, we can just save the state and
-          # proceed
+          # When there is nothing to replay and synchronize, we can just save the state and proceed
           if @catchup_commands.empty? && @catchup_schedule.nil?
             snapshot
 

data/lib/karafka/pro/routing/features/{active_job → consumer_groups/active_job}/builder.rb

@@ -32,26 +32,28 @@ module Karafka
   module Pro
     module Routing
       module Features
-        class ActiveJob < Base
-          # Pro ActiveJob builder expansions
-          module Builder
-            # This method simplifies routes definition for ActiveJob patterns / queues by
-            # auto-injecting the consumer class and other things needed
-            #
-            # @param regexp_or_name [String, Symbol, Regexp] pattern name or regexp to use
-            #   auto-generated regexp names
-            # @param regexp [Regexp, nil] activejob regexp pattern or nil when regexp is provided
-            #   as the first argument
-            # @param block [Proc] block that we can use for some extra configuration
-            def active_job_pattern(regexp_or_name, regexp = nil, &block)
-              pattern(regexp_or_name, regexp) do
-                consumer App.config.internal.active_job.consumer_class
-                active_job true
-                manual_offset_management true
+        module ConsumerGroups
+          class ActiveJob < Base
+            # Pro ActiveJob builder expansions
+            module Builder
+              # This method simplifies routes definition for ActiveJob patterns / queues by
+              # auto-injecting the consumer class and other things needed
+              #
+              # @param regexp_or_name [String, Symbol, Regexp] pattern name or regexp to use
+              #   auto-generated regexp names
+              # @param regexp [Regexp, nil] activejob regexp pattern or nil when regexp is provided
+              #   as the first argument
+              # @param block [Proc] block that we can use for some extra configuration
+              def active_job_pattern(regexp_or_name, regexp = nil, &block)
+                pattern(regexp_or_name, regexp) do
+                  consumer App.config.internal.active_job.consumer_class
+                  active_job true
+                  manual_offset_management true
 
-                next unless block
+                  next unless block
 
-                instance_eval(&block)
+                  instance_eval(&block)
+                end
               end
             end
           end