karafka 2.5.9 → 2.6.0.beta1

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

@@ -71,7 +71,7 @@ module Karafka
               batch_size: consumer.messages.size,
               first_offset: consumer.messages.metadata.first_offset,
               last_offset: consumer.messages.metadata.last_offset,
-              consumer_group: consumer.topic.consumer_group.id,
+              consumer_group: consumer.topic.group.id,
               topic: consumer.topic.name,
               partition: consumer.partition,
               attempt: consumer.coordinator.pause_tracker.attempt
@@ -166,20 +166,20 @@ module Karafka
           # @param event [Karafka::Core::Monitoring::Event]
           def on_statistics_emitted(event)
             statistics = event[:statistics]
-            consumer_group_id = event[:consumer_group_id]
+            group_id = event[:group_id]
 
             rd_kafka_metrics.each do |metric|
-              report_metric(metric, statistics, consumer_group_id)
+              report_metric(metric, statistics, group_id)
             end
 
-            report_aggregated_topics_metrics(statistics, consumer_group_id)
+            report_aggregated_topics_metrics(statistics, group_id)
           end
 
           # Reports a given metric statistics to Appsignal
           # @param metric [RdKafkaMetric] metric value object
           # @param statistics [Hash] hash with all the statistics emitted
-          # @param consumer_group_id [String] cg in context which we operate
-          def report_metric(metric, statistics, consumer_group_id)
+          # @param group_id [String] group id in context which we operate
+          def report_metric(metric, statistics, group_id)
             case metric.scope
             when :root
               # Do nothing on the root metrics as the same metrics are reported in a granular
@@ -188,8 +188,7 @@ module Karafka
             when :brokers
               statistics.fetch("brokers").each_value do |broker_statistics|
                 # Skip bootstrap nodes
-                # Bootstrap nodes have nodeid -1, other nodes have positive
-                # node ids
+                # Bootstrap nodes have nodeid -1, other nodes have positive node ids
                 next if broker_statistics["nodeid"] == -1
 
                 public_send(
@@ -218,7 +217,7 @@ module Karafka
                     metric.name,
                     partition_statistics.dig(*metric.key_location),
                     {
-                      consumer_group: consumer_group_id,
+                      consumer_group: group_id,
                       topic: topic_name,
                       partition: partition_name
                     }
@@ -233,8 +232,8 @@ module Karafka
           # Publishes aggregated topic-level metrics that are sum of per partition metrics
           #
           # @param statistics [Hash] hash with all the statistics emitted
-          # @param consumer_group_id [String] cg in context which we operate
-          def report_aggregated_topics_metrics(statistics, consumer_group_id)
+          # @param group_id [String] group id in context which we operate
+          def report_aggregated_topics_metrics(statistics, group_id)
             config.aggregated_rd_kafka_metrics.each do |metric|
               statistics.fetch("topics").each do |topic_name, topic_values|
                 sum = 0
@@ -253,7 +252,7 @@ module Karafka
                   metric.name,
                   sum,
                   {
-                    consumer_group: consumer_group_id,
+                    consumer_group: group_id,
                     topic: topic_name
                   }
                 )
@@ -314,11 +313,11 @@ module Karafka
           # @param consumer [Karafka::BaseConsumer] Karafka consumer instance
           def with_multiple_resolutions(consumer)
             topic_name = consumer.topic.name
-            consumer_group_id = consumer.topic.consumer_group.id
+            group_id = consumer.topic.group.id
             partition = consumer.partition
 
             tags = {
-              consumer_group: consumer_group_id,
+              consumer_group: group_id,
               topic: topic_name
             }
 
@@ -328,10 +327,8 @@ module Karafka
 
           # Sends minute based probing metrics
           def minute_probe
-            concurrency = Karafka::App.config.concurrency
-
             count("processes_count", 1, {})
-            count("threads_count", concurrency, {})
+            count("threads_count", Karafka::Server.workers.size, {})
           end
         end
       end

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

@@ -80,9 +80,9 @@ module Karafka
           # @param event [Karafka::Core::Monitoring::Event]
           def on_statistics_emitted(event)
             statistics = event[:statistics]
-            consumer_group_id = event[:consumer_group_id]
+            group_id = event[:group_id]
 
-            tags = ["consumer_group:#{consumer_group_id}"]
+            tags = ["consumer_group:#{group_id}"]
             tags.concat(default_tags)
 
             rd_kafka_metrics.each do |metric|
