fix: Do not emit a redundant ready event during initialization (#63)

Stops the provider from emitting a second `PROVIDER_READY` event during
initialization, and makes
`LifeCycleTest.itCanHandleClientThatIsNotInitializedImmediately` wait
for the event instead of racing it.

- The provider emitted ready from its data source status listener while
`initialize` was still running, and the OpenFeature SDK emits its own
ready event when initialization succeeds — consumers got two.
- The test only passed because it asserted the counter before the second
event was dispatched; adding a wait made it fail `expected: <1> but was:
<2>` 25/25 times, which is how the double emit surfaced.
- Ready events for later recoveries (stale/error back to valid) are
unaffected — only the emit that happens while `initialize` is in flight
is suppressed.
- Under CPU load, `LifeCycleTest` now passes 25/25; before this branch
it failed 9/25 with `expected: <1> but was: <0>`.

<details>
<summary>Implementation details</summary>

**Requirements**

- [x] I have added test coverage for new or changed functionality
- [x] I have followed the repository's [pull request submission
guidelines](../blob/main/CONTRIBUTING.md#submitting-pull-requests)
- [x] I have validated my changes against all supported platform
versions

**Mechanism**

`initialize` sets an `initializing` flag for the duration of the call.
In the `VALID` branch of `handleDataSourceStatus` the flag is read
*before* completing the initialization future, so the initialize thread
cannot clear it between the read and the emit:

```java
if (emit) {
    boolean duringInitialization = initializing;
    completer.complete(true);
    if (!duringInitialization) {
        emitProviderReady(...);
    }
}
```

`setProviderAndWait` also returns before API-level handlers have run,
since the OpenFeature SDK dispatches events on its own executor; the
test now waits on a `CompletableFuture` (1s timeout) and then asserts
the count after a short grace period so a duplicate emit is still
caught.

**Alternatives rejected**

Dropping the exact-count assertion from the test — it hides exactly the
duplicate-emit bug this change fixes.

**Testing**

`./gradlew test --tests '*LifeCycleTest*' --rerun-tasks` repeated 25x
with six busy loops pinning the CPUs, and the full suite once: all
green. On `main` the same loop failed 9/25 (and 5/20 in an earlier
round). CI on this branch was also re-triggered 11 times with empty
commits, all green, before the provider change.

**Related**

Found while investigating #32 (debug output for a flaky
`itEmitsReadyEvents`); that flake did not reproduce in ~75 runs and its
debug prints are superseded by #59, so #32 looks closable.

</details>


Link to Devin session:
https://app.devin.ai/sessions/3c9b094de4f84a0f82ba266098e823e9
Open in Devin Desktop:
https://app.devin.ai/desktop/session/3c9b094de4f84a0f82ba266098e823e9?variant=devin
Requested by: @kinyoklion

