karafka 2.4.6 → 2.4.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e550fa0b7395eab3b961181319d195809baeca82c02935d2735cf98353f6ef8b
-  data.tar.gz: f734562bfb86db59a64f4fbeb596bfe126eacd428a4ade00da90d238d959ab64
+  metadata.gz: c7e8e51a5c0c4ded0d074965cee2090e64ca77e43443f4f36ab03cc3a21ddfd6
+  data.tar.gz: c6e912c518d301f55974a9e4deb491ebe4c3e073e6748fe62ce1003eaea7bed7
 SHA512:
-  metadata.gz: f80b521d063653c93caee987358573c992af2488ffec9c6465dbb04f9e51e8334548cf669b2b5f8f5783540be01fa8b52e067042cf72afda35f14181148ec87d
-  data.tar.gz: 32fd0f08102a2687f4b646d15cd07599f9aaefac957f828396af1f2d91bc91d5c922119bfec04d94cba63af86724d43cb50852de140d78e289fdbb612892dc78
+  metadata.gz: 8769a192c7ebb852250afd96611e115807172bf320d4e9d513bffbcc66f5570ca637aee1b8f3b68e46350b37054935ea905893139bc264a02949f975b39f2041
+  data.tar.gz: 13dc8e118850aace7127bae5fe667b6f73118d220b61b1d2b590cc18e71243b3c1467d43df9ae134cd7b26c0274a100e34d8a07db0c6091bc02fd9c95ffb24f0

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Karafka Framework Changelog
 
