karafka 1.4.10 → 2.0.0.alpha2

data/lib/karafka/connection/messages_buffer.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Karafka
+  module Connection
+    # Buffer for messages.
+    # When message is added to this buffer, it gets assigned to an array with other messages from
+    # the same topic and partition.
+    #
+    # @note This buffer is NOT threadsafe.
+    class MessagesBuffer
+      attr_reader :size
+
+      # @return [Karafka::Connection::MessagesBuffer] buffer instance
+      def initialize
+        @size = 0
+        @groups = Hash.new do |topic_groups, topic|
+          topic_groups[topic] = Hash.new do |partition_groups, partition|
+            partition_groups[partition] = []
+          end
+        end
+      end
+
+      # Iterates over aggregated data providing messages per topic partition.
+      #
+      # @yieldparam [String] topic name
+      # @yieldparam [Integer] partition number
+      # @yieldparam [Array<Rdkafka::Consumer::Message>] topic partition aggregated results
+      def each
+        @groups.each do |topic, partitions|
+          partitions.each do |partition, messages|
+            yield(topic, partition, messages)
+          end
+        end
+      end
+
+      # Adds a message to the buffer.
+      #
+      # @param message [Rdkafka::Consumer::Message] raw rdkafka message
+      # @return [Array<Rdkafka::Consumer::Message>] given partition topic sub-buffer array
+      def <<(message)
+        @size += 1
+        @groups[message.topic][message.partition] << message
+      end
+
+      # Removes all the data from the buffer.
+      #
+      # @note We do not clear the whole groups hash but rather we clear the partition hashes, so
+      #   we save ourselves some objects allocations. We cannot clear the underlying arrays as they
+      #   may be used in other threads for data processing, thus if we would clear it, we could
+      #   potentially clear a raw messages array for a job that is in the jobs queue.
+      def clear
+        @size = 0
+        @groups.each_value(&:clear)
+      end
+    end
+  end
+end

data/lib/karafka/connection/pauses_manager.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Karafka
+  module Connection
+    # Partitions pauses management abstraction layer.
+    # It aggregates all the pauses for all the partitions that we're working with.
+    class PausesManager
+      # @return [Karafka::Connection::PausesManager] pauses manager
+      def initialize
+        @pauses = Hash.new do |h, k|
+          h[k] = {}
+        end
+      end
+
+      # Creates or fetches pause of a given topic partition.
+      #
+      # @param topic [String] topic name
+      # @param partition [Integer] partition number
+      # @return [Karafka::TimeTrackers::Pause] pause instance
+      def fetch(topic, partition)
+        @pauses[topic][partition] ||= TimeTrackers::Pause.new(
+          timeout: Karafka::App.config.pause_timeout,
+          max_timeout: Karafka::App.config.pause_max_timeout,
+          exponential_backoff: Karafka::App.config.pause_with_exponential_backoff
+        )
+      end
+
+      # Resumes processing of partitions for which pause time has ended.
+      #
+      # @yieldparam [String] topic name
+      # @yieldparam [Integer] partition number
+      def resume
+        @pauses.each do |topic, partitions|
+          partitions.each do |partition, pause|
+            next unless pause.paused?
+            next unless pause.expired?
+
+            pause.resume
+
+            yield(topic, partition)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/karafka/connection/rebalance_manager.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Karafka
+  module Connection
+    # Manager for tracking changes in the partitions assignment.
+    #
+    # We need tracking of those to clean up consumers that will no longer process given partitions
+    # as they were taken away.
+    #
+    # @note Since this does not happen really often, we try to stick with same objects for the
+    #   empty states most of the time, so we don't create many objects during the manager life
+    class RebalanceManager
+      # @return [RebalanceManager]
+      def initialize
+        @assigned = {}
+        @revoked = {}
+      end
+
+      # @return [Hash<String, Array<Integer>>] hash where the keys are the names of topics for
+      #   which we've got new partitions assigned and array with ids of the partitions as the value
+      # @note Once assigned partitions are fetched, the state will be reset since the callbacks
+      #   for new assigned partitions are set only during a state change
+      def assigned_partitions
+        return @assigned if @assigned.empty?
+
+        result = @assigned.dup
+        @assigned.clear
+        result
+      end
+
+      # @return [Hash<String, Array<Integer>>] hash where the keys are the names of topics for
+      #   which we've lost partitions and array with ids of the partitions as the value
+      # @note Once revoked partitions are fetched, the state will be reset since the callbacks
+      #   for new revoked partitions are set only during a state change
+      def revoked_partitions
+        return @revoked if @revoked.empty?
+
+        result = @revoked.dup
+        @revoked.clear
+        result
+      end
+
+      # Callback that kicks in inside of rdkafka, when new partitions are assigned.
+      #
+      # @private
+      # @param _ [Rdkafka::Consumer]
+      # @param partitions [Rdkafka::Consumer::TopicPartitionList]
+      def on_partitions_assigned(_, partitions)
+        @assigned = partitions.to_h.transform_values { |part| part.map(&:partition) }
+      end
+
+      # Callback that kicks in inside of rdkafka, when partitions are revoked.
+      #
+      # @private
+      # @param _ [Rdkafka::Consumer]
+      # @param partitions [Rdkafka::Consumer::TopicPartitionList]
+      def on_partitions_revoked(_, partitions)
+        @revoked = partitions.to_h.transform_values { |part| part.map(&:partition) }
+      end
+    end
+  end
+end

