optimizely-sdk 5.0.1 → 5.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28a736eab23780d594a9fbe207de49b685681d1d1ff1e8aea5f79119d8688728
-  data.tar.gz: d2eea43d2d2b2bebc0ba80d62388434fc67c111531c26ad0aa63dd8ba350a798
+  metadata.gz: 79f6fce62ba26147eef50a92fefb2cb443df50b2b3a0f4c15f75352f4052aaa8
+  data.tar.gz: d09bfd23ad927fa5ae62c03467647c65bc21ac68d19d88dc81ef6dea441a25bf
 SHA512:
-  metadata.gz: f1afde6d790fa44cc8cc1aedf4000aee59fa1ad27152b692eacc127d0993ef9c596f3b607c1df4c430ab98f86e9409af99106c5d9292d8702c5258944dd7989d
-  data.tar.gz: edf53d55f80565197ba3a10a436b455701a38400f3f1e2d95e63418a7b777ff9059c39a479ffd23a09658661f74af9d6a36b0860da1be919d06781a106d218a1
+  metadata.gz: 74e1e587ffdcadfcbbea0677d0de60376e7f677a8254d1e121d37994301c5ebd1959e21ff7bfea1493a441835a20e135dc4d4a4f1577939772b6e167d35f2789
+  data.tar.gz: 57c17f7508daeaed88755b9dc4463f019fb5b5a523c32cf5639375c06a07dd563786001282e59496d5e8c149c5d884ea5c16522d52edef03c40a0b9ff1890879

data/lib/optimizely/decision_service.rb

@@ -52,17 +52,20 @@ module Optimizely
       @forced_variation_map = {}
     end
 
-    def get_variation(project_config, experiment_id, user_context, decide_options = [])
+    def get_variation(project_config, experiment_id, user_context, user_profile_tracker = nil, decide_options = [], reasons = [])
       # Determines variation into which user will be bucketed.
       #
       # project_config - project_config - Instance of ProjectConfig
       # experiment_id - Experiment for which visitor variation needs to be determined
       # user_context - Optimizely user context instance
+      # user_profile_tracker: Tracker for reading and updating user profile of the user.
+      # reasons: Decision reasons.
       #
       # Returns variation ID where visitor will be bucketed
       #   (nil if experiment is inactive or user does not meet audience conditions)
-
+      user_profile_tracker = UserProfileTracker.new(user_context.user_id, @user_profile_service, @logger) unless user_profile_tracker.is_a?(Optimizely::UserProfileTracker)
       decide_reasons = []
+      decide_reasons.push(*reasons)
       user_id = user_context.user_id
       attributes = user_context.user_attributes
       # By default, the bucketing ID should be the user ID
@@ -92,10 +95,8 @@ module Optimizely
 
       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)
