JedisCluster throws "No reachable node in cluster" with zero suppressed exceptions - race condition in cluster cache

[aditya-baldwa]

Environment

• Jedis Version: 5.1.0
• Java Version: OpenJDK 17
• Redis Version: 8.0.0 with RediSearch

Problem Description

Under concurrent load, JedisCluster intermittently throws:

redis.clients.jedis.exceptions.JedisClusterOperationException: No reachable node in cluster.
    at redis.clients.jedis.providers.ClusterConnectionProvider.getConnection(ClusterConnectionProvider.java:135)

Critical observation: The exception has zero suppressed exceptions (e.getSuppressed().length == 0), indicating no connection attempt was made.

Evidence

Cluster Is Healthy and Reachable at Startup as well as when checked with CLI

1. Error Has Zero Suppressed Exceptions
   We added logging to capture suppressed exceptions:

catch (Exception e) {
    log.error("Failed: {}", e.getMessage());
    for (Throwable t : e.getSuppressed()) {
        log.error("  Cause: {}", t.getMessage());   // Never printed
    }
    throw e;
}

Output:
ERROR | Failed: No reachable node in cluster.
No "Cause:" line is ever printed, confirming e.getSuppressed() returns an empty array.

2. Verified Network Connectivity
   Ran redis-cli -c from application host → 100% success. Network is healthy. All nodes reachable.

3. Verified JedisCluster Discovers All Nodes
   At startup, JedisCluster successfully connects to all nodes and executes commands. The issue only occurs under concurrent load.

4. redis-cli Works 100%

5. JedisCluster Fails ~50%
   Same 50 concurrent requests has different success rate

Steps to Reproduce

1. Set up a Redis Cluster (3+ masters with replicas)
2. Configure JedisCluster with moderate pool size (maxTotal=10)
3. Send 50+ concurrent requests
4. Observe intermittent "No reachable node in cluster" errors
5. Check that e.getSuppressed() returns empty array
6. Compare with redis-cli -c running same concurrent test (100% success)

Root Cause Analysis

Looking at File src/main/java/redis/clients/jedis/providers/ClusterConnectionProvider.java:

public Connection getConnection() {
    List<ConnectionPool> pools = this.cache.getShuffledNodesPool();  // ← Returns EMPTY
    JedisException suppressed = null;
    
    while(var3.hasNext()) {  // Never executes if pools is empty
        ConnectionPool pool = (ConnectionPool)var3.next();
        try {
            jedis = pool.getResource();
            if (jedis != null) {
                jedis.ping();
                return jedis;
            }
        } catch (JedisException ex) {
            if (suppressed == null) {
                suppressed = ex;
            }
        }
    }
    
    // suppressed is still null because loop never ran
    JedisClusterOperationException noReachableNode = 
        new JedisClusterOperationException("No reachable node in cluster.");
    if (suppressed != null) {  // False - nothing to add
        noReachableNode.addSuppressed(suppressed);
    }
    throw noReachableNode;
}

Why getShuffledNodesPool() Returns Empty

The cluster node cache appears to have a race condition during refresh:

Timeline:
─────────────────────────────────────
Thread A (cache refresh):     cache.clear() → [fetch nodes] → cache.populate()
                                  ↑
Thread B (request):           getShuffledNodesPool() → EMPTY → throw error
─────────────────────────────────────

During the brief window when the cache is cleared but not yet repopulated:

1. getShuffledNodesPool() returns an empty list
2. The while loop never executes
3. Suppressed remains null
4. Exception is thrown with no suppressed exceptions
5. Error message says "No reachable node" even though no connection was attempted

Suggested Fix

Option 1: Atomic cache refresh (copy-on-write)

// Build entirely new cache while old cache still serves requests
Map<String, ConnectionPool> newNodes = discoverClusterNodes();

// Single reference swap - atomic
this.nodesCache = newNodes;

// No window where cache is empty

Option 2: Retry if pool list is empty

List<ConnectionPool> pools = this.cache.getShuffledNodesPool();
if (pools.isEmpty()) {
    Thread.sleep(50);  // Brief wait for cache refresh
    pools = this.cache.getShuffledNodesPool();
}

Impact

