optimizely-sdk 5.1.0 → 5.2.1

data/lib/optimizely/config/datafile_project_config.rb

@@ -27,12 +27,14 @@ module Optimizely
     attr_reader :datafile, :account_id, :attributes, :audiences, :typed_audiences, :events,
                 :experiments, :feature_flags, :groups, :project_id, :bot_filtering, :revision,
                 :sdk_key, :environment_key, :rollouts, :version, :send_flag_decisions,
-                :attribute_key_map, :audience_id_map, :event_key_map, :experiment_feature_map,
+                :attribute_key_map, :attribute_id_to_key_map, :attribute_id_map,
+                :audience_id_map, :event_key_map, :experiment_feature_map,
                 :experiment_id_map, :experiment_key_map, :feature_flag_key_map, :feature_variable_key_map,
                 :group_id_map, :rollout_id_map, :rollout_experiment_id_map, :variation_id_map,
                 :variation_id_to_variable_usage_map, :variation_key_map, :variation_id_map_by_experiment_id,
                 :variation_key_map_by_experiment_id, :flag_variation_map, :integration_key_map, :integrations,
-                :public_key_for_odp, :host_for_odp, :all_segments
+                :public_key_for_odp, :host_for_odp, :all_segments, :region, :holdouts, :holdout_id_map,
+                :global_holdouts, :included_holdouts, :excluded_holdouts, :flag_holdouts_map
     # Boolean - denotes if Optimizely should remove the last block of visitors' IP address before storing event data
     attr_reader :anonymize_ip
 
@@ -68,6 +70,11 @@ module Optimizely
       @rollouts = config.fetch('rollouts', [])
       @send_flag_decisions = config.fetch('sendFlagDecisions', false)
       @integrations = config.fetch('integrations', [])
+      @region = config.fetch('region', 'US')
+      @holdouts = config.fetch('holdouts', [])
+
+      # Default to US region if not specified
+      @region = 'US' if @region.nil? || @region.empty?
 
       # Json type is represented in datafile as a subtype of string for the sake of backwards compatibility.
       # Converting it to a first-class json type while creating Project Config
@@ -82,6 +89,11 @@ module Optimizely
 
       # Utility maps for quick lookup
       @attribute_key_map = generate_key_map(@attributes, 'key')
+      @attribute_id_map = generate_key_map(@attributes, 'id')
+      @attribute_id_to_key_map = {}
+      @attributes.each do |attribute|
+        @attribute_id_to_key_map[attribute['id']] = attribute['key']
+      end
       @event_key_map = generate_key_map(@events, 'key')
       @group_id_map = generate_key_map(@groups, 'id')
       @group_id_map.each do |key, group|
@@ -102,6 +114,45 @@ module Optimizely
       @variation_id_to_variable_usage_map = {}
       @variation_id_to_experiment_map = {}
       @flag_variation_map = {}
+      @holdout_id_map = {}
+      @global_holdouts = []
+      @included_holdouts = {}
+      @excluded_holdouts = {}
+      @flag_holdouts_map = {}
+
+      @holdouts.each do |holdout|
+        next unless holdout['status'] == 'Running'
+
+        # Ensure holdout has layerId field (holdouts don't have campaigns)
+        holdout['layerId'] ||= ''
+
+        @holdout_id_map[holdout['id']] = holdout
+
+        included_flags = holdout['includedFlags'] || []
+        excluded_flags = holdout['excludedFlags'] || []
+
+        case [included_flags.empty?, excluded_flags.empty?]
+        when [true, true]
+          # No included or excluded flags - this is a global holdout
+          @global_holdouts << holdout
+
+        when [false, true], [false, false]
+          # Has included flags - add to included_holdouts map
+          included_flags.each do |flag_id|
+            @included_holdouts[flag_id] ||= []
+            @included_holdouts[flag_id] << holdout
+          end
+
+        when [true, false]
+          # No included flags but has excluded flags - global with exclusions
+          @global_holdouts << holdout
+
+          excluded_flags.each do |flag_id|
+            @excluded_holdouts[flag_id] ||= []
+            @excluded_holdouts[flag_id] << holdout
+          end
+        end
+      end
 
       @experiment_id_map.each_value do |exp|
         # Excludes experiments from rollouts
@@ -155,6 +206,31 @@ module Optimizely
           @experiment_feature_map[experiment_id] = [feature_flag['id']]
         end
       end
+
+      # Adding Holdout variations in variation id and key maps
+      return unless @holdouts && !@holdouts.empty?
+
+      @holdouts.each do |holdout|
+        next unless holdout['status'] == 'Running'
+
+        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']
+        next unless 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
 
     def get_rules_for_flag(feature_flag)
@@ -440,6 +516,40 @@ module Optimizely
       nil
     end
 
