feat(Decide): Add Decide API

lib/optimizely.rb

@@ -19,6 +19,9 @@
 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/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 @@ def initialize(
       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,136 @@ def initialize(
                          end
     end
 
+    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(OptimizelyDecisionMessage::VARIABLE_VALUE_INVALID)
+        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
+
+      decision = @decision_service.get_variation_for_feature(config, feature_flag, user_id, attributes, decide_options)
+
+      # Send impression event if Decision came from a feature test and decide options doesn't include disableDecisionEvent
+      if decision.is_a?(Optimizely::DecisionService::Decision)
+        variation = decision['variation']
+        variation_key = variation['key']
+        feature_enabled = variation['featureEnabled']
+        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
+            )
+            decision_event_dispatched = true
+          end
+        end
+      end
+
+      # Generate all variables map if decide options doesn't include excludeVariables
+      unless decide_options.include? Optimizely::Decide::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
+
+      # 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: 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: 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 = {}
+      project_config.feature_flags.each do |feature_flag|
+        decisions[feature_flag['key']] = decide(user_context, feature_flag['key'], decide_options)
+      end
+      decisions
+    end
+
     # Buckets visitor and sends impression event to Optimizely.
     #
     # @param experiment_key - Experiment which needs to be activated.

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

lib/optimizely/decide/optimizely_decision.rb

@@ -0,0 +1,58 @@
+# 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
+      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

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

lib/optimizely/decision_service.rb

@@ -52,7 +52,7 @@ def initialize(logger, user_profile_service = nil)
       @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
@@ -83,15 +83,18 @@ def get_variation(project_config, experiment_key, user_id, attributes = nil)
       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
+      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 = 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
+        end
       end
 
       # Check audience conditions
@@ -118,11 +121,11 @@ def get_variation(project_config, experiment_key, user_id, attributes = nil)
       end
 
       # Persist bucketing decision
-      save_user_profile(user_profile, experiment_id, variation_id)
+      save_user_profile(user_profile, experiment_id, variation_id) unless should_ignore_user_profile_service
       variation_id
     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
@@ -133,15 +136,15 @@ def get_variation_for_feature(project_config, feature_flag, user_id, attributes
       # Returns Decision struct (nil if the user is not bucketed into any of the experiments on the feature)
 
       # 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)
+      decision = get_variation_for_feature_experiment(project_config, feature_flag, user_id, attributes, decide_options)
       return decision unless decision.nil?
 
       decision = get_variation_for_feature_rollout(project_config, feature_flag, user_id, attributes)
 
       decision
     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
@@ -172,7 +175,7 @@ def get_variation_for_feature_experiment(project_config, feature_flag, user_id,
         end
 
         experiment_key = experiment['key']
-        variation_id = get_variation(project_config, experiment_key, user_id, attributes)
+        variation_id = get_variation(project_config, experiment_key, user_id, attributes, decide_options)
 
         next unless variation_id
 

lib/optimizely/helpers/constants.rb

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