• Applications using JedisCluster experience intermittent failures under concurrent load
• Error message is misleading ("no reachable node" suggests network/cluster issues when the real cause is internal cache state)
• Debugging is difficult because suppressed exceptions are empty

Workaround

Require application-level retry logic

Questions

1. Is the cluster cache refresh designed to be atomic?
2. Is there a known race condition in ClusterNodesCache?
3. Would you accept a PR implementing copy-on-write for the cache refresh?

[ggivo]

@aditya-baldwa
Thanks for the comprehensive description.

Is the cluster cache refresh designed to be atomic?

Yes, the current design assumes atomic cache refresh.

Is there a known race condition in ClusterNodesCache?

There might be, but I'm not currently aware of such issues.

Would you accept a PR implementing copy-on-write for the cache refresh?

Looking at the code, I'm not sure the identified concurrency issue is the root cause. There's already a synchronization mechanism based on read/write locking that should prevent reading an empty node list while it's being refreshed.

In JedisClusterInfoCache.java:

private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
private final Lock r = rwl.readLock();
private final Lock w = rwl.writeLock();

The reset() method (which clears the nodes cache) is called within write lock protection, and any read operations must acquire the read lock (r.lock()), ensuring they cannot proceed while the cache is being cleared/updated.

See: reset() and getShuffledNodesPool()

I think as a first step we need:

1. A minimal code example that can reproduce the issue
2. A unit test demonstrating the concurrency problem

[aditya-baldwa]

@ggivo Thank you for the detailed explanation about the read/write locking mechanism. You're right - I can see the synchronization in JedisClusterInfoCache.java

Given this, I'm puzzled about what could cause getClusterNodes().size() to return 0 during the error.

We connect to Redis Cluster through a load balancer URL (single host:port that routes to cluster nodes):

Set<HostAndPort> clusterNodes = new HashSet<>();
clusterNodes.add(HostAndPort.from("redis-cluster-lb:6379"));

this.jedisCluster = new JedisCluster(
        clusterNodes,
        clientConfig,
        5,  // maxAttempts
        poolConfig
);

I'm sharing some code snippets, I can't share the exact code as it is used in our company.

1. Connection Initialization

@Repository
public class RedisDataStore {

    // UnifiedJedis for RediSearch operations (ftSearch, ftList, etc.)
    private UnifiedJedis unifiedJedis;

    // JedisCluster for cluster-specific operations (getClusterNodes, scan, etc.)
    private JedisCluster jedisCluster;

    @Value("${redis.cluster.nodes:}")
    private String clusterNodes;

    @Value("${redis.password}")
    private String password;

    @Value("${redis.timeout:2000}")
    private int timeout;

    @Value("${redis.pool.maxTotal:10}")
    private int maxTotal;

    @Value("${redis.pool.maxIdle:5}")
    private int maxIdle;

    @Value("${redis.pool.minIdle:1}")
    private int minIdle;

    @Value("${redis.pool.testWhileIdle:true}")
    private boolean testWhileIdle;

    @Value("${redis.pool.minEvictableIdleTime:60000}")
    private int minEvictableIdleTime;

    @Value("${redis.pool.timeBetweenEvictionRuns:30000}")
    private int timeBetweenEvictionRuns;

    @PostConstruct
    public void init() {
        ConnectionPoolConfig poolConfig = new ConnectionPoolConfig();
        poolConfig.setMaxTotal(maxTotal);
        poolConfig.setMaxIdle(maxIdle);
        poolConfig.setMinIdle(minIdle);
        poolConfig.setTestWhileIdle(testWhileIdle);
        poolConfig.setMinEvictableIdleTime(Duration.ofMillis(minEvictableIdleTime));
        poolConfig.setTimeBetweenEvictionRuns(Duration.ofMillis(timeBetweenEvictionRuns));

        Set<HostAndPort> nodes = parseClusterNodes(clusterNodes);

        DefaultJedisClientConfig clientConfig = DefaultJedisClientConfig.builder()
                .timeoutMillis(timeout)
                .password(password)
                .build();

        // Initialize JedisCluster
        this.jedisCluster = new JedisCluster(
                nodes,
                clientConfig,
                5,  // maxAttempts
                poolConfig
        );

        // JedisCluster extends UnifiedJedis, assign to unified reference
        this.unifiedJedis = this.jedisCluster;
    }

