optimizely-sdk 3.7.0 → 3.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 84b914d98655786586e8f691c82529bb3a8f074a6c157aceff6c2ef0ab4a4e3e
-  data.tar.gz: 484164de6c112f23adc94568371a33f564a99dba714c3141cf156783cb638a5d
+  metadata.gz: 62e8da2296d75e8f0cad746e8eca25c2670bde6bac084a840c46266322dc378f
+  data.tar.gz: 67d25b1695a294616b6dc62c7fa1d822c5262f273626d8c3c5a701e78b8e118f
 SHA512:
-  metadata.gz: b56b571c9aed79bdf0fdce664fa8ae24c152e52ac6804f3621c1597701a0293e4e105e0ce2db482d75640e81d7c8d9d1db085d70d0aa8827290277c87c280f68
-  data.tar.gz: a68af4ec2b0f7d02411e543aae1ca8e141d0be7a992e2d57ac6cd3c40e54ed3437ff39df312907914a679c7b75853902d4ab016b562428ae543f0af50730cabf
+  metadata.gz: 8891366e7765049a20b552eff7bd070c51eacf635664096235de97c9858f039410f23a5a3e6a902aee2269008cc50c1a45b22026c831843962c3ca04aa9f35af
+  data.tar.gz: 358139de2ecbbe9c6b2f4473bee6e56b784d22ef0e4067fc20a7f0e85a8d7cf293a6fe3cf7b9f4f1dbcf17c463392f8cedad62a7ad651f2fb70ecaee59fd5391

data/lib/optimizely.rb

@@ -19,6 +19,9 @@ require_relative 'optimizely/audience'
 require_relative 'optimizely/config/datafile_project_config'
 require_relative 'optimizely/config_manager/http_project_config_manager'
 require_relative 'optimizely/config_manager/static_project_config_manager'
+require_relative 'optimizely/decide/optimizely_decide_option'
+require_relative 'optimizely/decide/optimizely_decision'
+require_relative 'optimizely/decide/optimizely_decision_message'
 require_relative 'optimizely/decision_service'
 require_relative 'optimizely/error_handler'
 require_relative 'optimizely/event_builder'
@@ -34,9 +37,12 @@ require_relative 'optimizely/helpers/variable_type'
 require_relative 'optimizely/logger'
 require_relative 'optimizely/notification_center'
 require_relative 'optimizely/optimizely_config'
+require_relative 'optimizely/optimizely_user_context'
 
 module Optimizely
   class Project
+    include Optimizely::Decide
+
     attr_reader :notification_center
     # @api no-doc
     attr_reader :config_manager, :decision_service, :error_handler, :event_dispatcher,
@@ -67,12 +73,21 @@ module Optimizely
       sdk_key = nil,
       config_manager = nil,
       notification_center = nil,
-      event_processor = nil
+      event_processor = nil,
+      default_decide_options = []
     )
       @logger = logger || NoOpLogger.new
       @error_handler = error_handler || NoOpErrorHandler.new
       @event_dispatcher = event_dispatcher || EventDispatcher.new(logger: @logger, error_handler: @error_handler)
       @user_profile_service = user_profile_service
+      @default_decide_options = []
+
+      if default_decide_options.is_a? Array
+        @default_decide_options = default_decide_options.clone
+      else
+        @logger.log(Logger::DEBUG, 'Provided default decide options is not an array.')
+        @default_decide_options = []
+      end
 
       begin
         validate_instantiation_options
@@ -107,6 +122,175 @@ module Optimizely
                          end
     end
 