@@ -111,9 +111,9 @@ module Karafka
             time_taken = event[:time]
             messages_count = event[:messages_buffer].size
 
-            consumer_group_id = event[:subscription_group].consumer_group.id
+            group_id = event[:subscription_group].group.id
 
-            tags = ["consumer_group:#{consumer_group_id}"]
+            tags = ["consumer_group:#{group_id}"]
             tags.concat(default_tags)
 
             histogram("listener.polling.time_taken", time_taken, tags: tags)
@@ -164,7 +164,7 @@ module Karafka
             jq_stats = event[:jobs_queue].statistics
 
             tags = default_tags
-            gauge("worker.total_threads", Karafka::App.config.concurrency, tags: tags)
+            gauge("worker.total_threads", Karafka::Server.workers.size, tags: tags)
             histogram("worker.processing", jq_stats[:busy], tags: tags)
             histogram("worker.enqueued_jobs", jq_stats[:enqueued], tags: tags)
           end
@@ -241,8 +241,7 @@ module Karafka
             when :brokers
               statistics.fetch("brokers").each_value do |broker_statistics|
                 # Skip bootstrap nodes
-                # Bootstrap nodes have nodeid -1, other nodes have positive
-                # node ids
+                # Bootstrap nodes have nodeid -1, other nodes have positive node ids
                 next if broker_statistics["nodeid"] == -1
 
                 tags = ["broker:#{broker_statistics["nodename"]}"]
@@ -290,12 +289,12 @@ module Karafka
           def consumer_tags(consumer)
             messages = consumer.messages
             metadata = messages.metadata
-            consumer_group_id = consumer.topic.consumer_group.id
+            group_id = consumer.topic.group.id
 
             [
               "topic:#{metadata.topic}",
               "partition:#{metadata.partition}",
-              "consumer_group:#{consumer_group_id}"
+              "consumer_group:#{group_id}"
             ]
           end
         end

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

@@ -39,11 +39,15 @@ module Karafka
 
           # Responds to a HTTP request with the process liveness status
           def respond
-            body = JSON.generate(status_body)
-
             client = @server.accept
             client.gets
-            client.print "HTTP/1.1 #{healthy? ? OK_CODE : FAIL_CODE}\r\n"
+            # Compute body after accepting so it reflects current health at request time.
+            # Derive the HTTP status code from the same snapshot to guarantee consistency -
+            # calling healthy? separately could observe a different state.
+            snapshot = status_body
+            body = JSON.generate(snapshot)
+            code = (snapshot[:status] == "healthy") ? OK_CODE : FAIL_CODE
+            client.print "HTTP/1.1 #{code}\r\n"
             client.print "Content-Type: application/json\r\n"
             client.print "Content-Length: #{body.bytesize}\r\n"
             client.print "\r\n"

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

@@ -158,36 +158,39 @@ module Karafka
             @mutex.synchronize(&)
           end
 
-          # @return [Integer] object id of the current thread
-          def thread_id
-            Thread.current.object_id
+          # @return [Integer] object id of the current fiber
+          # @note We use fiber object id instead of thread object id to ensure fiber-safety.
+          #   Multiple fibers can run on the same thread, and using thread id would cause them
+          #   to overwrite each other's timestamps.
+          def fiber_id
+            Fiber.current.object_id
           end
 
-          # Update the polling tick time for current thread
+          # Update the polling tick time for current fiber
           def mark_polling_tick
             synchronize do
-              @pollings[thread_id] = monotonic_now
+              @pollings[fiber_id] = monotonic_now
             end
           end
 
-          # Clear current thread polling time tracker
+          # Clear current fiber polling time tracker
           def clear_polling_tick
             synchronize do
-              @pollings.delete(thread_id)
+              @pollings.delete(fiber_id)
             end
           end
 
           # Update the processing tick time
           def mark_consumption_tick
             synchronize do
-              @consumptions[thread_id] = monotonic_now
+              @consumptions[fiber_id] = monotonic_now
             end
           end
 
-          # Clear current thread consumption time tracker
+          # Clear current fiber consumption time tracker
           def clear_consumption_tick
             synchronize do
-              @consumptions.delete(thread_id)
+              @consumptions.delete(fiber_id)
             end
           end
 

data/lib/karafka/licenser.rb

