feat: Openfeature Provider implementation powered by DD Flags #2998

typotter · 2025-11-10T18:20:01Z

What does this PR do?

This PR adds a new OpenFeature provider module (dd-sdk-android-flags-openfeature) that integrates the Datadog Feature Flags SDK with the
OpenFeature API, enabling developers to use standardized feature flag management while leveraging Datadog's observability platform.

Key components:

DatadogFlagsProvider: OpenFeature FeatureProvider implementation that adapts the OpenFeature API to Datadog's FlagsClient
Blocking Lifecycle: Implements spec-compliant blocking for initialize() and onContextSet() methods
State Observation: observe() method emitting provider state change events via Kotlin Flow
Type Converters: Bidirectional conversion between OpenFeature Values and JSON types, preserving type information
Factory Method: Single create() method with @jvmoverloads for flexible provider instantiation
Extension Function: FlagsClient.asOpenFeatureProvider() for convenient wrapping of existing clients
Static-Context Paradigm: Implements OpenFeature's static-context model with global context management

Motivation

Why OpenFeature Integration?

Standardization: OpenFeature provides a vendor-neutral, community-driven specification for feature flagging
Ecosystem: Enables integration with OpenFeature-compatible tools and libraries
Migration Path: Allows customers to adopt OpenFeature API while using Datadog as the backend
Multi-Vendor: Customers can switch between feature flag providers without code changes

Dependencies

This PR depends on PR #3025 (State change notification for flags client).

PR feat: State change notification for flags client #3025 provides the StateObservable API (getCurrentState(), addListener(), removeListener())
This API enables blocking behavior and event observation without adding coroutines to the core flags module
Blocking is implemented in OpenFeature module only using coroutines (which OpenFeature SDK already requires)

Additional Notes

Architecture Decisions

Static-Context Paradigm

This provider implements the static-context paradigm per OpenFeature spec
Global context is set via OpenFeatureAPI.setEvaluationContext()
Per-evaluation (invocation) contexts are not supported - OpenFeature spec does not support invocation contexts in static-paradigm providers
Warnings are logged if invocation contexts are provided

** Provider Lifecycle & Blocking Behavior (OpenFeature Spec 1.7)**

Per the OpenFeature specification, provider lifecycle methods must block until ready:

initialize(initialContext)

Blocks until provider reaches Ready or Error state
Uses suspendCoroutine + StateObservable.addListener() to wait for terminal state
Throws exception if initialization fails (Error state)
Implementation: DatadogFlagsProvider.kt:99-124

onContextSet(oldContext, newContext)

Blocks during context reconciliation until Ready, Stale, or Error state
Enables OpenFeature SDK to emit PROVIDER_RECONCILING events while method executes
Returns normally for Ready/Stale, throws for Error
Implementation: DatadogFlagsProvider.kt:143-169

This blocking design ensures:

SDK knows when reconciliation is happening → emits PROVIDER_RECONCILING automatically
SDK emits PROVIDER_CONTEXT_CHANGED when onContextSet() completes
Proper state visibility for OpenFeature clients

Event Emission via observe() (OpenFeature Spec Section 5)

Per the OpenFeature Events specification, providers emit only certain events while the SDK handles others:

Provider emits (via observe() Flow):

PROVIDER_READY: When FlagsClient reaches Ready state
PROVIDER_STALE: When flags are stale but cached data available
PROVIDER_ERROR: When FlagsClient reaches Error state (unrecoverable)

SDK emits (not from provider):

PROVIDER_RECONCILING: SDK emits while onContextSet() is executing
PROVIDER_CONTEXT_CHANGED: SDK emits when onContextSet() completes

Filtered (not emitted by provider):

FlagsClientState.NotReady: Pre-initialization state, handled via blocking initialize()
FlagsClientState.Reconciling: Context reconciliation, SDK handles via blocking onContextSet()

Implementation: DatadogFlagsProvider.kt:325-345

Type Conversion Strategy

JSON → OpenFeature Value: Intelligent type promotion (e.g., Long within Int range becomes Value.Integer)
OpenFeature Value → JSON: Preserves type information (Integer→Int, Boolean→Boolean)
Null Handling: JSONObject.NULL sentinel values are converted to Value.Null
Special Values: Handles NaN, Infinity, nested structures, large collections

Error Handling

Specific exception catching (JSONException, ClassCastException, IllegalStateException)
Appropriate OpenFeature error codes (PARSE_ERROR, TYPE_MISMATCH, GENERAL, PROVIDER_NOT_READY)
Graceful degradation - returns default values on errors
Comprehensive logging via InternalLogger for debugging

Thread Safety

Provider methods are thread-safe, delegating coordination to FlagsClient
No synchronization locks (upstream FlagsClient handles concurrency)
State notifications use dedicated single-threaded executor (from FlagsClient)

Implementation Details