+    # Create a context of the user for which decision APIs will be called.
+    #
+    # A user context will be created successfully even when the SDK is not fully configured yet.
+    #
+    # @param user_id - The user ID to be used for bucketing.
+    # @param attributes - A Hash representing user attribute names and values.
+    #
+    # @return [OptimizelyUserContext] An OptimizelyUserContext associated with this OptimizelyClient.
+    # @return [nil] If user attributes are not in valid format.
+
+    def create_user_context(user_id, attributes = nil)
+      # We do not check for is_valid here as a user context can be created successfully
+      # even when the SDK is not fully configured.
+
+      # validate user_id
+      return nil unless Optimizely::Helpers::Validator.inputs_valid?(
+        {
+          user_id: user_id
+        }, @logger, Logger::ERROR
+      )
+
+      # validate attributes
+      return nil unless user_inputs_valid?(attributes)
+
+      user_context = OptimizelyUserContext.new(self, user_id, attributes)
+      user_context
+    end
+
+    def decide(user_context, key, decide_options = [])
+      # raising on user context as it is internal and not provided directly by the user.
+      raise if user_context.class != OptimizelyUserContext
+
+      reasons = []
+
+      # check if SDK is ready
+      unless is_valid
+        @logger.log(Logger::ERROR, InvalidProjectConfigError.new('decide').message)
+        reasons.push(OptimizelyDecisionMessage::SDK_NOT_READY)
+        return OptimizelyDecision.new(flag_key: key, user_context: user_context, reasons: reasons)
+      end
+
+      # validate that key is a string
+      unless key.is_a?(String)
+        @logger.log(Logger::ERROR, 'Provided key is invalid')
+        reasons.push(format(OptimizelyDecisionMessage::FLAG_KEY_INVALID, key))
+        return OptimizelyDecision.new(flag_key: key, user_context: user_context, reasons: reasons)
+      end
+
+      # validate that key maps to a feature flag
+      config = project_config
+      feature_flag = config.get_feature_flag_from_key(key)
+      unless feature_flag
+        @logger.log(Logger::ERROR, "No feature flag was found for key '#{key}'.")
+        reasons.push(format(OptimizelyDecisionMessage::FLAG_KEY_INVALID, key))
+        return OptimizelyDecision.new(flag_key: key, user_context: user_context, reasons: reasons)
+      end
+
+      # merge decide_options and default_decide_options
+      if decide_options.is_a? Array
+        decide_options += @default_decide_options
+      else
+        @logger.log(Logger::DEBUG, 'Provided decide options is not an array. Using default decide options.')
+        decide_options = @default_decide_options
+      end
+
+      # Create Optimizely Decision Result.
+      user_id = user_context.user_id
+      attributes = user_context.user_attributes
+      variation_key = nil
+      feature_enabled = false
+      rule_key = nil
+      flag_key = key
+      all_variables = {}
+      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)
+      reasons.push(*reasons_received)
+
+      # 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']
+        variation = decision['variation']
+        variation_key = variation['key']
+        feature_enabled = variation['featureEnabled']
+        decision_source = decision.source
+      end
+
+      unless decide_options.include? OptimizelyDecideOption::DISABLE_DECISION_EVENT
+        if decision_source == Optimizely::DecisionService::DECISION_SOURCES['FEATURE_TEST'] || config.send_flag_decisions
+          send_impression(config, experiment, variation_key || '', flag_key, rule_key || '', feature_enabled, decision_source, user_id, attributes)
+          decision_event_dispatched = true
+        end
+      end
+
+      # Generate all variables map if decide options doesn't include excludeVariables
+      unless decide_options.include? OptimizelyDecideOption::EXCLUDE_VARIABLES
+        feature_flag['variables'].each do |variable|
+          variable_value = get_feature_variable_for_variation(key, feature_enabled, variation, variable, user_id)
+          all_variables[variable['key']] = Helpers::VariableType.cast_value_to_type(variable_value, variable['type'], @logger)
+        end
+      end
+
+      should_include_reasons = decide_options.include? OptimizelyDecideOption::INCLUDE_REASONS
+
+      # Send notification
+      @notification_center.send_notifications(
+        NotificationCenter::NOTIFICATION_TYPES[:DECISION],
+        Helpers::Constants::DECISION_NOTIFICATION_TYPES['FLAG'],
+        user_id, (attributes || {}),
+        flag_key: flag_key,
+        enabled: feature_enabled,
+        variables: all_variables,
+        variation_key: variation_key,
+        rule_key: rule_key,
+        reasons: should_include_reasons ? reasons : [],
+        decision_event_dispatched: decision_event_dispatched
+      )
+
+      OptimizelyDecision.new(
+        variation_key: variation_key,
+        enabled: feature_enabled,
+        variables: all_variables,
+        rule_key: rule_key,
+        flag_key: flag_key,
+        user_context: user_context,
+        reasons: should_include_reasons ? reasons : []
+      )
+    end
+
+    def decide_all(user_context, decide_options = [])
+      # raising on user context as it is internal and not provided directly by the user.
+      raise if user_context.class != OptimizelyUserContext
+
+      # check if SDK is ready
+      unless is_valid
+        @logger.log(Logger::ERROR, InvalidProjectConfigError.new('decide_all').message)
+        return {}
+      end
+
+      keys = []
+      project_config.feature_flags.each do |feature_flag|
+        keys.push(feature_flag['key'])
+      end
+      decide_for_keys(user_context, keys, decide_options)
+    end
+
+    def decide_for_keys(user_context, keys, decide_options = [])
+      # raising on user context as it is internal and not provided directly by the user.
+      raise if user_context.class != OptimizelyUserContext
+
+      # check if SDK is ready
+      unless is_valid
+        @logger.log(Logger::ERROR, InvalidProjectConfigError.new('decide_for_keys').message)
+        return {}
+      end
+
+      enabled_flags_only = (!decide_options.nil? && (decide_options.include? OptimizelyDecideOption::ENABLED_FLAGS_ONLY)) || (@default_decide_options.include? OptimizelyDecideOption::ENABLED_FLAGS_ONLY)
+
+      decisions = {}
+      keys.each do |key|
+        decision = decide(user_context, key, decide_options)
+        decisions[key] = decision unless enabled_flags_only && !decision.enabled
+      end
+      decisions
+    end
+
     # Buckets visitor and sends impression event to Optimizely.
     #
     # @param experiment_key - Experiment which needs to be activated.
@@ -222,7 +406,7 @@ module Optimizely
       config = project_config
 
       forced_variation_key = nil
-      forced_variation = @decision_service.get_forced_variation(config, experiment_key, user_id)
+      forced_variation, = @decision_service.get_forced_variation(config, experiment_key, user_id)
       forced_variation_key = forced_variation['key'] if forced_variation
 
       forced_variation_key
@@ -306,7 +490,7 @@ module Optimizely
         return false
       end
 
-      decision = @decision_service.get_variation_for_feature(config, feature_flag, user_id, attributes)
+      decision, = @decision_service.get_variation_for_feature(config, feature_flag, user_id, attributes)
 
       feature_enabled = false
       source_string = Optimizely::DecisionService::DECISION_SOURCES['ROLLOUT']
@@ -555,7 +739,7 @@ module Optimizely
         return nil
       end
 
-      decision = @decision_service.get_variation_for_feature(config, feature_flag, user_id, attributes)
+      decision, = @decision_service.get_variation_for_feature(config, feature_flag, user_id, attributes)
       variation = decision ? decision['variation'] : nil
       feature_enabled = variation ? variation['featureEnabled'] : false
       all_variables = {}
@@ -695,7 +879,7 @@ module Optimizely
 
       return nil unless user_inputs_valid?(attributes)
 
-      variation_id = @decision_service.get_variation(config, experiment_key, user_id, attributes)
+      variation_id, = @decision_service.get_variation(config, experiment_key, user_id, attributes)
       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'])
