feat: match stable config java properties on other operator than 'contains'

Author: paullegranddc

internal-api/src/main/java/datadog/trace/bootstrap/config/provider/StableConfigParser.java

@@ -104,35 +104,27 @@ private static boolean doesRuleMatch(Rule rule) {
     return true; // Return true if all selectors match
   }
 
-  private static boolean validOperatorForLanguageOrigin(String operator) {
-    operator = operator.toLowerCase();
-    // "exists" is not valid
-    switch (operator) {
-      case "equals":
-      case "starts_with":
-      case "ends_with":
-      case "contains":
-        return true;
-      default:
-        return false;
-    }
-  }
-
-  private static boolean checkEnvMatches(
-      List<String> values, List<String> matches, BiPredicate<String, String> compareFunc) {
-    // envValue shouldn't be null, but doing an extra check to avoid NullPointerException on
-    // compareFunc.test
-    if (values == null) {
+  private static boolean matchOperator(String value, String operator, List<String> matches, String match) {
+    // not sure if these are nullable, but the semantics make sense
+    // and that will save us from a NPE
+    if (value == null || matches == null || operator == null) {
       return false;
     }
+    value = value.toLowerCase();
     for (String match : matches) {
-      if (match == null) {
-        continue;
-      }
-      for (String value : values) {
-        if (compareFunc.test(value, match.toLowerCase())) {
+      switch (operator) {
+        case "equals":
+          return value == match;
+        case "starts_with":
+          return value.startsWith(match);
+        case "ends_with":
+          return value.endsWith(match);
+        case "contains":
+          return value.contains(match);
+        case "exists":
           return true;
-        }
+        default:
+          return false;
       }
     }
     return false;
@@ -141,53 +133,32 @@ private static boolean checkEnvMatches(
   // We do all of the case insensitivity modifications in this function, because each selector will
   // be viewed just once
   static boolean selectorMatch(String origin, List<String> matches, String operator, String key) {
+    operator = operator.toLowerCase();
     switch (origin.toLowerCase()) {
       case "language":
-        if (!validOperatorForLanguageOrigin(operator)) {
-          return false;
-        }
-        for (String entry : matches) {
-          // loose match on any reference to "*java*"
-          if (entry.toLowerCase().contains("java")) {
-            return true;
-          }
-        }
+        return matchOperator("java", operator, matches);
       case "environment_variables":
         if (key == null) {
-          return false;
+            return false;
         }
-        String envValue = System.getenv(key.toUpperCase());
-        if (envValue == null) {
+        String value = System.getenv(key.toUpperCase());
+        if (value == null) {
           return false;
         }
-        envValue = envValue.toLowerCase();
-        switch (operator.toLowerCase()) {
-          case "exists":
-            // We don't care about the value
-            return true;
-          case "equals":
-            return checkEnvMatches(
-                Collections.singletonList(envValue), matches, String::equalsIgnoreCase);
-          case "starts_with":
-            return checkEnvMatches(
-                Collections.singletonList(envValue), matches, String::startsWith);
-          case "ends_with":
-            return checkEnvMatches(Collections.singletonList(envValue), matches, String::endsWith);
-          case "contains":
-            return checkEnvMatches(Collections.singletonList(envValue), matches, String::contains);
-          default:
-            return false;
-        }
+        return matchOperator(value, operator, matches, key);
       case "process_arguments":
+        if (key == null) {
+          return false;
+        }
         // TODO: flesh out the meaning of each operator for process_arguments
         if (!key.startsWith("-D")) {
           log.warn(
               "Ignoring unsupported process_arguments entry in selector match, '{}'. Only system properties specified with the '-D' prefix are supported.",
               key);
           return false;
         }
-        // Cut the -D prefix
-        return System.getProperty(key.substring(2)) != null;
+        String value = System.getProperty(key.substring(2));
+        return matchOperator(value, operator, matches, key);      
       case "tags":
         // TODO: Support this down the line (Must define the source of "tags" first)
         return false;