splitclient-rb 8.4.0 → 8.11.0

data/lib/splitclient-rb/cache/repositories/splits_repository.rb

@@ -31,8 +31,11 @@ module SplitIoClient
           ],
           label: "targeting rule type unsupported by sdk"
         }]
+        TILL_PREFIX = '.splits.till'
+        SPLIT_PREFIX = '.split.'
+        READY_PREFIX = '.splits.ready'
 
-        def initialize(config, flag_sets_repository, flag_set_filter)
+        def initialize(config, flag_sets_repository, flag_set_filter, internal_events_queue)
           super(config)
           @tt_cache = {}
           @adapter = case @config.cache_adapter.class.to_s
@@ -43,16 +46,26 @@ module SplitIoClient
           end
           @flag_sets = flag_sets_repository
           @flag_set_filter = flag_set_filter
-          unless @config.mode.equal?(:consumer)
-            @adapter.set_string(namespace_key('.splits.till'), '-1')
-            @adapter.initialize_map(namespace_key('.segments.registered'))
-          end
+          @internal_events_queue = internal_events_queue
+          initialize_keys
         end
 
         def update(to_add, to_delete, new_change_number)
           to_add.each{ |feature_flag| add_feature_flag(feature_flag) }
           to_delete.each{ |feature_flag| remove_feature_flag(feature_flag) }
           set_change_number(new_change_number)
+
+          if to_add.length > 0 || to_delete.length > 0
+            @internal_events_queue.push(
+              SplitIoClient::Engine::Models::SdkInternalEventNotification.new(
+                SplitIoClient::Engine::Models::SdkInternalEvent::FLAGS_UPDATED, 
+                SplitIoClient::Engine::Models::EventsMetadata.new(
+                  SplitIoClient::Engine::Models::SdkEventType::FLAG_UPDATE,
+                  to_add.map {|flag| flag[:name]} | to_delete.map {|flag| flag[:name]}
+                )
+              )
+            )
+          end
         end
 
         def get_split(name)
@@ -87,16 +100,16 @@ module SplitIoClient
 
         # Return an array of Split Names excluding control keys like splits.till
         def split_names
-          @adapter.find_strings_by_prefix(namespace_key('.split.'))
-            .map { |split| split.gsub(namespace_key('.split.'), '') }
+          @adapter.find_strings_by_prefix(namespace_key(SPLIT_PREFIX))
+            .map { |split| split.gsub(namespace_key(SPLIT_PREFIX), '') }
         end
 
         def set_change_number(since)
-          @adapter.set_string(namespace_key('.splits.till'), since)
+          @adapter.set_string(namespace_key(TILL_PREFIX), since)
         end
 
         def get_change_number
-          @adapter.string(namespace_key('.splits.till'))
+          @adapter.string(namespace_key(TILL_PREFIX))
         end
 
         def set_segment_names(names)
@@ -112,21 +125,22 @@ module SplitIoClient
         end
 
         def ready?
-          @adapter.string(namespace_key('.splits.ready')).to_i != -1
+          @adapter.string(namespace_key(READY_PREFIX)).to_i != -1
         end
 
         def not_ready!
-          @adapter.set_string(namespace_key('.splits.ready'), -1)
+          @adapter.set_string(namespace_key(READY_PREFIX), -1)
         end
 
         def ready!
-          @adapter.set_string(namespace_key('.splits.ready'), Time.now.utc.to_i)
+          @adapter.set_string(namespace_key(READY_PREFIX), Time.now.utc.to_i)
         end
 
         def clear
           @tt_cache.clear
 
           @adapter.clear(namespace_key)
+          initialize_keys
         end
 
         def kill(change_number, split_name, default_treatment)
@@ -139,6 +153,15 @@ module SplitIoClient
           split[:changeNumber] = change_number
 
           @adapter.set_string(namespace_key(".split.#{split_name}"), split.to_json)
+          @internal_events_queue.push(
+            SplitIoClient::Engine::Models::SdkInternalEventNotification.new(
+              SplitIoClient::Engine::Models::SdkInternalEvent::FLAG_KILLED_NOTIFICATION, 
+              SplitIoClient::Engine::Models::EventsMetadata.new(
+                SplitIoClient::Engine::Models::SdkEventType::FLAG_UPDATE,
+                [split_name]
+              )
+            )
+          )
         end
 
         def splits_count
@@ -167,6 +190,13 @@ module SplitIoClient
 
         private
 