Module Structure:
dd-sdk-android-flags-openfeature/
├── DatadogFlagsProvider.kt # Main provider implementation
├── FlagsClientExt.kt # Extension function
└── internal/adapters/
├── Converters.kt # Context & error code converters
└── ValueConverters.kt # JSON ↔ OpenFeature Value converters

Dependencies:

dev.openfeature:kotlin-sdk-android:0.6.2 (118 Kb)
kotlinx-coroutines-core-jvm:1.7.3 (1514 Kb) - For blocking suspend functions
Total transitive dependencies: 3 Mb

Test Coverage:

71 unit tests covering all provider methods and edge cases
Error code mapping, type conversion, context management
Blocking behavior verification
Uses Elmyr forgeries for better test data generation

CI/CD Integration:

Added to detekt pipeline (line 115 in ci/pipelines/default-pipeline.yml)
Added to local_ci.sh features block
Publishing configured
License compliance updated (Apache-2.0 for OpenFeature SDK)

Detekt Safe Calls:

Added OpenFeature SDK calls to detekt_custom_safe_calls.yml
Added coroutines flow API calls (callbackFlow, awaitClose, trySend)
All third-party calls verified as safe

Usage Example

import com.datadog.android.flags.openfeature.DatadogFlagsProvider
import dev.openfeature.kotlin.sdk.OpenFeatureAPI

// Create and set provider (blocks until ready)
val provider = DatadogFlagsProvider.create()
OpenFeatureAPI.setProviderAndWait(provider)

// Use OpenFeature API
val client = OpenFeatureAPI.getClient()
val isEnabled = client.getBooleanValue("my-feature", false)

// Observe provider state changes
lifecycleScope.launch {
provider.observe().collect { event ->
when (event) {
is OpenFeatureProviderEvents.ProviderReady -> { /* ready / }
is OpenFeatureProviderEvents.ProviderError -> { / handle error / }
is OpenFeatureProviderEvents.ProviderStale -> { / stale data */ }
}
}
}

Review checklist (to be filled by reviewers)

Feature or bugfix MUST have appropriate tests (unit, integration, e2e)
Make sure you discussed the feature or bugfix with the maintaining team in an Issue
Make sure each commit and the PR mention the Issue number (cf the CONTRIBUTING doc)

codecov-commenter · 2025-11-10T18:40:54Z

Codecov Report

❌ Patch coverage is 47.23247% with 143 lines in your changes missing coverage. Please review.
✅ Project coverage is 70.86%. Comparing base (6c2f8ab) to head (ef411d2).

Files with missing lines	Patch %	Lines
.../android/flags/openfeature/DatadogFlagsProvider.kt	23.08%	81 Missing and 9 partials ⚠️
...s/openfeature/internal/adapters/ValueConverters.kt	68.52%	12 Missing and 5 partials ⚠️
.../flags/openfeature/internal/adapters/Converters.kt	57.14%	14 Missing and 1 partial ⚠️
...in/kotlin/com/datadog/android/flags/FlagsClient.kt	0.00%	13 Missing ⚠️
...atadog/android/flags/internal/FlagsStateManager.kt	86.36%	3 Missing ⚠️
.../datadog/android/flags/internal/NoOpFlagsClient.kt	50.00%	2 Missing ⚠️
...id/flags/internal/evaluation/EvaluationsManager.kt	93.33%	1 Missing ⚠️
...lags/internal/repository/DefaultFlagsRepository.kt	0.00%	0 Missing and 1 partial ⚠️
...om/datadog/android/flags/model/FlagsClientState.kt	83.33%	1 Missing ⚠️

Additional details and impacted files

@@                   Coverage Diff                   @@
##           feature/flags-ofeat    #2998      +/-   ##
=======================================================
- Coverage                71.10%   70.86%   -0.24%     
=======================================================
  Files                      860      865       +5     
  Lines                    31311    31565     +254     
  Branches                  5275     5334      +59     
=======================================================
+ Hits                     22263    22368     +105     
- Misses                    7556     7673     +117     
- Partials                  1492     1524      +32

Files with missing lines	Coverage Δ
...atadog/android/flags/openfeature/FlagsClientExt.kt	`100.00% <100.00%> (ø)`
...tadog/android/flags/internal/DatadogFlagsClient.kt	`88.41% <100.00%> (-1.30%)`	⬇️
...id/flags/internal/evaluation/EvaluationsManager.kt	`91.18% <93.33%> (+1.89%)`	⬆️
...lags/internal/repository/DefaultFlagsRepository.kt	`64.00% <0.00%> (-1.31%)`	⬇️
...om/datadog/android/flags/model/FlagsClientState.kt	`83.33% <83.33%> (ø)`
.../datadog/android/flags/internal/NoOpFlagsClient.kt	`93.10% <50.00%> (-6.90%)`	⬇️
...atadog/android/flags/internal/FlagsStateManager.kt	`86.36% <86.36%> (ø)`
...in/kotlin/com/datadog/android/flags/FlagsClient.kt	`35.59% <0.00%> (-2.59%)`	⬇️
.../flags/openfeature/internal/adapters/Converters.kt	`57.14% <57.14%> (ø)`
...s/openfeature/internal/adapters/ValueConverters.kt	`68.52% <68.52%> (ø)`
... and 1 more

