Feature Flags & Rollout - Implemented New API changes. (#31)

Author: mfahadahmed

OptimizelySDK.Tests/OptimizelyTest.cs

@@ -360,7 +360,7 @@ public virtual Variation GetVariationForFeatureExperiment(FeatureFlag featureFla
         /// <param name = "filteredAttributes" >The user's attributes. This should be filtered to just attributes in the Datafile.</param>
         /// <returns>null if the user is not bucketed into any variation or the Variation the user is bucketed into
         /// if the user is successfully bucketed.</returns>
-        public Variation GetVariationForFeature(FeatureFlag featureFlag, string userId, UserAttributes filteredAttributes)
+        public virtual Variation GetVariationForFeature(FeatureFlag featureFlag, string userId, UserAttributes filteredAttributes)
         {
             // Check if the feature flag has an experiment and the user is bucketed into that experiment.
             var variation = GetVariationForFeatureExperiment(featureFlag, userId, filteredAttributes);

OptimizelySDK/Bucketing/DecisionService.cs

@@ -43,5 +43,15 @@ public List<FeatureVariable> Variables
         }
 
         public Dictionary<string, FeatureVariable> VariableKeyToFeatureVariableMap { get; set; }
+
+        public FeatureVariable GetFeatureVariableFromKey(string variableKey)
+        {
+            if (VariableKeyToFeatureVariableMap != null && VariableKeyToFeatureVariableMap.ContainsKey(variableKey))
+            {
+                return VariableKeyToFeatureVariableMap[variableKey];
+            }
+
+            return null;
+        }
     }
 }

OptimizelySDK/Entity/FeatureFlag.cs

@@ -39,5 +39,15 @@ public List<FeatureVariableUsage> FeatureVariableUsageInstances
         }
 
         public Dictionary<string, FeatureVariableUsage> VariableIdToVariableUsageInstanceMap { get; set; }
+
+        public FeatureVariableUsage GetFeatureVariableUsageFromId(string variableId)
+        {
+            if (VariableIdToVariableUsageInstanceMap != null && VariableIdToVariableUsageInstanceMap.ContainsKey(variableId))
+            {
+                return VariableIdToVariableUsageInstanceMap[variableId];
+            }
+
+            return null;
+        }
     }
 }

OptimizelySDK/Entity/Variation.cs

@@ -175,19 +175,7 @@ public string Activate(string experimentKey, string userId, UserAttributes userA
                 userAttributes = userAttributes.FilterNullValues(Logger);
             }
 
-            var impressionEvent = EventBuilder.CreateImpressionEvent(Config, experiment, variation.Id, userId, userAttributes);
-            Logger.Log(LogLevel.INFO, string.Format("Activating user {0} in experiment {1}.", userId, experimentKey));
-            Logger.Log(LogLevel.DEBUG, string.Format("Dispatching impression event to URL {0} with params {1}.", 
-                impressionEvent, impressionEvent.GetParamsAsJson()));
-
-            try
-            {
-                EventDispatcher.DispatchEvent(impressionEvent);
-            }
-            catch (Exception exception)
-            {
-                Logger.Log(LogLevel.ERROR, string.Format("Unable to dispatch impression event. Error {0}", exception.Message));
-            }
+            SendImpressionEvent(experiment, variation.Id, userId, userAttributes);
 
             return variation.Key;
         }
@@ -330,5 +318,249 @@ public Variation GetForcedVariation(string experimentKey, string userId)
 
             return forcedVariation;
         }
