karafka 2.5.2 → 2.5.4.rc1

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/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/multiplexing/subscription_groups_builder.rb

@@ -19,7 +19,7 @@ module Karafka
               factor = topics_array.first.subscription_group_details.fetch(:multiplexing_max, 1)
 
               Array.new(factor) do |i|
-                ::Karafka::Routing::Topics.new(
+                Karafka::Routing::Topics.new(
                   i.zero? ? topics_array : topics_array.map(&:dup)
                 )
               end

data/lib/karafka/pro/routing/features/multiplexing.rb

@@ -17,7 +17,7 @@ module Karafka
             # @param _config [Karafka::Core::Configurable::Node] app config node
             def pre_setup(_config)
               # Make sure we use proper unique validator for topics definitions
-              ::Karafka::Routing::Contracts::ConsumerGroup.singleton_class.prepend(
+              Karafka::Routing::Contracts::ConsumerGroup.singleton_class.prepend(
                 Patches::Contracts::ConsumerGroup
               )
             end
@@ -26,11 +26,11 @@ module Karafka
             #
             # @param _config [Karafka::Core::Configurable::Node] app config
             def post_setup(_config)
-              ::Karafka::App.monitor.subscribe('app.running') do
+              Karafka::App.monitor.subscribe('app.running') do
                 # Do not install the manager and listener to control multiplexing unless there is
                 # multiplexing enabled and it is dynamic.
                 # We only need to control multiplexing when it is in a dynamic state
-                next unless ::Karafka::App
+                next unless Karafka::App
                             .subscription_groups
                             .values
                             .flat_map(&:itself)
@@ -38,8 +38,8 @@ module Karafka
 
                 # Subscribe for events and possibility to manage via the Pro connection manager
                 # that supports multiplexing
-                ::Karafka.monitor.subscribe(
-                  ::Karafka::Pro::Connection::Multiplexing::Listener.new
+                Karafka.monitor.subscribe(
+                  Karafka::Pro::Connection::Multiplexing::Listener.new
                 )
               end
             end

data/lib/karafka/pro/routing/features/offset_metadata.rb

@@ -14,13 +14,13 @@ module Karafka
             #
             # @param _config [Karafka::Core::Configurable::Node] app config
             def post_setup(_config)
-              ::Karafka::App.monitor.subscribe('app.running') do
+              Karafka::App.monitor.subscribe('app.running') do
                 # Initialize the tracker prior to becoming multi-threaded
-                ::Karafka::Processing::InlineInsights::Tracker.instance
+                Karafka::Processing::InlineInsights::Tracker.instance
 
                 # Subscribe to the statistics reports and collect them
-                ::Karafka.monitor.subscribe(
-                  ::Karafka::Pro::Processing::OffsetMetadata::Listener.new
+                Karafka.monitor.subscribe(
+                  Karafka::Pro::Processing::OffsetMetadata::Listener.new
                 )
               end
             end

data/lib/karafka/pro/routing/features/parallel_segments/builder.rb

@@ -23,7 +23,7 @@ module Karafka
                 # We build a temp consumer group and a target to check if it has parallel segments
                 # enabled and if so, we do not add it to the routing but instead we build the
                 # appropriate number of parallel segment groups
-                temp_consumer_group = ::Karafka::Routing::ConsumerGroup.new(group_id.to_s)
+                temp_consumer_group = Karafka::Routing::ConsumerGroup.new(group_id.to_s)
                 temp_target = Karafka::Routing::Proxy.new(temp_consumer_group, &block).target
                 config = temp_target.parallel_segments
 

data/lib/karafka/pro/routing/features/patterns/patterns.rb

@@ -9,7 +9,7 @@ module Karafka
       module Features
         class Patterns < Base
           # Representation of groups of topics
-          class Patterns < ::Karafka::Routing::Topics
+          class Patterns < Karafka::Routing::Topics
             # Finds first pattern matching given topic name
             #
             # @param topic_name [String] topic name that may match a pattern

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

@@ -44,7 +44,7 @@ module Karafka
                 during_retry = false if during_retry.nil?
 
                 # If no interval, use default
-                interval ||= ::Karafka::App.config.internal.tick_interval
+                interval ||= Karafka::App.config.internal.tick_interval
 
                 Config.new(
                   active: active,

data/lib/karafka/pro/routing/features/recurring_tasks/builder.rb

@@ -108,7 +108,7 @@ module Karafka
               require 'fugit'
             rescue LoadError
               raise(
-                ::Karafka::Errors::DependencyConstraintsError,
+                Karafka::Errors::DependencyConstraintsError,
                 <<~ERROR_MSG
                   Failed to require fugit gem.
                   Add it to your Gemfile, as it is required for the recurring tasks to work.

data/lib/karafka/pro/routing/features/swarm.rb

@@ -14,7 +14,7 @@ module Karafka
             # Binds our routing validation contract prior to warmup in the supervisor, so we can
             # run it when all the context should be there (config + full routing)
             #
-            # @param config [Karafka::Core::Configurable::Node] app config
+            # @param config [Karafka::Core::Configurable::Node]
             def post_setup(config)
               config.monitor.subscribe('app.before_warmup') do
                 Contracts::Routing.new.validate!(

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

@@ -46,7 +46,9 @@ module Karafka
 
             # Just an alias for nice API
             #
-            # @param args [Array] Anything `#throttling` accepts
+            # @param args [Hash] Anything `#throttling` accepts
+            # @option args [Integer] :limit max messages to process in a time interval
+            # @option args [Integer] :interval time interval for processing in milliseconds
             def throttle(**args)
               throttling(**args)
             end

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

@@ -7,7 +7,7 @@ module Karafka
   module Pro
     module ScheduledMessages
       # Consumer that coordinates scheduling of messages when the time comes
-      class Consumer < ::Karafka::BaseConsumer
+      class Consumer < Karafka::BaseConsumer
         include Helpers::ConfigImporter.new(
           dispatcher_class: %i[scheduled_messages dispatcher_class]
         )

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

@@ -9,7 +9,7 @@ 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(
               File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
@@ -17,7 +17,7 @@ module Karafka
           end
 
           nested(:scheduled_messages) do
-            required(:consumer_class) { |val| val < ::Karafka::BaseConsumer }
+            required(:consumer_class) { |val| val < Karafka::BaseConsumer }
 
             # Do not allow to run more often than every second
             required(:interval) { |val| val.is_a?(Integer) && val >= 1_000 }

data/lib/karafka/pro/scheduled_messages/contracts/message.rb

@@ -11,7 +11,7 @@ module Karafka
         #
         # Our envelope always needs to comply with this format, otherwise we won't have enough
         # details to be able to dispatch the message
-        class Message < ::Karafka::Contracts::Base
+        class Message < Karafka::Contracts::Base
           configure do |config|
             config.error_messages = YAML.safe_load_file(
               File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')

data/lib/karafka/pro/scheduled_messages/daily_buffer.rb

@@ -14,6 +14,7 @@ module Karafka
       # up to 1.5 second, thus it is acceptable. Please ping me if you encounter performance
       # issues with this naive implementation so it can be improved.
       class DailyBuffer
+        # Initializes the daily buffer with empty accumulator
         def initialize
           @accu = {}
         end
@@ -69,8 +70,8 @@ module Karafka
           selected.each { |_, message| yield(message) }
         end
 
-        # Removes given key from the accumulator
-        # @param key [String] key to remove
+        # Removes the schedule entry identified by the given key from the daily buffer
+        # @param key [String]
         def delete(key)
           @accu.delete(key)
         end

data/lib/karafka/pro/scheduled_messages/day.rb

@@ -18,6 +18,7 @@ module Karafka
         # @return [Integer] utc timestamp when this day starts. Equal to 00:00:00
         attr_reader :starts_at
 
+        # Initializes a day representation for the current UTC day
         def initialize
           @created_at = Time.now.to_i
 

data/lib/karafka/pro/scheduled_messages/deserializers/headers.rb

@@ -16,7 +16,7 @@ module Karafka
 
           private_constant :WORKABLE_TYPES
 
-          # @param metadata [Karafka::aMessages::Metadata]
+          # @param metadata [Karafka::Messages::Metadata]
           # @return [Hash] headers
           def call(metadata)
             raw_headers = metadata.raw_headers

data/lib/karafka/pro/scheduled_messages/deserializers/payload.rb

@@ -15,7 +15,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/scheduled_messages/max_epoch.rb

@@ -23,6 +23,7 @@ module Karafka
         # @return [Integer] max epoch recorded
         attr_reader :to_i
 
+        # Initializes max epoch tracker with -1 as starting value
         def initialize
           @max = -1
           @to_i = @max

data/lib/karafka/pro/scheduled_messages/proxy.rb

@@ -21,7 +21,7 @@ module Karafka
       module Proxy
         # General WaterDrop message contract. Before we envelop a message, we need to be certain
         # it is correct, hence we use this contract.
-        MSG_CONTRACT = ::WaterDrop::Contracts::Message.new(
+        MSG_CONTRACT = WaterDrop::Contracts::Message.new(
           # Payload size is a subject to the target producer dispatch validation, so we set it
           # to 100MB basically to ignore it here.
           max_payload_size: 104_857_600

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

@@ -9,7 +9,7 @@ module Karafka
       # Serializers used to build payloads (if applicable) for dispatch
       # @note We only deal with states payload. Other payloads are not ours but end users.
       class Serializer
-        include ::Karafka::Core::Helpers::Time
+        include Karafka::Core::Helpers::Time
 
         # @param tracker [Tracker] tracker based on which we build the state
         # @return [String] compressed payload with the state details
@@ -32,9 +32,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/scheduled_messages/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(:group_id, default: 'karafka_scheduled_messages')
@@ -27,7 +27,7 @@ module Karafka
           # Producer to use. By default uses default Karafka producer.
           setting(
             :producer,
-            constructor: -> { ::Karafka.producer },
+            constructor: -> { Karafka.producer },
             lazy: true
           )
 

data/lib/karafka/pro/scheduled_messages/state.rb

@@ -27,6 +27,7 @@ module Karafka
 
         private_constant :STATES
 
+        # Initializes the state as fresh
         def initialize
           @state = 'fresh'
         end

data/lib/karafka/pro/scheduled_messages/tracker.rb

@@ -18,6 +18,7 @@ module Karafka
         # @return [Integer] time epoch when this tracker was started
         attr_reader :started_at
 
+        # Initializes the tracker with empty statistics
         def initialize
           @daily = Hash.new { |h, k| h[k] = 0 }
           @started_at = Time.now.to_i

data/lib/karafka/process.rb

@@ -5,7 +5,7 @@ module Karafka
   # @note There might be only one process - this class is a singleton
   class Process
     # Allow for process tagging for instrumentation
-    extend ::Karafka::Core::Taggable
+    extend Karafka::Core::Taggable
 
     # Signal types that we handle
     HANDLED_SIGNALS = %i[
@@ -79,12 +79,12 @@ module Karafka
     private
 
     # Traps a single signal and performs callbacks (if any) or just ignores this signal
-    # @param [Symbol] signal type that we want to catch
+    # @param signal [Symbol] signal type that we want to catch
     # @note Since we do a lot of threading and queuing, we don't want to handle signals from the
     # trap context s some things may not work there as expected, that is why we spawn a separate
     # thread to handle the signals process
     def trap_signal(signal)
-      previous_handler = ::Signal.trap(signal) do
+      previous_handler = Signal.trap(signal) do
         Thread.new do
           notice_signal(signal)
 
@@ -96,7 +96,7 @@ module Karafka
     end
 
     # Informs monitoring about trapped signal
-    # @param [Symbol] signal type that we received
+    # @param signal [Symbol] signal type that we received
     def notice_signal(signal)
       Karafka.monitor.instrument('process.notice_signal', caller: self, signal: signal)
     end

data/lib/karafka/processing/executor.rb

@@ -184,7 +184,7 @@ module Karafka
           # We assign producer only when not available already. It may already be available if
           # user redefined the `#producer` method for example. This can be useful for example when
           # having a multi-cluster setup and using a totally custom producer
-          consumer.producer ||= ::Karafka::App.producer
+          consumer.producer ||= Karafka::App.producer
           # Since we have some message-less flows (idle, etc), we initialize consumer with empty
           # messages set. In production we have persistent consumers, so this is not a performance
           # overhead as this will happen only once per consumer lifetime

data/lib/karafka/processing/inline_insights/tracker.rb

@@ -51,6 +51,7 @@ module Karafka
           def_delegators :instance, :find, :add, :exists?, :clear
         end
 
+        # Initializes the tracker with empty accumulator
         def initialize
           @accu = {}
           @mutex = Mutex.new

data/lib/karafka/processing/jobs_queue.rb

@@ -99,7 +99,7 @@ module Karafka
       # Marks a given job from a given group as completed. When there are no more jobs from a given
       # group to be executed, we won't wait.
       #
-      # @param [Jobs::Base] job that was completed
+      # @param job [Jobs::Base] job that was completed
       def complete(job)
         @mutex.synchronize do
           # We finish one job and if there is another, we pick it up

data/lib/karafka/processing/result.rb

@@ -8,6 +8,7 @@ module Karafka
     class Result
       attr_reader :cause
 
+      # Initializes the result as successful with no cause
       def initialize
         @success = true
         @cause = false

data/lib/karafka/processing/strategies/dlq.rb

@@ -94,7 +94,7 @@ module Karafka
         # @return [Array<Karafka::Messages::Message, Boolean>] message we may want to skip and
         #   information if this message was from marked offset or figured out via mom flow
         def find_skippable_message
-          skippable_message = messages.find do |msg|
+          skippable_message = messages.raw.find do |msg|
             coordinator.marked? && msg.offset == seek_offset
           end
 

data/lib/karafka/processing/strategy_selector.rb

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

data/lib/karafka/routing/activity_manager.rb

@@ -12,6 +12,7 @@ module Karafka
         topics
       ].freeze
 
+      # Initializes the activity manager with empty inclusion and exclusion lists
       def initialize
         @included = Hash.new { |h, k| h[k] = [] }
         @excluded = Hash.new { |h, k| h[k] = [] }

data/lib/karafka/routing/builder.rb

@@ -23,6 +23,7 @@ module Karafka
 
       private_constant :EMPTY_DEFAULTS
 
+      # Initializes the routing builder with empty routes
       def initialize
         @mutex = Mutex.new
         @draws = []
@@ -138,8 +139,9 @@ module Karafka
       # subscription group customization
       # @param subscription_group_name [String, Symbol] subscription group id. When not provided,
       #   a random uuid will be used
-      # @param args [Array] any extra arguments accepted by the subscription group builder
+      # @param args [Hash] any extra arguments accepted by the subscription group builder
       # @param block [Proc] further topics definitions
+      # @option args [String] :kafka optional kafka scope settings
       def subscription_group(
         subscription_group_name = SubscriptionGroup.id,
         **args,

data/lib/karafka/routing/consumer_group.rb

@@ -31,6 +31,9 @@ module Karafka
         # Initialize the subscription group so there's always a value for it, since even if not
         # defined directly, a subscription group will be created
         @current_subscription_group_details = { name: SubscriptionGroup.id }
+        # Track the base position for subscription groups to ensure stable positions when
+        # rebuilding. This is critical for static group membership in swarm mode
+        @subscription_groups_base_position = nil
       end
 
       # @return [Boolean] true if this consumer group should be active in our current process
@@ -42,6 +45,10 @@ module Karafka
       # @param name [String, Symbol] name of topic to which we want to subscribe
       # @return [Karafka::Routing::Topic] newly built topic instance
       def topic=(name, &)
+        # Clear memoized subscription groups since adding a topic requires rebuilding them
+        # This is critical for consumer group reopening across multiple draw calls
+        @subscription_groups = nil
+
         topic = Topic.new(name, self)
         @topics << Proxy.new(
           topic,
@@ -73,7 +80,18 @@ module Karafka
       # @return [Array<Routing::SubscriptionGroup>] all the subscription groups build based on
       #   the consumer group topics
       def subscription_groups
-        @subscription_groups ||= subscription_groups_builder.call(topics)
+        @subscription_groups ||= begin
+          result = subscription_groups_builder.call(
+            topics,
+            base_position: @subscription_groups_base_position
+          )
+
+          # Store the base position from the first subscription group for future rebuilds.
+          # This ensures stable positions for static group membership.
+          @subscription_groups_base_position ||= result.first&.position
+
+          result
+        end
       end
 
       # Hashed version of consumer group that can be used for validation purposes

data/lib/karafka/routing/contracts/consumer_group.rb

@@ -44,14 +44,15 @@ module Karafka
 
         virtual do |data, errors|
           next unless errors.empty?
-          next unless ::Karafka::App.config.strict_topics_namespacing
+          next unless Karafka::App.config.strict_topics_namespacing
 
           names = data.fetch(:topics).map { |topic| topic[:name] }
           names_hash = names.each_with_object({}) { |n, h| h[n] = true }
           error_occured = false
+          namespace_chars = ['.', '_'].freeze
           names.each do |n|
             # Skip topic names that are not namespaced
-            next unless n.chars.find { |c| ['.', '_'].include?(c) }
+            next unless n.chars.find { |c| namespace_chars.include?(c) }
 
             if n.chars.include?('.')
               # Check underscore styled topic

data/lib/karafka/routing/contracts/topic.rb

@@ -66,10 +66,13 @@ module Karafka
 
         virtual do |data, errors|
           next unless errors.empty?
-          next unless ::Karafka::App.config.strict_topics_namespacing
+          next unless Karafka::App.config.strict_topics_namespacing
 
           value = data.fetch(:name)
-          namespacing_chars_count = value.chars.find_all { |c| ['.', '_'].include?(c) }.uniq.size
+          namespace_chars = ['.', '_'].freeze
+          namespacing_chars_count = value.chars.find_all do |c|
+            namespace_chars.include?(c)
+          end.uniq.size
 
           next if namespacing_chars_count <= 1
 

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

@@ -39,7 +39,7 @@ module Karafka
               next unless dead_letter_queue[:active]
 
               topic = dead_letter_queue[:topic]
-              topic_regexp = ::Karafka::Contracts::TOPIC_REGEXP
+              topic_regexp = Karafka::Contracts::TOPIC_REGEXP
 
               # When topic is set to false, it means we just want to skip dispatch on DLQ
               next if topic == false

data/lib/karafka/routing/features/declaratives/topic.rb

@@ -16,9 +16,12 @@ module Karafka
           end
 
           # @param active [Boolean] is the topic structure management feature active
-          # @param partitions [Integer]
-          # @param replication_factor [Integer]
+          # @param partitions [Integer] number of partitions for the topic
+          # @param replication_factor [Integer] replication factor for the topic
           # @param details [Hash] extra configuration for the topic
+          # @option details [String] :retention.ms retention time in milliseconds
+          # @option details [String] :compression.type compression type
+          #   (none, gzip, snappy, lz4, zstd)
           # @return [Config] defined structure
           def config(active: true, partitions: 1, replication_factor: 1, **details)
             @declaratives ||= Config.new(

data/lib/karafka/routing/features/deserializers/topic.rb

@@ -22,9 +22,9 @@ module Karafka
           # @param key [Object] deserializer for the message key
           # @param headers [Object] deserializer for the message headers
           def deserializers(
-            payload: ::Karafka::Deserializers::Payload.new,
-            key: ::Karafka::Deserializers::Key.new,
-            headers: ::Karafka::Deserializers::Headers.new
+            payload: Karafka::Deserializers::Payload.new,
+            key: Karafka::Deserializers::Key.new,
+            headers: Karafka::Deserializers::Headers.new
           )
             @deserializers ||= Config.new(
               active: true,

data/lib/karafka/routing/features/inline_insights.rb

@@ -12,11 +12,11 @@ module Karafka
           #
           # @param _config [Karafka::Core::Configurable::Node] app config
           def post_setup(_config)
-            ::Karafka::App.monitor.subscribe('app.running') do
+            Karafka::App.monitor.subscribe('app.running') do
               # Do not activate tracking of statistics if none of our active topics uses it
               # This prevents us from tracking metrics when user just runs a subset of topics
               # in a given process and none of those actually utilizes this feature
-              next unless ::Karafka::App
+              next unless Karafka::App
                           .subscription_groups
                           .values
                           .flat_map(&:itself)
@@ -25,11 +25,11 @@ module Karafka
                           .any?(&:inline_insights?)
 
               # Initialize the tracker prior to becoming multi-threaded
-              ::Karafka::Processing::InlineInsights::Tracker.instance
+              Karafka::Processing::InlineInsights::Tracker.instance
 
               # Subscribe to the statistics reports and collect them
-              ::Karafka.monitor.subscribe(
-                ::Karafka::Processing::InlineInsights::Listener.new
+              Karafka.monitor.subscribe(
+                Karafka::Processing::InlineInsights::Listener.new
               )
             end
           end

data/lib/karafka/routing/router.rb

@@ -8,7 +8,7 @@ module Karafka
     #  structure so all the routes are being stored in a single level array
     module Router
       # Finds first reference of a given topic based on provided lookup attribute
-      # @param lookup [Hash<Symbol, String>] hash with attribute - value key pairs
+      # @param lookup [Hash{Symbol => String}] hash with attribute - value key pairs
       # @return [Karafka::Routing::Topic, nil] proper route details or nil if not found
       def find_by(lookup)
         App.consumer_groups.each do |consumer_group|

data/lib/karafka/routing/subscription_group.rb

@@ -14,7 +14,7 @@ module Karafka
         node: %i[swarm node]
       )
 
-      attr_reader :id, :name, :topics, :kafka, :consumer_group
+      attr_reader :id, :name, :topics, :kafka, :consumer_group, :position
 
       # Lock for generating new ids safely
       ID_MUTEX = Mutex.new
@@ -30,7 +30,7 @@ module Karafka
             @group_counter ||= 0
             @group_counter += 1
 
-            ::Digest::SHA256.hexdigest(
+            Digest::SHA256.hexdigest(
               @group_counter.to_s
             )[0..11]
           end