Repository navigation
feat!: Add a start wait time option for initialization - #71
Draft
kinyoklion wants to merge 3 commits into
Draft
kinyoklion wants to merge 3 commits into
kinyoklion wants to merge 3 commits into
Conversation
Co-Authored-By: rlamb@launchdarkly.com <4955475+kinyoklion@users.noreply.github.com>
Contributor
🤖 Devin AI EngineerI'll be helping with this pull request! Here's what you should know: ✅ I will automatically:
Note: I can only respond to comments from users who have write access to this repository. ⚙️ Control Options:
|
3 tasks done
Contributor
|
@cursor review |
Draft
3 tasks done
3 tasks done
Member
Author
|
Devin check this against the latest version of the spec. |
Co-Authored-By: rlamb@launchdarkly.com <4955475+kinyoklion@users.noreply.github.com>
Co-Authored-By: rlamb@launchdarkly.com <4955475+kinyoklion@users.noreply.github.com>
Contributor
Rechecked against the latest OFP spec (
|
kinyoklion
added a commit
that referenced
this pull request
Oct 8, 2026
`InitializeAsync` ignored its `CancellationToken`, so a caller that passed a token to `SetProviderAsync` could not stop waiting for the LaunchDarkly client. - Cancelling the token now completes `InitializeAsync` with an `OperationCanceledException` instead of waiting for the data source - Cancellation is per-call: cancelling one wait leaves the provider initializing and does not fail other waiters - Feature matrix Initialization row updated to describe the behavior **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 **Related issues** None. <details> <summary>Implementation details</summary> The OpenFeature .NET SDK passes the token given to `Api.SetProviderAsync(provider, cancellationToken)` through `ProviderRepository` into `FeatureProvider.InitializeAsync`. The provider returned `_initCompletion.Task` directly, so the token had no effect. Waiting now goes through a helper which, when the token can be canceled, races `_initCompletion.Task` against a `TaskCompletionSource` canceled by a token registration. `_initCompletion` itself is untouched, so the provider still becomes `READY` (or errors) when the data source reports its state, regardless of a canceled wait. Shutdown is unchanged: it only removes listeners and disposes the client, so there is no wait to cancel. Tests: two cases covering cancellation of a first wait and of a wait on an already in-progress initialization. `dotnet test -f net8.0` passes (70 tests). Note: [#71](#71) also changes initialization waiting; whichever merges second needs a trivial rebase of this region. </details> Link to Devin session: https://app.devin.ai/sessions/a47abf28ecd44130917b9b5131287221 Open in Devin Desktop: https://app.devin.ai/desktop/session/a47abf28ecd44130917b9b5131287221?variant=devin Requested by: @kinyoklion [SDK-3255](https://launchdarkly.atlassian.net/browse/SDK-3255) <!-- CURSOR_SUMMARY --> --- > [!NOTE] > **Overview** > **`InitializeAsync` now honors the `CancellationToken`** passed through OpenFeature (e.g. from `SetProviderAsync`), so callers can stop waiting for the LaunchDarkly data source without blocking until ready or permanent failure. > > Waiting goes through **`WaitForInitializationAsync`**, which races `_initCompletion` against token cancellation. Cancellation is **per call**: `_initCompletion` is unchanged, so the client can still finish initializing and other waiters are unaffected. A canceled wait completes with **`OperationCanceledException`**. > > **`StatusProvider`** gains **`StartupWaitCanceled`**: it clears the “first event” suppression and, if status is already known, emits the matching provider event so subscribers still see **READY** (or stale/error) after a canceled startup wait. Status messages are retained for that replay; event emission is centralized in **`EmitStatusEvent`**. > > The README **Initialization** row and **three unit tests** document and cover token cancel on first wait, cancel on a concurrent second wait, and **ProviderReady** after cancel when the data source later becomes valid. > > <sup>Reviewed by [Cursor Bugbot](https://cursor.com/bugbot) for commit afef99f. Bugbot is set up for automated code reviews on this repo. Configure [here](https://www.cursor.com/dashboard/bugbot).</sup> <!-- /CURSOR_SUMMARY --> [SDK-3255]: https://launchdarkly.atlassian.net/browse/SDK-3255?atlOrigin=eyJpIjoiNWRkNTljNzYxNjVmNDY3MDlhMDU5Y2ZhYzA5YTRkZjUiLCJwIjoiZ2l0aHViLWNvbS1KU1cifQ --------- Co-authored-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
kinyoklion
added a commit
to launchdarkly/js-core
that referenced
this pull request
Oct 9, 2026
Gives the OpenFeature providers the initialization waiting values the OpenFeature provider spec (OFP) requires, which the numeric-only `initTimeoutSeconds` could not express. - `initTimeoutSeconds: 'forever'` waits indefinitely for the LaunchDarkly client - `initTimeoutSeconds: 0` waits nowhere and fails initialization unless the client is already ready, so readiness is observed through provider events - A positive timeout behaves as before, and the default is still 10 seconds - Node provider README feature matrix row updated for the new values <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 **Related issues** OFP requirement 4.3.4 requires a value distinct from any duration to request waiting indefinitely, and 4.3.6 requires a zero wait to wait nowhere and fail initialization. Sibling changes for the same requirement: launchdarkly/openfeature-java-server#66, launchdarkly/openfeature-python-server#64, launchdarkly/openfeature-dotnet-server#71, launchdarkly/openfeature-ruby-server#36. **Describe the solution you've provided** `BaseProviderConfig.initTimeoutSeconds` and the Node provider's constructor parameter are now `number | 'forever'`, and zero is no longer coalesced into the default, since `??` only replaces `undefined`. `waitForInitialization` treats a falsy timeout as no timeout, so zero cannot be passed through: initialization races the pending initialization promise against an immediately rejected one, which succeeds only when the client is already ready. The Cloudflare provider is unaffected because it evaluates from a KV namespace and has no data source to wait for. **Describe alternatives you've considered** `number | null` was used initially for the indefinite case; `'forever'` reads better at the call site and matches the repository's preference for string unions. Adding `initialized()` to the client contract would let the zero case be checked directly, but that is a breaking change to a published interface for behavior the existing promise already expresses. **Additional context** Verified with `yarn workspace @launchdarkly/openfeature-js-server-common test` (82 tests), `yarn workspace @launchdarkly/openfeature-node-server test` (29 tests), and lint, format and build checks for both packages. </details> Link to Devin session: https://app.devin.ai/sessions/1fd3fcbfe79f482e8b58be29e8df2ffb Open in Devin Desktop: https://app.devin.ai/desktop/session/1fd3fcbfe79f482e8b58be29e8df2ffb?variant=devin Requested by: @kinyoklion <!-- CURSOR_SUMMARY --> --- > [!NOTE] > **Overview** > Extends **`initTimeoutSeconds`** on the shared **`BaseOpenFeatureProvider`** and the Node **`LaunchDarklyProvider`** to **`number | 'forever'`**, aligning initialization with the OpenFeature provider spec. > > **`'forever'`** calls **`waitForInitialization()`** with no timeout. **`0`** no longer falls through to the 10-second default (only **`undefined`** does); initialization races the client’s init promise against an immediate failure so it succeeds only when the client is already ready, otherwise it throws a clear error. Positive timeouts behave as before (default **10** seconds). > > The Node provider README initialization row documents the new values, and unit tests cover indefinite wait, zero-timeout failure, and zero-timeout success when already ready. > > <sup>Reviewed by [Cursor Bugbot](https://cursor.com/bugbot) for commit 87e9a23. 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>
This branch has not been deployed
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Aligns initialization with the OpenFeature provider spec (OFP) start wait requirements, so waiting for the client is bounded instead of unbounded.
Provider(Configuration config, TimeSpan? startWait)constructorInitializeAsyncthen reports the outcome without waiting againTimeSpan.Zerowaits nowhere; readiness is reported through provider eventsnullwaits indefinitely for the data source to become valid or fail permanentlyInitializeAsyncno longer waits indefinitely after a configuredStartWaitTimeelapsesImplementation details
Requirements
Describe the solution you've provided
InitializeAsyncstill registers the flag and data source listeners and checks the current data source status. Only the indefinite mode leaves the initialization task pending; every other mode completes it with the outcome that is known at that point, so initialization does not wait a second time after the LaunchDarkly client constructor has already waited.The README feature matrix row for initialization and the asynchronous initialization section were updated to describe the three modes.
Describe alternatives you've considered
Interpreting a timeout only inside
InitializeAsyncwould wait twice whenStartWaitTimeis also configured, and OFP treats the start wait time as a bound over construction plus initialization.Additional context
Sibling changes for the same OFP requirement: launchdarkly/openfeature-java-server#66, launchdarkly/openfeature-python-server#64, launchdarkly/openfeature-ruby-server#36.
Out of scope, per the audit request: the dependency injection package and the client-side paradigm.
Verified with
dotnet test -f net8.0(71 tests pass).Link to Devin session: https://app.devin.ai/sessions/1fd3fcbfe79f482e8b58be29e8df2ffb
Open in Devin Desktop: https://app.devin.ai/desktop/session/1fd3fcbfe79f482e8b58be29e8df2ffb?variant=devin
Requested by: @kinyoklion
SDK-3285