karafka 2.5.2 → 2.5.4.rc1

data/lib/karafka/admin/replication.rb

@@ -0,0 +1,462 @@
+# frozen_string_literal: true
+
+module Karafka
+  class Admin
+    # Replication administration operations helper
+    #
+    # Generates partition reassignment plans for increasing topic replication factor.
+    # Since librdkafka does not support changing replication factors directly, this class
+    # generates the necessary JSON configuration that can be executed using Kafka's Java-based
+    # reassignment tools.
+    #
+    # ## Important Considerations
+    #
+    # Replication factor changes are among the most resource-intensive operations in Kafka.
+    #
+    # ## Prerequisites
+    #
+    # 1. **Sufficient Disk Space**: Ensure target brokers have enough space for new replicas
+    # 2. **Network Capacity**: Verify network can handle additional replication traffic
+    # 3. **Broker Count**: Cannot exceed the number of available brokers
+    # 4. **Java Tools**: Kafka's reassignment tools must be available
+    #
+    # ## Best Practices
+    #
+    # - **Test First**: Always test on small topics or in staging environments
+    # - **Monitor Resources**: Watch disk space, network, and CPU during replication
+    # - **Incremental Changes**: Increase replication factor by 1 at a time for large topics
+    # - **Off-Peak Hours**: Execute during low-traffic periods to minimize impact
+    #
+    # @example Basic usage - increase replication factor
+    #   # Generate plan to increase replication from 2 to 3
+    #   plan = Karafka::Admin::Replication.plan(topic: 'events', to: 3)
+    #
+    #   # Review what will happen
+    #   puts plan.summary
+    #
+    #   # Export for execution
+    #   plan.export_to_file('/tmp/increase_replication.json')
+    #
+    #   # Execute with Kafka tools (outside of Ruby)
+    #   # kafka-reassign-partitions.sh --bootstrap-server localhost:9092 \
+    #   #   --reassignment-json-file /tmp/increase_replication.json --execute
+    #
+    # @example Rebalancing replicas across brokers
+    #   # Rebalance existing replicas without changing replication factor
+    #   plan = Karafka::Admin::Replication.rebalance(topic: 'events')
+    #   plan.export_to_file('/tmp/rebalance.json')
+    #
+    # @note This class only generates plans - actual execution requires Kafka's Java tools
+    # @note Always verify broker capacity before increasing replication
+    class Replication < Admin
+      attr_reader(
+        :topic,
+        :current_replication_factor,
+        :target_replication_factor,
+        :partitions_assignment,
+        :reassignment_json,
+        :execution_commands,
+        :steps
+      )
+
+      # Builds the replication plan
+      #
+      # @param topic [String] topic name
+      # @param current_replication_factor [Integer] current replication factor
+      # @param target_replication_factor [Integer] target replication factor
+      # @param partitions_assignment [Hash] partition to brokers assignment
+      # @param cluster_info [Hash] broker information
+      def initialize(
+        topic:,
+        current_replication_factor:,
+        target_replication_factor:,
+        partitions_assignment:,
+        cluster_info:
+      )
+        super()
+
+        @topic = topic
+        @current_replication_factor = current_replication_factor
+        @target_replication_factor = target_replication_factor
+        @partitions_assignment = partitions_assignment
+        @cluster_info = cluster_info
+
+        generate_reassignment_json
+        generate_execution_commands
+        generate_steps
+
+        freeze
+      end
+
+      # Export the reassignment JSON to a file
+      # @param file_path [String] path where to save the JSON file
+      def export_to_file(file_path)
+        File.write(file_path, @reassignment_json)
+        file_path
+      end
+
+      # @return [String] human-readable summary of the plan
+      def summary
+        broker_count = @cluster_info[:brokers].size
+        change = @target_replication_factor - @current_replication_factor
+        broker_nodes = @cluster_info[:brokers].map do |broker_info|
+          broker_info[:node_id]
+        end.join(', ')
+
+        <<~SUMMARY
+          Replication Increase Plan for Topic: #{@topic}
+          =====================================
+          Current replication factor: #{@current_replication_factor}
+          Target replication factor: #{@target_replication_factor}
+          Total partitions: #{@partitions_assignment.size}
+          Available brokers: #{broker_count} (#{broker_nodes})
+
+          This plan will increase replication by adding #{change} replica(s) to each partition.
+        SUMMARY
+      end
+
+      class << self
+        # Plans replication factor increase for a given topic
+        #
+        # Generates a detailed reassignment plan that preserves existing replica assignments
+        # while adding new replicas to meet the target replication factor. The plan uses
+        # round-robin distribution to balance new replicas across available brokers.
+        #
+        # @param topic [String] name of the topic
+        # @param to [Integer] target replication factor (must be higher than current)
+        # @param brokers [Hash{Integer => Array<Integer>}] optional manual broker assignments
+        #   per partition. Keys are partition IDs, values are arrays of broker IDs. If not provided
+        #   automatic distribution (usually fine) will be used
+        # @return [Replication] plan object containing JSON, commands, and instructions
+        #
+        # @raise [ArgumentError] if target replication factor is not higher than current
+        # @raise [ArgumentError] if target replication factor exceeds available broker count
+        # @raise [Rdkafka::RdkafkaError] if topic metadata cannot be fetched
+        #
+        # @example Increase replication from 1 to 3 with automatic distribution
+        #   plan = Replication.plan(topic: 'events', to: 3)
+        #
+        #   # Inspect the plan
+        #   puts plan.summary
+        #   puts plan.reassignment_json
+        #
+        #   # Check which brokers will get new replicas
+        #   plan.partitions_assignment.each do |partition_id, broker_ids|
+        #     puts "Partition #{partition_id}: #{broker_ids.join(', ')}"
+        #   end
+        #
+        #   # Save and execute
+        #   plan.export_to_file('increase_rf.json')
+        #
+        # @example Increase replication with manual broker placement
+        #   # Specify exactly which brokers should host each partition
+        #   plan = Replication.plan(
+        #     topic: 'events',
+        #     to: 3,
+        #     brokers: {
+        #       0 => [1, 2, 4],  # Partition 0 on brokers 1, 2, 4
+        #       1 => [2, 3, 4],  # Partition 1 on brokers 2, 3, 4
+        #       2 => [1, 3, 5]   # Partition 2 on brokers 1, 3, 5
+        #     }
+        #   )
+        #
+        #   # The plan will use your exact broker specifications
+        #   puts plan.partitions_assignment
+        #   # => {0=>[1, 2, 4], 1=>[2, 3, 4], 2=>[1, 3, 5]}
+        #
+        # @note When using manual placement, ensure all partitions are specified
+        # @note Manual placement overrides automatic distribution entirely
+        def plan(topic:, to:, brokers: nil)
+          topic_info = fetch_topic_info(topic)
+          first_partition = topic_info[:partitions].first
+          current_rf = first_partition[:replica_count] || first_partition[:replicas]&.size
+          cluster_info = fetch_cluster_info
+
+          # Use contract for validation
+          validation_data = {
+            topic: topic,
+            to: to,
+            brokers: brokers,
+            current_rf: current_rf,
+            broker_count: cluster_info[:brokers].size,
+            topic_info: topic_info,
+            cluster_info: cluster_info
+          }
+
+          Contracts::Replication.new.validate!(validation_data)
+
+          partitions_assignment = brokers || generate_partitions_assignment(
+            topic_info: topic_info,
+            target_replication_factor: to,
+            cluster_info: cluster_info
+          )
+
+          new(
+            topic: topic,
+            current_replication_factor: current_rf,
+            target_replication_factor: to,
+            partitions_assignment: partitions_assignment,
+            cluster_info: cluster_info
+          )
+        end
+
+        # Plans rebalancing of existing replicas across brokers
+        #
+        # Generates a reassignment plan that redistributes existing replicas more evenly
+        # across the cluster without changing the replication factor. Useful for:
+        #
+        # - Balancing load after adding new brokers to the cluster
+        # - Redistributing replicas after broker failures and recovery
+        # - Optimizing replica placement for better resource utilization
+        # - Moving replicas away from overloaded brokers
+        #
+        # @param topic [String] name of the topic to rebalance
+        # @return [Replication] rebalancing plan
+        #
+        # @example Rebalance after adding new brokers
+        #   # After adding brokers 4 and 5 to a 3-broker cluster
+        #   plan = Replication.rebalance(topic: 'events')
+        #
+        #   # Review how replicas will be redistributed
+        #   puts plan.summary
+        #
+        #   # Execute if distribution looks good
+        #   plan.export_to_file('rebalance.json')
+        #   # Then run: kafka-reassign-partitions.sh --execute ...
+        #
+        # @note This maintains the same replication factor
+        # @note All data will be copied to new locations during rebalancing
+        # @note Consider impact on cluster resources during rebalancing
+        def rebalance(topic:)
+          topic_info = fetch_topic_info(topic)
+          first_partition = topic_info[:partitions].first
+          current_rf = first_partition[:replica_count] || first_partition[:replicas]&.size
+          cluster_info = fetch_cluster_info
+
+          partitions_assignment = generate_partitions_assignment(
+            topic_info: topic_info,
+            target_replication_factor: current_rf,
+            cluster_info: cluster_info,
+            rebalance_only: true
+          )
+
+          new(
+            topic: topic,
+            current_replication_factor: current_rf,
+            target_replication_factor: current_rf,
+            partitions_assignment: partitions_assignment,
+            cluster_info: cluster_info
+          )
+        end
+
+        private
+
+        # Fetches topic metadata including partitions and replica information
+        # @param topic [String] name of the topic
+        # @return [Hash] topic information with partitions metadata
+        def fetch_topic_info(topic)
+          Topics.info(topic)
+        end
+
+        # Fetches cluster broker information from Kafka metadata
+        # @return [Hash] cluster information with broker details (node_id, host:port)
+        def fetch_cluster_info
+          cluster_metadata = cluster_info
+          {
+            brokers: cluster_metadata.brokers.map do |broker|
+              # Handle both hash and object formats from metadata
+              # rdkafka returns hashes with broker_id, broker_name, broker_port
+              if broker.is_a?(Hash)
+                node_id = broker[:broker_id] || broker[:node_id]
+                host = broker[:broker_name] || broker[:host]
+                port = broker[:broker_port] || broker[:port]
+                { node_id: node_id, host: "#{host}:#{port}" }
+              else
+                { node_id: broker.node_id, host: "#{broker.host}:#{broker.port}" }
+              end
+            end
+          }
+        end
+
+        # Generates partition-to-broker assignments for replication changes
+        # Handles both replication factor increases and rebalancing scenarios
+        # @param topic_info [Hash] topic metadata with partition information
+        # @param target_replication_factor [Integer] desired replication factor
+        # @param cluster_info [Hash] cluster metadata with broker information
+        # @param rebalance_only [Boolean] true for rebalancing, false for increase
+        # @return [Hash{Integer => Array<Integer>}] assignments (partition_id => broker_ids)
+        def generate_partitions_assignment(
+          topic_info:,
+          target_replication_factor:,
+          cluster_info:,
+          rebalance_only: false
+        )
+          partitions = topic_info[:partitions]
+          brokers = cluster_info[:brokers].map { |broker_info| broker_info[:node_id] }.sort
+          assignments = {}
+
+          partitions.each do |partition_info|
+            partition_id = partition_info[:partition_id]
+
+            # Handle both :replicas (array of objects) and :replica_brokers (array of IDs)
+            replicas = partition_info[:replicas] || partition_info[:replica_brokers] || []
+            current_replicas = if replicas.first.respond_to?(:node_id)
+                                 replicas.map(&:node_id).sort
+                               else
+                                 replicas.sort
+                               end
+
+            if rebalance_only
+              # For rebalancing, redistribute current replicas optimally
+              new_replicas = select_brokers_for_partition(
+                partition_id: partition_id,
+                brokers: brokers,
+                replica_count: target_replication_factor,
+                avoid_brokers: []
+              )
+            else
+              # For replication increase, keep existing replicas and add new ones
+              additional_needed = target_replication_factor - current_replicas.size
+              available_brokers = brokers - current_replicas
+
+              additional_replicas = select_additional_brokers(
+                available_brokers: available_brokers,
+                needed_count: additional_needed,
+                partition_id: partition_id
+              )
+
+              new_replicas = (current_replicas + additional_replicas).sort
+            end
+
+            assignments[partition_id] = new_replicas
+          end
+
+          assignments
+        end
+
+        # Selects brokers for a partition using round-robin distribution
+        # Distributes replicas evenly across available brokers
+        # @param partition_id [Integer] partition identifier for offset calculation
+        # @param brokers [Array<Integer>] available broker node IDs
+        # @param replica_count [Integer] number of replicas needed
+        # @param avoid_brokers [Array<Integer>] broker IDs to exclude from selection
+        # @return [Array<Integer>] sorted array of selected broker node IDs
+        def select_brokers_for_partition(
+          partition_id:,
+          brokers:,
+          replica_count:,
+          avoid_brokers: []
+        )
+          available_brokers = brokers - avoid_brokers
+
+          # Simple round-robin selection starting from a different offset per partition
+          # This helps distribute replicas more evenly across brokers
+          start_index = partition_id % available_brokers.size
+          selected = []
+
+          replica_count.times do |replica_index|
+            broker_index = (start_index + replica_index) % available_brokers.size
+            selected << available_brokers[broker_index]
+          end
+
+          selected.sort
+        end
+
+        # Selects additional brokers for increasing replication factor
+        # Uses round-robin selection for even distribution across available brokers
+        # @param available_brokers [Array<Integer>] broker IDs available for new replicas
+        # @param needed_count [Integer] number of additional brokers needed
+        # @param partition_id [Integer] partition identifier for offset calculation
+        # @return [Array<Integer>] sorted array of selected broker node IDs
+        def select_additional_brokers(available_brokers:, needed_count:, partition_id:)
+          # Use round-robin starting from partition-specific offset
+          start_index = partition_id % available_brokers.size
+          selected = []
+
+          needed_count.times do |additional_replica_index|
+            broker_index = (start_index + additional_replica_index) % available_brokers.size
+            selected << available_brokers[broker_index]
+          end
+
+          selected.sort
+        end
+      end
+
+      private
+
+      # Generates the JSON structure required by kafka-reassign-partitions.sh
+      # Creates Kafka-compatible reassignment plan with version and partitions data
+      # @return [void]
+      def generate_reassignment_json
+        partitions_data = @partitions_assignment.map do |partition_id, replica_broker_ids|
+          {
+            topic: @topic,
+            partition: partition_id,
+            replicas: replica_broker_ids
+          }
+        end
+
+        reassignment_data = {
+          version: 1,
+          partitions: partitions_data
+        }
+
+        @reassignment_json = JSON.pretty_generate(reassignment_data)
+      end
+
+      # Generates command templates for executing the reassignment plan
+      # Builds generate, execute, and verify command templates with placeholders
+      # @return [void]
+      def generate_execution_commands
+        @execution_commands = {
+          generate: build_generate_command,
+          execute: build_execute_command,
+          verify: build_verify_command
+        }
+      end
+
+      # Builds the kafka-reassign-partitions.sh command for generating reassignment plan
+      # @return [String] command template with placeholder for broker addresses
+      def build_generate_command
+        'kafka-reassign-partitions.sh --bootstrap-server <KAFKA_BROKERS> ' \
+          '--reassignment-json-file reassignment.json --generate'
+      end
+
+      # Builds the kafka-reassign-partitions.sh command for executing reassignment
+      # @return [String] command template with placeholder for broker addresses
+      def build_execute_command
+        'kafka-reassign-partitions.sh --bootstrap-server <KAFKA_BROKERS> ' \
+          '--reassignment-json-file reassignment.json --execute'
+      end
+
+      # Builds the kafka-reassign-partitions.sh command for verifying reassignment progress
+      # @return [String] command template with placeholder for broker addresses
+      def build_verify_command
+        'kafka-reassign-partitions.sh --bootstrap-server <KAFKA_BROKERS> ' \
+          '--reassignment-json-file reassignment.json --verify'
+      end
+
+      # Generates detailed step-by-step instructions for executing the reassignment
+      # Creates human-readable guide with commands and important safety notes
+      # @return [void]
+      def generate_steps
+        @steps = [
+          "1. Export the reassignment JSON using: plan.export_to_file('reassignment.json')",
+          "2. Validate the plan (optional): #{@execution_commands[:generate]}",
+          "3. Execute the reassignment: #{@execution_commands[:execute]}",
+          "4. Monitor progress: #{@execution_commands[:verify]}",
+          '5. Verify completion by checking topic metadata',
+          '',
+          'IMPORTANT NOTES:',
+          '- Replace <KAFKA_BROKERS> with your actual Kafka broker addresses',
+          '- The reassignment process may take time depending on data size',
+          '- Monitor disk space and network I/O during reassignment',
+          '- Consider running during low-traffic periods',
+          '- For large topics, consider throttling replica transfer rate',
+          '- Ensure sufficient disk space on target brokers before starting',
+          '- Keep monitoring until all replicas are in-sync (ISR)'
+        ]
+      end
+    end
+  end
+end

