karafka 2.5.1 → 2.5.3

data/lib/karafka/instrumentation/vendors/datadog/metrics_listener.rb

@@ -11,11 +11,12 @@ module Karafka
         #
         # @note You need to setup the `dogstatsd-ruby` client and assign it
         class MetricsListener
-          include ::Karafka::Core::Configurable
+          include Karafka::Core::Configurable
           extend Forwardable
 
-          def_delegators :config, :client, :rd_kafka_metrics, :namespace,
-                         :default_tags, :distribution_mode
+          def_delegators(
+            :config, :client, :rd_kafka_metrics, :namespace, :default_tags, :distribution_mode
+          )
 
           # Value object for storing a single rdkafka metric publishing details
           RdKafkaMetric = Struct.new(:type, :scope, :name, :key_location)
@@ -69,10 +70,9 @@ module Karafka
             setup(&block) if block
           end
 
-          # @param block [Proc] configuration block
           # @note We define this alias to be consistent with `WaterDrop#setup`
-          def setup(&block)
-            configure(&block)
+          def setup(&)
+            configure(&)
           end
 
           # Hooks up to Karafka instrumentation for emitted statistics
@@ -198,22 +198,21 @@ module Karafka
 
           # Selects the histogram mode configured and uses it to report to DD client
           # @param key [String] non-namespaced key
-          # @param args [Array] extra arguments to pass to the client
-          def histogram(key, *args)
+          def histogram(key, *)
             case distribution_mode
             when :histogram
               client.histogram(
                 namespaced_metric(key),
-                *args
+                *
               )
             when :distribution
               client.distribution(
                 namespaced_metric(key),
-                *args
+                *
               )
             else
               raise(
-                ::ArgumentError,
+                ArgumentError,
                 'distribution_mode setting value must be either :histogram or :distribution'
               )
             end

data/lib/karafka/instrumentation/vendors/kubernetes/base_listener.rb

@@ -10,7 +10,7 @@ module Karafka
         # Base Kubernetes Listener providing basic HTTP server capabilities to respond with health
         # statuses
         class BaseListener
-          include ::Karafka::Core::Helpers::Time
+          include Karafka::Core::Helpers::Time
 
           # All good with Karafka
           OK_CODE = '200 OK'

data/lib/karafka/instrumentation/vendors/kubernetes/liveness_listener.rb

@@ -26,19 +26,6 @@ module Karafka
         #
         # @note Please use `Kubernetes::SwarmLivenessListener` when operating in the swarm mode
         class LivenessListener < BaseListener
-          # When any of those occurs, it means something went wrong in a way that cannot be
-          # recovered. In such cases we should report that the consumer process is not healthy.
-          # - `fenced` - This instance has been fenced by a newer instance and will not do any
-          #   processing at all never. Fencing most of the time means the instance.group.id has
-          #   been reused without properly terminating the previous consumer process first
-          # - `fatal` - any fatal error that halts the processing forever
-          UNRECOVERABLE_RDKAFKA_ERRORS = [
-            :fenced, # -144
-            :fatal # -150
-          ].freeze
-
-          private_constant :UNRECOVERABLE_RDKAFKA_ERRORS
-
           # @param hostname [String, nil] hostname or nil to bind on all
           # @param port [Integer] TCP port on which we want to run our HTTP status server
           # @param consuming_ttl [Integer] time in ms after which we consider consumption hanging.
@@ -113,8 +100,9 @@ module Karafka
 
             # We are only interested in the rdkafka errors
             return unless error.is_a?(Rdkafka::RdkafkaError)
-            # We mark as unrecoverable only on certain errors that will not be fixed by retrying
-            return unless UNRECOVERABLE_RDKAFKA_ERRORS.include?(error.code)
+            # When any of those occurs, it means something went wrong in a way that cannot be
+            # recovered. In such cases we should report that the consumer process is not healthy.
+            return unless error.fatal?
 
             @unrecoverable = error.code
           end
@@ -166,9 +154,8 @@ module Karafka
           end
 
           # Wraps the logic with a mutex
-          # @param block [Proc] code we want to run in mutex
-          def synchronize(&block)
-            @mutex.synchronize(&block)
+          def synchronize(&)
+            @mutex.synchronize(&)
           end
 
           # @return [Integer] object id of the current thread