@@ -761,7 +945,7 @@ module Optimizely
         return nil
       end
 
-      decision = @decision_service.get_variation_for_feature(config, feature_flag, user_id, attributes)
+      decision, = @decision_service.get_variation_for_feature(config, feature_flag, user_id, attributes)
       variation = decision ? decision['variation'] : nil
       feature_enabled = variation ? variation['featureEnabled'] : false
 

data/lib/optimizely/audience.rb

@@ -38,6 +38,7 @@ module Optimizely
       #               This defaults to experiment['key'].
       #
       # Returns boolean representing if user satisfies audience conditions for the audiences or not.
+      decide_reasons = []
       logging_hash ||= 'EXPERIMENT_AUDIENCE_EVALUATION_LOGS'
       logging_key ||= experiment['key']
 
@@ -45,26 +46,15 @@ module Optimizely
 
       audience_conditions = experiment['audienceConditions'] || experiment['audienceIds']
 
-      logger.log(
-        Logger::DEBUG,
-        format(
-          logs_hash['EVALUATING_AUDIENCES_COMBINED'],
-          logging_key,
-          audience_conditions
-        )
-      )
+      message = format(logs_hash['EVALUATING_AUDIENCES_COMBINED'], logging_key, audience_conditions)
+      logger.log(Logger::DEBUG, message)
 
       # Return true if there are no audiences
       if audience_conditions.empty?
-        logger.log(
-          Logger::INFO,
-          format(
-            logs_hash['AUDIENCE_EVALUATION_RESULT_COMBINED'],
-            logging_key,
-            'TRUE'
-          )
-        )
-        return true
+        message = format(logs_hash['AUDIENCE_EVALUATION_RESULT_COMBINED'], logging_key, 'TRUE')
+        logger.log(Logger::INFO, message)
+        decide_reasons.push(message)
+        return true, decide_reasons
       end
 
       attributes ||= {}
@@ -80,39 +70,28 @@ module Optimizely
         return nil unless audience
 
         audience_conditions = audience['conditions']
-        logger.log(
-          Logger::DEBUG,
-          format(
-            logs_hash['EVALUATING_AUDIENCE'],
-            audience_id,
-            audience_conditions
-          )
-        )
+        message = format(logs_hash['EVALUATING_AUDIENCE'], audience_id, audience_conditions)
+        logger.log(Logger::DEBUG, message)
+        decide_reasons.push(message)
 
         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
-        logger.log(
-          Logger::DEBUG,
-          format(logs_hash['AUDIENCE_EVALUATION_RESULT'], audience_id, result_str)
-        )
+        message = format(logs_hash['AUDIENCE_EVALUATION_RESULT'], audience_id, result_str)
+        logger.log(Logger::DEBUG, message)
+        decide_reasons.push(message)
+
         result
       end
 
       eval_result = ConditionTreeEvaluator.evaluate(audience_conditions, evaluate_audience)
-
       eval_result ||= false
 
-      logger.log(
-        Logger::INFO,
-        format(
-          logs_hash['AUDIENCE_EVALUATION_RESULT_COMBINED'],
-          logging_key,
-          eval_result.to_s.upcase
-        )
-      )
+      message = format(logs_hash['AUDIENCE_EVALUATION_RESULT_COMBINED'], logging_key, eval_result.to_s.upcase)
+      logger.log(Logger::INFO, message)
+      decide_reasons.push(message)
 
-      eval_result
+      [eval_result, decide_reasons]
     end
   end
 end

data/lib/optimizely/bucketer.rb

@@ -44,7 +44,9 @@ module Optimizely
       # user_id - String ID for user.
       #
       # Returns variation in which visitor with ID user_id has been placed. Nil if no variation.
-      return nil if experiment.nil?
+      return nil, [] if experiment.nil?
+
+      decide_reasons = []
 
       # check if experiment is in a group; if so, check if user is bucketed into specified experiment
       # this will not affect evaluation of rollout rules.
@@ -55,46 +57,49 @@ module Optimizely
         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)
+          bucketed_experiment_id, find_bucket_reasons = find_bucket(bucketing_id, user_id, group_id, traffic_allocations)
+          decide_reasons.push(*find_bucket_reasons)
+
           # return if the user is not bucketed into any experiment
           unless bucketed_experiment_id
-            @logger.log(Logger::INFO, "User '#{user_id}' is in no experiment.")
-            return nil
+            message = "User '#{user_id}' is in no experiment."
+            @logger.log(Logger::INFO, message)
+            decide_reasons.push(message)
+            return nil, decide_reasons
           end
 
           # return if the user is bucketed into a different experiment than the one specified
           if bucketed_experiment_id != experiment_id
-            @logger.log(
-              Logger::INFO,
-              "User '#{user_id}' is not in experiment '#{experiment_key}' of group #{group_id}."
-            )
-            return nil
+            message = "User '#{user_id}' is not in experiment '#{experiment_key}' of group #{group_id}."
+            @logger.log(Logger::INFO, message)
+            decide_reasons.push(message)
+            return nil, decide_reasons
           end
 
           # continue bucketing if the user is bucketed into the experiment specified
-          @logger.log(
-            Logger::INFO,
-            "User '#{user_id}' is in experiment '#{experiment_key}' of group #{group_id}."
-          )
+          message = "User '#{user_id}' is in experiment '#{experiment_key}' of group #{group_id}."
+          @logger.log(Logger::INFO, message)
+          decide_reasons.push(message)
         end
       end
 
       traffic_allocations = experiment['trafficAllocation']
-      variation_id = find_bucket(bucketing_id, user_id, experiment_id, traffic_allocations)
+      variation_id, find_bucket_reasons = find_bucket(bucketing_id, user_id, experiment_id, traffic_allocations)
+      decide_reasons.push(*find_bucket_reasons)
+
       if variation_id && variation_id != ''
         variation = project_config.get_variation_from_id(experiment_key, variation_id)