+
+        #region  FeatureFlag APIs
+
+        /// <summary>
+        /// Determine whether a feature is enabled.
+        /// Send an impression event if the user is bucketed into an experiment using the feature.
+        /// </summary>
+        /// <param name="experimentKey">The experiment key</param>
+        /// <param name="userId">The user ID</param>
+        /// <param name="userAttributes">The user's attributes.</param>
+        /// <returns>True if feature is enabled, false or null otherwise</returns>
+        public bool? IsFeatureEnabled(string featureKey, string userId, UserAttributes userAttributes = null)
+        {
+            if (string.IsNullOrEmpty(userId))
+            {
+                Logger.Log(LogLevel.ERROR, "User ID must not be empty.");
+                return null;
+            }
+
+            if (string.IsNullOrEmpty(featureKey))
+            {
+                Logger.Log(LogLevel.ERROR, "Feature flag key must not be empty.");
+                return null;
+            }
+
+            var featureFlag = Config.GetFeatureFlagFromKey(featureKey);
+            if (string.IsNullOrEmpty(featureFlag.Key))
+                return null;
+
+            if (!Validator.IsFeatureFlagValid(Config, featureFlag))
+                return false;
+
+            var variation = DecisionService.GetVariationForFeature(featureFlag, userId, userAttributes);
+            if ( variation == null )
+            {
+                Logger.Log(LogLevel.INFO, $@"Feature flag ""{featureKey}"" is not enabled for user ""{userId}"".");
+                return false;
+            }
+
+            var experiment = Config.GetExperimentForVariationId(variation.Id);
+
+            if (!string.IsNullOrEmpty(experiment.Key))
+                SendImpressionEvent(experiment, variation.Id, userId, userAttributes);
+            else
+                Logger.Log(LogLevel.INFO, $@"The user ""{userId}"" is not being experimented on feature ""{featureKey}"".");
+
+            Logger.Log(LogLevel.INFO, $@"Feature flag ""{featureKey}"" is enabled for user ""{userId}"".");
+            return true;
+        }
+
+        /// <summary>
+        /// Gets the feature variable value for given type.
+        /// </summary>
+        /// <param name="featureKey">The feature flag key</param>
+        /// <param name="variableKey">The variable key</param>
+        /// <param name="userId">The user ID</param>
+        /// <param name="userAttributes">The user's attributes</param>
+        /// <param name="variableType">Variable type</param>
+        /// <returns>string | null Feature variable value</returns>
+        public virtual string GetFeatureVariableValueForType(string featureKey, string variableKey, string userId, 
+            UserAttributes userAttributes, FeatureVariable.VariableType variableType)
+        {
+            if (string.IsNullOrEmpty(featureKey))
+            {
+                Logger.Log(LogLevel.ERROR, "Feature flag key must not be empty.");
+                return null;
+            }
+
+            if (string.IsNullOrEmpty(variableKey))
+            {
+                Logger.Log(LogLevel.ERROR, "Variable key must not be empty.");
+                return null;
+            }
+
+            if (string.IsNullOrEmpty(userId))
+            {
+                Logger.Log(LogLevel.ERROR, "User ID must not be empty.");
+                return null;
+            }
+
+            var featureFlag = Config.GetFeatureFlagFromKey(featureKey);
+            if (string.IsNullOrEmpty(featureFlag.Key))
+                return null;
+
+            var featureVariable = featureFlag.GetFeatureVariableFromKey(variableKey);
+            if (featureVariable == null)
+            {
+                Logger.Log(LogLevel.ERROR,
+                    $@"No feature variable was found for key ""{variableKey}"" in feature flag ""{featureKey}"".");
+                return null;
+            }
+            else if (featureVariable.Type != variableType)
+            {
+                Logger.Log(LogLevel.ERROR,
+                    $@"Variable is of type ""{featureVariable.Type}"", but you requested it as type ""{variableType}"".");
+                return null;
+            }
+
+            var variableValue = featureVariable.DefaultValue;
+            var variation = DecisionService.GetVariationForFeature(featureFlag, userId, userAttributes);
+
+            if (variation != null)
+            {
+                var featureVariableUsageInstance = variation.GetFeatureVariableUsageFromId(featureVariable.Id);
+                if (featureVariableUsageInstance != null)
+                {
+                    variableValue = featureVariableUsageInstance.Value;
+                    Logger.Log(LogLevel.INFO,
+                        $@"Returning variable value ""{variableValue}"" for variation ""{variation.Key}"" of feature flag ""{featureFlag.Key}"".");
+                }
+                else
+                {
+                    Logger.Log(LogLevel.INFO,
+                        $@"Variable ""{variableKey}"" is not used in variation ""{variation.Key}"", returning default value ""{variableValue}"".");
+                }
+            }
+            else
+            {
+                Logger.Log(LogLevel.INFO,
+                    $@"User ""{userId}"" is not in any variation for feature flag ""{featureFlag.Key}"", returning default value ""{variableValue}"".");
+            }
+
+            return variableValue;
+        }
+
+        /// <summary>
+        /// Gets boolean feature variable value.
+        /// </summary>
+        /// <param name="featureKey">The feature flag key</param>
+        /// <param name="variableKey">The variable key</param>
+        /// <param name="userId">The user ID</param>
+        /// <param name="userAttributes">The user's attributes</param>
+        /// <returns>bool | Feature variable value or null</returns>
+        public bool? GetFeatureVariableBoolean(string featureKey, string variableKey, string userId, UserAttributes userAttributes)
+        {
+            var variableType = FeatureVariable.VariableType.BOOLEAN;
+            var variableValue = GetFeatureVariableValueForType(featureKey, variableKey, userId, userAttributes, variableType);
+            
+            if (variableValue != null)
+            {
+                if (Boolean.TryParse(variableValue, out bool booleanValue))
+                    return booleanValue;
+                else
+                    Logger.Log(LogLevel.ERROR, $@"Unable to cast variable value ""{variableValue}"" to type ""{variableType}"".");
+            }
+            
+            return null;
+        }
+
+        /// <summary>
+        /// Gets double feature variable value.
+        /// </summary>
+        /// <param name="featureKey">The feature flag key</param>
+        /// <param name="variableKey">The variable key</param>
+        /// <param name="userId">The user ID</param>
+        /// <param name="userAttributes">The user's attributes</param>
+        /// <returns>double | Feature variable value or null</returns>
+        public double? GetFeatureVariableDouble(string featureKey, string variableKey, string userId, UserAttributes userAttributes)
+        {
+            var variableType = FeatureVariable.VariableType.DOUBLE;
+            var variableValue = GetFeatureVariableValueForType(featureKey, variableKey, userId, userAttributes, variableType);
+
+            if (variableValue != null)
+            {
+                if (Double.TryParse(variableValue, out double doubleValue))
+                    return doubleValue;
+                else
+                    Logger.Log(LogLevel.ERROR, $@"Unable to cast variable value ""{variableValue}"" to type ""{variableType}"".");
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Gets integer feature variable value.
+        /// </summary>
+        /// <param name="featureKey">The feature flag key</param>
+        /// <param name="variableKey">The variable key</param>
+        /// <param name="userId">The user ID</param>
+        /// <param name="userAttributes">The user's attributes</param>
+        /// <returns>int | Feature variable value or null</returns>
+        public int? GetFeatureVariableInteger(string featureKey, string variableKey, string userId, UserAttributes userAttributes)
+        {
+            var variableType = FeatureVariable.VariableType.INTEGER;
+            var variableValue = GetFeatureVariableValueForType(featureKey, variableKey, userId, userAttributes, variableType);
+
+            if (variableValue != null)
+            {
+                if (Int32.TryParse(variableValue, out int intValue))
+                    return intValue;
+                else
+                    Logger.Log(LogLevel.ERROR, $@"Unable to cast variable value ""{variableValue}"" to type ""{variableType}"".");
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Gets string feature variable value.
+        /// </summary>
+        /// <param name="featureKey">The feature flag key</param>
+        /// <param name="variableKey">The variable key</param>
+        /// <param name="userId">The user ID</param>
+        /// <param name="userAttributes">The user's attributes</param>
+        /// <returns>string | Feature variable value or null</returns>
+        public string GetFeatureVariableString(string featureKey, string variableKey, string userId, UserAttributes userAttributes)
+        {
+            return GetFeatureVariableValueForType(featureKey, variableKey, userId, userAttributes, 
+                FeatureVariable.VariableType.STRING);
+        }
+
+        /// <summary>
+        /// Sends impression event.
+        /// </summary>
+        /// <param name="experiment">The experiment</param>
+        /// <param name="variationId">The variation Id</param>
+        /// <param name="userId">The user ID</param>
+        /// <param name="userAttributes">The user's attributes</param>
+        private void SendImpressionEvent(Experiment experiment, string variationId, string userId, 
+        UserAttributes userAttributes)
+        {
+            if (experiment.IsExperimentRunning)
+            {
+                var impressionEvent = EventBuilder.CreateImpressionEvent(Config, experiment, variationId, userId, userAttributes);
+                Logger.Log(LogLevel.INFO, string.Format("Activating user {0} in experiment {1}.", userId, experiment.Key));
+                Logger.Log(LogLevel.DEBUG, string.Format("Dispatching impression event to URL {0} with params {1}.",
+                    impressionEvent.Url, impressionEvent.GetParamsAsJson()));
+
+                try
+                {
+                    EventDispatcher.DispatchEvent(impressionEvent);
+                }
+                catch (Exception exception)
+                {
+                    Logger.Log(LogLevel.ERROR, string.Format("Unable to dispatch impression event. Error {0}", exception.Message));
+                }
+            }
+            else
+            {
+                Logger.Log(LogLevel.ERROR, @"Experiment has ""Launched"" status so not dispatching event during activation.");
+            }
+        }
+
+        #endregion // FeatureFlag APIs
     }
 }

OptimizelySDK/Optimizely.cs

@@ -125,7 +125,13 @@ private Dictionary<string, Dictionary<string, Variation>> _VariationIdMap
         /// </summary>
         private Dictionary<string, Rollout> _RolloutIdMap;
         public Dictionary<string, Rollout> RolloutIdMap { get { return _RolloutIdMap; } }
-        
+
+        /// <summary>
+        /// Associative array of Variation ID to Experiments(s) in the datafile
+        /// </summary>
+        private Dictionary<string, Experiment> _VariationIdToExperimentMap = new Dictionary<string, Experiment>();
+        public Dictionary<string, Experiment> VariationIdToExperimentMap{ get { return _VariationIdToExperimentMap; } }
+
         //========================= Callbacks ===========================
 
         /// <summary>
@@ -236,6 +242,9 @@ private void Initialize()
                     {
                         _VariationKeyMap[experiment.Key][variation.Key] = variation;
                         _VariationIdMap[experiment.Key][variation.Id] = variation;
+
+                        // Generate Variation ID to Experiment map.
+                        _VariationIdToExperimentMap[variation.Id] = experiment;
                     }
                 }
             }
