Send EXPOSURE and EVALUATION feature flag features to Datadog

products/feature-flagging/feature-flagging-api/src/main/java/datadog/trace/api/openfeature/DDEvaluator.java

@@ -68,6 +68,27 @@ class DDEvaluator implements Evaluator, FeatureFlaggingGateway.ConfigListener {
   static final AtomicBoolean SPLIT_FEATURES_SUPPORTED =
       new AtomicBoolean(splitFeaturesSupported(Split.class));
 
+  static final AtomicBoolean EXPOSURE_FEATURES_SUPPORTED =
+      new AtomicBoolean(exposureFeaturesSupported(ExposureEvent.class));
+
+  /** An older agent's exposure event has no features; its exposures are then sent without them. */
+  static boolean exposureFeaturesSupported(final Class<?> eventClass) {
+    try {
+      eventClass.getConstructor(
+          long.class,
+          datadog.trace.api.featureflag.exposure.Allocation.class,
+          datadog.trace.api.featureflag.exposure.Flag.class,
+          datadog.trace.api.featureflag.exposure.Variant.class,
+          Subject.class,
+          Integer.class,
+          Map.class);
+      return true;
+    } catch (final NoSuchMethodException | LinkageError | RuntimeException e) {
+      log.debug("The installed Datadog Java agent does not send features on exposures", e);
+      return false;
+    }
+  }
+
   /** An older agent ships a Split without features; its evaluations then carry no features. */
   static boolean splitFeaturesSupported(final Class<?> splitClass) {
     try {
@@ -164,12 +185,19 @@ static boolean exposureSerialIdSupported(final Class<?> eventClass) {
   // Emitted only when the allocation logs exposures: true when this subject's exposure was already
   // sent, so the exposure hook does not send it again.
   static final String METADATA_EXPOSURE_CACHE_HIT = "__dd_exposure_cache_hit";
-  // Each feature of the selected split is copied to the metadata under this prefix.
+  // Each feature of the selected split is copied to the metadata once for each destination it
+  // lists, under that destination's prefix. Only the HOOK prefix is a public contract; the
+  // other two carry features to Datadog's own exposure and flag-evaluation hooks.
   static final String METADATA_FEATURE_PREFIX = "__dd_feature.";
+  static final String METADATA_EXPOSURE_FEATURE_PREFIX = "__dd_exposure_feature.";
+  static final String METADATA_EVALUATION_FEATURE_PREFIX = "__dd_evaluation_feature.";
+  // Present only when the split routes a feature to EVALUATION, so FlagEvalLoggingHook can skip
+  // scanning the metadata on every other evaluation.
+  static final String METADATA_HAS_EVALUATION_FEATURES = "__dd_has_evaluation_features";
 
   static final String FEATURE_DESTINATION_HOOK = "HOOK";
-  private static final Set<String> KNOWN_FEATURE_DESTINATIONS =
-      new HashSet<>(asList(FEATURE_DESTINATION_HOOK, "EXPOSURE", "EVALUATION"));
+  static final String FEATURE_DESTINATION_EXPOSURE = "EXPOSURE";
+  static final String FEATURE_DESTINATION_EVALUATION = "EVALUATION";
   // A newer UFC can name destinations this SDK does not know; warn once per name, not per
   // evaluation.
   static final int MAX_WARNED_FEATURE_DESTINATIONS = 64;
@@ -669,40 +697,62 @@ private static void addSplitFeatures(
     if (split.features == null) {
       return;
     }
+    Set<String> seenKeys = null;
+    boolean evaluationFeatures = false;
     for (final Object item : split.features) {
       if (!(item instanceof Feature)) {
         continue;
       }
       final Feature feature = (Feature) item;
-      if (feature.key == null || !deliversToHook(feature)) {
+      if (feature.key == null || feature.destinations == null) {
         continue;
       }
-      final String key = METADATA_FEATURE_PREFIX + feature.key;
-      if (feature.value instanceof String) {
-        metadataBuilder.addString(key, (String) feature.value);
-      } else if (feature.value instanceof Boolean) {
-        metadataBuilder.addBoolean(key, (Boolean) feature.value);
-      } else if (feature.value instanceof Number) {
-        metadataBuilder.addDouble(key, ((Number) feature.value).doubleValue());
+      if (seenKeys == null) {
+        seenKeys = new HashSet<>();
+      }
+      if (!seenKeys.add(feature.key)) {
+        continue;
+      }
+      for (final String destination : feature.destinations) {
+        final String prefix = metadataPrefix(destination);
+        if (prefix != null) {
+          addFeature(metadataBuilder, prefix + feature.key, feature.value);
+          evaluationFeatures |= prefix.equals(METADATA_EVALUATION_FEATURE_PREFIX);
+        } else if (WARNED_FEATURE_DESTINATIONS.size() < MAX_WARNED_FEATURE_DESTINATIONS
+            && WARNED_FEATURE_DESTINATIONS.add(destination)) {
+          log.warn("Ignoring unknown feature destination {}", destination);
+        }
       }
     }
+    if (evaluationFeatures) {
+      metadataBuilder.addBoolean(METADATA_HAS_EVALUATION_FEATURES, true);
+    }
   }
 
-  private static boolean deliversToHook(final Feature feature) {
-    if (feature.destinations == null) {
-      return false;
+  private static String metadataPrefix(final String destination) {
+    if (FEATURE_DESTINATION_HOOK.equals(destination)) {
+      return METADATA_FEATURE_PREFIX;
     }
-    boolean hook = false;
-    for (final String destination : feature.destinations) {
-      if (FEATURE_DESTINATION_HOOK.equals(destination)) {
-        hook = true;
-      } else if (!KNOWN_FEATURE_DESTINATIONS.contains(destination)
-          && WARNED_FEATURE_DESTINATIONS.size() < MAX_WARNED_FEATURE_DESTINATIONS
-          && WARNED_FEATURE_DESTINATIONS.add(destination)) {
-        log.warn("Ignoring unknown feature destination {}", destination);
-      }
+    if (FEATURE_DESTINATION_EXPOSURE.equals(destination)) {
+      return METADATA_EXPOSURE_FEATURE_PREFIX;
+    }
+    if (FEATURE_DESTINATION_EVALUATION.equals(destination)) {
+      return METADATA_EVALUATION_FEATURE_PREFIX;
+    }
+    return null;
+  }
+
+  private static void addFeature(
+      final ImmutableMetadata.ImmutableMetadataBuilder metadataBuilder,
+      final String key,
+      final Object value) {
+    if (value instanceof String) {
+      metadataBuilder.addString(key, (String) value);
+    } else if (value instanceof Boolean) {
+      metadataBuilder.addBoolean(key, (Boolean) value);
+    } else if (value instanceof Number) {
+      metadataBuilder.addDouble(key, ((Number) value).doubleValue());
     }
-    return hook;
   }
 
   /** The serial id an exposure carries: none when the agent's exposure event predates it. */
@@ -784,7 +834,8 @@ static ExposureEvent exposureEvent(
       final String allocationKey,
       final String variantKey,
       final EvaluationContext context,
-      final Integer serialId) {
+      final Integer serialId,
+      final Map<String, Object> features) {
     final long timestamp = System.currentTimeMillis();
     // Exposure types share names with the imported UFC Allocation, Flag, and Variant types.
     final datadog.trace.api.featureflag.exposure.Allocation allocation =
@@ -795,9 +846,14 @@ static ExposureEvent exposureEvent(
         new datadog.trace.api.featureflag.exposure.Variant(variantKey);
     final Subject subject = new Subject(context.getTargetingKey(), flattenContext(context));
 
-    return EXPOSURE_SERIAL_ID_SUPPORTED.get()
-        ? new ExposureEvent(timestamp, allocation, exposureFlag, variant, subject, serialId)
-        : new ExposureEvent(timestamp, allocation, exposureFlag, variant, subject);
+    if (!EXPOSURE_SERIAL_ID_SUPPORTED.get()) {
+      return new ExposureEvent(timestamp, allocation, exposureFlag, variant, subject);
+    }
+    if (features.isEmpty() || !EXPOSURE_FEATURES_SUPPORTED.get()) {
+      return new ExposureEvent(timestamp, allocation, exposureFlag, variant, subject, serialId);
+    }
+    return new ExposureEvent(
+        timestamp, allocation, exposureFlag, variant, subject, serialId, features);
   }
 
   static AbstractMap<String, Object> flattenContext(final EvaluationContext context) {

products/feature-flagging/feature-flagging-api/src/main/java/datadog/trace/api/openfeature/ExposureHook.java

@@ -8,7 +8,6 @@
 import dev.openfeature.sdk.HookContext;
 import dev.openfeature.sdk.ImmutableMetadata;
 import java.util.Collections;
-import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Consumer;
@@ -137,24 +136,8 @@ private Map<String, Object> metadata() {
      * none.
      */
     public Map<String, Object> getFeatures() {
-      final ImmutableMetadata metadata = details.getFlagMetadata();
-      if (metadata == null) {
-        return Collections.emptyMap();
-      }
-      Map<String, Object> features = null;
-      for (final Map.Entry<String, Object> entry : metadata.asUnmodifiableMap().entrySet()) {
-        if (entry.getKey().startsWith(DDEvaluator.METADATA_FEATURE_PREFIX)) {
-          if (features == null) {
-            features = new HashMap<>();
-          }
-          features.put(
-              entry.getKey().substring(DDEvaluator.METADATA_FEATURE_PREFIX.length()),
-              entry.getValue());
-        }
-      }
-      return features == null
-          ? Collections.<String, Object>emptyMap()
-          : Collections.unmodifiableMap(features);
+      return SplitFeatureMetadata.featuresWithPrefix(
+          details.getFlagMetadata(), DDEvaluator.METADATA_FEATURE_PREFIX);
     }
   }
 }

products/feature-flagging/feature-flagging-api/src/main/java/datadog/trace/api/openfeature/ExposureLoggingHook.java

@@ -73,7 +73,14 @@ public void finallyAfter(
       cache.record(flag, context.getTargetingKey(), allocationKey, variantKey, serialId);
       if (sendToDatadog) {
         FeatureFlaggingGateway.dispatch(
-            DDEvaluator.exposureEvent(flag, allocationKey, variantKey, context, serialId));
+            DDEvaluator.exposureEvent(
+                flag,
+                allocationKey,
+                variantKey,
+                context,
+                serialId,
+                SplitFeatureMetadata.featuresWithPrefix(
+                    metadata, DDEvaluator.METADATA_EXPOSURE_FEATURE_PREFIX)));
       }
     } catch (LinkageError e) {
       // Never let exposure reporting break flag evaluation.

products/feature-flagging/feature-flagging-api/src/main/java/datadog/trace/api/openfeature/FlagEvalLoggingHook.java

@@ -9,7 +9,10 @@
 import dev.openfeature.sdk.ImmutableMetadata;
 import java.util.Collections;
 import java.util.Map;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Supplier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
  * OpenFeature Hook that captures flag evaluation events for EVP flagevaluation emission.
@@ -33,6 +36,33 @@
  */
 class FlagEvalLoggingHook<T> implements Hook<T> {
 
+  private static final Logger log = LoggerFactory.getLogger(FlagEvalLoggingHook.class);
+
+  static final AtomicBoolean FEATURES_SUPPORTED =
+      new AtomicBoolean(featuresSupported(FlagEvalEvent.class));
+
+  /**
+   * An older agent's flag-evaluation event has no features; its rows are then sent without them.
+   */
+  static boolean featuresSupported(final Class<?> eventClass) {
+    try {
+      eventClass.getConstructor(
+          String.class,
+          String.class,
+          String.class,
+          String.class,
+          String.class,
+          long.class,
+          boolean.class,
+          Map.class,
+          Map.class);
+      return true;
+    } catch (final NoSuchMethodException | LinkageError | RuntimeException e) {
+      log.debug("The installed Datadog Java agent does not send features on flag evaluations", e);
+      return false;
+    }
+  }
+
   /**
    * Singleton instance: always registered when the provider is created; harmless when writer=null
    * (killswitch off or not yet started).
@@ -98,11 +128,17 @@ public void finallyAfter(
       final ImmutableMetadata metadata = details.getFlagMetadata();
 
       // allocationKey: "allocationKey" (camelCase) - consistent with FlagEvalMetricsHook.java
-      final String allocationKey = metadata != null ? metadata.getString("allocationKey") : null;
+      // The ImmutableMetadata getters build a debug message for every absent key.
+      final Map<String, Object> values =
+          metadata == null ? Collections.<String, Object>emptyMap() : metadata.asUnmodifiableMap();
+      final Object allocationValue = values.get("allocationKey");
+      final String allocationKey =
+          allocationValue instanceof String ? (String) allocationValue : null;
 
       // eval-time: from flag metadata "__dd_eval_timestamp_ms" (Long), fallback to hook-fire time.
       // ImmutableMetadata.getLong available since sdk 1.4+.
-      final Long evalTimeObj = metadata != null ? metadata.getLong("__dd_eval_timestamp_ms") : null;
+      final Object evalTimeValue = values.get("__dd_eval_timestamp_ms");
+      final Long evalTimeObj = evalTimeValue instanceof Long ? (Long) evalTimeValue : null;
       final long evalTimeMs = evalTimeObj != null ? evalTimeObj : System.currentTimeMillis();
 
       // variant: the OpenFeature variant key (same source as the OTel FlagEvalMetricsHook), NOT the
@@ -115,10 +151,9 @@ public void finallyAfter(
 
       // Consent is read from metadata stamped by DDEvaluator (pinned to its ServerConfiguration).
       // Missing key = non-DD provider → false, the privacy-preserving default.
+      final Object consentValue = values.get(DDEvaluator.METADATA_OBSERVE_FULL_EVALUATION_DATA);
       final Boolean consentFromMetadata =
-          metadata != null
-              ? metadata.getBoolean(DDEvaluator.METADATA_OBSERVE_FULL_EVALUATION_DATA)
-              : null;
+          consentValue instanceof Boolean ? (Boolean) consentValue : null;
       final boolean observeFullEvaluationData = consentFromMetadata != null && consentFromMetadata;
 
       // Error message: prefer the human-readable message under consent-on; under consent-off the
@@ -151,16 +186,34 @@ public void finallyAfter(
         attrs = Collections.emptyMap();
       }
 
+      // Features come from the flag configuration, not the evaluation context, so they are sent
+      // whatever the consent.
+      final Map<String, Object> features =
+          Boolean.TRUE.equals(values.get(DDEvaluator.METADATA_HAS_EVALUATION_FEATURES))
+              ? SplitFeatureMetadata.featuresWithPrefix(
+                  metadata, DDEvaluator.METADATA_EVALUATION_FEATURE_PREFIX)
+              : Collections.<String, Object>emptyMap();
       w.enqueue(
-          new FlagEvalEvent(
-              flagKey,
-              variant,
-              allocationKey,
-              targetingKey,
-              errorMessage,
-              evalTimeMs,
-              observeFullEvaluationData,
-              attrs));
+          features.isEmpty() || !FEATURES_SUPPORTED.get()
+              ? new FlagEvalEvent(
+                  flagKey,
+                  variant,
+                  allocationKey,
+                  targetingKey,
+                  errorMessage,
+                  evalTimeMs,
+                  observeFullEvaluationData,
+                  attrs)
+              : new FlagEvalEvent(
+                  flagKey,
+                  variant,
+                  allocationKey,
+                  targetingKey,
+                  errorMessage,
+                  evalTimeMs,
+                  observeFullEvaluationData,
+                  attrs,
+                  features));
     } catch (LinkageError e) {
       // Never let EVP recording break flag evaluation
     }

products/feature-flagging/feature-flagging-api/src/main/java/datadog/trace/api/openfeature/SplitFeatureMetadata.java

@@ -0,0 +1,36 @@
+package datadog.trace.api.openfeature;
+
+import dev.openfeature.sdk.ImmutableMetadata;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Reads the split features that {@link DDEvaluator} copies into flag metadata. It depends only on
+ * the OpenFeature API, so {@link ExposureHook} keeps working where the Datadog Java agent is
+ * absent.
+ */
+final class SplitFeatureMetadata {
+
+  private SplitFeatureMetadata() {}
+
+  /** The features stored in the metadata under {@code prefix}, keyed without the prefix. */
+  static Map<String, Object> featuresWithPrefix(
+      final ImmutableMetadata metadata, final String prefix) {
+    if (metadata == null) {
+      return Collections.emptyMap();
+    }
+    Map<String, Object> features = null;
+    for (final Map.Entry<String, Object> entry : metadata.asUnmodifiableMap().entrySet()) {
+      if (entry.getKey().startsWith(prefix)) {
+        if (features == null) {
+          features = new HashMap<>();
+        }
+        features.put(entry.getKey().substring(prefix.length()), entry.getValue());
+      }
+    }
+    return features == null
+        ? Collections.<String, Object>emptyMap()
+        : Collections.unmodifiableMap(features);
+  }
+}