You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@kafka.apache.org by li...@apache.org on 2026/09/09 17:09:38 UTC

(kafka) branch 4.4 updated: KAFKA-21010 Another busy loop happens if the member is in JOINING state and bootstrap DNS resolution is not finished (#23348)

This is an automated email from the ASF dual-hosted git repository.

lianetm pushed a commit to branch 4.4
in repository https://gitbox.apache.org/repos/asf/kafka.git


The following commit(s) were added to refs/heads/4.4 by this push:
     new d12e95da902 KAFKA-21010 Another busy loop happens if the member is in JOINING state and bootstrap DNS resolution is not finished (#23348)
d12e95da902 is described below

commit d12e95da90259dd063cd736d9a9d579c54bf182e
Author: Ken Huang <s7...@gmail.com>
AuthorDate: Thu Sep 10 00:58:31 2026 +0800

    KAFKA-21010 Another busy loop happens if the member is in JOINING state and bootstrap DNS resolution is not finished (#23348)
    
    Follow-up to (#23227).
    
    Before bootstrap DNS resolution completes,
    `coordinatorRequestManager.coordinator()` is empty, causing the
    coordinator-unknown path in `maximumTimeToWait()` to return
    `heartbeatRequestState.heartbeatIntervalMs()`. However, the heartbeat
    interval is initialized to 0 and is not updated until the first
    heartbeat response is received. As a result, a member in the JOINING
    state reports `maximumTimeToWait() == 0`.
    
    Since the application thread's poll timeout is bounded by this value,
    both the application and network threads can busy-spin until the
    coordinator is discovered.
    
    Returning `retryBackoffMs` aligns with the behavior discussed in #23227.
    Until the coordinator is discovered, no heartbeat can be sent, making
    this equivalent to the "nothing to send right now, wait for a backoff"
    case for which `FetchRequestManager#maximumTimeToWait()` already returns
    the retry backoff. Coordinator discovery itself is also paced by the
    coordinator manager's backoff.
    
    Reviewers: Lianet Magrans <lm...@confluent.io>
---
 checkstyle/suppressions.xml                        |   2 +-
 .../internals/AbstractHeartbeatRequestManager.java |  30 +++--
 .../consumer/internals/CommitRequestManager.java   |   9 +-
 .../consumer/internals/HeartbeatRequestState.java  |   4 +
 .../StreamsGroupHeartbeatRequestManager.java       |   4 +-
 .../AbstractHeartbeatRequestManagerTest.java       |   2 +-
 .../internals/CommitRequestManagerTest.java        |  12 +-
 .../ConsumerHeartbeatRequestManagerTest.java       | 122 ++++++++++++++++++++-
 .../ShareHeartbeatRequestManagerTest.java          |  35 +++++-
 .../StreamsGroupHeartbeatRequestManagerTest.java   |   8 +-
 10 files changed, 199 insertions(+), 29 deletions(-)

diff --git a/checkstyle/suppressions.xml b/checkstyle/suppressions.xml
index d003eca5c93..b3fd9b27ade 100644
--- a/checkstyle/suppressions.xml
+++ b/checkstyle/suppressions.xml
@@ -86,7 +86,7 @@
 
     <!-- Clients tests -->
     <suppress checks="ClassDataAbstractionCoupling"
-              files="(Sender|Fetcher|FetchRequestManager|OffsetFetcher|KafkaConsumer|Metrics|RequestResponse|TransactionManager|KafkaAdminClient|Message|KafkaProducer|CommitRequestManager)Test.java"/>
+              files="(Sender|Fetcher|FetchRequestManager|OffsetFetcher|KafkaConsumer|Metrics|RequestResponse|TransactionManager|KafkaAdminClient|Message|KafkaProducer|CommitRequestManager|ConsumerHeartbeatRequestManager)Test.java"/>
 
     <suppress checks="ClassFanOutComplexity"
               files="(ConsumerCoordinator|KafkaConsumer|RequestResponse|Fetcher|FetchRequestManager|KafkaAdminClient|Message|KafkaProducer|NetworkClient|StreamsGroupHeartbeatRequestManager|CommitRequestManager)Test.java"/>
diff --git a/clients/src/main/java/org/apache/kafka/clients/consumer/internals/AbstractHeartbeatRequestManager.java b/clients/src/main/java/org/apache/kafka/clients/consumer/internals/AbstractHeartbeatRequestManager.java
index 8226d39535a..ef00f1d82e5 100644
--- a/clients/src/main/java/org/apache/kafka/clients/consumer/internals/AbstractHeartbeatRequestManager.java
+++ b/clients/src/main/java/org/apache/kafka/clients/consumer/internals/AbstractHeartbeatRequestManager.java
@@ -245,27 +245,35 @@ public abstract class AbstractHeartbeatRequestManager<R extends AbstractResponse
      * <p>Similarly, we may have to unblock the application thread to send a {@link AsyncPollEvent} to make sure
      * our poll timer will not expire while we are polling.
      *
-     * <p>When the member is {@link MemberState#UNSUBSCRIBED} (for example, with manual assignment),
-     * this returns {@code Long.MAX_VALUE} to indicate there is no next heartbeat to wait for,
-     * allowing the application thread to block for the full user-specified poll timeout rather than
-     * spinning in a busy loop.
+     * <p>When the member is {@link MemberState#UNSUBSCRIBED} or in the terminal {@link MemberState#FATAL} state,
+     * this returns {@code Long.MAX_VALUE} to indicate there is no next heartbeat to wait for, allowing the application
+     * thread to block for the full user-specified poll timeout rather than spinning in a busy loop.
      */
     @Override
     public long maximumTimeToWait(long currentTimeMs) {
         pollTimer.update(currentTimeMs);
-        if (membershipManager().state() == MemberState.UNSUBSCRIBED) {
+        MemberState state = membershipManager().state();
+        // No heartbeat can be sent in these states: UNSUBSCRIBED has nothing to heartbeat for,
+        // and FATAL is terminal. The fatal error has already been propagated to the
+        // application thread, so there is no need to wake it before its poll timeout expires.
+        if (state == MemberState.UNSUBSCRIBED || state == MemberState.FATAL) {
             return Long.MAX_VALUE;
         }
+        // Unblock the application thread so STALE/FENCED members can run
+        // assignment-release callbacks and rejoin during the next poll.
         if (pollTimer.isExpired()) {
             return 0L;
         }
-        // KAFKA-20253: mirror the guard in poll(). A heartbeat is only sent when the coordinator is known
-        // and the member is in a state that heartbeats. When the coordinator is unavailable (e.g. after a
-        // re-authentication failure) or the member should skip heartbeats (FATAL/FENCED/STALE/UNSUBSCRIBED),
-        // poll() returns EMPTY, so falling through to the timer-based branches below would return 0 (the
-        // heartbeat timer is left permanently expired) and busy-spin both the application and network threads.
+        // Mirror the guard in poll(). A heartbeat is only sent when the coordinator is known and the
+        // member is in a state that can send heartbeats. This covers cases such as:
+        // - The coordinator is unavailable (for example, during bootstrap DNS resolution or after a
+        //   re-authentication failure).
+        // - The member is FENCED (or STALE with the poll timer already reset) and waiting for the
+        //   application thread to run assignment-release callbacks before rejoining.
+        // Return retryBackoffMs rather than the heartbeat interval, since the interval remains 0 until
+        // the first heartbeat response is received, which would also lead to busy-spinning.
         if (coordinatorRequestManager.coordinator().isEmpty() || membershipManager().shouldSkipHeartbeat()) {
-            return heartbeatRequestState.heartbeatIntervalMs();
+            return heartbeatRequestState.retryBackoffMs();
         }
         if (membershipManager().shouldHeartbeatNow() && !heartbeatRequestState.requestInFlight()) {
             return 0L;
diff --git a/clients/src/main/java/org/apache/kafka/clients/consumer/internals/CommitRequestManager.java b/clients/src/main/java/org/apache/kafka/clients/consumer/internals/CommitRequestManager.java
index 1324ece542f..8360c746bfc 100644
--- a/clients/src/main/java/org/apache/kafka/clients/consumer/internals/CommitRequestManager.java
+++ b/clients/src/main/java/org/apache/kafka/clients/consumer/internals/CommitRequestManager.java
@@ -229,9 +229,10 @@ public class CommitRequestManager implements RequestManager, MemberStateListener
         // If the coordinator is unavailable (e.g. bootstrap DNS resolution is still in progress),
         // falling through to the timer-based remainingMs() would return 0 once the auto-commit interval
         // elapses, since the auto-commit timer remains permanently expired. This would cause both the
-        // application and network threads to busy-spin.
+        // application and network threads to busy-spin. Wait a retry backoff instead of the auto-commit
+        // interval, which may be configured to zero and is consistent with the other request managers.
         if (coordinatorRequestManager.coordinator().isEmpty()) {
-            return autoCommit.autoCommitIntervalMs();
+            return retryBackoffMs;
         }
         return autoCommit.remainingMs(currentTimeMs);
     }
@@ -1576,10 +1577,6 @@ public class CommitRequestManager implements RequestManager, MemberStateListener
         public void setInflightCommitStatus(final boolean inflightCommitStatus) {
             this.hasInflightCommit = inflightCommitStatus;
         }
-
-        public long autoCommitIntervalMs() {
-            return autoCommitInterval;
-        }
     }
 
     static class MemberInfo {
diff --git a/clients/src/main/java/org/apache/kafka/clients/consumer/internals/HeartbeatRequestState.java b/clients/src/main/java/org/apache/kafka/clients/consumer/internals/HeartbeatRequestState.java
index bdb66c4a10d..d43e956ddb9 100644
--- a/clients/src/main/java/org/apache/kafka/clients/consumer/internals/HeartbeatRequestState.java
+++ b/clients/src/main/java/org/apache/kafka/clients/consumer/internals/HeartbeatRequestState.java
@@ -60,6 +60,10 @@ public class HeartbeatRequestState extends RequestState {
         return heartbeatIntervalMs;
     }
 
+    public long retryBackoffMs() {
+        return exponentialBackoff.initialInterval();
+    }
+
     public void resetTimer() {
         this.heartbeatTimer.reset(heartbeatIntervalMs);
     }
diff --git a/clients/src/main/java/org/apache/kafka/clients/consumer/internals/StreamsGroupHeartbeatRequestManager.java b/clients/src/main/java/org/apache/kafka/clients/consumer/internals/StreamsGroupHeartbeatRequestManager.java
index 580cd9289e9..857c86eba1a 100644
--- a/clients/src/main/java/org/apache/kafka/clients/consumer/internals/StreamsGroupHeartbeatRequestManager.java
+++ b/clients/src/main/java/org/apache/kafka/clients/consumer/internals/StreamsGroupHeartbeatRequestManager.java
@@ -539,8 +539,10 @@ public class StreamsGroupHeartbeatRequestManager implements RequestManager {
         // shouldNotWaitForHeartbeatInterval() check would return 0 whenever the member wants to
         // (re)join. Because no heartbeat can be sent until the coordinator is discovered, the
         // condition remains true and both the application and network threads end up busy-spinning.
+        // Wait a retry backoff rather than the heartbeat interval, because the interval is zero
+        // until the first heartbeat response is received, which would also busy-spin.
         if (coordinatorRequestManager.coordinator().isEmpty() || membershipManager.shouldSkipHeartbeat()) {
-            return heartbeatRequestState.heartbeatIntervalMs();
+            return heartbeatRequestState.retryBackoffMs();
         }
         if (membershipManager.shouldNotWaitForHeartbeatInterval() && !heartbeatRequestState.requestInFlight()) {
             return 0L;
diff --git a/clients/src/test/java/org/apache/kafka/clients/consumer/internals/AbstractHeartbeatRequestManagerTest.java b/clients/src/test/java/org/apache/kafka/clients/consumer/internals/AbstractHeartbeatRequestManagerTest.java
index a572ac2d2f8..122fa7c020c 100644
--- a/clients/src/test/java/org/apache/kafka/clients/consumer/internals/AbstractHeartbeatRequestManagerTest.java
+++ b/clients/src/test/java/org/apache/kafka/clients/consumer/internals/AbstractHeartbeatRequestManagerTest.java
@@ -118,7 +118,7 @@ abstract class AbstractHeartbeatRequestManagerTest<R extends AbstractResponse> {
         NetworkClientDelegate.PollResult result = heartbeatRequestManager.poll(time.milliseconds());
 
         assertEquals(Long.MAX_VALUE, result.timeUntilNextPollMs);
-        assertEquals(DEFAULT_HEARTBEAT_INTERVAL_MS, heartbeatRequestManager.maximumTimeToWait(time.milliseconds()));
+        assertEquals(DEFAULT_RETRY_BACKOFF_MS, heartbeatRequestManager.maximumTimeToWait(time.milliseconds()));
         assertEquals(0, result.unsentRequests.size());
     }
 
diff --git a/clients/src/test/java/org/apache/kafka/clients/consumer/internals/CommitRequestManagerTest.java b/clients/src/test/java/org/apache/kafka/clients/consumer/internals/CommitRequestManagerTest.java
index 33863fcd765..1099b12f2a4 100644
--- a/clients/src/test/java/org/apache/kafka/clients/consumer/internals/CommitRequestManagerTest.java
+++ b/clients/src/test/java/org/apache/kafka/clients/consumer/internals/CommitRequestManagerTest.java
@@ -67,6 +67,7 @@ import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.ValueSource;
 import org.mockito.Mockito;
 
 import java.util.ArrayList;
@@ -741,9 +742,12 @@ public class CommitRequestManagerTest {
         assertPoll(1, commitRequestManager);
     }
 
-    @Test
-    public void testMaximumTimeToWaitWhenCoordinatorUnknownDoesNotSpin() {
-        CommitRequestManager commitRequestManager = create(true, 100);
+    // The auto-commit interval may be configured to zero, so a retry backoff is used while the
+    // coordinator is unknown, consistently with the fetch and heartbeat request managers.
+    @ParameterizedTest
+    @ValueSource(longs = {0, 5000})
+    public void testMaximumTimeToWaitWhenCoordinatorUnknownDoesNotSpin(long autoCommitInterval) {
+        CommitRequestManager commitRequestManager = create(true, autoCommitInterval);
         when(coordinatorRequestManager.coordinator()).thenReturn(Optional.empty());
 
         time.sleep(100);
@@ -751,7 +755,7 @@ public class CommitRequestManagerTest {
 
         assertTrue(result > 0,
             "maximumTimeToWait must be > 0 when the coordinator is unknown to avoid a busy-spin; got " + result);
-        assertEquals(100, result);
+        assertEquals(retryBackoffMs, result);
     }
 
     @Test
diff --git a/clients/src/test/java/org/apache/kafka/clients/consumer/internals/ConsumerHeartbeatRequestManagerTest.java b/clients/src/test/java/org/apache/kafka/clients/consumer/internals/ConsumerHeartbeatRequestManagerTest.java
index 5d3f6a7b285..27929bbd847 100644
--- a/clients/src/test/java/org/apache/kafka/clients/consumer/internals/ConsumerHeartbeatRequestManagerTest.java
+++ b/clients/src/test/java/org/apache/kafka/clients/consumer/internals/ConsumerHeartbeatRequestManagerTest.java
@@ -16,8 +16,13 @@
  */
 package org.apache.kafka.clients.consumer.internals;
 
+import org.apache.kafka.clients.ApiVersions;
+import org.apache.kafka.clients.BootstrapConfiguration;
+import org.apache.kafka.clients.ClientDnsLookup;
 import org.apache.kafka.clients.ClientResponse;
 import org.apache.kafka.clients.Metadata;
+import org.apache.kafka.clients.MetadataRecoveryStrategy;
+import org.apache.kafka.clients.NetworkClient;
 import org.apache.kafka.clients.consumer.CloseOptions;
 import org.apache.kafka.clients.consumer.ConsumerConfig;
 import org.apache.kafka.clients.consumer.SubscriptionPattern;
@@ -25,13 +30,16 @@ import org.apache.kafka.clients.consumer.internals.AbstractMembershipManager.Loc
 import org.apache.kafka.clients.consumer.internals.ConsumerHeartbeatRequestManager.HeartbeatState;
 import org.apache.kafka.clients.consumer.internals.events.BackgroundEventHandler;
 import org.apache.kafka.clients.consumer.internals.events.ErrorEvent;
+import org.apache.kafka.clients.consumer.internals.metrics.AsyncConsumerMetrics;
 import org.apache.kafka.common.KafkaException;
 import org.apache.kafka.common.Node;
 import org.apache.kafka.common.Uuid;
 import org.apache.kafka.common.errors.AuthenticationException;
+import org.apache.kafka.common.errors.BootstrapResolutionException;
 import org.apache.kafka.common.errors.DisconnectException;
 import org.apache.kafka.common.errors.TimeoutException;
 import org.apache.kafka.common.errors.UnsupportedVersionException;
+import org.apache.kafka.common.internals.ClusterResourceListeners;
 import org.apache.kafka.common.internals.UnsupportedProtocolFieldException;
 import org.apache.kafka.common.message.ConsumerGroupHeartbeatRequestData;
 import org.apache.kafka.common.message.ConsumerGroupHeartbeatResponseData;
@@ -46,6 +54,7 @@ import org.apache.kafka.common.serialization.StringDeserializer;
 import org.apache.kafka.common.utils.MockTime;
 import org.apache.kafka.common.utils.annotation.ApiKeyVersionsSource;
 import org.apache.kafka.common.utils.internals.LogContext;
+import org.apache.kafka.test.MockSelector;
 
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -57,6 +66,7 @@ import org.mockito.ArgumentCaptor;
 import org.mockito.InOrder;
 
 import java.util.Collections;
+import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Properties;
@@ -323,7 +333,117 @@ public class ConsumerHeartbeatRequestManagerTest
 
         assertTrue(result > 0,
             "maximumTimeToWait must be > 0 when the coordinator is unavailable to avoid a busy-spin; got " + result);
-        assertEquals(DEFAULT_HEARTBEAT_INTERVAL_MS, result);
+        assertEquals(DEFAULT_RETRY_BACKOFF_MS, result);
+    }
+
+    /**
+     * While bootstrap DNS resolution is still in progress the coordinator is unknown,
+     * and a member that wants to join has a zero heartbeat interval, since the interval is only
+     * learned from the first heartbeat response. maximumTimeToWait() must wait a retry backoff
+     * rather than the (zero) heartbeat interval; returning 0 busy-spins the application and
+     * network threads.
+     */
+    @Test
+    public void testMaximumTimeToWaitWhenJoiningAndCoordinatorUnknownDoesNotSpin() {
+        createHeartbeatRequestStateWithZeroHeartbeatInterval();
+        when(coordinatorRequestManager.coordinator()).thenReturn(Optional.empty());
+        when(membershipManager.state()).thenReturn(MemberState.JOINING);
+        when(membershipManager.shouldHeartbeatNow()).thenReturn(true);
+
+        long result = heartbeatRequestManager.maximumTimeToWait(time.milliseconds());
+
+        assertTrue(result > 0, "maximumTimeToWait must be > 0 while the member is joining and the coordinator is unknown to avoid a busy-spin; got " + result);
+        assertEquals(DEFAULT_RETRY_BACKOFF_MS, result);
+    }
+
+    @Test
+    public void testMaximumTimeToWaitWhenFatalReturnsMaxValue() {
+        createHeartbeatRequestStateWithZeroHeartbeatInterval();
+        when(membershipManager.state()).thenReturn(MemberState.FATAL);
+
+        assertEquals(Long.MAX_VALUE, heartbeatRequestManager.maximumTimeToWait(time.milliseconds()),
+            "maximumTimeToWait should return Long.MAX_VALUE in the terminal FATAL state");
+    }
+
+    @Test
+    public void testMaximumTimeToWaitWhenFencedWaitsRetryBackoff() {
+        createHeartbeatRequestStateWithZeroHeartbeatInterval();
+        when(membershipManager.state()).thenReturn(MemberState.FENCED);
+        when(membershipManager.shouldSkipHeartbeat()).thenReturn(true);
+
+        long result = heartbeatRequestManager.maximumTimeToWait(time.milliseconds());
+
+        assertTrue(result > 0, "maximumTimeToWait must be > 0 while the member is fenced to avoid a busy-spin; got " + result);
+        assertEquals(DEFAULT_RETRY_BACKOFF_MS, result);
+    }
+
+    @Test
+    public void testMaximumTimeToWaitDoesNotSpinDuringRealBootstrapDnsResolution() throws Exception {
+        long bootstrapResolveTimeoutMs = 1000;
+
+        BootstrapConfiguration bootstrapConfiguration = BootstrapConfiguration.enabled(
+            List.of("unresolvable.invalid:9092"),
+            ClientDnsLookup.USE_ALL_DNS_IPS,
+            bootstrapResolveTimeoutMs,
+            DEFAULT_RETRY_BACKOFF_MS
+        );
+
+        ConsumerConfig config = new ConsumerConfig(Map.of(
+            ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class,
+            ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class,
+            ConsumerConfig.GROUP_ID_CONFIG, DEFAULT_GROUP_ID,
+            ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "unresolvable.invalid:9092",
+            ConsumerConfig.MAX_POLL_INTERVAL_MS_CONFIG, String.valueOf(DEFAULT_MAX_POLL_INTERVAL_MS),
+            ConsumerConfig.RETRY_BACKOFF_MS_CONFIG, String.valueOf(DEFAULT_RETRY_BACKOFF_MS),
+            ConsumerConfig.RETRY_BACKOFF_MAX_MS_CONFIG, String.valueOf(DEFAULT_RETRY_BACKOFF_MAX_MS)
+        ));
+
+        ConsumerMetadata consumerMetadata = new ConsumerMetadata(config, subscriptions, logContext, new ClusterResourceListeners());
+
+        MockSelector selector = new MockSelector(time);
+        NetworkClient networkClient = new NetworkClient(selector, consumerMetadata, "test-client",
+            Integer.MAX_VALUE, 50, 1000, 64 * 1024, 64 * 1024, 1000, 5000, 30000,
+            time, false, new ApiVersions(), logContext,
+            MetadataRecoveryStrategy.NONE, bootstrapConfiguration, false);
+
+        CoordinatorRequestManager realCoordinatorRequestManager = new CoordinatorRequestManager(
+            logContext, DEFAULT_RETRY_BACKOFF_MS, DEFAULT_RETRY_BACKOFF_MAX_MS, DEFAULT_GROUP_ID);
+
+        // The member wants to join, but its heartbeat interval is still zero (unknown until the
+        // first heartbeat response).
+        createHeartbeatRequestStateWithZeroHeartbeatInterval();
+        when(membershipManager.state()).thenReturn(MemberState.JOINING);
+        when(membershipManager.shouldHeartbeatNow()).thenReturn(true);
+        ConsumerHeartbeatRequestManager realHeartbeatRequestManager = createHeartbeatRequestManager(
+            realCoordinatorRequestManager,
+            membershipManager,
+            heartbeatState,
+            heartbeatRequestState,
+            backgroundEventHandler);
+
+        try (NetworkClientDelegate networkClientDelegate = new NetworkClientDelegate(time, config, logContext, networkClient,
+                consumerMetadata, mock(BackgroundEventHandler.class), false, mock(AsyncConsumerMetrics.class))
+        ) {
+            long deadline = time.milliseconds() + bootstrapResolveTimeoutMs + 3000;
+            boolean sawBootstrapException = false;
+
+            while (time.milliseconds() < deadline) {
+                // Drives the real NetworkClient's ensureBootstrapped()/async DNS resolution forward;
+                // the coordinator never becomes known since there is no real broker to respond.
+                networkClientDelegate.poll(50, time.milliseconds());
+
+                long waitMs = realHeartbeatRequestManager.maximumTimeToWait(time.milliseconds());
+                assertTrue(waitMs > 0, "maximumTimeToWait must be > 0 while real bootstrap DNS resolution is pending; got " + waitMs);
+
+                Optional<Exception> metadataError = networkClientDelegate.getAndClearMetadataError();
+                if (metadataError.isPresent()) {
+                    assertInstanceOf(BootstrapResolutionException.class, metadataError.get());
+                    sawBootstrapException = true;
+                    break;
+                }
+            }
+            assertTrue(sawBootstrapException, "Expected a real BootstrapResolutionException within " + (bootstrapResolveTimeoutMs + 3000) + "ms");
+        }
     }
 
     @Test
diff --git a/clients/src/test/java/org/apache/kafka/clients/consumer/internals/ShareHeartbeatRequestManagerTest.java b/clients/src/test/java/org/apache/kafka/clients/consumer/internals/ShareHeartbeatRequestManagerTest.java
index 0f125f09dfb..b9ef2091652 100644
--- a/clients/src/test/java/org/apache/kafka/clients/consumer/internals/ShareHeartbeatRequestManagerTest.java
+++ b/clients/src/test/java/org/apache/kafka/clients/consumer/internals/ShareHeartbeatRequestManagerTest.java
@@ -164,7 +164,7 @@ public class ShareHeartbeatRequestManagerTest
     @Test
     public void testMaximumTimeToWaitWhenHeartbeatShouldBeSkippedDoesNotSpin() {
         when(coordinatorRequestManager.coordinator()).thenReturn(Optional.of(new Node(1, "localhost", 9999)));
-        when(membershipManager.state()).thenReturn(MemberState.FATAL);
+        when(membershipManager.state()).thenReturn(MemberState.FENCED);
         when(membershipManager.shouldSkipHeartbeat()).thenReturn(true);
         when(heartbeatRequestState.timeToNextHeartbeatMs(anyLong())).thenReturn(0L);
 
@@ -172,7 +172,38 @@ public class ShareHeartbeatRequestManagerTest
 
         assertTrue(result > 0,
             "maximumTimeToWait must be > 0 while heartbeats are skipped to avoid a busy-spin; got " + result);
-        assertEquals(DEFAULT_HEARTBEAT_INTERVAL_MS, result);
+        assertEquals(DEFAULT_RETRY_BACKOFF_MS, result);
+    }
+
+    @Test
+    public void testMaximumTimeToWaitWhenFatalReturnsMaxValue() {
+        when(coordinatorRequestManager.coordinator()).thenReturn(Optional.of(new Node(1, "localhost", 9999)));
+        when(membershipManager.state()).thenReturn(MemberState.FATAL);
+
+        assertEquals(Long.MAX_VALUE, heartbeatRequestManager.maximumTimeToWait(time.milliseconds()),
+            "maximumTimeToWait should return Long.MAX_VALUE in the terminal FATAL state");
+    }
+
+    /**
+     * While bootstrap DNS resolution is still in progress the coordinator is unknown,
+     * and a member that wants to join has a zero heartbeat interval, since the interval is only
+     * learned from the first heartbeat response. maximumTimeToWait() must wait a retry backoff
+     * rather than the (zero) heartbeat interval; returning 0 busy-spins the application and
+     * network threads.
+     */
+    @Test
+    public void testMaximumTimeToWaitWhenJoiningAndCoordinatorUnknownDoesNotSpin() {
+        createHeartbeatRequestStateWithZeroHeartbeatInterval();
+        when(coordinatorRequestManager.coordinator()).thenReturn(Optional.empty());
+        when(membershipManager.state()).thenReturn(MemberState.JOINING);
+        when(membershipManager.shouldHeartbeatNow()).thenReturn(true);
+
+        long result = heartbeatRequestManager.maximumTimeToWait(time.milliseconds());
+
+        assertTrue(result > 0,
+            "maximumTimeToWait must be > 0 while the member is joining and the coordinator is unknown " +
+                "to avoid a busy-spin; got " + result);
+        assertEquals(DEFAULT_RETRY_BACKOFF_MS, result);
     }
 
     @Test
diff --git a/clients/src/test/java/org/apache/kafka/clients/consumer/internals/StreamsGroupHeartbeatRequestManagerTest.java b/clients/src/test/java/org/apache/kafka/clients/consumer/internals/StreamsGroupHeartbeatRequestManagerTest.java
index 28f4df825ac..049d5ed0bc1 100644
--- a/clients/src/test/java/org/apache/kafka/clients/consumer/internals/StreamsGroupHeartbeatRequestManagerTest.java
+++ b/clients/src/test/java/org/apache/kafka/clients/consumer/internals/StreamsGroupHeartbeatRequestManagerTest.java
@@ -2577,11 +2577,15 @@ class StreamsGroupHeartbeatRequestManagerTest {
 
     @Test
     public void testMaximumTimeToWaitWhenCoordinatorUnknownDoesNotSpin() {
+        final long retryBackoffMs = 100L;
         try (
             final MockedConstruction<Timer> timerMockedConstruction = mockConstruction(Timer.class);
             final MockedConstruction<HeartbeatRequestState> heartbeatRequestStateMockedConstruction = mockConstruction(
                 HeartbeatRequestState.class,
-                (mock, context) -> when(mock.heartbeatIntervalMs()).thenReturn(6000L))
+                (mock, context) -> {
+                    when(mock.heartbeatIntervalMs()).thenReturn(0L);
+                    when(mock.retryBackoffMs()).thenReturn(retryBackoffMs);
+                })
         ) {
             final StreamsGroupHeartbeatRequestManager heartbeatRequestManager = createStreamsGroupHeartbeatRequestManager();
             when(coordinatorRequestManager.coordinator()).thenReturn(Optional.empty());
@@ -2589,7 +2593,7 @@ class StreamsGroupHeartbeatRequestManagerTest {
 
             final long maximumTimeToWait = heartbeatRequestManager.maximumTimeToWait(time.milliseconds());
 
-            assertEquals(6000L, maximumTimeToWait);
+            assertEquals(retryBackoffMs, maximumTimeToWait);
         }
     }