+      unless should_ignore_user_profile_service && user_profile_tracker
+        saved_variation_id, reasons_received = get_saved_variation_id(project_config, experiment_id, user_profile_tracker.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."
@@ -131,7 +132,7 @@ module Optimizely
       decide_reasons.push(message)
 
       # Persist bucketing decision
-      save_user_profile(user_profile, experiment_id, variation_id) unless should_ignore_user_profile_service
+      user_profile_tracker.update_user_profile(experiment_id, variation_id) unless should_ignore_user_profile_service && user_profile_tracker
       [variation_id, decide_reasons]
     end
 
@@ -143,21 +144,46 @@ module Optimizely
       # user_context - Optimizely user context instance
       #
       # Returns Decision struct (nil if the user is not bucketed into any of the experiments on the feature)
+      get_variations_for_feature_list(project_config, [feature_flag], user_context, decide_options).first
+    end
 
-      decide_reasons = []
-
-      # check if the feature is being experiment on and whether the user is bucketed into the experiment
-      decision, reasons_received = get_variation_for_feature_experiment(project_config, feature_flag, user_context, decide_options)
-      decide_reasons.push(*reasons_received)
-      return decision, decide_reasons unless decision.nil?
-
-      decision, reasons_received = get_variation_for_feature_rollout(project_config, feature_flag, user_context)
-      decide_reasons.push(*reasons_received)
-
-      [decision, decide_reasons]
+    def get_variations_for_feature_list(project_config, feature_flags, user_context, decide_options = [])
+      # Returns the list of experiment/variation the user is bucketed in for the given list of features.
+      #
+      # Args:
+      #   project_config: Instance of ProjectConfig.
+      #   feature_flags: Array of features for which we are determining if it is enabled or not for the given user.
+      #   user_context: User context for user.
+      #   decide_options: Decide options.
+      #
+      # Returns:
+      #   Array of Decision struct.
+      ignore_ups = decide_options.include? Optimizely::Decide::OptimizelyDecideOption::IGNORE_USER_PROFILE_SERVICE
+      user_profile_tracker = nil
+      unless ignore_ups && @user_profile_service
+        user_profile_tracker = UserProfileTracker.new(user_context.user_id, @user_profile_service, @logger)
+        user_profile_tracker.load_user_profile
+      end
+      decisions = []
+      feature_flags.each do |feature_flag|
+        decide_reasons = []
+        # check if the feature is being experiment on and whether the user is bucketed into the experiment
+        decision, reasons_received = get_variation_for_feature_experiment(project_config, feature_flag, user_context, user_profile_tracker, decide_options)
+        decide_reasons.push(*reasons_received)
+        if decision
+          decisions << [decision, decide_reasons]
+        else
+          # Proceed to rollout if the decision is nil
+          rollout_decision, reasons_received = get_variation_for_feature_rollout(project_config, feature_flag, user_context)
+          decide_reasons.push(*reasons_received)
+          decisions << [rollout_decision, decide_reasons]
+        end
+      end
+      user_profile_tracker&.save_user_profile
+      decisions
     end
 
-    def get_variation_for_feature_experiment(project_config, feature_flag, user_context, decide_options = [])
+    def get_variation_for_feature_experiment(project_config, feature_flag, user_context, user_profile_tracker, decide_options = [])
       # Gets the variation the user is bucketed into for the feature flag's experiment.
       #
       # project_config - project_config - Instance of ProjectConfig
@@ -187,7 +213,7 @@ module Optimizely
         end
 
         experiment_id = experiment['id']
-        variation_id, reasons_received = get_variation_from_experiment_rule(project_config, feature_flag_key, experiment, user_context, decide_options)
+        variation_id, reasons_received = get_variation_from_experiment_rule(project_config, feature_flag_key, experiment, user_context, user_profile_tracker, decide_options)
         decide_reasons.push(*reasons_received)
 
         next unless variation_id
@@ -252,7 +278,7 @@ module Optimizely
       [nil, decide_reasons]
     end
 
-    def get_variation_from_experiment_rule(project_config, flag_key, rule, user, options = [])
+    def get_variation_from_experiment_rule(project_config, flag_key, rule, user, user_profile_tracker, options = [])
       # Determine which variation the user is in for a given rollout.
       # Returns the variation from experiment rules.
       #
@@ -270,7 +296,7 @@ module Optimizely
 
       return [variation['id'], reasons] if variation
 
-      variation_id, response_reasons = get_variation(project_config, rule['id'], user, options)
+      variation_id, response_reasons = get_variation(project_config, rule['id'], user, user_profile_tracker, options)
       reasons.push(*response_reasons)
 
       [variation_id, reasons]

data/lib/optimizely/helpers/validator.rb

@@ -122,11 +122,11 @@ module Optimizely
 
         return false unless variables.respond_to?(:each) && !variables.empty?
 
-        is_valid = true
+        is_valid = true # rubocop:disable Lint/UselessAssignment
         if variables.include? :user_id
           # Empty str is a valid user ID.
           unless variables[:user_id].is_a?(String)
-            is_valid = false
+            is_valid = false # rubocop:disable Lint/UselessAssignment
             logger.log(level, "#{Constants::INPUT_VARIABLES['USER_ID']} is invalid")
           end
           variables.delete :user_id

data/lib/optimizely/optimizely_factory.rb

@@ -142,7 +142,6 @@ module Optimizely
       notification_center = nil,
       settings = nil
     )
-
       error_handler ||= NoOpErrorHandler.new
       logger ||= NoOpLogger.new
       notification_center = notification_center.is_a?(Optimizely::NotificationCenter) ? notification_center : NotificationCenter.new(logger, error_handler)

