Feature variable accessors (#58)

Author: mikeproeng37

lib/optimizely.rb

@@ -19,8 +19,10 @@
 require_relative 'optimizely/event_builder'
 require_relative 'optimizely/event_dispatcher'
 require_relative 'optimizely/exceptions'
+require_relative 'optimizely/helpers/constants'
 require_relative 'optimizely/helpers/group'
 require_relative 'optimizely/helpers/validator'
+require_relative 'optimizely/helpers/variable_type'
 require_relative 'optimizely/logger'
 require_relative 'optimizely/project_config'
 
@@ -237,8 +239,154 @@ def is_feature_enabled(feature_flag_key, user_id, attributes = nil)
       false
     end
 
+    def get_feature_variable_string(feature_flag_key, variable_key, user_id, attributes = nil)
+      # Get the String value of the specified variable in the feature flag.
+      #
+      # feature_flag_key - String key of feature flag the variable belongs to
+      # variable_key - String key of variable for which we are getting the string value
+      # user_id - String user ID
+      # attributes - Hash representing visitor attributes and values which need to be recorded.
+      #
+      # Returns the string variable value.
+      # Returns nil if the feature flag or variable are not found.
+
+      variable_value = get_feature_variable_for_type(
+        feature_flag_key,
+        variable_key,
+        Optimizely::Helpers::Constants::VARIABLE_TYPES["STRING"],
+        user_id,
+        attributes
+      )
+
+      return variable_value
+    end
+
+    def get_feature_variable_boolean(feature_flag_key, variable_key, user_id, attributes = nil)
+      # Get the Boolean value of the specified variable in the feature flag.
+      #
+      # feature_flag_key - String key of feature flag the variable belongs to
+      # variable_key - String key of variable for which we are getting the string value
+      # user_id - String user ID
+      # attributes - Hash representing visitor attributes and values which need to be recorded.
+      #
+      # Returns the boolean variable value.
+      # Returns nil if the feature flag or variable are not found.
+
+      variable_value = get_feature_variable_for_type(
+        feature_flag_key,
+        variable_key,
+        Optimizely::Helpers::Constants::VARIABLE_TYPES["BOOLEAN"],
+        user_id,
+        attributes
+      )
+
+      return variable_value
+    end
+
+    def get_feature_variable_double(feature_flag_key, variable_key, user_id, attributes = nil)
+      # Get the Double value of the specified variable in the feature flag.
+      #
+      # feature_flag_key - String key of feature flag the variable belongs to
+      # variable_key - String key of variable for which we are getting the string value
+      # user_id - String user ID
+      # attributes - Hash representing visitor attributes and values which need to be recorded.
+      #
+      # Returns the double variable value.
+      # Returns nil if the feature flag or variable are not found.
+
+      variable_value = get_feature_variable_for_type(
+        feature_flag_key,
+        variable_key,
+        Optimizely::Helpers::Constants::VARIABLE_TYPES["DOUBLE"],
+        user_id,
+        attributes
+      )
+
+      return variable_value
+    end
+
+    def get_feature_variable_integer(feature_flag_key, variable_key, user_id, attributes = nil)
+      # Get the Integer value of the specified variable in the feature flag.
+      #
+      # feature_flag_key - String key of feature flag the variable belongs to
+      # variable_key - String key of variable for which we are getting the string value
+      # user_id - String user ID
+      # attributes - Hash representing visitor attributes and values which need to be recorded.
+      #
+      # Returns the integer variable value.
+      # Returns nil if the feature flag or variable are not found.
+
+      variable_value = get_feature_variable_for_type(
+        feature_flag_key,
+        variable_key,
+        Optimizely::Helpers::Constants::VARIABLE_TYPES["INTEGER"],
+        user_id,
+        attributes
+      )
+
+      return variable_value
+    end
+
     private
 
+    def get_feature_variable_for_type(feature_flag_key, variable_key, variable_type, user_id, attributes = nil)
+      # Get the variable value for the given feature variable and cast it to the specified type
+      # The default value is returned if the feature flag is not enabled for the user.
+      #
+      # feature_flag_key - String key of feature flag the variable belongs to
+      # variable_key - String key of variable for which we are getting the string value
+      # variable_type - String requested type for feature variable
+      # user_id - String user ID
+      # attributes - Hash representing visitor attributes and values which need to be recorded.
+      #
+      # Returns the type-casted variable value.
+      # Returns nil if the feature flag or variable are not found.
+
+      feature_flag = @config.get_feature_flag_from_key(feature_flag_key)
+      unless feature_flag
+        @logger.log(Logger::INFO, "No feature flag was found for key '#{feature_flag_key}'.")
+        return nil
+      end
+
+      variable_value = nil
+      variable = @config.get_feature_variable(feature_flag, variable_key)
+      unless variable.nil?
+        variable_value = variable['defaultValue']
+
+        decision = @decision_service.get_variation_for_feature(feature_flag, user_id, attributes)
+        unless decision
+          @logger.log(Logger::INFO,
+            "User '#{user_id}' was not bucketed into any variation for feature flag '#{feature_flag_key}'. Returning the default variable value '#{variable_value}'.")
+        else
+          variation = decision['variation']
+          variation_variable_usages = @config.variation_id_to_variable_usage_map[variation['id']]
+          variable_id = variable['id']
+          unless variation_variable_usages.key?(variable_id)
+            variation_key = variation['key']
+            @logger.log(Logger::DEBUG,
+              "Variable '#{variable_key}' is not used in variation '#{variation_key}'. Returning the default variable value '#{variable_value}'."
+            )
+          else
+            variable_value = variation_variable_usages[variable_id]['value']
+            @logger.log(Logger::INFO,
+              "Got variable value '#{variable_value}' for variable '#{variable_key}' of feature flag '#{feature_flag_key}'.")
+          end
+        end
+      end
+
+      unless variable_value.nil?
+        actual_variable_type = variable['type']
+        unless variable_type == actual_variable_type
+          @logger.log(Logger::WARN,
+            "Requested variable type '#{variable_type}' but variable '#{variable_key}' is of type '#{actual_variable_type}'.")
+        end
+
+        variable_value = Helpers::VariableType.cast_value_to_type(variable_value, variable_type, @logger)
+      end
+
+      return variable_value
+    end
+
     def get_valid_experiments_for_event(event_key, user_id, attributes)
       # Get the experiments that we should be tracking for the given event.
       #

lib/optimizely/helpers/constants.rb

@@ -298,6 +298,13 @@ module Constants
           'revision'
         ]
       }
