fix(openfeature): return PARSE_ERROR for invalid regex in flag condition

Author: typotter

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

@@ -38,6 +38,7 @@
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.regex.Pattern;
+import java.util.regex.PatternSyntaxException;
 
 class DDEvaluator implements Evaluator, FeatureFlaggingGateway.ConfigListener {
 
@@ -147,6 +148,8 @@ public <T> ProviderEvaluation<T> evaluate(
           .value(defaultValue)
           .reason(Reason.DEFAULT.name())
           .build();
+    } catch (final PatternSyntaxException e) {
+      return error(defaultValue, ErrorCode.PARSE_ERROR, e);
     } catch (final NumberFormatException e) {
       return error(defaultValue, ErrorCode.TYPE_MISMATCH, e);
     } catch (final Exception e) {
@@ -250,12 +253,10 @@ private static boolean evaluateCondition(
   }
 
   private static boolean matchesRegex(final Object attributeValue, final Object conditionValue) {
-    try {
-      final Pattern pattern = Pattern.compile(String.valueOf(conditionValue));
-      return pattern.matcher(String.valueOf(attributeValue)).find();
-    } catch (Exception e) {
-      return false;
-    }
+    // PatternSyntaxException is intentionally not caught here so it propagates to evaluate(),
+    // which maps it to ErrorCode.PARSE_ERROR.
+    final Pattern pattern = Pattern.compile(String.valueOf(conditionValue));
+    return pattern.matcher(String.valueOf(attributeValue)).find();
   }
 
   private static boolean isOneOf(final Object attributeValue, final Object conditionValue) {

products/feature-flagging/feature-flagging-api/src/test/java/datadog/trace/api/openfeature/DDEvaluatorTest.java

@@ -462,7 +462,12 @@ private static List<TestCase<?>> evaluateTestCases() {
             .result(
                 new Result<>("null-handled")
                     .reason(TARGETING_MATCH.name())
-                    .variant("null-variant")));
+                    .variant("null-variant")),
+        new TestCase<>("default")
+            .flag("invalid-regex-flag")
+            .targetingKey("user-123")
+            .context("email", "user@example.com")
+            .result(new Result<>("default").reason(ERROR.name()).errorCode(ErrorCode.PARSE_ERROR)));
   }
 
   @MethodSource("evaluateTestCases")
@@ -551,6 +556,7 @@ private ServerConfiguration createTestConfiguration() {
     flags.put("not-one-of-false-flag", createNotOneOfFalseFlag());
     flags.put("null-context-values-flag", createNullContextValuesFlag());
     flags.put("country-rule-flag", createCountryRuleFlag());
+    flags.put("invalid-regex-flag", createInvalidRegexFlag());
     return new ServerConfiguration(null, null, null, flags);
   }
 
@@ -1236,6 +1242,22 @@ private Flag createCountryRuleFlag() {
         asList(usAllocation, globalAllocation));
   }
 
+  private Flag createInvalidRegexFlag() {
+    final Map<String, Variant> variants = new HashMap<>();
+    variants.put("matched", new Variant("matched", "matched-value"));
+
+    // Condition with an intentionally invalid regex pattern (unclosed bracket)
+    final List<ConditionConfiguration> conditions =
+        singletonList(new ConditionConfiguration(ConditionOperator.MATCHES, "email", "[invalid"));
+    final List<Rule> rules = singletonList(new Rule(conditions));
+    final List<Split> splits = singletonList(new Split(emptyList(), "matched", null));
+    final Allocation allocation =
+        new Allocation("invalid-regex-alloc", rules, null, null, splits, false);
+
+    return new Flag(
+        "invalid-regex-flag", true, ValueType.STRING, variants, singletonList(allocation));
+  }
+
   private static Map<String, Object> mapOf(final Object... props) {
     final Map<String, Object> result = new HashMap<>(props.length << 1);
     int index = 0;