data/lib/optimizely/user_profile_tracker.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative 'logger'
+
+module Optimizely
+  class UserProfileTracker
+    attr_reader :user_profile
+
+    def initialize(user_id, user_profile_service = nil, logger = nil)
+      @user_id = user_id
+      @user_profile_service = user_profile_service
+      @logger = logger || NoOpLogger.new
+      @profile_updated = false
+      @user_profile = {
+        user_id: user_id,
+        experiment_bucket_map: {}
+      }
+    end
+
+    def load_user_profile(reasons = [], error_handler = nil)
+      return if reasons.nil?
+
+      begin
+        @user_profile = @user_profile_service.lookup(@user_id) if @user_profile_service
+        if @user_profile.nil?
+          @user_profile = {
+            user_id: @user_id,
+            experiment_bucket_map: {}
+          }
+        end
+      rescue => e
+        message = "Error while looking up user profile for user ID '#{@user_id}': #{e}."
+        reasons << message
+        @logger.log(Logger::ERROR, message)
+        error_handler&.handle_error(e)
+      end
+    end
+
+    def update_user_profile(experiment_id, variation_id)
+      user_id = @user_profile[:user_id]
+      begin
+        @user_profile[:experiment_bucket_map][experiment_id] = {
+          variation_id: variation_id
+        }
+        @profile_updated = true
+        @logger.log(Logger::INFO, "Updated variation ID #{variation_id} of experiment ID #{experiment_id} for user '#{user_id}'.")
+      rescue => e
+        @logger.log(Logger::ERROR, "Error while updating user profile for user ID '#{user_id}': #{e}.")
+      end
+    end
+
+    def save_user_profile(error_handler = nil)
+      return unless @profile_updated && @user_profile_service
+
+      begin
+        @user_profile_service.save(@user_profile)
+        @logger.log(Logger::INFO, "Saved user profile for user '#{@user_profile[:user_id]}'.")
+      rescue => e
+        @logger.log(Logger::ERROR, "Failed to save user profile for user '#{@user_profile[:user_id]}': #{e}.")
+        error_handler&.handle_error(e)
+      end
+    end
+  end
+end

data/lib/optimizely/version.rb

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

data/lib/optimizely.rb

@@ -42,6 +42,7 @@ require_relative 'optimizely/optimizely_user_context'
 require_relative 'optimizely/odp/lru_cache'
 require_relative 'optimizely/odp/odp_manager'
 require_relative 'optimizely/helpers/sdk_settings'
+require_relative 'optimizely/user_profile_tracker'
 
 module Optimizely
   class Project
@@ -172,65 +173,18 @@ module Optimizely
       OptimizelyUserContext.new(self, user_id, attributes)
     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
-
+    def create_optimizely_decision(user_context, flag_key, decision, reasons, decide_options, config)
       # 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
+      feature_flag = config.get_feature_flag_from_key(flag_key)
       experiment = nil
       decision_source = Optimizely::DecisionService::DECISION_SOURCES['ROLLOUT']
-      context = Optimizely::OptimizelyUserContext::OptimizelyDecisionContext.new(key, nil)
-      variation, reasons_received = @decision_service.validated_forced_decision(config, context, user_context)
-      reasons.push(*reasons_received)
-
-      if variation
-        decision = Optimizely::DecisionService::Decision.new(nil, variation, Optimizely::DecisionService::DECISION_SOURCES['FEATURE_TEST'])
-      else
-        decision, reasons_received = @decision_service.get_variation_for_feature(config, feature_flag, user_context, decide_options)
-        reasons.push(*reasons_received)
-      end
-
       # Send impression event if Decision came from a feature test and decide options doesn't include disableDecisionEvent
       if decision.is_a?(Optimizely::DecisionService::Decision)
         experiment = decision.experiment
@@ -249,7 +203,7 @@ module Optimizely
       # 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)
+          variable_value = get_feature_variable_for_variation(flag_key, feature_enabled, variation, variable, user_id)
           all_variables[variable['key']] = Helpers::VariableType.cast_value_to_type(variable_value, variable['type'], @logger)
         end
       end
@@ -281,6 +235,47 @@ module Optimizely
       )
     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
+
+      decide_options.delete(OptimizelyDecideOption::ENABLED_FLAGS_ONLY) if decide_options.include?(OptimizelyDecideOption::ENABLED_FLAGS_ONLY)
+      decide_for_keys(user_context, [key], decide_options, true)[key]
+    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
@@ -298,7 +293,7 @@ module Optimizely
       decide_for_keys(user_context, keys, decide_options)
     end
 
-    def decide_for_keys(user_context, keys, decide_options = [])
+    def decide_for_keys(user_context, keys, decide_options = [], ignore_default_options = false) # rubocop:disable Style/OptionalBooleanParameter
       # raising on user context as it is internal and not provided directly by the user.
       raise if user_context.class != OptimizelyUserContext
 
@@ -308,13 +303,79 @@ module Optimizely
         return {}
       end
 
