\
@@ -151,21 +151,23 @@ java -javaagent:path/to/dd-java-agent.jar \
{{% /tab %}}
{{< /tabs >}}
-The Datadog feature flagging system starts automatically when the tracer is initialized with both Remote Configuration and the feature flagging provider enabled. No additional initialization code is required in your application.
+The Datadog feature flagging system starts automatically when the tracer is initialized with Remote Configuration available and the feature flagging provider enabled. No additional initialization code is required in your application.
-Feature flagging requires both DD_REMOTE_CONFIG_ENABLED=true and DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED=true. Without these settings, the feature flagging system does not start and the Provider returns the programmatic default.
+Feature flagging requires DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED=true and Remote Configuration connectivity. Without the provider setting, the feature flagging system does not start and the Provider returns the programmatic default.
+
+Remote Configuration must be available for server-side Feature Flags. On supported Agent versions it is enabled by default. Only set SDK-level Remote Configuration variables, such as DD_REMOTE_CONFIG_ENABLED=true, if your tracer has Remote Configuration disabled and you need to override that setting.
### Add the Java tracer to the JVM
For instructions on how to add the `-javaagent` argument to your application server or framework, see [Add the Java SDK to the JVM](/tracing/trace_collection/automatic_instrumentation/dd_libraries/java/#add-the-java-sdk-to-the-jvm).
Make sure to include the feature flagging configuration flags:
-- `-Ddd.remote.config.enabled=true`
- `-Ddd.experimental.flagging.provider.enabled=true`
+- `-Ddd.metrics.otel.enabled=true` if you want flag evaluation metrics
## Initialize the OpenFeature provider
-Initialize the Datadog OpenFeature provider in your application startup code. The provider connects to the feature flagging system running in the Datadog SDK.
+Initialize the Datadog OpenFeature provider in your application startup code. The provider connects to the feature flagging system running in the Datadog Java tracer.
{{< code-block lang="java" >}}
import dev.openfeature.sdk.OpenFeatureAPI;
@@ -239,6 +241,8 @@ api.setProvider(new Provider());
The evaluation context defines the subject (user, device, session) for flag evaluation. It determines which flag variations are returned based on targeting rules.
+Datadog Feature Flags requires evaluation context attributes to be flat primitive values: strings, numbers, and Booleans. Do not pass nested objects or arrays; they are not supported and can cause exposure data to be dropped.
+
{{< code-block lang="java" >}}
import dev.openfeature.sdk.EvaluationContext;
import dev.openfeature.sdk.MutableContext;
@@ -556,7 +560,7 @@ Before checking infrastructure, confirm the flag itself is set up correctly:
Remote Configuration delivers flag configurations from the Datadog backend to the Agent.
-1. **RC is enabled on the Agent**: Set `remote_configuration.enabled: true` in `datadog.yaml` or `DD_REMOTE_CONFIG_ENABLED=true`. See [Remote Configuration][1].
+1. **RC is enabled on the Agent**: Agent 7.47.0 and later enable Remote Configuration by default. If it has been disabled, set `remote_configuration.enabled: true` in `datadog.yaml` or `DD_REMOTE_CONFIGURATION_ENABLED=true`. See [Remote Configuration][1].
2. **`DD_API_KEY` is valid on the Agent** and belongs to the target organization.
3. **`DD_SITE` is set correctly** on the Agent (`site` in `datadog.yaml` or `DD_SITE` env var). See [Agent Site Issues][3].
4. **Fleet Automation**: Open [Fleet Automation][4], select the Agent your application connects to, and confirm Remote Configuration is active.
@@ -565,7 +569,7 @@ Remote Configuration delivers flag configurations from the Datadog backend to th
### 3. Agent: Verify Agent health and connectivity
1. **Agent is running and reachable**: See [APM Connection Errors][2] for steps to verify Agent connectivity from the tracer.
-2. **Agent version**: Feature flagging requires Agent 7.x or later with EVP Proxy support.
+2. **Agent version**: Feature flagging requires Agent 7.55 or later with EVP Proxy support.
3. **EVP proxy is available**: Query the Agent's info endpoint and confirm the response includes `evp_proxy/v4/` and `v0.7/config` in the `endpoints` array:
```bash
curl http://localhost:8126/info
diff --git a/content/en/feature_flags/server/nodejs.md b/content/en/feature_flags/server/nodejs.md
index 46454ac6185..5c2d95e8fa7 100644
--- a/content/en/feature_flags/server/nodejs.md
+++ b/content/en/feature_flags/server/nodejs.md
@@ -15,13 +15,13 @@ further_reading:
## Overview
-This page describes how to instrument your Node.js application with the Datadog Feature Flags SDK. The Node.js SDK integrates with [OpenFeature][2], an open standard for feature flag management, and uses the Datadog SDK's Remote Configuration to receive flag updates in real time.
+This page describes how to instrument your Node.js application with the Datadog Feature Flags SDK. The Node.js SDK integrates with [OpenFeature][2], an open standard for feature flag management, and receives flag updates through Remote Configuration in the Datadog Node.js tracer (`dd-trace`).
## Prerequisites
Before setting up the Node.js Feature Flags SDK, ensure you have:
-- **Datadog Agent** with [Remote Configuration](/agent/remote_config/) enabled. See [Agent Configuration](/feature_flags/server#agent-configuration) for details.
+- **Datadog Agent** version 7.55 or later with [Remote Configuration](/agent/remote_config/) enabled. See [Agent Configuration](/feature_flags/server#agent-configuration) for details.
- **Datadog [API key][3]** configured on the Agent
- **Datadog Node.js SDK** `dd-trace` version 5.80.0 or later
- **@openfeature/server-sdk** version ~1.20.0
@@ -34,6 +34,20 @@ Feature Flagging is provided by Application Performance Monitoring (APM). To int
npm install dd-trace @openfeature/server-sdk
```
+Enable the provider with environment variables:
+
+```shell
+# Required: Enable the feature flags provider
+DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED=true
+
+# Optional: Enable flag evaluation metrics
+DD_METRICS_OTEL_ENABLED=true
+```
+
+The EXPERIMENTAL_ prefix is retained for backwards compatibility; the provider itself is stable.
+
+Or enable the provider in code:
+
```javascript
import { OpenFeature } from '@openfeature/server-sdk'
import tracer from 'dd-trace';
@@ -116,6 +130,8 @@ app.get('/my-endpoint', async (req, res) => {
Define who or what the flag evaluation applies to using an `EvaluationContext`. The evaluation context can include user or session information used to determine which flag variations should be returned. Call the `OpenFeature.setContext` method before evaluating flags to ensure proper targeting.
+Datadog Feature Flags requires evaluation context attributes to be flat primitive values: strings, numbers, and Booleans. Do not pass nested objects or arrays; they are not supported and can cause exposure data to be dropped.
+
## Evaluate flags
After creating the `OpenFeature` client as described in the [Installing and initializing](#installing-and-initializing) section, you can start reading flag values throughout your app. Flag evaluation uses locally cached data, so no network requests occur when evaluating flags.
diff --git a/content/en/feature_flags/server/python.md b/content/en/feature_flags/server/python.md
index 5e6ddb3d1cd..f443c061006 100644
--- a/content/en/feature_flags/server/python.md
+++ b/content/en/feature_flags/server/python.md
@@ -12,7 +12,7 @@ further_reading:
## Overview
-This page describes how to instrument your Python application with the Datadog Feature Flags SDK. The Python SDK integrates with [OpenFeature][1], an open standard for feature flag management, and uses the Datadog SDK's Remote Configuration to receive flag updates in real time.
+This page describes how to instrument your Python application with the Datadog Feature Flags SDK. The Python SDK integrates with [OpenFeature][1], an open standard for feature flag management, and receives flag updates through Remote Configuration in the Datadog Python tracer (`ddtrace`).
This guide explains how to install and enable the SDK, create an OpenFeature client, and evaluate feature flags in your application.
@@ -20,10 +20,10 @@ This guide explains how to install and enable the SDK, create an OpenFeature cli
Before setting up the Python Feature Flags SDK, ensure you have:
-- **Datadog Agent** with [Remote Configuration][2] enabled
+- **Datadog Agent** version 7.55 or later with [Remote Configuration][2] enabled
- **Datadog [API key][3]** configured on the Agent
- **Datadog Python SDK** `ddtrace` version 3.19.0 or later
-- **OpenFeature Python SDK** `openfeature-sdk` version 0.5.0 or later
+- **OpenFeature Python SDK** `openfeature-sdk` version 0.7.0 or later if you use provider event handlers to wait for initialization. If you do not use that pattern, version 0.5.0 or later is sufficient.
Set the following environment variables:
@@ -31,11 +31,16 @@ Set the following environment variables:
# Required: Enable the feature flags provider
export DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED=true
+# Optional: Enable flag evaluation metrics
+export DD_METRICS_OTEL_ENABLED=true
+
# Required: Service identification
export DD_SERVICE=
export DD_ENV=
{{< /code-block >}}
+The EXPERIMENTAL_ prefix is retained for backwards compatibility; the provider itself is stable.
+
## Installation
Install the Datadog Python SDK and OpenFeature SDK:
@@ -53,7 +58,7 @@ openfeature-sdk>=0.5.0
## Initialize the SDK
-Register the Datadog OpenFeature provider with the OpenFeature API. The provider connects to the Datadog SDK's Remote Configuration system to receive flag configurations.
+Register the Datadog OpenFeature provider with the OpenFeature API. The provider connects to the Datadog Python tracer's Remote Configuration system to receive flag configurations.
{{< code-block lang="python" >}}
from ddtrace import tracer
@@ -77,6 +82,8 @@ client = api.get_client()
Define an evaluation context that identifies the user or entity for flag targeting. The evaluation context includes attributes used to determine which flag variations should be returned:
+Datadog Feature Flags requires evaluation context attributes to be flat primitive values: strings, numbers, and Booleans. Do not pass nested objects or arrays; they are not supported and can cause exposure data to be dropped.
+
{{< code-block lang="python" >}}
from openfeature.evaluation_context import EvaluationContext
diff --git a/content/en/feature_flags/server/ruby.md b/content/en/feature_flags/server/ruby.md
index f1709a09b25..4a169766769 100644
--- a/content/en/feature_flags/server/ruby.md
+++ b/content/en/feature_flags/server/ruby.md
@@ -15,18 +15,18 @@ further_reading:
## Overview
-This page describes how to instrument your Ruby application with the Datadog Feature Flags SDK. The Ruby SDK integrates with [OpenFeature][3], an open standard for feature flag management, and uses the Datadog SDK's Remote Configuration to receive flag updates in real time.
+This page describes how to instrument your Ruby application with the Datadog Feature Flags SDK. The Ruby SDK integrates with [OpenFeature][3], an open standard for feature flag management, and receives flag updates through Remote Configuration in the Datadog Ruby tracer (`datadog` gem).
## Prerequisites
Before setting up the Ruby Feature Flags SDK, ensure you have:
-- **Datadog Agent** with [Remote Configuration][1] enabled
+- **Datadog Agent** version 7.55 or later with [Remote Configuration][1] enabled
- **Datadog [API key][4]** configured on the Agent
-- **Datadog Ruby SDK** `datadog` version 2.23.0 or later
-- **OpenFeature Ruby SDK** `openfeature-sdk` version 0.4.1 or later
+- **Datadog Ruby SDK** `datadog` version 2.24.0 or later
+- **OpenFeature Ruby SDK** `openfeature-sdk` version 0.5.1 or later if you need flag evaluation metrics support
- **Service and environment configured** - Feature flags are targeted by service and environment
-- **Supported operating system** - Feature flags are only [supported on Linux operating systems][2]. Windows and macOS are not natively supported, but Dockerized Linux environments running on those operating systems are.
+- **Supported operating system** - Production support is currently limited to [Linux operating systems][2]. macOS can be used for local development when a compatible prebuilt native artifact is available. Windows and macOS are not natively supported production targets, but Dockerized Linux environments running on those operating systems are.
## Installing and initializing
@@ -34,9 +34,23 @@ Before setting up the Ruby Feature Flags SDK, ensure you have:
Feature Flagging is provided by Application Performance Monitoring (APM). To integrate APM into your application with feature flagging support, install the required gems and configure Remote Configuration with OpenFeature support.
```shell
-gem install ddtrace openfeature-sdk
+gem install datadog openfeature-sdk
```
+You can enable Feature Flags with environment variables:
+
+```shell
+# Required: Enable the feature flags provider
+DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED=true
+
+# Optional: Enable flag evaluation metrics
+DD_METRICS_OTEL_ENABLED=true
+```
+
+The EXPERIMENTAL_ prefix is retained for backwards compatibility; the provider itself is stable.
+
+Or enable the provider in code:
+
```ruby
require 'datadog'
require 'open_feature/sdk'
@@ -69,6 +83,8 @@ Using `set_provider_and_wait` blocks your application from proceeding until the
Define an evaluation context that identifies the user or entity for flag targeting. The evaluation context includes attributes used to determine which flag variations should be returned:
+Datadog Feature Flags requires evaluation context attributes to be flat primitive values: strings, numbers, and Booleans. Do not pass nested objects or arrays; they are not supported and can cause exposure data to be dropped.
+
```ruby
context = OpenFeature::SDK::EvaluationContext.new(
targeting_key: 'user-123', # Targeting key (typically user ID)
@@ -263,7 +279,7 @@ If feature flags unexpectedly always return default values, check the following:
### Remote Configuration connection issues
-Check the Datadog SDK logs for Remote Configuration status:
+Check the Datadog Ruby tracer logs for Remote Configuration status:
```ruby
# Enable startup and debug logging
diff --git a/content/en/getting_started/feature_flags/_index.md b/content/en/getting_started/feature_flags/_index.md
index 61553c2278a..bc66b86c7dd 100644
--- a/content/en/getting_started/feature_flags/_index.md
+++ b/content/en/getting_started/feature_flags/_index.md
@@ -29,7 +29,7 @@ Datadog feature flags offer a powerful, integrated way to manage feature deliver
- **Real-time metrics:** Understand who's receiving each variant, as well as how your flag impacts the health & performance of your application—all in real time.
-- **Supports any data type:** Use Booleans, strings, numbers or full JSON objects—whatever your use case requires.
+- **Supports common flag types:** Use Boolean, string, integer, numeric (float/double), or JSON variants. JavaScript SDKs use `getNumberValue()` for both integer and numeric variants, while Java, Swift, Kotlin, and Python expose separate integer and floating-point evaluation methods.
- **Built for experimentation:** Target specific audiences for A/B tests, roll out features gradually with canary releases, and automatically roll back when regressions are detected.
@@ -57,23 +57,30 @@ Your organization likely already has pre-configured environments for Development
### Step 1: Import and initialize the SDK
-First, install `@datadog/openfeature-browser`, `@openfeature/web-sdk`, and `@openfeature/core` as dependencies in your project:
+Choose the SDK that matches where the flag is evaluated and initialize the Datadog Feature Flags provider.
-```
+{{< tabs >}}
+{{% tab "JavaScript browser" %}}
+
+Install `@datadog/openfeature-browser`, `@openfeature/web-sdk`, and `@openfeature/core` as dependencies in your project:
+
+{{< code-block lang="bash" >}}
yarn add @datadog/openfeature-browser @openfeature/web-sdk @openfeature/core
-```
+{{< /code-block >}}
Then, add the following to your project to initialize the SDK:
-```js
+Note: Browser Feature Flags are currently not supported on GovCloud sites.
+
+{{< code-block lang="javascript" >}}
import { DatadogProvider } from '@datadog/openfeature-browser';
import { OpenFeature } from '@openfeature/web-sdk';
// Initialize the provider
const provider = new DatadogProvider({
- clientToken: '',
+ // Required client-side Datadog credentials
applicationId: '',
- enableExposureLogging: true, // Can impact RUM costs if enabled
+ clientToken: '',
site: 'datadoghq.com',
env: '', // Same environment normally passed to the RUM SDK
service: '',
@@ -82,21 +89,149 @@ const provider = new DatadogProvider({
// Set the provider
await OpenFeature.setProviderAndWait(provider);
-```
+{{< /code-block >}}
+
+The browser SDK emits three independent telemetry streams, all enabled by default. enableExposureLogging sends per-evaluation exposure events to the exposures intake. enableFlagEvaluationTracking sends aggregated evaluation telemetry to the flag-evaluation intake. enableRumFeatureFlagTracking attaches flag evaluations to RUM events and is the setting that can affect RUM usage. Disable only the stream you do not need.
+
+{{% /tab %}}
+{{% tab "Node.js server" %}}
+
+Install `dd-trace` and the OpenFeature server SDK:
+
+{{< code-block lang="bash" >}}
+npm install dd-trace @openfeature/server-sdk
+{{< /code-block >}}
+
+Enable the provider with environment variables:
+
+{{< code-block lang="bash" >}}
+# Required: Enable the feature flags provider
+DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED=true
+
+# Optional: Enable flag evaluation metrics
+DD_METRICS_OTEL_ENABLED=true
+{{< /code-block >}}
+
+Or enable the provider in code:
+
+{{< code-block lang="javascript" >}}
+import { OpenFeature } from '@openfeature/server-sdk'
+import tracer from 'dd-trace';
+
+tracer.init({
+ experimental: {
+ flaggingProvider: {
+ enabled: true,
+ }
+ }
+});
+
+OpenFeature.setProvider(tracer.openfeature);
+{{< /code-block >}}
+
+{{% /tab %}}
+{{% tab "Java" %}}
+
+Add the OpenFeature SDK and Datadog OpenFeature provider dependencies:
+
+{{< code-block lang="groovy" filename="build.gradle" >}}
+dependencies {
+ // OpenFeature SDK for flag evaluation
+ implementation 'dev.openfeature:sdk:1.18.2'
+
+ // Datadog OpenFeature Provider
+ implementation 'com.datadoghq:dd-openfeature:1.57.0'
+}
+{{< /code-block >}}
+
+Enable the provider and start your application with the Java tracer:
+
+{{< code-block lang="bash" >}}
+# Required: Enable the feature flagging provider
+# The EXPERIMENTAL_ prefix is historical; the provider is no longer experimental.
+export DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED=true
+
+# Optional: Enable flag evaluation metrics
+export DD_METRICS_OTEL_ENABLED=true
+
+java -javaagent:path/to/dd-java-agent.jar -jar your-application.jar
+{{< /code-block >}}
+
+Register the Datadog OpenFeature provider:
+
+{{< code-block lang="java" >}}
+import dev.openfeature.sdk.OpenFeatureAPI;
+import dev.openfeature.sdk.Client;
+import datadog.trace.api.openfeature.Provider;
+
+OpenFeatureAPI api = OpenFeatureAPI.getInstance();
+api.setProviderAndWait(new Provider());
+Client client = api.getClient("my-app");
+{{< /code-block >}}
+
+{{% /tab %}}
+{{% tab "Python" %}}
-Setting
enableExposureLogging to
true can impact
RUM costs, as it sends exposure events to Datadog through RUM. You can disable it if you don't need to track feature exposure or guardrail metric status.
Datadog Feature Flags requires evaluation context attributes to be flat primitive values: strings, numbers, and Booleans. Do not pass nested objects or arrays; they are not supported and can cause exposure data to be dropped.
+
+{{< tabs >}}
+{{% tab "JavaScript browser" %}}
+
+{{< code-block lang="javascript" >}}
import { OpenFeature } from '@openfeature/web-sdk';
const client = OpenFeature.getClient();
@@ -132,9 +272,76 @@ const showFeature = await client.getBooleanValue('show-new-feature', fallback);
if (showFeature) {
// Feature code here
}
-```
+{{< /code-block >}}
+
+{{% /tab %}}
+{{% tab "Node.js server" %}}
+
+{{< code-block lang="javascript" >}}
+const evaluationContext = {
+ targetingKey: req.session?.userID ?? 'unknown',
+ companyID: req.session?.companyID
+};
+
+const isNewCheckoutEnabled = await client.getBooleanValue(
+ 'new-checkout-flow', // flag key
+ false, // default value
+ evaluationContext, // context
+);
+
+if (isNewCheckoutEnabled) {
+ showNewCheckoutFlow();
+} else {
+ showLegacyCheckout();
+}
+{{< /code-block >}}
+
+{{% /tab %}}
+{{% tab "Java" %}}
+
+{{< code-block lang="java" >}}
+import dev.openfeature.sdk.EvaluationContext;
+import dev.openfeature.sdk.MutableContext;
+
+EvaluationContext context = new MutableContext("user-123")
+ .add("email", "user@example.com")
+ .add("tier", "premium");
+
+boolean enabled = client.getBooleanValue("checkout.new", false, context);
+
+if (enabled) {
+ // New checkout flow
+} else {
+ // Old checkout flow
+}
+{{< /code-block >}}
+
+{{% /tab %}}
+{{% tab "Python" %}}
+
+{{< code-block lang="python" >}}
+from openfeature.evaluation_context import EvaluationContext
+
+eval_ctx = EvaluationContext(
+ targeting_key="user-123",
+ attributes={
+ "email": "user@example.com",
+ "tier": "premium"
+ }
+)
+
+enabled = client.get_boolean_value("new-checkout-flow", False, eval_ctx)
+
+if enabled:
+ show_new_checkout()
+else:
+ show_legacy_checkout()
+{{< /code-block >}}
+
+{{% /tab %}}
+{{< /tabs >}}
-After you've completed this step, redeploy the application to pick up these changes. Additional usage examples can be found in the SDK's [documentation][1].
+After you've completed this step, redeploy the application to pick up these changes. Additional usage examples can be found in the platform-specific SDK pages linked above.
### Step 4: Define targeting rules and enable the feature flag
@@ -168,7 +375,6 @@ Monitor the feature rollout from the feature flag details page, which provides r
{{< partial name="whats-next/whats-next.html" >}}
-[1]: https://openfeature.dev/docs/reference/technologies/client/web/
[2]: https://app.datadoghq.com/feature-flags/create
[3]: https://app.datadoghq.com/feature-flags/settings/environments
[4]: https://docs.datadoghq.com/account_management/api-app-keys/#client-tokens