merge with main

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

Author: chrfwow

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

@@ -195,11 +195,6 @@ EvaluationContext getEnrichedContext() {
     private void onProviderEvent(FlagdProviderEvent flagdProviderEvent) {
         log.info("FlagdProviderEvent event {} ", flagdProviderEvent.getEvent());
         synchronized (syncResources) {
-            syncResources.setSyncMetadata(flagdProviderEvent.getSyncMetadata());
-            if (flagdProviderEvent.getSyncMetadata() != null) {
-                syncResources.setEnrichedContext(contextEnricher.apply(flagdProviderEvent.getSyncMetadata()));
-            }
-
             /*
              * We only use Error and Ready as previous states.
              * As error will first be emitted as Stale, and only turns after a while into an

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

@@ -2,33 +2,24 @@
 
 import dev.openfeature.sdk.EvaluationContext;
 import dev.openfeature.sdk.ImmutableContext;
-import dev.openfeature.sdk.ImmutableStructure;
 import dev.openfeature.sdk.ProviderEvent;
-import dev.openfeature.sdk.Structure;
 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
     private volatile ProviderEvent previousEvent = null;
 
-    private volatile ImmutableStructure syncMetadata = new ImmutableStructure();
     private volatile EvaluationContext enrichedContext = new ImmutableContext();
     private volatile boolean initialized;
     private volatile boolean isShutDown;
 
-    public void setSyncMetadata(Structure syncMetadata) {
-        this.syncMetadata = new ImmutableStructure(syncMetadata.asMap());
-    }
-
     public void setEnrichedContext(EvaluationContext context) {
         this.enrichedContext = new ImmutableContext(context.asMap());
     }
@@ -40,14 +31,11 @@ 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;
         }
         this.initialized = true;
         this.notifyAll();
-        log.info("notified all " + this.toString());
-
         return true;
     }
 
@@ -66,7 +54,6 @@ public synchronized boolean initialize() {
      *                               this object
      */
     public void waitForInitialization(long deadline) {
-        log.info("wait for init " + this);
         long start = System.currentTimeMillis();
         long end = start + deadline;
         while (!initialized && !isShutDown) {
@@ -78,34 +65,29 @@ public void waitForInitialization(long deadline) {
             }
             long remaining = end - now;
             synchronized (this) {
-                if (initialized) { // might have changed in the meantime
-                    log.info("post wait for init in loop");
-                    return;
-                }
                 if (isShutDown) {
                     break;
                 }
-                log.info("waiting for " + remaining + " at " + System.currentTimeMillis());
+                if (initialized) { // might have changed in the meantime
+                    return;
+                }
                 try {
                     this.wait(remaining);
                 } catch (InterruptedException e) {
                     // try again. Leave the continue to make PMD happy
                     continue;
                 }
-                log.info("waiting ended  at " + System.currentTimeMillis());
             }
         }
         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();
     }