data/lib/karafka/admin/topics.rb

@@ -36,7 +36,7 @@ module Karafka
 
             # Build the requested range - since first element is on the start offset we need to
             # subtract one from requested count to end up with expected number of elements
-            requested_range = (start_offset..(start_offset + (count - 1)))
+            requested_range = (start_offset..(start_offset + count - 1))
             # Establish theoretical available range. Note, that this does not handle cases related
             # to log retention or compaction
             available_range = (low_offset..(high_offset - 1))
@@ -75,7 +75,7 @@ module Karafka
           # Use topic from routes if we can match it or create a dummy one
           # Dummy one is used in case we cannot match the topic with routes. This can happen
           # when admin API is used to read topics that are not part of the routing
-          topic = ::Karafka::Routing::Router.find_or_initialize_by_name(name)
+          topic = Karafka::Routing::Router.find_or_initialize_by_name(name)
 
           messages.map! do |message|
             Messages::Builders::Message.call(
@@ -143,7 +143,8 @@ module Karafka
         # partitions
         #
         # @param name_or_hash [String, Symbol, Hash] topic name or hash with topics and partitions
-        # @param partition [Integer, nil] partition number (required when first param is topic name)
+        # @param partition [Integer, nil] partition number
+        #   (required when first param is topic name)
         #
         # @return [Array<Integer, Integer>, Hash] when querying single partition returns array with
         #   low and high watermark offsets, when querying multiple returns nested hash
@@ -217,7 +218,7 @@ module Karafka
         # @return [Integer] expected offset
         def resolve_offset(consumer, name, partition, offset)
           if offset.is_a?(Time)
-            tpl = ::Rdkafka::Consumer::TopicPartitionList.new
+            tpl = Rdkafka::Consumer::TopicPartitionList.new
             tpl.add_topic_and_partitions_with_offsets(
               name, partition => offset
             )

data/lib/karafka/admin.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'admin/consumer_groups'
-
 module Karafka
   # Admin actions that we can perform via Karafka on our Kafka cluster
   #
@@ -124,13 +122,13 @@ module Karafka
 
       # Reads lags and offsets for given topics in the context of consumer groups defined in the
       #   routing
-      # @param consumer_groups_with_topics [Hash<String, Array<String>>] hash with consumer groups
-      #   names with array of topics to query per consumer group inside
+      # @param consumer_groups_with_topics [Hash{String => Array<String>}] hash with consumer
+      #   groups names with array of topics to query per consumer group inside
       # @param active_topics_only [Boolean] if set to false, when we use routing topics, will
       #   select also topics that are marked as inactive in routing
-      # @return [Hash<String, Hash<Integer, <Hash<Integer>>>>] hash where the top level keys are
-      #   the consumer groups and values are hashes with topics and inside partitions with lags
-      #   and offsets
+      # @return [Hash{String => Hash{Integer => Hash{Integer => Object}}}] hash where the top
+      #   level keys are the consumer groups and values are hashes with topics and inside
+      #   partitions with lags and offsets
       # @see ConsumerGroups.read_lags_with_offsets
       def read_lags_with_offsets(consumer_groups_with_topics = {}, active_topics_only: true)
         ConsumerGroups.read_lags_with_offsets(
@@ -139,6 +137,53 @@ module Karafka
         )
       end
 
+      # Plans a replication factor increase for a topic that can be used with Kafka's
+      # reassignment tools. Since librdkafka does not support increasing replication factor
+      # directly, this method generates the necessary JSON and commands for manual execution.
+      #
+      # @param topic [String] name of the topic to plan replication for
+      # @param replication_factor [Integer] target replication factor (must be higher than current)
+      # @param brokers [Hash{Integer => Array<Integer>}] optional manual broker assignments
+      #   per partition. Keys are partition IDs, values are arrays of broker IDs. If not provided,
+      #   assignments distribution will happen automatically.
+      # @return [Replication] plan object with JSON, commands, and instructions
+      #
+      # @example Plan replication increase with automatic broker distribution
+      #   plan = Karafka::Admin.plan_topic_replication(topic: 'events', replication_factor: 3)
+      #
+      #   # Review the plan
+      #   puts plan.summary
+      #
+      #   # Export JSON for Kafka's reassignment tools
+      #   plan.export_to_file('reassignment.json')
+      #
+      #   # Execute the plan (replace <KAFKA_BROKERS> with actual brokers)
+      #   system(plan.execution_commands[:execute].gsub('<KAFKA_BROKERS>', 'localhost:9092'))
+      #
+      # @example Plan replication with manual broker placement - specify brokers
+      #   plan = Karafka::Admin.plan_topic_replication(
+      #     topic: 'events',
+      #     replication_factor: 3,
+      #     brokers: {
+      #       0 => [1, 2, 4],  # Partition 0 on brokers 1, 2, 4
+      #       1 => [2, 3, 4],  # Partition 1 on brokers 2, 3, 4
+      #       2 => [1, 3, 5]   # Partition 2 on brokers 1, 3, 5
+      #     }
+      #   )
+      #
+      #   # The plan will use your exact broker specifications
+      #   puts plan.partitions_assignment
+      #   # => { 0=>[1, 2, 4], 1=>[2, 3, 4], 2=>[1, 3, 5] }
+      #
+      # @see Replication.plan for more details
+      def plan_topic_replication(topic:, replication_factor:, brokers: nil)
+        Replication.plan(
+          topic: topic,
+          to: replication_factor,
+          brokers: brokers
+        )
+      end
+
       # @return [Rdkafka::Metadata] cluster metadata info
       def cluster_info
         with_admin(&:metadata)
@@ -158,7 +203,7 @@ module Karafka
         bind_oauth(bind_id, consumer)
 
         consumer.start
-        proxy = ::Karafka::Connection::Proxy.new(consumer)
+        proxy = Karafka::Connection::Proxy.new(consumer)
         yield(proxy)
       ensure
         # Always unsubscribe consumer just to be sure, that no metadata requests are running
@@ -188,7 +233,7 @@ module Karafka
         bind_oauth(bind_id, admin)
 
         admin.start
-        proxy = ::Karafka::Connection::Proxy.new(admin)
+        proxy = Karafka::Connection::Proxy.new(admin)
         yield(proxy)
       ensure
         admin&.close
@@ -211,7 +256,7 @@ module Karafka
       # @param instance [Rdkafka::Consumer, Rdkafka::Admin] rdkafka instance to be used to set
       #   appropriate oauth token when needed
       def bind_oauth(id, instance)
-        ::Karafka::Core::Instrumentation.oauthbearer_token_refresh_callbacks.add(
+        Karafka::Core::Instrumentation.oauthbearer_token_refresh_callbacks.add(
           id,
           Instrumentation::Callbacks::OauthbearerTokenRefresh.new(
             instance
@@ -224,7 +269,7 @@ module Karafka
       # @param id [String, Symbol] unique (for the lifetime of instance) id that we use for
       #   callback referencing
       def unbind_oauth(id)
-        ::Karafka::Core::Instrumentation.oauthbearer_token_refresh_callbacks.delete(id)
+        Karafka::Core::Instrumentation.oauthbearer_token_refresh_callbacks.delete(id)
       end
 
       # There are some cases where rdkafka admin operations finish successfully but without the
@@ -269,7 +314,7 @@ module Karafka
           # consumer group or do something similar
           .merge!(settings)
           .then { |config| Karafka::Setup::AttributesMap.public_send(type, config) }
-          .then { |config| ::Rdkafka::Config.new(config) }
+          .then { |config| Rdkafka::Config.new(config) }
       end
     end
   end

data/lib/karafka/app.rb

@@ -52,7 +52,7 @@ module Karafka
 
       # Returns current assignments of this process. Both topics and partitions
       #
-      # @return [Hash<Karafka::Routing::Topic, Array<Integer>>]
+      # @return [Hash{Karafka::Routing::Topic => Array<Integer>}]
       def assignments
         Instrumentation::AssignmentsTracker.instance.current
       end
@@ -102,8 +102,8 @@ module Karafka
       #
       # @param contexts [String] librdkafka low level debug contexts for granular debugging
       def debug!(contexts = 'all')
-        logger.level = ::Logger::DEBUG
-        producer.config.logger.level = ::Logger::DEBUG
+        logger.level = Logger::DEBUG
+        producer.config.logger.level = Logger::DEBUG
 
         config.kafka[:debug] = contexts
         producer.config.kafka[:debug] = contexts

data/lib/karafka/base_consumer.rb

@@ -5,7 +5,7 @@ module Karafka
   # Base consumer from which all Karafka consumers should inherit
   class BaseConsumer
     # Allow for consumer instance tagging for instrumentation
-    include ::Karafka::Core::Taggable
+    include Karafka::Core::Taggable
     include Helpers::ConfigImporter.new(
       monitor: %i[monitor]
     )

data/lib/karafka/cli/base.rb

@@ -72,7 +72,7 @@ module Karafka
 
           # All other commands except help and install do require an existing boot file if it was
           # declared
-          raise ::Karafka::Errors::MissingBootFileError, ::Karafka.boot_file
+          raise Karafka::Errors::MissingBootFileError, Karafka.boot_file
         end
 
         # Allows to set options for Thor cli

data/lib/karafka/cli/console.rb

@@ -28,7 +28,7 @@ module Karafka
       def call
         Info.new.call
 
-        command = ::Karafka.rails? ? self.class.rails_console : self.class.console
+        command = Karafka.rails? ? self.class.rails_console : self.class.console
 
         exec "KARAFKA_CONSOLE=true #{command}"
       end

data/lib/karafka/cli/contracts/server.rb

@@ -5,7 +5,7 @@ module Karafka
     # CLI related contracts
     module Contracts
       # Contract for validating correctness of the server cli command options.
-      class Server < ::Karafka::Contracts::Base
+      class Server < Karafka::Contracts::Base
         configure do |config|
           config.error_messages = YAML.safe_load_file(
             File.join(Karafka.gem_root, 'config', 'locales', 'errors.yml')