data/lib/karafka/contracts/base.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Karafka
+  module Contracts
+    # Base contract for all Karafka contracts
+    class Base < Dry::Validation::Contract
+      config.messages.load_paths << File.join(Karafka.gem_root, 'config', 'errors.yml')
+
+      # @param data [Hash] data for validation
+      # @return [Boolean] true if all good
+      # @raise [Errors::InvalidConfigurationError] invalid configuration error
+      # @note We use contracts only in the config validation context, so no need to add support
+      #   for multiple error classes. It will be added when it will be needed.
+      def validate!(data)
+        result = call(data)
+
+        return true if result.success?
+
+        raise Errors::InvalidConfigurationError, result.errors.to_h
+      end
+    end
+  end
+end

data/lib/karafka/contracts/config.rb

@@ -2,19 +2,55 @@
 
 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
+    #   so we validate all of that once all the routes are defined and ready.
+    class Config < Base
       params do
+        # License validity happens in the licenser. Here we do only the simple consistency checks
+        required(:license).schema do
+          required(:token) { bool? | str? }
+          required(:entity) { str? }
+          required(:expires_on) { date? }
+        end
+
         required(:client_id).filled(:str?, format?: Karafka::Contracts::TOPIC_REGEXP)
-        required(:shutdown_timeout) { (int? & gt?(0)) }
-        required(:consumer_mapper)
-        required(:topic_mapper)
+        required(:concurrency) { int? & gt?(0) }
+        required(:consumer_mapper).filled
+        required(:consumer_persistence).filled(:bool?)
+        required(:pause_timeout) { int? & gt?(0) }
+        required(:pause_max_timeout) { int? & gt?(0) }
+        required(:pause_with_exponential_backoff).filled(:bool?)
+        required(:shutdown_timeout) { int? & gt?(0) }
+        required(:kafka).filled(:hash)
+
+        # We validate internals just to be sure, that they are present and working
+        required(:internal).schema do
+          required(:routing_builder)
+          required(:status)
+          required(:process)
+          required(:subscription_groups_builder)
+        end
+      end
+
+      # rdkafka requires all the keys to be strings, so we ensure that
+      rule(:kafka) do
+        next unless value.is_a?(Hash)
+
+        value.each_key do |key|
+          next if key.is_a?(Symbol)
+
+          key(:"kafka.#{key}").failure(:kafka_key_must_be_a_symbol)
+        end
+      end
 
-        optional(:backend).filled
+      rule(:pause_timeout, :pause_max_timeout) do
+        if values[:pause_timeout].to_i > values[:pause_max_timeout].to_i
+          key(:pause_timeout).failure(:max_timeout_vs_pause_max_timeout)
+        end
       end
     end
   end

data/lib/karafka/contracts/consumer_group.rb

@@ -3,17 +3,7 @@
 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
-
+    class ConsumerGroup < Base
       # Internal contract for sub-validating topics schema
       TOPIC_CONTRACT = ConsumerGroupTopic.new.freeze
 
@@ -22,58 +12,6 @@ module Karafka
       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
@@ -93,119 +31,6 @@ module Karafka
           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

@@ -2,17 +2,25 @@
 
 module Karafka
   module Contracts
-    # Consumer group topic validation rules
-    class ConsumerGroupTopic < Dry::Validation::Contract
+    # Consumer group topic validation rules.
+    class ConsumerGroupTopic < Base
       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?)
+        required(:id).filled(:str?, format?: Karafka::Contracts::TOPIC_REGEXP)
+        required(:kafka).filled
+        required(:max_messages) { int? & gteq?(1) }
+        required(:max_wait_time).filled { int? & gteq?(10) }
+        required(:manual_offset_management).filled(:bool?)
+        required(:name).filled(:str?, format?: Karafka::Contracts::TOPIC_REGEXP)
+      end
+
+      rule(:kafka) do
+        # 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)
+      rescue Rdkafka::Config::ConfigError => e
+        key(:kafka).failure(e.message)
       end
     end
   end

data/lib/karafka/contracts/server_cli_options.rb

@@ -2,22 +2,12 @@
 
 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')
-
+    # Contract for validating correctness of the server cli command options.
+    class ServerCliOptions < Base
       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

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)
   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