+        def initialize_keys
+          unless @config.mode.equal?(:consumer)
+            @adapter.set_string(namespace_key(TILL_PREFIX), '-1')
+            @adapter.initialize_map(namespace_key('.segments.registered'))
+          end
+        end
+
         def add_feature_flag(split)
           return unless split[:name]
           existing_split = get_split(split[:name])

data/lib/splitclient-rb/cache/senders/impressions_formatter.rb

@@ -37,15 +37,28 @@ module SplitIoClient
 
         def current_impressions(feature_impressions)
           feature_impressions.map do |impression|
-            {
-              k: impression[:i][:k],
-              t: impression[:i][:t],
-              m: impression[:i][:m],
-              b: impression[:i][:b],
-              r: impression[:i][:r],
-              c: impression[:i][:c],
-              pt: impression[:i][:pt]
-            }
+            if impression[:i][:properties].nil?
+              impression = {
+                k: impression[:i][:k],
+                t: impression[:i][:t],
+                m: impression[:i][:m],
+                b: impression[:i][:b],
+                r: impression[:i][:r],
+                c: impression[:i][:c],
+                pt: impression[:i][:pt]
+              }
+            else
+              impression = {
+                k: impression[:i][:k],
+                t: impression[:i][:t],
+                m: impression[:i][:m],
+                b: impression[:i][:b],
+                r: impression[:i][:r],
+                c: impression[:i][:c],
+                pt: impression[:i][:pt],
+                properties: impression[:i][:properties].to_json.to_s
+              }
+            end
           end
         end
 
@@ -73,7 +86,8 @@ module SplitIoClient
           "#{impression[:i][:b]}:" \
           "#{impression[:i][:c]}:" \
           "#{impression[:i][:t]}:" \
-          "#{impression[:i][:pt]}"
+          "#{impression[:i][:pt]}" \
+          "#{impression[:i][:properties]}" \
         end
       end
     end

data/lib/splitclient-rb/cache/stores/localhost_split_builder.rb

@@ -22,7 +22,8 @@ module SplitIoClient
               seed: 2_089_907_429,
               defaultTreatment: 'control_treatment',
               configurations: build_configurations(treatments),
-              conditions: build_conditions(treatments)
+              conditions: build_conditions(treatments),
+              prerequisites: []
             }
           end
 

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

@@ -18,10 +18,11 @@ 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, events_manager)
       @api_key = sdk_key
       @splits_repository = repositories[:splits]
       @segments_repository = repositories[:segments]
+      @rule_based_segments_repository = repositories[:rule_based_segments]
       @impressions_repository = repositories[:impressions]
       @events_repository = repositories[:events]
       @status_manager = status_manager
@@ -31,26 +32,33 @@ module SplitIoClient
       @telemetry_evaluation_producer = telemetry_evaluation_producer
       @split_validator = split_validator
       @evaluator = evaluator
+      @fallback_treatment_calculator = fallback_treatment_calculator
+      @events_manager = events_manager
     end
 
     def get_treatment(
-        key, split_name, attributes = {}, split_data = nil, store_impressions = true,
+        key, split_name, attributes = {}, evaluation_options = nil, split_data = nil, store_impressions = nil,
         multiple = false, evaluator = nil
       )
-      result = treatment(key, split_name, attributes, split_data, store_impressions, GET_TREATMENT, multiple)
+      log_deprecated_warning(GET_TREATMENT, evaluator, 'evaluator')
+    
+      result = treatment(key, split_name, attributes, split_data, store_impressions, GET_TREATMENT, multiple, evaluation_options)
       return result.tap { |t| t.delete(:config) } if multiple
       result[:treatment]
     end
 
     def get_treatment_with_config(
-        key, split_name, attributes = {}, split_data = nil, store_impressions = true,
+        key, split_name, attributes = {}, evaluation_options = nil, split_data = nil, store_impressions = nil,
         multiple = false, evaluator = nil
       )
-      treatment(key, split_name, attributes, split_data, store_impressions, GET_TREATMENT_WITH_CONFIG, multiple)
+      log_deprecated_warning(GET_TREATMENT, evaluator, 'evaluator')
+      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 = {})
-      treatments = treatments(key, split_names, attributes)
+    def get_treatments(key, split_names, attributes = {}, evaluation_options = nil)
+      treatments = treatments(key, split_names, attributes, evaluation_options)
 
       return treatments if treatments.nil?
       keys = treatments.keys
@@ -58,51 +66,63 @@ module SplitIoClient
       Hash[keys.zip(treats)]
     end
 