    private Set<HostAndPort> parseClusterNodes(String nodesString) {
        Set<HostAndPort> nodes = new HashSet<>();
        if (nodesString == null || nodesString.trim().isEmpty()) {
            return nodes;
        }
        for (String node : nodesString.split(",")) {
            node = node.trim();
            if (!node.isEmpty()) {
                nodes.add(HostAndPort.from(node));
            }
        }
        return nodes;
    }

    public UnifiedJedis getUnifiedJedis() {
        return unifiedJedis;
    }

    public JedisCluster getJedisCluster() {
        return jedisCluster;
    }
}

2. Search Service Usage

@Service
public class SearchService {

    private UnifiedJedis unifiedJedis;
    private JedisCluster jedisCluster;

    @Autowired
    private RedisDataStore redisDataStore;

    @PostConstruct
    public void init() {
        this.unifiedJedis = redisDataStore.getUnifiedJedis();
        this.jedisCluster = redisDataStore.getJedisCluster();
    }

    public SearchResult search(String indexName, Query query) {
        // Uses UnifiedJedis for RediSearch
        // This call intermittently throws "No reachable node in cluster"
        return unifiedJedis.ftSearch(indexName, query);
    }

    public void loadIndexes() {
        // Uses JedisCluster for cluster-specific operations
        Map<String, ConnectionPool> clusterNodes = jedisCluster.getClusterNodes();
        
        for (Map.Entry<String, ConnectionPool> entry : clusterNodes.entrySet()) {
            try (Connection conn = entry.getValue().getResource()) {
                // Load indexes from each node
                conn.sendCommand(Command.LIST);
                // ...
            }
        }
    }
}

Question -

1. Is this a valid way to initialize JedisCluster connection pool and use it for RediSearch operations?
   If not can you guide me to correct way to do it

2. Are there recommended pool settings for cluster mode under concurrent load?

[ggivo]

@aditya-baldwa

We connect to Redis Cluster through a load balancer URL (single host:port that routes to cluster nodes):

It's not clear what your deployment and load balancer configuration looks like and what is used for, but it might be a source of the problem.
How JedisCluster Node Resolution Works

• The nodes you provide to the JedisCluster constructor are seed nodes
• JedisCluster only needs one working seed node to discover the entire cluster
• JedisCluster connects to the seed node and executes CLUSTER SLOTS command
• This returns the complete cluster topology: which nodes handle which hash slots
• JedisCluster then creates direct connections to all discovered nodes
• CLUSTER SLOTS returns the actual cluster node addresses as reported by Redis
• JedisCluster needs direct connectivity to all nodes returned by the CLUSTER SLOTS command, not just the initial seed nodes
  If your deployment prevents access to the discovered cluster nodes, this might cause "No reachable node in cluster" errors.

[aditya-baldwa]

@ggivo Thank you for the explanation about JedisCluster node resolution.

Load balancer doesn't seem to be the issue:
The load balancer simply routes to master nodes. To verify this, we tested by passing the node IPs directly instead of the load balancer:

Set<HostAndPort> nodes = new HashSet<>();
nodes.add(HostAndPort.from("192.xxx.xx.xxx:6379"));
nodes.add(HostAndPort.from("192.xxx.xx.xxx:6379"));
nodes.add(HostAndPort.from("192.xxx.xx.xxx:6379"));

this.jedisCluster = new JedisCluster(nodes, clientConfig, 5, poolConfig);

Result: Same intermittent failures.

If it was a load balancer or network routing issue, we would expect consistent failures. But the issue is intermittent

Our observation during failure:

jedisCluster.getClusterNodes().size()  // Returns 0
e.getSuppressed().length               // Returns 0

The cluster nodes map appears empty during failure, even though the nodes are reachable.

During parallel/concurrent access, when topology refreshes, is there a brief period where the nodes map could be empty? Could a concurrent read hit that window before the map is repopulated?

[ggivo]

@aditya-baldwa

1. Just saw that the above code example uses sendCommand, which will not consume the output from the command, and if not consumed when the connection is returned to the pool, subsequently issued commands with the same connection will fail.

            try (Connection conn = entry.getValue().getResource()) {
                // Load indexes from each node
                conn.sendCommand(Command.LIST);
                // ...
            }

Also, what does Command.LIST refers to?

