karafka 1.0.1 → 1.4.14

data/lib/karafka/consumers/includer.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Karafka
+  # Additional functionalities for consumers
+  module Consumers
+    # Module used to inject functionalities into a given consumer instance, based on the consumer
+    # topic and its settings
+    # We don't need all the behaviors in all the cases, so it is not worth having everything
+    # in all the cases all the time
+    module Includer
+      class << self
+        # @param consumer [Karafka::BaseConsumer] consumer instance, that will get some
+        #   functionalities based on the topic under which it operates
+        def call(consumer)
+          topic = consumer.topic
+
+          bind_backend(consumer, topic)
+          bind_params(consumer, topic)
+          bind_batch_metadata(consumer, topic)
+          bind_responders(consumer, topic)
+        end
+
+        private
+
+        # Figures out backend for a given consumer class, based on the topic backend and
+        #   includes it into the consumer class
+        # @param consumer [Karafka::BaseConsumer] consumer instance
+        # @param topic [Karafka::Routing::Topic] topic of a consumer class
+        def bind_backend(consumer, topic)
+          backend = Kernel.const_get("::Karafka::Backends::#{topic.backend.to_s.capitalize}")
+          consumer.extend(backend)
+        end
+
+        # Adds a single #params support for non batch processed topics
+        # @param consumer [Karafka::BaseConsumer] consumer instance
+        # @param topic [Karafka::Routing::Topic] topic of a consumer class
+        def bind_params(consumer, topic)
+          return if topic.batch_consuming
+
+          consumer.extend(SingleParams)
+        end
+
+        # Adds an option to work with batch metadata for consumer instances that have
+        #   batch fetching enabled
+        # @param consumer [Karafka::BaseConsumer] consumer instance
+        # @param topic [Karafka::Routing::Topic] topic of a consumer class
+        def bind_batch_metadata(consumer, topic)
+          return unless topic.batch_fetching
+
+          consumer.extend(BatchMetadata)
+        end
+
+        # Adds responders support for topics and consumers with responders defined for them
+        # @param consumer [Karafka::BaseConsumer] consumer instance
+        # @param topic [Karafka::Routing::Topic] topic of a consumer class
+        def bind_responders(consumer, topic)
+          return unless topic.responder
+
+          consumer.extend(Responders)
+        end
+      end
+    end
+  end
+end

data/lib/karafka/consumers/responders.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Karafka
+  module Consumers
+    # Feature that allows us to use responders flow in consumer
+    module Responders
+      # Responds with given data using given responder. This allows us to have a similar way of
+      # defining flows like synchronous protocols
+      # @param data Anything we want to pass to responder based on which we want to trigger further
+      #   Kafka responding
+      def respond_with(*data)
+        Karafka.monitor.instrument(
+          'consumers.responders.respond_with',
+          caller: self,
+          data: data
+        ) do
+          # @note we build a new instance of responder each time, as a long-running (persisted)
+          #   consumers can respond multiple times during the life-cycle
+          topic.responder.new.call(*data)
+        end
+      end
+    end
+  end
+end

data/lib/karafka/{controllers → consumers}/single_params.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
 module Karafka
-  module Controllers
-    # Params alias for single message processing controllers
+  module Consumers
+    # Params alias for single message consumption consumers
     module SingleParams
       private
 
-      # @return [Karafka::Params::Params] params instance for non batch processed controllers
+      # @return [Karafka::Params::Params] params instance for non batch consumption consumers
       def params
         params_batch.first
       end

data/lib/karafka/contracts/config.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Karafka
+  module Contracts
+    # Contract with validation rules for Karafka configuration details
+    # @note There are many more configuration options inside of the
+    #   Karafka::Setup::Config model, but we don't validate them here as they are
+    #   validated per each route (topic + consumer_group) because they can be overwritten,
+    #   so we validate all of that once all the routes are defined and ready
+    class Config < Dry::Validation::Contract
+      params do
+        required(:client_id).filled(:str?, format?: Karafka::Contracts::TOPIC_REGEXP)
+        required(:shutdown_timeout) { (int? & gt?(0)) }
+        required(:consumer_mapper)
+        required(:topic_mapper)
+
+        optional(:backend).filled
+      end
+    end
+  end
+end