@@ -46,12 +46,25 @@ module Karafka
 
       # Check if License module and required methods are already defined
       # @return [Boolean]
+      # @raise [Errors::InvalidLicenseTokenError] when License module exists but is missing
+      #   required methods (token or version)
       def license_fully_defined?
         return false unless const_defined?("::Karafka::License")
 
-        # Check if the required methods exist
-        ::Karafka::License.respond_to?(:token) &&
-          ::Karafka::License.respond_to?(:version)
+        missing = []
+        missing << "#token" unless ::Karafka::License.respond_to?(:token)
+        missing << "#version" unless ::Karafka::License.respond_to?(:version)
+
+        return true if missing.empty?
+
+        raise(
+          Errors::InvalidLicenseTokenError,
+          <<~MSG.tr("\n", " ")
+            Karafka::License module is defined but missing required method(s): #{missing.join(", ")}.
+            When defining Karafka::License manually, both #token and #version must be implemented.
+            Please refer to https://karafka.io/docs/Pro-Enterprise-License-Setup/ for details.
+          MSG
+        )
       end
 
       # Attempt to safely load license without executing gem code

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

@@ -48,8 +48,7 @@ module Karafka
             break if revoked?
 
             # We cannot early stop when running virtual partitions because the intermediate state
-            # would force us not to commit the offsets. This would cause extensive
-            # double-processing
+            # would force us not to commit the offsets. This would cause extensive double-processing
             break if ::Karafka::App.stopping? && !topic.virtual_partitions?
 
             consume_job(message)

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

@@ -40,8 +40,7 @@ module Karafka
           deserializer: %i[internal active_job deserializer]
         )
 
