optimizely-sdk 5.2.1 → 5.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f3f7080762c8f6eeb95b64da8d451035e5f162208f7556aed1886dfa5bce0b8c
-  data.tar.gz: 046cf325408978dc7c0584d7a6ece61ae4795b843717164080b964a60ccd5a85
+  metadata.gz: 98f3ee93c9d69f15110623bfffad642326cd891607899ded857c6289e315a34f
+  data.tar.gz: ee719a38656735b49e65d37a261b4b709a84a76d9157d40889ce7be4a56c0029
 SHA512:
-  metadata.gz: ff65b8f753315ac052920dd4c1bfe6f7d46d14742911c2a7cfe21d91d85fc424439724df7445eddf9d7453ca0bbd2a7306669ba255df1f811390c3d1e54d645e
-  data.tar.gz: 4ca8a3093958b3061c38648c93494c5e36ab4b31917af95f89dc66ec420f384a4189a7e46467210283ea370a98ab71be22b63d7de90d6bb9fa02d9144ad5f1ea
+  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,10 +114,6 @@ 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'
@@ -127,31 +122,6 @@ module Optimizely
         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|
@@ -180,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')
@@ -205,8 +174,33 @@ module Optimizely
         feature_flag['experimentIds'].each do |experiment_id|
           @experiment_feature_map[experiment_id] = [feature_flag['id']]
         end
+
+        # 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
       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?
 
@@ -634,46 +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?
-
-      # 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
       #
@@ -690,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)

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.1'
+  VERSION = '5.3.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: optimizely-sdk
 version: !ruby/object:Gem::Version
-  version: 5.2.1
+  version: 5.3.0
 platform: ruby
 authors:
 - Optimizely
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-12-17 00:00:00.000000000 Z
+date: 2026-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler