splitclient-rb 8.7.0 → 8.9.0.pre.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dee5c1546cb828e8f0bd5d8da3be7b3eaa85324e38fcc26ae730d6fc1e5954b7
-  data.tar.gz: 1951546596f01d3aef2688ad40f8b9c060b0032f5df42f55e2f90ba26c42b4f2
+  metadata.gz: e4b77297a7d366bf770ee722755053a57b7335dc0c430976d9c9979df36aa314
+  data.tar.gz: 22e38080ffb04c1223637db2d5a38e4fa0f6a7601aeee289bcb66efc661eeb7c
 SHA512:
-  metadata.gz: '094314dcffc65c199290db8a2bbcd69902deaaf61adc01dba13da0ce348155ef2731ebe8b0d0cdb006502bb5e4ab699549e21e79008831bd1ddd5a0b44cc5da7'
-  data.tar.gz: e1f1935ec5f7eee464dd07e1e7cff953434721db0181e1d243671e05df273ed9fea8ce5c3de643674e957d0b3a97949e2b524f53237d2dbce7425d7c7af27b16
+  metadata.gz: 89f39548cab9c8d6f1e234a696653940ba928bb2c2f061f26a37a471f964f29895d6530bf480d45eab757bf771aea4436bd7b177eb10dbbbd1cfe10dedb5ebc4
+  data.tar.gz: 5222a70eaf6a336543dc3447bca2a2ba2d69ddcf8ef686e68451f645ce721c0b1028c0f8e8416d8bc85c2afe37cbc6a2c4ba8be2c0af39a0c9122398c016a5c6

data/CHANGES.txt

@@ -1,5 +1,8 @@
 CHANGES
 
+8.8.0 (Sep 26, 2025)
+- Added a maximum size payload when posting unique keys telemetry in batches
+
 8.7.0 (Aug 1, 2025)
 - Added a new optional argument to the client `getTreatment` methods to allow passing additional evaluation options, such as a map of properties to append to the generated impressions sent to Split backend. Read more in our docs.
 

data/lib/splitclient-rb/clients/split_client.rb

@@ -18,7 +18,7 @@ module SplitIoClient
     # @param sdk_key [String] the SDK key for your split account
     #
     # @return [SplitIoClient] split.io client instance
-    def initialize(sdk_key, repositories, status_manager, config, impressions_manager, telemetry_evaluation_producer, evaluator, split_validator)
+    def initialize(sdk_key, repositories, status_manager, config, impressions_manager, telemetry_evaluation_producer, evaluator, split_validator, fallback_treatment_calculator)
       @api_key = sdk_key
       @splits_repository = repositories[:splits]
       @segments_repository = repositories[:segments]
@@ -32,6 +32,7 @@ module SplitIoClient
       @telemetry_evaluation_producer = telemetry_evaluation_producer
       @split_validator = split_validator
       @evaluator = evaluator
+      @fallback_treatment_calculator = fallback_treatment_calculator
     end
 
     def get_treatment(
@@ -50,7 +51,9 @@ module SplitIoClient
         multiple = false, evaluator = nil
       )
       log_deprecated_warning(GET_TREATMENT, evaluator, 'evaluator')
-      treatment(key, split_name, attributes, split_data, store_impressions, GET_TREATMENT_WITH_CONFIG, multiple, evaluation_options)
+      result = treatment(key, split_name, attributes, split_data, store_impressions, GET_TREATMENT_WITH_CONFIG, multiple, evaluation_options)
+
+      { :config => result[:config], :treatment => result[:treatment] }
     end
 
     def get_treatments(key, split_names, attributes = {}, evaluation_options = nil)
@@ -63,7 +66,11 @@ module SplitIoClient
     end
 
     def get_treatments_with_config(key, split_names, attributes = {}, evaluation_options = nil)
-      treatments(key, split_names, attributes, evaluation_options, GET_TREATMENTS_WITH_CONFIG)
+      results = treatments(key, split_names, attributes, evaluation_options, GET_TREATMENTS_WITH_CONFIG)
+
+      results.map{|key, value|
+        [key, { treatment: value[:treatment], config: value[:config] }]
+      }.to_h
     end
 
     def get_treatments_by_flag_set(key, flag_set, attributes = {}, evaluation_options = nil)
