feat(Decide): Add Decide API

lib/optimizely.rb

@@ -156,7 +156,7 @@ def decide(user_context, key, decide_options = [])
       # validate that key is a string
       unless key.is_a?(String)
         @logger.log(Logger::ERROR, 'Provided key is invalid')
-        reasons.push(OptimizelyDecisionMessage::VARIABLE_VALUE_INVALID)
+        reasons.push(format(OptimizelyDecisionMessage::FLAG_KEY_INVALID, key))
         return OptimizelyDecision.new(flag_key: key, user_context: user_context, reasons: reasons)
       end
 
@@ -187,7 +187,7 @@ def decide(user_context, key, decide_options = [])
       all_variables = {}
       decision_event_dispatched = false
 
-      decision = @decision_service.get_variation_for_feature(config, feature_flag, user_id, attributes, decide_options)
+      decision = @decision_service.get_variation_for_feature(config, feature_flag, user_id, attributes, decide_options, reasons)
 
       # Send impression event if Decision came from a feature test and decide options doesn't include disableDecisionEvent
       if decision.is_a?(Optimizely::DecisionService::Decision)
@@ -197,19 +197,22 @@ def decide(user_context, key, decide_options = [])
         flag_key = key
         rule_key = decision.experiment['key']
 
-        if decision.source == Optimizely::DecisionService::DECISION_SOURCES['FEATURE_TEST']
-          unless decide_options.include? Optimizely::Decide::OptimizelyDecideOption::DISABLE_DECISION_EVENT
-            source_string = Optimizely::DecisionService::DECISION_SOURCES['FEATURE_TEST']
-            send_impression(
-              config, decision.experiment, variation_key, flag_key, rule_key, source_string, user_id, attributes
-            )
+        unless decide_options.include? OptimizelyDecideOption::DISABLE_DECISION_EVENT
+          if decision.source == Optimizely::DecisionService::DECISION_SOURCES['FEATURE_TEST'] ||
+             (decision.source == Optimizely::DecisionService::DECISION_SOURCES['ROLLOUT'] && config.send_flag_decisions)
+            send_impression(config, decision.experiment, variation_key, flag_key, rule_key, decision.source, user_id, attributes)
             decision_event_dispatched = true
           end
         end
       end
 
+      if decision.nil? && config.send_flag_decisions
+        send_impression(config, nil, '', flag_key, '', Optimizely::DecisionService::DECISION_SOURCES['ROLLOUT'], user_id, attributes)
+        decision_event_dispatched = true
+      end
+
       # Generate all variables map if decide options doesn't include excludeVariables
-      unless decide_options.include? Optimizely::Decide::OptimizelyDecideOption::EXCLUDE_VARIABLES
+      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)
@@ -230,24 +233,50 @@ def decide(user_context, key, decide_options = [])
         decision_event_dispatched: decision_event_dispatched
       )
 
+      should_include_reasons = decide_options.include? OptimizelyDecideOption::INCLUDE_REASONS
       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: reasons
+        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
 
-      decisions = {}
+      # 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|
-        decisions[feature_flag['key']] = decide(user_context, feature_flag['key'], decide_options)
+        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)
+      decisions = {}
+      keys.each do |key|
+        decision = decide(user_context, key, decide_options)
+        decisions[key] = decision unless enabled_flags_only && !decision.enabled
       end
       decisions
     end

lib/optimizely/bucketer.rb

@@ -35,7 +35,7 @@ def initialize(logger)
       @bucket_seed = HASH_SEED
     end
 
-    def bucket(project_config, experiment, bucketing_id, user_id)
+    def bucket(project_config, experiment, bucketing_id, user_id, decide_reasons = nil)
       # Determines ID of variation to be shown for a given experiment key and user ID.
       #
       # project_config - Instance of ProjectConfig
@@ -58,46 +58,45 @@ def bucket(project_config, experiment, bucketing_id, user_id)
           bucketed_experiment_id = find_bucket(bucketing_id, user_id, group_id, traffic_allocations)
           # return if the user is not bucketed into any experiment
           unless bucketed_experiment_id
-            @logger.log(Logger::INFO, "User '#{user_id}' is in no experiment.")
+            message = "User '#{user_id}' is in no experiment."
+            @logger.log(Logger::INFO, message)
+            decide_reasons&.push(message)
             return nil
           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}."
-            )
+            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
           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(bucketing_id, user_id, experiment_id, traffic_allocations, decide_reasons)
       if variation_id && variation_id != ''
         variation = project_config.get_variation_from_id(experiment_key, variation_id)
         return variation
       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
     end
 
-    def find_bucket(bucketing_id, user_id, parent_id, traffic_allocations)
+    def find_bucket(bucketing_id, user_id, parent_id, traffic_allocations, decide_reasons = nil)
       # Helper function to find the matching entity ID for a given bucketing value in a list of traffic allocations.
       #
       # bucketing_id - String A customer-assigned value user to generate bucketing key
@@ -108,8 +107,10 @@ def find_bucket(bucketing_id, user_id, parent_id, traffic_allocations)
       # Returns entity ID corresponding to the provided bucket value or nil if no match is found.
       bucketing_key = format(BUCKETING_ID_TEMPLATE, bucketing_id: bucketing_id, entity_id: parent_id)
       bucket_value = generate_bucket_value(bucketing_key)
-      @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)
+      decide_reasons&.push(message)
 
       traffic_allocations.each do |traffic_allocation|
         current_end_of_range = traffic_allocation['endOfRange']

lib/optimizely/decide/optimizely_decision.rb

@@ -20,6 +20,8 @@
 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,