optimizely-sdk 3.6.0 → 3.9.0

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,12 +46,20 @@ module Optimizely
 
     def revision; end
 
+    def sdk_key; end
+
+    def environment_key; end
+
+    def send_flag_decisions; end
+
     def rollouts; end
 
     def experiment_running?(experiment); end
 
     def get_experiment_from_key(experiment_key); end
 
+    def get_experiment_from_id(experiment_id); end
+
     def get_experiment_key(experiment_id); end
 
     def get_event_from_key(event_key); end
@@ -60,9 +68,13 @@ module Optimizely
 
     def get_variation_from_id(experiment_key, variation_id); end
 
+    def get_variation_from_id_by_experiment_id(experiment_id, variation_id); end
+
+    def get_variation_id_from_key_by_experiment_id(experiment_id, variation_key); end
+
     def get_variation_id_from_key(experiment_key, variation_key); end
 
-    def get_whitelisted_variations(experiment_key); end
+    def get_whitelisted_variations(experiment_id); end
 
     def get_attribute_id(attribute_key); end
 

data/lib/optimizely/version.rb

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

data/lib/optimizely.rb

@@ -1,7 +1,7 @@
 # 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.
@@ -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.
@@ -140,7 +324,10 @@ module Optimizely
 
       # Create and dispatch impression event
       experiment = config.get_experiment_from_key(experiment_key)
-      send_impression(config, experiment, variation_key, user_id, attributes)
+      send_impression(
+        config, experiment, variation_key, '', experiment_key, true,
+        Optimizely::DecisionService::DECISION_SOURCES['EXPERIMENT'], user_id, attributes
+      )
 
       variation_key
     end
@@ -219,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
@@ -303,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']
@@ -316,14 +503,23 @@ module Optimizely
             experiment_key: decision.experiment['key'],
             variation_key: variation['key']
           }
-          # Send event if Decision came from an experiment.
-          send_impression(config, decision.experiment, variation['key'], user_id, attributes)
-        else
-          @logger.log(Logger::DEBUG,
-                      "The user '#{user_id}' is not being experimented on in feature '#{feature_flag_key}'.")
+          # Send event if Decision came from a feature test.
+          send_impression(
+            config, decision.experiment, variation['key'], feature_flag_key, decision.experiment['key'], feature_enabled, source_string, user_id, attributes
+          )
+        elsif decision.source == Optimizely::DecisionService::DECISION_SOURCES['ROLLOUT'] && config.send_flag_decisions
+          send_impression(
+            config, decision.experiment, variation['key'], feature_flag_key, decision.experiment['key'], feature_enabled, source_string, user_id, attributes
+          )
         end
       end
 
+      if decision.nil? && config.send_flag_decisions
+        send_impression(
+          config, nil, '', feature_flag_key, '', feature_enabled, source_string, user_id, attributes
+        )
+      end
+
       @notification_center.send_notifications(
         NotificationCenter::NOTIFICATION_TYPES[:DECISION],
         Helpers::Constants::DECISION_NOTIFICATION_TYPES['FEATURE'],
@@ -543,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 = {}
@@ -681,12 +877,14 @@ module Optimizely
       experiment = config.get_experiment_from_key(experiment_key)
       return nil if experiment.nil?
 
+      experiment_id = experiment['id']
+
       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_id, 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'])
+      decision_notification_type = if config.feature_experiment?(experiment_id)
                                      Helpers::Constants::DECISION_NOTIFICATION_TYPES['FEATURE_TEST']
                                    else
                                      Helpers::Constants::DECISION_NOTIFICATION_TYPES['AB_TEST']
@@ -749,7 +947,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
 
@@ -867,15 +1065,44 @@ module Optimizely
       raise InvalidInputError, 'event_dispatcher'
     end
 
-    def send_impression(config, experiment, variation_key, user_id, attributes = nil)
+    def send_impression(config, experiment, variation_key, flag_key, rule_key, enabled, rule_type, user_id, attributes = nil)
+      if experiment.nil?
+        experiment = {
+          'id' => '',
+          'key' => '',
+          'layerId' => '',
+          'status' => '',
+          'variations' => [],
+          'trafficAllocation' => [],
+          'audienceIds' => [],
+          'audienceConditions' => [],
+          'forcedVariations' => {}
+        }
+      end
+
+      experiment_id = experiment['id']
       experiment_key = experiment['key']
-      variation_id = config.get_variation_id_from_key(experiment_key, variation_key)
-      user_event = UserEventFactory.create_impression_event(config, experiment, variation_id, user_id, attributes)
+
+      variation_id = ''
+      variation_id = config.get_variation_id_from_key_by_experiment_id(experiment_id, variation_key) if experiment_id != ''
+
+      metadata = {
+        flag_key: flag_key,
+        rule_key: rule_key,
+        rule_type: rule_type,
+        variation_key: variation_key,
+        enabled: enabled
+      }
+
+      user_event = UserEventFactory.create_impression_event(config, experiment, variation_id, metadata, user_id, attributes)
       @event_processor.process(user_event)
       return unless @notification_center.notification_count(NotificationCenter::NOTIFICATION_TYPES[:ACTIVATE]).positive?
 
       @logger.log(Logger::INFO, "Activating user '#{user_id}' in experiment '#{experiment_key}'.")
-      variation = config.get_variation_from_id(experiment_key, variation_id)
+
+      experiment = nil if experiment_id == ''
+      variation = nil
+      variation = config.get_variation_from_id_by_experiment_id(experiment_id, variation_id) unless experiment.nil?
       log_event = EventFactory.create_log_event(user_event, @logger)
       @notification_center.send_notifications(
         NotificationCenter::NOTIFICATION_TYPES[:ACTIVATE],

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: optimizely-sdk
 version: !ruby/object:Gem::Version
-  version: 3.6.0
+  version: 3.9.0
 platform: ruby
 authors:
 - Optimizely
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-09-30 00:00:00.000000000 Z
+date: 2021-09-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
@@ -196,7 +200,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
 summary: Ruby SDK for Optimizely's testing framework