move locks out to wasmresolverapi, remove retry strategy, handle isflushedexception

Author: vahidlazio

openfeature-provider-local/src/main/java/com/spotify/confidence/ExponentialRetryStrategy.java

@@ -67,27 +67,22 @@ static FlagResolverService from(
       ApiSecret apiSecret,
       String clientSecret,
       boolean isWasm,
-      StickyResolveStrategy stickyResolveStrategy,
-      RetryStrategy retryStrategy) {
-    return createFlagResolverService(
-        apiSecret, clientSecret, isWasm, stickyResolveStrategy, retryStrategy);
+      StickyResolveStrategy stickyResolveStrategy) {
+    return createFlagResolverService(apiSecret, clientSecret, isWasm, stickyResolveStrategy);
   }
 
   static FlagResolverService from(
       AccountStateProvider accountStateProvider,
       String accountId,
-      StickyResolveStrategy stickyResolveStrategy,
-      RetryStrategy retryStrategy) {
-    return createFlagResolverService(
-        accountStateProvider, accountId, stickyResolveStrategy, retryStrategy);
+      StickyResolveStrategy stickyResolveStrategy) {
+    return createFlagResolverService(accountStateProvider, accountId, stickyResolveStrategy);
   }
 
   private static FlagResolverService createFlagResolverService(
       ApiSecret apiSecret,
       String clientSecret,
       boolean isWasm,
-      StickyResolveStrategy stickyResolveStrategy,
-      RetryStrategy retryStrategy) {
+      StickyResolveStrategy stickyResolveStrategy) {
     final var channel = createConfidenceChannel();
     final AuthServiceBlockingStub authService = AuthServiceGrpc.newBlockingStub(channel);
     final TokenHolder tokenHolder =
@@ -116,8 +111,7 @@ private static FlagResolverService createFlagResolverService(
               wasmFlagLogger,
               sidecarFlagsAdminFetcher.rawStateHolder().get().toByteArray(),
               sidecarFlagsAdminFetcher.accountId,
-              stickyResolveStrategy,
-              retryStrategy);
+              stickyResolveStrategy);
       flagsFetcherExecutor.scheduleAtFixedRate(
           sidecarFlagsAdminFetcher::reload,
           pollIntervalSeconds,
@@ -173,8 +167,7 @@ private static boolean getFailFast(StickyResolveStrategy stickyResolveStrategy)
   private static FlagResolverService createFlagResolverService(
       AccountStateProvider accountStateProvider,
       String accountId,
-      StickyResolveStrategy stickyResolveStrategy,
-      RetryStrategy retryStrategy) {
+      StickyResolveStrategy stickyResolveStrategy) {
     final var mode = System.getenv("LOCAL_RESOLVE_MODE");
     if (!(mode == null || mode.equals("WASM"))) {
       throw new RuntimeException("Only WASM mode supported with AccountStateProvider");
@@ -187,7 +180,7 @@ private static FlagResolverService createFlagResolverService(
     final WasmFlagLogger flagLogger = request -> WriteFlagLogsResponse.getDefaultInstance();
     final ResolverApi wasmResolverApi =
         new ThreadLocalSwapWasmResolverApi(
-            flagLogger, resolverStateProtobuf, accountId, stickyResolveStrategy, retryStrategy);
+            flagLogger, resolverStateProtobuf, accountId, stickyResolveStrategy);
     flagsFetcherExecutor.scheduleAtFixedRate(
         () -> {
           wasmResolverApi.updateStateAndFlushLogs(accountStateProvider.provide(), accountId);

openfeature-provider-local/src/main/java/com/spotify/confidence/LocalResolverServiceFactory.java

@@ -90,28 +90,7 @@ public class OpenFeatureLocalResolveProvider implements FeatureProvider {
    * @since 0.2.4
    */
   public OpenFeatureLocalResolveProvider(ApiSecret apiSecret, String clientSecret) {
-    this(apiSecret, clientSecret, new RemoteResolverFallback(), new NoRetryStrategy());
-  }
-
-  /**
-   * Creates a new OpenFeature provider for local flag resolution with configurable sticky resolve
-   * strategy and no retry.
-   *
-   * <p>The provider will automatically determine the resolution mode (WASM or Java) based on the
-   * {@code LOCAL_RESOLVE_MODE} environment variable, defaulting to WASM mode.
-   *
-   * @param apiSecret the API credentials containing client ID and client secret for authenticating
-   *     with the Confidence service. Create using {@code new ApiSecret("client-id",
-   *     "client-secret")}
-   * @param clientSecret the client secret for your application, used for flag resolution
-   *     authentication. This is different from the API secret and is specific to your application
-   *     configuration
-   * @param stickyResolveStrategy the strategy to use for handling sticky flag resolution
-   * @since 0.2.4
-   */
-  public OpenFeatureLocalResolveProvider(
-      ApiSecret apiSecret, String clientSecret, StickyResolveStrategy stickyResolveStrategy) {
-    this(apiSecret, clientSecret, stickyResolveStrategy, new NoRetryStrategy());
+    this(apiSecret, clientSecret, new RemoteResolverFallback());
   }
 
   /**
@@ -128,56 +107,25 @@ public OpenFeatureLocalResolveProvider(
    *     authentication. This is different from the API secret and is specific to your application
    *     configuration
    * @param stickyResolveStrategy the strategy to use for handling sticky flag resolution
-   * @param retryStrategy the retry strategy for WASM operations (use {@link NoRetryStrategy} to
-   *     disable retries or {@link ExponentialRetryStrategy} for exponential backoff)
    * @since 0.2.4
    */
   public OpenFeatureLocalResolveProvider(
-      ApiSecret apiSecret,
-      String clientSecret,
-      StickyResolveStrategy stickyResolveStrategy,
-      RetryStrategy retryStrategy) {
+      ApiSecret apiSecret, String clientSecret, StickyResolveStrategy stickyResolveStrategy) {
     final var env = System.getenv("LOCAL_RESOLVE_MODE");
     if (env != null && env.equals("WASM")) {
       this.flagResolverService =
-          LocalResolverServiceFactory.from(
-              apiSecret, clientSecret, true, stickyResolveStrategy, retryStrategy);
+          LocalResolverServiceFactory.from(apiSecret, clientSecret, true, stickyResolveStrategy);
     } else if (env != null && env.equals("JAVA")) {
       this.flagResolverService =
-          LocalResolverServiceFactory.from(
-              apiSecret, clientSecret, false, stickyResolveStrategy, retryStrategy);
+          LocalResolverServiceFactory.from(apiSecret, clientSecret, false, stickyResolveStrategy);
     } else {
       this.flagResolverService =
-          LocalResolverServiceFactory.from(
-              apiSecret, clientSecret, true, stickyResolveStrategy, retryStrategy);
+          LocalResolverServiceFactory.from(apiSecret, clientSecret, true, stickyResolveStrategy);
     }
     this.stickyResolveStrategy = stickyResolveStrategy;
     this.clientSecret = clientSecret;
   }
 
-  /**
-   * To be used for testing purposes only! This constructor allows to inject flags state for testing
-   * the WASM resolver (no Java supported) No resolve/assign logging is forwarded to production No
-   * need to supply ApiSecret
-   *
-   * @param accountStateProvider a functional interface that provides AccountState instances
-   * @param clientSecret the flag client key used to filter the flags
-   * @since 0.2.4
-   */
-  @VisibleForTesting
-  public OpenFeatureLocalResolveProvider(
-      AccountStateProvider accountStateProvider,
-      String accountId,
-      String clientSecret,
-      StickyResolveStrategy stickyResolveStrategy) {
-    this(
-        accountStateProvider,
-        accountId,
-        clientSecret,
-        stickyResolveStrategy,
-        new NoRetryStrategy());
-  }
-
   /**
    * To be used for testing purposes only! This constructor allows to inject flags state for testing
    * the WASM resolver with full control over retry strategy.
@@ -186,21 +134,18 @@ public OpenFeatureLocalResolveProvider(
    * @param accountId the account ID
    * @param clientSecret the flag client key used to filter the flags
    * @param stickyResolveStrategy the strategy to use for handling sticky flag resolution
-   * @param retryStrategy the retry strategy for WASM operations
    * @since 0.2.4
    */
   @VisibleForTesting
   public OpenFeatureLocalResolveProvider(
       AccountStateProvider accountStateProvider,
       String accountId,
       String clientSecret,
-      StickyResolveStrategy stickyResolveStrategy,
-      RetryStrategy retryStrategy) {
+      StickyResolveStrategy stickyResolveStrategy) {
     this.stickyResolveStrategy = stickyResolveStrategy;
     this.clientSecret = clientSecret;
     this.flagResolverService =
-        LocalResolverServiceFactory.from(
-            accountStateProvider, accountId, stickyResolveStrategy, retryStrategy);
+        LocalResolverServiceFactory.from(accountStateProvider, accountId, stickyResolveStrategy);
   }
 
   @Override

openfeature-provider-local/src/main/java/com/spotify/confidence/NoRetryStrategy.java

@@ -11,72 +11,53 @@
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.atomic.AtomicReference;
-import java.util.concurrent.locks.ReentrantLock;
 import java.util.stream.Collectors;
 
 class SwapWasmResolverApi implements ResolverApi {
   private final AtomicReference<WasmResolveApi> wasmResolverApiRef = new AtomicReference<>();
   private final StickyResolveStrategy stickyResolveStrategy;
   private final WasmFlagLogger flagLogger;
-  private final RetryStrategy retryStrategy;
 
   public SwapWasmResolverApi(
       WasmFlagLogger flagLogger,
       byte[] initialState,
       String accountId,
-      StickyResolveStrategy stickyResolveStrategy,
-      RetryStrategy retryStrategy) {
+      StickyResolveStrategy stickyResolveStrategy) {
     this.stickyResolveStrategy = stickyResolveStrategy;
     this.flagLogger = flagLogger;
-    this.retryStrategy = retryStrategy;
 
     // Create initial instance
-    final WasmResolveApi initialInstance = new WasmResolveApi(flagLogger, retryStrategy);
+    final WasmResolveApi initialInstance = new WasmResolveApi(flagLogger);
     initialInstance.setResolverState(initialState, accountId);
     this.wasmResolverApiRef.set(initialInstance);
   }
 
   @Override
   public void updateStateAndFlushLogs(byte[] state, String accountId) {
-    logResolveLock.lock();
     // Create new instance with updated state
-    final WasmResolveApi newInstance = new WasmResolveApi(flagLogger, retryStrategy);
+    final WasmResolveApi newInstance = new WasmResolveApi(flagLogger);
     newInstance.setResolverState(state, accountId);
 
     // Get current instance before switching
     final WasmResolveApi oldInstance = wasmResolverApiRef.getAndSet(newInstance);
-
     if (oldInstance != null) {
       oldInstance.flushLogs();
-      oldInstance.isIsFlushed(true);
     }
-    logResolveLock.unlock();
   }
 
   @Override
-  public void close() {
-    final WasmResolveApi currentInstance = wasmResolverApiRef.get();
-    if (currentInstance != null) {
-      // Note: WasmResolveApi doesn't have a close method, so this is a no-op for now
-      // but the instance will be GC'd naturally
-    }
-  }
-
-  private final ReentrantLock logResolveLock = new ReentrantLock();
+  public void close() {}
 
   @Override
   public CompletableFuture<ResolveFlagsResponse> resolveWithSticky(
       ResolveWithStickyRequest request) {
-    logResolveLock.lock();
-    final var response = resolveWithStickyInternal(request);
-    logResolveLock.unlock();
-    return response;
-  }
-
-  private CompletableFuture<ResolveFlagsResponse> resolveWithStickyInternal(
-      ResolveWithStickyRequest request) {
     final var instance = wasmResolverApiRef.get();
-    final var response = instance.resolveWithSticky(request);
+    final ResolveWithStickyResponse response;
+    try {
+      response = instance.resolveWithSticky(request);
+    } catch (IsFlushedException e) {
+      return resolveWithSticky(request);
+    }
 
     switch (response.getResolveResultCase()) {
       case SUCCESS -> {
@@ -85,9 +66,6 @@ private CompletableFuture<ResolveFlagsResponse> resolveWithStickyInternal(
         if (!success.getUpdatesList().isEmpty()) {
           storeUpdates(success.getUpdatesList());
         }
-        if (instance.isFlushed()) {
-          CompletableFuture.runAsync(instance::flushLogs);
-        }
         return CompletableFuture.completedFuture(success.getResponse());
       }
       case MISSING_MATERIALIZATIONS -> {
@@ -103,7 +81,7 @@ private CompletableFuture<ResolveFlagsResponse> resolveWithStickyInternal(
           final var currentRequest =
               handleMissingMaterializations(
                   request, missingMaterializations.getItemsList(), repository);
-          return resolveWithStickyInternal(currentRequest);
+          return resolveWithSticky(currentRequest);
         }
 
         throw new RuntimeException(
@@ -208,13 +186,11 @@ private ResolveWithStickyRequest handleMissingMaterializations(
 
   @Override
   public ResolveFlagsResponse resolve(ResolveFlagsRequest request) {
-    logResolveLock.lock();
     final var instance = wasmResolverApiRef.get();
-    final var response = instance.resolve(request);
-    if (instance.isFlushed()) {
-      CompletableFuture.runAsync(instance::flushLogs);
+    try {
+      return instance.resolve(request);
+    } catch (IsFlushedException e) {
+      return resolve(request);
     }
-    logResolveLock.unlock();
-    return response;
   }
 }