Initial implementation of the OpenFeature SDK

Author: manuel-alvarez-alvarez

.github/CODEOWNERS

@@ -139,3 +139,6 @@ dd-trace-core/src/test/groovy/datadog/trace/llmobs/  @DataDog/ml-observability
 /internal-api/src/test/groovy/datadog/trace/api/rum/ @DataDog/rum
 /telemetry/src/main/java/datadog/telemetry/rum/      @DataDog/rum
 /telemetry/src/test/groovy/datadog/telemetry/rum/    @DataDog/rum
+
+# @DataDog/feature-flagging-and-experimentation-sdk
+/products/openfeature/      @DataDog/feature-flagging-and-experimentation-sdk

internal-api/src/main/java/datadog/trace/api/intake/Intake.java

@@ -15,13 +15,18 @@ public enum Intake {
       "ci-intake",
       "v2",
       Config::isCiVisibilityAgentlessEnabled,
-      Config::getCiVisibilityIntakeAgentlessUrl);
+      Config::getCiVisibilityIntakeAgentlessUrl),
+  EVENT_PLATFORM("event-platform-intake", "v2");
 
   public final String urlPrefix;
   public final String version;
   public final Function<Config, Boolean> agentlessModeEnabled;
   public final Function<Config, String> customUrl;
 
