optimizely-sdk 5.0.1 → 5.2.0

data/lib/optimizely.rb

@@ -42,6 +42,9 @@ 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'
+require_relative 'optimizely/cmab/cmab_client'
+require_relative 'optimizely/cmab/cmab_service'
 
 module Optimizely
   class Project
@@ -83,7 +86,8 @@ module Optimizely
       event_processor: nil,
       default_decide_options: [],
       event_processor_options: {},
-      settings: nil
+      settings: nil,
+      cmab_service: nil
     )
       @logger = logger || NoOpLogger.new
       @error_handler = error_handler || NoOpErrorHandler.new
@@ -130,7 +134,24 @@ module Optimizely
 
       setup_odp!(@config_manager.sdk_key)
 
-      @decision_service = DecisionService.new(@logger, @user_profile_service)
+      # Initialize CMAB components if cmab service is nil
+      if cmab_service.nil?
+        @cmab_client = DefaultCmabClient.new(
+          http_client: nil,
+          retry_config: CmabRetryConfig.new,
+          logger: @logger
+        )
+        @cmab_cache = LRUCache.new(Optimizely::DefaultCmabCacheOptions::DEFAULT_CMAB_CACHE_SIZE, Optimizely::DefaultCmabCacheOptions::DEFAULT_CMAB_CACHE_TIMEOUT)
+        @cmab_service = DefaultCmabService.new(
+          @cmab_cache,
+          @cmab_client,
+          @logger
+        )
+      else
+        @cmab_service = cmab_service
+      end
+
+      @decision_service = DecisionService.new(@logger, @cmab_service, @user_profile_service)
 
       @event_processor = if event_processor.respond_to?(:process)
                            event_processor
@@ -172,84 +193,42 @@ 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
+      experiment_id = nil
+      variation_id = nil
 
       # 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 ? experiment['key'] : nil
-        variation = decision['variation']
+        experiment_id = experiment ? experiment['id'] : nil
+        variation = decision.variation
         variation_key = variation ? variation['key'] : nil
+        variation_id = variation ? variation['id'] : nil
         feature_enabled = variation ? variation['featureEnabled'] : false
         decision_source = decision.source
       end
 
       if !decide_options.include?(OptimizelyDecideOption::DISABLE_DECISION_EVENT) && (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)
+        send_impression(config, experiment, variation_key || '', flag_key, rule_key || '', feature_enabled, decision_source, user_id, attributes, decision&.cmab_uuid)
         decision_event_dispatched = true
       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)
+          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
@@ -260,14 +239,16 @@ module Optimizely
       @notification_center.send_notifications(
         NotificationCenter::NOTIFICATION_TYPES[:DECISION],
         Helpers::Constants::DECISION_NOTIFICATION_TYPES['FLAG'],
-        user_id, (attributes || {}),
+        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
+        decision_event_dispatched: decision_event_dispatched,
+        experiment_id: experiment_id,
+        variation_id: variation_id
       )
 
       OptimizelyDecision.new(
@@ -281,6 +262,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 +320,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 +330,87 @@ 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(variation_key: nil, enabled: false, variables: nil, rule_key: nil, flag_key: key, user_context: user_context, reasons: [])
+          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].decision
+        reasons = decision_list[i].reasons
+        error = decision_list[i].error
+        flag_key = flag['key']
+        # store error decision against key and remove key from valid keys
+        if error
+          optimizely_decision = OptimizelyDecision.new_error_decision(flag_key, user_context, reasons)
+          decisions[flag_key] = optimizely_decision
+          valid_keys.delete(flag_key) if valid_keys.include?(flag_key)
+          next
+        end
+        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
 
@@ -531,14 +627,14 @@ module Optimizely
       end
 
       user_context = OptimizelyUserContext.new(self, user_id, attributes, identify: false)
-      decision, = @decision_service.get_variation_for_feature(config, feature_flag, user_context)
-
+      decision_result = @decision_service.get_variation_for_feature(config, feature_flag, user_context)
+      decision = decision_result.decision
       feature_enabled = false
       source_string = Optimizely::DecisionService::DECISION_SOURCES['ROLLOUT']
       if decision.is_a?(Optimizely::DecisionService::Decision)
         variation = decision['variation']
         feature_enabled = variation['featureEnabled']
