[Feature Flags] Advertise dependent flag support to Remote Configuration

tracer/src/Datadog.FeatureFlags.OpenFeature/DatadogProvider.Experimental.cs

@@ -118,6 +118,7 @@ internal static ResolutionDetails<T> RunProviderHooks<T>(IImmutableList<Hook> ho
         }
 
         var details = ToDetails(resolution);
+        var originalMetadata = resolution.FlagMetadata;
         Exception? error = resolution.ErrorType == ErrorType.None ? null : new FeatureProviderException(resolution.ErrorType, resolution.ErrorMessage);
         if (error is null)
         {
@@ -167,6 +168,14 @@ internal static ResolutionDetails<T> RunProviderHooks<T>(IImmutableList<Hook> ho
             }
         }
 
+        foreach (var hook in hooks)
+        {
+            if (hook is ExposureCommitHook exposureCommitHook)
+            {
+                exposureCommitHook.Complete(originalMetadata, resolution.ErrorType == ErrorType.None);
+            }
+        }
+
         return resolution;
     }
 
@@ -188,7 +197,7 @@ private static void Wait(ValueTask task)
     private ResolutionDetails<T> ResolveSync<T>(string flagKey, Trace.FeatureFlags.ValueType valueType, FlagValueType flagValueType, T defaultValue, EvaluationContext? context, CancellationToken cancellationToken)
     {
         cancellationToken.ThrowIfCancellationRequested();
-        var resolution = FeatureFlagsSdk.Resolve(flagKey, valueType, defaultValue, context, _evaluate, _evpHook);
+        var resolution = FeatureFlagsSdk.Resolve(flagKey, valueType, defaultValue, context, _evaluate, _evpHook, _exposureCommitHook);
         return _providerHooks.Count == 0
             ? resolution
             : RunProviderHooks(_providerHooks, new HookContext<T>(flagKey, defaultValue, flagValueType, DirectClientMetadata, _metadata, context ?? EvaluationContext.Empty), resolution);

tracer/src/Datadog.FeatureFlags.OpenFeature/DatadogProvider.cs

@@ -43,6 +43,7 @@ public sealed partial class DatadogProvider : global::OpenFeature.FeatureProvide
     private readonly SpanEnrichmentHook? _spanEnrichmentHook;
     // Startup gate: enabling events later requires a new provider (or application restart).
     private readonly FlagEvalEVPHook? _evpHook;
+    private readonly ExposureCommitHook _exposureCommitHook = new();
 
     // Hooks are fixed at construction, so the list is built once per provider and reused for every evaluation.
     private readonly IImmutableList<Hook> _providerHooks;
@@ -233,7 +234,7 @@ public override async Task InitializeAsync(EvaluationContext context, Cancellati
     public override Task<ResolutionDetails<bool>> ResolveBooleanValueAsync(string flagKey, bool defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default)
     {
         cancellationToken.ThrowIfCancellationRequested();
-        var res = FeatureFlagsSdk.Resolve<bool>(flagKey, Trace.FeatureFlags.ValueType.Boolean, defaultValue, context, _evaluate, _evpHook);
+        var res = FeatureFlagsSdk.Resolve<bool>(flagKey, Trace.FeatureFlags.ValueType.Boolean, defaultValue, context, _evaluate, _evpHook, _exposureCommitHook);
         return Task.FromResult(res);
     }
 
@@ -246,7 +247,7 @@ public override Task<ResolutionDetails<bool>> ResolveBooleanValueAsync(string fl
     public override Task<ResolutionDetails<double>> ResolveDoubleValueAsync(string flagKey, double defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default)
     {
         cancellationToken.ThrowIfCancellationRequested();
-        var res = FeatureFlagsSdk.Resolve<double>(flagKey, Trace.FeatureFlags.ValueType.Numeric, defaultValue, context, _evaluate, _evpHook);
+        var res = FeatureFlagsSdk.Resolve<double>(flagKey, Trace.FeatureFlags.ValueType.Numeric, defaultValue, context, _evaluate, _evpHook, _exposureCommitHook);
         return Task.FromResult(res);
     }
 
@@ -259,7 +260,7 @@ public override Task<ResolutionDetails<double>> ResolveDoubleValueAsync(string f
     public override Task<ResolutionDetails<int>> ResolveIntegerValueAsync(string flagKey, int defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default)
     {
         cancellationToken.ThrowIfCancellationRequested();
-        var res = FeatureFlagsSdk.Resolve<int>(flagKey, Trace.FeatureFlags.ValueType.Integer, defaultValue, context, _evaluate, _evpHook);
+        var res = FeatureFlagsSdk.Resolve<int>(flagKey, Trace.FeatureFlags.ValueType.Integer, defaultValue, context, _evaluate, _evpHook, _exposureCommitHook);
         return Task.FromResult(res);
     }
 
@@ -272,7 +273,7 @@ public override Task<ResolutionDetails<int>> ResolveIntegerValueAsync(string fla
     public override Task<ResolutionDetails<string>> ResolveStringValueAsync(string flagKey, string defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default)
     {
         cancellationToken.ThrowIfCancellationRequested();
-        var res = FeatureFlagsSdk.Resolve<string>(flagKey, Trace.FeatureFlags.ValueType.String, defaultValue, context, _evaluate, _evpHook);
+        var res = FeatureFlagsSdk.Resolve<string>(flagKey, Trace.FeatureFlags.ValueType.String, defaultValue, context, _evaluate, _evpHook, _exposureCommitHook);
         return Task.FromResult(res);
     }
 
@@ -285,7 +286,7 @@ public override Task<ResolutionDetails<string>> ResolveStringValueAsync(string f
     public override Task<ResolutionDetails<Value>> ResolveStructureValueAsync(string flagKey, Value defaultValue, EvaluationContext? context = null, CancellationToken cancellationToken = default)
     {
         cancellationToken.ThrowIfCancellationRequested();
-        var res = FeatureFlagsSdk.Resolve<Value>(flagKey, Trace.FeatureFlags.ValueType.Json, defaultValue, context, _evaluate, _evpHook);
+        var res = FeatureFlagsSdk.Resolve<Value>(flagKey, Trace.FeatureFlags.ValueType.Json, defaultValue, context, _evaluate, _evpHook, _exposureCommitHook);
         return Task.FromResult(res);
     }
 
@@ -308,17 +309,17 @@ private IImmutableList<Hook> CreateProviderHooks()
 #if NET6_0_OR_GREATER
         if (_spanEnrichmentHook is not null)
         {
-            return _evpHook is null ? ImmutableList.Create<Hook>(_metricsHook, _spanEnrichmentHook) : ImmutableList.Create<Hook>(_metricsHook, _spanEnrichmentHook, _evpHook);
+            return _evpHook is null ? ImmutableList.Create<Hook>(_metricsHook, _spanEnrichmentHook, _exposureCommitHook) : ImmutableList.Create<Hook>(_metricsHook, _spanEnrichmentHook, _evpHook, _exposureCommitHook);
         }
 
-        return _evpHook is null ? ImmutableList.Create<Hook>(_metricsHook) : ImmutableList.Create<Hook>(_metricsHook, _evpHook);
+        return _evpHook is null ? ImmutableList.Create<Hook>(_metricsHook, _exposureCommitHook) : ImmutableList.Create<Hook>(_metricsHook, _evpHook, _exposureCommitHook);
 #else
         if (_spanEnrichmentHook is not null)
         {
-            return _evpHook is null ? ImmutableList.Create<Hook>(_spanEnrichmentHook) : ImmutableList.Create<Hook>(_spanEnrichmentHook, _evpHook);
+            return _evpHook is null ? ImmutableList.Create<Hook>(_spanEnrichmentHook, _exposureCommitHook) : ImmutableList.Create<Hook>(_spanEnrichmentHook, _evpHook, _exposureCommitHook);
         }
 
-        return _evpHook is null ? ImmutableList<Hook>.Empty : ImmutableList.Create<Hook>(_evpHook);
+        return _evpHook is null ? ImmutableList.Create<Hook>(_exposureCommitHook) : ImmutableList.Create<Hook>(_evpHook, _exposureCommitHook);
 #endif
     }
 }

tracer/src/Datadog.FeatureFlags.OpenFeature/ExposureCommitHook.cs

@@ -0,0 +1,80 @@
+// <copyright file="ExposureCommitHook.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.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
+using OpenFeature;
+using OpenFeature.Constant;
+using OpenFeature.Model;
+
+namespace Datadog.FeatureFlags.OpenFeature;
+
+internal sealed class ExposureCommitHook : Hook
+{
+    private readonly ConditionalWeakTable<ImmutableMetadata, CommitOwner> _commits = new();
+
+    internal void Capture(ImmutableMetadata? metadata, Action? commit)
+    {
+        try
+        {
+            if (metadata is not null && commit is not null)
+            {
+                // The immutable metadata instance is unique to one OpenFeature invocation. The weak
+                // key prevents an abandoned provider result from retaining its pending exposure batch.
+                _commits.Add(metadata, new CommitOwner(commit));
+            }
+        }
+        catch
+        {
+            // Exposure reporting is best effort and must never affect the application result.
+        }
+    }
+
+    internal void Complete(ImmutableMetadata? metadata, bool success)
+    {
+        try
+        {
+            if (metadata is not null && _commits.TryGetValue(metadata, out var owner))
+            {
+                _commits.Remove(metadata);
+                owner.Complete(success);
+            }
+        }
+        catch
+        {
+            // Exposure reporting is best effort and must never affect the application result.
+        }
+    }
+
+    public override ValueTask FinallyAsync<T>(
+        HookContext<T> context,
+        FlagEvaluationDetails<T> details,
+        IReadOnlyDictionary<string, object>? hints = null,
+        CancellationToken cancellationToken = default)
+    {
+        Complete(details.FlagMetadata, details.ErrorType == ErrorType.None);
+
+        return default;
+    }
+
+    private sealed class CommitOwner(Action commit)
+    {
+        private Action? _commit = commit;
+
+        public void Complete(bool success)
+        {
+            var action = Interlocked.Exchange(ref _commit, null);
+            if (success)
+            {
+                action?.Invoke();
+            }
+        }
+    }
+}

tracer/src/Datadog.FeatureFlags.OpenFeature/FlagEvalMetricsHook.cs

@@ -45,9 +45,7 @@ public override ValueTask FinallyAsync<T>(
             var flagKey = context.FlagKey;
             var variant = details.Variant ?? string.Empty;
 
-            // Reason is already in lower_snake_case format from the provider
-            // Use "unknown" as fallback for missing reason (matches OpenFeature SDK telemetry convention)
-            var reason = string.IsNullOrEmpty(details.Reason) ? "unknown" : details.Reason;
+            var reason = ToTelemetryReason(details.Reason);
 
             // Extract error type if present
             string? errorType = null;
@@ -76,6 +74,22 @@ public void Dispose()
         _metrics.Dispose();
     }
 
+    // OpenFeature reasons are canonical uppercase strings, while the Datadog telemetry
+    // convention uses lower_snake_case tags. Cache the standard mappings on this hot path.
+    private static string ToTelemetryReason(string? reason) => reason switch
+    {
+        null or "" => "unknown",
+        Reason.TargetingMatch => "targeting_match",
+        Reason.Split => "split",
+        Reason.Disabled => "disabled",
+        Reason.Default => "default",
+        Reason.Static => "static",
+        Reason.Cached => "cached",
+        Reason.Unknown => "unknown",
+        Reason.Error => "error",
+        _ => reason.ToLowerInvariant()
+    };
+
     private static string ErrorTypeToString(ErrorType errorType)
     {
         return errorType switch