optimizely-sdk 5.2.0 → 5.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f3e60440f1cc553ee8c1eac5ffc7657b6f4de011a4d53a31674c0f5f68843b68
-  data.tar.gz: 2e9f30000ddabe5118f32d4afda400f02db039b0e1e8ffca23d0bd96439ef71c
+  metadata.gz: 98f3ee93c9d69f15110623bfffad642326cd891607899ded857c6289e315a34f
+  data.tar.gz: ee719a38656735b49e65d37a261b4b709a84a76d9157d40889ce7be4a56c0029
 SHA512:
-  metadata.gz: b563647ea0496d3c1b65d478c00918729e95b32b74e1260c34b92c2115d791101bfa0f22450b92185172773a8c16ae2cb36854f69792652da259b99499f28acd
-  data.tar.gz: '038f0fd4bf0280b7d68a33bf7b0bb27f3efe482ef94995bb53751966e9fa7c4b3229fb62a513c2b88458557280b27e339a3222a459649d8b91e837e3e13adb00'
+  metadata.gz: 898908417c5e73e4136295ac92c942597cce81be13b6f2def6871c0635cf4c5ac52731140a0eaf154a6cfe75e3819e0fe7061f0d3af9c039e82e8a6ff9853592
+  data.tar.gz: 9938341c76b893da676e2bbcfd7406959ead3b38558bf8052261f50acde9d42f4e556af3e61cf84fbc6a8c34abf2c15bf69ce0812ca91ea9c7249a10b30bcdde

data/lib/optimizely/config/datafile_project_config.rb

@@ -33,8 +33,7 @@ module Optimizely
                 :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, :region, :holdouts, :holdout_id_map,
-                :global_holdouts, :included_holdouts, :excluded_holdouts, :flag_holdouts_map
+                :public_key_for_odp, :host_for_odp, :all_segments, :region, :holdouts, :holdout_id_map
     # Boolean - denotes if Optimizely should remove the last block of visitors' IP address before storing event data
     attr_reader :anonymize_ip
 
@@ -115,32 +114,14 @@ module Optimizely
       @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'
 
-        @holdout_id_map[holdout['id']] = holdout
-
-        if holdout['includedFlags'].nil? || holdout['includedFlags'].empty?
-          @global_holdouts[holdout['id']] = holdout
+        # Ensure holdout has layerId field (holdouts don't have campaigns)
+        holdout['layerId'] ||= ''
 
-          excluded_flags = holdout['excludedFlags']
-          if excluded_flags && !excluded_flags.empty?
-            excluded_flags.each do |flag_id|
-              @excluded_holdouts[flag_id] ||= []
-              @excluded_holdouts[flag_id] << holdout
-            end
-          end
-        else
-          holdout['includedFlags'].each do |flag_id|
-            @included_holdouts[flag_id] ||= []
-            @included_holdouts[flag_id] << holdout
-          end
-        end
+        @holdout_id_map[holdout['id']] = holdout
       end
 
       @experiment_id_map.each_value do |exp|
@@ -169,7 +150,6 @@ module Optimizely
         @all_segments.concat Audience.get_segments(audience['conditions'])
       end
 
-      @flag_variation_map = generate_feature_variation_map(@feature_flags)
       @all_experiments = @experiment_id_map.merge(@rollout_experiment_id_map)
       @all_experiments.each do |id, exp|
         variations = exp.fetch('variations')
@@ -195,19 +175,32 @@ module Optimizely
           @experiment_feature_map[experiment_id] = [feature_flag['id']]
         end
 