-    def get_treatments_with_config(key, split_names, attributes = {})
-      treatments(key, split_names, attributes, GET_TREATMENTS_WITH_CONFIG)
+    def get_treatments_with_config(key, split_names, attributes = {}, evaluation_options = nil)
+      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 = {})
+    def get_treatments_by_flag_set(key, flag_set, attributes = {}, evaluation_options = nil)
       valid_flag_set = @split_validator.valid_flag_sets(GET_TREATMENTS_BY_FLAG_SET, [flag_set])
       split_names = @splits_repository.get_feature_flags_by_sets(valid_flag_set)
-      treatments = treatments(key, split_names, attributes, GET_TREATMENTS_BY_FLAG_SET)
+      treatments = treatments(key, split_names, attributes, evaluation_options, GET_TREATMENTS_BY_FLAG_SET)
       return treatments if treatments.nil?
       keys = treatments.keys
       treats = treatments.map { |_,t| t[:treatment]  }
       Hash[keys.zip(treats)]
     end
 
-    def get_treatments_by_flag_sets(key, flag_sets, attributes = {})
+    def get_treatments_by_flag_sets(key, flag_sets, attributes = {}, evaluation_options = nil)
       valid_flag_set = @split_validator.valid_flag_sets(GET_TREATMENTS_BY_FLAG_SETS, flag_sets)
       split_names = @splits_repository.get_feature_flags_by_sets(valid_flag_set)
-      treatments = treatments(key, split_names, attributes, GET_TREATMENTS_BY_FLAG_SETS)
+      treatments = treatments(key, split_names, attributes, evaluation_options, GET_TREATMENTS_BY_FLAG_SETS)
       return treatments if treatments.nil?
       keys = treatments.keys
       treats = treatments.map { |_,t| t[:treatment]  }
       Hash[keys.zip(treats)]
     end
 
-    def get_treatments_with_config_by_flag_set(key, flag_set, attributes = {})
+    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, 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 = {})
+    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, 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
       @config.logger.info('Split client shutdown started...') if @config.debug_enabled
       if !@config.cache_adapter.is_a?(SplitIoClient::Cache::Adapters::RedisAdapter) && @config.impressions_mode != :none &&
           (!@impressions_repository.empty? || !@events_repository.empty?)
-        @config.logger.debug("Impressions and/or Events cache is not empty")
+        @config.logger.debug("Impressions and/or Events cache is not empty") if @config.debug_enabled
         # Adding small delay to ensure sender threads are fully running
         sleep(0.1)
         if !@config.threads.key?(:impressions_sender) || !@config.threads.key?(:events_sender)
-          @config.logger.debug("Periodic data recording thread has not started yet, waiting for service startup.")
+          @config.logger.debug("Periodic data recording thread has not started yet, waiting for service startup.") if @config.debug_enabled
           @config.threads[:start_sdk].join(5) if @config.threads.key?(:start_sdk)
         end
       end
@@ -115,6 +135,7 @@ module SplitIoClient
 
       @splits_repository.clear
       @segments_repository.clear
+      @rule_based_segments_repository.clear
 
       SplitIoClient.load_factory_registry
       SplitIoClient.split_factory_registry.remove(@api_key)
@@ -133,10 +154,7 @@ module SplitIoClient
       if !properties.nil?
         properties, size = validate_properties(properties)
         properties_size += size
-        if (properties_size > EVENTS_SIZE_THRESHOLD)
-          @config.logger.error("The maximum size allowed for the properties is #{EVENTS_SIZE_THRESHOLD}. Current is #{properties_size}. Event not queued")
-          return false
-        end
+        return false unless check_properties_size(properties_size)
       end
 
       if ready? && !@config.localhost_mode && !@splits_repository.traffic_type_exists(traffic_type_name)
@@ -159,8 +177,24 @@ module SplitIoClient
       @status_manager.wait_until_ready(time) if @status_manager
     end
 
+    def register(sdk_event, handler)
+      @events_manager.register(sdk_event, handler)
+    end
+
+    def unregister(sdk_event, handler)
+      @events_manager.unregister(sdk_event)
+    end
+
     private
 
+    def check_properties_size(properties_size, msg = "Event not queued")
+      if (properties_size > EVENTS_SIZE_THRESHOLD)
+        @config.logger.error("The maximum size allowed for the properties is #{EVENTS_SIZE_THRESHOLD}. Current is #{properties_size}. #{msg}")
+        return false
+      end
+      return true
+    end
+
     def keys_from_key(key)
       case key
       when Hash
@@ -204,7 +238,7 @@ module SplitIoClient
       end
     end
 