-        return variation
+        return variation, decide_reasons
       end
 
       # Handle the case when the traffic range is empty due to sticky bucketing
       if variation_id == ''
-        @logger.log(
-          Logger::DEBUG,
-          'Bucketed into an empty traffic range. Returning nil.'
-        )
+        message = 'Bucketed into an empty traffic range. Returning nil.'
+        @logger.log(Logger::DEBUG, message)
+        decide_reasons.push(message)
       end
 
-      nil
+      [nil, decide_reasons]
     end
 
     def find_bucket(bucketing_id, user_id, parent_id, traffic_allocations)
@@ -105,21 +110,24 @@ module Optimizely
       # parent_id - String entity ID to use for bucketing ID
       # traffic_allocations - Array of traffic allocations
       #
-      # Returns entity ID corresponding to the provided bucket value or nil if no match is found.
+      # Returns and array of two values where first value is the entity ID corresponding to the provided bucket value
+      # or nil if no match is found. The second value contains the array of reasons stating how the deicision was taken
+      decide_reasons = []
       bucketing_key = format(BUCKETING_ID_TEMPLATE, bucketing_id: bucketing_id, entity_id: parent_id)
       bucket_value = generate_bucket_value(bucketing_key)
-      @logger.log(Logger::DEBUG, "Assigned bucket #{bucket_value} to user '#{user_id}' "\
-                         "with bucketing ID: '#{bucketing_id}'.")
+
+      message = "Assigned bucket #{bucket_value} to user '#{user_id}' with bucketing ID: '#{bucketing_id}'."
+      @logger.log(Logger::DEBUG, message)
 
       traffic_allocations.each do |traffic_allocation|
         current_end_of_range = traffic_allocation['endOfRange']
         if bucket_value < current_end_of_range
           entity_id = traffic_allocation['entityId']
-          return entity_id
+          return entity_id, decide_reasons
         end
       end
 
-      nil
+      [nil, decide_reasons]
     end
 
     private

data/lib/optimizely/decide/optimizely_decide_option.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+#    Copyright 2020, 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.
+#
+
+module Optimizely
+  module Decide
+    module OptimizelyDecideOption
+      DISABLE_DECISION_EVENT = 'DISABLE_DECISION_EVENT'
+      ENABLED_FLAGS_ONLY = 'ENABLED_FLAGS_ONLY'
+      IGNORE_USER_PROFILE_SERVICE = 'IGNORE_USER_PROFILE_SERVICE'
+      INCLUDE_REASONS = 'INCLUDE_REASONS'
+      EXCLUDE_VARIABLES = 'EXCLUDE_VARIABLES'
+    end
+  end
+end

data/lib/optimizely/decide/optimizely_decision.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+#    Copyright 2020, 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'
+
+module Optimizely
+  module Decide
+    class OptimizelyDecision
+      attr_reader :variation_key, :enabled, :variables, :rule_key, :flag_key, :user_context, :reasons
+
+      def initialize(
+        variation_key: nil,
+        enabled: nil,
+        variables: nil,
+        rule_key: nil,
+        flag_key: nil,
+        user_context: nil,
+        reasons: nil
+      )
+        @variation_key = variation_key
+        @enabled = enabled || false
+        @variables = variables || {}
+        @rule_key = rule_key
+        @flag_key = flag_key
+        @user_context = user_context
+        @reasons = reasons || []
+      end
+
+      def as_json
+        {
+          variation_key: @variation_key,
+          enabled: @enabled,
+          variables: @variables,
+          rule_key: @rule_key,
+          flag_key: @flag_key,
+          user_context: @user_context.as_json,
+          reasons: @reasons
+        }
+      end
+
+      def to_json(*args)
+        as_json.to_json(*args)
+      end
+    end
+  end
+end

data/lib/optimizely/decide/optimizely_decision_message.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+#    Copyright 2020, 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.
+#
+
+module Optimizely
+  module Decide
+    module OptimizelyDecisionMessage
+      SDK_NOT_READY = 'Optimizely SDK not configured properly yet.'
+      FLAG_KEY_INVALID = 'No flag was found for key "%s".'
+      VARIABLE_VALUE_INVALID = 'Variable value for key "%s" is invalid or wrong type.'
+    end
+  end
+end

data/lib/optimizely/decision_service.rb

@@ -52,7 +52,7 @@ module Optimizely
       @forced_variation_map = {}
     end
 
-    def get_variation(project_config, experiment_key, user_id, attributes = nil)
+    def get_variation(project_config, experiment_key, user_id, attributes = nil, decide_options = [])
       # Determines variation into which user will be bucketed.
       #
       # project_config - project_config - Instance of ProjectConfig
@@ -63,66 +63,78 @@ module Optimizely
       # Returns variation ID where visitor will be bucketed
       #   (nil if experiment is inactive or user does not meet audience conditions)
 
+      decide_reasons = []
       # By default, the bucketing ID should be the user ID
-      bucketing_id = get_bucketing_id(user_id, attributes)
+      bucketing_id, bucketing_id_reasons = get_bucketing_id(user_id, attributes)
+      decide_reasons.push(*bucketing_id_reasons)
       # Check to make sure experiment is active
       experiment = project_config.get_experiment_from_key(experiment_key)
-      return nil if experiment.nil?
+      return nil, decide_reasons if experiment.nil?
 
       experiment_id = experiment['id']
       unless project_config.experiment_running?(experiment)
-        @logger.log(Logger::INFO, "Experiment '#{experiment_key}' is not running.")
-        return nil
+        message = "Experiment '#{experiment_key}' is not running."
+        @logger.log(Logger::INFO, message)
+        decide_reasons.push(message)
+        return nil, decide_reasons
       end
 
       # Check if a forced variation is set for the user