data/lib/karafka/messages/builders/batch_metadata.rb

@@ -46,12 +46,12 @@ module Karafka
           # @note Message can be from the future in case consumer machine and Kafka cluster drift
           #   apart and the machine is behind the cluster.
           def local_created_at(last_message)
-            now = ::Time.now
+            now = Time.now
 
             return now unless last_message
 
             timestamp = last_message.timestamp
-            timestamp > now ? now : timestamp
+            [timestamp, now].min
           end
         end
       end

data/lib/karafka/messages/builders/message.rb

@@ -28,7 +28,7 @@ module Karafka
 
             # And nullify it in the kafka message. This can save a lot of memory when used with
             # the Pro Cleaner API
-            kafka_message.instance_variable_set('@payload', nil)
+            kafka_message.instance_variable_set(:@payload, nil)
 
             # Karafka messages cannot be frozen because of the lazy deserialization feature
             message = Karafka::Messages::Message.new(payload, metadata)

data/lib/karafka/messages/messages.rb

@@ -16,10 +16,9 @@ module Karafka
         @metadata = metadata
       end
 
-      # @param block [Proc] block we want to execute per each message
       # @note Invocation of this method will not cause loading and deserializing of messages.
-      def each(&block)
-        @messages_array.each(&block)
+      def each(&)
+        @messages_array.each(&)
       end
 
       # Runs deserialization of all the messages and returns them

data/lib/karafka/patches/rdkafka/bindings.rb

@@ -93,29 +93,29 @@ end
 
 # We need to replace the original callback with ours.
 # At the moment there is no API in rdkafka-ruby to do so