+## 2.4.8 (2024-08-09)
+- **[Feature]** Introduce ability to react to `#eof` either from `#consume` or from `#eofed` when EOF without new messages.
+- [Enhancement] Provide `Consumer#eofed?` to indicate reaching EOF.
+- [Enhancement] Always immediately report on `inconsistent_group_protocol` error.
+- [Enhancement] Reduce virtual partitioning to 1 partition when any partitioner execution in a partitioned batch crashes.
+- [Enhancement] Provide `KARAFKA_REQUIRE_RAILS` to disable default Rails `require` to run Karafka without Rails despite having Rails in the Gemfile.
+- [Enhancement] Increase final listener recovery from 1 to 60 seconds to prevent constant rebalancing. This is the last resort recovery and should never happen unless critical errors occur.
+
+## 2.4.7 (2024-08-01)
+- [Enhancement] Introduce `Karafka::Server.execution_mode` to check in what mode Karafka process operates (`standalone`, `swarm`, `supervisor`, `embedded`).
+- [Enhancement] Ensure `max.poll.interval.ms` is always present and populate it with librdkafka default.
+- [Enhancement] Introduce a shutdown time limit for unsubscription wait.
+- [Enhancement] Tag with `mode:swarm` each of the running swarm consumers.
+- [Change] Tag with `mode:embedded` instead of `embedded` the embedded consumers.
+- [Fix] License identifier `LGPL-3.0` is deprecated for SPDX (#2177).
+- [Fix] Fix an issue where custom clusters would not have default settings populated same as the primary cluster.
+- [Fix] Fix Rspec warnings of nil mocks.
+- [Maintenance] Cover `cooperative-sticky` librdkafka issues with integration spec.
+
 ## 2.4.6 (2024-07-22)
 - [Fix] Mitigate `rd_kafka_cgrp_terminated` and other `librdkafka` shutdown issues by unsubscribing fully prior to shutdown.
 

data/Gemfile

@@ -12,7 +12,7 @@ gemspec
 group :integrations do
   gem 'activejob', require: false
   gem 'karafka-testing', '>= 2.4.0', require: false
-  gem 'karafka-web', '>= 0.9.0', require: false
+  gem 'karafka-web', '>= 0.10.0.beta1', require: false
   gem 'rspec', require: false
 end
 

data/Gemfile.lock

@@ -1,9 +1,10 @@
 PATH
   remote: .
   specs:
-    karafka (2.4.6)
+    karafka (2.4.8)
       base64 (~> 0.2)
       karafka-core (>= 2.4.3, < 2.5.0)
+      karafka-rdkafka (>= 0.17.2)
       waterdrop (>= 2.7.3, < 3.0.0)
       zeitwerk (~> 2.3)
 
@@ -29,7 +30,7 @@ GEM
     concurrent-ruby (1.3.3)
     connection_pool (2.4.1)
     diff-lcs (1.5.1)
-    docile (1.4.0)
+    docile (1.4.1)
     drb (2.2.1)
     erubi (1.13.0)
     factory_bot (6.4.6)
@@ -41,26 +42,26 @@ GEM
       concurrent-ruby (~> 1.0)
     karafka-core (2.4.4)
       karafka-rdkafka (>= 0.15.0, < 0.18.0)
-    karafka-rdkafka (0.17.0)
+    karafka-rdkafka (0.17.3)
       ffi (~> 1.15)
       mini_portile2 (~> 2.6)
       rake (> 12)
-    karafka-testing (2.4.5)
+    karafka-testing (2.4.6)
       karafka (>= 2.4.0, < 2.5.0)
       waterdrop (>= 2.7.0)
-    karafka-web (0.9.1)
+    karafka-web (0.10.0.rc1)
       erubi (~> 1.4)
-      karafka (>= 2.4.0, < 2.5.0)
+      karafka (>= 2.4.7, < 2.5.0)
       karafka-core (>= 2.4.0, < 2.5.0)
       roda (~> 3.68, >= 3.69)
       tilt (~> 2.0)
     mini_portile2 (2.8.7)
-    minitest (5.24.0)
+    minitest (5.24.1)
     mutex_m (0.2.0)
     ostruct (0.6.0)
-    rack (3.1.5)
+    rack (3.1.7)
     rake (13.2.1)
-    roda (3.81.0)
+    roda (3.82.0)
       rack
     rspec (3.13.0)
       rspec-core (~> 3.13.0)
@@ -88,7 +89,7 @@ GEM
       karafka-core (>= 2.4.3, < 3.0.0)
       karafka-rdkafka (>= 0.15.1)
       zeitwerk (~> 2.3)
-    zeitwerk (2.6.16)
+    zeitwerk (2.6.17)
 
 PLATFORMS
   ruby
@@ -100,7 +101,7 @@ DEPENDENCIES
   factory_bot
   karafka!
   karafka-testing (>= 2.4.0)
-  karafka-web (>= 0.9.0)
+  karafka-web (>= 0.10.0.beta1)
   ostruct
   rspec
   simplecov

data/LICENSE

@@ -1,7 +1,7 @@
 Copyright (c) Maciej Mensfeld
 
 Karafka is an Open Source project licensed under the terms of
-the LGPLv3 license. Please see <https://github.com/karafka/karafka/blob/master/LGPL>
+the LGPLv3 license. Please see <https://github.com/karafka/karafka/blob/master/LICENSE-LGPL>
 for license text.
 
 Karafka has also commercial-friendly license, commercial support and commercial components.

data/config/locales/errors.yml

@@ -49,6 +49,7 @@ en:
 
       internal.connection.manager_format: needs to be present
       internal.connection.conductor_format: needs to be present
+      internal.connection.reset_backoff_format: needs to be an integer bigger or equal to 1000
       internal.connection.proxy.query_watermark_offsets.timeout_format: needs to be an integer bigger than 0
       internal.connection.proxy.query_watermark_offsets.max_attempts_format: needs to be an integer bigger than 0
       internal.connection.proxy.query_watermark_offsets.wait_time_format: needs to be an integer bigger than 0
@@ -115,6 +116,8 @@ en:
 
       active_format: needs to be either true or false
 
+      eofed.active_format: needs to be either true or false
+
       declaratives.partitions_format: needs to be more or equal to 1
       declaratives.active_format: needs to be true
       declaratives.replication_factor_format: needs to be more or equal to 1

data/docker-compose.yml

@@ -3,7 +3,7 @@ version: '2'
 services:
   kafka:
     container_name: kafka
-    image: confluentinc/cp-kafka:7.6.2
+    image: confluentinc/cp-kafka:7.7.0
 
     ports:
       - 9092:9092

data/karafka.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
   spec.authors     = ['Maciej Mensfeld']
   spec.email       = %w[contact@karafka.io]
   spec.homepage    = 'https://karafka.io'
-  spec.licenses    = %w[LGPL-3.0 Commercial]
+  spec.licenses    = %w[LGPL-3.0-only Commercial]
   spec.summary     = 'Karafka is Ruby and Rails efficient Kafka processing framework.'
   spec.description = <<-DESC
     Karafka is Ruby and Rails efficient Kafka processing framework.
@@ -23,6 +23,7 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'base64', '~> 0.2'
   spec.add_dependency 'karafka-core', '>= 2.4.3', '< 2.5.0'
+  spec.add_dependency 'karafka-rdkafka', '>= 0.17.2'
   spec.add_dependency 'waterdrop', '>= 2.7.3', '< 3.0.0'
   spec.add_dependency 'zeitwerk', '~> 2.3'
 

data/lib/karafka/base_consumer.rb

@@ -9,7 +9,7 @@ module Karafka
 
     extend Forwardable
 
-    def_delegators :@coordinator, :topic, :partition
+    def_delegators :@coordinator, :topic, :partition, :eofed?
 
     def_delegators :producer, :produce_async, :produce_sync, :produce_many_async,
                    :produce_many_sync
@@ -100,6 +100,24 @@ module Karafka
       retry_after_pause
     end
 
+    # Can be used to run code prior to scheduling of eofed execution
+    def on_before_schedule_eofed
+      handle_before_schedule_eofed
+    end
+
+    # Trigger method for running on eof without messages
+    def on_eofed
+      handle_eofed
+    rescue StandardError => e
+      Karafka.monitor.instrument(
+        'error.occurred',
+        error: e,
+        caller: self,
+        seek_offset: coordinator.seek_offset,
+        type: 'consumer.eofed.error'
+      )
+    end
+
     # Can be used to run code prior to scheduling of idle execution
     #
     # @private
@@ -166,6 +184,10 @@ module Karafka
       raise NotImplementedError, 'Implement this in a subclass'
     end
 
+    # Method that will be executed when a given topic partition reaches eof without any new
+    # incoming messages alongside
+    def eofed; end
+
     # Method that will be executed when a given topic partition is revoked. You can use it for
     # some teardown procedures (closing file handler, etc).
     def revoked; end

data/lib/karafka/cli/server.rb

@@ -89,6 +89,7 @@ module Karafka
         register_inclusions
         register_exclusions
 
+        Karafka::Server.execution_mode = :standalone
         Karafka::Server.run
       end
 

data/lib/karafka/cli/swarm.rb

@@ -23,6 +23,7 @@ module Karafka
         server.register_inclusions
         server.register_exclusions
 
+        Karafka::Server.execution_mode = :supervisor
         Karafka::Swarm::Supervisor.new.run
       end
     end

data/lib/karafka/connection/client.rb

@@ -8,6 +8,8 @@ module Karafka
     # It is threadsafe and provides some security measures so we won't end up operating on a
     # closed consumer instance as it causes Ruby VM process to crash.
     class Client
+      include ::Karafka::Core::Helpers::Time
+
       attr_reader :rebalance_manager
 
       # @return [Karafka::Routing::SubscriptionGroup] subscription group to which this client
@@ -24,7 +26,26 @@ module Karafka
       # How many times should we retry polling in case of a failure
       MAX_POLL_RETRIES = 20
 
-      private_constant :MAX_POLL_RETRIES
+      # How much time of the total shutdown time can we wait for our manual unsubscribe before
+      # attempting to close without unsubscribe. We try to wait for 50% of the shutdown time
+      # before we move to a regular unsubscribe.
+      COOP_UNSUBSCRIBE_FACTOR = 0.5
+
+      # Errors upon which we early report that something is off without retrying prior to the
+      # report
+      EARLY_REPORT_ERRORS = [
+        :inconsistent_group_protocol, # 23
+        :max_poll_exceeded, # -147
+        :network_exception, # 13
+        :transport, # -195
+        :topic_authorization_failed, # 29
+        :group_authorization_failed, # 30
+        :cluster_authorization_failed, # 31
+        # This can happen for many reasons, including issues with static membership being fenced
+        :fatal # -150
+      ].freeze
+
+      private_constant :MAX_POLL_RETRIES, :COOP_UNSUBSCRIBE_FACTOR, :EARLY_REPORT_ERRORS
 
       # Creates a new consumer instance.
       #
@@ -91,8 +112,17 @@ module Karafka
           # Fetch message within our time boundaries
           response = poll(time_poll.remaining)
 
-          # Put a message to the buffer if there is one
-          @buffer << response if response && response != :tick_time
+          case response
+          when :tick_time
+            nil
+          # We get a hash only in case of eof error
+          when Hash
+            @buffer.eof(response[:topic], response[:partition])
+          when nil
+            nil
+          else
+            @buffer << response
+          end
 
           # Upon polling rebalance manager might have been updated.
           # If partition revocation happens, we need to remove messages from revoked partitions
@@ -115,10 +145,11 @@ module Karafka
           time_poll.checkpoint
 
           # Finally once we've (potentially) removed revoked, etc, if no messages were returned
-          # and it was not an early poll exist, we can break.
+          # and it was not an early poll exist, we can break. We also break if we got the eof
+          # signaling to propagate it asap
           # Worth keeping in mind, that the rebalance manager might have been updated despite no
           # messages being returned during a poll
-          break unless response
+          break if response.nil? || response.is_a?(Hash)
         end
 
         @buffer
@@ -261,14 +292,32 @@ module Karafka
         # an issue that gets back every few versions of librdkafka in a limited scope, for example
         # for cooperative-sticky or in a general scope. This is why we unsubscribe and wait until
         # we no longer have any assignments. That way librdkafka consumer shutdown should never
-        # happen with rebalance associated with the given consumer instance
+        # happen with rebalance associated with the given consumer instance. Since we do not want
+        # to wait forever, we also impose a limit on how long should we wait. This prioritizes
+        # shutdown stability over endless wait.
+        #
+        # The `@unsubscribing` ensures that when there would be a direct close attempt, it
+        # won't get into this loop again. This can happen when supervision decides it should close
+        # things faster
         #
         # @see https://github.com/confluentinc/librdkafka/issues/4792
         # @see https://github.com/confluentinc/librdkafka/issues/4527
         if unsubscribe?
+          @unsubscribing = true
+
+          # Give 50% of time for the final close before we reach the forceful
+          max_wait = ::Karafka::App.config.shutdown_timeout * COOP_UNSUBSCRIBE_FACTOR
+          used = 0
+          stopped_at = monotonic_now
+
           unsubscribe
 
           until assignment.empty?
+            used += monotonic_now - stopped_at
+            stopped_at = monotonic_now
+
+            break if used >= max_wait
+
             sleep(0.1)
 
             ping
@@ -551,20 +600,7 @@ module Karafka
         # We want to report early on max poll interval exceeding because it may mean that the
         # underlying processing is taking too much time and it is not LRJ
         case e.code
-        when :max_poll_exceeded # -147
-          early_report = true
-        when :network_exception # 13
-          early_report = true
-        when :transport # -195
-          early_report = true
-        when :topic_authorization_failed # 29
-          early_report = true
-        when :group_authorization_failed # 30
-          early_report = true
-        when :cluster_authorization_failed # 31
-          early_report = true
-        # This can happen for many reasons, including issues with static membership being fenced
-        when :fatal # -150
+        when *EARLY_REPORT_ERRORS
           early_report = true
         # @see
         # https://github.com/confluentinc/confluent-kafka-dotnet/issues/1366#issuecomment-821842990
@@ -578,11 +614,12 @@ module Karafka
           # No sense in retrying when no topic/partition and we're no longer running
           retryable = false unless Karafka::App.running?
         # If we detect the end of partition which can happen if `enable.partition.eof` is set to
-        # true, we can just return nil fast. This will fast yield whatever set of messages we
+        # true, we can just return fast. This will fast yield whatever set of messages we
         # already have instead of waiting. This can be used for better latency control when we do
         # not expect a lof of lag and want to quickly move to processing.
+        # We can also pass the eof notion to the consumers for improved decision making.
         when :partition_eof
-          return nil
+          return e.details
         end
 
         if early_report || !retryable
@@ -709,6 +746,7 @@ module Karafka
       #
       # @return [Boolean] should we unsubscribe prior to shutdown
       def unsubscribe?
+        return false if @unsubscribing
         return false if @subscription_group.kafka.key?(:'group.instance.id')
         return false if @mode != :subscribe
         return false if assignment.empty?

data/lib/karafka/connection/listener.rb

@@ -253,7 +253,9 @@ module Karafka
 
         reset
 
-        sleep(1) && retry
+        # Ruby sleep is in seconds
+        sleep_time = ::Karafka::App.config.internal.connection.reset_backoff / 10_000.0
+        sleep(sleep_time) && retry
       end
 
       # Resumes processing of partitions that were paused due to an error.
@@ -330,28 +332,57 @@ module Karafka
       # given scheduler. It also handles the idle jobs when filtering API removed all messages
       # and we need to run house-keeping
       def build_and_schedule_flow_jobs
-        return if @messages_buffer.empty?
-
         consume_jobs = []
         idle_jobs = []
+        eofed_jobs = []
+
+        @messages_buffer.each do |topic, partition, messages, eof|
+          # In case we did not receive any new messages without eof we skip.
+          # We may yield empty array here in case we have reached eof without new messages but in
+          # such cases, we can run an eof job
+          next if messages.empty? && !eof
 
-        @messages_buffer.each do |topic, partition, messages|
           coordinator = @coordinators.find_or_create(topic, partition)
-          # Start work coordination for this topic partition
+          coordinator.eofed = eof
+
+          # If we did not receive any messages and we did receive eof signal, we run the eofed
+          # jobs so user can take actions on reaching eof
+          if messages.empty? && eof
+            # If user wants to run the eofed jobs on eof we do it. Otherwise we just allow it to
+            # pass through. This allows to configure if user actually wants to have `#eofed`
+            # logic or if he wants to only use fast eof work yield
+            if coordinator.topic.eofed?
+              @executors.find_all_or_create(topic, partition, coordinator).each do |executor|
+                coordinator.increment(:eofed)
+                eofed_jobs << @jobs_builder.eofed(executor)
+              end
+            end
+
+            next
+          end
+
           coordinator.start(messages)
 
+          # If it is not an eof and there are no new messages, we just run house-keeping
+          #
           # We do not increment coordinator for idle job because it's not a user related one
           # and it will not go through a standard lifecycle. Same applies to revoked and shutdown
           if messages.empty?
+            # Start work coordination for this topic partition
             coordinator.increment(:idle)
             executor = @executors.find_or_create(topic, partition, 0, coordinator)
             idle_jobs << @jobs_builder.idle(executor)
-          else
-            @partitioner.call(topic, messages, coordinator) do |group_id, partition_messages|
-              coordinator.increment(:consume)
-              executor = @executors.find_or_create(topic, partition, group_id, coordinator)
-              consume_jobs << @jobs_builder.consume(executor, partition_messages)
-            end
+
+            next
+          end
+
+          # If there are messages, it is irrelevant if eof or not as consumption needs to happen
+          #
+          # Start work coordination for this topic partition
+          @partitioner.call(topic, messages, coordinator) do |group_id, partition_messages|
+            coordinator.increment(:consume)
+            executor = @executors.find_or_create(topic, partition, group_id, coordinator)
+            consume_jobs << @jobs_builder.consume(executor, partition_messages)
           end
         end
 
@@ -367,6 +398,11 @@ module Karafka
           consume_jobs.each(&:before_schedule)
           @scheduler.on_schedule_consumption(consume_jobs)
         end
+
+        unless eofed_jobs.empty?
+          eofed_jobs.each(&:before_schedule)
+          @scheduler.on_schedule_eofed(eofed_jobs)
+        end
       end
 
       # Builds and schedules periodic jobs for topics partitions for which no messages were

data/lib/karafka/connection/messages_buffer.rb

@@ -23,9 +23,13 @@ module Karafka
       def initialize(subscription_group)
         @subscription_group = subscription_group
         @size = 0
+
         @groups = Hash.new do |topic_groups, topic|
           topic_groups[topic] = Hash.new do |partition_groups, partition|
-            partition_groups[partition] = []
+            partition_groups[partition] = {
+              eof: false,
+              messages: []
+            }
           end
         end
       end
@@ -33,24 +37,29 @@ module Karafka
       # Remaps raw messages from the raw messages buffer to Karafka messages
       # @param raw_messages_buffer [RawMessagesBuffer] buffer with raw messages
       def remap(raw_messages_buffer)
-        clear unless @size.zero?
+        clear
 
         # Since it happens "right after" we've received the messages, it is close enough it time
         # to be used as the moment we received messages.
         received_at = Time.now
 
-        raw_messages_buffer.each do |topic, partition, messages|
+        raw_messages_buffer.each do |topic, partition, messages, eof|
           @size += messages.count
 
           ktopic = @subscription_group.topics.find(topic)
 
-          @groups[topic][partition] = messages.map do |message|
+          built_messages = messages.map do |message|
             Messages::Builders::Message.call(
               message,
               ktopic,
               received_at
             )
           end
+
+          @groups[topic][partition] = {
+            eof: eof,
+            messages: built_messages
+          }
         end
       end
 
@@ -59,10 +68,11 @@ module Karafka
       # @yieldparam [String] topic name
       # @yieldparam [Integer] partition number
       # @yieldparam [Array<Karafka::Messages::Message>] messages from a given topic partition
+      # @yieldparam [Boolean] true if eof, false otherwise
       def each
         @groups.each do |topic, partitions|
-          partitions.each do |partition, messages|
-            yield(topic, partition, messages)
+          partitions.each do |partition, details|
+            yield(topic, partition, details[:messages], details[:eof])
           end
         end
       end

data/lib/karafka/connection/raw_messages_buffer.rb

@@ -2,7 +2,7 @@
 
 module Karafka
   module Connection
-    # Buffer for raw librdkafka messages.
+    # Buffer for raw librdkafka messages and eof status.
     #
     # When message is added to this buffer, it gets assigned to an array with other messages from
     # the same topic and partition.
@@ -17,9 +17,13 @@ module Karafka
       # @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] = []
+            partition_groups[partition] = {
+              eof: false,
+              messages: []
+            }
           end
         end
       end
@@ -30,7 +34,16 @@ module Karafka
       # @return [Array<Rdkafka::Consumer::Message>] given partition topic sub-buffer array
       def <<(message)
         @size += 1
-        @groups[message.topic][message.partition] << message
+        partition_state = @groups[message.topic][message.partition]
+        partition_state[:messages] << message
+        partition_state[:eof] = false
+      end
+
+      # Marks given topic partition as one that reached eof
+      # @param topic [String] topic that reached eof
+      # @param partition [Integer] partition that reached eof
+      def eof(topic, partition)
+        @groups[topic][partition][:eof] = true
       end
 
       # Allows to iterate over all the topics and partitions messages
@@ -38,10 +51,11 @@ module Karafka
       # @yieldparam [String] topic name
       # @yieldparam [Integer] partition number
       # @yieldparam [Array<Rdkafka::Consumer::Message>] topic partition aggregated results
+      # @yieldparam [Boolean] has polling of this partition reach eof
       def each
         @groups.each do |topic, partitions|
-          partitions.each do |partition, messages|
-            yield(topic, partition, messages)
+          partitions.each do |partition, details|
+            yield(topic, partition, details[:messages], details[:eof])
           end
         end
       end
@@ -69,8 +83,8 @@ module Karafka
       # again and we do want to ensure as few duplications as possible
       def uniq!
         @groups.each_value do |partitions|
-          partitions.each_value do |messages|
-            messages.uniq!(&:offset)
+          partitions.each_value do |details|
+            details[:messages].uniq!(&:offset)
           end
         end
 
@@ -83,6 +97,11 @@ module Karafka
       #   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.
+      #
+      # @note We do not clear the eof assignments because they can span across batch pollings.
+      #   Since eof is not raised non-stop and is silenced after an eof poll, if we would clean it
+      #   here we would loose the notion of it. The reset state for it should happen when we do
+      #   discover new messages for given topic partition.
       def clear
         @size = 0
         @groups.each_value(&:clear)
@@ -92,8 +111,12 @@ module Karafka
 
       # Updates the messages count if we performed any operations that could change the state
       def recount!
-        @size = @groups.each_value.sum do |partitions|
-          partitions.each_value.map(&:count).sum
+        @size = 0
+
+        @groups.each_value do |partitions|
+          partitions.each_value do |details|
+            @size += details[:messages].size
+          end
         end
       end
     end

data/lib/karafka/contracts/config.rb

@@ -79,6 +79,7 @@ module Karafka
         nested(:connection) do
           required(:manager) { |val| !val.nil? }
           required(:conductor) { |val| !val.nil? }
+          required(:reset_backoff) { |val| val.is_a?(Integer) && val >= 1_000 }
 
           nested(:proxy) do
             nested(:commit) do

data/lib/karafka/embedded.rb

@@ -27,7 +27,8 @@ module Karafka
         Thread.new do
           Thread.current.name = 'karafka.embedded'
 
-          Karafka::Process.tags.add(:execution_mode, 'embedded')
+          Karafka::Process.tags.add(:execution_mode, 'mode:embedded')
+          Karafka::Server.execution_mode = :embedded
           Karafka::Server.start
         end
       end

data/lib/karafka/instrumentation/logger_listener.rb

@@ -290,6 +290,9 @@ module Karafka
         when 'consumer.tick.error'
           error "Consumer on tick failed due to an error: #{error}"
           error details
+        when 'consumer.eofed.error'
+          error "Consumer on eofed failed due to an error: #{error}"
+          error details
         when 'consumer.after_consume.error'
           error "Consumer on after_consume failed due to an error: #{error}"
           error details