karafka 1.4.13 → 2.0.0

data/lib/karafka/contracts/config.rb

@@ -2,19 +2,96 @@
 
 module Karafka
   module Contracts
-    # Contract with validation rules for Karafka configuration details
+    # 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
+    #   `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
+    #   so we validate all of that once all the routes are defined and ready.
+    class Config < Base
+      configure do |config|
+        config.error_messages = YAML.safe_load(
+          File.read(
+            File.join(Karafka.gem_root, 'config', 'errors.yml')
+          )
+        ).fetch('en').fetch('validations').fetch('config')
+      end
+
+      # License validity happens in the licenser. Here we do only the simple consistency checks
+      nested(:license) do
+        required(:token) { |val| [true, false].include?(val) || val.is_a?(String) }
+        required(:entity) { |val| val.is_a?(String) }
+      end
+
+      required(:client_id) { |val| val.is_a?(String) && Contracts::TOPIC_REGEXP.match?(val) }
+      required(:concurrency) { |val| val.is_a?(Integer) && val.positive? }
+      required(:consumer_mapper) { |val| !val.nil? }
+      required(:consumer_persistence) { |val| [true, false].include?(val) }
+      required(:pause_timeout) { |val| val.is_a?(Integer) && val.positive? }
+      required(:pause_max_timeout) { |val| val.is_a?(Integer) && val.positive? }
+      required(:pause_with_exponential_backoff) { |val| [true, false].include?(val) }
+      required(:shutdown_timeout) { |val| val.is_a?(Integer) && val.positive? }
+      required(:max_wait_time) { |val| val.is_a?(Integer) && val.positive? }
+      required(:kafka) { |val| val.is_a?(Hash) && !val.empty? }
+
+      # We validate internals just to be sure, that they are present and working
+      nested(:internal) do
+        required(:status) { |val| !val.nil? }
+        required(:process) { |val| !val.nil? }
+
+        nested(:routing) do
+          required(:builder) { |val| !val.nil? }
+          required(:subscription_groups_builder) { |val| !val.nil? }
+        end
+
+        nested(:processing) do
+          required(:jobs_builder) { |val| !val.nil? }
+          required(:scheduler) { |val| !val.nil? }
+          required(:coordinator_class) { |val| !val.nil? }
+          required(:partitioner_class) { |val| !val.nil? }
+        end
+
+        nested(:active_job) do
+          required(:dispatcher) { |val| !val.nil? }
+          required(:job_options_contract) { |val| !val.nil? }
+          required(:consumer_class) { |val| !val.nil? }
+        end
+      end
+
+      virtual do |data, errors|
+        next unless errors.empty?
+
+        detected_errors = []
+
+        data.fetch(:kafka).each_key do |key|
+          next if key.is_a?(Symbol)
+
+          detected_errors << [[:kafka, key], :key_must_be_a_symbol]
+        end
+
+        detected_errors
+      end
+
+      virtual do |data, errors|
+        next unless errors.empty?
+
+        pause_timeout = data.fetch(:pause_timeout)
+        pause_max_timeout = data.fetch(:pause_max_timeout)
+
+        next if pause_timeout <= pause_max_timeout
+
+        [[%i[pause_timeout], :max_timeout_vs_pause_max_timeout]]
+      end
+
+      virtual do |data, errors|
+        next unless errors.empty?
+
+        shutdown_timeout = data.fetch(:shutdown_timeout)
+        max_wait_time = data.fetch(:max_wait_time)
+
+        next if max_wait_time < shutdown_timeout
+
+        [[%i[shutdown_timeout], :shutdown_timeout_vs_max_wait_time]]
       end
     end
   end

data/lib/karafka/contracts/consumer_group.rb

@@ -3,208 +3,40 @@
 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
+    class ConsumerGroup < Base
+      configure do |config|
+        config.error_messages = YAML.safe_load(
+          File.read(
+            File.join(Karafka.gem_root, 'config', 'errors.yml')
+          )
+        ).fetch('en').fetch('validations').fetch('consumer_group')
       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
+      required(:id) { |id| id.is_a?(String) && Contracts::TOPIC_REGEXP.match?(id) }
+      required(:topics) { |topics| topics.is_a?(Array) && !topics.empty? }
 
-      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
+      virtual do |data, errors|
+        next unless errors.empty?
 
-      rule(:ssl_ca_cert) do
-        key.failure(:invalid_certificate) if value && !valid_certificate?(value)
-      end
+        names = data.fetch(:topics).map { |topic| topic[:name] }
 
-      rule(:ssl_client_cert) do
-        key.failure(:invalid_certificate) if value && !valid_certificate?(value)
-      end
+        next if names.size == names.uniq.size
 
-      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
+        [[%i[topics], :names_not_unique]]
       end
 
-      rule(:ssl_client_cert_key) do
-        key.failure(:invalid_private_key) if value && !valid_private_key?(value)
-      end
+      virtual do |data, errors|
+        next unless errors.empty?
 