-        if decision.source == Optimizely::DecisionService::DECISION_SOURCES['FEATURE_TEST']
+        if decision.source == Optimizely::DecisionService::DECISION_SOURCES['FEATURE_TEST'] || decision.source == Optimizely::DecisionService::DECISION_SOURCES['HOLDOUT']
           source_string = Optimizely::DecisionService::DECISION_SOURCES['FEATURE_TEST']
           source_info = {
             experiment_key: decision.experiment['key'],
@@ -564,7 +660,7 @@ module Optimizely
       @notification_center.send_notifications(
         NotificationCenter::NOTIFICATION_TYPES[:DECISION],
         Helpers::Constants::DECISION_NOTIFICATION_TYPES['FEATURE'],
-        user_id, (attributes || {}),
+        user_id, attributes || {},
         feature_key: feature_flag_key,
         feature_enabled: feature_enabled,
         source: source_string,
@@ -771,7 +867,8 @@ module Optimizely
       end
 
       user_context = OptimizelyUserContext.new(self, user_id, attributes, identify: false)
-      decision, = @decision_service.get_variation_for_feature(config, feature_flag, user_context)
+      decision_result = @decision_service.get_variation_for_feature(config, feature_flag, user_context)
+      decision = decision_result.decision
       variation = decision ? decision['variation'] : nil
       feature_enabled = variation ? variation['featureEnabled'] : false
       all_variables = {}
@@ -792,7 +889,7 @@ module Optimizely
 
       @notification_center.send_notifications(
         NotificationCenter::NOTIFICATION_TYPES[:DECISION],
-        Helpers::Constants::DECISION_NOTIFICATION_TYPES['ALL_FEATURE_VARIABLES'], user_id, (attributes || {}),
+        Helpers::Constants::DECISION_NOTIFICATION_TYPES['ALL_FEATURE_VARIABLES'], user_id, attributes || {},
         feature_key: feature_flag_key,
         feature_enabled: feature_enabled,
         source: source_string,
@@ -959,7 +1056,11 @@ 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_result = @decision_service.get_variation(config, experiment_id, user_context, user_profile_tracker)
+      variation_id = variation_result.variation_id
+      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)
@@ -969,7 +1070,7 @@ module Optimizely
                                    end
       @notification_center.send_notifications(
         NotificationCenter::NOTIFICATION_TYPES[:DECISION],
-        decision_notification_type, user_id, (attributes || {}),
+        decision_notification_type, user_id, attributes || {},
         experiment_key: experiment_key,
         variation_key: variation_key
       )
@@ -1026,7 +1127,8 @@ module Optimizely
       end
 
       user_context = OptimizelyUserContext.new(self, user_id, attributes, identify: false)
-      decision, = @decision_service.get_variation_for_feature(config, feature_flag, user_context)
+      decision_result = @decision_service.get_variation_for_feature(config, feature_flag, user_context)
+      decision = decision_result.decision
       variation = decision ? decision['variation'] : nil
       feature_enabled = variation ? variation['featureEnabled'] : false
 
@@ -1044,7 +1146,7 @@ module Optimizely
 
       @notification_center.send_notifications(
         NotificationCenter::NOTIFICATION_TYPES[:DECISION],
-        Helpers::Constants::DECISION_NOTIFICATION_TYPES['FEATURE_VARIABLE'], user_id, (attributes || {}),
+        Helpers::Constants::DECISION_NOTIFICATION_TYPES['FEATURE_VARIABLE'], user_id, attributes || {},
         feature_key: feature_flag_key,
         feature_enabled: feature_enabled,
         source: source_string,
@@ -1144,7 +1246,7 @@ module Optimizely
       raise InvalidInputError, 'event_dispatcher'
     end
 
-    def send_impression(config, experiment, variation_key, flag_key, rule_key, enabled, rule_type, user_id, attributes = nil)
+    def send_impression(config, experiment, variation_key, flag_key, rule_key, enabled, rule_type, user_id, attributes = nil, cmab_uuid = nil)
       if experiment.nil?
         experiment = {
           'id' => '',
@@ -1176,6 +1278,7 @@ module Optimizely
         variation_key: variation_key,
         enabled: enabled
       }
+      metadata[:cmab_uuid] = cmab_uuid unless cmab_uuid.nil?
 
       user_event = UserEventFactory.create_impression_event(config, experiment, variation_id, metadata, user_id, attributes)
       @event_processor.process(user_event)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: optimizely-sdk
 version: !ruby/object:Gem::Version
-  version: 5.0.1
+  version: 5.2.0
 platform: ruby
 authors:
 - Optimizely
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-08 00:00:00.000000000 Z
+date: 2025-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -134,6 +134,8 @@ files:
 - lib/optimizely.rb
 - lib/optimizely/audience.rb
 - lib/optimizely/bucketer.rb
+- lib/optimizely/cmab/cmab_client.rb
+- lib/optimizely/cmab/cmab_service.rb
 - lib/optimizely/condition_tree_evaluator.rb
 - lib/optimizely/config/datafile_project_config.rb
 - lib/optimizely/config/proxy_config.rb
@@ -191,6 +193,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 +216,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