@@ -89,13 +96,21 @@ module SplitIoClient
     def get_treatments_with_config_by_flag_set(key, flag_set, attributes = {}, evaluation_options = nil)
       valid_flag_set = @split_validator.valid_flag_sets(GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, [flag_set])
       split_names = @splits_repository.get_feature_flags_by_sets(valid_flag_set)
-      treatments(key, split_names, attributes, evaluation_options, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET)
+      results = treatments(key, split_names, attributes, evaluation_options, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET)
+
+      results.map{|key, value|
+        [key, { treatment: value[:treatment], config: value[:config] }]
+      }.to_h
     end
 
     def get_treatments_with_config_by_flag_sets(key, flag_sets, attributes = {}, evaluation_options = nil)
       valid_flag_set = @split_validator.valid_flag_sets(GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, flag_sets)
       split_names = @splits_repository.get_feature_flags_by_sets(valid_flag_set)
-      treatments(key, split_names, attributes, evaluation_options, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS)
+      results = treatments(key, split_names, attributes, evaluation_options, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS)
+
+      results.map{|key, value|
+        [key, { treatment: value[:treatment], config: value[:config] }]
+      }.to_h
     end
 
     def destroy
@@ -277,7 +292,7 @@ module SplitIoClient
       if !@config.split_validator.valid_get_treatments_parameters(calling_method, key, sanitized_feature_flag_names, matching_key, bucketing_key, attributes)
         to_return = Hash.new
         sanitized_feature_flag_names.each {|name|
-          to_return[name.to_sym] = control_treatment_with_config
+          to_return[name.to_sym] = check_fallback_treatment(name, '')
         }
         return to_return
       end
@@ -286,9 +301,11 @@ module SplitIoClient
         impressions = []
         to_return = Hash.new
         sanitized_feature_flag_names.each {|name|
-          to_return[name.to_sym] = control_treatment_with_config
+          treatment_data = check_fallback_treatment(name, Engine::Models::Label::NOT_READY)
+          to_return[name.to_sym] = treatment_data
+
           impressions << { :impression => @impressions_manager.build_impression(matching_key, bucketing_key, name.to_sym, 
-                                                               control_treatment_with_config.merge({ :label => Engine::Models::Label::NOT_READY }), false, { attributes: attributes, time: nil },
+                                                               get_treatment_without_config(treatment_data), false, { attributes: attributes, time: nil },
                                                                evaluation_options), :disabled => false }
         }
         @impressions_manager.track(impressions)
@@ -308,7 +325,7 @@ module SplitIoClient
         if feature_flag.nil?
           @config.logger.warn("#{calling_method}: you passed #{key} that " \
             'does not exist in this environment, please double check what feature flags exist in the Split user interface')
-            invalid_treatments[key] = control_treatment_with_config
+            invalid_treatments[key] = check_fallback_treatment(key, Engine::Models::Label::NOT_FOUND)
           next
         end
         treatments_labels_change_numbers, impressions = evaluate_treatment(feature_flag, key, bucketing_key, matching_key, attributes, calling_method, false, evaluation_options)
@@ -344,7 +361,7 @@ module SplitIoClient
 
       attributes = parsed_attributes(attributes)
 
-      return parsed_treatment(control_treatment, multiple) unless valid_client && @config.split_validator.valid_get_treatment_parameters(calling_method, key, feature_flag_name, matching_key, bucketing_key, attributes)
+      return parsed_treatment(check_fallback_treatment(feature_flag_name, ""), multiple) unless valid_client && @config.split_validator.valid_get_treatment_parameters(calling_method, key, feature_flag_name, matching_key, bucketing_key, attributes)
 
       bucketing_key = bucketing_key ? bucketing_key.to_s : nil
       matching_key = matching_key.to_s
@@ -373,7 +390,7 @@ module SplitIoClient
         if feature_flag.nil? && ready?
           @config.logger.warn("#{calling_method}: you passed #{feature_flag_name} that " \
             'does not exist in this environment, please double check what feature flags exist in the Split user interface')
-          return parsed_treatment(control_treatment.merge({ :label => Engine::Models::Label::NOT_FOUND }), multiple), nil
+          return check_fallback_treatment(feature_flag_name, Engine::Models::Label::NOT_FOUND), nil
         end
 
         if !feature_flag.nil? && ready?