+
+      VARIABLE_TYPES = {
+        'BOOLEAN' => 'boolean',
+        'DOUBLE' => 'double',
+        'INTEGER' => 'integer',
+        'STRING' => 'string'
+      }
     end
   end
 end

lib/optimizely/helpers/variable_type.rb

@@ -0,0 +1,56 @@
+#
+#    Copyright 2017, Optimizely and contributors
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+require 'optimizely/logger'
+
+module Optimizely
+  module Helpers
+    module VariableType
+      module_function
+
+      def cast_value_to_type(value, variable_type, logger)
+        # Attempts to cast the given value to the specified type
+        #
+        # value - The string value to cast
+        # variable_type - String variable type
+        #
+        # Returns the cast value or nil if not able to cast
+        return_value = nil
+
+        case variable_type
+        when "boolean"
+          return_value = value == "true"
+        when "double"
+          begin
+            return_value = Float(value)
+          rescue => e
+            logger.log(Logger::ERROR, "Unable to cast variable value '#{value}' to type '#{variable_type}': #{e.message}.")
+          end
+        when "integer"
+          begin
+            return_value = Integer(value)
+          rescue => e
+            logger.log(Logger::ERROR, "Unable to cast variable value '#{value}' to type '#{variable_type}': #{e.message}.")
+          end
+        else
+          # default case is string
+          return_value = value
+        end
+
+        return return_value
+      end
+    end
+  end
+end

lib/optimizely/project_config.rb

@@ -48,6 +48,7 @@ class ProjectConfig
     attr_reader :experiment_id_map
     attr_reader :experiment_key_map
     attr_reader :feature_flag_key_map
+    attr_reader :feature_variable_key_map
     attr_reader :group_key_map
     attr_reader :rollout_id_map
     attr_reader :rollout_experiment_id_map
@@ -129,6 +130,10 @@ def initialize(datafile, logger, error_handler)
         end
       end
       @feature_flag_key_map = generate_key_map(@feature_flags, 'key')
+      @feature_variable_key_map = {}
+      @feature_flag_key_map.each do |key, feature_flag|
+        @feature_variable_key_map[key] = generate_key_map(feature_flag['variables'], 'key')
+      end
       @parsing_succeeded = true
     end
 
@@ -303,6 +308,20 @@ def get_feature_flag_from_key(feature_flag_key)
       nil
     end
 
+    def get_feature_variable(feature_flag, variable_key)
+      # Retrieves the variable with the given key for the given feature
+      #
+      # feature_flag - The feature flag for which we are retrieving the variable
+      # variable_key - String variable key
+      #
+      # Returns variable if found, otherwise nil
+      feature_flag_key = feature_flag['key']
+      variable = @feature_variable_key_map[feature_flag_key][variable_key]
+      return variable if variable
+      @logger.log Logger::ERROR, "No feature variable was found for key '#{variable_key}' in feature flag '#{feature_flag_key}'."
+      nil
+    end
+
     def get_rollout_from_id(rollout_id)
       # Retrieves the rollout with the given ID
       #

spec/decision_service_spec.rb

@@ -269,11 +269,11 @@
     describe 'when the feature flag\'s experiment ids array is empty' do
       it 'should return nil and log a message' do
         user_attributes = {}
-        feature_flag = config.feature_flag_key_map['double_single_variable_feature']
+        feature_flag = config.feature_flag_key_map['empty_feature']
         expect(decision_service.get_variation_for_feature_experiment(feature_flag, 'user_1', user_attributes)).to eq(nil)
 
         expect(spy_logger).to have_received(:log).once
-                          .with(Logger::DEBUG, "The feature flag 'double_single_variable_feature' is not used in any experiments.")
+                          .with(Logger::DEBUG, "The feature flag 'empty_feature' is not used in any experiments.")
       end
     end