-::Rdkafka::Bindings.send(
+Rdkafka::Bindings.send(
   :remove_const,
   'RebalanceCallback'
 )
 
-::Rdkafka::Bindings.const_set(
-  'RebalanceCallback',
+Rdkafka::Bindings.const_set(
+  :RebalanceCallback,
   Karafka::Patches::Rdkafka::Bindings::RebalanceCallback
 )
 
-::Rdkafka::Bindings.attach_function(
+Rdkafka::Bindings.attach_function(
   :rd_kafka_rebalance_protocol,
   %i[pointer],
   :string
 )
 
-::Rdkafka::Bindings.attach_function(
+Rdkafka::Bindings.attach_function(
   :rd_kafka_incremental_assign,
   %i[pointer pointer],
   :string
 )
 
-::Rdkafka::Bindings.attach_function(
+Rdkafka::Bindings.attach_function(
   :rd_kafka_incremental_unassign,
   %i[pointer pointer],
   :string

data/lib/karafka/patches/rdkafka/opaque.rb

@@ -31,6 +31,6 @@ module Karafka
   end
 end
 
-::Rdkafka::Opaque.include(
+Rdkafka::Opaque.include(
   Karafka::Patches::Rdkafka::Opaque
 )

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

@@ -14,7 +14,7 @@ module Karafka
       #
       # It contains slightly better revocation warranties than the regular blocking consumer as
       # it can stop processing batch of jobs in the middle after the revocation.
-      class Consumer < ::Karafka::ActiveJob::Consumer
+      class Consumer < Karafka::ActiveJob::Consumer
         # Runs ActiveJob jobs processing and handles lrj if needed
         def consume
           messages.each(clean: true) do |message|
@@ -25,7 +25,7 @@ module Karafka
             # We cannot early stop when running virtual partitions because the intermediate state
             # would force us not to commit the offsets. This would cause extensive
             # double-processing
-            break if Karafka::App.stopping? && !topic.virtual_partitions?
+            break if ::Karafka::App.stopping? && !topic.virtual_partitions?
 
             consume_job(message)
 

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

@@ -10,7 +10,11 @@ module Karafka
       # Pro dispatcher that sends the ActiveJob job to a proper topic based on the queue name
       # and that allows to inject additional options into the producer, effectively allowing for a
       # much better and more granular control over the dispatch and consumption process.
-      class Dispatcher < ::Karafka::ActiveJob::Dispatcher
+      class Dispatcher < Karafka::ActiveJob::Dispatcher
+        include Helpers::ConfigImporter.new(
+          deserializer: %i[internal active_job deserializer]
+        )
+
         # Defaults for dispatching
         # They can be updated by using `#karafka_options` on the job
         DEFAULTS = {
@@ -27,7 +31,7 @@ module Karafka
           # Allows for setting a callable producer since at the moment of defining the class,
           # variants may not be available
           #
-          # We do not initialize it with `-> { ::Karafka.producer }` so we do not have to call it
+          # We do not initialize it with `-> { Karafka.producer }` so we do not have to call it
           #   each time for the defaults to preserve CPU cycles.
           #
           # We also do **not** cache the execution of this producer lambda because we want to
@@ -43,7 +47,7 @@ module Karafka
             fetch_option(job, :dispatch_method, DEFAULTS),
             dispatch_details(job).merge!(
               topic: job.queue_name,
-              payload: ::ActiveSupport::JSON.encode(serialize_job(job))
+              payload: serialize_job(job)
             )
           )
         end
@@ -64,7 +68,7 @@ module Karafka
 
             dispatches[d_method][producer] << dispatch_details(job).merge!(
               topic: job.queue_name,
-              payload: ::ActiveSupport::JSON.encode(serialize_job(job))
+              payload: serialize_job(job)
             )
           end
 
@@ -90,7 +94,7 @@ module Karafka
 
           target_message = dispatch_details(job).merge!(
             topic: job.queue_name,
-            payload: ::ActiveSupport::JSON.encode(serialize_job(job))
+            payload: serialize_job(job)
           )
 
           proxy_message = Pro::ScheduledMessages.schedule(
@@ -118,7 +122,7 @@ module Karafka
         def producer(job)
           dynamic_producer = fetch_option(job, :producer, DEFAULTS)
 
-          dynamic_producer ? dynamic_producer.call(job) : ::Karafka.producer
+          dynamic_producer ? dynamic_producer.call(job) : Karafka.producer
         end
 
         # @param job [ActiveJob::Base] job instance

data/lib/karafka/pro/active_job/job_options_contract.rb

@@ -10,10 +10,8 @@ module Karafka
       # class that works with Pro features.
       class JobOptionsContract < Contracts::Base
         configure do |config|
-          config.error_messages = YAML.safe_load(
-            File.read(
-              File.join(Karafka.gem_root, 'config', 'locales', 'errors.yml')
-            )
+          config.error_messages = YAML.safe_load_file(
+            File.join(Karafka.gem_root, 'config', 'locales', 'errors.yml')
           ).fetch('en').fetch('validations').fetch('job_options')
         end
 

data/lib/karafka/pro/cleaner/messages/messages.rb

@@ -17,7 +17,6 @@ module Karafka
         module Messages
           # @param clean [Boolean] do we want to clean each message after we're done working with
           #   it.
-          # @param block [Proc] block we want to execute per each message
           #
           # @note Cleaning messages after we're done with each of them and did not fail does not
           #   affect any other functionalities. The only thing that is crucial is to make sure,
@@ -27,14 +26,14 @@ module Karafka
           # @note This method calls super() to ensure compatibility with other libraries that
           #   may have prepended modules to modify #each behavior. This preserves the method
           #   chain and allows instrumentation libraries to function correctly.
-          def each(clean: false, &block)
+          def each(clean: false, &)
             if clean
               super() do |message|
                 yield(message)
                 message.clean!
               end
             else
-              super(&block)
+              super(&)
             end
           end
         end

data/lib/karafka/pro/cleaner.rb

@@ -19,9 +19,9 @@ module Karafka
       class << self
         # @param _config [Karafka::Core::Configurable::Node] root node config
         def pre_setup(_config)
-          ::Karafka::Messages::Message.prepend(Messages::Message)
-          ::Karafka::Messages::Metadata.prepend(Messages::Metadata)
-          ::Karafka::Messages::Messages.prepend(Messages::Messages)
+          Karafka::Messages::Message.prepend(Messages::Message)
+          Karafka::Messages::Metadata.prepend(Messages::Metadata)
+          Karafka::Messages::Messages.prepend(Messages::Messages)
         end
 
         # @param _config [Karafka::Core::Configurable::Node] root node config

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

@@ -10,12 +10,10 @@ module Karafka
       module Contracts
         # Contract for validating correctness of the server cli command options.
         # It differs slightly from the OSS one because it is aware of the routing patterns
-        class Server < ::Karafka::Cli::Contracts::Server
+        class Server < Karafka::Cli::Contracts::Server
           configure do |config|
-            config.error_messages = YAML.safe_load(
-              File.read(
-                File.join(Karafka.gem_root, 'config', 'locales', 'errors.yml')
-              )
+            config.error_messages = YAML.safe_load_file(
+              File.join(Karafka.gem_root, 'config', 'locales', 'errors.yml')
             ).fetch('en').fetch('validations').fetch('cli').fetch('server')
           end
 

data/lib/karafka/pro/cli/parallel_segments/base.rb

@@ -12,6 +12,7 @@ module Karafka
           include Helpers::Colorize
 
           # @param options [Hash] cli flags options
+          # @option options [Array<String>] :groups consumer group names to work with
           def initialize(options)
             @options = options
           end
@@ -23,12 +24,12 @@ module Karafka
 
           # Returns consumer groups for parallel segments with which we should be working
           #
-          # @return [Hash<String, Array<Karafka::Routing::ConsumerGroup>>] hash with all parallel
+          # @return [Hash{String => Array<Karafka::Routing::ConsumerGroup>}] hash with all parallel
           #   consumer groups as values and names of segments origin consumer group as the key.
           def applicable_groups
             requested_groups = options[:groups].dup || []
 
-            workable_groups = ::Karafka::App
+            workable_groups = Karafka::App
                               .routes
                               .select(&:parallel_segments?)
                               .group_by(&:segment_origin)
@@ -46,7 +47,7 @@ module Karafka
                 applicable_groups[requested_group] = workable_group
               else
                 raise(
-                  ::Karafka::Errors::ConsumerGroupNotFoundError,
+                  Karafka::Errors::ConsumerGroupNotFoundError,
                   "Consumer group #{requested_group} was not found"
                 )
               end
@@ -67,8 +68,7 @@ module Karafka
             consumer_groups = [segment_origin, segments.map(&:name)].flatten
 
             consumer_groups_with_topics = consumer_groups
-                                          .map { |name| [name, topics_names] }
-                                          .to_h
+                                          .to_h { |name| [name, topics_names] }
 
             lags_with_offsets = Karafka::Admin.read_lags_with_offsets(
               consumer_groups_with_topics

data/lib/karafka/pro/cli/parallel_segments/collapse.rb

@@ -123,8 +123,8 @@ module Karafka
                 inconclusive = true
 
                 puts(
-                  "  Inconclusive offsets for #{red(topic_name)}##{red(partition_id)}:" \
-                  " #{parallel_offsets.to_a.join(', ')}"
+                  "  Inconclusive offsets for #{red(topic_name)}##{red(partition_id)}: " \
+                  "#{parallel_offsets.to_a.join(', ')}"
                 )
               end
             end
@@ -132,7 +132,7 @@ module Karafka
             return unless inconclusive
 
             raise(
-              ::Karafka::Errors::CommandValidationError,
+              Karafka::Errors::CommandValidationError,
               "Parallel segments for #{red(segment_origin)} have #{red('inconclusive')} offsets"
             )
           end

data/lib/karafka/pro/cli/parallel_segments/distribute.rb

@@ -91,9 +91,9 @@ module Karafka
                   next unless offset.to_i.positive?
 
                   raise(
-                    ::Karafka::Errors::CommandValidationError,
-                    "Parallel segment #{red(cg_name)} already has offset #{red(offset)}" \
-                    " set for #{red("#{topic_name}##{partition_id}")}"
+                    Karafka::Errors::CommandValidationError,
+                    "Parallel segment #{red(cg_name)} already has offset #{red(offset)} " \
+                    "set for #{red("#{topic_name}##{partition_id}")}"
                   )
                 end
               end

data/lib/karafka/pro/cli/parallel_segments.rb

@@ -51,7 +51,7 @@ module Karafka
             Collapse.new(options).call
             Distribute.new(options).call
           else
-            raise ::ArgumentError, "Invalid topics action: #{action}"
+            raise ArgumentError, "Invalid topics action: #{action}"
           end
         end
       end

data/lib/karafka/pro/connection/manager.rb

@@ -21,7 +21,7 @@ module Karafka
 
         # Creates new manager instance
         def initialize
-          super()
+          super
           @mutex = Mutex.new
           @changes = Hash.new do |h, k|
             h[k] = {
@@ -69,7 +69,7 @@ module Karafka
           times = []
           # stateage is in microseconds
           # We monitor broker changes to make sure we do not introduce extra friction
-          times << statistics['brokers'].values.map { |stats| stats['stateage'] }.min / 1_000
+          times << (statistics['brokers'].values.map { |stats| stats['stateage'] }.min / 1_000)
           times << statistics['cgrp']['rebalance_age']
           times << statistics['cgrp']['stateage']
 
@@ -184,8 +184,7 @@ module Karafka
                                     .assignments
                                     .select { |_, partitions| partitions.size > 1 }
                                     .keys
-                                    .map(&:subscription_group)
-                                    .map(&:name)
+                                    .map { |sg| sg.subscription_group.name }
                                     .uniq
 
           # Select connections for scaling up

data/lib/karafka/pro/connection/multiplexing/listener.rb

@@ -12,6 +12,7 @@ module Karafka
         # Listener used to connect listeners manager to the lifecycle events that are significant
         # to its operations
         class Listener
+          # Initializes the multiplexing listener with the connection manager
           def initialize
             @manager = App.config.internal.connection.manager
           end

data/lib/karafka/pro/contracts/base.rb

@@ -8,7 +8,7 @@ module Karafka
     # Pro contracts that aim to replace or complement the general framework contracts
     module Contracts
       # Base for all the Pro contracts
-      class Base < ::Karafka::Contracts::Base
+      class Base < Karafka::Contracts::Base
       end
     end
   end

data/lib/karafka/pro/encryption/cipher.rb

@@ -12,6 +12,7 @@ module Karafka
           encryption: %i[encryption]
         )
 
+        # Initializes the cipher with empty private keys cache
         def initialize
           @private_pems = {}
         end
@@ -35,7 +36,7 @@ module Karafka
 
         # @return [::OpenSSL::PKey::RSA] rsa public key
         def public_pem
-          @public_pem ||= ::OpenSSL::PKey::RSA.new(encryption.public_key)
+          @public_pem ||= OpenSSL::PKey::RSA.new(encryption.public_key)
         end
 
         # @param version [String] version for which we want to get the rsa key
@@ -46,7 +47,7 @@ module Karafka
           key_string = encryption.private_keys[version]
           key_string || raise(Errors::PrivateKeyNotFoundError, version)
 
-          @private_pems[version] = ::OpenSSL::PKey::RSA.new(key_string)
+          @private_pems[version] = OpenSSL::PKey::RSA.new(key_string)
         end
       end
     end

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

@@ -9,12 +9,10 @@ module Karafka
       # Encryption related contracts
       module Contracts
         # Makes sure, all the expected config is defined as it should be
-        class Config < ::Karafka::Contracts::Base
+        class Config < Karafka::Contracts::Base
           configure do |config|
-            config.error_messages = YAML.safe_load(
-              File.read(
-                File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
-              )
+            config.error_messages = YAML.safe_load_file(
+              File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
             ).fetch('en').fetch('validations').fetch('setup').fetch('config')
           end
 
@@ -26,8 +24,8 @@ module Karafka
 
             required(:private_keys) do |val|
               val.is_a?(Hash) &&
-                val.keys.all? { |key| key.is_a?(String) } &&
-                val.values.all? { |key| key.is_a?(String) }
+                val.keys.all?(String) &&
+                val.values.all?(String)
             end
           end
 

data/lib/karafka/pro/encryption/messages/parser.rb

@@ -11,7 +11,7 @@ module Karafka
         # @note There may be a case where someone decides not to encrypt data and we start getting
         #   unencrypted payloads. That is why we always rely on message headers for encryption
         #   indication.
-        class Parser < ::Karafka::Messages::Parser
+        class Parser < Karafka::Messages::Parser
           include Helpers::ConfigImporter.new(
             cipher: %i[encryption cipher],
             active: %i[encryption active],
@@ -25,7 +25,7 @@ module Karafka
             encryption = headers['encryption']
             fingerprint = headers['encryption_fingerprint']
 
-            return super(message) unless active && encryption
+            return super unless active && encryption
 
             # Decrypt raw payload so it can be handled by the default parser logic
             decrypted_payload = cipher.decrypt(
@@ -35,11 +35,11 @@ module Karafka
 
             message.raw_payload = decrypted_payload
 
-            return super(message) unless fingerprint && fingerprinter
+            return super unless fingerprint && fingerprinter
 
             message_fingerprint = fingerprinter.hexdigest(decrypted_payload)
 
-            return super(message) if message_fingerprint == fingerprint
+            return super if message_fingerprint == fingerprint
 
             raise(Errors::FingerprintVerificationError, message.to_s)
           end

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

@@ -10,7 +10,7 @@ module Karafka
       module Setup
         # Config for encryption
         class Config
-          extend ::Karafka::Core::Configurable
+          extend Karafka::Core::Configurable
 
           # Should this feature be in use
           setting(:active, default: false)

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

@@ -50,7 +50,7 @@ module Karafka
           partition = messages.metadata.partition
 
           samples = @processing_times[topic][partition]
-          samples << event[:time] / messages.size
+          samples << (event[:time] / messages.size)
 
           return unless samples.size > SAMPLES_COUNT
 
@@ -66,8 +66,8 @@ module Karafka
         def percentile(percentile, values)
           values_sorted = values.sort
 
-          floor = (percentile * (values_sorted.length - 1) + 1).floor - 1
-          mod = (percentile * (values_sorted.length - 1) + 1).modulo(1)
+          floor = ((percentile * (values_sorted.length - 1)) + 1).floor - 1
+          mod = ((percentile * (values_sorted.length - 1)) + 1).modulo(1)
 
           values_sorted[floor] + (mod * (values_sorted[floor + 1] - values_sorted[floor]))
         end

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

@@ -62,7 +62,7 @@ module Karafka
 
           # If we've got just array with topics, we need to convert that into a representation
           # that we can expand with offsets
-          topics = topics.map { |name| [name, false] }.to_h if topics.is_a?(Array)
+          topics = topics.to_h { |name| [name, false] } if topics.is_a?(Array)
           # We remap by creating new hash, just in case the hash came as the argument for this
           # expanded. We do not want to modify user provided hash
           topics.transform_keys(&:to_s)

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

@@ -22,7 +22,7 @@ module Karafka
         # @param consumer [::Rdkafka::Consumer] consumer instance needed to talk with Kafka
         # @param expanded_topics [Hash] hash with expanded and normalized topics data
         def initialize(consumer, expanded_topics)
-          @consumer = ::Karafka::Connection::Proxy.new(consumer)
+          @consumer = Karafka::Connection::Proxy.new(consumer)
           @expanded_topics = expanded_topics
           @mapped_topics = Hash.new { |h, k| h[k] = {} }
         end
@@ -56,7 +56,7 @@ module Karafka
             next unless partitions.is_a?(Array) || partitions.is_a?(Range)
 
             # When no offsets defined, we just start from zero
-            @mapped_topics[name] = partitions.map { |partition| [partition, 0] }.to_h
+            @mapped_topics[name] = partitions.to_h { |partition| [partition, 0] }
           end
         end
 

data/lib/karafka/pro/iterator.rb

@@ -43,9 +43,9 @@ module Karafka
       )
         @topics_with_partitions = Expander.new.call(topics)
 
-        @routing_topics = @topics_with_partitions.map do |name, _|
-          [name, ::Karafka::Routing::Router.find_or_initialize_by_name(name)]
-        end.to_h
+        @routing_topics = @topics_with_partitions.to_h do |name, _|
+          [name, Karafka::Routing::Router.find_or_initialize_by_name(name)]
+        end
 
         @total_partitions = @topics_with_partitions.map(&:last).sum(&:count)
 

data/lib/karafka/pro/loader.rb

@@ -120,7 +120,7 @@ module Karafka
         # Loads the Pro features of Karafka
         # @note Object space lookup is not the fastest but we do it once during boot, so it's ok
         def load_topic_features
-          ::Karafka::Pro::Routing::Features::Base.load_all
+          Karafka::Pro::Routing::Features::Base.load_all
         end
       end
     end