@@ -383,7 +400,7 @@ module SplitIoClient
           impressions_disabled = feature_flag[:impressionsDisabled]
         else
           @config.logger.error("#{calling_method}: the SDK is not ready, results may be incorrect for feature flag #{feature_flag_name}. Make sure to wait for SDK readiness before using this method.")
-          treatment_data = control_treatment.merge({ :label => Engine::Models::Label::NOT_READY })
+          treatment_data = check_fallback_treatment(feature_flag_name, Engine::Models::Label::NOT_READY)
           impressions_disabled = false
         end
 
@@ -396,22 +413,16 @@ module SplitIoClient
       rescue StandardError => e
         @config.log_found_exception(__method__.to_s, e)
         record_exception(calling_method)
-        impression_decorator = { :impression => @impressions_manager.build_impression(matching_key, bucketing_key, feature_flag_name, control_treatment, false, { attributes: attributes, time: nil }, evaluation_options), :disabled => false }
+        treatment_data = check_fallback_treatment(feature_flag_name, Engine::Models::Label::EXCEPTION)
+        impression_decorator = { :impression => @impressions_manager.build_impression(matching_key, bucketing_key, feature_flag_name, get_treatment_without_config(treatment_data), false, { attributes: attributes, time: nil }, evaluation_options), :disabled => false }
+
         impressions_decorator << impression_decorator unless impression_decorator.nil?
 
-        return parsed_treatment(control_treatment.merge({ :label => Engine::Models::Label::EXCEPTION }), multiple), impressions_decorator
+        return parsed_treatment(treatment_data, multiple), impressions_decorator
       end
       return parsed_treatment(treatment_data, multiple), impressions_decorator
     end
 
-    def control_treatment
-      { :treatment => Engine::Models::Treatment::CONTROL }
-    end
-
-    def control_treatment_with_config
-      {:treatment => Engine::Models::Treatment::CONTROL, :config => nil}
-    end
-
     def variable_size(value)
       value.is_a?(String) ? value.length : 0
     end
@@ -472,5 +483,39 @@ module SplitIoClient
         @telemetry_evaluation_producer.record_exception(Telemetry::Domain::Constants::TRACK)
       end
     end
+
+    def check_fallback_treatment(feature_name, label)
+      return  { 
+        label: (label != '')? label : nil,  
+        treatment: Engine::Models::Treatment::CONTROL, 
+        config: nil,
+        change_number: nil
+      } unless feature_name.is_a?(Symbol) || feature_name.is_a?(String)
+
+      fallback_treatment = @fallback_treatment_calculator.resolve(feature_name.to_sym, label)
+
+      { 
+        label: (label != '')? fallback_treatment.label : nil, 
+        treatment: fallback_treatment.treatment, 
+        config: get_fallback_config(fallback_treatment),
+        change_number: nil
+      }        
+    end
+
+    def get_treatment_without_config(treatment)
+      { 
+        label: treatment[:label], 
+        treatment: treatment[:treatment], 
+      }        
+    end
+
+    def get_fallback_config(fallback_treatment)
+      if fallback_treatment.config != nil
+          return fallback_treatment.config
+      end
+
+      return nil
+    end
+
   end
 end

data/lib/splitclient-rb/engine/fallback_treatment_calculator.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Engine
+    class FallbackTreatmentCalculator
+      attr_accessor :fallback_treatments_configuration, :label_prefix
+
+      def initialize(fallback_treatment_configuration)
+        @label_prefix = 'fallback - '
+        @fallback_treatments_configuration = fallback_treatment_configuration
+      end
+
+      def resolve(flag_name, label)
+        default_fallback_treatment = Engine::Models::FallbackTreatment.new(
+          Engine::Models::Treatment::CONTROL,
+          nil,
+          label
+        )
+        return default_fallback_treatment if @fallback_treatments_configuration.nil?
+
+        if !@fallback_treatments_configuration.by_flag_fallback_treatment.nil? \
+            && !@fallback_treatments_configuration.by_flag_fallback_treatment.fetch(flag_name, nil).nil?
+          return copy_with_label(
+            @fallback_treatments_configuration.by_flag_fallback_treatment[flag_name],
+            resolve_label(label)
+          )
+        end
+
+        return copy_with_label(@fallback_treatments_configuration.global_fallback_treatment, resolve_label(label)) \
+          unless @fallback_treatments_configuration.global_fallback_treatment.nil?
+
+        default_fallback_treatment
+      end
+
+      private
+
+      def resolve_label(label)
+        return nil if label.nil?
+
+        @label_prefix + label
+      end
+
+      def copy_with_label(fallback_treatment, label)
+        Engine::Models::FallbackTreatment.new(fallback_treatment.treatment, fallback_treatment.config, label)
+      end
+    end
+  end
+end

