optimizely-sdk 3.8.1 → 3.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5751701cecb265d27a62c72b268fcb01bb5a37f8696f97a6f56ad29776b226cc
-  data.tar.gz: 32533f70bdd2861e2250b3c1b8e274d61f04395dd4ff5cf7ff0776d5f49c2a90
+  metadata.gz: f6a2a4abf7984fbba2d78c4c8cf39c39b66d3cd9e2d381b5d0e8ab0cc9ea0324
+  data.tar.gz: 62e9a6d0a44a5d83fcb4f574905cd64873c53d052503d135df6eb83b93c91b41
 SHA512:
-  metadata.gz: f7258d91de18c854b91f1d938c4624bf227307a2f01aec82aa23d1f2978ca8510209171f4dc62a3d2dcc606784a741dd9f6572d7c6a81475e2b791e70b7e45be
-  data.tar.gz: 1471cf812fbebc51fe2207e599f44b60597c3e6e15209af400d4ecabe0333bcd285269b3b421ad80f043c33012aecc54d3d41e59c53dffe64b09b93039b36254
+  metadata.gz: 807fe5ee0c7ab987ca2e273ea340aace86170295b0746f69b4ca5fb8e4d389093a43f1a8d625efd2e55c29960baa7dbc3b747111bd98bcf7e1e011da753cafff
+  data.tar.gz: 44fa786ddcc047608c8b3cac34c01c7f15822f9f33db0fd9cadedc2b4440a3b6b52177e94708223ae5e16d4ae5b46553e3c1820bb9b083dfcaee889e64ea3e8f

data/lib/optimizely/condition_tree_evaluator.rb

@@ -28,6 +28,8 @@ module Optimizely
       NOT_CONDITION => :not_evaluator
     }.freeze
 
+    OPERATORS = [AND_CONDITION, OR_CONDITION, NOT_CONDITION].freeze
+
     module_function
 
     def evaluate(conditions, leaf_evaluator)

data/lib/optimizely/config/datafile_project_config.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-#    Copyright 2019-2020, Optimizely and contributors
+#    Copyright 2019-2021, 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.
@@ -38,6 +38,8 @@ module Optimizely
     attr_reader :anonymize_ip
     attr_reader :bot_filtering
     attr_reader :revision
+    attr_reader :sdk_key
+    attr_reader :environment_key
     attr_reader :rollouts
     attr_reader :version
     attr_reader :send_flag_decisions
@@ -58,6 +60,7 @@ module Optimizely
     attr_reader :variation_key_map
     attr_reader :variation_id_map_by_experiment_id
     attr_reader :variation_key_map_by_experiment_id
+    attr_reader :flag_variation_map
 
     def initialize(datafile, logger, error_handler)
       # ProjectConfig init method to fetch and set project config data
@@ -85,6 +88,8 @@ module Optimizely
       @anonymize_ip = config.key?('anonymizeIP') ? config['anonymizeIP'] : false
       @bot_filtering = config['botFiltering']
       @revision = config['revision']
+      @sdk_key = config.fetch('sdkKey', '')
+      @environment_key = config.fetch('environmentKey', '')
       @rollouts = config.fetch('rollouts', [])
       @send_flag_decisions = config.fetch('sendFlagDecisions', false)
 
@@ -119,6 +124,8 @@ module Optimizely
       @variation_key_map_by_experiment_id = {}
       @variation_id_to_variable_usage_map = {}
       @variation_id_to_experiment_map = {}
+      @flag_variation_map = {}
+
       @experiment_id_map.each_value do |exp|
         # Excludes experiments from rollouts
         variations = exp.fetch('variations')
@@ -134,6 +141,8 @@ module Optimizely
         exps = rollout.fetch('experiments')
         @rollout_experiment_id_map = @rollout_experiment_id_map.merge(generate_key_map(exps, 'id'))
       end
+
+      @flag_variation_map = generate_feature_variation_map(@feature_flags)
       @all_experiments = @experiment_id_map.merge(@rollout_experiment_id_map)
       @all_experiments.each do |id, exp|
         variations = exp.fetch('variations')
@@ -161,6 +170,24 @@ module Optimizely
       end
     end
 
+    def get_rules_for_flag(feature_flag)
+      # Retrieves rules for a given feature flag
+      #
+      # feature_flag - String key representing the feature_flag
+      #
+      # Returns rules in feature flag
+      rules = feature_flag['experimentIds'].map { |exp_id| @experiment_id_map[exp_id] }
+      rollout = feature_flag['rolloutId'].empty? ? nil : @rollout_id_map[feature_flag['rolloutId']]
+
+      if rollout
+        rollout_experiments = rollout.fetch('experiments')
+        rollout_experiments.each do |exp|
+          rules.push(exp)
+        end
+      end
+      rules
+    end
+
     def self.create(datafile, logger, error_handler, skip_json_validation)
       # Looks up and sets datafile and config based on response body.
       #
@@ -275,6 +302,13 @@ module Optimizely
       nil
     end
 
+    def get_variation_from_flag(flag_key, target_value, attribute)
+      variations = @flag_variation_map[flag_key]
+      return variations.select { |variation| variation[attribute] == target_value }.first if variations
+
+      nil
+    end
+
     def get_variation_from_id(experiment_key, variation_id)
       # Get variation given experiment key and variation ID
       #