-        flag_id = feature_flag['id']
-        applicable_holdouts = []
-
-        applicable_holdouts.concat(@included_holdouts[flag_id]) if @included_holdouts[flag_id]
-
-        @global_holdouts.each_value do |holdout|
-          excluded_flag_ids = holdout['excludedFlags'] || []
-          applicable_holdouts << holdout unless excluded_flag_ids.include?(flag_id)
+        # Feature Rollout support: inject the "everyone else" variation
+        # into any experiment with type == "feature_rollout"
+        everyone_else_variation = get_everyone_else_variation(feature_flag)
+        next if everyone_else_variation.nil?
+
+        feature_flag['experimentIds'].each do |exp_id|
+          experiment = @experiment_id_map[exp_id]
+          next unless experiment && experiment['type'] == Helpers::Constants::EXPERIMENT_TYPES['fr']
+
+          experiment['variations'].push(everyone_else_variation)
+          experiment['trafficAllocation'].push(
+            'entityId' => everyone_else_variation['id'],
+            'endOfRange' => 10_000
+          )
+          @variation_key_map[experiment['key']][everyone_else_variation['key']] = everyone_else_variation
+          @variation_id_map[experiment['key']][everyone_else_variation['id']] = everyone_else_variation
+          @variation_id_map_by_experiment_id[exp_id][everyone_else_variation['id']] = everyone_else_variation
+          @variation_key_map_by_experiment_id[exp_id][everyone_else_variation['key']] = everyone_else_variation
+          variation_variables = everyone_else_variation['variables']
+          @variation_id_to_variable_usage_map[everyone_else_variation['id']] = generate_key_map(variation_variables, 'id') if variation_variables
         end
-
-        @flag_holdouts_map[key] = applicable_holdouts unless applicable_holdouts.empty?
       end
 
+      # Generate flag_variation_map after injection so it includes everyone-else variations
+      @flag_variation_map = generate_feature_variation_map(@feature_flags)
+
       # Adding Holdout variations in variation id and key maps
       return unless @holdouts && !@holdouts.empty?
 
@@ -635,19 +628,6 @@ 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?
-
-      @flag_holdouts_map[flag_id] || []
-    end
-
     def get_holdout(holdout_id)
       # Helper method to get holdout from holdout ID
       #
@@ -664,6 +644,38 @@ module Optimizely
 
     private
 
+    def get_everyone_else_variation(feature_flag)
+      # Get the "everyone else" variation for a feature flag.
+      #
+      # The "everyone else" rule is the last experiment in the flag's rollout,
+      # and its first variation is the "everyone else" variation.
+      #
+      # feature_flag - Feature flag hash
+      #
+      # Returns the "everyone else" variation hash, or nil if not available.
+
+      rollout_id = feature_flag['rolloutId']
+      return nil if rollout_id.nil? || rollout_id.empty?
+
+      rollout = @rollout_id_map[rollout_id]
+      return nil if rollout.nil?
+
+      experiments = rollout['experiments']
+      return nil if experiments.nil? || experiments.empty?
+
+      everyone_else_rule = experiments.last
+      variations = everyone_else_rule['variations']
+      return nil if variations.nil? || variations.empty?
+
+      variation = variations.first
+      {
+        'id' => variation['id'],
+        'key' => variation['key'],
+        'featureEnabled' => variation['featureEnabled'] == true,
+        'variables' => variation.fetch('variables', [])
+      }
+    end
+
     def generate_feature_variation_map(feature_flags)
       flag_variation_map = {}
       feature_flags.each do |flag|

data/lib/optimizely/decision_service.rb

@@ -132,6 +132,8 @@ module Optimizely
           return VariationResult.new(nil, true, decide_reasons, nil)
         end
 
+        @logger.log(Logger::DEBUG, "Skipping user profile service for CMAB experiment '#{experiment_key}'. CMAB decisions are dynamic and not stored for sticky bucketing.")
+        should_ignore_user_profile_service = true
         cmab_decision = cmab_decision_result.result
         variation_id = cmab_decision&.variation_id
         cmab_uuid = cmab_decision&.cmab_uuid
@@ -167,9 +169,10 @@ module Optimizely
       # user_context - Optimizely user context instance
       #
       # Returns DecisionResult struct.
-      holdouts = project_config.get_holdouts_for_flag(feature_flag['id'])
+      # Get running holdouts from the holdout_id_map (all holdouts are global now)
+      running_holdouts = project_config.holdout_id_map.values
 
-      if holdouts && !holdouts.empty?
+      if running_holdouts && !running_holdouts.empty?
         # Has holdouts - use get_decision_for_flag which checks holdouts first
         get_decision_for_flag(feature_flag, user_context, project_config, decide_options)
       else
@@ -193,8 +196,8 @@ module Optimizely
       reasons = decide_reasons ? decide_reasons.dup : []
       user_id = user_context.user_id
 