data/lib/splitclient-rb/engine/impressions/unique_keys_tracker.rb

@@ -14,9 +14,9 @@ module SplitIoClient
           @filter_adapter = filter_adapter
           @sender_adapter = sender_adapter
           @cache = cache
-          @cache_max_size = config.unique_keys_cache_max_size
           @max_bulk_size = config.unique_keys_bulk_size
           @semaphore = Mutex.new
+          @keys_size = 0
         end
 
         def call
@@ -30,8 +30,9 @@ module SplitIoClient
           @filter_adapter.add(feature_name, key)
 
           add_or_update(feature_name, key)
+          @keys_size += 1
 
-          send_bulk_data if @cache.size >= @cache_max_size
+          send_bulk_data if @keys_size >= @max_bulk_size
 
           true
         rescue StandardError => e
@@ -70,27 +71,73 @@ module SplitIoClient
           end
         end
 
+        def clear_cache
+          uniques = @cache.clone
+          keys_size = @keys_size
+          @cache.clear
+          @keys_size = 0
+
+          [uniques, keys_size]
+        end
+
         def send_bulk_data
           @semaphore.synchronize do
             return if @cache.empty?
 
-            uniques = @cache.clone
-            @cache.clear
-
-            if uniques.size <= @max_bulk_size
+            uniques, keys_size = clear_cache
+            if keys_size <= @max_bulk_size
               @sender_adapter.record_uniques_key(uniques)
               return
-            end
-
-            bulks = SplitIoClient::Utilities.split_bulk_to_send(uniques, uniques.size / @max_bulk_size)
 
-            bulks.each do |b|
-              @sender_adapter.record_uniques_key(b)
             end
+            bulks = flatten_bulks(uniques)
+            bulks_to_post = group_bulks_by_max_size(bulks)
+            @sender_adapter.record_uniques_key(bulks_to_post)
           end
         rescue StandardError => e
           @config.log_found_exception(__method__.to_s, e)
         end
+
+        def group_bulks_by_max_size(bulks)
+          current_size = 0
+          bulks_to_post = Concurrent::Hash.new
+          bulks.each do |bulk|
+            key, value = bulk.first
+            if (value.size + current_size) > @max_bulk_size
+              @sender_adapter.record_uniques_key(bulks_to_post)
+              bulks_to_post = Concurrent::Hash.new
+              current_size = 0
+            end
+            bulks_to_post[key] = value
+            current_size += value.size
+          end
+
+          bulks_to_post
+        end
+
+        def flatten_bulks(uniques)
+          bulks = []
+          uniques.each_key do |unique_key|
+            bulks += check_keys_and_split_to_bulks(uniques[unique_key], unique_key)
+          end
+
+          bulks
+        end
+
+        def check_keys_and_split_to_bulks(value, key)
+          unique_updated = []
+          if value.size > @max_bulk_size
+            sub_bulks = SplitIoClient::Utilities.split_bulk_to_send(value, @max_bulk_size)
+            sub_bulks.each do |sub_bulk|
+              unique_updated << { key => sub_bulk.to_set }
+            end
+            return unique_updated
+
+          end
+          unique_updated << { key => value }
+
+          unique_updated
+        end
       end
     end
   end

data/lib/splitclient-rb/engine/models/fallback_treatment.rb

@@ -0,0 +1,11 @@
+module SplitIoClient::Engine::Models
+    class FallbackTreatment
+    attr_accessor :treatment, :config, :label
+
+    def initialize(treatment, config=nil, label=nil)
+        @treatment = treatment
+        @config = config
+        @label = label
+    end
+  end
+end

data/lib/splitclient-rb/engine/models/fallback_treatments_configuration.rb