-      forced_variation = get_forced_variation(project_config, experiment_key, user_id)
-      return forced_variation['id'] if forced_variation
+      forced_variation, reasons_received = get_forced_variation(project_config, experiment_key, user_id)
+      decide_reasons.push(*reasons_received)
+      return forced_variation['id'], decide_reasons if forced_variation
 
       # Check if user is in a white-listed variation
-      whitelisted_variation_id = get_whitelisted_variation_id(project_config, experiment_key, user_id)
-      return whitelisted_variation_id if whitelisted_variation_id
-
-      # Check for saved bucketing decisions
-      user_profile = get_user_profile(user_id)
-      saved_variation_id = get_saved_variation_id(project_config, experiment_id, user_profile)
-      if saved_variation_id
-        @logger.log(
-          Logger::INFO,
-          "Returning previously activated variation ID #{saved_variation_id} of experiment '#{experiment_key}' for user '#{user_id}' from user profile."
-        )
-        return saved_variation_id
+      whitelisted_variation_id, reasons_received = get_whitelisted_variation_id(project_config, experiment_key, user_id)
+      decide_reasons.push(*reasons_received)
+      return whitelisted_variation_id, decide_reasons if whitelisted_variation_id
+
+      should_ignore_user_profile_service = decide_options.include? Optimizely::Decide::OptimizelyDecideOption::IGNORE_USER_PROFILE_SERVICE
+      # Check for saved bucketing decisions if decide_options do not include ignoreUserProfileService
+      unless should_ignore_user_profile_service
+        user_profile, reasons_received = get_user_profile(user_id)
+        decide_reasons.push(*reasons_received)
+        saved_variation_id, reasons_received = get_saved_variation_id(project_config, experiment_id, user_profile)
+        decide_reasons.push(*reasons_received)
+        if saved_variation_id
+          message = "Returning previously activated variation ID #{saved_variation_id} of experiment '#{experiment_key}' for user '#{user_id}' from user profile."
+          @logger.log(Logger::INFO, message)
+          decide_reasons.push(message)
+          return saved_variation_id, decide_reasons
+        end
       end
 
       # Check audience conditions
-      unless Audience.user_meets_audience_conditions?(project_config, experiment, attributes, @logger)
-        @logger.log(
-          Logger::INFO,
-          "User '#{user_id}' does not meet the conditions to be in experiment '#{experiment_key}'."
-        )
-        return nil
+      user_meets_audience_conditions, reasons_received = Audience.user_meets_audience_conditions?(project_config, experiment, attributes, @logger)
+      decide_reasons.push(*reasons_received)
+      unless user_meets_audience_conditions
+        message = "User '#{user_id}' does not meet the conditions to be in experiment '#{experiment_key}'."
+        @logger.log(Logger::INFO, message)
+        decide_reasons.push(message)
+        return nil, decide_reasons
       end
 
       # Bucket normally
-      variation = @bucketer.bucket(project_config, experiment, bucketing_id, user_id)
+      variation, bucket_reasons = @bucketer.bucket(project_config, experiment, bucketing_id, user_id)
+      decide_reasons.push(*bucket_reasons)
       variation_id = variation ? variation['id'] : nil
 
+      message = ''
       if variation_id
         variation_key = variation['key']
-        @logger.log(
-          Logger::INFO,
-          "User '#{user_id}' is in variation '#{variation_key}' of experiment '#{experiment_key}'."
-        )
+        message = "User '#{user_id}' is in variation '#{variation_key}' of experiment '#{experiment_key}'."
       else
-        @logger.log(Logger::INFO, "User '#{user_id}' is in no variation.")
+        message = "User '#{user_id}' is in no variation."
       end
+      @logger.log(Logger::INFO, message)
+      decide_reasons.push(message)
 
       # Persist bucketing decision
-      save_user_profile(user_profile, experiment_id, variation_id)
-      variation_id
+      save_user_profile(user_profile, experiment_id, variation_id) unless should_ignore_user_profile_service
+      [variation_id, decide_reasons]
     end
 
-    def get_variation_for_feature(project_config, feature_flag, user_id, attributes = nil)
+    def get_variation_for_feature(project_config, feature_flag, user_id, attributes = nil, decide_options = [])
       # Get the variation the user is bucketed into for the given FeatureFlag.
       #
       # project_config - project_config - Instance of ProjectConfig
@@ -132,16 +144,20 @@ module Optimizely
       #
       # 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 = get_variation_for_feature_experiment(project_config, feature_flag, user_id, attributes)
-      return decision unless decision.nil?
+      decision, reasons_received = get_variation_for_feature_experiment(project_config, feature_flag, user_id, attributes, decide_options)
+      decide_reasons.push(*reasons_received)
+      return decision, decide_reasons unless decision.nil?
 
-      decision = 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_id, attributes)
+      decide_reasons.push(*reasons_received)
 
-      decision
+      [decision, decide_reasons]
     end
 
-    def get_variation_for_feature_experiment(project_config, feature_flag, user_id, attributes = nil)
+    def get_variation_for_feature_experiment(project_config, feature_flag, user_id, attributes = nil, decide_options = [])
       # Gets the variation the user is bucketed into for the feature flag's experiment.
       #
       # project_config - project_config - Instance of ProjectConfig
@@ -151,42 +167,41 @@ module Optimizely
       #
       # 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 = []
       feature_flag_key = feature_flag['key']
       if feature_flag['experimentIds'].empty?