data/lib/karafka/contracts/consumer_group.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module Karafka
+  module Contracts
+    # Contract for single full route (consumer group + topics) validation.
+    class ConsumerGroup < Dry::Validation::Contract
+      config.messages.load_paths << File.join(Karafka.gem_root, 'config', 'errors.yml')
+
+      # Valid uri schemas of Kafka broker url
+      # The ||= is due to the behavior of require_all that resolves dependencies
+      # but sometimes loads things twice
+      URI_SCHEMES ||= %w[kafka kafka+ssl plaintext ssl].freeze
+
+      # Available sasl scram mechanism of authentication (plus nil)
+      SASL_SCRAM_MECHANISMS ||= %w[sha256 sha512].freeze
+
+      # Internal contract for sub-validating topics schema
+      TOPIC_CONTRACT = ConsumerGroupTopic.new.freeze
+
+      private_constant :TOPIC_CONTRACT
+
+      params do
+        required(:id).filled(:str?, format?: Karafka::Contracts::TOPIC_REGEXP)
+        required(:topics).value(:array, :filled?)
+        required(:seed_brokers).value(:array, :filled?)
+        required(:session_timeout).filled { int? | float? }
+        required(:pause_timeout).maybe(%i[integer float]) { filled? > gteq?(0) }
+        required(:pause_max_timeout).maybe(%i[integer float]) { filled? > gteq?(0) }
+        required(:pause_exponential_backoff).filled(:bool?)
+        required(:offset_commit_interval) { int? | float? }
+        required(:offset_commit_threshold).filled(:int?)
+        required(:offset_retention_time).maybe(:integer)
+        required(:heartbeat_interval).filled { (int? | float?) & gteq?(0) }
+        required(:fetcher_max_queue_size).filled(:int?, gt?: 0)
+        required(:assignment_strategy).value(:any)
+        required(:connect_timeout).filled { (int? | float?) & gt?(0) }
+        required(:reconnect_timeout).filled { (int? | float?) & gteq?(0) }
+        required(:socket_timeout).filled { (int? | float?) & gt?(0) }
+        required(:min_bytes).filled(:int?, gt?: 0)
+        required(:max_bytes).filled(:int?, gt?: 0)
+        required(:max_wait_time).filled { (int? | float?) & gteq?(0) }
+        required(:batch_fetching).filled(:bool?)
+
+        %i[
+          ssl_ca_cert
+          ssl_ca_cert_file_path
+          ssl_client_cert
+          ssl_client_cert_key
+          ssl_client_cert_chain
+          ssl_client_cert_key_password
+          sasl_gssapi_principal
+          sasl_gssapi_keytab
+          sasl_plain_authzid
+          sasl_plain_username
+          sasl_plain_password
+          sasl_scram_username
+          sasl_scram_password
+        ].each do |encryption_attribute|
+          optional(encryption_attribute).maybe(:str?)
+        end
+
+        optional(:ssl_verify_hostname).maybe(:bool?)
+        optional(:ssl_ca_certs_from_system).maybe(:bool?)
+        optional(:sasl_over_ssl).maybe(:bool?)
+        optional(:sasl_oauth_token_provider).value(:any)
+
+        # It's not with other encryptions as it has some more rules
+        optional(:sasl_scram_mechanism)
+          .maybe(:str?, included_in?: SASL_SCRAM_MECHANISMS)
+      end
+
+      # Uri rule to check if uri is in a Karafka acceptable format
+      rule(:seed_brokers) do
+        if value.is_a?(Array) && !value.all?(&method(:kafka_uri?))
+          key.failure(:invalid_broker_schema)
+        end
+      end
+
+      rule(:topics) do
+        if value.is_a?(Array)
+          names = value.map { |topic| topic[:name] }
+
+          key.failure(:topics_names_not_unique) if names.size != names.uniq.size
+        end
+      end
+
+      rule(:topics) do
+        if value.is_a?(Array)
+          value.each_with_index do |topic, index|
+            TOPIC_CONTRACT.call(topic).errors.each do |error|
+              key([:topics, index, error.path[0]]).failure(error.text)
+            end
+          end
+        end
+      end
+
+      rule(:assignment_strategy) do
+        key.failure(:does_not_respond_to_call) unless value.respond_to?(:call)
+      end
+
+      rule(:ssl_client_cert, :ssl_client_cert_key) do
+        if values[:ssl_client_cert] && !values[:ssl_client_cert_key]
+          key(:ssl_client_cert_key).failure(:ssl_client_cert_with_ssl_client_cert_key)
+        end
+      end
+
+      rule(:ssl_client_cert, :ssl_client_cert_key) do
+        if values[:ssl_client_cert_key] && !values[:ssl_client_cert]
+          key(:ssl_client_cert).failure(:ssl_client_cert_key_with_ssl_client_cert)
+        end
+      end
+
+      rule(:ssl_client_cert, :ssl_client_cert_chain) do
+        if values[:ssl_client_cert_chain] && !values[:ssl_client_cert]
+          key(:ssl_client_cert).failure(:ssl_client_cert_chain_with_ssl_client_cert)
+        end
+      end
+
+      rule(:ssl_client_cert_chain, :ssl_client_cert_key) do
+        if values[:ssl_client_cert_chain] && !values[:ssl_client_cert]
+          key(:ssl_client_cert).failure(:ssl_client_cert_chain_with_ssl_client_cert_key)
+        end
+      end
+
+      rule(:ssl_client_cert_key_password, :ssl_client_cert_key) do
+        if values[:ssl_client_cert_key_password] && !values[:ssl_client_cert_key]
+          key(:ssl_client_cert_key).failure(:ssl_client_cert_key_password_with_ssl_client_cert_key)
+        end
+      end
+
+      rule(:ssl_ca_cert) do
+        key.failure(:invalid_certificate) if value && !valid_certificate?(value)
+      end
+
+      rule(:ssl_client_cert) do
+        key.failure(:invalid_certificate) if value && !valid_certificate?(value)
+      end
+
+      rule(:ssl_ca_cert_file_path) do
+        if value
+          if File.exist?(value)
+            key.failure(:invalid_certificate_from_path) unless valid_certificate?(File.read(value))
+          else
+            key.failure(:does_not_exist)
+          end
+        end
+      end
+
+      rule(:ssl_client_cert_key) do
+        key.failure(:invalid_private_key) if value && !valid_private_key?(value)
+      end
+
+      rule(:ssl_client_cert_chain) do
+        key.failure(:invalid_certificate) if value && !valid_certificate?(value)
+      end
+
+      rule(:sasl_oauth_token_provider) do
+        key.failure(:does_not_respond_to_token) if value && !value.respond_to?(:token)
+      end
+
+      rule(:max_wait_time, :socket_timeout) do
+        max_wait_time = values[:max_wait_time]
+        socket_timeout = values[:socket_timeout]
+
+        if socket_timeout.is_a?(Numeric) &&
+           max_wait_time.is_a?(Numeric) &&
+           max_wait_time > socket_timeout
+
+          key(:max_wait_time).failure(:max_wait_time_limit)
+        end
+      end
+
+      rule(:pause_timeout, :pause_max_timeout, :pause_exponential_backoff) do
+        if values[:pause_exponential_backoff]
+          if values[:pause_timeout].to_i > values[:pause_max_timeout].to_i
+            key(:pause_max_timeout).failure(:max_timeout_size_for_exponential)
+          end
+        end
+      end
+
+      private
+
+      # @param value [String] potential RSA key value
+      # @return [Boolean] is the given string a valid RSA key
+      def valid_private_key?(value)
+        OpenSSL::PKey.read(value)
+        true
+      rescue OpenSSL::PKey::PKeyError
+        false
+      end
+
+      # @param value [String] potential X509 cert value
+      # @return [Boolean] is the given string a valid X509 cert
+      def valid_certificate?(value)
+        OpenSSL::X509::Certificate.new(value)
+        true
+      rescue OpenSSL::X509::CertificateError
+        false
+      end
+
+      # @param value [String] potential kafka uri
+      # @return [Boolean] true if it is a kafka uri, otherwise false
+      def kafka_uri?(value)
+        uri = URI.parse(value)
+        URI_SCHEMES.include?(uri.scheme) && uri.port
+      rescue URI::InvalidURIError
+        false
+      end
+    end
+  end
+end

