SocketTimeoutException intermitente com elasticsearch-rest-client-7.2.0

Estou usando o RestHighLevelClient versão 7.2 para me conectar ao cluster ElasticSearch versão 7.2. Meu cluster tem 3 nós principais e 2 nós de dados. Configuração de memória do nó de dados: 2 núcleos e 8 GB. Eu costumava usar o código abaixo em meu projeto de boot de primavera para criar a instância RestHighLevelClient.

 @Bean(destroyMethod = "close")
    @Qualifier("readClient")
    public RestHighLevelClient readClient(){

        final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        credentialsProvider.setCredentials(AuthScope.ANY,
                new UsernamePasswordCredentials(elasticUser, elasticPass));

        RestClientBuilder builder = RestClient.builder(new HttpHost(elasticHost, elasticPort))
                .setHttpClientConfigCallback(httpClientBuilder ->httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider).setDefaultIOReactorConfig(IOReactorConfig.custom().setIoThreadCount(5).build()));

        builder.setRequestConfigCallback(requestConfigBuilder -> requestConfigBuilder.setConnectTimeout(30000).setSocketTimeout(60000)
                );

        RestHighLevelClient restClient = new RestHighLevelClient(builder);
        return restClient;
    }

RestHighLevelClient é um singleton bean. Intermitentemente, estou recebendo SocketTimeoutException com a solicitação GET e PUT. O tamanho do índice é de cerca de 50 MB. Eu tentei aumentar o valor de tempo limite do soquete, mas ainda recebo o mesmo erro. Estou faltando alguma configuração? Qualquer ajuda seria apreciada.

Eu entendi o problema só queria compartilhar para que possa ajudar outras pessoas. Eu estava usando o Load Balancer para se conectar ao ElasticSerach Cluster. Como você pode ver no meu código RestClientBuilder, eu estava usando apenas o host e a porta do balanceador de carga. Embora eu tenha vários nós mestre, o RestClient ainda não estava tentando novamente minha solicitação no caso de tempo limite de conexão.

RestClientBuilder builder = RestClient.builder(new HttpHost(elasticHost, elasticPort))
                .setHttpClientConfigCallback(httpClientBuilder ->httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider).setDefaultIOReactorConfig(IOReactorConfig.custom().setIoThreadCount(5).build()));

De acordo com o código RestClient, se usarmos um único host, ele não tentará novamente em caso de qualquer problema de conexão. Então mudei meu código conforme abaixo e ele começou a funcionar.

RestClientBuilder builder = RestClient.builder(new HttpHost(elasticHost, 9200),new HttpHost(elasticHost, 9201))).setHttpClientConfigCallback(httpClientBuilder -> httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider));

Para o código RestClient completo, consulte https://github.com/elastic/elasticsearch/blob/master/client/rest/src/main/java/org/elasticsearch/client/RestClient.java

Repita o bloco de código em RestClient

private Response performRequest(final NodeTuple<Iterator<Node>> nodeTuple,
                                    final InternalRequest request,
                                    Exception previousException) throws IOException {
        RequestContext context = request.createContextForNextAttempt(nodeTuple.nodes.next(), nodeTuple.authCache);
        HttpResponse httpResponse;
        try {
            httpResponse = client.execute(context.requestProducer, context.asyncResponseConsumer, context.context, null).get();
        } catch(Exception e) {
            RequestLogger.logFailedRequest(logger, request.httpRequest, context.node, e);
            onFailure(context.node);
            Exception cause = extractAndWrapCause(e);
            addSuppressedException(previousException, cause);
            if (nodeTuple.nodes.hasNext()) {
                return performRequest(nodeTuple, request, cause);
            }
            if (cause instanceof IOException) {
                throw (IOException) cause;
            }
            if (cause instanceof RuntimeException) {
                throw (RuntimeException) cause;
            }
            throw new IllegalStateException("unexpected exception type: must be either RuntimeException or IOException", cause);
        }
        ResponseOrResponseException responseOrResponseException = convertResponse(request, context.node, httpResponse);
        if (responseOrResponseException.responseException == null) {
            return responseOrResponseException.response;
        }
        addSuppressedException(previousException, responseOrResponseException.responseException);
        if (nodeTuple.nodes.hasNext()) {
            return performRequest(nodeTuple, request, responseOrResponseException.responseException);
        }
        throw responseOrResponseException.responseException;
    }

Estou enfrentando o mesmo problema e, vendo isso, percebi que a nova tentativa está acontecendo do meu lado também em cada host (tenho 3 hosts e a exceção acontece em 3 threads). Eu queria postá-lo, pois você pode enfrentar o mesmo problema ou outra pessoa pode vir a este post por causa da mesma exceção SocketConnection.

Pesquisando os documentos oficiais, o HighLevelRestClient usa sob o capô RestClient, e o RestClient usa CloseableHttpAsyncClient que tem um pool de conexão. ElasticSearch especifica que você deve fechar a conexão assim que terminar, (o que parece ambíguo a definição de "concluído" em um aplicativo), mas em geral, na Internet, descobri que você deve fechá-la quando o aplicativo estiver fechando ou terminando, em vez de quando você terminou de consultar.