@@ -0,0 +1,36 @@
+module SplitIoClient::Engine::Models
+    class FallbackTreatmentsConfiguration
+    attr_accessor :global_fallback_treatment, :by_flag_fallback_treatment
+
+    def initialize(global_fallback_treatment=nil, by_flag_fallback_treatment=nil)
+        @global_fallback_treatment = build_global_fallback_treatment(global_fallback_treatment)
+        @by_flag_fallback_treatment = build_by_flag_fallback_treatment(by_flag_fallback_treatment)
+    end
+
+    private 
+
+    def build_global_fallback_treatment(global_fallback_treatment)
+      if global_fallback_treatment.is_a? String
+        return FallbackTreatment.new(global_fallback_treatment)
+      end
+      
+      global_fallback_treatment
+    end
+
+    def build_by_flag_fallback_treatment(by_flag_fallback_treatment)
+      return nil unless by_flag_fallback_treatment.is_a?(Hash)
+      processed_by_flag_fallback_treatment = Hash.new
+      
+      by_flag_fallback_treatment.each do |key, value|
+        if value.is_a? String
+          processed_by_flag_fallback_treatment[key] = FallbackTreatment.new(value)
+          next
+        end
+
+        processed_by_flag_fallback_treatment[key] = value
+      end
+
+      processed_by_flag_fallback_treatment
+    end
+  end
+end

data/lib/splitclient-rb/split_config.rb

@@ -112,7 +112,7 @@ module SplitIoClient
       @telemetry_service_url = opts[:telemetry_service_url] || SplitConfig.default_telemetry_service_url
 
       @unique_keys_refresh_rate = SplitConfig.default_unique_keys_refresh_rate(@cache_adapter)
-      @unique_keys_cache_max_size = SplitConfig.default_unique_keys_cache_max_size
+      # @unique_keys_cache_max_size = SplitConfig.default_unique_keys_cache_max_size
       @unique_keys_bulk_size = SplitConfig.default_unique_keys_bulk_size(@cache_adapter)
 
       @counter_refresh_rate = SplitConfig.default_counter_refresh_rate(@cache_adapter)
@@ -123,6 +123,8 @@ module SplitIoClient
       @on_demand_fetch_max_retries = SplitConfig.default_on_demand_fetch_max_retries
 
       @flag_sets_filter = SplitConfig.sanitize_flag_set_filter(opts[:flag_sets_filter], @split_validator, opts[:cache_adapter], @logger)
+
+      @fallback_treatments_configuration = SplitConfig.sanitize_fallback_config(opts[:fallback_treatments], @split_validator, @logger)
       startup_log
     end
 
@@ -292,7 +294,7 @@ module SplitIoClient
     attr_accessor :on_demand_fetch_max_retries
 
     attr_accessor :unique_keys_refresh_rate
-    attr_accessor :unique_keys_cache_max_size
+    #attr_accessor :unique_keys_cache_max_size
     attr_accessor :unique_keys_bulk_size
 
     attr_accessor :counter_refresh_rate
@@ -303,6 +305,8 @@ module SplitIoClient
     # @return [Array]
     attr_accessor :flag_sets_filter
 
+    attr_accessor :fallback_treatments_configuration
+
     def self.default_counter_refresh_rate(adapter)
       return 300 if adapter == :redis # Send bulk impressions count - Refresh rate: 5 min.
 
@@ -498,9 +502,9 @@ module SplitIoClient
       900
     end
 
-    def self.default_unique_keys_cache_max_size
-      30000
-    end
+#    def self.default_unique_keys_cache_max_size
+#      30000
+#    end
 
     def self.default_unique_keys_bulk_size(adapter)
       return 2000 if adapter == :redis
@@ -697,5 +701,37 @@ module SplitIoClient
 
       return ''.freeze
     end
+
+    def self.sanitize_fallback_config(fallback_config, validator, logger)
+      return fallback_config if fallback_config.nil?
+      
+      processed = Engine::Models::FallbackTreatmentsConfiguration.new
+      if !fallback_config.is_a?(Engine::Models::FallbackTreatmentsConfiguration)
+        logger.warn('Config: fallbackTreatments parameter should be of `FallbackTreatmentsConfiguration` class.')
+        return processed        
+      end
+
+      sanitized_global_fallback_treatment = fallback_config.global_fallback_treatment
+      if !fallback_config.global_fallback_treatment.nil? && !validator.validate_fallback_treatment('Config', fallback_config.global_fallback_treatment)
+        logger.warn('Config: global fallbacktreatment parameter is discarded.')
+        sanitized_global_fallback_treatment = nil
+      end
+
+      sanitized_flag_fallback_treatments = nil
+      if !fallback_config.by_flag_fallback_treatment.nil? && fallback_config.by_flag_fallback_treatment.is_a?(Hash)
+        sanitized_flag_fallback_treatments = Hash.new
+        for feature_name in fallback_config.by_flag_fallback_treatment.keys()
+          if !validator.valid_split_name?('Config', feature_name) || !validator.validate_fallback_treatment('Config', fallback_config.by_flag_fallback_treatment[feature_name])
+            logger.warn("Config: fallback treatment parameter for feature flag #{feature_name} is discarded.")
+            next
+          end   
+
+          sanitized_flag_fallback_treatments[feature_name] = fallback_config.by_flag_fallback_treatment[feature_name]
+        end
+      end          
+      processed = Engine::Models::FallbackTreatmentsConfiguration.new(sanitized_global_fallback_treatment, sanitized_flag_fallback_treatments)
+
+      processed
+    end
   end
 end