<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> **Overview**
> Fixes **double `PROVIDER_READY` events** when the LaunchDarkly data
source becomes valid while `initialize` is still running. The
OpenFeature SDK already emits ready on successful initialization; the
provider was also calling `emitProviderReady` from the data-source
status listener, so listeners could see two events.
> 
> An **`initializing` flag** wraps the wait in `initialize` (cleared in
`finally`). On transition to `VALID`, the provider still completes
initialization and updates state, but **skips `emitProviderReady` while
`initializing` is true**. Recoveries after init (e.g. stale/error back
to valid) still emit ready as before.
> 
> **Tests:** `itCanHandleClientThatIsNotInitializedImmediately` now
waits for the ready event and rechecks the count after a short delay to
catch races. A new case uses a controllable data source to assert that
**failed init followed by `VALID` still produces exactly one ready
event**.
> 
> <sup>Reviewed by [Cursor Bugbot](https://cursor.com/bugbot) for commit
f8a6052. Bugbot is set up for automated
code reviews on this repo. Configure
[here](https://www.cursor.com/dashboard/bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

---------

Co-authored-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>

Author: kinyoklion

src/main/java/com/launchdarkly/openfeature/serverprovider/Provider.java

@@ -51,6 +51,8 @@ public String getName() {
 
     private final Object stateLock = new Object();
 
+    private boolean initializing = false;
+
     /**
      * Create a provider with the specified SDK and default configuration.
      * <p>
@@ -152,6 +154,7 @@ public void initialize(EvaluationContext evaluationContext) throws Exception {
             setState(ProviderState.READY);
         }
 
+        setInitializing(true);
         var completer = new CompletableFuture<Boolean>();
 
         client.getFlagTracker().addFlagChangeListener(detail -> {
@@ -164,11 +167,17 @@ public void initialize(EvaluationContext evaluationContext) throws Exception {
         });
 
         if (getState() == ProviderState.READY) {
+            setInitializing(false);
             return;
         }
 
-        handleDataSourceStatus(client.getDataSourceStatusProvider().getStatus(), completer);
-        var successfullyInitialized = completer.get();
+        boolean successfullyInitialized;
+        try {
+            handleDataSourceStatus(client.getDataSourceStatusProvider().getStatus(), completer);
+            successfullyInitialized = completer.get();
+        } finally {
+            setInitializing(false);
+        }
 
         if(!successfullyInitialized) {
             throw new RuntimeException("Failed to initialize LaunchDarkly client.");
@@ -189,19 +198,24 @@ private void handleDataSourceStatus(DataSourceStatusProvider.Status res, Complet
             }
             break;
             case VALID: {
+                boolean becameReady = false;
                 boolean emit = false;
                 synchronized (stateLock) {
                     // If we are ready, then we don't want to emit it again. Other conditions we may be updating the
                     // reason we are stale or interrupted, so we want to emit an event each time.
                     if (state != ProviderState.READY) {
-                        emit = true;
-                        setState(ProviderState.READY);
+                        becameReady = true;
+                        // The OpenFeature SDK emits its own ready event when initialization succeeds.
+                        emit = !initializing;
+                        state = ProviderState.READY;
                     }
                 }
 
-                if (emit) {
+                if (becameReady) {
                     completer.complete(true);
-                    emitProviderReady(ProviderEventDetails.builder().build());
+                    if (emit) {
+                        emitProviderReady(ProviderEventDetails.builder().build());
+                    }
                 }
             }
             break;
@@ -218,6 +232,12 @@ private void handleDataSourceStatus(DataSourceStatusProvider.Status res, Complet
         }
     }
 
+    private void setInitializing(boolean initializing) {
+        synchronized (stateLock) {
+            this.initializing = initializing;
+        }
+    }
+
     private void setState(ProviderState state) {
         synchronized (stateLock) {
             this.state = state;

src/test/java/com/launchdarkly/openfeature/serverprovider/LifeCycleTest.java

@@ -104,6 +104,29 @@ public void close() throws IOException {
     }
 }
 
+class ControllableDataSource implements DataSource {
+    public Future<Void> start() {
+        return new CompletableFuture<>();
+    }
+
+    public boolean isInitialized() {
+        return false;
+    }
+
+    public void close() throws IOException {
+    }
+}
+
+class ControllableDataSourceFactory implements ComponentConfigurer<DataSource> {
+    final CompletableFuture<DataSourceUpdateSink> sink = new CompletableFuture<>();
+
+    @Override
+    public DataSource build(ClientContext clientContext) {
+        sink.complete(clientContext.getDataSourceUpdateSink());
+        return new ControllableDataSource();
+    }
+}
+
 class DelayedDataSourceFactory implements ComponentConfigurer<DataSource> {
     private Duration startDelay;
     private boolean willError;
@@ -219,14 +242,19 @@ public void itCanHandleClientThatIsNotInitializedImmediately() throws Exception
         assertEquals(ProviderState.NOT_READY, provider.getState());
 
         var readyCount = new AtomicInteger();
+        CompletableFuture<Boolean> gotReadyEvent = new CompletableFuture<>();
 
         OpenFeatureAPI.getInstance().on(ProviderEvent.PROVIDER_READY, (detail) -> {
             readyCount.getAndIncrement();
+            gotReadyEvent.complete(true);
         });
 
         OpenFeatureAPI.getInstance().setProviderAndWait(provider);
 
         assertEquals(ProviderState.READY, provider.getState());
+        assertTrue(gotReadyEvent.get(1000, TimeUnit.MILLISECONDS));
+
+        Thread.sleep(100);
         assertEquals(1, readyCount.get());
     }
 
@@ -260,6 +288,54 @@ public void itCanHandleClientThatIsNotInitializedImmediatelyAndErrors() throws E
         assertTrue(gotErrorEvent.get(1000, TimeUnit.MILLISECONDS));
     }
 
+    @Test
+    public void itEmitsReadyWhenTheDataSourceRecoversFromAFailedInitialization() throws Exception {
+        var dataSourceFactory = new ControllableDataSourceFactory();
+        var config = new LDConfig.Builder()
+            .startWait(Duration.ZERO)
+            .dataSource(dataSourceFactory)
+            .events(Components.noEvents())
+            .build();
+        var provider = new Provider("fake-key", config);
+        var sink = dataSourceFactory.sink.get(1000, TimeUnit.MILLISECONDS);
+
+        var readyCount = new AtomicInteger();
+        CompletableFuture<Boolean> gotReadyEvent = new CompletableFuture<>();
+        CompletableFuture<Boolean> gotErrorEvent = new CompletableFuture<>();
+
+        OpenFeatureAPI.getInstance().on(ProviderEvent.PROVIDER_READY, (detail) -> {
+            readyCount.getAndIncrement();
+            gotReadyEvent.complete(true);
+        });
+
+        OpenFeatureAPI.getInstance().on(ProviderEvent.PROVIDER_ERROR, (detail) -> {
+            gotErrorEvent.complete(true);
+        });
+
+        sink.updateStatus(DataSourceStatusProvider.State.OFF, new DataSourceStatusProvider.ErrorInfo(
+            DataSourceStatusProvider.ErrorKind.NETWORK_ERROR,
+            404,
+            "bad",
+            LocalDateTime.now().toInstant(ZoneOffset.UTC)));
+
+        GeneralError initializationError = null;
+        try {
+            OpenFeatureAPI.getInstance().setProviderAndWait(provider);
+        } catch (GeneralError e) {
+            initializationError = e;
+        }
+
+        assertNotNull(initializationError);
+        assertTrue(gotErrorEvent.get(1000, TimeUnit.MILLISECONDS));
+
+        sink.updateStatus(DataSourceStatusProvider.State.VALID, null);
+
+        assertTrue(gotReadyEvent.get(1000, TimeUnit.MILLISECONDS));
+
+        Thread.sleep(100);
+        assertEquals(1, readyCount.get());
+    }
+
     @Test
     public void itIncludesTheDataSourceErrorInErrorEvents() throws Exception {
         var config = new LDConfig.Builder()