-    def validate_properties(properties)
+    def validate_properties(properties, method = 'Event')
       properties_count = 0
       size = 0
 
@@ -223,11 +257,21 @@ module SplitIoClient
         end
       }
 
-      @config.logger.warn('Event has more than 300 properties. Some of them will be trimmed when processed') if properties_count > 300
+      @config.logger.warn("#{method} has more than 300 properties. Some of them will be trimmed when processed") if properties_count > 300
 
       return fixed_properties, size
     end
 
+    def validate_evaluation_options(evaluation_options)
+      if !evaluation_options.is_a?(SplitIoClient::Engine::Models::EvaluationOptions)
+        @config.logger.warn("Option #{evaluation_options} should be a EvaluationOptions type. Setting value to nil")
+        return nil, 0
+      end
+      evaluation_options.properties = evaluation_options.properties.transform_keys(&:to_sym)
+      evaluation_options.properties, size = validate_properties(evaluation_options.properties, 'Treatment')
+      return evaluation_options, size
+    end
+
     def valid_client
       if @destroyed
         @config.logger.error('Client has already been destroyed - no calls possible')
@@ -236,8 +280,7 @@ module SplitIoClient
       @config.valid_mode
     end
 
-    def treatments(key, feature_flag_names, attributes = {}, calling_method = 'get_treatments')
-      attributes = {} if attributes.nil?
+    def treatments(key, feature_flag_names, attributes = {}, evaluation_options = nil, calling_method = 'get_treatments')
       sanitized_feature_flag_names = sanitize_split_names(calling_method, feature_flag_names)
 
       if sanitized_feature_flag_names.nil?
@@ -253,11 +296,12 @@ module SplitIoClient
       bucketing_key, matching_key = keys_from_key(key)
       bucketing_key = bucketing_key ? bucketing_key.to_s : nil
       matching_key = matching_key ? matching_key.to_s : nil
+      attributes = parsed_attributes(attributes)
 
       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
@@ -266,8 +310,12 @@ module SplitIoClient
         impressions = []
         to_return = Hash.new
         sanitized_feature_flag_names.each {|name|
-          to_return[name.to_sym] = control_treatment_with_config
-          impressions << @impressions_manager.build_impression(matching_key, bucketing_key, name.to_sym, control_treatment_with_config.merge({ label: Engine::Models::Label::NOT_READY }), { attributes: attributes, time: nil })
+          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, 
+                                                               get_treatment_without_config(treatment_data), false, { attributes: attributes, time: nil },
+                                                               evaluation_options), :disabled => false }
         }
         @impressions_manager.track(impressions)
         return to_return
@@ -278,7 +326,6 @@ module SplitIoClient
         valid_feature_flag_names << feature_flag_name unless feature_flag_name.nil?
       }
       start = Time.now
-      impressions_total = []
 
       feature_flags = @splits_repository.splits(valid_feature_flag_names)
       treatments = Hash.new
@@ -287,19 +334,18 @@ 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)
-        impressions_total.concat(impressions) unless impressions.nil?
+        treatments_labels_change_numbers, impressions = evaluate_treatment(feature_flag, key, bucketing_key, matching_key, attributes, calling_method, false, evaluation_options)
         treatments[key] =
         {
           treatment: treatments_labels_change_numbers[:treatment],
           config: treatments_labels_change_numbers[:config]
         }
+        @impressions_manager.track(impressions) unless impressions.empty?
       end
       record_latency(calling_method, start)
-      @impressions_manager.track(impressions_total) unless impressions_total.empty?
 
       treatments.merge(invalid_treatments)
     end
@@ -313,14 +359,18 @@ module SplitIoClient
     # @param split_data [Hash] split data, when provided this method doesn't fetch splits_repository for the data
     # @param store_impressions [Boolean] impressions aren't stored if this flag is false
     # @return [String/Hash] Treatment as String or Hash of treatments in case of array of features
-    def treatment(key, feature_flag_name, attributes = {}, split_data = nil, store_impressions = true,
-                   calling_method = 'get_treatment', multiple = false)
+    def treatment(key, feature_flag_name, attributes = {}, split_data = nil, store_impressions = nil,
+                   calling_method = 'get_treatment', multiple = false, evaluation_options = nil)
+
+      log_deprecated_warning(calling_method, split_data, 'split_data')
+      log_deprecated_warning(calling_method, store_impressions, 'store_impressions')
+        
       impressions = []
       bucketing_key, matching_key = keys_from_key(key)
 
       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