@@ -478,8 +512,32 @@ module Optimizely
       @experiment_feature_map.key?(experiment_id)
     end
 
+    def rollout_experiment?(experiment_id)
+      # Determines if given experiment is a rollout test.
+      #
+      # experiment_id - String experiment ID
+      #
+      # Returns true if experiment belongs to  any rollout,
+      #              false otherwise.
+      @rollout_experiment_id_map.key?(experiment_id)
+    end
+
     private
 
+    def generate_feature_variation_map(feature_flags)
+      flag_variation_map = {}
+      feature_flags.each do |flag|
+        variations = []
+        get_rules_for_flag(flag).each do |rule|
+          rule['variations'].each do |rule_variation|
+            variations.push(rule_variation) if variations.select { |variation| variation['id'] == rule_variation['id'] }.empty?
+          end
+        end
+        flag_variation_map[flag['key']] = variations
+      end
+      flag_variation_map
+    end
+
     def generate_key_map(array, key)
       # Helper method to generate map from key to hash in array of hashes
       #

data/lib/optimizely/config_manager/http_project_config_manager.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #
-#    Copyright 2019-2020, Optimizely and contributors
+#    Copyright 2019-2020, 2022, 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.
@@ -33,7 +33,7 @@ module Optimizely
   class HTTPProjectConfigManager < ProjectConfigManager
     # Config manager that polls for the datafile and updated ProjectConfig based on an update interval.
 
-    attr_reader :stopped, :optimizely_config
+    attr_reader :stopped
 
     # Initialize config manager. One of sdk_key or url has to be set to be able to use.
     #
@@ -80,8 +80,8 @@ module Optimizely
       @last_modified = nil
       @skip_json_validation = skip_json_validation
       @notification_center = notification_center.is_a?(Optimizely::NotificationCenter) ? notification_center : NotificationCenter.new(@logger, @error_handler)
+      @optimizely_config = nil
       @config = datafile.nil? ? nil : DatafileProjectConfig.create(datafile, @logger, @error_handler, @skip_json_validation)
-      @optimizely_config = @config.nil? ? nil : OptimizelyConfig.new(@config).config
       @mutex = Mutex.new
       @resource = ConditionVariable.new
       @async_scheduler = AsyncScheduler.new(method(:fetch_datafile_config), @polling_interval, auto_update, @logger)
@@ -140,6 +140,12 @@ module Optimizely
       @config
     end
 
+    def optimizely_config
+      @optimizely_config = OptimizelyConfig.new(@config).config if @optimizely_config.nil?
+
+      @optimizely_config
+    end
+
     private
 
     def fetch_datafile_config
@@ -209,7 +215,9 @@ module Optimizely
       end
 
       @config = config
-      @optimizely_config = OptimizelyConfig.new(config).config
+
+      # clearing old optimizely config so that a fresh one is generated on the next api call.
+      @optimizely_config = nil
 
       @notification_center.send_notifications(NotificationCenter::NOTIFICATION_TYPES[:OPTIMIZELY_CONFIG_UPDATE])
 

data/lib/optimizely/config_manager/static_project_config_manager.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #
-#    Copyright 2019-2020, Optimizely and contributors
+#    Copyright 2019-2020, 2022, 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.
@@ -23,7 +23,7 @@ require_relative 'project_config_manager'
 module Optimizely
   class StaticProjectConfigManager < ProjectConfigManager
     # Implementation of ProjectConfigManager interface.
-    attr_reader :config, :optimizely_config
+    attr_reader :config
 
     def initialize(datafile, logger, error_handler, skip_json_validation)
       # Looks up and sets datafile and config based on response body.
@@ -40,8 +40,13 @@ module Optimizely
         error_handler,
         skip_json_validation
       )
+      @optimizely_config = nil
+    end
+
+    def optimizely_config
+      @optimizely_config = OptimizelyConfig.new(@config).config if @optimizely_config.nil?
 
-      @optimizely_config = @config.nil? ? nil : OptimizelyConfig.new(@config).config
+      @optimizely_config
     end
   end
 end

data/lib/optimizely/decision_service.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #
-#    Copyright 2017-2021, Optimizely and contributors
+#    Copyright 2017-2022, 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.
@@ -52,18 +52,19 @@ module Optimizely
       @forced_variation_map = {}
     end
 
-    def get_variation(project_config, experiment_id, user_id, attributes = nil, decide_options = [])
+    def get_variation(project_config, experiment_id, user_context, decide_options = [])
       # Determines variation into which user will be bucketed.
       #
       # project_config - project_config - Instance of ProjectConfig
       # experiment_id - Experiment for which visitor variation needs to be determined
-      # user_id - String ID for user
-      # attributes - Hash representing user attributes
+      # user_context - Optimizely user context instance
       #
       # Returns variation ID where visitor will be bucketed
       #   (nil if experiment is inactive or user does not meet audience conditions)
 
       decide_reasons = []
+      user_id = user_context.user_id
+      attributes = user_context.user_attributes
       # By default, the bucketing ID should be the user ID
       bucketing_id, bucketing_id_reasons = get_bucketing_id(user_id, attributes)
       decide_reasons.push(*bucketing_id_reasons)
