How long does it normally take to establish a connection?

[y2241]

I have found that this block code typically takes between 1.3 seconds and 1.7 seconds in our environment when the load is very LOW.
public <K, V> StatefulRedisConnection<K, V> connect(RedisCodec<K, V> codec) {

    checkForRedisURI();

    return getConnection(connectStandaloneAsync(codec, this.redisURI, getDefaultTimeout()));
}

I wonder how long it is supposed to be, like 300 ms, 1000 ms? Is our 1.7 seconds is abnormally high? We are using Lettuce client 6.2 final and the server is aws redis.
What this code does to use so much time? And anyway to improve it?

[mp911de]

What scope and what warming state are you measuring? If you have a pre-initialized RedisClient, then connection creation should take not significantly longer than the latency required for the handshake.

[y2241]

Thanks Mark. Here is how we create and config our Lettuce client object:
RedisClient client = RedisClient.create(buildClientResources(), uri);
ClientResources.Builder builder = DefaultClientResources.builder();

where buildClientResources() is:

builder.commandLatencyRecorder(new DefaultCommandLatencyCollector(DefaultCommandLatencyCollectorOptions.builder()
.resetLatenciesAfterEvent(true)
.enable()
.targetUnit(MILLISECONDS)
.build()))
.commandLatencyPublisherOptions(DefaultEventPublisherOptions.builder().eventEmitInterval(ofMinutes(1)).build();

    builder.reconnectDelay(Delay.exponential(0, 2000, MILLISECONDS, 2));
    return builder.ioThreadPoolSize(1).build();

Then client set its options:
client.setOptions(clientOptions);

This is how we build clientOptions:
return builder()
.autoReconnect(true)
.cancelCommandsOnReconnectFailure(true)
.disconnectedBehavior(ClientOptions.DisconnectedBehavior.REJECT_COMMANDS)
.pingBeforeActivateConnection(true)
.requestQueueSize(1000) //Designates how many individual commands can be sent on a single connection
.socketOptions(socketOptions)
.build();

This is how we build socketOptions:
SocketOptions.builder()
.connectTimeout(Duration.ofSeconds(2))
.keepAlive(true)
.build();

After the client object is created, we reuse it to create a connection:
if (!isConnectionActive()) {
logger.info("getConnection() Establishing a new connection to {} ", redisURI);

                StopWatch stopWatch = new StopWatch();
                stopWatch.start();
                redisConnection = client.connect();
                stopWatch.stop();
              
                logger.info("Established new connection  getConnection(), getConnection() execution time  {} ms", (stopWatch.getTime(MILLISECONDS)));
            }

We use stopWatch to measure how long it takes for the client.connect() to finish. It normally takes 1.3-1.7 seconds but sometimes could be as high as 2.0 seconds.

public boolean isConnectionActive() { //we reuse the same connection
return redisConnection != null && redisConnection.isOpen();
}

Anything wrong here or anything to improve? This is running inside a lambda function, so once the lambda is triggered by an event, this is to run immediately. I meant that right after the client is built, it is used to create a connection and then the connection is put into use immediately for uploading lua scripts and running those lua scripts.