refactor: replace remote resolve with remote materialization store (#209)

Author: nicklasl

openfeature-provider/java/README.md

@@ -121,6 +121,8 @@ Configure the provider behavior using environment variables:
 
 - `CONFIDENCE_RESOLVER_POLL_INTERVAL_SECONDS`: How often to poll Confidence to get updates (default: `30` seconds)
 - `CONFIDENCE_NUMBER_OF_WASM_INSTANCES`: How many WASM instances to create (this defaults to `Runtime.getRuntime().availableProcessors()` and will affect the performance of the provider)
+- `CONFIDENCE_MATERIALIZATION_READ_TIMEOUT_SECONDS`: Timeout for materialization read operations when using remote materialization store (default: `2` seconds)
+- `CONFIDENCE_MATERIALIZATION_WRITE_TIMEOUT_SECONDS`: Timeout for materialization write operations when using remote materialization store (default: `5` seconds)
 
 ##### Deprecated in favour of a custom ChannelFactory:
 - `CONFIDENCE_DOMAIN`: Override the default Confidence service endpoint (default: `edge-grpc.spotify.com`)
@@ -161,17 +163,54 @@ The provider supports **materializations** for two key use cases:
 
 1. **Custom Targeting via Materialized Segments**: Efficiently target precomputed sets of identifiers from datasets. Instead of evaluating complex targeting rules at runtime, materializations allow for fast lookups of whether a unit (user, session, etc.) is included in a target segment.
 
-**By default, materializations are managed by Confidence servers.** When sticky assignment data is needed, the provider makes a network call to Confidence, which maintains the sticky repository server-side with automatic 90-day TTL management. This requires no additional setup.
+### Materialization Storage Options
 
-### Custom Materialization Storage
+The provider offers three options for managing materialization data:
 
-Optionally, you can implement a custom `MaterializationStore` to manage materialization data in your own storage (Redis, database, etc.) to eliminate network calls and improve latency:
+#### 1. No Materialization Support (Default)
+
+By default, materializations are not supported. If a flag requires materialization data (sticky assignments or custom targeting), the evaluation will fail and return the default value.
+
+```java
+// Default behavior - no materialization support
+OpenFeatureLocalResolveProvider provider =
+    new OpenFeatureLocalResolveProvider("your-client-secret");
+```
+
+#### 2. Remote Materialization Store
+
+Enable remote materialization storage to have Confidence manage materialization data server-side. When sticky assignment data or materialized segment targeting data is needed, the provider makes a gRPC call to Confidence:
+
+```java
+// Enable remote materialization storage
+LocalProviderConfig config = LocalProviderConfig.builder()
+    .useRemoteMaterializationStore(true)
+    .build();
+
+OpenFeatureLocalResolveProvider provider =
+    new OpenFeatureLocalResolveProvider(config, "your-client-secret");
+```
+
+**⚠️ Important Performance Impact**: This option fundamentally changes how the provider operates:
+- **Without materialization (default)**: Flag evaluation requires **zero network calls** - all evaluations happen locally with minimal latency
+- **With remote materialization**: Flag evaluation **requires network calls** to Confidence for materialization reads/writes, adding latency to each evaluation
+
+This option:
+- Requires network calls for materialization reads/writes during flag evaluation
+- Automatically handles TTL and cleanup
+- Requires no additional infrastructure
+- Suitable for production use cases where sticky assignments or materialized segment targeting are required
+
+#### 3. Custom Materialization Storage
+
+For advanced use cases requiring minimal latency, implement a custom `MaterializationStore` to manage materialization data in your own infrastructure (Redis, database, etc.):
 
 ```java
-// Optional: Custom storage for materialization data
+// Custom storage for materialization data
 MaterializationStore store = new RedisMaterializationStore(jedisPool);
 OpenFeatureLocalResolveProvider provider = new OpenFeatureLocalResolveProvider(
-    clientSecret,
+    new LocalProviderConfig(),
+    "your-client-secret",
     store
 );
 ```

openfeature-provider/java/src/main/java/com/spotify/confidence/ConfidenceGrpcFlagResolver.java

@@ -3,6 +3,7 @@
 public class LocalProviderConfig {
   private final ChannelFactory channelFactory;
   private final HttpClientFactory httpClientFactory;
+  private final boolean useRemoteMaterializationStore;
 
   public LocalProviderConfig() {
     this(null, null);
@@ -16,6 +17,17 @@ public LocalProviderConfig(ChannelFactory channelFactory, HttpClientFactory http
     this.channelFactory = channelFactory != null ? channelFactory : new DefaultChannelFactory();
     this.httpClientFactory =
         httpClientFactory != null ? httpClientFactory : new DefaultHttpClientFactory();
+    this.useRemoteMaterializationStore = false;
+  }
+
+  public LocalProviderConfig(
+      ChannelFactory channelFactory,
+      HttpClientFactory httpClientFactory,
+      boolean useRemoteMaterializationStore) {
+    this.channelFactory = channelFactory != null ? channelFactory : new DefaultChannelFactory();
+    this.httpClientFactory =
+        httpClientFactory != null ? httpClientFactory : new DefaultHttpClientFactory();
+    this.useRemoteMaterializationStore = useRemoteMaterializationStore;
   }
 
   public ChannelFactory getChannelFactory() {
@@ -25,4 +37,38 @@ public ChannelFactory getChannelFactory() {
   public HttpClientFactory getHttpClientFactory() {
     return httpClientFactory;
   }
+
+  public boolean isUseRemoteMaterializationStore() {
+    return useRemoteMaterializationStore;
+  }
+
+  public static Builder builder() {
+    return new Builder();
+  }
+
+  public static class Builder {
+    private ChannelFactory channelFactory;
+    private HttpClientFactory httpClientFactory;
+    private boolean useRemoteMaterializationStore;
+
+    public Builder channelFactory(ChannelFactory channelFactory) {
+      this.channelFactory = channelFactory;
+      return this;
+    }
+
+    public Builder httpClientFactory(HttpClientFactory httpClientFactory) {
+      this.httpClientFactory = httpClientFactory;
+      return this;
+    }
+
+    public Builder useRemoteMaterializationStore(boolean useRemoteMaterializationStore) {
+      this.useRemoteMaterializationStore = useRemoteMaterializationStore;
+      return this;
+    }
+
+    public LocalProviderConfig build() {
+      return new LocalProviderConfig(
+          channelFactory, httpClientFactory, useRemoteMaterializationStore);
+    }
+  }
 }

openfeature-provider/java/src/main/java/com/spotify/confidence/LocalProviderConfig.java

@@ -60,7 +60,6 @@ public class OpenFeatureLocalResolveProvider implements FeatureProvider {
   private final AtomicReference<ProviderState> state =
       new AtomicReference<>(ProviderState.NOT_READY);
   private final ChannelFactory channelFactory;
-  private final RemoteResolver grpcFlagResolver;
 
   private static long getPollIntervalSeconds() {
     return Optional.ofNullable(System.getenv("CONFIDENCE_RESOLVER_POLL_INTERVAL_SECONDS"))
@@ -115,7 +114,12 @@ public OpenFeatureLocalResolveProvider(String clientSecret) {
    *     authentication
    */
   public OpenFeatureLocalResolveProvider(LocalProviderConfig config, String clientSecret) {
-    this(config, clientSecret, new UnsupportedMaterializationStore());
+    this(
+        config,
+        clientSecret,
+        config.isUseRemoteMaterializationStore()
+            ? new RemoteMaterializationStore(clientSecret, config.getChannelFactory())
+            : new UnsupportedMaterializationStore());
   }
 
   /**
@@ -160,7 +164,6 @@ public OpenFeatureLocalResolveProvider(
     final var wasmFlagLogger = new GrpcWasmFlagLogger(clientSecret, config.getChannelFactory());
     this.wasmResolveApi = new ThreadLocalSwapWasmResolverApi(wasmFlagLogger, materializationStore);
     this.channelFactory = config.getChannelFactory();
-    this.grpcFlagResolver = new ConfidenceGrpcFlagResolver(this.channelFactory);
   }
 
   /**
@@ -179,13 +182,11 @@ public OpenFeatureLocalResolveProvider(
       AccountStateProvider accountStateProvider,
       String clientSecret,
       MaterializationStore materializationStore,
-      WasmFlagLogger wasmFlagLogger,
-      RemoteResolver remoteResolver) {
+      WasmFlagLogger wasmFlagLogger) {
     this.materializationStore = materializationStore;
     this.clientSecret = clientSecret;
     this.stateProvider = accountStateProvider;
     this.wasmResolveApi = new ThreadLocalSwapWasmResolverApi(wasmFlagLogger, materializationStore);
-    this.grpcFlagResolver = remoteResolver;
     this.channelFactory = new LocalProviderConfig().getChannelFactory();
   }
 
@@ -293,7 +294,6 @@ public void shutdown() {
     log.debug("Shutting down scheduled executors");
     flagsFetcherExecutor.shutdown();
     logPollExecutor.shutdown();
-    this.grpcFlagResolver.close();
 
     try {
       if (!flagsFetcherExecutor.awaitTermination(1, TimeUnit.SECONDS)) {
@@ -311,6 +311,11 @@ public void shutdown() {
       Thread.currentThread().interrupt();
     }
 
+    // if we created the materialization store ourselves we are responsible for shutting it down
+    if (materializationStore instanceof RemoteMaterializationStore remoteMaterializationStore) {
+      remoteMaterializationStore.shutdown();
+    }
+
     // wasmResolveApi.close() flushes logs and calls flagLogger.shutdown() which waits for pending
     // writes
     this.wasmResolveApi.close();
@@ -350,19 +355,15 @@ public ProviderEvaluation<Value> getObjectEvaluation(
                       .build())
               .build();
 
-      try {
-        resolveFlagResponse =
-            wasmResolveApi
-                .resolveWithSticky(
-                    ResolveWithStickyRequest.newBuilder()
-                        .setResolveRequest(req)
-                        .setFailFastOnSticky(false)
-                        .build())
-                .toCompletableFuture()
-                .get();
-      } catch (MaterializationNotSupportedException e) {
-        resolveFlagResponse = remoteResolve(req).get();
-      }
+      resolveFlagResponse =
+          wasmResolveApi
+              .resolveWithSticky(
+                  ResolveWithStickyRequest.newBuilder()
+                      .setResolveRequest(req)
+                      .setFailFastOnSticky(false)
+                      .build())
+              .toCompletableFuture()
+              .get();
 
       if (resolveFlagResponse.getResolvedFlagsList().isEmpty()) {
         log.warn("No active flag '{}' was found", flagPath.getFlag());
@@ -413,13 +414,6 @@ public ProviderEvaluation<Value> getObjectEvaluation(
     }
   }
 
-  private CompletableFuture<ResolveFlagsResponse> remoteResolve(ResolveFlagsRequest req) {
-    if (req.getFlagsList().isEmpty()) {
-      return CompletableFuture.completedFuture(ResolveFlagsResponse.newBuilder().build());
-    }
-    return grpcFlagResolver.resolve(req);
-  }
-
   private static void handleStatusRuntimeException(StatusRuntimeException e) {
     if (e.getStatus().getCode() == Status.Code.DEADLINE_EXCEEDED) {
       log.error("Deadline exceeded when calling provider backend", e);