[FSSDK-11577] Ruby: Add holdout support and refactor decision logic in DefaultDecisionService

Author: esrakartalOpt

lib/optimizely/config/datafile_project_config.rb

@@ -194,6 +194,43 @@ def initialize(datafile, logger, error_handler)
         feature_flag['experimentIds'].each do |experiment_id|
           @experiment_feature_map[experiment_id] = [feature_flag['id']]
         end
+
+        flag_id = feature_flag['id']
+        applicable_holdouts = []
+
+        if @included_holdouts[flag_id]
+          applicable_holdouts.concat(@included_holdouts[flag_id])
+        end
+
+        @global_holdouts.each_value do |holdout|
+          excluded_flag_ids = holdout['excludedFlags'] || []
+          applicable_holdouts << holdout unless excluded_flag_ids.include?(flag_id)
+        end
+
+        @flag_holdouts_map[key] = applicable_holdouts unless applicable_holdouts.empty?
+      end
+
+      # Adding Holdout variations in variation id and key maps
+      if @holdouts && !@holdouts.empty?
+        @holdouts.each do |holdout|
+          holdout_key = holdout['key']
+          holdout_id = holdout['id']
+          
+          @variation_key_map[holdout_key] = {}
+          @variation_id_map[holdout_key] = {}
+          @variation_id_map_by_experiment_id[holdout_id] = {}
+          @variation_key_map_by_experiment_id[holdout_id] = {}
+
+          variations = holdout['variations']
+          if variations && !variations.empty?
+            variations.each do |variation|
+              @variation_key_map[holdout_key][variation['key']] = variation
+              @variation_id_map[holdout_key][variation['id']] = variation
+              @variation_key_map_by_experiment_id[holdout_id][variation['key']] = variation
+              @variation_id_map_by_experiment_id[holdout_id][variation['id']] = variation
+            end
+          end
+        end
       end
     end
 
@@ -605,38 +642,9 @@ def get_holdouts_for_flag(flag_key)
       #
       # Returns the holdouts that apply for a specific flag
 
-      feature_flag = @feature_flag_key_map[flag_key]
-      return [] unless feature_flag
-
-      flag_id = feature_flag['id']
-
-      # Check catch first
-      return @flag_holdouts_map[flag_id] if @flag_holdouts_map.key?(flag_id)
-
-      holdouts = []
-
-      # Add global holdouts that don't exclude this flag
-      @global_holdouts.each_value do |holdout|
-        is_excluded = false
-        excluded_flags = holdout['excludedFlags']
-        if excluded_flags && !excluded_flags.empty?
-          excluded_flags.each do |excluded_flag_id|
-            if excluded_flag_id == flag_id
-              is_excluded = true
-              break
-            end
-          end
-        end
-        holdouts << holdout unless is_excluded
-      end
-
-      # Add holdouts that specifically include this flag
-      holdouts.concat(@included_holdouts[flag_id]) if @included_holdouts.key?(flag_id)
-
-      # Cache the result
-      @flag_holdouts_map[flag_id] = holdouts
+      return [] if @holdouts.nil? || @holdouts.empty?
 
-      holdouts
+      @flag_holdouts_map[flag_key] || []
     end
 
     def get_holdout(holdout_id)

lib/optimizely/decision_service.rb

@@ -46,7 +46,8 @@ class DecisionService
     DECISION_SOURCES = {
       'EXPERIMENT' => 'experiment',
       'FEATURE_TEST' => 'feature-test',
-      'ROLLOUT' => 'rollout'
+      'ROLLOUT' => 'rollout',
+      'HOLDOUT' => 'holdout'
     }.freeze
 
     def initialize(logger, cmab_service, user_profile_service = nil)
