DataDog · pavlokhrebto · Sep 14, 2026 · Aug 13, 2026 · Aug 13, 2026 · Aug 13, 2026
@@ -14164,6 +14164,52 @@
     "IsAdoNetIntegration": false,
     "InstrumentationCategory": 1
   },
+  {
+    "IntegrationName": "OpenFeature",
+    "AssemblyName": "Datadog.FeatureFlags.OpenFeature",
+    "TargetTypeName": "Datadog.FeatureFlags.OpenFeature.FeatureFlagsSdk",
+    "TargetMethodName": "HasConfiguration",
+    "TargetReturnType": "System.Boolean",
+    "TargetParameterTypes": [],
+    "MinimumVersion": {
+      "Item1": 2,
+      "Item2": 0,
+      "Item3": 0
+    },
+    "MaximumVersion": {
+      "Item1": 2,
+      "Item2": 65535,
+      "Item3": 65535
+    },
+    "InstrumentationTypeName": "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.OpenFeature.OpenFeatureSdkHasConfigurationIntegration",
+    "IntegrationKind": 0,
+    "IsAdoNetIntegration": false,
+    "InstrumentationCategory": 1
+  },
+  {
+    "IntegrationName": "OpenFeature",
+    "AssemblyName": "Datadog.FeatureFlags.OpenFeature",
+    "TargetTypeName": "Datadog.FeatureFlags.OpenFeature.FeatureFlagsSdk",
+    "TargetMethodName": "InitializeAsync",
+    "TargetReturnType": "System.Threading.Tasks.Task",
+    "TargetParameterTypes": [
+      "System.Threading.CancellationToken"
+    ],
+    "MinimumVersion": {
+      "Item1": 2,
+      "Item2": 0,
+      "Item3": 0
+    },
+    "MaximumVersion": {
+      "Item1": 2,
+      "Item2": 65535,
+      "Item3": 65535
+    },
+    "InstrumentationTypeName": "Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.OpenFeature.OpenFeatureSdkInitializeAsyncIntegration",
+    "IntegrationKind": 0,
+    "IsAdoNetIntegration": false,
+    "InstrumentationCategory": 1
+  },
   {
     "IntegrationName": "OpenFeature",
     "AssemblyName": "Datadog.FeatureFlags.OpenFeature",

@@ -14,6 +14,7 @@
 using System.Threading.Tasks;
 using OpenFeature;
 using OpenFeature.Constant;
+using OpenFeature.Error;
 using OpenFeature.Model;
 
 namespace Datadog.FeatureFlags.OpenFeature;
@@ -23,6 +24,13 @@ namespace Datadog.FeatureFlags.OpenFeature;
 /// </summary>
 public sealed class DatadogProvider : global::OpenFeature.FeatureProvider, IDisposable
 {
+    // The status this provider last reported, which decides the transitions it owns. The first ready
+    // event is not one of them: OpenFeature synthesizes one as soon as InitializeAsync returns, so
+    // emitting it here as well would run every application handler twice.
+    private const int StatusInitializing = 0;
+    private const int StatusReady = 1;
+    private const int StatusError = 2;
+
     private static Action? _onNewConfig = null;
     private readonly Metadata _metadata = new Metadata("datadog-openfeature-provider");
 #if NET6_0_OR_GREATER
@@ -33,6 +41,8 @@ public sealed class DatadogProvider : global::OpenFeature.FeatureProvider, IDisp
     // nothing is allocated/registered when the feature is disabled.
     private readonly SpanEnrichmentHook? _spanEnrichmentHook;
 
+    private int _status = StatusInitializing;
+
     /// <summary> Initializes a new instance of the <see cref="DatadogProvider"/> class. </summary>
     public DatadogProvider()
     {
@@ -58,19 +68,135 @@ public static void RegisterOnNewConfigEventHandler(Action onNewConfig)
 
     private void SignalGeneralUpdate()
     {
+        // The status event is written before anything the application supplied runs: a handler that
+        // throws must not be able to suppress it.
         try
         {
-            _onNewConfig?.Invoke();
-
-            // You don't have to provide specific flag keys
-            var payload = new ProviderEventPayload
+            if (!FeatureFlagsSdk.HasConfiguration())
             {
-                Message = "A backend update occurred, but specific changes are unknown."
-            };
+                SignalConfigurationUnavailable();
+            }
+            else if (Interlocked.CompareExchange(ref _status, StatusReady, StatusError) == StatusError)
+            {
+                // Configuration is back after a withdrawal, and nothing else promotes the provider:
+                // OpenFeature keeps the error status until a ready event replaces it.
+                SignalReady();
+            }
+            else if (Volatile.Read(ref _status) == StatusReady)
+            {
+                // Specific flag keys are unknown, so this payload only reports that something changed.
+                // An event already queued says exactly the same thing, which is why a full channel is
+                // left alone: the notification is on its way regardless.
+                EventChannel.Writer.TryWrite(CreatePayload(ProviderEventTypes.ProviderConfigurationChanged, "A backend update occurred, but specific changes are unknown."));
+            }
 
-            EventChannel.Writer.TryWrite((object)payload);
+            // Otherwise initialization has not returned yet, and the ready event it produces already
+            // accounts for this configuration.
         }
         catch { }
+
+        try
+        {
+            _onNewConfig?.Invoke();
+        }
+        catch { }
+    }
+
+    private void SignalConfigurationUnavailable()
+    {
+        // Configuration was withdrawn, so every evaluation now returns its default value. Leaving the
+        // status at READY would report a provider that resolves nothing, so an error is emitted; the
+        // next configuration promotes the provider back.
+        if (Interlocked.CompareExchange(ref _status, StatusError, StatusReady) != StatusReady)
+        {
+            // Not reported as ready, so there is no status to correct.
+            return;
+        }
+
+        var payload = CreatePayload(ProviderEventTypes.ProviderError, "Feature flag configuration is unavailable.");
+        payload.ErrorType = ErrorType.ProviderNotReady;
+
+        if (!EventChannel.Writer.TryWrite(payload))
+        {
+            // A status transition cannot be dropped, for the same reason the ready event cannot.
+            _ = WriteWhenRoomAvailableAsync(payload);
+        }
+    }
+
+    private void SignalReady()
+    {
+        var payload = CreatePayload(ProviderEventTypes.ProviderReady, "Feature flag configuration was received.");
+
+        if (EventChannel.Writer.TryWrite(payload))
+        {
+            return;
+        }
+
+        // Unlike a change notification, this one cannot be dropped: losing it would leave the provider
+        // reported as errored even though it can now resolve flags. The channel holds a single item, so
+        // waiting for room happens in the background rather than on the thread applying the
+        // configuration.
+        _ = WriteWhenRoomAvailableAsync(payload);
+    }
+
+    private async Task WriteWhenRoomAvailableAsync(ProviderEventPayload payload)
+    {
+        try
+        {
+            await EventChannel.Writer.WriteAsync(payload).ConfigureAwait(false);
+        }
+        catch
+        {
+            // The channel is completed when the provider is replaced or the SDK shuts down, at which
+            // point this provider's status no longer matters.
+        }
+    }
+
+    private ProviderEventPayload CreatePayload(ProviderEventTypes type, string message)
+        => new ProviderEventPayload
+        {
+            Type = type,
+            Message = message,
+            ProviderName = _metadata.Name,
+        };
+
+    /// <summary>
+    /// Starts flag configuration delivery and waits for the first configuration, so that a ready
+    /// provider can actually resolve flags.
+    /// <para>
+    /// It returns normally when the wait times out, because slow delivery is transient and the
+    /// configuration still arrives afterwards. It throws <see cref="ProviderFatalException"/> when no
+    /// source could start delivery at all, which leaves the provider unable to resolve anything for
+    /// the rest of the process: that is irrecoverable rather than merely not-ready. The exception does
+    /// not reach the application, because OpenFeature handles it while setting the provider.
+    /// </para>
+    /// <para>
+    /// No status event is emitted here. OpenFeature derives the provider's initial status from how
+    /// this method returns, so the provider only reports the transitions that happen afterwards.
+    /// </para>
+    /// </summary>
+    /// <param name="context"> Evaluation context </param>
+    /// <param name="cancellationToken"> Async cancellation token </param>
+    /// <returns> A task that completes when initialization is complete </returns>
+    public override async Task InitializeAsync(EvaluationContext context, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await FeatureFlagsSdk.InitializeAsync(cancellationToken).ConfigureAwait(false);
+        }
+        catch (Exception exception)
+        {
+            Volatile.Write(ref _status, StatusError);
+
+            // Irrecoverable: no source can be started later in this process, so no configuration will
+            // ever arrive and every evaluation returns its default value. OpenFeature reports the error
+            // status from this exception.
+            throw new ProviderFatalException(exception.Message, exception);
+        }
+
+        // Recorded rather than signalled, because OpenFeature marks the provider ready as soon as this
+        // returns. It is what lets a later withdrawal be reported as a transition out of READY.
+        Volatile.Write(ref _status, StatusReady);
     }
 
     /// <summary> Gets provider metadata </summary>

@@ -9,6 +9,8 @@
 using System.ComponentModel;
 using System.Linq;
 using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
 using Datadog.Trace.FeatureFlags;
 using OpenFeature.Constant;
 using OpenFeature.Model;
@@ -32,6 +34,24 @@ internal static class FeatureFlagsSdk
     [MethodImpl(MethodImplOptions.NoInlining)]
     internal static bool IsSpanEnrichmentEnabled() => false;
 
+    /// <summary>
+    /// Gets a value indicating whether flag configuration is currently held, so the provider can
+    /// resolve flags. Goes back to <c>false</c> when configuration is withdrawn.
+    /// </summary>
+    /// <returns> True while configuration is held </returns>
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    internal static bool HasConfiguration() => false;
+
+    /// <summary>
+    /// Activates flag configuration delivery and waits for the first configuration to arrive.
+    /// Delivery only starts here, because requesting configuration is billable and installing the
+    /// tracer alone must not do it.
+    /// </summary>
+    /// <param name="cancellationToken"> Cancellation token. OpenFeature 2.3.0 does not forward one through SetProviderAsync, so only a direct caller supplies it </param>
+    /// <returns> A task that completes once configuration has arrived or the initialization timeout has elapsed, and that faults when no source could start delivery at all </returns>
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static Task InitializeAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+
     /// <summary> Installs an event handler to be fired when a new config has been received </summary>
     /// <param name="onNewConfig"> Action to be called when the event is fired </param>
     [MethodImpl(MethodImplOptions.NoInlining)]

@@ -50,6 +50,10 @@ internal static CallTargetState OnMethodBegin<TTarget>(ref string flagKey, Featu
             return new CallTargetReturn<TReturn?>(returnValue);
         }
 
+        // Manual API users may not call InitializeAsync before Evaluate. Activate delivery as a
+        // fallback so the agentless poller starts on first evaluation, not never.
+        flags.Activate();
+
         var parameters = (State)state.State!;
         var res = flags.Evaluate(parameters.FlagKey, parameters.TargetType, parameters.DefaultValue, parameters.TargetingKey ?? string.Empty, parameters.Attributes);
         var traceContext = tracer.InternalActiveScope?.Span?.Context.TraceContext;

@@ -43,7 +43,13 @@ internal static CallTargetState OnMethodBegin<TTarget>(ref string flagKey, Featu
         }
 
         var parameters = (State)state.State!;
-        var res = TracerManager.Instance.FeatureFlags?.Evaluate(parameters.FlagKey, parameters.TargetType, parameters.DefaultValue, parameters.TargetingKey ?? string.Empty, parameters.Attributes);
+        var flags = TracerManager.Instance.FeatureFlags;
+
+        // Fallback activation: if the user calls Evaluate without InitializeAsync (for example,
+        // via the manual API or an older OpenFeature package), start delivery on first evaluation.
+        flags?.Activate();
+
+        var res = flags?.Evaluate(parameters.FlagKey, parameters.TargetType, parameters.DefaultValue, parameters.TargetingKey ?? string.Empty, parameters.Attributes);
         return new CallTargetReturn<TReturn?>(res.DuckCast<TReturn>());
     }
 