Agora na documentação oficial do apache eles têm um exemplo para lidar com o pool de conexão, que estou tentando seguir, vou tentar replicar o cenário e postarei se isso corrige meu problema, o código pode ser encontrado aqui:

https://hc.apache.org/httpcomponents-asyncclient-dev/httpasyncclient/examples/org/apache/http/examples/nio/client/AsyncClientEvictExpiredConnections.java

Isso é o que eu tenho até agora:

@Bean(name = "RestHighLevelClientWithCredentials", destroyMethod = "close")
public RestHighLevelClient elasticsearchClient(ElasticSearchClientConfiguration elasticSearchClientConfiguration,
                                               RestClientBuilder.HttpClientConfigCallback httpClientConfigCallback) {
    return new RestHighLevelClient(
            RestClient
                    .builder(getElasticSearchHosts(elasticSearchClientConfiguration))
                    .setHttpClientConfigCallback(httpClientConfigCallback)
    );
}

@Bean
@RefreshScope
public RestClientBuilder.HttpClientConfigCallback getHttpClientConfigCallback(
        PoolingNHttpClientConnectionManager poolingNHttpClientConnectionManager,
        CredentialsProvider credentialsProvider
) {
    return httpAsyncClientBuilder -> {
        httpAsyncClientBuilder.setSSLHostnameVerifier(NoopHostnameVerifier.INSTANCE);
        httpAsyncClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
        httpAsyncClientBuilder.setConnectionManager(poolingNHttpClientConnectionManager);
        return httpAsyncClientBuilder;
    };
}

public class ElasticSearchClientManager {

private ElasticSearchClientManager.IdleConnectionEvictor idleConnectionEvictor;

/**
 * Custom client connection manager to create a connection watcher
 *
 * @param elasticSearchClientConfiguration elasticSearchClientConfiguration
 * @return PoolingNHttpClientConnectionManager
 */
@Bean
@RefreshScope
public PoolingNHttpClientConnectionManager getPoolingNHttpClientConnectionManager(
        ElasticSearchClientConfiguration elasticSearchClientConfiguration
) {
    try {
        SSLIOSessionStrategy sslSessionStrategy = new SSLIOSessionStrategy(getTrustAllSSLContext());
        Registry<SchemeIOSessionStrategy> sessionStrategyRegistry = RegistryBuilder.<SchemeIOSessionStrategy>create()
                .register("http", NoopIOSessionStrategy.INSTANCE)
                .register("https", sslSessionStrategy)
                .build();
        ConnectingIOReactor ioReactor = new DefaultConnectingIOReactor();
        PoolingNHttpClientConnectionManager poolingNHttpClientConnectionManager =
                new PoolingNHttpClientConnectionManager(ioReactor, sessionStrategyRegistry);
        idleConnectionEvictor = new ElasticSearchClientManager.IdleConnectionEvictor(poolingNHttpClientConnectionManager,
                elasticSearchClientConfiguration);
        idleConnectionEvictor.start();
        return poolingNHttpClientConnectionManager;
    } catch (IOReactorException e) {
        throw new RuntimeException("Failed to create a watcher for the connection pool");
    }
}

private SSLContext getTrustAllSSLContext() {
    try {
        return new SSLContextBuilder()
                .loadTrustMaterial(null, (x509Certificates, string) -> true)
                .build();
    } catch (Exception e) {
        throw new RuntimeException("Failed to create SSL Context with open certificate", e);
    }
}

public IdleConnectionEvictor.State state() {
    return idleConnectionEvictor.evictorState;
}

@PreDestroy
private void finishManager() {
    idleConnectionEvictor.shutdown();
}


public static class IdleConnectionEvictor extends Thread {

    private final NHttpClientConnectionManager nhttpClientConnectionManager;
    private final ElasticSearchClientConfiguration elasticSearchClientConfiguration;

    @Getter
    private State evictorState;
    private volatile boolean shutdown;

    public IdleConnectionEvictor(NHttpClientConnectionManager nhttpClientConnectionManager,
                                 ElasticSearchClientConfiguration elasticSearchClientConfiguration) {
        super();
        this.nhttpClientConnectionManager = nhttpClientConnectionManager;
        this.elasticSearchClientConfiguration = elasticSearchClientConfiguration;
    }

    @Override
    public void run() {
        try {
            while (!shutdown) {
                synchronized (this) {
                    wait(elasticSearchClientConfiguration.getExpiredConnectionsCheckTime());
                    // Close expired connections
                    nhttpClientConnectionManager.closeExpiredConnections();
                    // Optionally, close connections
                    // that have been idle longer than 5 sec
                    nhttpClientConnectionManager.closeIdleConnections(elasticSearchClientConfiguration.getMaxTimeIdleConnections(),
                            TimeUnit.SECONDS);
                    this.evictorState = State.RUNNING;
                }
            }
        } catch (InterruptedException ex) {
            this.evictorState = State.NOT_RUNNING;
        }
    }

    private void shutdown() {
        shutdown = true;
        synchronized (this) {
            notifyAll();
        }
    }

    public enum State {
        RUNNING,
        NOT_RUNNING
    }
}

}