data/lib/splitclient-rb/split_factory.rb

@@ -58,8 +58,8 @@ module SplitIoClient
       @evaluator = Engine::Parser::Evaluator.new(@segments_repository, @splits_repository, @rule_based_segment_repository, @config)
 
       start!
-
-      @client = SplitClient.new(@api_key, repositories, @status_manager, @config, @impressions_manager, @evaluation_producer, @evaluator, @split_validator)
+      fallback_treatment_calculator = SplitIoClient::Engine::FallbackTreatmentCalculator.new(@config.fallback_treatments_configuration) 
+      @client = SplitClient.new(@api_key, repositories, @status_manager, @config, @impressions_manager, @evaluation_producer, @evaluator, @split_validator, fallback_treatment_calculator)
       @manager = SplitManager.new(@splits_repository, @status_manager, @config)
     end
 

data/lib/splitclient-rb/utilitites.rb

@@ -38,16 +38,12 @@ module SplitIoClient
       interval * random_factor
     end
 
-    def split_bulk_to_send(hash, divisions)
-      count = 0
-
-      hash.each_with_object([]) do |key_value, final|
-        final[count % divisions] ||= {}
-        final[count % divisions][key_value[0]] = key_value[1]
-        count += 1
-      end
-    rescue StandardError
-      []
+    def split_bulk_to_send(items, divisions)
+      to_return = []
+      items.to_a.each_slice(divisions) {|bulk|
+        to_return.push(bulk.to_set)
+      }
+      to_return
     end
   end  
 end

data/lib/splitclient-rb/validators.rb

@@ -4,6 +4,8 @@ module SplitIoClient
   class Validators
 
     Flagset_regex = /^[a-z0-9][_a-z0-9]{0,49}$/
+    Fallback_treatment_regex = /^[0-9]+[.a-zA-Z0-9_-]*$|^[a-zA-Z]+[a-zA-Z0-9_-]*$/
+    Fallback_treatment_size = 100
 
     def initialize(config)
       @config = config
@@ -68,7 +70,7 @@ module SplitIoClient
           log_invalid_flag_set_type(method)
         elsif flag_set.is_a?(String) && flag_set.empty?
           log_invalid_flag_set_type(method)
-        elsif !flag_set.empty? && string_match?(flag_set.strip.downcase, method)
+        elsif !flag_set.empty? && string_match?(flag_set.strip.downcase, method, Flagset_regex, :log_invalid_match)
           valid_flag_sets.add(flag_set.strip.downcase)
         else
           log_invalid_flag_set_type(method)
@@ -77,6 +79,46 @@ module SplitIoClient
       !valid_flag_sets.empty? ? valid_flag_sets.to_a.sort :  []
     end
 
+    def validate_fallback_treatment(method, fallback_treatment)
+      if !fallback_treatment.is_a? Engine::Models::FallbackTreatment
+          @config.logger.warn("#{method}: Fallback treatment instance should be FallbackTreatment, input is discarded")
+          return false
+      end
+
+      if !fallback_treatment.treatment.is_a? String
+          @config.logger.warn("#{method}: Fallback treatment value should be str type, input is discarded")
+          return false
+      end    
+
+      return false unless string_match?(fallback_treatment.treatment, method, Fallback_treatment_regex, :log_invalid_fallback_treatment)
+
+      if fallback_treatment.treatment.size > Fallback_treatment_size
+          @config.logger.warn("#{method}: Fallback treatment size should not exceed #{Fallback_treatment_size} characters")
+          return false
+      end
+      
+      true
+    end
+
+    def valid_split_name?(method, split_name)
+      if split_name.nil?
+        log_nil(:split_name, method)
+        return false
+      end
+
+      unless string?(split_name)
+        log_invalid_type(:split_name, method)
+        return false
+      end
+
+      if empty_string?(split_name)
+        log_empty_string(:split_name, method)
+        return false
+      end
+
+      true
+    end
+
     private
 
     def string?(value)