@@ -0,0 +1,39 @@
+// <copyright file="OpenFeatureSdkHasConfigurationIntegration.cs" company="Datadog">
+// Unless explicitly stated otherwise all files in this repository are licensed under the Apache 2 License.
+// This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2017 Datadog, Inc.
+// </copyright>
+#nullable enable
+
+using System;
+using System.ComponentModel;
+using Datadog.Trace.ClrProfiler.CallTarget;
+using Datadog.Trace.Configuration;
+
+namespace Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.OpenFeature;
+
+/// <summary>
+/// System.Boolean Datadog.FeatureFlags.OpenFeature.FeatureFlagsSdk::HasConfiguration() calltarget instrumentation
+/// </summary>
+[InstrumentMethod(
+    AssemblyName = "Datadog.FeatureFlags.OpenFeature",
+    TypeName = "Datadog.FeatureFlags.OpenFeature.FeatureFlagsSdk",
+    MethodName = "HasConfiguration",
+    ReturnTypeName = ClrNames.Bool,
+    ParameterTypeNames = [],
+    MinimumVersion = "2.0.0",
+    MaximumVersion = "2.*.*",
+    IntegrationName = nameof(IntegrationId.OpenFeature))]
+[Browsable(false)]
+[EditorBrowsable(EditorBrowsableState.Never)]
+public sealed class OpenFeatureSdkHasConfigurationIntegration
+{
+    internal static CallTargetReturn<bool> OnMethodEnd<TTarget>(bool returnValue, Exception? exception, in CallTargetState state)
+    {
+        if (exception is not null)
+        {
+            return new CallTargetReturn<bool>(returnValue);
+        }
+
+        return new CallTargetReturn<bool>(TracerManager.Instance.FeatureFlags?.HasConfiguration == true);
+    }
+}
@@ -0,0 +1,54 @@
+// <copyright file="OpenFeatureSdkInitializeAsyncIntegration.cs" company="Datadog">
+// Unless explicitly stated otherwise all files in this repository are licensed under the Apache 2 License.
+// This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2017 Datadog, Inc.
+// </copyright>
+#nullable enable
+
+using System;
+using System.ComponentModel;
+using System.Threading;
+using System.Threading.Tasks;
+using Datadog.Trace.ClrProfiler.CallTarget;
+using Datadog.Trace.Configuration;
+
+namespace Datadog.Trace.ClrProfiler.AutoInstrumentation.ManualInstrumentation.OpenFeature;
+
+/// <summary>
+/// System.Threading.Tasks.Task Datadog.FeatureFlags.OpenFeature.FeatureFlagsSdk::InitializeAsync(System.Threading.CancellationToken) calltarget instrumentation
+/// </summary>
+[InstrumentMethod(
+    AssemblyName = "Datadog.FeatureFlags.OpenFeature",
+    TypeName = "Datadog.FeatureFlags.OpenFeature.FeatureFlagsSdk",
+    MethodName = "InitializeAsync",
+    ReturnTypeName = ClrNames.Task,
+    ParameterTypeNames = [ClrNames.CancellationToken],
+    MinimumVersion = "2.0.0",
+    MaximumVersion = "2.*.*",
+    IntegrationName = nameof(IntegrationId.OpenFeature))]
+[Browsable(false)]
+[EditorBrowsable(EditorBrowsableState.Never)]
+public sealed class OpenFeatureSdkInitializeAsyncIntegration
+{
+    internal static CallTargetState OnMethodBegin<TTarget>(ref CancellationToken cancellationToken)
+        => new CallTargetState(scope: null, state: cancellationToken);
+
+    internal static CallTargetReturn<Task> OnMethodEnd<TTarget>(Task returnValue, Exception? exception, in CallTargetState state)
+    {
+        if (exception is not null)
+        {
+            return new CallTargetReturn<Task>(returnValue);
+        }
+
+        // Agentless polling only starts here, because those requests go straight to Datadog and are
+        // billable, so the tracer must not start them until application code adopts the provider. The
+        // Remote Configuration source is already subscribed by then; this call waits for its first
+        // configuration.
+        if (TracerManager.Instance.FeatureFlags is { } featureFlags)
+        {
+            var cancellationToken = state.State is CancellationToken token ? token : default;
+            return new CallTargetReturn<Task>(featureFlags.InitializeAsync(cancellationToken));
+        }
+
+        return new CallTargetReturn<Task>(returnValue);
+    }
+}