fixup! feat: improve wait logic to a more elegant solution open-feature#1160

Signed-off-by: christian.lutnik <[email protected]>

Author: chrfwow

providers/flagd/src/main/java/dev/openfeature/contrib/providers/flagd/FlagdProvider.java

@@ -117,6 +117,7 @@ public List<Hook> getProviderHooks() {
 
     @Override
     public void initialize(EvaluationContext evaluationContext) throws Exception {
+        log.info("called initialize");
         synchronized (syncResources) {
             if (syncResources.isInitialized()) {
                 return;
@@ -207,7 +208,8 @@ EvaluationContext getEnrichedContext() {
     private void onProviderEvent(FlagdProviderEvent flagdProviderEvent) {
 
         synchronized (syncResources) {
-            log.info("FlagdProviderEvent: {}", flagdProviderEvent);
+            log.info("FlagdProviderEvent: {} of type {}", flagdProviderEvent, flagdProviderEvent.getClass().getName());
+            log.info("FlagdProviderEvent event {} ", flagdProviderEvent.getEvent().toString());
             syncResources.setSyncMetadata(flagdProviderEvent.getSyncMetadata());
             if (flagdProviderEvent.getSyncMetadata() != null) {
                 syncResources.setEnrichedContext(contextEnricher.apply(flagdProviderEvent.getSyncMetadata()));
@@ -228,6 +230,7 @@ private void onProviderEvent(FlagdProviderEvent flagdProviderEvent) {
                         onConfigurationChanged(flagdProviderEvent);
                         break;
                     }
+                    log.info("config change not ready");
                     // intentional fall through, a not-ready change will trigger a ready.
                 case PROVIDER_READY:
                     onReady();
@@ -248,13 +251,16 @@ private void onProviderEvent(FlagdProviderEvent flagdProviderEvent) {
     }
 
     private void onConfigurationChanged(FlagdProviderEvent flagdProviderEvent) {
+        log.info("FlagdProvider.onConfigurationChanged");
         this.emitProviderConfigurationChanged(ProviderEventDetails.builder()
                 .flagsChanged(flagdProviderEvent.getFlagsChanged())
                 .message("configuration changed")
                 .build());
+        log.info("post FlagdProvider.onConfigurationChanged");
     }
 
     private void onReady() {
+        log.info("on ready");
         if (syncResources.initialize()) {
             log.info("initialized FlagdProvider");
         }

providers/flagd/src/main/java/dev/openfeature/contrib/providers/flagd/FlagdProviderSyncResources.java

@@ -8,11 +8,13 @@
 import dev.openfeature.sdk.exceptions.GeneralError;
 import lombok.Getter;
 import lombok.Setter;
+import lombok.extern.slf4j.Slf4j;
 
 /**
  * Contains all fields we need to worry about locking, used as intrinsic lock
  * for sync blocks in the {@link FlagdProvider}.
  */
+@Slf4j
 @Getter
 class FlagdProviderSyncResources {
     @Setter
@@ -38,6 +40,7 @@ public void setEnrichedContext(EvaluationContext context) {
      * @return true iff this was the first call to {@code initialize()}
      */
     public synchronized boolean initialize() {
+        log.info("initialize in wait");
         if (this.initialized) {
             return false;
         }
@@ -47,20 +50,21 @@ public synchronized boolean initialize() {
     }
 
     /**
-     * Blocks the calling thread until either {@link EventsLock#initialize()} or {@link EventsLock#shutdown()} is called
-     * or the deadline is exceeded, whatever happens first. If {@link EventsLock#initialize()} has been executed before
-     * {@code waitForInitialization(long)} is called, it will return instantly.
-     * If the deadline is exceeded, a GeneralError will be thrown.
-     * If {@link EventsLock#shutdown()} is called in the meantime, an {@link IllegalStateException} will be thrown.
-     * Otherwise, the method will return cleanly.
+     * Blocks the calling thread until either {@link FlagdProviderSyncResources#initialize()} or
+     * {@link FlagdProviderSyncResources#shutdown()} is called or the deadline is exceeded, whatever happens first. If
+     * {@link FlagdProviderSyncResources#initialize()} has been executed before {@code waitForInitialization(long)} is
+     * called, it will return instantly. If the deadline is exceeded, a GeneralError will be thrown.
+     * If {@link FlagdProviderSyncResources#shutdown()} is called in the meantime, an {@link IllegalStateException} will
+     * be thrown. Otherwise, the method will return cleanly.
      *
      * @param deadline the maximum time in ms to wait
-     * @throws GeneralError          when the deadline is exceeded before {@link EventsLock#initialize()} is called on
-     *                               this
-     *                               object
-     * @throws IllegalStateException when {@link EventsLock#shutdown()} is called or has been called on this object
+     * @throws GeneralError          when the deadline is exceeded before
+     *                               {@link FlagdProviderSyncResources#initialize()} is called on this object
+     * @throws IllegalStateException when {@link FlagdProviderSyncResources#shutdown()} is called or has been called on
+     *                               this object
      */
     public void waitForInitialization(long deadline) {
+        log.info("wait for init");
         long start = System.currentTimeMillis();
         long end = start + deadline;
         while (!initialized && !isShutDown) {
@@ -89,12 +93,14 @@ public void waitForInitialization(long deadline) {
         if (isShutDown) {
             throw new IllegalStateException("Already shut down");
         }
+        log.info("post wait for init");
     }
 
     /**
      * Signals a shutdown. Threads waiting for initialization will wake up and throw an {@link IllegalStateException}.
      */
     public synchronized void shutdown() {
+        log.info("shutdown in wait");
         isShutDown = true;
         this.notifyAll();
     }

providers/flagd/src/main/java/dev/openfeature/contrib/providers/flagd/resolver/process/InProcessResolver.java

@@ -68,10 +68,12 @@ public void init() throws Exception {
                             flagStore.getStateQueue().take();
                     switch (storageStateChange.getStorageState()) {
                         case OK:
+                            log.info("onConnectionEvent.accept ProviderEvent.PROVIDER_CONFIGURATION_CHANGED");
                             onConnectionEvent.accept(new FlagdProviderEvent(
                                     ProviderEvent.PROVIDER_CONFIGURATION_CHANGED,
                                     storageStateChange.getChangedFlagsKeys(),
                                     storageStateChange.getSyncMetadata()));
+                            log.info("post onConnectionEvent.accept ProviderEvent.PROVIDER_CONFIGURATION_CHANGED");
                             break;
                         case ERROR:
                             onConnectionEvent.accept(new FlagdProviderEvent(ProviderEvent.PROVIDER_ERROR));