@@ -134,40 +135,39 @@ module Optimizely
       [variation_id, decide_reasons]
     end
 
-    def get_variation_for_feature(project_config, feature_flag, user_id, attributes = nil, decide_options = [])
+    def get_variation_for_feature(project_config, feature_flag, user_context, decide_options = [])
       # Get the variation the user is bucketed into for the given FeatureFlag.
       #
       # project_config - project_config - Instance of ProjectConfig
       # feature_flag - The feature flag the user wants to access
-      # user_id - String ID for the user
-      # attributes - Hash representing user attributes
+      # user_context - Optimizely user context instance
       #
       # Returns Decision struct (nil if the user is not bucketed into any of the experiments on the feature)
 
       decide_reasons = []
 
       # check if the feature is being experiment on and whether the user is bucketed into the experiment
-      decision, reasons_received = get_variation_for_feature_experiment(project_config, feature_flag, user_id, attributes, decide_options)
+      decision, reasons_received = get_variation_for_feature_experiment(project_config, feature_flag, user_context, decide_options)
       decide_reasons.push(*reasons_received)
       return decision, decide_reasons unless decision.nil?
 
-      decision, reasons_received = get_variation_for_feature_rollout(project_config, feature_flag, user_id, attributes)
+      decision, reasons_received = get_variation_for_feature_rollout(project_config, feature_flag, user_context)
       decide_reasons.push(*reasons_received)
 
       [decision, decide_reasons]
     end
 
-    def get_variation_for_feature_experiment(project_config, feature_flag, user_id, attributes = nil, decide_options = [])
+    def get_variation_for_feature_experiment(project_config, feature_flag, user_context, decide_options = [])
       # Gets the variation the user is bucketed into for the feature flag's experiment.
       #
       # project_config - project_config - Instance of ProjectConfig
       # feature_flag - The feature flag the user wants to access
-      # user_id - String ID for the user
-      # attributes - Hash representing user attributes
+      # user_context - Optimizely user context instance
       #
       # Returns Decision struct (nil if the user is not bucketed into any of the experiments on the feature)
       # or nil if the user is not bucketed into any of the experiments on the feature
       decide_reasons = []
+      user_id = user_context.user_id
       feature_flag_key = feature_flag['key']
       if feature_flag['experimentIds'].empty?
         message = "The feature flag '#{feature_flag_key}' is not used in any experiments."
@@ -187,12 +187,13 @@ module Optimizely
         end
 
         experiment_id = experiment['id']
-        variation_id, reasons_received = get_variation(project_config, experiment_id, user_id, attributes, decide_options)
+        variation_id, reasons_received = get_variation_from_experiment_rule(project_config, feature_flag_key, experiment, user_context, decide_options)
         decide_reasons.push(*reasons_received)
 
         next unless variation_id
 
         variation = project_config.get_variation_from_id_by_experiment_id(experiment_id, variation_id)
+        variation = project_config.get_variation_from_flag(feature_flag['key'], variation_id, 'id') if variation.nil?
 
         return Decision.new(experiment, variation, DECISION_SOURCES['FEATURE_TEST']), decide_reasons
       end
@@ -204,22 +205,20 @@ module Optimizely
       [nil, decide_reasons]
     end
 
-    def get_variation_for_feature_rollout(project_config, feature_flag, user_id, attributes = nil)
+    def get_variation_for_feature_rollout(project_config, feature_flag, user_context)
       # Determine which variation the user is in for a given rollout.
       # Returns the variation of the first experiment the user qualifies for.
       #
       # project_config - project_config - Instance of ProjectConfig
       # feature_flag - The feature flag the user wants to access
-      # user_id - String ID for the user
-      # attributes - Hash representing user attributes
+      # user_context - Optimizely user context instance
       #
       # Returns the Decision struct or nil if not bucketed into any of the targeting rules
       decide_reasons = []
-      bucketing_id, bucketing_id_reasons = get_bucketing_id(user_id, attributes)
-      decide_reasons.push(*bucketing_id_reasons)
+
       rollout_id = feature_flag['rolloutId']
+      feature_flag_key = feature_flag['key']
       if rollout_id.nil? || rollout_id.empty?
-        feature_flag_key = feature_flag['key']
         message = "Feature flag '#{feature_flag_key}' is not used in a rollout."
         @logger.log(Logger::DEBUG, message)
         decide_reasons.push(message)
@@ -236,60 +235,102 @@ module Optimizely
 
       return nil, decide_reasons if rollout['experiments'].empty?
 
+      index = 0
       rollout_rules = rollout['experiments']
-      number_of_rules = rollout_rules.length - 1
-
-      # Go through each experiment in order and try to get the variation for the user
-      number_of_rules.times do |index|
-        rollout_rule = rollout_rules[index]
-        logging_key = index + 1
-
-        user_meets_audience_conditions, reasons_received = Audience.user_meets_audience_conditions?(project_config, rollout_rule, attributes, @logger, 'ROLLOUT_AUDIENCE_EVALUATION_LOGS', logging_key)
+      while index < rollout_rules.length
+        variation, skip_to_everyone_else, reasons_received = get_variation_from_delivery_rule(project_config, feature_flag_key, rollout_rules, index, user_context)
         decide_reasons.push(*reasons_received)