2. Note also that with Redis 8.0, ft.create must be issued to a single cluster node, and not to all nodes in the cluster.

3. Adding a code example I used in my environment to try to reproduce the issue. If still having issues feel free to modify it acordingly to reproduce it!

Click to expand code

import redis.clients.jedis.ClusterCommandObjects;
import redis.clients.jedis.CommandObject;
import redis.clients.jedis.CommandObjects;
import redis.clients.jedis.Connection;
import redis.clients.jedis.ConnectionPool;
import redis.clients.jedis.ConnectionPoolConfig;
import redis.clients.jedis.DefaultJedisClientConfig;
import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.Protocol;
import redis.clients.jedis.exceptions.JedisBroadcastException;
import redis.clients.jedis.search.IndexDefinition;
import redis.clients.jedis.search.IndexOptions;
import redis.clients.jedis.search.Schema;
import redis.clients.jedis.search.SearchResult;

import java.time.Duration;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

class ClusterTopologyRefreshEmptyNodesTestApp {

    private final int numThreads = 50;

    ExecutorService executor;

    public static void main(String[] args) {

        ClusterTopologyRefreshEmptyNodesTestApp app = new ClusterTopologyRefreshEmptyNodesTestApp();

        app.run();
         }

    ClusterTopologyRefreshEmptyNodesTestApp() {
        executor = Executors.newFixedThreadPool(numThreads);
    }

    public void run() {
        JedisCluster jedisCluster = createClusterClient();

        // uncommenting this line will cause the app to fail
        // sendCommandWithoutReadingTheOutput(jedisCluster);

        loadIndexes(jedisCluster);

        submitConcurrentRequests(jedisCluster,  numThreads,     1);

        awaitCompletion();
    }

    private JedisCluster createClusterClient(){
        ConnectionPoolConfig poolConfig = new ConnectionPoolConfig();
        poolConfig.setMaxTotal(10);
        poolConfig.setMaxIdle(5);
        poolConfig.setMinIdle(1);
        poolConfig.setTestWhileIdle(true);
        poolConfig.setMinEvictableIdleTime(Duration.ofMillis(60000));
        poolConfig.setTimeBetweenEvictionRuns(Duration.ofMillis(30000));

        Set<HostAndPort> nodes = new HashSet<>();
        nodes.add(HostAndPort.from("localhost:6379"));
        //nodes.add(HostAndPort.from("localhost:6380"));
        //nodes.add(HostAndPort.from("localhost:6381"));


        DefaultJedisClientConfig clientConfig = DefaultJedisClientConfig.builder()
                .timeoutMillis(2000)
                .build();

        // Initialize JedisCluster
        JedisCluster jedisCluster = new JedisCluster(
                nodes,
                clientConfig,
                5,  // maxAttempts
                poolConfig
        );

        return jedisCluster;
    }