data/lib/karafka/contracts/consumer_group_topic.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Karafka
+  module Contracts
+    # Consumer group topic validation rules
+    class ConsumerGroupTopic < Dry::Validation::Contract
+      params do
+        required(:id).filled(:str?, format?: Karafka::Contracts::TOPIC_REGEXP)
+        required(:name).filled(:str?, format?: Karafka::Contracts::TOPIC_REGEXP)
+        required(:backend).filled(included_in?: %i[inline sidekiq])
+        required(:consumer).filled
+        required(:deserializer).filled
+        required(:max_bytes_per_partition).filled(:int?, gteq?: 0)
+        required(:start_from_beginning).filled(:bool?)
+        required(:batch_consuming).filled(:bool?)
+      end
+    end
+  end
+end

data/lib/karafka/contracts/responder_usage.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Karafka
+  module Contracts
+    # Validator to check responder topic usage
+    class ResponderUsageTopic < Dry::Validation::Contract
+      config.messages.load_paths << File.join(Karafka.gem_root, 'config', 'errors.yml')
+
+      params do
+        required(:name).filled(:str?, format?: Karafka::Contracts::TOPIC_REGEXP)
+        required(:required).filled(:bool?)
+        required(:usage_count).filled(:int?, gteq?: 0)
+        required(:registered).filled(eql?: true)
+        required(:async).filled(:bool?)
+        required(:serializer).filled
+      end
+
+      rule(:required, :usage_count) do
+        key(:name).failure(:required_usage_count) if values[:required] && values[:usage_count] < 1
+      end
+    end
+
+    # Validator to check that everything in a responder flow matches responder rules
+    class ResponderUsage < Dry::Validation::Contract
+      include Dry::Core::Constants
+
+      # Contract for verifying the topic usage details
+      TOPIC_CONTRACT = ResponderUsageTopic.new.freeze
+
+      private_constant :TOPIC_CONTRACT
+
+      params do
+        required(:used_topics)
+        required(:registered_topics)
+      end
+
+      rule(:used_topics) do
+        (value || EMPTY_ARRAY).each do |used_topic|
+          TOPIC_CONTRACT.call(used_topic).errors.each do |error|
+            key([:used_topics, used_topic, error.path[0]]).failure(error.text)
+          end
+        end
+      end
+
+      rule(:registered_topics) do
+        (value || EMPTY_ARRAY).each do |used_topic|
+          TOPIC_CONTRACT.call(used_topic).errors.each do |error|
+            key([:registered_topics, used_topic, error.path[0]]).failure(error.text)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/karafka/contracts/server_cli_options.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Karafka
+  module Contracts
+    # Contract for validating correctness of the server cli command options
+    # We validate some basics + the list of consumer_groups on which we want to use, to make
+    # sure that all of them are defined, plus that a pidfile does not exist
+    class ServerCliOptions < Dry::Validation::Contract
+      config.messages.load_paths << File.join(Karafka.gem_root, 'config', 'errors.yml')
+
+      params do
+        optional(:pid).filled(:str?)
+        optional(:daemon).filled(:bool?)
+        optional(:consumer_groups).value(:array, :filled?)
+      end
+
+      rule(:pid) do
+        key(:pid).failure(:pid_already_exists) if value && File.exist?(value)
+      end
+
+      rule(:consumer_groups) do
+        # If there were no consumer_groups declared in the server cli, it means that we will
+        # run all of them and no need to validate them here at all
+        if !value.nil? &&
+           !(value - Karafka::App.config.internal.routing_builder.map(&:name)).empty?
+          key(:consumer_groups).failure(:consumer_groups_inclusion)
+        end
+      end
+    end
+  end
+end