-        # Check that user meets audience conditions for targeting rule
-        unless user_meets_audience_conditions
-          message = "User '#{user_id}' does not meet the audience conditions for targeting rule '#{logging_key}'."
-          @logger.log(Logger::DEBUG, message)
-          decide_reasons.push(message)
-          # move onto the next targeting rule
-          next
+        if variation
+          rule = rollout_rules[index]
+          feature_decision = Decision.new(rule, variation, DECISION_SOURCES['ROLLOUT'])
+          return [feature_decision, decide_reasons]
         end
 
-        message = "User '#{user_id}' meets the audience conditions for targeting rule '#{logging_key}'."
-        @logger.log(Logger::DEBUG, message)
-        decide_reasons.push(message)
+        index = skip_to_everyone_else ? (rollout_rules.length - 1) : (index + 1)
+      end
 
-        # Evaluate if user satisfies the traffic allocation for this rollout rule
-        variation, bucket_reasons = @bucketer.bucket(project_config, rollout_rule, bucketing_id, user_id)
-        decide_reasons.push(*bucket_reasons)
-        return Decision.new(rollout_rule, variation, DECISION_SOURCES['ROLLOUT']), decide_reasons unless variation.nil?
+      [nil, decide_reasons]
+    end
 
-        break
-      end
+    def get_variation_from_experiment_rule(project_config, flag_key, rule, user, options = [])
+      # Determine which variation the user is in for a given rollout.
+      # Returns the variation from experiment rules.
+      #
+      # project_config - project_config - Instance of ProjectConfig
+      # flag_key - The feature flag the user wants to access
+      # rule - An experiment rule key
+      # user - Optimizely user context instance
+      #
+      # Returns variation_id and reasons
+      reasons = []
 
-      # get last rule which is the everyone else rule
-      everyone_else_experiment = rollout_rules[number_of_rules]
-      logging_key = 'Everyone Else'
+      context = Optimizely::OptimizelyUserContext::OptimizelyDecisionContext.new(flag_key, rule['key'])
+      variation, forced_reasons = validated_forced_decision(project_config, context, user)
+      reasons.push(*forced_reasons)
 
-      user_meets_audience_conditions, reasons_received = Audience.user_meets_audience_conditions?(project_config, everyone_else_experiment, attributes, @logger, 'ROLLOUT_AUDIENCE_EVALUATION_LOGS', logging_key)
-      decide_reasons.push(*reasons_received)
-      # Check that user meets audience conditions for last rule
+      return [variation['id'], reasons] if variation
+
+      variation_id, response_reasons = get_variation(project_config, rule['id'], user, options)
+      reasons.push(*response_reasons)
+
+      [variation_id, reasons]
+    end
+
+    def get_variation_from_delivery_rule(project_config, flag_key, rules, rule_index, user)
+      # Determine which variation the user is in for a given rollout.
+      # Returns the variation from delivery rules.
+      #
+      # project_config - project_config - Instance of ProjectConfig
+      # flag_key - The feature flag the user wants to access
+      # rule - An experiment rule key
+      # user - Optimizely user context instance
+      #
+      # Returns variation, boolean to skip for eveyone else rule and reasons
+      reasons = []
+      skip_to_everyone_else = false
+      rule = rules[rule_index]
+      context = Optimizely::OptimizelyUserContext::OptimizelyDecisionContext.new(flag_key, rule['key'])
+      variation, forced_reasons = validated_forced_decision(project_config, context, user)
+      reasons.push(*forced_reasons)
+
+      return [variation, skip_to_everyone_else, reasons] if variation
+
+      user_id = user.user_id
+      attributes = user.user_attributes
+      bucketing_id, bucketing_id_reasons = get_bucketing_id(user_id, attributes)
+      reasons.push(*bucketing_id_reasons)
+
+      everyone_else = (rule_index == rules.length - 1)
+
+      logging_key = everyone_else ? 'Everyone Else' : (rule_index + 1).to_s
+
+      user_meets_audience_conditions, reasons_received = Audience.user_meets_audience_conditions?(project_config, rule, attributes, @logger, 'ROLLOUT_AUDIENCE_EVALUATION_LOGS', logging_key)
+      reasons.push(*reasons_received)
       unless user_meets_audience_conditions
-        message = "User '#{user_id}' does not meet the audience conditions for targeting rule '#{logging_key}'."
+        message = "User '#{user_id}' does not meet the conditions for targeting rule '#{logging_key}'."
         @logger.log(Logger::DEBUG, message)
-        decide_reasons.push(message)
-        return nil, decide_reasons
+        reasons.push(message)
+        return [nil, skip_to_everyone_else, reasons]
       end
 
       message = "User '#{user_id}' meets the audience conditions for targeting rule '#{logging_key}'."
       @logger.log(Logger::DEBUG, message)
-      decide_reasons.push(message)
+      reasons.push(message)
+      bucket_variation, bucket_reasons = @bucketer.bucket(project_config, rule, bucketing_id, user_id)
 
-      variation, bucket_reasons = @bucketer.bucket(project_config, everyone_else_experiment, bucketing_id, user_id)
-      decide_reasons.push(*bucket_reasons)
-      return Decision.new(everyone_else_experiment, variation, DECISION_SOURCES['ROLLOUT']), decide_reasons unless variation.nil?
+      reasons.push(*bucket_reasons)
 
