karafka 2.6.0.beta1 → 2.6.0.rc1

data/lib/karafka/pro/instrumentation/performance_tracker.rb

@@ -45,19 +45,26 @@ module Karafka
         private_constant :SAMPLES_COUNT
 
         # Builds up nested concurrent hash for data tracking
+        #
+        # @note Samples are scoped by subscription group id so that two groups consuming the same
+        #   topic name keep independent measurements - and so revoking a partition in one group
+        #   never drops samples another group is still using.
         def initialize
-          @processing_times = Hash.new do |topics_hash, topic|
-            topics_hash[topic] = Hash.new do |partitions_hash, partition|
-              partitions_hash[partition] = []
+          @processing_times = Hash.new do |groups_hash, group_id|
+            groups_hash[group_id] = Hash.new do |topics_hash, topic|
+              topics_hash[topic] = Hash.new do |partitions_hash, partition|
+                partitions_hash[partition] = []
+              end
             end
           end
         end
 
+        # @param group_id [String] subscription group id the topic partition belongs to
         # @param topic [String]
         # @param partition [Integer]
         # @return [Float] p95 processing time of a single message from a single topic partition
-        def processing_time_p95(topic, partition)
-          values = @processing_times[topic][partition]
+        def processing_time_p95(group_id, topic, partition)
+          values = @processing_times[group_id][topic][partition]
 
           return 0 if values.empty?
           return values.first if values.size == 1
@@ -71,10 +78,11 @@ module Karafka
         def on_consumer_consumed(event)
           consumer = event[:caller]
           messages = consumer.messages
+          group_id = consumer.topic.subscription_group.id
           topic = messages.metadata.topic
           partition = messages.metadata.partition
 
-          samples = @processing_times[topic][partition]
+          samples = @processing_times[group_id][topic][partition]
           samples << (event[:time] / messages.size)
 
           return unless samples.size > SAMPLES_COUNT
@@ -82,6 +90,32 @@ module Karafka
           samples.shift
         end
 
+        # @param event [Karafka::Core::Monitoring::Event] rebalance revoked event details
+        # Evicts the processing time samples of revoked partitions so the tracker does not retain
+        # them for the whole process lifetime. Without this every (topic, partition) ever consumed
+        # keeps its samples array forever - unbounded under regex pattern subscriptions that keep
+        # discovering new topic names. Mirrors the offset metadata fetcher, which also clears on
+        # revoke. Samples are scoped by subscription group, so we only ever evict the revoked
+        # group's data and never another group consuming the same topic.
+        def on_rebalance_partitions_revoked(event)
+          group_id = event[:subscription_group_id]
+
+          # Do not auto-vivify a branch for a group we have never tracked
+          return unless @processing_times.key?(group_id)
+
+          group_times = @processing_times[group_id]
+
+          event[:tpl].to_h.each do |topic, partitions|
+            next unless group_times.key?(topic)
+
+            topic_times = group_times[topic]
+            partitions.each { |partition| topic_times.delete(partition.partition) }
+            group_times.delete(topic) if topic_times.empty?
+          end
+
+          @processing_times.delete(group_id) if group_times.empty?
+        end
+
         private
 
         # Computers the requested percentile out of provided values

data/lib/karafka/pro/iterator/tpl_builder.rb

@@ -129,7 +129,7 @@ module Karafka
           # librdkafka's per-partition metadata cache for all integer-offset partitions in
           # one roundtrip. Without this pre-fetch, librdkafka triggers a much broader
           # metadata refresh when assign is called later, adding at least a second to
-          # iterator startup — noticeable in latency-sensitive contexts like Puma.
+          # iterator startup - noticeable in latency-sensitive contexts like Puma.
           # The epoch timestamp ensures every partition returns its LWM; the result is
           # intentionally discarded since we only need the warm-up side effect here.
           warm_up_tpl = Rdkafka::Consumer::TopicPartitionList.new
@@ -142,16 +142,36 @@ module Karafka
 
           return if negative_partitions.empty?
 