+    def get_attribute_by_key(attribute_key)
+      # Get attribute for the provided attribute key.
+      #
+      # Args:
+      #   Attribute key for which attribute is to be fetched.
+      #
+      # Returns:
+      #   Attribute corresponding to the provided attribute key.
+      attribute = @attribute_key_map[attribute_key]
+      return attribute if attribute
+
+      invalid_attribute_error = InvalidAttributeError.new(attribute_key)
+      @logger.log Logger::ERROR, invalid_attribute_error.message
+      @error_handler.handle_error invalid_attribute_error
+      nil
+    end
+
+    def get_attribute_key_by_id(attribute_id)
+      # Get attribute key for the provided attribute ID.
+      #
+      # Args:
+      #   Attribute ID for which attribute is to be fetched.
+      #
+      # Returns:
+      #   Attribute key corresponding to the provided attribute ID.
+      attribute = @attribute_id_to_key_map[attribute_id]
+      return attribute if attribute
+
+      invalid_attribute_error = InvalidAttributeError.new(attribute_id)
+      @logger.log Logger::ERROR, invalid_attribute_error.message
+      @error_handler.handle_error invalid_attribute_error
+      nil
+    end
+
     def variation_id_exists?(experiment_id, variation_id)
       # Determines if a given experiment ID / variation ID pair exists in the datafile
       #
@@ -524,6 +634,60 @@ module Optimizely
       @rollout_experiment_id_map.key?(experiment_id)
     end
 
+    def get_holdouts_for_flag(flag_id)
+      # Helper method to get holdouts from an applied feature flag
+      #
+      # flag_id - (REQUIRED) ID of the feature flag
+      #         This parameter is required and should not be null/nil
+      #
+      # Returns the holdouts that apply for a specific flag
+
+      return [] if @holdouts.nil? || @holdouts.empty?
+
+      # Check cache first (before validation, so we cache the validation result too)
+      return @flag_holdouts_map[flag_id] if @flag_holdouts_map.key?(flag_id)
+
+      # Validate that the flag exists in the datafile
+      flag_exists = @feature_flags.any? { |flag| flag['id'] == flag_id }
+      unless flag_exists
+        # Cache the empty result for non-existent flags
+        @flag_holdouts_map[flag_id] = []
+        return []
+      end
+
+      # Prioritize global holdouts first
+      excluded = @excluded_holdouts[flag_id] || []
+
+      active_holdouts = if excluded.any?
+                          @global_holdouts.reject { |holdout| excluded.include?(holdout) }
+                        else
+                          @global_holdouts.dup
+                        end
+
+      # Append included holdouts
+      included = @included_holdouts[flag_id] || []
+      active_holdouts.concat(included)
+
+      # Cache the result
+      @flag_holdouts_map[flag_id] = active_holdouts
+
+      @flag_holdouts_map[flag_id] || []
+    end
+
+    def get_holdout(holdout_id)
+      # Helper method to get holdout from holdout ID
+      #
+      # holdout_id - ID of the holdout
+      #
+      # Returns the holdout
+
+      holdout = @holdout_id_map[holdout_id]
+      return holdout if holdout
+
+      @logger.log Logger::ERROR, "Holdout with ID '#{holdout_id}' not found."
+      nil
+    end
+
     private
 
     def generate_feature_variation_map(feature_flags)

data/lib/optimizely/config_manager/http_project_config_manager.rb

@@ -326,7 +326,7 @@ module Optimizely
       unless url
         url_template ||= @access_token.nil? ? Helpers::Constants::CONFIG_MANAGER['DATAFILE_URL_TEMPLATE'] : Helpers::Constants::CONFIG_MANAGER['AUTHENTICATED_DATAFILE_URL_TEMPLATE']
         begin
-          return (url_template % sdk_key)
+          return url_template % sdk_key
         rescue
           error_msg = "Invalid url_template #{url_template} provided."
           @logger.log(Logger::ERROR, error_msg)

data/lib/optimizely/decide/optimizely_decide_option.rb

@@ -23,6 +23,9 @@ module Optimizely
       IGNORE_USER_PROFILE_SERVICE = 'IGNORE_USER_PROFILE_SERVICE'
       INCLUDE_REASONS = 'INCLUDE_REASONS'
       EXCLUDE_VARIABLES = 'EXCLUDE_VARIABLES'
+      IGNORE_CMAB_CACHE = 'IGNORE_CMAB_CACHE'
+      RESET_CMAB_CACHE = 'RESET_CMAB_CACHE'
+      INVALIDATE_USER_CMAB_CACHE = 'INVALIDATE_USER_CMAB_CACHE'
     end
   end
 end

data/lib/optimizely/decide/optimizely_decision.rb

@@ -55,6 +55,25 @@ module Optimizely
       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