-      [nil, decide_reasons]
+      if bucket_variation
+        message = "User '#{user_id}' is in the traffic group of targeting rule '#{logging_key}'."
+        @logger.log(Logger::DEBUG, message)
+        reasons.push(message)
+      elsif !everyone_else
+        message = "User '#{user_id}' is not in the traffic group for targeting rule '#{logging_key}'."
+        @logger.log(Logger::DEBUG, message)
+        reasons.push(message)
+        skip_to_everyone_else = true
+      end
+      [bucket_variation, skip_to_everyone_else, reasons]
     end
 
     def set_forced_variation(project_config, experiment_key, user_id, variation_key)
@@ -376,6 +417,28 @@ module Optimizely
       [variation, decide_reasons]
     end
 
+    def validated_forced_decision(project_config, context, user_context)
+      decision = user_context.get_forced_decision(context)
+      flag_key = context[:flag_key]
+      rule_key = context[:rule_key]
+      variation_key = decision ? decision[:variation_key] : decision
+      reasons = []
+      target = rule_key ? "flag (#{flag_key}), rule (#{rule_key})" : "flag (#{flag_key})"
+      if variation_key
+        variation = project_config.get_variation_from_flag(flag_key, variation_key, 'key')
+        if variation
+          reason = "Variation (#{variation_key}) is mapped to #{target} and user (#{user_context.user_id}) in the forced decision map."
+          reasons.push(reason)
+          return variation, reasons
+        else
+          reason = "Invalid variation is mapped to #{target} and user (#{user_context.user_id}) in the forced decision map."
+          reasons.push(reason)
+        end
+      end
+
+      [nil, reasons]
+    end
+
     private
 
     def get_whitelisted_variation_id(project_config, experiment_id, user_id)

data/lib/optimizely/optimizely_config.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-#    Copyright 2019-2020, Optimizely and contributors
+#    Copyright 2019-2021, 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.
@@ -16,53 +16,109 @@
 #
 
 module Optimizely
+  require 'json'
   class OptimizelyConfig
+    include Optimizely::ConditionTreeEvaluator
     def initialize(project_config)
       @project_config = project_config
+      @rollouts = @project_config.rollouts
+      @audiences = []
+      audience_id_lookup_dict = {}
+
+      @project_config.typed_audiences.each do |typed_audience|
+        @audiences.push(
+          'id' => typed_audience['id'],
+          'name' => typed_audience['name'],
+          'conditions' => typed_audience['conditions'].to_json
+        )
+        audience_id_lookup_dict[typed_audience['id']] = typed_audience['id']
+      end
+
+      @project_config.audiences.each do |audience|
+        next unless !audience_id_lookup_dict.key?(audience['id']) && (audience['id'] != '$opt_dummy_audience')
+
+        @audiences.push(
+          'id' => audience['id'],
+          'name' => audience['name'],
+          'conditions' => audience['conditions']
+        )
+      end
     end
 
     def config
       experiments_map_object = experiments_map