@@ -332,54 +382,54 @@ module SplitIoClient
       end
 
       feature_flag = @splits_repository.get_split(feature_flag_name)
-      treatments, impressions = evaluate_treatment(feature_flag, feature_flag_name, bucketing_key, matching_key, attributes, calling_method, multiple)
+      treatments, impressions_decorator = evaluate_treatment(feature_flag, feature_flag_name, bucketing_key, matching_key, attributes, calling_method, multiple, evaluation_options)
 
-      @impressions_manager.track(impressions) unless impressions.nil?
+      @impressions_manager.track(impressions_decorator) unless impressions_decorator.nil?
       treatments
     end
 
-    def evaluate_treatment(feature_flag, feature_flag_name, bucketing_key, matching_key, attributes, calling_method, multiple = false)
-      impressions = []
+    def log_deprecated_warning(calling_method, parameter, parameter_name)
+        @config.logger.warn("#{calling_method}: detected #{parameter_name} parameter used, this parameter is deprecated and its value is ignored.") unless parameter.nil?
+    end
+
+    def evaluate_treatment(feature_flag, feature_flag_name, bucketing_key, matching_key, attributes, calling_method, multiple = false, evaluation_options = nil)
+      impressions_decorator = []
       begin
         start = Time.now
         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
-        treatment_data =
+
         if !feature_flag.nil? && ready?
-          @evaluator.evaluate_feature_flag(
+          treatment_data = @evaluator.evaluate_feature_flag(
             { bucketing_key: bucketing_key, matching_key: matching_key }, feature_flag, attributes
           )
+          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.")
-          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
 
+        evaluation_options, size = validate_evaluation_options(evaluation_options) unless evaluation_options.nil?
+        evaluation_options.properties = nil unless evaluation_options.nil? or check_properties_size((EVENT_AVERAGE_SIZE + size), "Properties are ignored")
+
         record_latency(calling_method, start)
-        impression = @impressions_manager.build_impression(matching_key, bucketing_key, feature_flag_name, treatment_data, { attributes: attributes, time: nil })
-        impressions << impression unless impression.nil?
+        impression_decorator = { :impression => @impressions_manager.build_impression(matching_key, bucketing_key, feature_flag_name, treatment_data, impressions_disabled, { attributes: attributes, time: nil }, evaluation_options), :disabled => impressions_disabled }
+        impressions_decorator << impression_decorator unless impression_decorator.nil?
       rescue StandardError => e
         @config.log_found_exception(__method__.to_s, e)
-
         record_exception(calling_method)
+        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 }
 
-        impression = @impressions_manager.build_impression(matching_key, bucketing_key, feature_flag_name, control_treatment, { attributes: attributes, time: nil })
-        impressions << impression unless impression.nil?
+        impressions_decorator << impression_decorator unless impression_decorator.nil?
 
-        return parsed_treatment(control_treatment.merge({ label: Engine::Models::Label::EXCEPTION }), multiple), impressions
+        return parsed_treatment(treatment_data, multiple), impressions_decorator
       end
-
-      return parsed_treatment(treatment_data, multiple), impressions
-    end
-
-    def control_treatment
-      { treatment: Engine::Models::Treatment::CONTROL }
-    end
-
-    def control_treatment_with_config
-      {:treatment => Engine::Models::Treatment::CONTROL, :config => nil}
+      return parsed_treatment(treatment_data, multiple), impressions_decorator
     end
 
     def variable_size(value)
@@ -442,5 +492,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/api/client.rb

@@ -20,6 +20,11 @@ module SplitIoClient
 
           @config.split_logger.log_if_debug("GET #{url} proxy: #{api_client.proxy}")
         end
+      
+      rescue Zlib::GzipFile::Error => e
+        @config.logger.warn("Incorrect formatted response exception: #{e}\n")
+        SplitIoClient::Engine::Models::SplitHttpResponse.new(400, '', true)
+
       rescue StandardError => e
         @config.logger.warn("#{e}\nURL:#{url}\nparams:#{params}")
         raise e, 'Split SDK failed to connect to backend to retrieve information', e.backtrace
@@ -50,6 +55,9 @@ module SplitIoClient
         raise e, 'Split SDK failed to connect to backend to post information', e.backtrace
       end
 
+      def sdk_url_overriden?
+        @config.sdk_url_overriden?
+      end
       private
 
       def api_client

data/lib/splitclient-rb/engine/api/faraday_middleware/gzip.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'faraday'
+require 'stringio'
 
 module SplitIoClient
   module FaradayMiddleware