[FSSDK-11176] Update: Implement Decision Service methods to handle CMAB (#369)

* update: Extend LRUCache with remove method and corresponding tests

* update: Clean up whitespace in LRUCache implementation and tests

* update: Extend copyright notice to include 2025

* update: Implement Default CMAB Service

* update: Enable keyword initialization for CmabDecision and CmabCacheValue structs (otherwise breaks in ruby version change)

* update: Refactor bucketing logic to handle empty traffic ranges and improve logging

* update: Add support for CMAB traffic allocation in bucketing logic

* update: Enhance DecisionService to support CMAB traffic allocation and decision retrieval

* update: Integrate CMAB decision logic into DecisionService and update related tests

* update: Refactor DecisionService to return DecisionResult struct instead of Decision struct

* update: Integrate CMAB components into Project class and enhance decision handling

* update: Refactor CMAB traffic allocation handling and enhance decision service error logging

* update: Refactor OptimizelyDecision instantiation to use keyword arguments for clarity

* update: Remove commented debug output from Optimizely user context spec

* Trigger CI build

---------

Co-authored-by: Matjaz Pirnovar <Mat001@users.noreply.github.com>

Author: FarhanAnjum-opti

lib/optimizely.rb

@@ -43,11 +43,17 @@
 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
     include Optimizely::Decide
 
+    # CMAB Constants
+    DEFAULT_CMAB_CACHE_TIMEOUT = (30 * 60 * 1000)
+    DEFAULT_CMAB_CACHE_SIZE = 1000
+
     attr_reader :notification_center
     # @api no-doc
     attr_reader :config_manager, :decision_service, :error_handler, :event_dispatcher,
@@ -131,7 +137,19 @@ def initialize(
 
       setup_odp!(@config_manager.sdk_key)
 
-      @decision_service = DecisionService.new(@logger, @user_profile_service)
+      # Initialize CMAB components
+      @cmab_client = DefaultCmabClient.new(
+        retry_config: CmabRetryConfig.new,
+        logger: @logger
+      )
+      @cmab_cache = LRUCache.new(DEFAULT_CMAB_CACHE_SIZE, DEFAULT_CMAB_CACHE_TIMEOUT)
+      @cmab_service = DefaultCmabService.new(
+        @cmab_cache,
+        @cmab_client,
+        @logger
+      )
+
+      @decision_service = DecisionService.new(@logger, @cmab_service, @user_profile_service)
 
       @event_processor = if event_processor.respond_to?(:process)
                            event_processor
@@ -337,7 +355,7 @@ def decide_for_keys(user_context, keys, decide_options = [], ignore_default_opti
 
         # 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, [])
+          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)
@@ -358,9 +376,17 @@ def decide_for_keys(user_context, keys, decide_options = [], ignore_default_opti
       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]
+        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)
@@ -599,8 +625,8 @@ def is_feature_enabled(feature_flag_key, user_id, attributes = nil)
       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)
@@ -839,7 +865,8 @@ def get_all_feature_variables(feature_flag_key, user_id, attributes = nil)
       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 = {}
@@ -1029,7 +1056,8 @@ def get_variation_with_config(experiment_key, user_id, attributes, config)
       user_context = OptimizelyUserContext.new(self, user_id, attributes, identify: false)
       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)
+      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
@@ -1097,7 +1125,8 @@ def get_feature_variable_for_type(feature_flag_key, variable_key, variable_type,
       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
 

lib/optimizely/bucketer.rb

@@ -44,6 +44,25 @@ def bucket(project_config, experiment, bucketing_id, user_id)
       # user_id - String ID for user.
       #
       # Returns variation in which visitor with ID user_id has been placed. Nil if no variation.
+
+      variation_id, decide_reasons = bucket_to_entity_id(project_config, experiment, bucketing_id, user_id)
+      if variation_id && variation_id != ''
+        experiment_id = experiment['id']
+        variation = project_config.get_variation_from_id_by_experiment_id(experiment_id, variation_id)
+        return variation, decide_reasons
+      end
+
+      # Handle the case when the traffic range is empty due to sticky bucketing
+      if variation_id == ''
+        message = 'Bucketed into an empty traffic range. Returning nil.'
+        @logger.log(Logger::DEBUG, message)
+        decide_reasons.push(message)
+      end
+
+      [nil, decide_reasons]
+    end
+
+    def bucket_to_entity_id(project_config, experiment, bucketing_id, user_id)
       return nil, [] if experiment.nil?
 
       decide_reasons = []
@@ -84,22 +103,18 @@ def bucket(project_config, experiment, bucketing_id, user_id)
       end
 
       traffic_allocations = experiment['trafficAllocation']
+      if experiment['cmab']
+        traffic_allocations = [
+          {
+            'entityId' => '$',
+            'endOfRange' => experiment['cmab']['trafficAllocation']
+          }
+        ]
+      end
       variation_id, find_bucket_reasons = find_bucket(bucketing_id, user_id, experiment_id, traffic_allocations)
       decide_reasons.push(*find_bucket_reasons)
 
-      if variation_id && variation_id != ''
-        variation = project_config.get_variation_from_id_by_experiment_id(experiment_id, variation_id)
-        return variation, decide_reasons
-      end
-
-      # Handle the case when the traffic range is empty due to sticky bucketing
-      if variation_id == ''
-        message = 'Bucketed into an empty traffic range. Returning nil.'
-        @logger.log(Logger::DEBUG, message)
-        decide_reasons.push(message)
-      end
-
-      [nil, decide_reasons]
+      [variation_id, decide_reasons]
     end
 
     def find_bucket(bucketing_id, user_id, parent_id, traffic_allocations)

lib/optimizely/decide/optimizely_decision.rb

@@ -55,6 +55,25 @@ def as_json
       def to_json(*args)
         as_json.to_json(*args)
       end
+
+      # Create a new OptimizelyDecision representing an error state.
+      #
+      # @param key [String] The flag key
+      # @param user [OptimizelyUserContext] The user context
+      # @param reasons [Array<String>] List of reasons explaining the error
+      #
+      # @return [OptimizelyDecision] OptimizelyDecision with error state values
+      def self.new_error_decision(key, user, reasons = [])
+        new(
+          variation_key: nil,
+          enabled: false,
+          variables: {},
+          rule_key: nil,
+          flag_key: key,
+          user_context: user,
+          reasons: reasons
+        )
+      end
     end
   end
 end