-      enabled_flags_only = (!decide_options.nil? && (decide_options.include? OptimizelyDecideOption::ENABLED_FLAGS_ONLY)) || (@default_decide_options.include? OptimizelyDecideOption::ENABLED_FLAGS_ONLY)
+      # merge decide_options and default_decide_options
+      unless ignore_default_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
+      end
+
+      # enabled_flags_only = (!decide_options.nil? && (decide_options.include? OptimizelyDecideOption::ENABLED_FLAGS_ONLY)) || (@default_decide_options.include? OptimizelyDecideOption::ENABLED_FLAGS_ONLY)
 
       decisions = {}
+      valid_keys = []
+      decision_reasons_dict = {}
+      config = project_config
+      return decisions unless config
+
+      flags_without_forced_decision = []
+      flag_decisions = {}
+
       keys.each do |key|
-        decision = decide(user_context, key, decide_options)
-        decisions[key] = decision unless enabled_flags_only && !decision.enabled
+        # Retrieve the feature flag from the project's feature flag key map
+        feature_flag = config.feature_flag_key_map[key]
+
+        # If the feature flag is nil, create a default OptimizelyDecision and move to the next key
+        if feature_flag.nil?
+          decisions[key] = OptimizelyDecision.new(nil, false, nil, nil, key, user_context, [])
+          next
+        end
+        valid_keys.push(key)
+        decision_reasons = []
+        decision_reasons_dict[key] = decision_reasons
+
+        config = project_config
+        context = Optimizely::OptimizelyUserContext::OptimizelyDecisionContext.new(key, nil)
+        variation, reasons_received = @decision_service.validated_forced_decision(config, context, user_context)
+        decision_reasons_dict[key].push(*reasons_received)
+        if variation
+          decision = Optimizely::DecisionService::Decision.new(nil, variation, Optimizely::DecisionService::DECISION_SOURCES['FEATURE_TEST'])
+          flag_decisions[key] = decision
+        else
+          flags_without_forced_decision.push(feature_flag)
+        end
       end
+      decision_list = @decision_service.get_variations_for_feature_list(config, flags_without_forced_decision, user_context, decide_options)
+
+      flags_without_forced_decision.each_with_index do |flag, i|
+        decision = decision_list[i][0]
+        reasons = decision_list[i][1]
+        flag_key = flag['key']
+        flag_decisions[flag_key] = decision
+        decision_reasons_dict[flag_key] ||= []
+        decision_reasons_dict[flag_key].push(*reasons)
+      end
+      valid_keys.each do |key|
+        flag_decision = flag_decisions[key]
+        decision_reasons = decision_reasons_dict[key]
+        optimizely_decision = create_optimizely_decision(
+          user_context,
+          key,
+          flag_decision,
+          decision_reasons,
+          decide_options,
+          config
+        )
+
+        enabled_flags_only_missing = !decide_options.include?(OptimizelyDecideOption::ENABLED_FLAGS_ONLY)
+        is_enabled = optimizely_decision.enabled
+
+        decisions[key] = optimizely_decision if enabled_flags_only_missing || is_enabled
+      end
+
       decisions
     end
 
@@ -959,7 +1020,10 @@ module Optimizely
       return nil unless user_inputs_valid?(attributes)
 
       user_context = OptimizelyUserContext.new(self, user_id, attributes, identify: false)
-      variation_id, = @decision_service.get_variation(config, experiment_id, user_context)
+      user_profile_tracker = UserProfileTracker.new(user_id, @user_profile_service, @logger)
+      user_profile_tracker.load_user_profile
+      variation_id, = @decision_service.get_variation(config, experiment_id, user_context, user_profile_tracker)
+      user_profile_tracker.save_user_profile
       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)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: optimizely-sdk
 version: !ruby/object:Gem::Version
-  version: 5.0.1
+  version: 5.1.0
 platform: ruby
 authors:
 - Optimizely
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-08 00:00:00.000000000 Z
+date: 2025-01-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -191,6 +191,7 @@ files:
 - lib/optimizely/semantic_version.rb
 - lib/optimizely/user_condition_evaluator.rb
 - lib/optimizely/user_profile_service.rb
+- lib/optimizely/user_profile_tracker.rb
 - lib/optimizely/version.rb
 homepage: https://github.com/optimizely/ruby-sdk
 licenses:
@@ -213,7 +214,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.4.19
 signing_key:
 specification_version: 4
 summary: Ruby SDK for Optimizely's testing framework