Always include allocation keys in the result

Author: manuel-alvarez-alvarez

products/openfeature/src/main/java/datadog/trace/api/openfeature/DDFeatureFlagEvaluator.java

@@ -370,18 +370,16 @@ private static <T> ProviderEvaluation<T> resolveVariant(
     final ImmutableMetadata.ImmutableMetadataBuilder metadataBuilder =
         ImmutableMetadata.builder()
             .addString("flagKey", flag.key)
-            .addString("variationType", flag.variationType.name());
-    final boolean doLog = allocation.doLog != null && allocation.doLog;
-    if (doLog) {
-      metadataBuilder.addString("allocationKey", allocation.key);
-    }
+            .addString("variationType", flag.variationType.name())
+            .addString("allocationKey", allocation.key);
     final ProviderEvaluation<T> result =
         ProviderEvaluation.<T>builder()
             .value(mapValue(target, variant.value))
             .reason(Reason.TARGETING_MATCH.name())
             .variant(variant.key)
             .flagMetadata(metadataBuilder.build())
             .build();
+    final boolean doLog = allocation.doLog != null && allocation.doLog;
     if (doLog) {
       dispatchExposure(key, result, context);
     }

products/openfeature/src/test/java/datadog/trace/api/openfeature/DDFeatureFlagEvaluatorTest.java

@@ -353,12 +353,8 @@ private static List<TestCase<?>> evaluateTestCases() {
                 new Result<>("tracked-value")
                     .reason(TARGETING_MATCH.name())
                     .variant("tracked")
-                    .flagMetadata("allocationKey", "exposure-alloc")),
-        new TestCase<>("default")
-            .flag("double-comparison-flag")
-            .targetingKey("user-123")
-            .context("score", 3.14159)
-            .result(new Result<>("exact-match").reason(TARGETING_MATCH.name()).variant("exact")),
+                    .flagMetadata("allocationKey", "exposure-alloc")
+                    .flagMetadata("doLog", true)),
         new TestCase<>("default")
             .flag("exposure-logging-flag")
             .targetingKey("user-exposure")
@@ -367,7 +363,13 @@ private static List<TestCase<?>> evaluateTestCases() {
                 new Result<>("logged-value")
                     .reason(TARGETING_MATCH.name())
                     .variant("logged")
-                    .flagMetadata("allocationKey", "logged-alloc")),
+                    .flagMetadata("allocationKey", "logged-alloc")
+                    .flagMetadata("doLog", true)),
+        new TestCase<>("default")
+            .flag("double-comparison-flag")
+            .targetingKey("user-123")
+            .context("score", 3.14159)
+            .result(new Result<>("exact-match").reason(TARGETING_MATCH.name()).variant("exact")),
         new TestCase<>("default")
             .flag("numeric-one-of-flag")
             .targetingKey("user-123")
@@ -484,12 +486,16 @@ public <E> void testEvaluate(final TestCase<E> testCase) {
     assertThat(details.getReason(), oneOf(expected.reason));
     assertThat(details.getVariant(), equalTo(expected.variant));
     assertThat(details.getErrorCode(), equalTo(expected.errorCode));
-    if (details.getFlagMetadata().getString("allocationKey") != null) {
+    assertThat(details.getErrorCode(), equalTo(expected.errorCode));
+    final String expectedAllocation = (String) expected.flagMetadata.get("allocationKey");
+    if (expectedAllocation != null) {
+      assertThat(details.getFlagMetadata().getString("allocationKey"), equalTo(expectedAllocation));
+    }
+    if (shouldDispatchExposure(expected)) {
       verify(exposureListener, times(1)).accept(exposureEventCaptor.capture());
       final ExposureEvent capturedEvent = exposureEventCaptor.getValue();
       assertThat(capturedEvent.flag.key, equalTo(testCase.flag));
-      assertThat(
-          capturedEvent.allocation.key, equalTo(testCase.result.flagMetadata.get("allocationKey")));
+      assertThat(capturedEvent.allocation.key, equalTo(expectedAllocation));
       assertThat(capturedEvent.variant.key, equalTo(testCase.result.variant));
       assertThat(capturedEvent.subject.id, equalTo(testCase.context.getTargetingKey()));
       for (final Map.Entry<String, Object> entry : testCase.context.asObjectMap().entrySet()) {
@@ -500,6 +506,11 @@ public <E> void testEvaluate(final TestCase<E> testCase) {
     }
   }
 
+  private static boolean shouldDispatchExposure(final Result<?> result) {
+    final Boolean doLog = (Boolean) result.flagMetadata.get("doLog");
+    return doLog != null && doLog;
+  }
+
   private ServerConfiguration createTestConfiguration() {
     final Map<String, Flag> flags = new HashMap<>();
     flags.put(
@@ -526,8 +537,8 @@ private ServerConfiguration createTestConfiguration() {
     flags.put("double-equals-flag", createDoubleEqualsFlag());
     flags.put("nested-attr-flag", createNestedAttributeFlag());
     flags.put("exposure-flag", createExposureFlag());
-    flags.put("double-comparison-flag", createDoubleComparisonFlag());
     flags.put("exposure-logging-flag", createExposureLoggingFlag());
+    flags.put("double-comparison-flag", createDoubleComparisonFlag());
     flags.put("numeric-one-of-flag", createNumericOneOfFlag());
     flags.put("numeric-not-one-of-flag", createNumericNotOneOfFlag());
     flags.put("is-null-false-flag", createIsNullFalseFlag());