-      # Check holdouts
-      holdouts = project_config.get_holdouts_for_flag(feature_flag['id'])
+      # Check holdouts (all holdouts are global now - apply to all flags)
+      holdouts = project_config.holdout_id_map.values
 
       holdouts.each do |holdout|
         holdout_decision = get_variation_for_holdout(holdout, user_context, project_config)
@@ -214,6 +217,9 @@ module Optimizely
 
       return DecisionResult.new(experiment_decision.decision, experiment_decision.error, reasons) if experiment_decision.decision
 
+      # If there's an error (e.g., CMAB error), return immediately without falling back to rollout
+      return DecisionResult.new(nil, experiment_decision.error, reasons) if experiment_decision.error
+
       # 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)
@@ -312,15 +318,8 @@ module Optimizely
 
       decisions = []
       feature_flags.each do |feature_flag|
-        # check if the feature is being experiment on and whether the user is bucketed into the experiment
-        decision_result = get_variation_for_feature_experiment(project_config, feature_flag, user_context, user_profile_tracker, decide_options)
-        # Only process rollout if no experiment decision was found and no error
-        if decision_result.decision.nil? && !decision_result.error
-          decision_result_rollout = get_variation_for_feature_rollout(project_config, feature_flag, user_context) unless decision_result.decision
-          decision_result.decision = decision_result_rollout.decision
-          decision_result.reasons.push(*decision_result_rollout.reasons)
-        end
-        decisions << decision_result
+        decision = get_decision_for_flag(feature_flag, user_context, project_config, decide_options, user_profile_tracker)
+        decisions << decision
       end
       user_profile_tracker&.save_user_profile
       decisions

data/lib/optimizely/event/batch_event_processor.rb

@@ -172,20 +172,35 @@ module Optimizely
       return if @current_batch.empty?
 
       log_event = Optimizely::EventFactory.create_log_event(@current_batch, @logger)
-      begin
-        @logger.log(
-          Logger::INFO,
-          'Flushing Queue.'
-        )
-
-        @event_dispatcher.dispatch_event(log_event)
-        @notification_center&.send_notifications(
-          NotificationCenter::NOTIFICATION_TYPES[:LOG_EVENT],
-          log_event
-        )
-      rescue StandardError => e
-        @logger.log(Logger::ERROR, "Error dispatching event: #{log_event} #{e.message}.")
+      @logger.log(
+        Logger::INFO,
+        'Flushing Queue.'
+      )
+
+      retry_count = 0
+      max_retries = Optimizely::Helpers::Constants::EVENT_DISPATCH_CONFIG[:MAX_RETRIES]
+
+      while retry_count < max_retries
+        begin
+          @event_dispatcher.dispatch_event(log_event)
+          @notification_center&.send_notifications(
+            NotificationCenter::NOTIFICATION_TYPES[:LOG_EVENT],
+            log_event
+          )
+          # Success - break out of retry loop
+          break
+        rescue StandardError => e
+          @logger.log(Logger::ERROR, "Error dispatching event: #{log_event} #{e.message}.")
+          retry_count += 1
+
+          if retry_count < max_retries
+            delay = calculate_retry_interval(retry_count - 1)
+            @logger.log(Logger::DEBUG, "Retrying event dispatch (attempt #{retry_count + 1} of #{max_retries}) after #{delay}s")
+            sleep(delay)
+          end
+        end
       end
+
       @current_batch = []
     end
 
@@ -231,5 +246,16 @@ module Optimizely
       #   false otherwise.
       Helpers::Validator.finite_number?(value) && value.positive?
     end
+
+    # Calculate exponential backoff interval: 200ms, 400ms, 800ms, ... capped at 1s
+    #
+    # @param retry_count - Zero-based retry count
+    # @return [Float] - Delay in seconds
+    def calculate_retry_interval(retry_count)
+      initial_interval = Helpers::Constants::EVENT_DISPATCH_CONFIG[:INITIAL_RETRY_INTERVAL]
+      max_interval = Helpers::Constants::EVENT_DISPATCH_CONFIG[:MAX_RETRY_INTERVAL]
+      interval = initial_interval * (2**retry_count)
+      [interval, max_interval].min
+    end
   end
 end

data/lib/optimizely/helpers/constants.rb

@@ -18,6 +18,14 @@
 module Optimizely
   module Helpers
     module Constants