-          # Batch-fetch LWM and HWM for all negative-offset partitions in two admin calls
-          # (one for :earliest, one for :latest) instead of N per-partition consumer calls
-          watermarks = Karafka::Admin::Topics.read_watermark_offsets(
-            negative_partitions.transform_values(&:keys)
-          )
+          # Batch-fetch LWM and HWM for all negative-offset partitions in two calls (one for
+          # :earliest, one for :latest) instead of N per-partition watermark queries. Both run
+          # on the consumer own connection, so no dedicated admin client is ever created. The
+          # proxy passes no isolation level, so :latest resolves with the librdkafka default
+          # (read_uncommitted), i.e. the true high watermark - same as the previous
+          # read_watermark_offsets path this replaced
+          low_specs = {}
+          high_specs = {}
+
+          negative_partitions.each do |name, partitions|
+            low_specs[name] = partitions.keys.map { |p| { partition: p, offset: :earliest } }
+            high_specs[name] = partitions.keys.map { |p| { partition: p, offset: :latest } }
+          end
+
+          lows = {}
+          highs = {}
+
+          @consumer.read_partition_offsets(low_specs).each do |result|
+            (lows[result[:topic]] ||= {})[result[:partition]] = result[:offset]
+          end
+
+          @consumer.read_partition_offsets(high_specs).each do |result|
+            (highs[result[:topic]] ||= {})[result[:partition]] = result[:offset]
+          end
 
           negative_partitions.each do |name, partitions|
             partitions.each do |partition, offset|
+              low = lows.dig(name, partition) || 0
+              high = highs.dig(name, partition) || 0
               # We add because this offset is negative
-              low, high = watermarks.dig(name, partition) || [0, 0]
               @mapped_topics[name][partition] = [high + offset, low].max
             end
           end

data/lib/karafka/pro/iterator.rb

@@ -74,7 +74,12 @@ module Karafka
 
         @total_partitions = @topics_with_partitions.map(&:last).sum(&:count)
 
-        @stopped_partitions = 0
+        # Set of [topic, partition] that have reached EOF or were explicitly stopped. We track
+        # identities instead of counting EOF events because librdkafka re-emits EOF for the same
+        # partition every time it reaches the end again after new data arrived. Counting events
+        # would let a single live partition exhaust the whole EOF budget and terminate iteration
+        # while other partitions still had a backlog.
+        @stopped_partitions = Set.new
 
         @settings = settings
         @yield_nil = yield_nil
@@ -115,9 +120,14 @@ module Karafka
           @current_message = nil
           @current_consumer = nil
         end
-
-        # Reset so we can use the same iterator again if needed
-        @stopped_partitions = 0
+      ensure
+        # Reset so we can use the same iterator again if needed, regardless of how the previous run
+        # ended: normal completion, `#stop`, or a `break` out of the yielded block. A `break` is a
+        # non-local return out of `#each`; placed after the loop this reset would be skipped on a
+        # break, leaving `@stopped_partitions` full so the next run's `done?` is immediately true
+        # and the whole iteration becomes a silent no-op.
+        @stopped_partitions = Set.new
+        @stopped = false
       end
 
       # Stops the partition we're currently yielded into
@@ -138,7 +148,7 @@ module Karafka
       # @param name [String] topic name of which partition we want to stop
       # @param partition [Integer] partition we want to stop processing
       def stop_partition(name, partition)