... and 37 files with indirect coverage changes

🚀 New features to boost your workflow:

❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.

0xnm · 2025-11-24T17:05:40Z

ci/pipelines/default-pipeline.yml

    paths:
      - features/dd-sdk-android-flags/verification-metadata.xml

+publish:release-flags-openfeature:


it seems that :features:dd-sdk-android-flags-openfeature is missing in the custom Detekt rules execution job above, at least at this revision.

Was added in the first module scaffolding merge to the feature branch ~line 115. L106 now that I've reordered

0xnm · 2025-11-24T17:07:50Z

local_ci.sh

  rm -rf integrations/dd-sdk-android-sqldelight/build/
  rm -rf integrations/dd-sdk-android-timber/build/
  rm -rf integrations/dd-sdk-android-tv/build/
+  rm -rf features/dd-sdk-android-flags-openfeature/build/


nit: it is better to move it up, to the features block

moved. also added the flags feature module

0xnm · 2025-11-24T17:18:23Z

...gs-openfeature/src/main/kotlin/com/datadog/android/flags/openfeature/DatadogFlagsProvider.kt

+        context: OpenFeatureEvaluationContext?
+    ): ProviderEvaluation<Boolean> {
+        context?.let {
+            Log.w(LOG_TAG, INVOCATION_CONTEXT_NOT_SUPPORTED_MESSAGE)


We shouldn't use android.util.Log, but InternalLogger. We must get it from the SdkCore instance which was used to create this provider.

0xnm · 2025-11-24T17:22:45Z

...gs-openfeature/src/main/kotlin/com/datadog/android/flags/openfeature/DatadogFlagsProvider.kt

+                errorCode = null,
+                errorMessage = null
+            )
+        } catch (e: org.json.JSONException) {


Suggested change

} catch (e: org.json.JSONException) {

} catch (e: JSONException) {

...gs-openfeature/src/main/kotlin/com/datadog/android/flags/openfeature/DatadogFlagsProvider.kt

...c/test/kotlin/com/datadog/android/flags/openfeature/internal/adapters/ValueConvertersTest.kt

aleksandr-gringauz · 2025-11-26T14:17:30Z

...eature/src/main/kotlin/com/datadog/android/flags/openfeature/internal/adapters/Converters.kt

+    val targetingKey = this.getTargetingKey()
+
+    val stringAttributes = this.asMap()
+        .filterKeys { it != "targetingKey" }


Are you sure we need to filter this "targetingKey"? Is it put inside by dev.openfeature.kotlin.sdk?

aleksandr-gringauz · 2025-11-26T14:34:36Z

...gs-openfeature/src/main/kotlin/com/datadog/android/flags/openfeature/DatadogFlagsProvider.kt

+
+    override val hooks: List<Hook<*>> = emptyList()
+
+    override suspend fun initialize(initialContext: OpenFeatureEvaluationContext?) {


I see that it is suspend in openfeature sdk https://github.com/open-feature/kotlin-sdk/blob/da47e54909bc1cfc77e2295b3d0ceb217d4193b9/kotlin-sdk/src/commonMain/kotlin/dev/openfeature/kotlin/sdk/FeatureProvider.kt#L19

It says in the docs: "This function should block until ready". What does "ready" mean here? Does it mean that when this function is finished it is expected that we've loaded the current state of the flags (from disk, from network, ...)?

I'm asking because IIUC the current implementation doesn't provide such guarantees.

Same question for override suspend fun onContextSet.

I've added lifecycle state events to the base flags module which we can consume/re-emit here. The OpenFeature API handles emitting the READY, RECONCILING and ERROR/FATAL states depending on how initialize resolves. Thus, we don't need to re-emit those events in our openfeature layer, just watch for them when initializing and block the method until the underlying flags client enters either the READY or the ERROR state.

for setEvaluationContext I have added a direct callback in #3056

I looked at this pr.

Hope I understood your intentions correctly.

Here you notify the new callback after the call to flagStateManager.updateState. But flagStateManager.updateState changes the state asynchronously. So when the callback is called, there is no guarantee that the state has changed. So you'll still have to wait for the state like you do now.

@typotter WDYT about the comment above? Does the state in FlagStateManager need to be Ready when initialize returns?

typotter · 2025-11-25T22:02:03Z

ci/pipelines/default-pipeline.yml

    paths:
      - features/dd-sdk-android-flags/verification-metadata.xml

+publish:release-flags-openfeature:


Was added in the first module scaffolding merge to the feature branch ~line 115. L106 now that I've reordered

features/dd-sdk-android-flags-openfeature/build.gradle.kts

typotter · 2025-12-08T21:06:50Z

...gs-openfeature/src/main/kotlin/com/datadog/android/flags/openfeature/DatadogFlagsProvider.kt

+
+    override val hooks: List<Hook<*>> = emptyList()
+
+    override suspend fun initialize(initialContext: OpenFeatureEvaluationContext?) {


I've added lifecycle state events to the base flags module which we can consume/re-emit here. The OpenFeature API handles emitting the READY, RECONCILING and ERROR/FATAL states depending on how initialize resolves. Thus, we don't need to re-emit those events in our openfeature layer, just watch for them when initializing and block the method until the underlying flags client enters either the READY or the ERROR state.

typotter · 2025-12-08T21:09:21Z

local_ci.sh

  rm -rf integrations/dd-sdk-android-sqldelight/build/
  rm -rf integrations/dd-sdk-android-timber/build/
  rm -rf integrations/dd-sdk-android-tv/build/
+  rm -rf features/dd-sdk-android-flags-openfeature/build/


moved. also added the flags feature module

typotter · 2025-12-08T21:09:59Z

...gs-openfeature/src/main/kotlin/com/datadog/android/flags/openfeature/DatadogFlagsProvider.kt

+        context: OpenFeatureEvaluationContext?
+    ): ProviderEvaluation<Boolean> {
+        context?.let {
+            Log.w(LOG_TAG, INVOCATION_CONTEXT_NOT_SUPPORTED_MESSAGE)


...penfeature/src/test/kotlin/com/datadog/android/flags/openfeature/DatadogFlagsProviderTest.kt

typotter · 2025-12-08T21:20:49Z

...penfeature/src/test/kotlin/com/datadog/android/flags/openfeature/DatadogFlagsProviderTest.kt

+    // region String Evaluation
+
+    @Test
+    fun `M return string value W getStringEvaluation() {successful resolution}`(


typotter · 2025-12-08T21:23:06Z

...eature/src/main/kotlin/com/datadog/android/flags/openfeature/internal/adapters/Converters.kt

+    val targetingKey = this.getTargetingKey()
+
+    val stringAttributes = this.asMap()
+        .filterKeys { it != "targetingKey" }


typotter · 2025-12-08T21:23:21Z

...gs-openfeature/src/main/kotlin/com/datadog/android/flags/openfeature/DatadogFlagsProvider.kt

+                errorCode = null,
+                errorMessage = null
+            )
+        } catch (e: org.json.JSONException) {


typotter · 2025-12-08T21:23:26Z

...gs-openfeature/src/main/kotlin/com/datadog/android/flags/openfeature/DatadogFlagsProvider.kt

+        context: OpenFeatureEvaluationContext?
+    ): ProviderEvaluation<Boolean> {
+        context?.let {
+            Log.w(LOG_TAG, INVOCATION_CONTEXT_NOT_SUPPORTED_MESSAGE)


0xnm · 2025-12-09T08:31:22Z

features/dd-sdk-android-flags-openfeature/build.gradle.kts

    }
    testImplementation(libs.bundles.jUnit5)
    testImplementation(libs.bundles.testTools)
+    testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.7.3")


should go to version catalog

done and aligned with core version

there is no change here, probably it wasn't committed/pushed

:( lost them in when rebasing. pushed now

Looks like some other review-related changes are still missing.

yes, still working through these between meetings this morning. Didn't realize my push would dismiss your review/re-request.

0xnm · 2025-12-09T08:37:29Z

...gs-openfeature/src/main/kotlin/com/datadog/android/flags/openfeature/DatadogFlagsProvider.kt

+ * The underlying [FlagsClient] handles thread coordination.
 */
-class DatadogFlagsProvider {
+class DatadogFlagsProvider private constructor(private val flagsClient: FlagsClient, sdkCore: SdkCore) :


apparently SdkCore is not needed here, but only InternalLogger. So it can be DatadogFlagsProvider(flagsClient, sdkCore as FeatureSdkCore) at the call side.

moved the cast to the wrap method

it seems there is no change there as well

...eature/src/main/kotlin/com/datadog/android/flags/openfeature/internal/adapters/Converters.kt

0xnm · 2025-12-09T09:13:44Z

...eature/src/main/kotlin/com/datadog/android/flags/openfeature/internal/adapters/Converters.kt

+ * @return A map containing the JSONObject's key-value pairs, or an empty map if an error occurs
+ */
+@Suppress("UnsafeThirdPartyFunctionCall")
+internal fun JSONObject.toMap(internalLogger: InternalLogger? = null): Map<String, Any> {


this means that we will only convert top-level keys, leaving nested values as of JsonElement / JsonObject / JsonArray type?

For example, this:

{ "foo": "bar", "qwerty": { "a" : "b" } }

will be converted to:

mapOf<String, Any>("foo" to JsonElement("bar"), "qwerty" to JsonObject(...))

is it expected?

0xnm · 2025-12-09T09:14:54Z

...e/src/main/kotlin/com/datadog/android/flags/openfeature/internal/adapters/ValueConverters.kt

+ * @param internalLogger Logger for diagnostic messages (optional, for unexpected type warnings)
+ * @return The converted OpenFeature Value
+ */
+internal fun convertToValue(value: Any?, internalLogger: InternalLogger? = null): Value = when (value) {


Suggested change

internal fun convertToValue(value: Any?, internalLogger: InternalLogger? = null): Value = when (value) {

internal fun convertToValue(value: Any?, internalLogger: InternalLogger?): Value = when (value) {

The suggestion is not applied despite the resolved comment. I guess the changes are not pushed?

0xnm · 2025-12-09T09:38:43Z

...penfeature/src/test/kotlin/com/datadog/android/flags/openfeature/DatadogFlagsProviderTest.kt

+    @Test
+    fun `M call setEvaluationContext W onContextSet() {context change}`() = runTest {
+        // Given
+        val newContext = dev.openfeature.kotlin.sdk.ImmutableContext(targetingKey = "user-456")


Suggested change

val newContext = dev.openfeature.kotlin.sdk.ImmutableContext(targetingKey = "user-456")

val newContext = ImmutableContext(targetingKey = "user-456")

0xnm · 2025-12-09T09:40:00Z

...penfeature/src/test/kotlin/com/datadog/android/flags/openfeature/DatadogFlagsProviderTest.kt

+        val flow = provider.observe()
+
+        // Then - returns a Flow (basic smoke test)
+        assertThat(flow).isNotNull()


it is already guaranteed by the type system that this value is not null

0xnm · 2025-12-09T09:40:37Z

...penfeature/src/test/kotlin/com/datadog/android/flags/openfeature/DatadogFlagsProviderTest.kt

+
+    @Test
+    fun `M not throw exception W shutdown()`() {
+        assertThatCode { provider.shutdown() }.doesNotThrowAnyException()


Suggested change

assertThatCode { provider.shutdown() }.doesNotThrowAnyException()

assertDoesNotThrow { provider.shutdown() }

0xnm · 2025-12-09T09:49:44Z

...gs-openfeature/src/main/kotlin/com/datadog/android/flags/openfeature/DatadogFlagsProvider.kt

+                is FlagsClientState.Ready -> {
+                    flagsClient.state.removeListener(listener)
+                    continuation.resume(Unit)
+                }
+                is FlagsClientState.Error -> {
+                    flagsClient.state.removeListener(listener)
+                    continuation.resumeWithException(
+                        currentState.error ?: Exception("Initialization failed")
+                    )
+                }
+                else -> {} // Wait for state change notification


minor: it seems that this block is exactly the same as above, maybe it is worth extracting it?

0xnm · 2025-12-09T09:51:31Z

...gs-openfeature/src/main/kotlin/com/datadog/android/flags/openfeature/DatadogFlagsProvider.kt

+                FlagsClientState.Ready, FlagsClientState.Stale -> {
+                    flagsClient.state.removeListener(listener)
+                    continuation.resume(Unit)
+                }
+                is FlagsClientState.Error -> {
+                    flagsClient.state.removeListener(listener)
+                    continuation.resumeWithException(
+                        currentState.error ?: Exception("Context reconciliation failed")
+                    )
+                }
+                else -> {} // Wait for state change notification


similar to the comment above: a bit of duplication

using callback has cleared this up tremendously

typotter

Thanks. Still need to sort out some more changes. Will ping when ready for review

typotter · 2025-12-16T04:47:32Z

...gs-openfeature/src/main/kotlin/com/datadog/android/flags/openfeature/DatadogFlagsProvider.kt

+
+    override val hooks: List<Hook<*>> = emptyList()
+
+    override suspend fun initialize(initialContext: OpenFeatureEvaluationContext?) {


for setEvaluationContext I have added a direct callback in #3056

typotter · 2025-12-16T04:52:09Z

...gs-openfeature/src/main/kotlin/com/datadog/android/flags/openfeature/DatadogFlagsProvider.kt

+                FlagsClientState.Ready, FlagsClientState.Stale -> {
+                    flagsClient.state.removeListener(listener)
+                    continuation.resume(Unit)
+                }
+                is FlagsClientState.Error -> {
+                    flagsClient.state.removeListener(listener)
+                    continuation.resumeWithException(
+                        currentState.error ?: Exception("Context reconciliation failed")
+                    )
+                }
+                else -> {} // Wait for state change notification


using callback has cleared this up tremendously

typotter · 2025-12-16T05:01:41Z

...e/src/main/kotlin/com/datadog/android/flags/openfeature/internal/adapters/ValueConverters.kt

+ * @return Value.List containing the converted elements
+ */
+@Suppress("UnsafeThirdPartyFunctionCall")
+internal fun convertArrayToValue(jsonArray: JSONArray, internalLogger: InternalLogger? = null): Value {


made not optional.

typotter · 2025-12-16T05:02:54Z

...penfeature/src/test/kotlin/com/datadog/android/flags/openfeature/DatadogFlagsProviderTest.kt

+        Mockito.lenient().`when`(mockFlagsClient.state).thenReturn(mockStateObservable)
+        Mockito.lenient().`when`(mockStateObservable.addListener(any())).thenAnswer {
+            capturedStateListener = it.getArgument(0)
+            Unit
+        }
+        Mockito.lenient().`when`(mockStateObservable.getCurrentState()).thenReturn(FlagsClientState.NotReady)


typotter · 2025-12-16T05:03:24Z

...penfeature/src/test/kotlin/com/datadog/android/flags/openfeature/DatadogFlagsProviderTest.kt

+    // region String Evaluation
+
+    @Test
+    fun `M return string value W getStringEvaluation() {successful resolution}`(


typotter · 2025-12-16T05:10:01Z

...penfeature/src/test/kotlin/com/datadog/android/flags/openfeature/DatadogFlagsProviderTest.kt

+    @Test
+    fun `M call setEvaluationContext W initialize() {valid context}`() = runTest {
+        // Given
+        val context = dev.openfeature.kotlin.sdk.ImmutableContext(targetingKey = "user-123")


typotter · 2025-12-16T05:10:06Z

...penfeature/src/test/kotlin/com/datadog/android/flags/openfeature/DatadogFlagsProviderTest.kt

-        val result = provider.helloWorld()
+    fun `M return immediately W initialize() {already ready state}`() = runTest {
+        // Given
+        val context = dev.openfeature.kotlin.sdk.ImmutableContext(targetingKey = "user-123")


typotter · 2025-12-16T05:10:11Z

...penfeature/src/test/kotlin/com/datadog/android/flags/openfeature/DatadogFlagsProviderTest.kt

+    @Test
+    fun `M call setEvaluationContext W onContextSet() {context change}`() = runTest {
+        // Given
+        val newContext = dev.openfeature.kotlin.sdk.ImmutableContext(targetingKey = "user-456")


typotter · 2025-12-16T05:10:33Z

...penfeature/src/test/kotlin/com/datadog/android/flags/openfeature/DatadogFlagsProviderTest.kt

+        val flow = provider.observe()
+
+        // Then - returns a Flow (basic smoke test)
+        assertThat(flow).isNotNull()


typotter · 2025-12-16T05:11:03Z

...penfeature/src/test/kotlin/com/datadog/android/flags/openfeature/DatadogFlagsProviderTest.kt

+
+    @Test
+    fun `M not throw exception W shutdown()`() {
+        assertThatCode { provider.shutdown() }.doesNotThrowAnyException()


aleksandr-gringauz · 2025-12-15T16:02:37Z

...gs-openfeature/src/main/kotlin/com/datadog/android/flags/openfeature/DatadogFlagsProvider.kt

+                        }
+                        is FlagsClientState.Error -> {
+                            flagsClient.state.removeListener(this)
+                            continuation.resumeWithException(


This will make initialize function throw an exception that isn't specified in its signature here https://github.com/open-feature/kotlin-sdk/blob/da47e54909bc1cfc77e2295b3d0ceb217d4193b9/kotlin-sdk/src/commonMain/kotlin/dev/openfeature/kotlin/sdk/FeatureProvider.kt#L18. Should we create OpenFeatureError here?

aleksandr-gringauz · 2025-12-15T16:07:31Z

...gs-openfeature/src/main/kotlin/com/datadog/android/flags/openfeature/DatadogFlagsProvider.kt

+            when (val currentState = flagsClient.state.getCurrentState()) {
+                is FlagsClientState.Ready -> {
+                    flagsClient.state.removeListener(listener)
+                    continuation.resume(Unit)


We should be extra careful here. You can't call resume methods of Continuation multiple times https://kotlinlang.org/api/core/kotlin-stdlib/kotlin.coroutines/suspend-coroutine.html. It is theoretically possible that it will be called in addListener right away. I suggest that we add the listener only if we aren't resuming here. Or skip this "fast path" entirely.

understood. With the setContext callback now, I think we should be OK here, as we're either calling resume from the callback, or from the other branch of the if; not both. Not listening to state change either

aleksandr-gringauz · 2025-12-16T09:23:31Z

...gs-openfeature/src/main/kotlin/com/datadog/android/flags/openfeature/DatadogFlagsProvider.kt

+        setContext(newContext)
+
+        // Then wait for Ready, Stale, or Error state
+        suspendCoroutine<Unit> { continuation ->


I think you can create a helper function like this

private suspend fun StateObservable.waitFor(predicate: (FlagsClientState) -> Boolean): FlagsClientState { val currentState = getCurrentState() if (predicate(currentState)) { return currentState } return suspendCancellableCoroutine { cont -> val listener = object : FlagsStateListener { override fun onStateChanged(newState: FlagsClientState) { if (predicate(newState)) { removeListener(this) cont.resume(newState) } } } addListener(listener) cont.invokeOnCancellation { removeListener(listener) } } }

and use it here and in initialize function.

Also it is better to use suspendCancellableCoroutine.

Thanks for the details. We have a callback now, so much cleaner.

Implements OpenFeature Provider for Datadog Feature Flags SDK, enabling standardized feature flag management with vendor-neutral API. Key components: - DatadogFlagsProvider: Spec-compliant provider with blocking lifecycle - FlagsClient.asOpenFeatureProvider(): Extension function for wrapping clients - Type converters: Bidirectional JSON ↔ OpenFeature Value conversion - Event observation: Filtered state change events via Kotlin Flow OpenFeature spec compliance: - Blocking initialize() and onContextSet() (spec 1.7) - Proper event filtering (NotReady/Reconciling handled by SDK) - Static-context paradigm implementation - Error code mapping NotReady state clarifications: - Enhanced FlagsClientState.NotReady documentation - NoOpFlagsClient returns NotReady (not Error) as appropriate state - Aligns with OpenFeature NOT_READY semantics Dependencies: - dev.openfeature:kotlin-sdk-android:0.6.2 (118 Kb) - kotlinx-coroutines-core-jvm:1.7.3 (1514 Kb) - kotlinx-coroutines-test:1.7.3 (test only) - Total transitive dependencies: 3 Mb Test coverage: - 147 unit tests covering all provider methods - Type conversion edge cases - Blocking behavior verification - Event emission and filtering

…ng the listener

- Add resolveStructureValue(Map) overload that returns pure Kotlin collections - Implement JsonExtensions with bidirectional Map<->JSONObject conversion - Add comprehensive test coverage for Map API - Update FlagValueConverter to support all Map implementations - Add detekt safe calls configuration for JSON methods The Map API provides better Kotlin integration by returning nested Maps and Lists instead of JSONObject/JSONArray types. Both APIs coexist for compatibility.

aleksandr-gringauz · 2025-12-18T09:22:19Z

...gs-openfeature/src/main/kotlin/com/datadog/android/flags/openfeature/DatadogFlagsProvider.kt

+                }
+
+                override fun onFailure(error: Throwable) {
+                    continuation.resumeWithException(error)


Here we throw an exception that isn't specified in the function signature.

aleksandr-gringauz · 2025-12-18T09:22:31Z

...gs-openfeature/src/main/kotlin/com/datadog/android/flags/openfeature/DatadogFlagsProvider.kt

+                    else -> {
+                        // Not ready yet - need to wait, but no context to set
+                        // This shouldn't happen in normal flow
+                        continuation.resumeWithException(


Here we throw an exception that isn't specified in the function signature.

aleksandr-gringauz · 2025-12-18T09:26:24Z

...gs-openfeature/src/main/kotlin/com/datadog/android/flags/openfeature/DatadogFlagsProvider.kt

+                }
+
+                override fun onFailure(error: Throwable) {
+                    continuation.resumeWithException(error)


Here we throw an exception that isn't specified in the function signature.

aleksandr-gringauz · 2025-12-18T09:27:12Z

...gs-openfeature/src/main/kotlin/com/datadog/android/flags/openfeature/DatadogFlagsProvider.kt

+            }
+
+            flagsClient.setEvaluationContext(newContext.toDatadogEvaluationContext(), callback)
+        }


This can be extracted into a helper function and reused in initialize function.

override suspend fun initialize(initialContext: OpenFeatureEvaluationContext?) { val datadogContext = initialContext?.toDatadogEvaluationContext() if (datadogContext != null) { flagsClient.setEvaluationContextSuspend(datadogContext) } else { // No context provided - check if already ready when (flagsClient.state.getCurrentState()) { is FlagsClientState.Ready -> return is FlagsClientState.Error -> throw OpenFeatureError.ProviderFatalError("Provider not ready") else -> throw OpenFeatureError.ProviderFatalError("Provider initialization requires a context") } } } override suspend fun onContextSet( oldContext: OpenFeatureEvaluationContext?, newContext: OpenFeatureEvaluationContext ) { flagsClient.setEvaluationContextSuspend(newContext.toDatadogEvaluationContext()) } private suspend fun FlagsClient.setEvaluationContextSuspend(context: EvaluationContext) { suspendCoroutine { continuation -> val callback = object : EvaluationContextCallback { override fun onSuccess() { continuation.resume(Unit) } override fun onFailure(error: Throwable) { continuation.resumeWithException(OpenFeatureError.ProviderFatalError(error.message ?: "")) } } flagsClient.setEvaluationContext(context, callback) } }

aleksandr-gringauz · 2025-12-18T09:42:18Z

...gs-openfeature/src/main/kotlin/com/datadog/android/flags/openfeature/DatadogFlagsProvider.kt

+
+    override val hooks: List<Hook<*>> = emptyList()
+
+    override suspend fun initialize(initialContext: OpenFeatureEvaluationContext?) {


@typotter WDYT about the comment above? Does the state in FlagStateManager need to be Ready when initialize returns?

t resolution tests to cover errors, verify all fields

- Add comprehensive tests for state mapping (NotReady, Reconciling, Ready, Stale, Error) - Add test for listener lifecycle (removal on flow cancellation) - Add publish job for dd-sdk-android-flags-openfeature module - Include openfeature module in merge-verification-metadata dependencies - Fix imports for ImmutableContext and OpenFeatureProviderEvents

typotter changed the base branch from develop to feature/flags-ofeat November 10, 2025 18:22

This comment has been minimized.

Sign in to view

typotter marked this pull request as ready for review November 24, 2025 16:51

typotter requested review from a team as code owners November 24, 2025 16:51

0xnm requested changes Nov 25, 2025

View reviewed changes

aleksandr-gringauz reviewed Nov 26, 2025

View reviewed changes

typotter force-pushed the typo/openfeature-module-impl branch from 16c7902 to 7692d7f Compare December 2, 2025 04:41

typotter mentioned this pull request Dec 8, 2025

feat: State change notification for flags client (for OpenFeature) #3042

Merged

typotter changed the base branch from feature/flags-ofeat to typo/openfeature-flags-client-state December 8, 2025 16:44

typotter force-pushed the typo/openfeature-module-impl branch from ef411d2 to 688b08c Compare December 8, 2025 17:02

typotter mentioned this pull request Dec 8, 2025

docs: Clarify NotReady state semantics for OpenFeature #3043

Closed

typotter changed the base branch from typo/openfeature-flags-client-state to typo/flags-not-ready-clarifications December 8, 2025 17:36

typotter force-pushed the typo/openfeature-module-impl branch from 688b08c to 2f3ed72 Compare December 8, 2025 17:36

typotter changed the base branch from typo/flags-not-ready-clarifications to typo/openfeature-flags-client-state December 8, 2025 17:45

typotter force-pushed the typo/openfeature-module-impl branch 4 times, most recently from 778e82a to 3e80743 Compare December 8, 2025 20:39

typotter commented Dec 8, 2025

View reviewed changes

0xnm requested changes Dec 9, 2025

View reviewed changes

Base automatically changed from typo/openfeature-flags-client-state to feature/flags-ofeat December 9, 2025 15:16

typotter commented Dec 16, 2025

View reviewed changes

aleksandr-gringauz reviewed Dec 16, 2025

View reviewed changes

typotter added 5 commits December 17, 2025 21:22

fix: rely on the StateObservable emitting the current state upon addi…

e92e064

…ng the listener

use resolve map

63b1963

tidy tests

5673b4f

typotter added 2 commits December 17, 2025 21:22

add usage example

172905c

Use set context callback

1e5bd40

typotter force-pushed the typo/openfeature-module-impl branch from 3e80743 to 1e5bd40 Compare December 18, 2025 04:46

typotter requested review from 0xnm and aleksandr-gringauz December 18, 2025 04:50

resume with OpenFeature error

468ee09

aleksandr-gringauz reviewed Dec 18, 2025

View reviewed changes

align coroutines test to v1.4 and define in libs module

16154c8

typotter mentioned this pull request Dec 19, 2025

FFL-1621 Fix: set currentState in a blocking call #3068

Open

3 tasks

typotter added 10 commits December 19, 2025 01:45

Empty EvaluationContext

6f98bb9

use FeatureSDKCore in Provider, proper exceptions, update tests

dee88d9

Round ou

0a442e0

t resolution tests to cover errors, verify all fields

Drop JSON handling from converters

97a2a03

perf(openfeature): use sentinel to avoid converting default on error

e65cc7e

Remove unused convertValueToMap and related functions

58ddde1

test(openfeature): expand observe() tests and fix imports

3befc89

detekt fixes

7ecf153

lint

92e43c1

	} catch (e: org.json.JSONException) {
	} catch (e: JSONException) {


		override val hooks: List<Hook<*>> = emptyList()

		override suspend fun initialize(initialContext: OpenFeatureEvaluationContext?) {

	internal fun convertToValue(value: Any?, internalLogger: InternalLogger? = null): Value = when (value) {
	internal fun convertToValue(value: Any?, internalLogger: InternalLogger?): Value = when (value) {

	val newContext = dev.openfeature.kotlin.sdk.ImmutableContext(targetingKey = "user-456")
	val newContext = ImmutableContext(targetingKey = "user-456")

	assertThatCode { provider.shutdown() }.doesNotThrowAnyException()
	assertDoesNotThrow { provider.shutdown() }

feat: Openfeature Provider implementation powered by DD Flags #2998

Are you sure you want to change the base?

feat: Openfeature Provider implementation powered by DD Flags #2998

Uh oh!

Conversation

typotter commented Nov 10, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Review checklist (to be filled by reviewers)

Uh oh!

codecov-commenter commented Nov 10, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Codecov Report

Uh oh!

This comment has been minimized.

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

typotter commented Nov 10, 2025 •

edited

Loading

codecov-commenter commented Nov 10, 2025 •

edited

Loading