-      rule(:ssl_client_cert_chain) do
-        key.failure(:invalid_certificate) if value && !valid_certificate?(value)
-      end
+        fetched_errors = []
 
-      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)
+        data.fetch(:topics).each do |topic|
+          ConsumerGroupTopic.new.call(topic).errors.each do |key, value|
+            fetched_errors << [[topic, key].flatten, value]
           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
+        fetched_errors
       end
     end
   end

data/lib/karafka/contracts/consumer_group_topic.rb

@@ -2,17 +2,40 @@
 
 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?)
+    # Consumer group topic validation rules.
+    class ConsumerGroupTopic < Base
+      configure do |config|
+        config.error_messages = YAML.safe_load(
+          File.read(
+            File.join(Karafka.gem_root, 'config', 'errors.yml')
+          )
+        ).fetch('en').fetch('validations').fetch('consumer_group_topic')
+      end
+
+      required(:consumer) { |consumer_group| !consumer_group.nil? }
+      required(:deserializer) { |deserializer| !deserializer.nil? }
+      required(:id) { |id| id.is_a?(String) && Contracts::TOPIC_REGEXP.match?(id) }
+      required(:kafka) { |kafka| kafka.is_a?(Hash) && !kafka.empty? }
+      required(:max_messages) { |mm| mm.is_a?(Integer) && mm >= 1 }
+      required(:initial_offset) { |io| %w[earliest latest].include?(io) }
+      required(:max_wait_time) { |mwt| mwt.is_a?(Integer) && mwt >= 10 }
+      required(:manual_offset_management) { |mmm| [true, false].include?(mmm) }
+      required(:name) { |name| name.is_a?(String) && Contracts::TOPIC_REGEXP.match?(name) }
+
+      virtual do |data, errors|
+        next unless errors.empty?
+
+        value = data.fetch(:kafka)
+
+        begin
+          # This will trigger rdkafka validations that we catch and re-map the info and use dry
+          # compatible format
+          Rdkafka::Config.new(value).send(:native_config)
+
+          nil
+        rescue Rdkafka::Config::ConfigError => e
+          [[%w[kafka], e.message]]
+        end
       end
     end
   end

data/lib/karafka/contracts/server_cli_options.rb

@@ -2,29 +2,30 @@
 
 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?)
+    # Contract for validating correctness of the server cli command options.
+    class ServerCliOptions < Base
+      configure do |config|
+        config.error_messages = YAML.safe_load(
+          File.read(
+            File.join(Karafka.gem_root, 'config', 'errors.yml')
+          )
+        ).fetch('en').fetch('validations').fetch('server_cli_options')
       end
 
-      rule(:pid) do
-        key(:pid).failure(:pid_already_exists) if value && File.exist?(value)
-      end
+      optional(:consumer_groups) { |cg| cg.is_a?(Array) && !cg.empty? }
+
+      virtual do |data, errors|
+        next unless errors.empty?
+        next unless data.key?(:consumer_groups)
+
+        value = data.fetch(:consumer_groups)
 
-      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
+        next if value.nil?
+        next if (value - Karafka::App.config.internal.routing.builder.map(&:name)).empty?
+
+        [[%i[consumer_groups], :consumer_groups_inclusion]]
       end
     end
   end

data/lib/karafka/contracts.rb

@@ -5,6 +5,6 @@ module Karafka
   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
+    TOPIC_REGEXP = /\A(\w|-|\.)+\z/
   end
 end

data/lib/karafka/env.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Karafka
+  # Env management class to get and set environment for Karafka
+  class Env < String
+    # Keys where we look for environment details for Karafka
+    LOOKUP_ENV_KEYS = %w[
+      KARAFKA_ENV
+      RACK_ENV
+      RAILS_ENV
+    ].freeze
+
+    # Default fallback env
+    DEFAULT_ENV = 'development'
+
+    private_constant :LOOKUP_ENV_KEYS, :DEFAULT_ENV
+
+    # @return [Karafka::Env] env object
+    # @note Will load appropriate environment automatically
+    def initialize
+      super('')
+
+      LOOKUP_ENV_KEYS
+        .map { |key| ENV[key] }
+        .compact
+        .first
+        .then { |env| env || DEFAULT_ENV }
+        .then { |env| replace(env) }
+    end
+
+    # @param method_name [String] method name
+    # @param include_private [Boolean] should we include private methods as well
+    # @return [Boolean] true if we respond to a given missing method, otherwise false
+    def respond_to_missing?(method_name, include_private = false)
+      (method_name[-1] == '?') || super
+    end
+
+    # Reacts to missing methods, from which some might be the env checks.
+    # If the method ends with '?' we assume, that it is an env check
+    # @param method_name [String] method name for missing or env name with question mark
+    # @param arguments [Array] any arguments that we pass to the method
+    def method_missing(method_name, *arguments)
+      method_name[-1] == '?' ? self == method_name[0..-2] : super
+    end
+  end
+end

