(feat): Feature Management getFeatureVariable Listener

core-api/src/main/java/com/optimizely/ab/Optimizely.java

@@ -465,17 +465,13 @@ public Boolean getFeatureVariableBoolean(@Nonnull String featureKey,
             return null;
         }
 
-        String variableValue = getFeatureVariableValueForType(
-            featureKey,
-            variableKey,
-            userId,
-            attributes,
-            FeatureVariable.VariableType.BOOLEAN
-        );
-        if (variableValue != null) {
-            return Boolean.parseBoolean(variableValue);
-        }
-        return null;
+        return getFeatureVariableValueForType(
+                featureKey,
+                variableKey,
+                userId,
+                attributes,
+                FeatureVariable.VariableType.BOOLEAN
+            );
     }
 
     /**
@@ -514,20 +510,19 @@ public Double getFeatureVariableDouble(@Nonnull String featureKey,
             return null;
         }
 
-        String variableValue = getFeatureVariableValueForType(
-            featureKey,
-            variableKey,
-            userId,
-            attributes,
-            FeatureVariable.VariableType.DOUBLE
-        );
-        if (variableValue != null) {
-            try {
-                return Double.parseDouble(variableValue);
-            } catch (NumberFormatException exception) {
-                logger.error("NumberFormatException while trying to parse \"" + variableValue +
-                    "\" as Double. " + exception);
-            }
+        Double variableValue = null;
+        try {
+            variableValue = getFeatureVariableValueForType(
+                featureKey,
+                variableKey,
+                userId,
+                attributes,
+                FeatureVariable.VariableType.DOUBLE
+            );
+            return variableValue;
+        } catch (Exception exception) {
+            logger.error("NumberFormatException while trying to parse \"" + variableValue +
+                "\" as Double. " + exception);
         }
         return null;
     }
@@ -567,21 +562,19 @@ public Integer getFeatureVariableInteger(@Nonnull String featureKey,
             logger.error("Optimizely instance is not valid, failing getFeatureVariableInteger call.");
             return null;
         }
-
-        String variableValue = getFeatureVariableValueForType(
-            featureKey,
-            variableKey,
-            userId,
-            attributes,
-            FeatureVariable.VariableType.INTEGER
-        );
-        if (variableValue != null) {
-            try {
-                return Integer.parseInt(variableValue);
-            } catch (NumberFormatException exception) {
-                logger.error("NumberFormatException while trying to parse \"" + variableValue +
-                    "\" as Integer. " + exception.toString());
+        try {
+            Integer variableValue = getFeatureVariableValueForType(
+                featureKey,
+                variableKey,
+                userId,
+                attributes,
+                FeatureVariable.VariableType.INTEGER
+            );
+            if (variableValue != null) {
+                return variableValue;
             }
+        } catch (Exception exception) {
+            logger.error("NumberFormatException while trying to parse value as Integer. " + exception.toString());
         }
         return null;
     }
@@ -631,11 +624,11 @@ public String getFeatureVariableString(@Nonnull String featureKey,
     }
 
     @VisibleForTesting
-    String getFeatureVariableValueForType(@Nonnull String featureKey,
-                                          @Nonnull String variableKey,
-                                          @Nonnull String userId,
-                                          @Nonnull Map<String, ?> attributes,
-                                          @Nonnull FeatureVariable.VariableType variableType) {
+    <T extends Object> T getFeatureVariableValueForType(@Nonnull String featureKey,
+                                                        @Nonnull String variableKey,
+                                                        @Nonnull String userId,
+                                                        @Nonnull Map<String, ?> attributes,
+                                                        @Nonnull FeatureVariable.VariableType variableType) {
         if (featureKey == null) {
             logger.warn("The featureKey parameter must be nonnull.");
             return null;
@@ -668,6 +661,7 @@ String getFeatureVariableValueForType(@Nonnull String featureKey,
         String variableValue = variable.getDefaultValue();
         Map<String, ?> copiedAttributes = copyAttributes(attributes);
         FeatureDecision featureDecision = decisionService.getVariationForFeature(featureFlag, userId, copiedAttributes);
+        Boolean featureEnabled = false;
         if (featureDecision.variation != null) {
             if (featureDecision.variation.getFeatureEnabled()) {
                 FeatureVariableUsageInstance featureVariableUsageInstance =
@@ -683,14 +677,61 @@ String getFeatureVariableValueForType(@Nonnull String featureKey,
                     featureKey, featureDecision.variation.getKey(), variableValue, variableKey
                 );
             }
+            featureEnabled = featureDecision.variation.getFeatureEnabled();
         } else {
             logger.info("User \"{}\" was not bucketed into any variation for feature flag \"{}\". " +
                     "The default value \"{}\" for \"{}\" is being returned.",
                 userId, featureKey, variableValue, variableKey
             );
         }
 
-        return variableValue;
+        Object convertedValue = convertStringToType(variableValue, variableType);
+
+        DecisionNotification decisionNotification = DecisionNotification.newFeatureVariableBuilder()
+            .withUserId(userId)
+            .withAttributes(copiedAttributes)
+            .withFeatureKey(featureKey)
+            .withFeatureEnabled(featureEnabled)
+            .withVariableKey(variableKey)
+            .withVariableType(variableType)
+            .withVariableValue(convertedValue)
+            .withFeatureDecision(featureDecision)
+            .build();
+
+
+        notificationCenter.sendNotifications(decisionNotification);
+
+        return (T) convertedValue;
+    }
+
+    // Helper method which takes type and variable value and convert it to object to use in Listener DecisionInfo object variable value
+    @VisibleForTesting
+    Object convertStringToType(String variableValue, FeatureVariable.VariableType type) {
+        if (variableValue != null) {
+            switch (type) {
+                case DOUBLE:
+                    try {
+                        return Double.parseDouble(variableValue);
+                    } catch (NumberFormatException exception) {
+                        logger.error("NumberFormatException while trying to parse \"" + variableValue +
+                            "\" as Double. " + exception);
+                    }
+                    break;
+                case STRING:
+                    return variableValue;
+                case BOOLEAN:
+                    return Boolean.parseBoolean(variableValue);
+                case INTEGER:
+                    try {
+                        return Integer.parseInt(variableValue);
+                    } catch (NumberFormatException exception) {
+                        logger.error("NumberFormatException while trying to parse \"" + variableValue +
+                            "\" as Integer. " + exception.toString());
+                    }
+                    break;
+            }
+        }
+        return null;
     }
 
     /**

core-api/src/main/java/com/optimizely/ab/notification/DecisionNotification.java

@@ -16,7 +16,9 @@
 
 package com.optimizely.ab.notification;
 
+
 import com.optimizely.ab.bucketing.FeatureDecision;
+import com.optimizely.ab.config.FeatureVariable;
 import com.optimizely.ab.config.Variation;
 
 import javax.annotation.Nonnull;
@@ -191,4 +193,98 @@ public DecisionNotification build() {
                 decisionInfo);
         }
     }
-}
+
+    public static FeatureVariableDecisionNotificationBuilder newFeatureVariableBuilder() {
+        return new FeatureVariableDecisionNotificationBuilder();
+    }
+
+    public static class FeatureVariableDecisionNotificationBuilder {
+
+        public static final String FEATURE_KEY = "featureKey";
+        public static final String FEATURE_ENABLED = "featureEnabled";
+        public static final String SOURCE = "source";
+        public static final String SOURCE_INFO = "sourceInfo";
+        public static final String EXPERIMENT_KEY = "experimentKey";
+        public static final String VARIATION_KEY = "variationKey";
+        public static final String VARIABLE_KEY = "variableKey";
+        public static final String VARIABLE_TYPE = "variableType";
+        public static final String VARIABLE_VALUE = "variableValue";
+
+        private String featureKey;
+        private Boolean featureEnabled;
+        private FeatureDecision featureDecision;
+        private String variableKey;
+        private FeatureVariable.VariableType variableType;
+        private Object variableValue;
+        private String userId;
+        private Map<String, ?> attributes;
+        private Map<String, Object> decisionInfo;
+
+        protected FeatureVariableDecisionNotificationBuilder() {
+        }
+
+        public FeatureVariableDecisionNotificationBuilder withUserId(String userId) {
+            this.userId = userId;
+            return this;
+        }
+
+        public FeatureVariableDecisionNotificationBuilder withAttributes(Map<String, ?> attributes) {
+            this.attributes = attributes;
+            return this;
+        }
+
+        public FeatureVariableDecisionNotificationBuilder withFeatureKey(String featureKey) {
+            this.featureKey = featureKey;
+            return this;
+        }
+
+        public FeatureVariableDecisionNotificationBuilder withFeatureEnabled(boolean featureEnabled) {
+            this.featureEnabled = featureEnabled;
+            return this;
+        }
+
+        public FeatureVariableDecisionNotificationBuilder withFeatureDecision(FeatureDecision featureDecision) {
+            this.featureDecision = featureDecision;
+            return this;
+        }
+
+        public FeatureVariableDecisionNotificationBuilder withVariableKey(String variableKey) {
+            this.variableKey = variableKey;
+            return this;
+        }
+
+        public FeatureVariableDecisionNotificationBuilder withVariableType(FeatureVariable.VariableType variableType) {
+            this.variableType = variableType;
+            return this;
+        }
+
+        public FeatureVariableDecisionNotificationBuilder withVariableValue(Object variableValue) {
+            this.variableValue = variableValue;
+            return this;
+        }
+
+        public DecisionNotification build() {
+            decisionInfo = new HashMap<>();
+            decisionInfo.put(FEATURE_KEY, featureKey);
+            decisionInfo.put(FEATURE_ENABLED, featureEnabled);
+            decisionInfo.put(VARIABLE_KEY, variableKey);
+            decisionInfo.put(VARIABLE_TYPE, variableType);
+            decisionInfo.put(VARIABLE_VALUE, variableValue);
+            Map<String, String> sourceInfo = new HashMap<>();
+            if (featureDecision != null && FeatureDecision.DecisionSource.FEATURE_TEST.equals(featureDecision.decisionSource)) {
+                sourceInfo.put(EXPERIMENT_KEY, featureDecision.experiment.getKey());
+                sourceInfo.put(VARIATION_KEY, featureDecision.variation.getKey());
+                decisionInfo.put(SOURCE, featureDecision.decisionSource);
+            } else {
+                decisionInfo.put(SOURCE, FeatureDecision.DecisionSource.ROLLOUT);
+            }
+            decisionInfo.put(SOURCE_INFO, sourceInfo);
+
+            return new DecisionNotification(
+                NotificationCenter.DecisionNotificationType.FEATURE_VARIABLE.toString(),
+                userId,
+                attributes,
+                decisionInfo);
+        }
+    }
+}