data/lib/karafka/contracts.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Karafka
+  # Namespace for all the validation contracts that we use to check input
+  module Contracts
+    # Regexp for validating format of groups and topics
+    # @note It is not nested inside of the contracts, as it is used by couple of them
+    TOPIC_REGEXP = /\A(\w|-|\.)+\z/.freeze
+  end
+end

data/lib/karafka/errors.rb

@@ -6,17 +6,18 @@ module Karafka
     # Base class for all the Karafka internal errors
     BaseError = Class.new(StandardError)
 
-    # Should be raised when we attemp to parse incoming params but parsing fails
-    #   If this error (or its descendant) is detected, we will pass the raw message
-    #   into params and proceed further
-    ParserError = Class.new(BaseError)
+    # Should be raised when we have that that we cannot serialize
+    SerializationError = Class.new(BaseError)
+
+    # Should be raised when we tried to deserialize incoming data but we failed
+    DeserializationError = Class.new(BaseError)
 
     # Raised when router receives topic name which does not correspond with any routes
     # This can only happen in a case when:
-    #   - you've received a message and we cannot match it with a controller
+    #   - you've received a message and we cannot match it with a consumer
     #   - you've changed the routing, so router can no longer associate your topic to
-    #     any controller
-    #   - or in a case when you do a lot of metaprogramming and you change routing/etc on runtime
+    #     any consumer
+    #   - or in a case when you do a lot of meta-programming and you change routing/etc on runtime
     #
     # In case this happens, you will have to create a temporary route that will allow
     # you to "eat" everything from the Sidekiq queue.