-        @logger.log(
-          Logger::DEBUG,
-          "The feature flag '#{feature_flag_key}' is not used in any experiments."
-        )
-        return nil
+        message = "The feature flag '#{feature_flag_key}' is not used in any experiments."
+        @logger.log(Logger::DEBUG, message)
+        decide_reasons.push(message)
+        return nil, decide_reasons
       end
 
       # Evaluate each experiment and return the first bucketed experiment variation
       feature_flag['experimentIds'].each do |experiment_id|
         experiment = project_config.experiment_id_map[experiment_id]
         unless experiment
-          @logger.log(
-            Logger::DEBUG,
-            "Feature flag experiment with ID '#{experiment_id}' is not in the datafile."
-          )
-          return nil
+          message = "Feature flag experiment with ID '#{experiment_id}' is not in the datafile."
+          @logger.log(Logger::DEBUG, message)
+          decide_reasons.push(message)
+          return nil, decide_reasons
         end
 
         experiment_key = experiment['key']
-        variation_id = get_variation(project_config, experiment_key, user_id, attributes)
+        variation_id, reasons_received = get_variation(project_config, experiment_key, user_id, attributes, decide_options)
+        decide_reasons.push(*reasons_received)
 
         next unless variation_id
 
         variation = project_config.variation_id_map[experiment_key][variation_id]
 
-        return Decision.new(experiment, variation, DECISION_SOURCES['FEATURE_TEST'])
+        return Decision.new(experiment, variation, DECISION_SOURCES['FEATURE_TEST']), decide_reasons
       end
 
-      @logger.log(
-        Logger::INFO,
-        "The user '#{user_id}' is not bucketed into any of the experiments on the feature '#{feature_flag_key}'."
-      )
+      message = "The user '#{user_id}' is not bucketed into any of the experiments on the feature '#{feature_flag_key}'."
+      @logger.log(Logger::INFO, message)
+      decide_reasons.push(message)
 
-      nil
+      [nil, decide_reasons]
     end
 
     def get_variation_for_feature_rollout(project_config, feature_flag, user_id, attributes = nil)
@@ -199,27 +214,27 @@ module Optimizely
       # attributes - Hash representing user attributes
       #
       # Returns the Decision struct or nil if not bucketed into any of the targeting rules
-      bucketing_id = get_bucketing_id(user_id, attributes)
+      decide_reasons = []
+      bucketing_id, bucketing_id_reasons = get_bucketing_id(user_id, attributes)
+      decide_reasons.push(*bucketing_id_reasons)
       rollout_id = feature_flag['rolloutId']
       if rollout_id.nil? || rollout_id.empty?
         feature_flag_key = feature_flag['key']
-        @logger.log(
-          Logger::DEBUG,
-          "Feature flag '#{feature_flag_key}' is not used in a rollout."
-        )
-        return nil
+        message = "Feature flag '#{feature_flag_key}' is not used in a rollout."
+        @logger.log(Logger::DEBUG, message)
+        decide_reasons.push(message)
+        return nil, decide_reasons
       end
 
       rollout = project_config.get_rollout_from_id(rollout_id)
       if rollout.nil?
-        @logger.log(
-          Logger::DEBUG,
-          "Rollout with ID '#{rollout_id}' is not in the datafile '#{feature_flag['key']}'"
-        )
-        return nil
+        message = "Rollout with ID '#{rollout_id}' is not in the datafile '#{feature_flag['key']}'"
+        @logger.log(Logger::DEBUG, message)
+        decide_reasons.push(message)
+        return nil, decide_reasons
       end
 
-      return nil if rollout['experiments'].empty?
+      return nil, decide_reasons if rollout['experiments'].empty?
 
       rollout_rules = rollout['experiments']
       number_of_rules = rollout_rules.length - 1
@@ -229,24 +244,25 @@ module Optimizely
         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)
+        decide_reasons.push(*reasons_received)
         # Check that user meets audience conditions for targeting rule
-        unless Audience.user_meets_audience_conditions?(project_config, rollout_rule, attributes, @logger, 'ROLLOUT_AUDIENCE_EVALUATION_LOGS', logging_key)
-          @logger.log(
-            Logger::DEBUG,
-            "User '#{user_id}' does not meet the audience conditions for targeting rule '#{logging_key}'."
-          )
+        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
         end
 
-        @logger.log(
-          Logger::DEBUG,
-          "User '#{user_id}' meets the audience conditions for targeting rule '#{logging_key}'."
-        )
+        message = "User '#{user_id}' meets the audience conditions for targeting rule '#{logging_key}'."
+        @logger.log(Logger::DEBUG, message)
+        decide_reasons.push(message)
 
         # Evaluate if user satisfies the traffic allocation for this rollout rule
-        variation = @bucketer.bucket(project_config, rollout_rule, bucketing_id, user_id)
-        return Decision.new(rollout_rule, variation, DECISION_SOURCES['ROLLOUT']) unless variation.nil?
+        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?
 
         break
       end
@@ -254,23 +270,26 @@ module Optimizely
       # get last rule which is the everyone else rule
       everyone_else_experiment = rollout_rules[number_of_rules]
       logging_key = 'Everyone Else'
+
+      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
-      unless Audience.user_meets_audience_conditions?(project_config, everyone_else_experiment, attributes, @logger, 'ROLLOUT_AUDIENCE_EVALUATION_LOGS', logging_key)
-        @logger.log(
-          Logger::DEBUG,
-          "User '#{user_id}' does not meet the audience conditions for targeting rule '#{logging_key}'."
-        )
-        return nil
+      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)
+        return nil, decide_reasons
       end
 
-      @logger.log(
-        Logger::DEBUG,
-        "User '#{user_id}' meets the audience conditions for targeting rule '#{logging_key}'."
-      )
-      variation = @bucketer.bucket(project_config, everyone_else_experiment, bucketing_id, user_id)
-      return Decision.new(everyone_else_experiment, variation, DECISION_SOURCES['ROLLOUT']) unless variation.nil?
+      message = "User '#{user_id}' meets the audience conditions for targeting rule '#{logging_key}'."
+      @logger.log(Logger::DEBUG, message)
+      decide_reasons.push(message)
 
