init: adding System.getenv forbiddenAPI, ConfigHelper, ParseSupportedConfigurations, and DD_ linting logger

Author: mhlidd

build.gradle

@@ -66,6 +66,7 @@ spotlessPredeclare {
   }
 }
 apply from: "$rootDir/gradle/spotless.gradle"
+apply from: "$rootDir/gradle/logEnvVarUsages.gradle"
 
 def compileTask = tasks.register("compile")
 

components/environment/build.gradle.kts

@@ -3,6 +3,11 @@ plugins {
   id("com.gradleup.shadow")
 }
 
+dependencies {
+  implementation(project(":components:json"))
+  implementation("org.slf4j:slf4j-api:1.7.36")
+}
+
 apply(from = "$rootDir/gradle/java.gradle")
 
 /*

components/environment/src/main/java/datadog/environment/ConfigHelper.java

@@ -0,0 +1,76 @@
+package datadog.environment;
+
+import de.thetaphi.forbiddenapis.SuppressForbidden;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+@SuppressForbidden
+public class ConfigHelper {
+  // Parse the supported-configurations JSON once using ParseSupportedConfigurations.
+
+  public static Map<String, String> getEnvironmentVariables() {
+    // TODO: Remove once JSON parsing is separate from data access
+    ParseSupportedConfigurations.loadSupportedConfigurations("supported-configurations.json");
+
+    Map<String, String> env = System.getenv();
+    Map<String, String> configs = new LinkedHashMap<>();
+    for (Map.Entry<String, String> entry : env.entrySet()) {
+      String key = entry.getKey();
+      String value = entry.getValue();
+      if (key.startsWith("DD_")
+          || key.startsWith("OTEL_")
+          || ParseSupportedConfigurations.aliasMapping.containsKey(key)) {
+        if (ParseSupportedConfigurations.supportedConfigurations.contains(key)) {
+          configs.put(key, value);
+          // If this environment variable is the alias of another, and we haven't processed the
+          // original environment variable yet, handle it here.
+        } else if (ParseSupportedConfigurations.aliasMapping.containsKey(key)
+            && !configs.containsKey(ParseSupportedConfigurations.aliasMapping.get(key))) {
+          List<String> aliasList =
+              ParseSupportedConfigurations.aliases.get(
+                  ParseSupportedConfigurations.aliasMapping.get(key));
+          for (String alias : aliasList) {
+            if (env.containsKey(alias)) {
+              configs.put(ParseSupportedConfigurations.aliasMapping.get(key), env.get(alias));
+              break;
+            }
+          }
+        }
+        //        if (deprecatedConfigurations.containsKey(key)) {
+        //          String warning = "Environment variable " + key + " is deprecated. " +
+        //              (aliasMapping.containsKey(key)
+        //                  ? "Please use " + aliasMapping.get(key) + " instead."
+        //                  : deprecatedConfigurations.get(key));
+        //          System.err.println(warning); // TODO: REPLACE with log call
+        //        }
+      } else {
+        configs.put(key, value);
+      }
+    }
+    return configs;
+  }
+
+  public static String getEnvironmentVariable(String name) {
+    // TODO: Remove once JSON parsing is separate from data access
+    ParseSupportedConfigurations.loadSupportedConfigurations("supported-configurations.json");
+
+    if ((name.startsWith("DD_")
+            || name.startsWith("OTEL_")
+            || ParseSupportedConfigurations.aliasMapping.containsKey(name))
+        && !ParseSupportedConfigurations.supportedConfigurations.contains(name)) {
+      throw new IllegalArgumentException(
+          "Missing " + name + " env/configuration in supported-configurations.json file.");
+    }
+    String config = System.getenv(name);
+    if (config == null && ParseSupportedConfigurations.aliases.containsKey(name)) {
+      for (String alias : ParseSupportedConfigurations.aliases.get(name)) {
+        String aliasValue = System.getenv(alias);
+        if (aliasValue != null) {
+          return aliasValue;
+        }
+      }
+    }
+    return config;
+  }
+}

components/environment/src/main/java/datadog/environment/EnvironmentVariables.java

@@ -32,7 +32,7 @@ private EnvironmentVariables() {}
    */
   public static String getOrDefault(@Nonnull String name, String defaultValue) {
     try {
-      String value = System.getenv(name);
+      String value = ConfigHelper.getEnvironmentVariable(name);
       return value == null ? defaultValue : value;
     } catch (SecurityException e) {
       return defaultValue;

components/environment/src/main/java/datadog/environment/ParseSupportedConfigurations.java

@@ -0,0 +1,59 @@
+package datadog.environment;
+
+import datadog.json.JsonMapper;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Scanner;
+import java.util.Set;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+// TODO: Make this class run at buildtime and generate a static class with the data
+public class ParseSupportedConfigurations {
+  public static Map<String, Object> fileData;
+  public static Map<String, String> aliasMapping;
+  public static Set<String> supportedConfigurations;
+  public static Map<String, String> deprecatedConfigurations;
+  public static Map<String, List<String>> aliases;
+  private static final Logger log = LoggerFactory.getLogger(ParseSupportedConfigurations.class);
+
+  public static void loadSupportedConfigurations(String filename) {
+    String jsonString;
+    try {
+      InputStream in =
+          ParseSupportedConfigurations.class.getClassLoader().getResourceAsStream(filename);
+      jsonString = new Scanner(in, "UTF-8").useDelimiter("\\A").next();
+      fileData = JsonMapper.fromJsonToMap(jsonString);
+      supportedConfigurations =
+          new HashSet<>(
+              ((Map<String, List<String>>) fileData.get("supportedConfigurations")).keySet());
+      aliasToConfig();
+      deprecatedConfigurations = (Map<String, String>) fileData.get("deprecated");
+      aliases = (Map<String, List<String>>) fileData.get("aliases");
+    } catch (IOException e) {
+      throw new RuntimeException("Failed to read " + filename, e);
+    }
+  }
+
+  private static void aliasToConfig() {
+    aliasMapping = new HashMap<>();
+    Map<String, List<String>> aliases = (Map<String, List<String>>) fileData.get("aliases");
+    for (String env : aliases.keySet()) {
+      for (String alias : aliases.get(env)) {
+        if (aliasMapping.containsKey(alias)) {
+          log.info(
+              "{} is listed as an alias of {} when it already exists as an alias of {}",
+              alias,
+              env,
+              aliasMapping.get(alias));
+        } else {
+          aliasMapping.put(alias, env);
+        }
+      }
+    }
+  }
+}