+  Intake(String urlPrefix, String version) {
+    this(urlPrefix, version, config -> false, config -> null);
+  }
+
   Intake(
       String urlPrefix,
       String version,

internal-api/src/main/java/datadog/trace/util/AgentThreadFactory.java

@@ -59,7 +59,9 @@ public enum AgentThread {
 
     LOGS_INTAKE("dd-logs-intake"),
 
-    LLMOBS_EVALS_PROCESSOR("dd-llmobs-evals-processor");
+    LLMOBS_EVALS_PROCESSOR("dd-llmobs-evals-processor"),
+
+    FEATURE_FLAG_EXPOSURE_PROCESSOR("dd-ffe-exposure-processor");
 
     public final String threadName;
 

products/openfeature/build.gradle.kts

@@ -0,0 +1,99 @@
+import de.thetaphi.forbiddenapis.gradle.CheckForbiddenApis
+import groovy.lang.Closure
+
+plugins {
+  `java-library`
+  idea
+}
+
+apply(from = "$rootDir/gradle/java.gradle")
+apply(from = "$rootDir/gradle/publish.gradle")
+
+val minJavaVersionForTests by extra(JavaVersion.VERSION_11)
+
+description = "dd-openfeature"
+
+idea {
+  module {
+    jdkName = "11"
+  }
+}
+
+java {
+  toolchain {
+    languageVersion = JavaLanguageVersion.of(11)
+  }
+}
+
+val excludedClassesCoverage by extra(
+  listOf(
+    // Feature lags POJOs
+    "datadog.trace.api.openfeature.exposure.ExposureCache.Key",
+    "datadog.trace.api.openfeature.exposure.ExposureCache.Value",
+    "datadog.trace.api.openfeature.exposure.dto.Allocation",
+    "datadog.trace.api.openfeature.exposure.dto.ExposureEvent",
+    "datadog.trace.api.openfeature.exposure.dto.ExposuresRequest",
+    "datadog.trace.api.openfeature.exposure.dto.Flag",
+    "datadog.trace.api.openfeature.exposure.dto.Subject",
+    "datadog.trace.api.openfeature.exposure.dto.Variant",
+    "datadog.trace.api.openfeature.config.ufc.v1.Allocation",
+    "datadog.trace.api.openfeature.config.ufc.v1.ConditionConfiguration",
+    "datadog.trace.api.openfeature.config.ufc.v1.ConditionOperator",
+    "datadog.trace.api.openfeature.config.ufc.v1.Environment",
+    "datadog.trace.api.openfeature.config.ufc.v1.Flag",
+    "datadog.trace.api.openfeature.config.ufc.v1.Rule",
+    "datadog.trace.api.openfeature.config.ufc.v1.ServerConfiguration",
+    "datadog.trace.api.openfeature.config.ufc.v1.Shard",
+    "datadog.trace.api.openfeature.config.ufc.v1.ShardRange",
+    "datadog.trace.api.openfeature.config.ufc.v1.Split",
+    "datadog.trace.api.openfeature.config.ufc.v1.ValueType",
+    "datadog.trace.api.openfeature.config.ufc.v1.Variant",
+  )
+)
+
+dependencies {
+  api("dev.openfeature:sdk:1.18.2")
+  api(libs.slf4j)
+  api(libs.moshi)
+  api(libs.okhttp)
+  api(libs.jctools)
+
+  compileOnly(project(":remote-config:remote-config-api"))
+  compileOnly(project(":communication"))
+  compileOnly(project(":internal-api"))
+
+  testImplementation(project(":utils:test-utils"))
+  testImplementation(project(":dd-java-agent:testing"))
+  testImplementation(project(":remote-config:remote-config-api"))
+  testImplementation(project(":communication"))
+  testImplementation(project(":internal-api"))
+}
+
+fun AbstractCompile.configureCompiler(
+  javaVersionInteger: Int,
+  compatibilityVersion: JavaVersion? = null,
+  unsetReleaseFlagReason: String? = null
+) {
+  (project.extra["configureCompiler"] as Closure<*>).call(
+    this,
+    javaVersionInteger,
+    compatibilityVersion,
+    unsetReleaseFlagReason
+  )
+}
+
+tasks.withType<JavaCompile>().configureEach {
+  configureCompiler(11, JavaVersion.VERSION_11)
+}
+
+tasks.withType<Javadoc>().configureEach {
+  javadocTool = javaToolchains.javadocToolFor(java.toolchain)
+}
+
+tasks.named<CheckForbiddenApis>("forbiddenApisMain") {
+  failOnMissingClasses = false
+}
+
+tasks.named<Jar>("jar") {
+  archiveBaseName.set("dd-openfeature")
+}

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

@@ -0,0 +1,73 @@
+package datadog.trace.api.openfeature;
+
+import datadog.communication.ddagent.SharedCommunicationObjects;
+import datadog.trace.api.Config;
+import datadog.trace.api.openfeature.config.RemoteConfigService;
+import datadog.trace.api.openfeature.config.RemoteConfigServiceImpl;
+import datadog.trace.api.openfeature.config.ServerConfigurationListener;
+import datadog.trace.api.openfeature.config.ufc.v1.ServerConfiguration;
+import datadog.trace.api.openfeature.evaluator.FeatureFlagEvaluator;
+import datadog.trace.api.openfeature.evaluator.FeatureFlagEvaluatorImpl;
+import datadog.trace.api.openfeature.exposure.ExposureWriter;
+import datadog.trace.api.openfeature.exposure.ExposureWriterImpl;
+import dev.openfeature.sdk.EventProvider;
+import dev.openfeature.sdk.ProviderEvent;
+import dev.openfeature.sdk.ProviderEventDetails;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class DDProviderInitializer implements Initializer, ServerConfigurationListener {
+
+  private final AtomicBoolean initialized = new AtomicBoolean(false);
+  private final CountDownLatch configurationLatch = new CountDownLatch(1);
+  private EventProvider eventProvider;
+  private RemoteConfigServiceImpl remoteConfigService;
+  private ExposureWriter exposureWriter;
+  private FeatureFlagEvaluator evaluator;
+
+  @Override
+  public boolean init(final EventProvider provider, final long timeout, final TimeUnit timeUnit)
+      throws Exception {
+    final Config config = Config.get();
+    final SharedCommunicationObjects sco = new SharedCommunicationObjects();
+    eventProvider = provider;
+    exposureWriter = new ExposureWriterImpl(sco, config);
+    evaluator = new FeatureFlagEvaluatorImpl(exposureWriter);
+    remoteConfigService = new RemoteConfigServiceImpl(sco, config, this);
+    return configurationLatch.await(timeout, timeUnit);
+  }
+
+  @Override
+  public void close() {
+    remoteConfigService.close();
+    exposureWriter.close();
+  }
+
+  @Override
+  public FeatureFlagEvaluator evaluator() {
+    return evaluator;
+  }
+
+  @Override
+  public ExposureWriter exposureWriter() {
+    return exposureWriter;
+  }
+
+  @Override
+  public RemoteConfigService remoteConfigService() {
+    return remoteConfigService;
+  }
+
+  @Override
+  public void onConfiguration(final ServerConfiguration configuration) {
+    evaluator.onConfiguration(configuration);
+    if (!initialized.getAndSet(true)) {
+      eventProvider.emit(ProviderEvent.PROVIDER_READY, ProviderEventDetails.builder().build());
+    } else {
+      eventProvider.emit(
+          ProviderEvent.PROVIDER_CONFIGURATION_CHANGED, ProviderEventDetails.builder().build());
+    }
+    configurationLatch.countDown();
+  }
+}

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

@@ -0,0 +1,67 @@
+package datadog.trace.api.openfeature;
+
+import datadog.trace.api.openfeature.config.RemoteConfigService;
+import datadog.trace.api.openfeature.evaluator.FeatureFlagEvaluator;
+import datadog.trace.api.openfeature.exposure.ExposureWriter;
+import de.thetaphi.forbiddenapis.SuppressForbidden;
+import dev.openfeature.sdk.EventProvider;
+import java.lang.reflect.Constructor;
+import java.util.concurrent.TimeUnit;
+
+public interface Initializer {
+
+  boolean init(EventProvider provider, long timeout, TimeUnit timeUnit) throws Exception;
+
+  void close();
+
+  RemoteConfigService remoteConfigService();
+
+  FeatureFlagEvaluator evaluator();
+
+  ExposureWriter exposureWriter();
+
+  /**
+   * Uses reflection to load the initializer so we are in control of the loading of internal Datadog
+   * classes
+   */
+  static Initializer withReflection(final String initializerClass) {
+    return new Initializer() {
+
+      private Initializer delegate;
+
+      @Override
+      public boolean init(final EventProvider provider, final long timeout, final TimeUnit timeUnit)
+          throws Exception {
+        delegate = loadInitializer();
+        return delegate.init(provider, timeout, timeUnit);
+      }
+
+      @Override
+      public void close() {
+        delegate.close();
+      }
+
+      @Override
+      public FeatureFlagEvaluator evaluator() {
+        return delegate.evaluator();
+      }
+
+      @Override
+      public ExposureWriter exposureWriter() {
+        return delegate.exposureWriter();
+      }
+
+      @Override
+      public RemoteConfigService remoteConfigService() {
+        return delegate.remoteConfigService();
+      }
+
+      @SuppressForbidden // Class#forName(String) used to lazy load Datadog internal dependencies
+      private Initializer loadInitializer() throws Exception {
+        final Class<?> clazz = Class.forName(initializerClass);
+        final Constructor<?> constructor = clazz.getConstructor();
+        return (Initializer) constructor.newInstance();
+      }
+    };
+  }
+}

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

@@ -0,0 +1,116 @@
+package datadog.trace.api.openfeature;
+
+import static java.util.concurrent.TimeUnit.SECONDS;
+
+import dev.openfeature.sdk.EvaluationContext;
+import dev.openfeature.sdk.EventProvider;
+import dev.openfeature.sdk.Metadata;
+import dev.openfeature.sdk.ProviderEvaluation;
+import dev.openfeature.sdk.Value;
+import dev.openfeature.sdk.exceptions.FatalError;
+import dev.openfeature.sdk.exceptions.OpenFeatureError;
+import dev.openfeature.sdk.exceptions.ProviderNotReadyError;
+import java.util.concurrent.TimeUnit;
+
+public class Provider extends EventProvider implements Metadata {
+
+  static final String METADATA = "datadog-openfeature-provider";
+  static final Options DEFAULT_OPTIONS = new Options().initTimeout(30, SECONDS);
+  static final String INITIALIZER_CLASS = "datadog.trace.api.openfeature.DDProviderInitializer";
+
+  private final Options options;
+  private final Initializer initializer;
+
+  public Provider() {
+    this(DEFAULT_OPTIONS);
+  }
+
+  public Provider(final Options options) {
+    this(options, Initializer.withReflection(INITIALIZER_CLASS));
+  }
+
+  Provider(final Options options, final Initializer initializer) {
+    this.options = options;
+    this.initializer = initializer;
+  }
+
+  @Override
+  public void initialize(final EvaluationContext context) throws Exception {
+    try {
+      if (!initializer.init(this, options.getTimeout(), options.getUnit())) {
+        throw new ProviderNotReadyError(
+            "Provider timed-out while waiting for initial configuration");
+      }
+    } catch (final OpenFeatureError e) {
+      throw e;
+    } catch (final Throwable e) {
+      throw new FatalError(
+          "Failed to initialize provider, is the tracer enabled with -javaagent?", e);
+    }
+  }
+
+  @Override
+  public void shutdown() {
+    initializer.close();
+  }
+
+  @Override
+  public Metadata getMetadata() {
+    return this;
+  }
+
+  @Override
+  public String getName() {
+    return METADATA;
+  }
+
+  @Override
+  public ProviderEvaluation<Boolean> getBooleanEvaluation(
+      final String key, final Boolean defaultValue, final EvaluationContext ctx) {
+    return initializer.evaluator().evaluate(Boolean.class, key, defaultValue, ctx);
+  }
+
+  @Override
+  public ProviderEvaluation<String> getStringEvaluation(
+      final String key, final String defaultValue, final EvaluationContext ctx) {
+    return initializer.evaluator().evaluate(String.class, key, defaultValue, ctx);
+  }
+
+  @Override
+  public ProviderEvaluation<Integer> getIntegerEvaluation(
+      final String key, final Integer defaultValue, final EvaluationContext ctx) {
+    return initializer.evaluator().evaluate(Integer.class, key, defaultValue, ctx);
+  }
+
+  @Override
+  public ProviderEvaluation<Double> getDoubleEvaluation(
+      final String key, final Double defaultValue, final EvaluationContext ctx) {
+    return initializer.evaluator().evaluate(Double.class, key, defaultValue, ctx);
+  }
+
+  @Override
+  public ProviderEvaluation<Value> getObjectEvaluation(
+      final String key, final Value defaultValue, final EvaluationContext ctx) {
+    return initializer.evaluator().evaluate(Value.class, key, defaultValue, ctx);
+  }
+
+  public static class Options {
+
+    private long timeout;
+    private TimeUnit unit;
+
+    public Options initTimeout(final long timeout, final TimeUnit unit) {
+      this.timeout = timeout;
+      this.unit = unit;
+      return this;
+    }
+
+    public long getTimeout() {
+      return timeout;
+    }
+
+    public TimeUnit getUnit() {
+      return unit;
+    }
+  }
+}