-        @stopped_partitions += 1
+        @stopped_partitions << [name, partition]
 
         @current_consumer.pause(
           Rdkafka::Consumer::TopicPartitionList.new(
@@ -178,7 +188,12 @@ module Karafka
       rescue Rdkafka::RdkafkaError => e
         # End of partition
         if e.code == :partition_eof
-          @stopped_partitions += 1
+          # The error details carry the topic and partition of the EOF-ed partition. We track
+          # them instead of counting events: librdkafka re-emits EOF for the same partition
+          # whenever it reaches the end again after new data arrived, and an explicitly stopped
+          # partition can also EOF - either would inflate a plain counter and end the iteration
+          # before other partitions were fully consumed
+          @stopped_partitions << [e.details[:topic], e.details[:partition]]
 
           retry
         end
@@ -201,7 +216,7 @@ module Karafka
       # Do we have all the data we wanted or did every topic partition has reached eof.
       # @return [Boolean]
       def done?
-        (@stopped_partitions >= @total_partitions) || @stopped
+        (@stopped_partitions.size >= @total_partitions) || @stopped
       end
     end
   end

data/lib/karafka/pro/loader.rb

@@ -84,6 +84,14 @@ module Karafka
 
           # We initialize it here so we don't initialize it during multi-threading work
           Processing::ConsumerGroups::SubscriptionGroupsCoordinator.instance
+
+          # Subscribe the paused partitions lags refresher only when the feature is enabled.
+          # It is checked post setup as the interval is user-configurable during setup
+          unless config.internal.statistics.consumer_groups.lag_compensation.interval.zero?
+            config.monitor.subscribe(
+              Instrumentation::ConsumerGroups::LagCompensation::Refresher.new
+            )
+          end
         end
 
         # Runs operations needed after fork in swarm for features that need it
@@ -135,6 +143,10 @@ module Karafka
           icfg.active_job.dispatcher = ActiveJob::Dispatcher.new
           icfg.active_job.job_options_contract = ActiveJob::JobOptionsContract.new
 
+          # The decorator is swapped unconditionally as it is a pass-through when the paused
+          # partitions lags refreshing is disabled or when there is no refreshed data
+          icfg.statistics.consumer_groups.decorator_class = Instrumentation::Callbacks::ConsumerGroups::Decorator
+
           config.monitor.subscribe(Instrumentation::PerformanceTracker.instance)
         end
 

data/lib/karafka/pro/processing/consumer_groups/adaptive_iterator/consumer.rb

@@ -31,9 +31,6 @@
 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
         # Namespace for adaptive iterator consumer components
         module AdaptiveIterator

data/lib/karafka/pro/processing/consumer_groups/adaptive_iterator/tracker.rb

@@ -31,9 +31,6 @@
 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 AdaptiveIterator
           # Tracker is responsible for monitoring the processing of messages within the poll
@@ -45,7 +42,8 @@ module Karafka
 
             # Initializes a new Tracker instance.
             #
-            # @param safety_margin [Float] The safety margin percentage (0-100) to leave as a buffer.
+            # @param safety_margin [Float] The safety margin percentage (0-100) to leave as a
+            #   buffer.
             # @param last_polled_at [Float] The timestamp of the last polling in milliseconds.
             # @param max_poll_interval_ms [Integer] The maximum poll interval time in milliseconds.
             def initialize(

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

@@ -31,16 +31,13 @@
 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
         # Manages the collapse of virtual partitions
         # Since any non-virtual partition is actually a virtual partition of size one, we can use
         # it in a generic manner without having to distinguish between those cases.
         #
-        # We need to have notion of the offset until we want to collapse because upon pause and retry
-        # rdkafka may purge the buffer. This means, that we may end up with smaller or bigger
+        # We need to have notion of the offset until we want to collapse because upon pause and
+        # retry rdkafka may purge the buffer. This means, that we may end up with smaller or bigger
         # (different) dataset and without tracking the end of collapse, there would be a chance for
         # things to flicker. Tracking allows us to ensure, that collapse is happening until all the
         # messages from the corrupted batch are processed.
@@ -57,8 +54,8 @@ module Karafka
             @collapsed
           end
 
-          # Collapse until given offset. Until given offset is encountered or offset bigger than that
-          # we keep collapsing.
+          # Collapse until given offset. Until given offset is encountered or offset bigger than
+          # that we keep collapsing.
           # @param offset [Integer] offset until which we keep the collapse
           def collapse_until!(offset)
             @mutex.synchronize do
@@ -69,8 +66,8 @@ module Karafka
             end
           end
 
-          # Sets the collapse state based on the first collective offset that we are going to process
-          # and makes the decision whether or not we need to still keep the collapse.
+          # Sets the collapse state based on the first collective offset that we are going to
+          # process and makes the decision whether or not we need to still keep the collapse.
           # @param first_offset [Integer] first offset from a collective batch
           def refresh!(first_offset)
             @mutex.synchronize do

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

@@ -31,9 +31,6 @@
 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
         # Pro coordinator that provides extra orchestration methods useful for parallel processing
         # within the same partition
@@ -95,7 +92,7 @@ module Karafka
             # need to make sure we collect them all. Under collapse when we reference a given
             # consumer we should be able to get all the errors and not just first/last.
             #
-            # @note We use zero as the attempt mark because we are not "yet" in the attempt 1
+            # We use zero as the attempt mark because we are not "yet" in the attempt 1
             @errors_tracker.clear if attempt.zero?
             @executed.clear
 

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

@@ -31,9 +31,6 @@
 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
         # Namespace for Pro coordinator related sub-components
         module Coordinators

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

@@ -31,9 +31,6 @@
 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 Coordinators
           # Applier for all filters we want to have. Whether related to limiting messages based
@@ -43,6 +40,10 @@ module Karafka
           # This means that this is the API we expose as a single filter, allowing us to control
           # the filtering via many filters easily.
           class FiltersApplier
+            # Provides `#skip?`, `#pause?` and `#seek?` predicates built on top of `#action`, the
+            # same API individual filters expose
+            include Filters::Actions
+
             # @return [Array] registered filters array. Useful if we want to inject internal context
             #   aware filters.
             attr_reader :filters
@@ -79,25 +80,35 @@ module Karafka
               !applied.empty?
             end
 
-            # @return [Symbol] consumer post-filtering action that should be taken
+            # @return [Symbol] consumer post-filtering action that should be taken. One of
+            #   {Filters::Actions::ALL}.
             def action
-              return :skip unless applied?
+              return Filters::Actions.skip unless applied?
 
               # The highest priority is on a potential backoff from any of the filters because it is
               # the less risky (delay and continue later)
-              return :pause if applied.any? { |filter| filter.action == :pause }
+              return Filters::Actions.pause if applied.any?(&:pause?)
 
               # If none of the filters wanted to pause, we can check for any that would want to seek
               # and if there is any, we can go with this strategy
-              return :seek if applied.any? { |filter| filter.action == :seek }
+              return Filters::Actions.seek if applied.any?(&:seek?)
 
-              :skip
+              Filters::Actions.skip
             end
 
             # @return [Integer] minimum timeout we need to pause. This is the minimum for all the
-            #   filters to satisfy all of them.
+            #   pausing filters to satisfy all of them: we pause for the shortest requested backoff,
+            #   re-poll and re-apply, and any filter that still needs more time pauses again. We
+            #   consider only filters that actually resolved to `:pause`. Per the filter contract
+            #   non-pausing filters should report a `nil` timeout, but the built-in
+            #   throttler/delayer report `0` when seeking; including such a filter let that `0`
+            #   collapse the pause to `0`, which expires immediately and busy-spins instead of
+            #   backing off.
             def timeout
-              applied.filter_map(&:timeout).min || 0
+              applied
+                .select(&:pause?)
+                .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

data/lib/karafka/pro/processing/consumer_groups/coordinators/virtual_offset_manager.rb

@@ -31,9 +31,6 @@
 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 Coordinators
           # Manager that keeps track of our offsets with the virtualization layer that are local
@@ -173,7 +170,10 @@ module Karafka
 
               offset_metadata = case @offset_metadata_strategy
               when :exact
-                @offsets_metadata.fetch(@real_offset)
+                # When the lowest-offset group is unmarked, the materialized real offset falls back
+                # to `min - 1` (see #materialize_real_offset), an offset that was never registered
+                # and thus has no metadata. Fall back to the current metadata instead of raising.
+                @offsets_metadata.fetch(@real_offset, @current_offset_metadata)
               when :current
                 @current_offset_metadata
               else

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

@@ -31,9 +31,6 @@
 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
         # Pro selector of appropriate topic setup based features enhancements.
         class ExpansionsSelector < Karafka::Processing::ConsumerGroups::ExpansionsSelector

data/lib/karafka/pro/processing/consumer_groups/filters/actions.rb

@@ -0,0 +1,84 @@
+# 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
+      module ConsumerGroups
+        module Filters
+          # Single source of truth for the post-filtering actions. Exposes each action as a method
+          # (so filters and internal code can return `Actions.pause` instead of the raw `:pause`
+          # symbol), the full `ALL` list, and the `#skip?` / `#pause?` / `#seek?` predicate helpers
+          # built on top of `#action`. The predicates are mixed into both individual filters
+          # (`Filters::Base`) and the aggregating `Coordinators::FiltersApplier`, so both expose the
+          # same API instead of comparing the `#action` symbol directly. The returned values are the
+          # plain symbols, so filters that still return `:skip`/`:pause`/`:seek` directly keep
+          # working.
+          module Actions
+            class << self
+              # @return [Symbol] the filter did not alter the consumption flow
+              def skip
+                :skip
+              end
+
+              # @return [Symbol] back off the partition and continue later
+              def pause
+                :pause
+              end
+
+              # @return [Symbol] move the partition offset without pausing
+              def seek
+                :seek
+              end
+            end
+
+            # All the actions a filter's `#action` (or the aggregated applier `#action`) can return
+            ALL = [skip, pause, seek].freeze
+
+            # @return [Boolean] should we skip without pausing or seeking
+            def skip?
+              action == Actions.skip
+            end
+
+            # @return [Boolean] should we pause the partition
+            def pause?
+              action == Actions.pause
+            end
+
+            # @return [Boolean] should we seek the partition
+            def seek?
+              action == Actions.seek
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -31,9 +31,6 @@
 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 Filters
           # Base for all the filters. All filters (including custom) need to use this API.
@@ -47,6 +44,8 @@ module Karafka
             attr_reader :cursor
 
             include Karafka::Core::Helpers::Time
+            # Provides `#skip?`, `#pause?` and `#seek?` predicates built on top of `#action`
+            include Actions
 
             # Initializes the filter as not yet applied
             def initialize
@@ -60,10 +59,10 @@ module Karafka
               raise NotImplementedError, "Implement in a subclass"
             end
 
-            # @return [Symbol] filter post-execution action on consumer. Either `:skip`, `:pause` or
-            #   `:seek`.
+            # @return [Symbol] filter post-execution action on consumer. One of {Actions::ALL}
+            #   (`Actions.skip`, `Actions.pause` or `Actions.seek`).
             def action
-              :skip
+              Actions.skip
             end
 
             # @return [Boolean] did this filter change messages in any way

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

@@ -31,9 +31,6 @@
 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 Filters
           # A filter that allows us to delay processing by pausing until time is right.
@@ -80,9 +77,9 @@ module Karafka
 
             # @return [Symbol] action to take on post-filtering
             def action
-              return :skip unless applied?
+              return Actions.skip unless applied?
 
-              (timeout <= 0) ? :seek : :pause
+              (timeout <= 0) ? Actions.seek : Actions.pause
             end
           end
         end

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

@@ -31,14 +31,11 @@
 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 Filters
           # Expirer for removing too old messages.
           # It never moves offsets in any way and does not impact the processing flow. It always
-          # runs `:skip` action.
+          # runs the `Actions.skip` action.
           class Expirer < Base
             # @param ttl [Integer] maximum age of a message (in ms)
             def initialize(ttl)

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

@@ -31,9 +31,6 @@
 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 Filters
           # Delayer that checks if we have appropriate insights available. If not, pauses for
@@ -89,7 +86,7 @@ module Karafka
 
             # Pause when we had to back-off or skip if delay is not needed
             def action
-              applied? ? :pause : :skip
+              applied? ? Actions.pause : Actions.skip
             end
           end
         end

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

@@ -31,9 +31,6 @@
 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
         # Namespace containing Pro out of the box filters used by various strategies
         module Filters
@@ -86,9 +83,9 @@ module Karafka
             # @return [Symbol] action to take upon throttler reaching certain state
             def action
               if applied?
-                timeout.zero? ? :seek : :pause
+                timeout.zero? ? Actions.seek : Actions.pause
               else
-                :skip
+                Actions.skip
               end
             end
 

data/lib/karafka/pro/processing/consumer_groups/filters/virtual_limiter.rb

@@ -31,9 +31,6 @@
 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 Filters
           # Removes messages that are already marked as consumed in the virtual offset manager

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

@@ -32,9 +32,7 @@ module Karafka
   module Pro
     # Pro components related to processing part of Karafka
     module Processing
-      # Pro consumer-group-specific processing components
       module ConsumerGroups
-        # Pro jobs
         module Jobs
           # The main job type in a non-blocking variant.
           # This variant works "like" the regular consumption but does not block the queue.
@@ -43,7 +41,8 @@ module Karafka
           # if would block.
           #
           # @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.
+          #   management. This layer of the framework knows nothing about Kafka messages
+          #   consumption.
           class ConsumeNonBlocking < Karafka::Processing::ConsumerGroups::Jobs::Consume
             self.action = :consume