-      nil
+      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?
+
+      [nil, decide_reasons]
     end
 
     def set_forced_variation(project_config, experiment_key, user_id, variation_key)
@@ -320,9 +339,11 @@ module Optimizely
       #
       # Returns Variation The variation which the given user and experiment should be forced into
 
+      decide_reasons = []
       unless @forced_variation_map.key? user_id
-        @logger.log(Logger::DEBUG, "User '#{user_id}' is not in the forced variation map.")
-        return nil
+        message = "User '#{user_id}' is not in the forced variation map."
+        @logger.log(Logger::DEBUG, message)
+        return nil, decide_reasons
       end
 
       experiment_to_variation_map = @forced_variation_map[user_id]
@@ -330,12 +351,13 @@ module Optimizely
       experiment_id = experiment['id'] if experiment
       # check for nil and empty string experiment ID
       # this case is logged in get_experiment_from_key
-      return nil if experiment_id.nil? || experiment_id.empty?
+      return nil, decide_reasons if experiment_id.nil? || experiment_id.empty?
 
       unless experiment_to_variation_map.key? experiment_id
-        @logger.log(Logger::DEBUG, "No experiment '#{experiment_key}' mapped to user '#{user_id}' "\
-                    'in the forced variation map.')
-        return nil
+        message = "No experiment '#{experiment_key}' mapped to user '#{user_id}' in the forced variation map."
+        @logger.log(Logger::DEBUG, message)
+        decide_reasons.push(message)
+        return nil, decide_reasons
       end
 
       variation_id = experiment_to_variation_map[experiment_id]
@@ -345,12 +367,13 @@ module Optimizely
 
       # check if the variation exists in the datafile
       # this case is logged in get_variation_from_id
-      return nil if variation_key.empty?
+      return nil, decide_reasons if variation_key.empty?
 
-      @logger.log(Logger::DEBUG, "Variation '#{variation_key}' is mapped to experiment '#{experiment_key}' "\
-                  "and user '#{user_id}' in the forced variation map")
+      message = "Variation '#{variation_key}' is mapped to experiment '#{experiment_key}' and user '#{user_id}' in the forced variation map"
+      @logger.log(Logger::DEBUG, message)
+      decide_reasons.push(message)
 
-      variation
+      [variation, decide_reasons]
     end
 
     private
@@ -366,27 +389,24 @@ module Optimizely
 
       whitelisted_variations = project_config.get_whitelisted_variations(experiment_key)
 
-      return nil unless whitelisted_variations
+      return nil, nil unless whitelisted_variations
 
       whitelisted_variation_key = whitelisted_variations[user_id]
 
-      return nil unless whitelisted_variation_key
+      return nil, nil unless whitelisted_variation_key
 
       whitelisted_variation_id = project_config.get_variation_id_from_key(experiment_key, whitelisted_variation_key)
 
       unless whitelisted_variation_id
-        @logger.log(
-          Logger::INFO,
-          "User '#{user_id}' is whitelisted into variation '#{whitelisted_variation_key}', which is not in the datafile."
-        )
-        return nil
+        message = "User '#{user_id}' is whitelisted into variation '#{whitelisted_variation_key}', which is not in the datafile."
+        @logger.log(Logger::INFO, message)
+        return nil, message
       end
 
-      @logger.log(
-        Logger::INFO,
-        "User '#{user_id}' is whitelisted into variation '#{whitelisted_variation_key}' of experiment '#{experiment_key}'."
-      )
-      whitelisted_variation_id
+      message = "User '#{user_id}' is whitelisted into variation '#{whitelisted_variation_key}' of experiment '#{experiment_key}'."
+      @logger.log(Logger::INFO, message)
+
+      [whitelisted_variation_id, message]
     end
 
     def get_saved_variation_id(project_config, experiment_id, user_profile)
@@ -397,19 +417,18 @@ module Optimizely
       # user_profile - Hash user profile
       #
       # Returns string variation ID (nil if no decision is found)
-      return nil unless user_profile[:experiment_bucket_map]
+      return nil, nil unless user_profile[:experiment_bucket_map]
 
       decision = user_profile[:experiment_bucket_map][experiment_id]
-      return nil unless decision
+      return nil, nil unless decision
 
       variation_id = decision[:variation_id]
-      return variation_id if project_config.variation_id_exists?(experiment_id, variation_id)
+      return variation_id, nil if project_config.variation_id_exists?(experiment_id, variation_id)
+
+      message = "User '#{user_profile[:user_id]}' was previously bucketed into variation ID '#{variation_id}' for experiment '#{experiment_id}', but no matching variation was found. Re-bucketing user."
+      @logger.log(Logger::INFO, message)
 
-      @logger.log(
-        Logger::INFO,
-        "User '#{user_profile['user_id']}' was previously bucketed into variation ID '#{variation_id}' for experiment '#{experiment_id}', but no matching variation was found. Re-bucketing user."
-      )
-      nil
+      [nil, message]
     end
 
     def get_user_profile(user_id)
@@ -424,15 +443,17 @@ module Optimizely
         experiment_bucket_map: {}
       }
 
-      return user_profile unless @user_profile_service
+      return user_profile, nil unless @user_profile_service
 
+      message = nil
       begin
         user_profile = @user_profile_service.lookup(user_id) || user_profile
       rescue => e
-        @logger.log(Logger::ERROR, "Error while looking up user profile for user ID '#{user_id}': #{e}.")
+        message = "Error while looking up user profile for user ID '#{user_id}': #{e}."
+        @logger.log(Logger::ERROR, message)
       end
 