@@ -532,5 +541,21 @@ public Rollout GetRolloutFromId(string rolloutId)
             ErrorHandler.HandleError(new Exceptions.InvalidRolloutException("Provided rollout is not in datafile."));
             return new Rollout();
         }
+
+        /// <summary>
+        /// Get experiment from variation ID.
+        /// </summary>
+        /// <param name="variationId">Variation ID</param>
+        /// <returns>Experiment Entity corresponding to the variation ID or a dummy entity if ID is invalid</returns>
+        public Experiment GetExperimentForVariationId(string variationId)
+        {
+            if (_VariationIdToExperimentMap.ContainsKey(variationId))
+                return _VariationIdToExperimentMap[variationId];
+            
+            Logger.Log(LogLevel.ERROR, $@"No experiment has been defined in datafile for variation ""{variationId}"".");
+            ErrorHandler.HandleError(new Exceptions.InvalidVariationException("No experiment has been found for provided variation Id in the datafile."));
+
+            return new Experiment();
+        }
     }
 }

OptimizelySDK/ProjectConfig.cs

@@ -76,6 +76,32 @@ public static bool AreEventTagsValid(Dictionary<string, object> eventTags) {
             return eventTags.All(tag => !int.TryParse(tag.Key, out key));
 
         }
+
+        /// <summary>
+        /// Determines whether all the experiments in the feature flag
+        /// belongs to the same mutex group
+        /// </summary>
+        /// <param name="projectConfig">The project config object</param>
+        /// <param name="featureFlag">Feature flag to validate</param>
+        /// <returns>true if feature flag is valid.</returns>
+        public static bool IsFeatureFlagValid(ProjectConfig projectConfig, FeatureFlag featureFlag)
+        {
+            var experimentIds = featureFlag.ExperimentIds;
+            
+            if (experimentIds == null || experimentIds.Count <= 1)
+                return true;
+
+            var groupId = projectConfig.GetExperimentFromId(experimentIds[0]).GroupId;
+
+            for (int i = 1; i < experimentIds.Count; i++)
+            {
+                // Every experiment should have the same group Id.
+                if (projectConfig.GetExperimentFromId(experimentIds[i]).GroupId != groupId)
+                    return false;
+            }
+
+            return true;
+        }
     }
 }