feat: implemented support for tracking

Signed-off-by: Bernd Warmuth <[email protected]>

Author: Bernd Warmuth

src/main/java/dev/openfeature/sdk/Client.java

@@ -5,17 +5,19 @@
 /**
  * Interface used to resolve flags of varying types.
  */
-public interface Client extends Features, EventBus<Client> {
+public interface Client extends Features, Tracking, EventBus<Client> {
     ClientMetadata getMetadata();
 
     /**
      * Return an optional client-level evaluation context.
+     *
      * @return {@link EvaluationContext}
      */
     EvaluationContext getEvaluationContext();
 
     /**
      * Set the client-level evaluation context.
+     *
      * @param ctx Client level context.
      */
     Client setEvaluationContext(EvaluationContext ctx);
@@ -30,12 +32,14 @@ public interface Client extends Features, EventBus<Client> {
 
     /**
      * Fetch the hooks associated to this client.
+     *
      * @return A list of {@link Hook}s.
      */
     List<Hook> getHooks();
 
     /**
      * Returns the current state of the associated provider.
+     *
      * @return the provider state
      */
     ProviderState getProviderState();

src/main/java/dev/openfeature/sdk/FeatureProvider.java

@@ -71,4 +71,14 @@ default ProviderState getState() {
         return ProviderState.READY;
     }
 
+    /**
+     * Feature provider implementations can opt in for to support Tracking by implementing this method.
+     *
+     * @param eventName The name of the tracking event
+     * @param context   Evaluation context used in flag evaluation (Optional)
+     * @param details   Data pertinent to a particular tracking event (Optional)
+     */
+    default void track(String eventName, EvaluationContext context, TrackingEventDetails details) {
+
+    }
 }

src/main/java/dev/openfeature/sdk/ImmutableTrackingEventDetails.java

@@ -0,0 +1,53 @@
+package dev.openfeature.sdk;
+
+import dev.openfeature.sdk.internal.ExcludeFromGeneratedCoverageReport;
+import lombok.experimental.Delegate;
+
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.Function;
+
+
+/**
+ * ImmutableTrackingEventDetails represents data pertinent to a particular tracking event.
+ */
+public class ImmutableTrackingEventDetails implements TrackingEventDetails {
+
+    @Delegate(excludes = DelegateExclusions.class)
+    private final ImmutableStructure structure;
+
+    private final Number value;
+
+    public ImmutableTrackingEventDetails() {
+        this.value = null;
+        this.structure = new ImmutableStructure();
+    }
+
+    public ImmutableTrackingEventDetails(final Number value) {
+        this.value = value;
+        this.structure = new ImmutableStructure();
+    }
+
+    public ImmutableTrackingEventDetails(final Number value, final Map<String, Value> attributes) {
+        this.value = value;
+        this.structure = new ImmutableStructure(attributes);
+    }
+
+    /**
+     * Returns the optional tracking value.
+     */
+    public Optional<Number> getValue() {
+        return Optional.ofNullable(value);
+    }
+
+
+    @SuppressWarnings("all")
+    private static class DelegateExclusions {
+        @ExcludeFromGeneratedCoverageReport
+        public <T extends Structure> Map<String, Value> merge(Function<Map<String, Value>, Structure> newStructure,
+                                                              Map<String, Value> base,
+                                                              Map<String, Value> overriding) {
+            return null;
+        }
+    }
+}

src/main/java/dev/openfeature/sdk/MutableTrackingEventDetails.java

@@ -0,0 +1,94 @@
+package dev.openfeature.sdk;
+
+import dev.openfeature.sdk.internal.ExcludeFromGeneratedCoverageReport;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+import lombok.experimental.Delegate;
+
+import java.time.Instant;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.Function;
+
+/**
+ * MutableTrackingEventDetails represents data pertinent to a particular tracking event.
+ */
+@EqualsAndHashCode
+@ToString
+public class MutableTrackingEventDetails implements TrackingEventDetails {
+
+    private final Number value;
+    @Delegate(excludes = MutableTrackingEventDetails.DelegateExclusions.class)
+    private final MutableStructure structure;
+
+    public MutableTrackingEventDetails() {
+        this.value = null;
+        this.structure = new MutableStructure();
+    }
+
+    public MutableTrackingEventDetails(final Number value) {
+        this.value = value;
+        this.structure = new MutableStructure();
+    }
+
+    /**
+     * Returns the optional tracking value.
+     */
+    public Optional<Number> getValue() {
+        return Optional.ofNullable(value);
+    }
+
+    // override @Delegate methods so that we can use "add" methods and still return MutableTrackingEventDetails,
+    // not Structure
+    public MutableTrackingEventDetails add(String key, Boolean value) {
+        this.structure.add(key, value);
+        return this;
+    }
+
+    public MutableTrackingEventDetails add(String key, String value) {
+        this.structure.add(key, value);
+        return this;
+    }
+
+    public MutableTrackingEventDetails add(String key, Integer value) {
+        this.structure.add(key, value);
+        return this;
+    }
+
+    public MutableTrackingEventDetails add(String key, Double value) {
+        this.structure.add(key, value);
+        return this;
+    }
+
+    public MutableTrackingEventDetails add(String key, Instant value) {
+        this.structure.add(key, value);
+        return this;
+    }
+
+    public MutableTrackingEventDetails add(String key, Structure value) {
+        this.structure.add(key, value);
+        return this;
+    }
+
+    public MutableTrackingEventDetails add(String key, List<Value> value) {
+        this.structure.add(key, value);
+        return this;
+    }
+
+    public MutableTrackingEventDetails add(String key, Value value) {
+        this.structure.add(key, value);
+        return this;
+    }
+
+
+    @SuppressWarnings("all")
+    private static class DelegateExclusions {
+        @ExcludeFromGeneratedCoverageReport
+        public <T extends Structure> Map<String, Value> merge(Function<Map<String, Value>, Structure> newStructure,
+                                                              Map<String, Value> base,
+                                                              Map<String, Value> overriding) {
+            return null;
+        }
+    }
+}