@@ -25,12 +26,26 @@ module Karafka
 
     # Raised when we don't use or use responder not in the way it expected to based on the
     # topics usage definitions
-    InvalidResponderUsage = Class.new(BaseError)
+    InvalidResponderUsageError = Class.new(BaseError)
+
+    # Raised when options that we provide to the responder to respond aren't what the contract
+    # requires
+    InvalidResponderMessageOptionsError = Class.new(BaseError)
+
+    # Raised when configuration doesn't match with validation contract
+    InvalidConfigurationError = Class.new(BaseError)
+
+    # Raised when we try to use Karafka CLI commands (except install) without a boot file
+    MissingBootFileError = Class.new(BaseError)
+
+    # Raised when we want to read a persisted thread messages consumer but it is unavailable
+    # This should never happen and if it does, please contact us
+    MissingClientError = Class.new(BaseError)
 
-    # Raised when configuration doesn't match with validation schema
-    InvalidConfiguration = Class.new(BaseError)
+    # Raised when want to hook up to an event that is not registered and supported
+    UnregisteredMonitorEventError = Class.new(BaseError)
 
-    # Raised when we try to use Karafka CLI commands (except install) without a bootfile
-    MissingBootFile = Class.new(BaseError)
+    # Raised when we've waited enough for shutting down a non-responsive process
+    ForcefulShutdownError = Class.new(BaseError)
   end
 end

data/lib/karafka/fetcher.rb

@@ -8,16 +8,24 @@ module Karafka
     # Starts listening on all the listeners asynchronously
     # Fetch loop should never end, which means that we won't create more actor clusters
     # so we don't have to terminate them
-    def fetch_loop
-      futures = listeners.map do |listener|
-        listener.future.public_send(:fetch_loop, processor)
+    def call
+      threads = listeners.map do |listener|
+        # We abort on exception because there should be an exception handling developed for
+        # each listener running in separate threads, so the exceptions should never leak
+        # and if that happens, it means that something really bad happened and we should stop
+        # the whole process
+        Thread
+          .new { listener.call }
+          .tap { |thread| thread.abort_on_exception = true }
       end
 
-      futures.map(&:value)
+      # We aggregate threads here for a supervised shutdown process
+      threads.each { |thread| Karafka::Server.consumer_threads << thread }
+      threads.each(&:join)
     # If anything crashes here, we need to raise the error and crush the runner because it means
-    # that something really bad happened
-    rescue => e
-      Karafka.monitor.notice_error(self.class, e)
+    # that something terrible happened
+    rescue StandardError => e
+      Karafka.monitor.instrument('fetcher.call.error', caller: self, error: e)
       Karafka::App.stop!
       raise e
     end
@@ -30,13 +38,5 @@ module Karafka
         Karafka::Connection::Listener.new(consumer_group)
       end
     end
-
-    # @return [Proc] proc that should be processed when a messages arrive
-    # @yieldparam messages [Array<Kafka::FetchedMessage>] messages from kafka (raw)
-    def processor
-      lambda do |group_id, messages|
-        Karafka::Connection::MessagesProcessor.process(group_id, messages)
-      end
-    end
   end
 end

data/lib/karafka/helpers/class_matcher.rb

@@ -4,20 +4,22 @@ module Karafka
   module Helpers
     # Class used to autodetect corresponding classes that are internally inside Karafka framework
     # It is used among others to match:
-    #   controller => responder
+    #   consumer => responder
     class ClassMatcher
-      # Regexp used to remove any non classy like characters that might be in the controller
+      # Regexp used to remove any non classy like characters that might be in the consumer
       # class name (if defined dynamically, etc)