@@ -91,9 +133,9 @@ module SplitIoClient
       (value.is_a?(Numeric) && !value.to_f.nan?) || string?(value)
     end
 
-    def string_match?(value, method)
-      if Flagset_regex.match(value) == nil
-        log_invalid_match(value, method)
+    def string_match?(value, method, regex_exp, log_if_invalid)
+      if regex_exp.match(value) == nil
+        method(log_if_invalid).call(value, method)
         false
       else
         true
@@ -132,25 +174,6 @@ module SplitIoClient
       @config.logger.error("#{method}: #{key} is too long - must be #{@config.max_key_size} characters or less")
     end
 
-    def valid_split_name?(method, split_name)
-      if split_name.nil?
-        log_nil(:split_name, method)
-        return false
-      end
-
-      unless string?(split_name)
-        log_invalid_type(:split_name, method)
-        return false
-      end
-
-      if empty_string?(split_name)
-        log_empty_string(:split_name, method)
-        return false
-      end
-
-      true
-    end
-
     def valid_key?(method, key)
       if key.nil?
         log_nil(:key, method)
@@ -326,5 +349,9 @@ module SplitIoClient
 
       true
     end
+
+    def log_invalid_fallback_treatment(key, method)
+      @config.logger.warn("#{method}: Invalid treatment #{key}, Fallback treatment should match regex #{Fallback_treatment_regex}")
+    end
   end
 end

data/lib/splitclient-rb/version.rb

@@ -1,3 +1,3 @@
 module SplitIoClient
-  VERSION = '8.7.0'
+  VERSION = '8.9.0-rc1'
 end

data/lib/splitclient-rb.rb

@@ -110,8 +110,11 @@ require 'splitclient-rb/engine/models/segment_type'
 require 'splitclient-rb/engine/models/treatment'
 require 'splitclient-rb/engine/models/split_http_response'
 require 'splitclient-rb/engine/models/evaluation_options'
+require 'splitclient-rb/engine/models/fallback_treatment.rb'
+require 'splitclient-rb/engine/models/fallback_treatments_configuration.rb'
 require 'splitclient-rb/engine/auth_api_client'
 require 'splitclient-rb/engine/back_off'
+require 'splitclient-rb/engine/fallback_treatment_calculator.rb'
 require 'splitclient-rb/engine/push_manager'
 require 'splitclient-rb/engine/status_manager'
 require 'splitclient-rb/engine/sync_manager'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: splitclient-rb
 version: !ruby/object:Gem::Version
-  version: 8.7.0
+  version: 8.9.0.pre.rc1
 platform: ruby
 authors:
 - Split Software
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-08-01 00:00:00.000000000 Z
+date: 2025-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: allocation_stats
@@ -481,6 +481,7 @@ files:
 - lib/splitclient-rb/engine/common/impressions_manager.rb
 - lib/splitclient-rb/engine/common/noop_impressions_counter.rb
 - lib/splitclient-rb/engine/evaluator/splitter.rb
+- lib/splitclient-rb/engine/fallback_treatment_calculator.rb
 - lib/splitclient-rb/engine/impressions/noop_unique_keys_tracker.rb
 - lib/splitclient-rb/engine/impressions/unique_keys_tracker.rb
 - lib/splitclient-rb/engine/matchers/all_keys_matcher.rb
@@ -515,6 +516,8 @@ files:
 - lib/splitclient-rb/engine/matchers/whitelist_matcher.rb
 - lib/splitclient-rb/engine/metrics/binary_search_latency_tracker.rb
 - lib/splitclient-rb/engine/models/evaluation_options.rb
+- lib/splitclient-rb/engine/models/fallback_treatment.rb
+- lib/splitclient-rb/engine/models/fallback_treatments_configuration.rb
 - lib/splitclient-rb/engine/models/label.rb
 - lib/splitclient-rb/engine/models/segment_type.rb
 - lib/splitclient-rb/engine/models/split.rb
@@ -592,9 +595,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project:
 rubygems_version: 2.7.6.2