Updated client

Author: chillaq

lib/splitclient-rb/clients/split_client.rb

@@ -18,7 +18,7 @@ class SplitClient
     # @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 @@ def initialize(sdk_key, repositories, status_manager, config, impressions_manage
       @telemetry_evaluation_producer = telemetry_evaluation_producer
       @split_validator = split_validator
       @evaluator = evaluator
+      @fallback_treatment_calculator = fallback_treatment_calculator
     end
 
     def get_treatment(
@@ -277,7 +278,7 @@ def treatments(key, feature_flag_names, attributes = {}, evaluation_options = ni
       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 +287,11 @@ def treatments(key, feature_flag_names, attributes = {}, evaluation_options = ni
         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 +311,7 @@ def treatments(key, feature_flag_names, attributes = {}, evaluation_options = ni
         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 +347,7 @@ def treatment(key, feature_flag_name, attributes = {}, split_data = nil, store_i
 
       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 +376,7 @@ def evaluate_treatment(feature_flag, feature_flag_name, bucketing_key, matching_
         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 +386,7 @@ def evaluate_treatment(feature_flag, feature_flag_name, bucketing_key, matching_
           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 +399,16 @@ def evaluate_treatment(feature_flag, feature_flag_name, bucketing_key, matching_
       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 +469,31 @@ def record_exception(method)
         @telemetry_evaluation_producer.record_exception(Telemetry::Domain::Constants::TRACK)
       end
     end
+
+    def check_fallback_treatment(feature_name, label)
+      fallback_treatment = @fallback_treatment_calculator.resolve(feature_name.to_sym, label)
+
+      { 
+        label: fallback_treatment.label, 
+        treatment: fallback_treatment.treatment, 
+        config: get_fallback_config(fallback_treatment) 
+      }        
+    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

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

@@ -18,7 +18,7 @@ def build_global_fallback_treatment(global_fallback_treatment)
     end
 
     def build_by_flag_fallback_treatment(by_flag_fallback_treatment)
-      return nil unless by_flag_fallback_treatment.is_a? Hash
+      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|

lib/splitclient-rb/split_config.rb

@@ -712,15 +712,16 @@ def self.sanitize_fallback_config(fallback_config, validator, logger)
       end
 
       sanitized_global_fallback_treatment = fallback_config.global_fallback_treatment
-      if !fallback_config.global_fallback_treatment.nil? && !validator.validate_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 = None
+        sanitized_global_fallback_treatment = nil
       end
 
-      sanitized_flag_fallback_treatments = Hash.new
+      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(fallback_config.by_flag_fallback_treatment[feature_name])
+          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   

lib/splitclient-rb/split_factory.rb

@@ -58,8 +58,9 @@ def initialize(api_key, config_hash = {})
       @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(SplitIoClient::Engine::Models::FallbackTreatmentsConfiguration.new) 
+      @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
 

lib/splitclient-rb/validators.rb

@@ -70,7 +70,7 @@ def valid_flag_sets(method, flag_sets)
           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, Flagset_regex, log_invalid_match)
+        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)
@@ -79,6 +79,46 @@ def valid_flag_sets(method, flag_sets)
       !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)
@@ -95,7 +135,7 @@ def number_or_string?(value)
 
     def string_match?(value, method, regex_exp, log_if_invalid)
       if regex_exp.match(value) == nil
-        log_if_invalid(value, method)
+        method(log_if_invalid).call(value, method)
         false
       else
         true
@@ -134,25 +174,6 @@ def log_key_too_long(key, method)
       @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)
@@ -329,29 +350,8 @@ def valid_properties?(properties)
       true
     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)
-
-      if fallback_treatment.treatment.size > Fallback_treatment_size
-          @config.logger.warn("#{method}: Fallback treatment size should not exceed %s characters", Fallback_treatment_size)
-          return false
-      end            
-      
-      true
-    end
-
     def log_invalid_fallback_treatment(key, method)
-      @config.logger.warn("#{method}: Invalid treatment #{key}, Fallback treatment should match regex %s", Fallback_treatment_regex)
+      @config.logger.warn("#{method}: Invalid treatment #{key}, Fallback treatment should match regex #{Fallback_treatment_regex}")
     end
   end
 end