+      EXPERIMENT_TYPES = {
+        'ab' => 'ab',
+        'mab' => 'mab',
+        'cmab' => 'cmab',
+        'td' => 'td',
+        'fr' => 'fr'
+      }.freeze
+
       JSON_SCHEMA_V2 = {
         'type' => 'object',
         'properties' => {
@@ -205,6 +213,9 @@ module Optimizely
                 'cmab' => {
                   'type' => 'object'
                 },
+                'type' => {
+                  'type' => %w[string null]
+                },
                 'holdouts' => {
                   'type' => 'array'
                 }
@@ -335,14 +346,6 @@ module Optimizely
                 },
                 'status' => {
                   'type' => 'string'
-                },
-                'includedFlags' => {
-                  'type' => 'array',
-                  'items' => {'type' => 'string'}
-                },
-                'excludedFlags' => {
-                  'type' => 'array',
-                  'items' => {'type' => 'string'}
                 }
               }
             }
@@ -459,7 +462,10 @@ module Optimizely
       }.freeze
 
       EVENT_DISPATCH_CONFIG = {
-        REQUEST_TIMEOUT: 10
+        REQUEST_TIMEOUT: 10,
+        MAX_RETRIES: 3,
+        INITIAL_RETRY_INTERVAL: 0.2, # 200ms in seconds
+        MAX_RETRY_INTERVAL: 1.0 # 1 second
       }.freeze
 
       ODP_GRAPHQL_API_CONFIG = {
@@ -490,7 +496,9 @@ module Optimizely
         DEFAULT_QUEUE_CAPACITY: 10_000,
         DEFAULT_BATCH_SIZE: 10,
         DEFAULT_FLUSH_INTERVAL_SECONDS: 1,
-        DEFAULT_RETRY_COUNT: 3
+        DEFAULT_RETRY_COUNT: 3,
+        INITIAL_RETRY_INTERVAL: 0.2, # 200ms in seconds
+        MAX_RETRY_INTERVAL: 1.0 # 1 second
       }.freeze
 
       HTTP_HEADERS = {

data/lib/optimizely/odp/odp_event_manager.rb

@@ -239,7 +239,12 @@ module Optimizely
         end
         break unless should_retry
 
-        @logger.log(Logger::DEBUG, 'Error dispatching ODP events, scheduled to retry.') if i < @retry_count
+        if i < @retry_count - 1
+          # Exponential backoff: 200ms, 400ms, 800ms, ... capped at 1s
+          delay = calculate_retry_interval(i)
+          @logger.log(Logger::DEBUG, "Error dispatching ODP events, retrying (attempt #{i + 2} of #{@retry_count}) after #{delay}s")
+          sleep(delay)
+        end
         i += 1
       end
 
@@ -282,5 +287,16 @@ module Optimizely
       @api_key = @odp_config&.api_key
       @api_host = @odp_config&.api_host
     end
+
+    # Calculate exponential backoff interval: 200ms, 400ms, 800ms, ... capped at 1s
+    #
+    # @param retry_count - Zero-based retry count
+    # @return [Float] - Delay in seconds
+    def calculate_retry_interval(retry_count)
+      initial_interval = Helpers::Constants::ODP_EVENT_MANAGER[:INITIAL_RETRY_INTERVAL]
+      max_interval = Helpers::Constants::ODP_EVENT_MANAGER[:MAX_RETRY_INTERVAL]
+      interval = initial_interval * (2**retry_count)
+      [interval, max_interval].min
+    end
   end
 end

data/lib/optimizely/version.rb

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

data/lib/optimizely.rb

@@ -220,7 +220,7 @@ module Optimizely
         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)
+      if !decide_options.include?(OptimizelyDecideOption::DISABLE_DECISION_EVENT) && (decision_source == Optimizely::DecisionService::DECISION_SOURCES['FEATURE_TEST'] || decision_source == Optimizely::DecisionService::DECISION_SOURCES['HOLDOUT'] || config.send_flag_decisions)
         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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: optimizely-sdk
 version: !ruby/object:Gem::Version
-  version: 5.2.0
+  version: 5.3.0
 platform: ruby
 authors:
 - Optimizely
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-11-13 00:00:00.000000000 Z
+date: 2026-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -216,7 +216,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Ruby SDK for Optimizely's testing framework