data/lib/karafka/errors.rb

@@ -6,12 +6,6 @@ module Karafka
     # Base class for all the Karafka internal errors
     BaseError = Class.new(StandardError)
 
-    # 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 consumer
@@ -24,28 +18,34 @@ module Karafka
     # @see https://github.com/karafka/karafka/issues/135
     NonMatchingRouteError = Class.new(BaseError)
 
-    # Raised when we don't use or use responder not in the way it expected to based on the
-    # topics usage definitions
-    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 want to hook up to an event that is not registered and supported
-    UnregisteredMonitorEventError = Class.new(BaseError)
-
     # Raised when we've waited enough for shutting down a non-responsive process
     ForcefulShutdownError = Class.new(BaseError)
+
+    # Raised when the jobs queue receives a job that should not be received as it would cause
+    # the processing to go out of sync. We should never process in parallel data from the same
+    # topic partition (unless virtual partitions apply)
+    JobsQueueSynchronizationError = Class.new(BaseError)
+
+    # Raised when given topic is not found while expected
+    TopicNotFoundError = Class.new(BaseError)
+
+    # This should never happen. Please open an issue if it does.
+    UnsupportedCaseError = Class.new(BaseError)
+
+    # Raised when the license token is not valid
+    InvalidLicenseTokenError = Class.new(BaseError)
+
+    # Used to instrument this error into the error notifications
+    # We do not raise it so we won't crash deployed systems
+    ExpiredLicenseTokenError = Class.new(BaseError)
+
+    # This should never happen. Please open an issue if it does.
+    InvalidCoordinatorState = Class.new(BaseError)
   end
 end

data/lib/karafka/helpers/async.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Karafka
+  module Helpers
+    # Allows a given class to run async in a separate thread. Provides also few methods we may
+    # want to use to control the underlying thread
+    #
+    # @note Thread running code needs to manage it's own exceptions. If they leak out, they will
+    #   abort thread on exception.
+    module Async
+      class << self
+        # Adds forwardable to redirect thread-based control methods to the underlying thread that
+        # runs the async operations
+        #
+        # @param base [Class] class we're including this module in
+        def included(base)
+          base.extend ::Forwardable
+
+          base.def_delegators :@thread, :join, :terminate, :alive?
+        end
+      end
+
+      # Runs the `#call` method in a new thread
+      def async_call
+        @thread = Thread.new do
+          Thread.current.abort_on_exception = true
+
+          call
+        end
+      end
+    end
+  end
+end

data/lib/karafka/helpers/colorize.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Karafka
+  module Helpers
+    # Simple wrapper for adding colors to strings
+    module Colorize
+      # @param string [String] string we want to have in green
+      # @return [String] green string
+      def green(string)
+        "\033[0;32m#{string}\033[0m"
+      end
+
+      # @param string [String] string we want to have in red
+      # @return [String] red string
+      def red(string)
+        "\033[0;31m#{string}\033[0m"
+      end
+    end
+  end
+end

data/lib/karafka/helpers/multi_delegator.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 module Karafka
-  # Module containing classes and methods that provide some additional functionalities
+  # Module containing classes and methods that provide some additional helper functionalities.
   module Helpers
     # @note Taken from http://stackoverflow.com/questions/6407141
-    # Multidelegator is used to delegate calls to multiple targets
+    # Multidelegator is used to delegate calls to multiple targets.
     class MultiDelegator
       # @param targets to which we want to delegate methods
       def initialize(*targets)

data/lib/karafka/instrumentation/callbacks/error.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Karafka
+  module Instrumentation
+    # Callbacks used to transport things from rdkafka
+    module Callbacks
+      # Callback that kicks in when consumer error occurs and is published in a background thread
+      class Error
+        # @param subscription_group_id [String] id of the current subscription group instance
+        # @param consumer_group_id [String] id of the current consumer group
+        # @param client_name [String] rdkafka client name
+        # @param monitor [WaterDrop::Instrumentation::Monitor] monitor we are using
+        def initialize(subscription_group_id, consumer_group_id, client_name, monitor)
+          @subscription_group_id = subscription_group_id
+          @consumer_group_id = consumer_group_id
+          @client_name = client_name
+          @monitor = monitor
+        end
+
+        # Runs the instrumentation monitor with error
+        # @param client_name [String] rdkafka client name
+        # @param error [Rdkafka::Error] error that occurred
+        # @note It will only instrument on errors of the client of our consumer
+        def call(client_name, error)
+          # Emit only errors related to our client
+          # Same as with statistics (mor explanation there)
+          return unless @client_name == client_name
+
+          @monitor.instrument(
+            'error.occurred',
+            subscription_group_id: @subscription_group_id,
+            consumer_group_id: @consumer_group_id,
+            type: 'librdkafka.error',
+            error: error
+          )
+        end
+      end
+    end
+  end
+end