-      CONSTANT_REGEXP = %r{[?!=+\-\*/\^\|&\[\]<>%~\#\:\s\(\)]}
+      CONSTANT_REGEXP = %r{[?!=+\-*/\^|&\[\]<>%~\#:\s()]}.freeze
+
+      private_constant :CONSTANT_REGEXP
 
       # @param klass [Class] class to which we want to find a corresponding class
       # @param from [String] what type of object is it (based on postfix name part)
       # @param to [String] what are we looking for (based on a postfix name part)
-      # @example Controller that has a corresponding responder
-      #   matcher = Karafka::Helpers::ClassMatcher.new(SuperController, 'Controller', 'Responder')
+      # @example Consumer that has a corresponding responder
+      #   matcher = Karafka::Helpers::ClassMatcher.new(SuperConsumer, 'Consumer', 'Responder')
       #   matcher.match #=> SuperResponder
-      # @example Controller without a corresponding responder
-      #   matcher = Karafka::Helpers::ClassMatcher.new(Super2Controller, 'Controller', 'Responder')
+      # @example Consumer without a corresponding responder
+      #   matcher = Karafka::Helpers::ClassMatcher.new(Super2Consumer, 'Consumer', 'Responder')
       #   matcher.match #=> nil
       def initialize(klass, from:, to:)
         @klass = klass
@@ -30,18 +32,25 @@ module Karafka
       def match
         return nil if name.empty?
         return nil unless scope.const_defined?(name)
+
         matching = scope.const_get(name)
         same_scope?(matching) ? matching : nil
       end
 
       # @return [String] name of a new class that we're looking for
       # @note This method returns name of a class without a namespace
-      # @example From SuperController matching responder
+      # @example From SuperConsumer matching responder
       #   matcher.name #=> 'SuperResponder'
-      # @example From Namespaced::Super2Controller matching responder
+      # @example From Namespaced::Super2Consumer matching responder
       #   matcher.name #=> Super2Responder
       def name
-        inflected = @klass.to_s.split('::').last.to_s
+        inflected = +@klass.to_s.split('::').last.to_s
+        # We inject the from into the name just in case it is missing as in a situation like
+        # that it would just sanitize the name without adding the "to" postfix.
+        # It could create cases when we want to build for example a responder to a consumer
+        # that does not have the "Consumer" postfix and would do nothing returning the same name.
+        # That would be bad as the matching classes shouldn't be matched to themselves.
+        inflected << @from unless inflected.include?(@from)
         inflected.gsub!(@from, @to)
         inflected.gsub!(CONSTANT_REGEXP, '')
         inflected
@@ -65,6 +74,7 @@ module Karafka
       def scope_of(klass)
         enclosing = klass.to_s.split('::')[0...-1]
         return ::Object if enclosing.empty?
+
         ::Object.const_get(enclosing.join('::'))
       end
 

data/lib/karafka/helpers/config_retriever.rb

@@ -5,7 +5,7 @@ module Karafka
     # A helper method that allows us to build methods that try to get a given
     # attribute from its instance value and if it fails, will fallback to
     # the default config or config.kafka value for a given attribute.
-    # It is used to simplify the checkings.
+    # It is used to simplify the checks.
     # @note Worth noticing, that the value might be equal to false, so even
     #   then we need to return it. That's why we check for nil?
     # @example Define config retried attribute for start_from_beginning
@@ -33,9 +33,9 @@ module Karafka
           return current_value unless current_value.nil?
 
           value = if Karafka::App.config.respond_to?(attribute)
-                    Karafka::App.config.public_send(attribute)
+                    Karafka::App.config.send(attribute)
                   else
-                    Karafka::App.config.kafka.public_send(attribute)
+                    Karafka::App.config.kafka.send(attribute)
                   end
 
           instance_variable_set(:"@#{attribute}", value)

data/lib/karafka/helpers/inflector.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Karafka
+  module Helpers
+    # Inflector provides inflection for the whole Karafka framework with additional inflection
+    # caching (due to the fact, that Dry::Inflector is slow)
+    module Inflector
+      # What inflection engine do we want to use
+      ENGINE = Dry::Inflector.new
+
+      @map = Concurrent::Hash.new
+
+      private_constant :ENGINE
+
+      class << self
+        # @param string [String] string that we want to convert to our underscore format
+        # @return [String] inflected string
+        # @example
+        #   Karafka::Helpers::Inflector.map('Module/ControllerName') #=> 'module_controller_name'
+        def map(string)
+          @map[string] ||= ENGINE.underscore(string).tr('/', '_')
+        end
+      end
+    end
+  end
+end