Rate limiting with redis

Question

I'm using elasticache redis for rate limit and use Redisson as the client, the related code is:

public CompletableFuture<List<Long>> incrementSingleKeys(
      List<String> keys, List<Long> increments, List<Long> ttls) {

    RBatch batch = redissonClient.createBatch(BatchOptions.defaults());

    for (int i = 0; i < keys.size(); i++) {
      batch.getAtomicLong(keys.get(i)).addAndGetAsync(increments.get(i));
    }
    return batch
        .executeAsync()
        .thenCompose(
            (counters) -> {
              List<String> keysToSet = Lists.newArrayList();
              List<Long> TTLsToSet = Lists.newArrayList();
              for (int i = 0; i < counters.size(); i++) {
                if (counters.get(i) == increments.get(i)) { // only set ttl for new keys
                  keysToSet.add(keys.get(i));
                  TTLsToSet.add(ttls.get(i));
                }
              }
              if (!keysToSet.isEmpty()) { // Call setTTLS
                return setTTLs(keysToSet, TTLsToSet)
                    .thenApply(
                        (r) -> counters
                    );
              } else {
                return CompletableFuture.completedFuture(counters);
              }
            });
  }

public CompletableFuture<List<Boolean>> setTTLs(List<String> keys, List<Long> TTLs) {
    CompletableFuture<List<Boolean>> future = new CompletableFuture<>();
    Stopwatch timer = Stopwatch.createStarted();
    RBatch batch = redissonClient.createBatch(BatchOptions.defaults());
    for (int i = 0; i < keys.size(); i++) {
      batch.getBucket(keys.get(i)).expireAsync(TTLs.get(i), TimeUnit.MILLISECONDS);
    }

    batch
        .executeAsync()
        .whenComplete(
            (list, ex) -> {
              if (ex != null) {
                future.complete(
                    Collections.nCopies(size, false);  // fail open
                )
              } else {
                future.complete(
                    list.stream()
                        .map(entry -> (entry instanceof Boolean ? (Boolean) entry : false))
                        .collect(Collectors.toList()),
                );
              }
            });
    return future;
}

Basically, I'll set ttl only for new keys. The issue is that sometimes the increment batch call is successful but setTTL call timeout, which results in a permanent key and could lead to incorrect rate limiting. One workaround is to always get and set ttl whenever increment happens, but this would affect the performance. Is there any other solution?