optimizely-sdk 3.1.1 → 3.2.0

data/lib/optimizely/audience.rb

@@ -24,7 +24,7 @@ module Optimizely
   module Audience
     module_function
 
-    def user_in_experiment?(config, experiment, attributes)
+    def user_in_experiment?(config, experiment, attributes, logger)
       # Determine for given experiment if user satisfies the audiences for the experiment.
       #
       # config - Representation of the Optimizely project config.
@@ -36,7 +36,7 @@ module Optimizely
 
       audience_conditions = experiment['audienceConditions'] || experiment['audienceIds']
 
-      config.logger.log(
+      logger.log(
         Logger::DEBUG,
         format(
           Helpers::Constants::AUDIENCE_EVALUATION_LOGS['EVALUATING_AUDIENCES_COMBINED'],
@@ -47,7 +47,7 @@ module Optimizely
 
       # Return true if there are no audiences
       if audience_conditions.empty?
-        config.logger.log(
+        logger.log(
           Logger::INFO,
           format(
             Helpers::Constants::AUDIENCE_EVALUATION_LOGS['AUDIENCE_EVALUATION_RESULT_COMBINED'],
@@ -60,7 +60,7 @@ module Optimizely
 
       attributes ||= {}
 
-      custom_attr_condition_evaluator = CustomAttributeConditionEvaluator.new(attributes, config.logger)
+      custom_attr_condition_evaluator = CustomAttributeConditionEvaluator.new(attributes, logger)
 
       evaluate_custom_attr = lambda do |condition|
         return custom_attr_condition_evaluator.evaluate(condition)
@@ -71,7 +71,7 @@ module Optimizely
         return nil unless audience
 
         audience_conditions = audience['conditions']
-        config.logger.log(
+        logger.log(
           Logger::DEBUG,
           format(
             Helpers::Constants::AUDIENCE_EVALUATION_LOGS['EVALUATING_AUDIENCE'],
@@ -83,7 +83,7 @@ module Optimizely
         audience_conditions = JSON.parse(audience_conditions) if audience_conditions.is_a?(String)
         result = ConditionTreeEvaluator.evaluate(audience_conditions, evaluate_custom_attr)
         result_str = result.nil? ? 'UNKNOWN' : result.to_s.upcase
-        config.logger.log(
+        logger.log(
           Logger::INFO,
           format(Helpers::Constants::AUDIENCE_EVALUATION_LOGS['AUDIENCE_EVALUATION_RESULT'], audience_id, result_str)
         )
@@ -94,7 +94,7 @@ module Optimizely
 
       eval_result ||= false
 
-      config.logger.log(
+      logger.log(
         Logger::INFO,
         format(
           Helpers::Constants::AUDIENCE_EVALUATION_LOGS['AUDIENCE_EVALUATION_RESULT_COMBINED'],

data/lib/optimizely/bucketer.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #
-#    Copyright 2016-2017, Optimizely and contributors
+#    Copyright 2016-2017, 2019 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.
@@ -28,18 +28,17 @@ module Optimizely
     MAX_TRAFFIC_VALUE = 10_000
     UNSIGNED_MAX_32_BIT_VALUE = 0xFFFFFFFF
 
-    def initialize(config)
-      # Bucketer init method to set bucketing seed and project config data.
-      #
-      # config - ProjectConfig data to be used in making bucketing decisions.
-
+    def initialize(logger)
+      # Bucketer init method to set bucketing seed and logger.
+      # logger - Optional component which provides a log method to log messages.
+      @logger = logger
       @bucket_seed = HASH_SEED
-      @config = config
     end
 
-    def bucket(experiment, bucketing_id, user_id)
+    def bucket(project_config, experiment, bucketing_id, user_id)
       # Determines ID of variation to be shown for a given experiment key and user ID.
       #
+      # project_config - Instance of ProjectConfig
       # experiment - Experiment for which visitor is to be bucketed.
       # bucketing_id - String A customer-assigned value used to generate the bucketing key
       # user_id - String ID for user.
@@ -52,19 +51,19 @@ module Optimizely
       experiment_key = experiment['key']
       group_id = experiment['groupId']
       if group_id
-        group = @config.group_key_map.fetch(group_id)
+        group = project_config.group_id_map.fetch(group_id)
         if Helpers::Group.random_policy?(group)
           traffic_allocations = group.fetch('trafficAllocation')
           bucketed_experiment_id = find_bucket(bucketing_id, user_id, group_id, traffic_allocations)
           # return if the user is not bucketed into any experiment
           unless bucketed_experiment_id
-            @config.logger.log(Logger::INFO, "User '#{user_id}' is in no experiment.")
+            @logger.log(Logger::INFO, "User '#{user_id}' is in no experiment.")
             return nil
           end
 
           # return if the user is bucketed into a different experiment than the one specified
           if bucketed_experiment_id != experiment_id
-            @config.logger.log(
+            @logger.log(
               Logger::INFO,
               "User '#{user_id}' is not in experiment '#{experiment_key}' of group #{group_id}."
             )
@@ -72,7 +71,7 @@ module Optimizely
           end
 
           # continue bucketing if the user is bucketed into the experiment specified
-          @config.logger.log(
+          @logger.log(
             Logger::INFO,
             "User '#{user_id}' is in experiment '#{experiment_key}' of group #{group_id}."
           )
@@ -82,9 +81,9 @@ module Optimizely
       traffic_allocations = experiment['trafficAllocation']
       variation_id = find_bucket(bucketing_id, user_id, experiment_id, traffic_allocations)
       if variation_id && variation_id != ''
-        variation = @config.get_variation_from_id(experiment_key, variation_id)
+        variation = project_config.get_variation_from_id(experiment_key, variation_id)
         variation_key = variation ? variation['key'] : nil
-        @config.logger.log(
+        @logger.log(
           Logger::INFO,
           "User '#{user_id}' is in variation '#{variation_key}' of experiment '#{experiment_key}'."
         )
@@ -93,13 +92,13 @@ module Optimizely
 
       # Handle the case when the traffic range is empty due to sticky bucketing
       if variation_id == ''
-        @config.logger.log(
+        @logger.log(
           Logger::DEBUG,
           'Bucketed into an empty traffic range. Returning nil.'
         )
       end
 
-      @config.logger.log(Logger::INFO, "User '#{user_id}' is in no variation.")
+      @logger.log(Logger::INFO, "User '#{user_id}' is in no variation.")
       nil
     end
 
@@ -114,7 +113,7 @@ module Optimizely
       # Returns entity ID corresponding to the provided bucket value or nil if no match is found.
       bucketing_key = format(BUCKETING_ID_TEMPLATE, bucketing_id: bucketing_id, entity_id: parent_id)
       bucket_value = generate_bucket_value(bucketing_key)
-      @config.logger.log(Logger::DEBUG, "Assigned bucket #{bucket_value} to user '#{user_id}' "\
+      @logger.log(Logger::DEBUG, "Assigned bucket #{bucket_value} to user '#{user_id}' "\
                          "with bucketing ID: '#{bucketing_id}'.")
 
       traffic_allocations.each do |traffic_allocation|

data/lib/optimizely/config/datafile_project_config.rb

@@ -0,0 +1,411 @@
+# frozen_string_literal: true
+
+#    Copyright 2019, 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 'json'
+require 'optimizely/project_config'
+require 'optimizely/helpers/constants'
+require 'optimizely/helpers/validator'
+module Optimizely
+  class DatafileProjectConfig < ProjectConfig
+    # Representation of the Optimizely project config.
+    RUNNING_EXPERIMENT_STATUS = ['Running'].freeze
+    RESERVED_ATTRIBUTE_PREFIX = '$opt_'
+
+    attr_reader :account_id
+    attr_reader :attributes
+    attr_reader :audiences
+    attr_reader :typed_audiences
+    attr_reader :events
+    attr_reader :experiments
+    attr_reader :feature_flags
+    attr_reader :groups
+    attr_reader :project_id
+    # Boolean - denotes if Optimizely should remove the last block of visitors' IP address before storing event data
+    attr_reader :anonymize_ip
+    attr_reader :bot_filtering
+    attr_reader :revision
+    attr_reader :rollouts
+    attr_reader :version
+
+    attr_reader :attribute_key_map
+    attr_reader :audience_id_map
+    attr_reader :event_key_map
+    attr_reader :experiment_feature_map
+    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_id_map
+    attr_reader :rollout_id_map
+    attr_reader :rollout_experiment_key_map
+    attr_reader :variation_id_map
+    attr_reader :variation_id_to_variable_usage_map
+    attr_reader :variation_key_map
+
+    def initialize(datafile, logger, error_handler)
+      # ProjectConfig init method to fetch and set project config data
+      #
+      # datafile - JSON string representing the project
+
+      config = JSON.parse(datafile)
+
+      @error_handler = error_handler
+      @logger = logger
+      @version = config['version']
+
+      raise InvalidDatafileVersionError, @version unless Helpers::Constants::SUPPORTED_VERSIONS.value?(@version)
+
+      @account_id = config['accountId']
+      @attributes = config.fetch('attributes', [])
+      @audiences = config.fetch('audiences', [])
+      @typed_audiences = config.fetch('typedAudiences', [])
+      @events = config.fetch('events', [])
+      @experiments = config['experiments']
+      @feature_flags = config.fetch('featureFlags', [])
+      @groups = config.fetch('groups', [])
+      @project_id = config['projectId']
+      @anonymize_ip = config.key?('anonymizeIP') ? config['anonymizeIP'] : false
+      @bot_filtering = config['botFiltering']
+      @revision = config['revision']
+      @rollouts = config.fetch('rollouts', [])
+
+      # Utility maps for quick lookup
+      @attribute_key_map = generate_key_map(@attributes, 'key')
+      @event_key_map = generate_key_map(@events, 'key')
+      @group_id_map = generate_key_map(@groups, 'id')
+      @group_id_map.each do |key, group|
+        exps = group.fetch('experiments')
+        exps.each do |exp|
+          @experiments.push(exp.merge('groupId' => key))
+        end
+      end
+      @experiment_key_map = generate_key_map(@experiments, 'key')
+      @experiment_id_map = generate_key_map(@experiments, 'id')
+      @audience_id_map = generate_key_map(@audiences, 'id')
+      @audience_id_map = @audience_id_map.merge(generate_key_map(@typed_audiences, 'id')) unless @typed_audiences.empty?
+      @variation_id_map = {}
+      @variation_key_map = {}
+      @variation_id_to_variable_usage_map = {}
+      @variation_id_to_experiment_map = {}
+      @experiment_key_map.each_value do |exp|
+        # Excludes experiments from rollouts
+        variations = exp.fetch('variations')
+        variations.each do |variation|
+          variation_id = variation['id']
+          @variation_id_to_experiment_map[variation_id] = exp
+        end
+      end
+      @rollout_id_map = generate_key_map(@rollouts, 'id')
+      # split out the experiment key map for rollouts
+      @rollout_experiment_key_map = {}
+      @rollout_id_map.each_value do |rollout|
+        exps = rollout.fetch('experiments')
+        @rollout_experiment_key_map = @rollout_experiment_key_map.merge(generate_key_map(exps, 'key'))
+      end
+      @all_experiments = @experiment_key_map.merge(@rollout_experiment_key_map)
+      @all_experiments.each do |key, exp|
+        variations = exp.fetch('variations')
+        variations.each do |variation|
+          variation_id = variation['id']
+          variation['featureEnabled'] = variation['featureEnabled'] == true
+          variation_variables = variation['variables']
+          next if variation_variables.nil?
+
+          @variation_id_to_variable_usage_map[variation_id] = generate_key_map(variation_variables, 'id')
+        end
+        @variation_id_map[key] = generate_key_map(variations, 'id')
+        @variation_key_map[key] = generate_key_map(variations, 'key')
+      end
+      @feature_flag_key_map = generate_key_map(@feature_flags, 'key')
+      @experiment_feature_map = {}
+      @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')
+        feature_flag['experimentIds'].each do |experiment_id|
+          @experiment_feature_map[experiment_id] = [feature_flag['id']]
+        end
+      end
+    end
+
+    def self.create(datafile, logger, error_handler, skip_json_validation)
+      # Looks up and sets datafile and config based on response body.
+      #
+      # datafile - JSON string representing the Optimizely project.
+      # logger - Provides a logger instance.
+      # error_handler - Provides a handle_error method to handle exceptions.
+      # skip_json_validation - Optional boolean param which allows skipping JSON schema
+      #                       validation upon object invocation. By default JSON schema validation will be performed.
+      # Returns instance of DatafileProjectConfig, nil otherwise.
+      if !skip_json_validation && !Helpers::Validator.datafile_valid?(datafile)
+        default_logger = SimpleLogger.new
+        default_logger.log(Logger::ERROR, InvalidInputError.new('datafile').message)
+        return nil
+      end
+
+      begin
+        config = new(datafile, logger, error_handler)
+      rescue StandardError => e
+        default_logger = SimpleLogger.new
+        error_msg = e.class == InvalidDatafileVersionError ? e.message : InvalidInputError.new('datafile').message
+        error_to_handle = e.class == InvalidDatafileVersionError ? InvalidDatafileVersionError : InvalidInputError
+        default_logger.log(Logger::ERROR, error_msg)
+        error_handler.handle_error error_to_handle
+        return nil
+      end
+
+      config
+    end
+
+    def experiment_running?(experiment)
+      # Determine if experiment corresponding to given key is running
+      #
+      # experiment - Experiment
+      #
+      # Returns true if experiment is running
+      RUNNING_EXPERIMENT_STATUS.include?(experiment['status'])
+    end
+
+    def get_experiment_from_key(experiment_key)
+      # Retrieves experiment ID for a given key
+      #
+      # experiment_key - String key representing the experiment
+      #
+      # Returns Experiment or nil if not found
+
+      experiment = @experiment_key_map[experiment_key]
+      return experiment if experiment
+
+      @logger.log Logger::ERROR, "Experiment key '#{experiment_key}' is not in datafile."
+      @error_handler.handle_error InvalidExperimentError
+      nil
+    end
+
+    def get_experiment_key(experiment_id)
+      # Retrieves experiment key for a given ID.
+      #
+      # experiment_id - String ID representing the experiment.
+      #
+      # Returns String key.
+
+      experiment = @experiment_id_map[experiment_id]
+      return experiment['key'] unless experiment.nil?
+
+      @logger.log Logger::ERROR, "Experiment id '#{experiment_id}' is not in datafile."
+      @error_handler.handle_error InvalidExperimentError
+      nil
+    end
+
+    def get_event_from_key(event_key)
+      # Get event for the provided event key.
+      #
+      # event_key - Event key for which event is to be determined.
+      #
+      # Returns Event corresponding to the provided event key.
+
+      event = @event_key_map[event_key]
+      return event if event
+
+      @logger.log Logger::ERROR, "Event '#{event_key}' is not in datafile."
+      @error_handler.handle_error InvalidEventError
+      nil
+    end
+
+    def get_audience_from_id(audience_id)
+      # Get audience for the provided audience ID
+      #
+      # audience_id - ID of the audience
+      #
+      # Returns the audience
+
+      audience = @audience_id_map[audience_id]
+      return audience if audience
+
+      @logger.log Logger::ERROR, "Audience '#{audience_id}' is not in datafile."
+      @error_handler.handle_error InvalidAudienceError
+      nil
+    end
+
+    def get_variation_from_id(experiment_key, variation_id)
+      # Get variation given experiment key and variation ID
+      #
+      # experiment_key - Key representing parent experiment of variation
+      # variation_id - ID of the variation
+      #
+      # Returns the variation or nil if not found
+
+      variation_id_map = @variation_id_map[experiment_key]
+      if variation_id_map
+        variation = variation_id_map[variation_id]
+        return variation if variation
+
+        @logger.log Logger::ERROR, "Variation id '#{variation_id}' is not in datafile."
+        @error_handler.handle_error InvalidVariationError
+        return nil
+      end
+
+      @logger.log Logger::ERROR, "Experiment key '#{experiment_key}' is not in datafile."
+      @error_handler.handle_error InvalidExperimentError
+      nil
+    end
+
+    def get_variation_id_from_key(experiment_key, variation_key)
+      # Get variation ID given experiment key and variation key
+      #
+      # experiment_key - Key representing parent experiment of variation
+      # variation_key - Key of the variation
+      #
+      # Returns ID of the variation
+
+      variation_key_map = @variation_key_map[experiment_key]
+      if variation_key_map
+        variation = variation_key_map[variation_key]
+        return variation['id'] if variation
+
+        @logger.log Logger::ERROR, "Variation key '#{variation_key}' is not in datafile."
+        @error_handler.handle_error InvalidVariationError
+        return nil
+      end
+
+      @logger.log Logger::ERROR, "Experiment key '#{experiment_key}' is not in datafile."
+      @error_handler.handle_error InvalidExperimentError
+      nil
+    end
+
+    def get_whitelisted_variations(experiment_key)
+      # Retrieves whitelisted variations for a given experiment Key
+      #
+      # experiment_key - String Key representing the experiment
+      #
+      # Returns whitelisted variations for the experiment or nil
+
+      experiment = @experiment_key_map[experiment_key]
+      return experiment['forcedVariations'] if experiment
+
+      @logger.log Logger::ERROR, "Experiment key '#{experiment_key}' is not in datafile."
+      @error_handler.handle_error InvalidExperimentError
+    end
+
+    def get_attribute_id(attribute_key)
+      # Get attribute ID for the provided attribute key.
+      #
+      # Args:
+      #   Attribute key for which attribute is to be fetched.
+      #
+      # Returns:
+      #   Attribute ID corresponding to the provided attribute key.
+      attribute = @attribute_key_map[attribute_key]
+      has_reserved_prefix = attribute_key.to_s.start_with?(RESERVED_ATTRIBUTE_PREFIX)
+      unless attribute.nil?
+        if has_reserved_prefix
+          @logger.log(Logger::WARN, "Attribute '#{attribute_key}' unexpectedly has reserved prefix '#{RESERVED_ATTRIBUTE_PREFIX}'; "\
+                      'using attribute ID instead of reserved attribute name.')
+        end
+        return attribute['id']
+      end
+      return attribute_key if has_reserved_prefix
+
+      @logger.log Logger::ERROR, "Attribute key '#{attribute_key}' is not in datafile."
+      @error_handler.handle_error InvalidAttributeError
+      nil
+    end
+
+    def variation_id_exists?(experiment_id, variation_id)
+      # Determines if a given experiment ID / variation ID pair exists in the datafile
+      #
+      # experiment_id - String experiment ID
+      # variation_id - String variation ID
+      #
+      # Returns true if variation is in datafile
+
+      experiment_key = get_experiment_key(experiment_id)
+      variation_id_map = @variation_id_map[experiment_key]
+      if variation_id_map
+        variation = variation_id_map[variation_id]
+        return true if variation
+
+        @logger.log Logger::ERROR, "Variation ID '#{variation_id}' is not in datafile."
+        @error_handler.handle_error InvalidVariationError
+      end
+
+      false
+    end
+
+    def get_feature_flag_from_key(feature_flag_key)
+      # Retrieves the feature flag with the given key
+      #
+      # feature_flag_key - String feature key
+      #
+      # Returns feature flag if found, otherwise nil
+      feature_flag = @feature_flag_key_map[feature_flag_key]
+      return feature_flag if feature_flag
+
+      @logger.log Logger::ERROR, "Feature flag key '#{feature_flag_key}' is not in datafile."
+      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
+      #
+      # rollout_id - String rollout ID
+      #
+      # Returns the rollout if found, otherwise nil
+      rollout = @rollout_id_map[rollout_id]
+      return rollout if rollout
+
+      @logger.log Logger::ERROR, "Rollout with ID '#{rollout_id}' is not in the datafile."
+      nil
+    end
+
+    def feature_experiment?(experiment_id)
+      # Determines if given experiment is a feature test.
+      #
+      # experiment_id - String experiment ID
+      #
+      # Returns true if experiment belongs to  any feature,
+      #              false otherwise.
+      @experiment_feature_map.key?(experiment_id)
+    end
+
+    private
+
+    def generate_key_map(array, key)
+      # Helper method to generate map from key to hash in array of hashes
+      #
+      # array - Array consisting of hash
+      # key - Key in each hash which will be key in the map
+      #
+      # Returns map mapping key to hash
+
+      Hash[array.map { |obj| [obj[key], obj] }]
+    end
+  end
+end