    private void awaitCompletion(){
        // Shutdown executor and await completion
        executor.shutdown();
        try {
            if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                executor.shutdownNow();
                if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                    System.err.println("Executor did not terminate");
                }
            }
            System.out.println("All tasks completed");
        } catch (InterruptedException e) {
            executor.shutdownNow();
            Thread.currentThread().interrupt();
            System.err.println("Interrupted while waiting for tasks to complete");
        }
    }

    private void submitConcurrentRequests(JedisCluster jedisCluster, int numThreads, int numRequests) {
            for (int i = 0; i < numThreads; i++) {
                final int threadId = i;
                executor.submit(() -> {
                    try {
                        for (int j = 0; j < numRequests; j++) {
                            search(jedisCluster);
                            //System.out.println(Thread.currentThread().getName() + ": Request " + requestId + " set and get " + value);
                        }
                    } catch (Exception e) {
                        System.err.println(Thread.currentThread().getName() + ":  Request error: " + e.getMessage());
                    }
                });
            }
    }



    void loadIndexes(JedisCluster jedisCluster) {
        // Load indexes
        Schema sc = new Schema().addTextField("title", 1.0);
        IndexDefinition rule = new IndexDefinition()
                .setPrefixes(new String[]{"book:details"});



        try {
            jedisCluster.ftDropIndex("books-idx");
        } catch (Exception e) {
            // Ignore
        }
        try {
            System.out.println("Creating index...");
            // With Redis 8.0 ftCreate need to be executed on a single node
            // Using jedisCluster.ftCreate broadcasts command to all nodes and will throw an exception that index already exists
            // Unless we use RedisSearch.Light mode which will send the command to a single node based on used index name
            //
//            try {
//                jedisCluster.ftCreate("person-index", IndexOptions.defaultOptions().setDefinition(rule), sc);
//            } catch (JedisBroadcastException e) {
//                JedisBroadcastException bcastError = e;
//                bcastError.getReplies().forEach((node, reply) -> {
//                    System.err.println("Node " + node + " reply: " + reply);
//                });
//                System.err.println("Error creating index: " + e.getMessage());
//            }
            // workaround to send command to single node
            CommandObjects cmd = new ClusterCommandObjects();
            CommandObject<String>  createIndexCmd = cmd.ftCreate("books-idx", IndexOptions.defaultOptions().setDefinition(rule), sc);
            jedisCluster.executeCommand(createIndexCmd);

        } catch (JedisBroadcastException e) {
            System.err.println("Error creating index: " + e.getMessage());
            JedisBroadcastException bcastError = e;
            bcastError.getReplies().forEach((node, reply) -> {
                System.err.println("Node " + node + " reply: " + reply);
            });
            throw e;
        }

        populateData(jedisCluster);
    }

    void populateData(JedisCluster jedisCluster) {
        jedisCluster.hset("book:details:1", toMap("title", "1"));
        jedisCluster.hset("book:details:2", toMap("title", "2"));
        jedisCluster.hset("book:details:3", toMap("title", "3"));
        jedisCluster.hset("book:details:4", toMap("title", "4"));
        jedisCluster.hset("book:details:5", toMap("title", "5"));
    }

    void search(JedisCluster jedisCluster) {
        try {
            SearchResult result = jedisCluster.ftSearch("books-idx", "@title:1 | @title:2 | @title:3 ");
            System.out.println("Found : " + result.getTotalResults());
            //System.out.println("Search result: " + result);
        } catch (JedisBroadcastException e) {
            System.err.println("Error searching: " + e.getMessage());
            JedisBroadcastException bcastError = e;
            bcastError.getReplies().forEach((node, reply) -> {
                System.err.println("Node " + node + " reply: " + reply);
            });
            throw e;
        }
    }


    private  void sendCommandWithoutReadingTheOutput(JedisCluster jedisCluster) {
        Map<String, ConnectionPool> clusterNodes = jedisCluster.getClusterNodes();

        for (Map.Entry<String, ConnectionPool> entry : clusterNodes.entrySet()) {

            List<Connection> conns = new ArrayList<>();
            for (int i = 0; i < 1; i++) {
                conns.add(entry.getValue().getResource());
            }

            for (Connection conn : conns) {
                conn.sendCommand(Protocol.Command.INFO);
            }

            for (Connection conn : conns) {
                conn.close();
            }
        }
    }

    private static Map<String, String> toMap(String... values) {
        Map<String, String> map = new HashMap<>();
        for (int i = 0; i < values.length; i += 2) {
            map.put(values[i], values[i + 1]);
        }
        return map;
    }
}

[aditya-baldwa]

@ggivo Great catch here on sendCommand !!

Let me address your points:

1. As suggested by you, this can cause issue. We have refactored our code. We're no longer using sendCommand directly. We have migrated everything towards unifiedJedis now. Our current implementation uses the proper API methods:

// Current approach - using proper Jedis API
Set<String> indexList = unifiedJedis.ftList();
Map<String, Object> ftInfo = unifiedJedis.ftInfo(indexName);
SearchResult result = unifiedJedis.ftSearch(indexName, query);

2. Regarding Command.LIST:
   It was used to call FT._LIST. We've replaced it with unifiedJedis.ftList()

3. Current Situation:
   After the refactoring, we're still experiencing intermittent "No reachable node in cluster"
   The error is intermittent - most requests succeed
   We've implemented application-level retry logic as well to give it a try, but no luck there as well.

4. The current code after refactoring

Click to expand code block

/**
 * =============================================================================
 * Redis Cluster - Intermittent "No reachable node" Issue
 * Jedis Version: 5.1.0
 * Java Version: 17
 * Spring Boot: 3.x
 * =============================================================================
 */