@@ -169,6 +170,107 @@ def get_variation_for_feature(project_config, feature_flag, user_context, decide
       get_variations_for_feature_list(project_config, [feature_flag], user_context, decide_options).first
     end
 
+    def get_decision_for_flag(feature_flag, user_context, project_config, decide_options = [], user_profile_tracker = nil, decide_reasons = nil)
+      # Get the decision for a single feature flag.
+      # Processes holdouts, experiments, and rollouts in that order.
+      #
+      # feature_flag - The feature flag to get a decision for
+      # user_context - The user context
+      # project_config - The project config
+      # decide_options - Array of decide options
+      # user_profile_tracker - The user profile tracker
+      # decide_reasons - Array of decision reasons to merge
+      #
+      # Returns a DecisionResult for the feature flag
+
+      reasons = decide_reasons ? decide_reasons.dup : []
+      user_id = user_context.user_id
+
+      # Check holdouts
+      holdouts = project_config.get_holdouts_for_flag(feature_flag['key'])
+      holdouts.each do |holdout|
+        holdout_decision = get_variation_for_holdout(holdout, user_context, project_config)
+        reasons.push(*holdout_decision.reasons)
+
+        if holdout_decision.decision
+          message = "The user '#{user_id}' is bucketed into holdout '#{holdout['key']}' for feature flag '#{feature_flag['key']}'."
+          @logger.log(Logger::INFO, message)
+          reasons.push(message)
+          return DecisionResult.new(holdout_decision.decision, false, reasons)
+        end
+      end
+
+      # Check if the feature flag has an experiment and the user is bucketed into that experiment
+      experiment_decision = get_variation_for_feature_experiment(project_config, feature_flag, user_context, user_profile_tracker, decide_options)
+      reasons.push(*experiment_decision.reasons)
+
+      if experiment_decision.decision
+        return DecisionResult.new(experiment_decision.decision, experiment_decision.error, reasons)
+      end
+
+      # Check if the feature flag has a rollout and the user is bucketed into that rollout
+      rollout_decision = get_variation_for_feature_rollout(project_config, feature_flag, user_context)
+      reasons.push(*rollout_decision.reasons)
+
+      if rollout_decision.decision
+        message = "The user '#{user_id}' is bucketed into a rollout for feature flag '#{feature_flag['key']}'."
+        @logger.log(Logger::INFO, message)
+        reasons.push(message)
+        return DecisionResult.new(rollout_decision.decision, rollout_decision.error, reasons)
+      else
+        message = "The user '#{user_id}' is not bucketed into a rollout for feature flag '#{feature_flag['key']}'."
+        @logger.log(Logger::INFO, message)
+        reasons.push(message)
+        default_decision = Decision.new(nil, nil, DECISION_SOURCES['ROLLOUT'], nil)
+        return DecisionResult.new(nil, false, reasons)
+      end
+    end
+
+    def get_variation_for_holdout(holdout, user_context, project_config)
+      # Get the variation for holdout
+      #
+      # holdout - The holdout configuration
+      # user_context - The user context
+      # project_config - The project config
+      #
+      # Returns a DecisionResult for the holdout
+
+      decide_reasons = []
+      user_id = user_context.user_id
+      attributes = user_context.user_attributes
+      bucketing_id, bucketing_id_reasons = get_bucketing_id(user_id, attributes)
+      decide_reasons.push(*bucketing_id_reasons)
+
+      # Check audience conditions
+      user_meets_audience_conditions, reasons_received = Audience.user_meets_audience_conditions?(project_config, holdout, user_context, @logger)
+      decide_reasons.push(*reasons_received)
+
+      unless user_meets_audience_conditions
+        message = "User '#{user_id}' does not meet the conditions for holdout '#{holdout['key']}'."
+        @logger.log(Logger::DEBUG, message)
+        decide_reasons.push(message)
+        return DecisionResult.new(nil, false, decide_reasons)
+      end
+
+      # Bucket user into holdout variation
+      variation, bucket_reasons = @bucketer.bucket(project_config, holdout, bucketing_id, user_id)
+      decide_reasons.push(*bucket_reasons)
+
+      if variation
+        message = "The user '#{user_id}' is bucketed into variation '#{variation['key']}' of holdout '#{holdout['key']}'."
+        @logger.log(Logger::INFO, message)
+        decide_reasons.push(message)
+
+        holdout_decision = Decision.new(holdout, variation, DECISION_SOURCES['HOLDOUT'], nil)
+        return DecisionResult.new(holdout_decision, false, decide_reasons)
+      else
+        message = "The user '#{user_id}' is not bucketed into holdout '#{holdout['key']}'."
+        @logger.log(Logger::DEBUG, message)
+        decide_reasons.push(message)
+        return DecisionResult.new(nil, false, decide_reasons)
+      end
+    end
+
     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.
       #