Finished caffeine migration

Author: wolpert

feature-flag/build.gradle.kts

@@ -11,7 +11,8 @@ dependencies {
 
     // This dependency is used internally, and not exposed to consumers on their own compile classpath.
     implementation(libs.slf4j.api)
-    implementation(libs.guava)
+    implementation(libs.guava) // hashing
+    implementation(libs.bundles.caffine)
     implementation(libs.bundles.jdbi)
 
     // Immutables

feature-flag/src/main/java/org/codeheadsystems/featureflag/manager/FeatureManager.java

@@ -1,6 +1,6 @@
 package org.codeheadsystems.featureflag.manager;
 
-import com.google.common.cache.CacheBuilder;
+import com.github.benmanes.caffeine.cache.Caffeine;
 import java.time.Duration;
 import java.util.ArrayList;
 import java.util.List;
@@ -77,16 +77,16 @@ class Builder {
     private EnablementFactory enablementFactory;
     private FeatureLookupManager featureLookupManager;
     private FeatureManagerConfiguration configuration;
-    private CacheBuilder<String, Enablement> cacheBuilder;
+    private Caffeine<String, Enablement> cacheBuilder;
     private List<Decorator<FeatureManager>> featureManagerDecorator = new ArrayList<>();
     private List<Decorator<FeatureLookupManager>> featureLookupManagerDecorator = new ArrayList<>();
 
-    private static CacheBuilder<String, Enablement> getDefaultCacheBuilder() {
-      return CacheBuilder.newBuilder()
+    private static Caffeine<String, Enablement> getDefaultCacheBuilder() {
+      return Caffeine.newBuilder()
           .maximumSize(100) // oh god, like we will have 100 features?
           .refreshAfterWrite(Duration.ofSeconds(60)) // refresh from source every 60seconds
           .expireAfterAccess(Duration.ofSeconds(600)) // expire after 600 seconds of inactivity
-          .removalListener(notification -> LOGGER.trace("removalListener({})", notification.getKey()));
+          .removalListener((key,value, cause) -> LOGGER.trace("removalListener({})", key));
     }
 
     /**
@@ -150,7 +150,7 @@ public FeatureManagerImpl.Builder withConfiguration(final FeatureManagerConfigur
      * @param cacheBuilder the configuration
      * @return the builder
      */
-    public FeatureManagerImpl.Builder withCacheBuilder(final CacheBuilder<String, Enablement> cacheBuilder) {
+    public FeatureManagerImpl.Builder withCacheBuilder(final Caffeine<String, Enablement> cacheBuilder) {
       this.cacheBuilder = cacheBuilder;
       return this;
     }
@@ -211,7 +211,7 @@ public FeatureManagerConfiguration getConfiguration() {
      *
      * @return the cache builder
      */
-    public CacheBuilder<String, Enablement> getCacheBuilder() {
+    public Caffeine<String, Enablement> getCacheBuilder() {
       return cacheBuilder;
     }
   }

feature-flag/src/main/java/org/codeheadsystems/featureflag/manager/impl/FeatureManagerImpl.java

@@ -1,9 +1,6 @@
 package org.codeheadsystems.featureflag.manager.impl;
 
-import com.google.common.cache.CacheLoader;
-import com.google.common.cache.LoadingCache;
-import com.google.common.util.concurrent.UncheckedExecutionException;
-import java.util.concurrent.ExecutionException;
+import com.github.benmanes.caffeine.cache.LoadingCache;
 import org.codeheadsystems.featureflag.factory.Enablement;
 import org.codeheadsystems.featureflag.factory.EnablementFactory;
 import org.codeheadsystems.featureflag.manager.FeatureLookupManager;
@@ -31,9 +28,8 @@ public FeatureManagerImpl(final Builder builder) {
     this.enablementFactory = builder.getEnablementFactory();
     this.featureLookupManager = builder.getFeatureLookupManager();
     this.featureEnablementCache = builder.getCacheBuilder()
-        .build(CacheLoader.asyncReloading(
-            CacheLoader.from(this::lookup),
-            builder.getConfiguration().cacheLoaderExecutor()));
+        .executor(builder.getConfiguration().cacheLoaderExecutor())
+        .build(this::lookup);
     LOGGER.info("FeatureManager({},{},{})", builder.getConfiguration(), featureLookupManager, enablementFactory);
   }
 
@@ -55,7 +51,7 @@ private Enablement lookup(String featureId) {
   public boolean isEnabled(String featureId, String discriminator) {
     try {
       return featureEnablementCache.get(featureId).enabled(discriminator);
-    } catch (ExecutionException | UncheckedExecutionException e) {
+    } catch (RuntimeException e) {
       LOGGER.error("Error getting feature enablement for: {}:{}", featureId, discriminator, e);
       return false;
     }

local-queue/build.gradle.kts

@@ -5,7 +5,7 @@ plugins {
 }
 
 dependencies {
-    implementation (libs.guava) // for hashing
+    implementation(libs.bundles.caffine)
     implementation(libs.dropwizard4.core)
     api(libs.micrometer.core)
     implementation(libs.slf4j.api)

local-queue/src/main/java/com/codeheadsystems/queue/factory/MessageFactory.java

@@ -4,10 +4,9 @@
 
 import com.codeheadsystems.queue.ImmutableMessage;
 import com.codeheadsystems.queue.Message;
+import com.github.benmanes.caffeine.cache.Caffeine;
+import com.github.benmanes.caffeine.cache.LoadingCache;
 import com.google.common.base.Charsets;
-import com.google.common.cache.CacheBuilder;
-import com.google.common.cache.CacheLoader;
-import com.google.common.cache.LoadingCache;
 import com.google.common.hash.HashFunction;
 import com.google.common.hash.Hashing;
 import java.time.Clock;
@@ -34,9 +33,9 @@ public class MessageFactory {
   @Inject
   public MessageFactory(final Clock clock) {
     this.clock = clock;
-    this.hashFunctionCache = CacheBuilder.newBuilder()
+    this.hashFunctionCache = Caffeine.newBuilder()
         .maximumSize(10) // TODO: Set this ina configuration
-        .build(CacheLoader.from(this::generateHashFunction));
+        .build(this::generateHashFunction);
     LOGGER.info("MessageFactory({})", clock);
   }
 
@@ -54,7 +53,7 @@ private HashFunction generateHashFunction(final String messageType) {
   public Message createMessage(final String messageType,
                                final String payload) {
     LOGGER.trace("createMessage({},{})", messageType, payload);
-    final HashFunction hashFunction = hashFunctionCache.getUnchecked(messageType);
+    final HashFunction hashFunction = hashFunctionCache.get(messageType);
     return ImmutableMessage.builder()
         .timestamp(clock.instant().toEpochMilli())
         .messageType(messageType)