-      user_profile
+      [user_profile, message]
     end
 
     def save_user_profile(user_profile, experiment_id, variation_id)
@@ -463,16 +484,17 @@ module Optimizely
       # attributes - Hash user attributes
       # Returns String representing bucketing ID if it is a String type in attributes else return user ID
 
-      return user_id unless attributes
+      return user_id, nil unless attributes
 
       bucketing_id = attributes[Optimizely::Helpers::Constants::CONTROL_ATTRIBUTES['BUCKETING_ID']]
 
       if bucketing_id
-        return bucketing_id if bucketing_id.is_a?(String)
+        return bucketing_id, nil if bucketing_id.is_a?(String)
 
-        @logger.log(Logger::WARN, 'Bucketing ID attribute is not a string. Defaulted to user ID.')
+        message = 'Bucketing ID attribute is not a string. Defaulted to user ID.'
+        @logger.log(Logger::WARN, message)
       end
-      user_id
+      [user_id, message]
     end
   end
 end

data/lib/optimizely/helpers/constants.rb

@@ -369,6 +369,7 @@ module Optimizely
         'FEATURE' => 'feature',
         'FEATURE_TEST' => 'feature-test',
         'FEATURE_VARIABLE' => 'feature-variable',
+        'FLAG' => 'flag',
         'ALL_FEATURE_VARIABLES' => 'all-feature-variables'
       }.freeze
 

data/lib/optimizely/optimizely_user_context.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+#
+#    Copyright 2020, 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'
+
+module Optimizely
+  class OptimizelyUserContext
+    # Representation of an Optimizely User Context using which APIs are to be called.
+
+    attr_reader :user_id
+
+    def initialize(optimizely_client, user_id, user_attributes)
+      @attr_mutex = Mutex.new
+      @optimizely_client = optimizely_client
+      @user_id = user_id
+      @user_attributes = user_attributes.nil? ? {} : user_attributes.clone
+    end
+
+    def clone
+      OptimizelyUserContext.new(@optimizely_client, @user_id, user_attributes)
+    end
+
+    def user_attributes
+      @attr_mutex.synchronize { @user_attributes.clone }
+    end
+
+    # Set an attribute for a given key
+    #
+    # @param key - An attribute key
+    # @param value - An attribute value
+
+    def set_attribute(attribute_key, attribute_value)
+      @attr_mutex.synchronize { @user_attributes[attribute_key] = attribute_value }
+    end
+
+    # Returns a decision result (OptimizelyDecision) for a given flag key and a user context, which contains all data required to deliver the flag.
+    #
+    # If the SDK finds an error, it'll return a `decision` with nil for `variation_key`. The decision will include an error message in `reasons`
+    #
+    # @param key -A flag key for which a decision will be made
+    # @param options - A list of options for decision making.
+    #
+    # @return [OptimizelyDecision] A decision result
+
+    def decide(key, options = nil)
+      @optimizely_client&.decide(clone, key, options)
+    end
+
+    # Returns a hash of decision results (OptimizelyDecision) for multiple flag keys and a user context.
+    #
+    # If the SDK finds an error for a key, the response will include a decision for the key showing `reasons` for the error.
+    # The SDK will always return hash of decisions. When it can not process requests, it'll return an empty hash after logging the errors.
+    #
+    # @param keys - A list of flag keys for which the decisions will be made.
+    # @param options - A list of options for decision making.
+    #
+    # @return - Hash of decisions containing flag keys as hash keys and corresponding decisions as their values.
+
+    def decide_for_keys(keys, options = nil)
+      @optimizely_client&.decide_for_keys(clone, keys, options)
+    end
+
+    # Returns a hash of decision results (OptimizelyDecision) for all active flag keys.
+    #
+    # @param options - A list of options for decision making.
+    #
+    # @return - Hash of decisions containing flag keys as hash keys and corresponding decisions as their values.
+
+    def decide_all(options = nil)
+      @optimizely_client&.decide_all(clone, options)
+    end
+
+    # Track an event
+    #
+    # @param event_key - Event key representing the event which needs to be recorded.
+
+    def track_event(event_key, event_tags = nil)
+      @optimizely_client&.track(event_key, @user_id, user_attributes, event_tags)
+    end
+
+    def as_json
+      {
+        user_id: @user_id,
+        attributes: @user_attributes
+      }
+    end
+
+    def to_json(*args)
+      as_json.to_json(*args)
+    end
+  end
+end

data/lib/optimizely/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: optimizely-sdk
 version: !ruby/object:Gem::Version
-  version: 3.7.0
+  version: 3.8.0
 platform: ruby
 authors:
 - Optimizely
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-11-20 00:00:00.000000000 Z
+date: 2021-02-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -141,6 +141,9 @@ files:
 - lib/optimizely/config_manager/project_config_manager.rb
 - lib/optimizely/config_manager/static_project_config_manager.rb
 - lib/optimizely/custom_attribute_condition_evaluator.rb
+- lib/optimizely/decide/optimizely_decide_option.rb
+- lib/optimizely/decide/optimizely_decision.rb
+- lib/optimizely/decide/optimizely_decision_message.rb
 - lib/optimizely/decision_service.rb
 - lib/optimizely/error_handler.rb
 - lib/optimizely/event/batch_event_processor.rb
@@ -172,6 +175,7 @@ files:
 - lib/optimizely/notification_center.rb
 - lib/optimizely/optimizely_config.rb
 - lib/optimizely/optimizely_factory.rb
+- lib/optimizely/optimizely_user_context.rb
 - lib/optimizely/params.rb
 - lib/optimizely/project_config.rb
 - lib/optimizely/semantic_version.rb