-        # Defaults for dispatching
-        # They can be updated by using `#karafka_options` on the job
+        # Defaults for dispatching They can be updated by using `#karafka_options` on the job
         DEFAULTS = {
           dispatch_method: :produce_async,
           dispatch_many_method: :produce_many_async,

data/lib/karafka/pro/admin/recovery.rb

@@ -77,30 +77,30 @@ module Karafka
         private_constant :OFFSETS_TOPIC, :DEFAULT_LAST_COMMITTED_AT_OFFSET
 
         class << self
-          # @param consumer_group_id [String] consumer group to read offsets for
+          # @param group_id [String] consumer group to read offsets for
           # @param last_committed_at [Time] approximate time of last successful offset commit
           #   (default: 1 hour ago). A good rule of thumb is the crash time minus 10 minutes
           # @return [Hash{String => Hash{Integer => Integer}}]
           # @see #read_committed_offsets
           def read_committed_offsets(
-            consumer_group_id,
+            group_id,
             last_committed_at: Time.now - DEFAULT_LAST_COMMITTED_AT_OFFSET
           )
-            new.read_committed_offsets(consumer_group_id, last_committed_at: last_committed_at)
+            new.read_committed_offsets(group_id, last_committed_at: last_committed_at)
           end
 
-          # @param consumer_group_id [String] consumer group id
+          # @param group_id [String] consumer group id
           # @return [Integer] __consumer_offsets partition number
           # @see #offsets_partition_for
-          def offsets_partition_for(consumer_group_id)
-            new.offsets_partition_for(consumer_group_id)
+          def offsets_partition_for(group_id)
+            new.offsets_partition_for(group_id)
           end
 
-          # @param consumer_group_id [String] consumer group to look up
+          # @param group_id [String] consumer group to look up
           # @return [Hash] coordinator broker info
           # @see #coordinator_for
-          def coordinator_for(consumer_group_id)
-            new.coordinator_for(consumer_group_id)
+          def coordinator_for(group_id)
+            new.coordinator_for(group_id)
           end
 
           # @param partition [Integer] __consumer_offsets partition to scan
@@ -143,7 +143,7 @@ module Karafka
         #   caller's responsibility to verify that all expected topic-partitions are present before
         #   using the result for migration or other operations.
         #
-        # @param consumer_group_id [String] consumer group to read offsets for
+        # @param group_id [String] consumer group to read offsets for
         # @param last_committed_at [Time] approximate time of last successful offset commit
         #   (default: 1 hour ago). A good rule of thumb is the crash time minus 10 minutes
         # @return [Hash{String => Hash{Integer => Integer}}]
@@ -174,11 +174,11 @@ module Karafka
         #
         #   # Now reconfigure your consumers to use 'sync_v2' and restart them
         def read_committed_offsets(
-          consumer_group_id,
+          group_id,
           last_committed_at: Time.now - DEFAULT_LAST_COMMITTED_AT_OFFSET
         )
           committed = Hash.new { |h, k| h[k] = {} }
-          target_partition = offsets_partition_for(consumer_group_id)
+          target_partition = offsets_partition_for(group_id)
 
           iterator = Pro::Iterator.new(
             { OFFSETS_TOPIC => { target_partition => last_committed_at } },
@@ -190,7 +190,7 @@ module Karafka
 
             parsed = parse_offset_commit(message)
             next unless parsed
-            next unless parsed[:group] == consumer_group_id
+            next unless parsed[:group] == group_id
 
             if parsed[:offset].nil?
               # Tombstone — offset was deleted, remove from results
@@ -211,14 +211,14 @@ module Karafka
         # hash: s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1], computed with int32 overflow
         # semantics. Utils.abs maps Integer.MIN_VALUE to 0.
         #
-        # @param consumer_group_id [String] consumer group id
+        # @param group_id [String] consumer group id
         # @return [Integer] __consumer_offsets partition number
         #
         # @example Check which partition stores offsets for a group
         #   Karafka::Admin::Recovery.offsets_partition_for('my-group')
         #   #=> 17
-        def offsets_partition_for(consumer_group_id)
-          h = java_hash_code(consumer_group_id)
+        def offsets_partition_for(group_id)
+          h = java_hash_code(group_id)
           # Kafka's Utils.abs: Integer.MIN_VALUE maps to 0
           h = (h == -2_147_483_648) ? 0 : h.abs
           h % offsets_partition_count
@@ -233,7 +233,7 @@ module Karafka
         # returned broker is the one that is down or in a FAILED state, the group is stuck and
         # needs migration.
         #
-        # @param consumer_group_id [String] consumer group to look up
+        # @param group_id [String] consumer group to look up
         # @return [Hash{Symbol => Object}] coordinator info with :partition, :broker_id,
         #   and :broker_host keys
         #
@@ -246,8 +246,8 @@ module Karafka
         #   if info[:broker_id] == failed_broker_id
         #     puts "Group 'my-group' is stuck on failed broker #{info[:broker_host]}"
         #   end
-        def coordinator_for(consumer_group_id)
-          target_partition = offsets_partition_for(consumer_group_id)
+        def coordinator_for(group_id)
+          target_partition = offsets_partition_for(group_id)
           metadata = cluster_info
 
           offsets_topic = metadata.topics.find { |t| t[:topic_name] == OFFSETS_TOPIC }

data/lib/karafka/pro/base_consumer.rb

@@ -37,7 +37,7 @@ module Karafka
     #
     # Methods here are suppose to be always available or are expected to be redefined
     module BaseConsumer
-      # @return [Karafka::Pro::Processing::Coordinators::ErrorsTracker] tracker for errors that
+      # @return [Karafka::Pro::Processing::ConsumerGroups::Coordinators::ErrorsTracker] tracker for errors that
       #   occurred during processing until another successful processing
       #
       # @note This will always contain **only** details of errors that occurred during `#consume`
@@ -53,7 +53,7 @@ module Karafka
         coordinator.errors_tracker
       end
 
-      # @return [Karafka::Pro::Processing::SubscriptionGroupsCoordinator] Coordinator allowing to
+      # @return [Karafka::Pro::Processing::ConsumerGroups::SubscriptionGroupsCoordinator] Coordinator allowing to
       #   pause and resume polling of the given subscription group jobs queue for postponing
       #   further work.
       #
@@ -62,7 +62,7 @@ module Karafka
       # @note This is a low-level API used for cross-topic coordination and some advanced features.
       #   Use it at own risk.
       def subscription_groups_coordinator
-        Processing::SubscriptionGroupsCoordinator.instance
+        Processing::ConsumerGroups::SubscriptionGroupsCoordinator.instance
       end
     end
   end

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

@@ -46,7 +46,7 @@ module Karafka
             include
             exclude
           ].each do |action|
-            optional(:"#{action}_consumer_groups") { |cg| cg.is_a?(Array) }
+            optional(:"#{action}_consumer_groups") { |val| val.is_a?(Array) }
             optional(:"#{action}_subscription_groups") { |sg| sg.is_a?(Array) }
             optional(:"#{action}_topics") { |topics| topics.is_a?(Array) }
 
@@ -58,7 +58,7 @@ module Karafka
               # 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
               next if value.empty?
-              next if (value - Karafka::App.consumer_groups.map(&:name)).empty?
+              next if (value - Karafka::App.routes.map(&:name)).empty?
 
               # Found unknown consumer groups
               [[[:"#{action}_consumer_groups"], :consumer_groups_inclusion]]
@@ -74,7 +74,7 @@ module Karafka
               next if value.empty?
 
               subscription_groups = Karafka::App
-                .consumer_groups
+                .routes
                 .map(&:subscription_groups)
                 .flatten
                 .map(&:name)
@@ -95,7 +95,7 @@ module Karafka
               next if value.empty?
 
               topics = Karafka::App
-                .consumer_groups
+                .routes
                 .map(&:subscription_groups)
                 .flatten
                 .map(&:topics)
@@ -107,7 +107,7 @@ module Karafka
               # If there are any patterns defined, we cannot report on topics inclusions because
               # topics may be added during boot or runtime. We go with simple assumption:
               # if there are patterns defined, we do not check the inclusions at all
-              next unless Karafka::App.consumer_groups.map(&:patterns).flatten.empty?
+              next unless Karafka::App.routes.map(&:patterns).flatten.empty?
 
               # Found unknown topics
               [[[:"#{action}_topics"], :topics_inclusion]]

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

@@ -82,24 +82,24 @@ module Karafka
           end
 
           # Collects the offsets for the segment origin consumer group and the parallel segments
-          # consumers groups. We use segment origin cg offsets as a baseline for the distribution
-          # and use existing (if any) parallel segments cgs offsets for validations.
+          # consumers groups. We use segment origin group offsets as a baseline for the
+          # distribution and use existing (if any) parallel segments groups offsets for validations.
           #
           # @param segment_origin [String] name of the origin consumer group
           # @param segments [Array<Karafka::Routing::ConsumerGroup>]
-          # @return [Hash] fetched offsets for all the cg topics for all the consumer groups
+          # @return [Hash] fetched offsets for all the group topics for all the groups
           def collect_offsets(segment_origin, segments)
             topics_names = segments.first.topics.map(&:name)
-            consumer_groups = [segment_origin, segments.map(&:name)].flatten
+            groups = [segment_origin, segments.map(&:name)].flatten
 
-            consumer_groups_with_topics = consumer_groups
+            groups_with_topics = groups
               .to_h { |name| [name, topics_names] }
 
             lags_with_offsets = Karafka::Admin.read_lags_with_offsets(
-              consumer_groups_with_topics
+              groups_with_topics
             )
 
-            lags_with_offsets.each do |_cg_name, topics|
+            lags_with_offsets.each do |_group_name, topics|
               topics.each do |_topic_name, partitions|
                 partitions.transform_values! { |details| details[:offset] }
               end

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

@@ -97,8 +97,8 @@ module Karafka
             collapse = Hash.new { |h, k| h[k] = {} }
             segments_names = segments.map(&:name)
 
-            offsets.each do |cg_name, topics|
-              next unless segments_names.include?(cg_name)
+            offsets.each do |group_name, topics|
+              next unless segments_names.include?(group_name)
 
               topics.each do |topic_name, partitions|
                 partitions.each do |partition_id, offset|
@@ -128,8 +128,8 @@ module Karafka
           def validate!(offsets, segment_origin)
             collapse = Hash.new { |h, k| h[k] = {} }
 
-            offsets.each do |cg_name, topics|
-              next if cg_name == segment_origin
+            offsets.each do |group_name, topics|
+              next if group_name == segment_origin
 
               topics.each do |topic_name, partitions|
                 partitions.each do |partition_id, offset|

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

@@ -101,15 +101,15 @@ module Karafka
           # It prevents users from overwriting the already set segments distribution.
           # Adding new topics to the same parallel segments consumer group does not require us to
           # run this at all and on top of that users can always use `--consumer_groups` flag to
-          # limit the cgs that we will be operating here
+          # limit the groups that we will be operating here
           #
           # @param offsets [Hash]
           # @param segments [Array<Karafka::Routing::ConsumerGroup>]
           def validate!(offsets, segments)
             segments_names = segments.map(&:name)
 
-            offsets.each do |cg_name, topics|
-              next unless segments_names.include?(cg_name)
+            offsets.each do |group_name, topics|
+              next unless segments_names.include?(group_name)
 
               topics.each do |topic_name, partitions|
                 partitions.each do |partition_id, offset|
@@ -117,7 +117,7 @@ module Karafka
 
                   raise(
                     Karafka::Errors::CommandValidationError,
-                    "Parallel segment #{red(cg_name)} already has offset #{red(offset)} " \
+                    "Parallel segment #{red(group_name)} already has offset #{red(offset)} " \
                     "set for #{red("#{topic_name}##{partition_id}")}"
                   )
                 end
@@ -136,8 +136,8 @@ module Karafka
             distributions = []
             segments_names = segments.map(&:name)
 
-            offsets.each do |cg_name, topics|
-              next if segments_names.include?(cg_name)
+            offsets.each do |group_name, topics|
+              next if segments_names.include?(group_name)
 
               distribution = {}
 

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

@@ -94,8 +94,7 @@ module Karafka
               # Skip negative and time based offsets
               next unless offset.is_a?(Integer) && offset >= 0
 
-              # Exact offsets can be used as they are
-              # No need for extra operations
+              # Exact offsets can be used as they are No need for extra operations
               @mapped_topics[name][partition] = offset
             end
           end
@@ -108,31 +107,52 @@ module Karafka
         # heavily compacted topics, this may return less than the desired number but it is a
         # limitation that is documented.
         def resolve_partitions_with_negative_offsets
+          # Collect all integer-offset partitions (positive and negative) and the subset
+          # that actually need LWM/HWM resolution
+          warm_up_partitions = {}
+          negative_partitions = {}
+
           @expanded_topics.each do |name, partitions|
             next unless partitions.is_a?(Hash)
 
             partitions.each do |partition, offset|
-              # Care only about numerical offsets
-              #
-              # For time based we already resolve them via librdkafka lookup API
               next unless offset.is_a?(Integer)
 
-              low_offset, high_offset = @consumer.query_watermark_offsets(name, partition)
+              (warm_up_partitions[name] ||= []) << partition
+              (negative_partitions[name] ||= {})[partition] = offset if offset.negative?
+            end
+          end
 
-              # Care only about negative offsets (last n messages)
-              #
-              # We reject the above results but we **NEED** to run the `#query_watermark_offsets`
-              # for each topic partition nonetheless. Without this, librdkafka fetches a lot more
-              # metadata about each topic and each partition and this takes much more time than
-              # just getting watermarks. If we do not run watermark, at least an extra second
-              # is added at the beginning of iterator flow
-              #
-              # This may not be significant when this runs in the background but in case of
-              # using iterator in thins like Puma, it heavily impacts the end user experience
-              next unless offset.negative?
+          return if warm_up_partitions.empty?
+
+          # A single batched offsets_for_times call on the consumer handle warms up
+          # librdkafka's per-partition metadata cache for all integer-offset partitions in
+          # one roundtrip. Without this pre-fetch, librdkafka triggers a much broader
+          # metadata refresh when assign is called later, adding at least a second to
+          # iterator startup — noticeable in latency-sensitive contexts like Puma.
+          # The epoch timestamp ensures every partition returns its LWM; the result is
+          # intentionally discarded since we only need the warm-up side effect here.
+          warm_up_tpl = Rdkafka::Consumer::TopicPartitionList.new
+          warm_up_partitions.each do |name, part_ids|
+            warm_up_tpl.add_topic_and_partitions_with_offsets(
+              name, part_ids.to_h { |p| [p, Time.at(0)] }
+            )
+          end
+          @consumer.offsets_for_times(warm_up_tpl)
 
+          return if negative_partitions.empty?
+
+          # Batch-fetch LWM and HWM for all negative-offset partitions in two admin calls
+          # (one for :earliest, one for :latest) instead of N per-partition consumer calls
+          watermarks = Karafka::Admin::Topics.read_watermark_offsets(
+            negative_partitions.transform_values(&:keys)
+          )
+
+          negative_partitions.each do |name, partitions|
+            partitions.each do |partition, offset|
               # We add because this offset is negative
-              @mapped_topics[name][partition] = [high_offset + offset, low_offset].max
+              low, high = watermarks.dig(name, partition) || [0, 0]
+              @mapped_topics[name][partition] = [high + offset, low].max
             end
           end
         end