-      features_map = get_features_map(experiments_map_object)
-      {
+      features_map = get_features_map(experiments_id_map)
+      config = {
+        'sdkKey' => @project_config.sdk_key,
         'datafile' => @project_config.datafile,
+        # This experimentsMap is for experiments of legacy projects only.
+        # For flag projects, experiment keys are not guaranteed to be unique
+        # across multiple flags, so this map may not include all experiments
+        # when keys conflict. Use experimentRules and deliveryRules instead.
         'experimentsMap' => experiments_map_object,
         'featuresMap' => features_map,
-        'revision' => @project_config.revision
+        'revision' => @project_config.revision,
+        'attributes' => get_attributes_list(@project_config.attributes),
+        'audiences' => @audiences,
+        'events' => get_events_list(@project_config.events),
+        'environmentKey' => @project_config.environment_key
       }
+      config
     end
 
     private
 
-    def experiments_map
-      feature_variables_map = @project_config.feature_flags.reduce({}) do |result_map, feature|
-        result_map.update(feature['id'] => feature['variables'])
-      end
+    def experiments_id_map
+      feature_variables_map = feature_variable_map
+      audiences_id_map = audiences_map
       @project_config.experiments.reduce({}) do |experiments_map, experiment|
+        feature_id = @project_config.experiment_feature_map.fetch(experiment['id'], []).first
         experiments_map.update(
-          experiment['key'] => {
+          experiment['id'] => {
             'id' => experiment['id'],
             'key' => experiment['key'],
-            'variationsMap' => experiment['variations'].reduce({}) do |variations_map, variation|
-              variation_object = {
-                'id' => variation['id'],
-                'key' => variation['key'],
-                'variablesMap' => get_merged_variables_map(variation, experiment['id'], feature_variables_map)
-              }
-              variation_object['featureEnabled'] = variation['featureEnabled'] if @project_config.feature_experiment?(experiment['id'])
-              variations_map.update(variation['key'] => variation_object)
-            end
+            'variationsMap' => get_variation_map(feature_id, experiment, feature_variables_map),
+            'audiences' => replace_ids_with_names(experiment.fetch('audienceConditions', []), audiences_id_map) || ''
           }
         )
       end
     end
 
+    def audiences_map
+      @audiences.reduce({}) do |audiences_map, optly_audience|
+        audiences_map.update(optly_audience['id'] => optly_audience['name'])
+      end
+    end
+
+    def experiments_map
+      experiments_id_map.values.reduce({}) do |experiments_key_map, experiment|
+        experiments_key_map.update(experiment['key'] => experiment)
+      end
+    end
+
+    def feature_variable_map
+      @project_config.feature_flags.reduce({}) do |result_map, feature|
+        result_map.update(feature['id'] => feature['variables'])
+      end
+    end
+
+    def get_variation_map(feature_id, experiment, feature_variables_map)
+      experiment['variations'].reduce({}) do |variations_map, variation|
+        variation_object = {
+          'id' => variation['id'],
+          'key' => variation['key'],
+          'featureEnabled' => variation['featureEnabled'],
+          'variablesMap' => get_merged_variables_map(variation, feature_id, feature_variables_map)
+        }
+        variations_map.update(variation['key'] => variation_object)
+      end
+    end
+
     # Merges feature key and type from feature variables to variation variables.
-    def get_merged_variables_map(variation, experiment_id, feature_variables_map)
-      feature_ids = @project_config.experiment_feature_map[experiment_id]
-      return {} unless feature_ids
+    def get_merged_variables_map(variation, feature_id, feature_variables_map)
+      return {} unless feature_id
 
-      experiment_feature_variables = feature_variables_map[feature_ids[0]]
+      feature_variables = feature_variables_map[feature_id]
       # temporary variation variables map to get values to merge.
       temp_variables_id_map = {}
       if variation['variables']
@@ -75,7 +131,7 @@ module Optimizely
           )
         end
       end
-      experiment_feature_variables.reduce({}) do |variables_map, feature_variable|
+      feature_variables.reduce({}) do |variables_map, feature_variable|
         variation_variable = temp_variables_id_map[feature_variable['id']]
         variable_value = variation['featureEnabled'] && variation_variable ? variation_variable['value'] : feature_variable['defaultValue']
         variables_map.update(
@@ -91,13 +147,15 @@ module Optimizely
 
     def get_features_map(all_experiments_map)
       @project_config.feature_flags.reduce({}) do |features_map, feature|
+        delivery_rules = get_delivery_rules(@rollouts, feature['rolloutId'], feature['id'])
         features_map.update(
           feature['key'] => {
             'id' => feature['id'],
             'key' => feature['key'],
+            # This experimentsMap is deprecated. Use experimentRules and deliveryRules instead.
             'experimentsMap' => feature['experimentIds'].reduce({}) do |experiments_map, experiment_id|
               experiment_key = @project_config.experiment_id_map[experiment_id]['key']
-              experiments_map.update(experiment_key => all_experiments_map[experiment_key])
+              experiments_map.update(experiment_key => experiments_id_map[experiment_id])
             end,
             'variablesMap' => feature['variables'].reduce({}) do |variables, variable|
               variables.update(
@@ -108,10 +166,107 @@ module Optimizely
                   'value' => variable['defaultValue']
                 }
               )
-            end
+            end,
+            'experimentRules' => feature['experimentIds'].reduce([]) do |experiments_map, experiment_id|
+              experiments_map.push(all_experiments_map[experiment_id])
+            end,
+            'deliveryRules' => delivery_rules
           }
         )
       end
     end
+
+    def get_attributes_list(attributes)
+      attributes.map do |attribute|
+        {
+          'id' => attribute['id'],
+          'key' => attribute['key']
+        }
+      end
+    end
+
+    def get_events_list(events)
+      events.map do |event|
+        {
+          'id' => event['id'],
+          'key' => event['key'],
+          'experimentIds' => event['experimentIds']
+        }
+      end
+    end
+
+    def lookup_name_from_id(audience_id, audiences_map)
+      audiences_map[audience_id] || audience_id
+    end
+
+    def stringify_conditions(conditions, audiences_map)
+      operand = 'OR'
+      conditions_str = ''
+      length = conditions.length()
+      return '' if length.zero?
+      return '"' + lookup_name_from_id(conditions[0], audiences_map) + '"' if length == 1 && !OPERATORS.include?(conditions[0])
+
+      # Edge cases for lengths 0, 1 or 2
+      if length == 2 && OPERATORS.include?(conditions[0]) && !conditions[1].is_a?(Array) && !OPERATORS.include?(conditions[1])
+        return '"' + lookup_name_from_id(conditions[1], audiences_map) + '"' if conditions[0] != 'not'
+
+        return conditions[0].upcase + ' "' + lookup_name_from_id(conditions[1], audiences_map) + '"'
+
+      end
+      if length > 1
+        (0..length - 1).each do |n|
+          # Operand is handled here and made Upper Case
+          if OPERATORS.include?(conditions[n])
+            operand = conditions[n].upcase
+          # Check if element is a list or not
+          elsif conditions[n].is_a?(Array)
+            # Check if at the end or not to determine where to add the operand
+            # Recursive call to call stringify on embedded list
+            conditions_str += if n + 1 < length
+                                '(' + stringify_conditions(conditions[n], audiences_map) + ') '
+                              else
+                                operand + ' (' + stringify_conditions(conditions[n], audiences_map) + ')'
+                              end
+          # If the item is not a list, we process as an audience ID and retrieve the name
+          else
+            audience_name = lookup_name_from_id(conditions[n], audiences_map)
+            unless audience_name.nil?
+              # Below handles all cases for one ID or greater
+              conditions_str += if n + 1 < length - 1
+                                  '"' + audience_name + '" ' + operand + ' '
+                                elsif n + 1 == length
+                                  operand + ' "' + audience_name + '"'
+                                else
+                                  '"' + audience_name + '" '
+                                end
+            end
+          end
+        end
+      end
+      conditions_str || ''
+    end
+
+    def replace_ids_with_names(conditions, audiences_map)
+      !conditions.empty? ? stringify_conditions(conditions, audiences_map) : ''
+    end
+
+    def get_delivery_rules(rollouts, rollout_id, feature_id)
+      audiences_id_map = audiences_map
+      feature_variables_map = feature_variable_map
+      rollout = rollouts.select { |selected_rollout| selected_rollout['id'] == rollout_id }
+      if rollout.any?
+        rollout = rollout[0]
+        experiments = rollout['experiments']
+        return experiments.map do |experiment|
+          {
+            'id' => experiment['id'],
+            'key' => experiment['key'],
+            'variationsMap' => get_variation_map(feature_id, experiment, feature_variables_map),
+            'audiences' => replace_ids_with_names(experiment.fetch('audienceConditions', []), audiences_id_map) || ''
+          }
+        end
+      end
+      []
+    end
   end
 end

data/lib/optimizely/optimizely_user_context.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #
-#    Copyright 2020, Optimizely and contributors
+#    Copyright 2020-2022, 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.
@@ -23,16 +23,26 @@ module Optimizely
     # Representation of an Optimizely User Context using which APIs are to be called.
 
     attr_reader :user_id
+    attr_reader :forced_decisions
+    attr_reader :OptimizelyDecisionContext
+    attr_reader :OptimizelyForcedDecision
+    attr_reader :optimizely_client
 
+    OptimizelyDecisionContext = Struct.new(:flag_key, :rule_key)
+    OptimizelyForcedDecision = Struct.new(:variation_key)
     def initialize(optimizely_client, user_id, user_attributes)
       @attr_mutex = Mutex.new
+      @forced_decision_mutex = Mutex.new
       @optimizely_client = optimizely_client
       @user_id = user_id
       @user_attributes = user_attributes.nil? ? {} : user_attributes.clone
+      @forced_decisions = {}
     end
 
     def clone
-      OptimizelyUserContext.new(@optimizely_client, @user_id, user_attributes)
+      user_context = OptimizelyUserContext.new(@optimizely_client, @user_id, user_attributes)
+      @forced_decision_mutex.synchronize { user_context.instance_variable_set('@forced_decisions', @forced_decisions.dup) unless @forced_decisions.empty? }
+      user_context
     end
 
     def user_attributes
@@ -85,6 +95,68 @@ module Optimizely
       @optimizely_client&.decide_all(clone, options)
     end
 
+    # Sets the forced decision (variation key) for a given flag and an optional rule.
+    #
+    # @param context - An OptimizelyDecisionContext object containg flag key and rule key.
+    # @param decision - An OptimizelyForcedDecision object containing variation key
+    #
+    # @return - true if the forced decision has been set successfully.
+
+    def set_forced_decision(context, decision)
+      flag_key = context[:flag_key]
+      return false if flag_key.nil?
+
+      @forced_decision_mutex.synchronize { @forced_decisions[context] = decision }
+
+      true
+    end
+
+    def find_forced_decision(context)
+      return nil if @forced_decisions.empty?
+
+      decision = nil
+      @forced_decision_mutex.synchronize { decision = @forced_decisions[context] }
+      decision
+    end
+
+    # Returns the forced decision for a given flag and an optional rule.
+    #
+    # @param context - An OptimizelyDecisionContext object containg flag key and rule key.
+    #
+    # @return - A variation key or nil if forced decisions are not set for the parameters.
+
+    def get_forced_decision(context)
+      find_forced_decision(context)
+    end
+
+    # Removes the forced decision for a given flag and an optional rule.
+    #
+    # @param context - An OptimizelyDecisionContext object containg flag key and rule key.
+    #
+    # @return - true if the forced decision has been removed successfully.
+
+    def remove_forced_decision(context)
+      deleted = false
+      @forced_decision_mutex.synchronize do
+        if @forced_decisions.key?(context)
+          @forced_decisions.delete(context)
+          deleted = true
+        end
+      end
+      deleted
+    end
+
+    # Removes all forced decisions bound to this user context.
+    #
+    # @return - true if forced decisions have been removed successfully.
+
+    def remove_all_forced_decisions
+      return false if @optimizely_client&.get_optimizely_config.nil?
+
+      @forced_decision_mutex.synchronize { @forced_decisions.clear }
+      true
+    end
+
     # Track an event
     #
     # @param event_key - Event key representing the event which needs to be recorded.

data/lib/optimizely/project_config.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-#    Copyright 2016-2020, Optimizely and contributors
+#    Copyright 2016-2021, 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.
@@ -46,6 +46,10 @@ module Optimizely
 
     def revision; end
 
+    def sdk_key; end
+
+    def environment_key; end
+
     def send_flag_decisions; end
 
     def rollouts; end

data/lib/optimizely/version.rb

@@ -17,5 +17,5 @@
 #
 module Optimizely
   CLIENT_ENGINE = 'ruby-sdk'
-  VERSION = '3.8.1'
+  VERSION = '3.10.1'
 end

data/lib/optimizely.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #
-#    Copyright 2016-2021, Optimizely and contributors
+#    Copyright 2016-2022, 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.
@@ -198,17 +198,24 @@ module Optimizely
       decision_event_dispatched = false
       experiment = nil
       decision_source = Optimizely::DecisionService::DECISION_SOURCES['ROLLOUT']
-
-      decision, reasons_received = @decision_service.get_variation_for_feature(config, feature_flag, user_id, attributes, decide_options)
+      context = Optimizely::OptimizelyUserContext::OptimizelyDecisionContext.new(key, nil)
+      variation, reasons_received = @decision_service.validated_forced_decision(config, context, user_context)
       reasons.push(*reasons_received)
 
+      if variation
+        decision = Optimizely::DecisionService::Decision.new(nil, variation, Optimizely::DecisionService::DECISION_SOURCES['FEATURE_TEST'])
+      else
+        decision, reasons_received = @decision_service.get_variation_for_feature(config, feature_flag, user_context, decide_options)
+        reasons.push(*reasons_received)
+      end
+
       # Send impression event if Decision came from a feature test and decide options doesn't include disableDecisionEvent
       if decision.is_a?(Optimizely::DecisionService::Decision)
         experiment = decision.experiment
-        rule_key = experiment['key']
+        rule_key = experiment ? experiment['key'] : nil
         variation = decision['variation']
-        variation_key = variation['key']
-        feature_enabled = variation['featureEnabled']
+        variation_key = variation ? variation['key'] : nil
+        feature_enabled = variation ? variation['featureEnabled'] : false
         decision_source = decision.source
       end
 
@@ -291,6 +298,19 @@ module Optimizely
       decisions
     end
 
+    # Gets variation using variation key or id and flag key.
+    #
+    # @param flag_key - flag key from which the variation is required.
+    # @param target_value - variation value either id or key that will be matched.
+    # @param attribute - string representing variation attribute.
+    #
+    # @return [variation]
+    # @return [nil] if no variation found in flag_variation_map.
+
+    def get_flag_variation(flag_key, target_value, attribute)
+      project_config.get_variation_from_flag(flag_key, target_value, attribute)
+    end
+
     # Buckets visitor and sends impression event to Optimizely.
     #
     # @param experiment_key - Experiment which needs to be activated.
@@ -490,7 +510,8 @@ module Optimizely
         return false
       end
 
-      decision, = @decision_service.get_variation_for_feature(config, feature_flag, user_id, attributes)
+      user_context = create_user_context(user_id, attributes)
+      decision, = @decision_service.get_variation_for_feature(config, feature_flag, user_context)
 
       feature_enabled = false
       source_string = Optimizely::DecisionService::DECISION_SOURCES['ROLLOUT']
@@ -739,7 +760,8 @@ module Optimizely
         return nil
       end
 
-      decision, = @decision_service.get_variation_for_feature(config, feature_flag, user_id, attributes)
+      user_context = create_user_context(user_id, attributes)
+      decision, = @decision_service.get_variation_for_feature(config, feature_flag, user_context)
       variation = decision ? decision['variation'] : nil
       feature_enabled = variation ? variation['featureEnabled'] : false
       all_variables = {}
@@ -881,7 +903,8 @@ module Optimizely
 
       return nil unless user_inputs_valid?(attributes)
 
-      variation_id, = @decision_service.get_variation(config, experiment_id, user_id, attributes)
+      user_context = create_user_context(user_id, attributes)
+      variation_id, = @decision_service.get_variation(config, experiment_id, user_context)
       variation = config.get_variation_from_id(experiment_key, variation_id) unless variation_id.nil?
       variation_key = variation['key'] if variation
       decision_notification_type = if config.feature_experiment?(experiment_id)
@@ -947,7 +970,8 @@ module Optimizely
         return nil
       end
 
-      decision, = @decision_service.get_variation_for_feature(config, feature_flag, user_id, attributes)
+      user_context = create_user_context(user_id, attributes)
+      decision, = @decision_service.get_variation_for_feature(config, feature_flag, user_context)
       variation = decision ? decision['variation'] : nil
       feature_enabled = variation ? variation['featureEnabled'] : false
 
@@ -1083,8 +1107,12 @@ module Optimizely
       experiment_id = experiment['id']
       experiment_key = experiment['key']
 
-      variation_id = ''
-      variation_id = config.get_variation_id_from_key_by_experiment_id(experiment_id, variation_key) if experiment_id != ''
+      variation_id = config.get_variation_id_from_key_by_experiment_id(experiment_id, variation_key) unless experiment_id.empty?
+
+      unless variation_id
+        variation = !flag_key.empty? ? get_flag_variation(flag_key, variation_key, 'key') : nil
+        variation_id = variation ? variation['id'] : ''
+      end
 
       metadata = {
         flag_key: flag_key,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: optimizely-sdk
 version: !ruby/object:Gem::Version
-  version: 3.8.1
+  version: 3.10.1
 platform: ruby
 authors:
 - Optimizely
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-08-02 00:00:00.000000000 Z
+date: 2022-02-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler