noderoster: configurable host cache size and eviction duration (#1246)

Author: benbroadaway

server/dist/src/main/resources/concord-server.conf

@@ -724,6 +724,15 @@ concord-server {
             # date/time of the first event that should be processed (ISO 8601 timestamp)
             # if partitioning is used then the value must be in the existing partition's range
             # startTimestamp = "2020-01-20T23:59:59.000Z"
+
+            # Host id cache size. Each element (hostname[String] + id[UUID]) is
+            # up-to 2072 bytes each, but usually in the 200-300 bytes range.
+            # 50,000 entries will use approx 10-15MB of heap or worst-case 98MB
+            # if all hostnames are max-length. A value of 0 disables caching.
+            hostCacheSize = 10000
+
+            # Duration to keep host IDs in cache after last access
+            hostCacheDuration = "1 hour"
         }
     }
 

server/plugins/noderoster/impl/src/main/java/com/walmartlabs/concord/server/plugins/noderoster/HostManager.java

@@ -20,34 +20,45 @@
  * =====
  */
 
-import com.google.common.cache.Cache;
 import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.LoadingCache;
+import com.walmartlabs.concord.server.plugins.noderoster.cfg.NodeRosterEventsConfiguration;
 import com.walmartlabs.concord.server.plugins.noderoster.dao.HostsDao;
 import com.walmartlabs.concord.server.sdk.metrics.WithTimer;
 
+import javax.annotation.Nonnull;
 import javax.inject.Inject;
 import javax.inject.Named;
+import javax.inject.Singleton;
 import java.util.Optional;
 import java.util.UUID;
-import java.util.concurrent.Callable;
-import java.util.concurrent.TimeUnit;
 
 @Named
+@Singleton
 public class HostManager {
 
     private final HostsDao dao;
     private final HostNormalizer hostNormalizer;
 
-    private final Cache<String, Optional<UUID>> hostCache;
+    private final LoadingCache<String, Optional<UUID>> hostCache;
 
     @Inject
-    public HostManager(HostsDao dao, HostNormalizer hostNormalizer) {
+    public HostManager(HostsDao dao, HostNormalizer hostNormalizer, NodeRosterEventsConfiguration cfg) {
         this.dao = dao;
         this.hostNormalizer = hostNormalizer;
 
         this.hostCache = CacheBuilder.newBuilder()
-                .expireAfterAccess(1, TimeUnit.MINUTES)
-                .build();
+                .expireAfterAccess(cfg.getHostCacheDuration())
+                .maximumSize(cfg.getHostCacheSize())
+                .recordStats()
+                .build(new CacheLoader<>() {
+                    @Override
+                    public @Nonnull Optional<UUID> load(@Nonnull String host) {
+                        UUID id = findHost(host);
+                        return Optional.ofNullable(id);
+                    }
+                });
     }
 
     @WithTimer
@@ -57,7 +68,7 @@ public UUID getId(UUID hostId, String host) {
         }
 
         try {
-            return hostCache.get(host, new GetLoader(host))
+            return hostCache.get(host)
                     .orElse(null);
         } catch (Exception e) {
             throw new RuntimeException(e);
@@ -67,69 +78,24 @@ public UUID getId(UUID hostId, String host) {
     @WithTimer
     public UUID getOrCreate(String host) {
         try {
-            return hostCache.get(host, new GetOrCreateLoader(host))
-                    .orElseThrow(() -> new RuntimeException("Can't find a host: " + host));
-        } catch (Exception e) {
-            throw new RuntimeException(e);
-        }
-    }
-
-    private Host findHost(String host) {
-        String normalizedHost = hostNormalizer.normalize(host);
-        UUID hostId = dao.getId(normalizedHost);
-        if (hostId != null) {
-            return new Host(hostId, normalizedHost);
-        }
-
-        return new Host(null, normalizedHost);
-    }
-
-    private static class Host {
-
-        private final UUID id;
-        private final String normalizedHost;
-
-        public Host(UUID id, String normalizedHost) {
-            this.id = id;
-            this.normalizedHost = normalizedHost;
-        }
-    }
+            Optional<UUID> knownHost = hostCache.get(host);
 
-    private final class GetLoader implements Callable<Optional<UUID>> {
-
-        private final String host;
-
-        private GetLoader(String host) {
-            this.host = host;
-        }
-
-        @Override
-        public Optional<UUID> call() {
-            Host h = findHost(host);
-            if (h.id == null) {
-                return Optional.empty();
+            if (knownHost.isPresent()) {
+                return knownHost.get();
             }
 
-            return Optional.of(h.id);
-        }
-    }
-
-    private final class GetOrCreateLoader implements Callable<Optional<UUID>> {
-
-        private final String host;
+            // insert in db and update cache
+            UUID id = dao.insert(hostNormalizer.normalize(host));
+            hostCache.put(host, Optional.of(id));
 
-        private GetOrCreateLoader(String host) {
-            this.host = host;
+            return id;
+        } catch (Exception e) {
+            throw new RuntimeException(e);
         }
+    }
 
-        @Override
-        public Optional<UUID> call() {
-            Host h = findHost(host);
-            if (h.id != null) {
-                return Optional.of(h.id);
-            }
-
-            return Optional.of(dao.insert(h.normalizedHost));
-        }
+    private UUID findHost(String host) {
+        String normalizedHost = hostNormalizer.normalize(host);
+        return dao.getId(normalizedHost);
     }
 }

server/plugins/noderoster/impl/src/main/java/com/walmartlabs/concord/server/plugins/noderoster/cfg/NodeRosterEventsConfiguration.java

@@ -44,6 +44,14 @@ public class NodeRosterEventsConfiguration implements Serializable {
     @Config("noderoster.events.fetchLimit")
     private int fetchLimit;
 
+    @Inject
+    @Config("noderoster.events.hostCacheSize")
+    private long hostCacheSize;
+
+    @Inject
+    @Config("noderoster.events.hostCacheDuration")
+    private Duration hostCacheDuration;
+
     private final Instant startTimestamp;
 
     @Inject
@@ -59,6 +67,14 @@ public int getFetchLimit() {
         return fetchLimit;
     }
 
+    public long getHostCacheSize() {
+        return hostCacheSize;
+    }
+
+    public Duration getHostCacheDuration() {
+        return hostCacheDuration;
+    }
+
     @Nullable
     public Instant getStartTimestamp() {
         return startTimestamp;

server/plugins/noderoster/impl/src/main/java/com/walmartlabs/concord/server/plugins/noderoster/processor/ProcessHostsProcessor.java

@@ -141,7 +141,7 @@ public ProcessHostsPartitioner() {
     }
 
     @Value.Immutable
-    static abstract class ProcessHostItem {
+    public abstract static class ProcessHostItem {
 
         public abstract UUID instanceId();