import jakarta.annotation.PostConstruct;
import jakarta.annotation.PreDestroy;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Repository;
import redis.clients.jedis.*;
import redis.clients.jedis.search.*;
import java.time.Duration;
import java.util.*;

@Repository
public class RedisClusterDataStore {

    private UnifiedJedis unifiedJedis;

    @PostConstruct
    public void init() {
        ConnectionPoolConfig poolConfig = new ConnectionPoolConfig();
        poolConfig.setMaxTotal(10);
        poolConfig.setMaxIdle(5);
        poolConfig.setMinIdle(1);
        poolConfig.setTestWhileIdle(true);
        poolConfig.setMinEvictableIdleTime(Duration.ofMillis(60000));
        poolConfig.setTimeBetweenEvictionRuns(Duration.ofMillis(30000));

        Set<HostAndPort> nodes = new HashSet<>();
        nodes.add(HostAndPort.from("localhost:6379"));
        nodes.add(HostAndPort.from("localhost:6380"));
        nodes.add(HostAndPort.from("localhost:6381"));

        DefaultJedisClientConfig clientConfig = DefaultJedisClientConfig.builder()
                .connectionTimeoutMillis(2000)
                .socketTimeoutMillis(2000)
                .password("password")
                .build();

        // JedisCluster extends UnifiedJedis
        this.unifiedJedis = new JedisCluster(
                nodes,
                clientConfig,
                5,  // maxAttempts
                poolConfig
        );

        System.out.println("Redis Cluster initialized with nodes: " + nodes);
    }

    @PreDestroy
    public void destroy() {
        if (unifiedJedis != null) {
            unifiedJedis.close();
        }
    }

    public UnifiedJedis getUnifiedJedis() {
        return unifiedJedis;
    }
}

// =============================================================================

import jakarta.annotation.PostConstruct;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import redis.clients.jedis.*;
import redis.clients.jedis.search.*;
import java.util.*;

@Component
public class RedisService {

    private UnifiedJedis unifiedJedis;

    @Autowired
    private RedisClusterDataStore dataStore;

    @PostConstruct
    public void init() {
        this.unifiedJedis = dataStore.getUnifiedJedis();
        loadIndexes();
    }

    public void loadIndexes() {
        // Using proper API - NOT sendCommand
        Set<String> indexes = unifiedJedis.ftList();
        System.out.println("Found " + indexes.size() + " indexes");

        for (String indexName : indexes) {
            try {
                Map<String, Object> info = unifiedJedis.ftInfo(indexName);
                System.out.println("Loaded: " + indexName);
            } catch (Exception e) {
                System.err.println("Failed: " + indexName + " - " + e.getMessage());
            }
        }
    }

    public SearchResult search(String indexName, String queryString) {
        Query query = new Query(queryString).limit(0, 100);
        
        // Using proper API - NOT sendCommand
        return unifiedJedis.ftSearch(indexName, query);
    }
}

/*
 * Note: Most requests succeed. Error occurs intermittently.
 * No reachable node in cluster. JedisClusterOperationException
 */

5. I'm attaching stack trace too for reference (Note: Jedis version 5.1.0)

Caused by: redis.clients.jedis.exceptions.JedisClusterOperationException: No reachable node in cluster.
	at redis.clients.jedis.providers.ClusterConnectionProvider.getConnection(ClusterConnectionProvider.java:135)
	at redis.clients.jedis.providers.ClusterConnectionProvider.getConnection(ClusterConnectionProvider.java:102)
	at redis.clients.jedis.executors.ClusterCommandExecutor.executeCommand(ClusterCommandExecutor.java:90)
	at redis.clients.jedis.UnifiedJedis.executeCommand(UnifiedJedis.java:250)
	at redis.clients.jedis.UnifiedJedis.ftSearch(UnifiedJedis.java:3702) 

6. We're running this in a Kubernetes environment:

• Multiple pods of the same service (3-5 replicas)
• Each pod initializes its own JedisCluster instance on startup
• Incoming API requests are load-balanced to random pods
• All pods connect to the same Redis Cluster

Just a thought, Could this multi-instance setup affect the cluster topology discovery? Perhaps multiple JedisCluster instances refreshing topology simultaneously could cause contention?