splitclient-rb 6.3.0 → 8.11.0

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

@@ -1,126 +1,198 @@
 module SplitIoClient
+  EVENTS_SIZE_THRESHOLD = 32768
+  EVENT_AVERAGE_SIZE = 1024
+  GET_TREATMENT = 'get_treatment'
+  GET_TREATMENTS = 'get_treatments'
+  GET_TREATMENT_WITH_CONFIG = 'get_treatment_with_config'
+  GET_TREATMENTS_WITH_CONFIG = 'get_treatments_with_config'
+  GET_TREATMENTS_BY_FLAG_SET = 'get_treatments_by_flag_set'
+  GET_TREATMENTS_BY_FLAG_SETS = 'get_treatments_by_flag_sets'
+  GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET = 'get_treatments_with_config_by_flag_set'
+  GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS = 'get_treatments_with_config_by_flag_sets'
+  TRACK = 'track'
 
   class SplitClient
     #
     # Creates a new split client instance that connects to split.io API.
     #
-    # @param api_key [String] the API key for your split account
+    # @param sdk_key [String] the SDK key for your split account
     #
     # @return [SplitIoClient] split.io client instance
-    def initialize(api_key, adapter = nil, splits_repository, segments_repository, impressions_repository, metrics_repository, events_repository)
-      @splits_repository = splits_repository
-      @segments_repository = segments_repository
-      @impressions_repository = impressions_repository
-      @metrics_repository = metrics_repository
-      @events_repository = events_repository
+    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
       @destroyed = false
-
-      @adapter = adapter
+      @config = config
+      @impressions_manager = impressions_manager
+      @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
       )
-      treatment = treatment(key, split_name, attributes, split_data, store_impressions, multiple, evaluator)
-      if multiple
-         treatment.tap { |t| t.delete(:config) }
-      else
-        treatment[:treatment]
-      end
+      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, multiple, evaluator, 'get_treatment_with_config')
+      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
       treats = treatments.map { |_,t| t[:treatment]  }
       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 destroy
-      SplitIoClient.configuration.logger.info('Split client shutdown started...') if SplitIoClient.configuration.debug_enabled
+    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, 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 = {}, 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, 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 = {}, 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)
+      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)
+      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
 
-      SplitIoClient.configuration.threads.select { |name, thread| name.to_s.end_with? 'sender' }.values.each do |thread|
+    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") 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.") if @config.debug_enabled
+          @config.threads[:start_sdk].join(5) if @config.threads.key?(:start_sdk)
+        end
+      end
+      @config.threads.select { |name, thread| name.to_s.end_with? 'sender' }.values.each do |thread|
         thread.raise(SplitIoClient::SDKShutdownException)
         thread.join
       end
 
-      SplitIoClient.configuration.threads.values.each { |thread| Thread.kill(thread) }
+      @config.threads.values.each { |thread| Thread.kill(thread) }
 
       @splits_repository.clear
       @segments_repository.clear
+      @rule_based_segments_repository.clear
+
+      SplitIoClient.load_factory_registry
+      SplitIoClient.split_factory_registry.remove(@api_key)
 
-      SplitIoClient.configuration.logger.info('Split client shutdown complete') if SplitIoClient.configuration.debug_enabled
-      SplitIoClient.configuration.valid_mode = false
+      @config.logger.info('Split client shutdown complete') if @config.debug_enabled
+      @config.valid_mode = false
       @destroyed = true
     end
 
-    def store_impression(split_name, matching_key, bucketing_key, treatment, store_impressions, attributes)
-      time = (Time.now.to_f * 1000.0).to_i
+    def track(key, traffic_type_name, event_type, value = nil, properties = nil)
+      return false unless valid_client && @config.split_validator.valid_track_parameters(key, traffic_type_name, event_type, value, properties)
+
+      start = Time.now
+      properties_size = EVENT_AVERAGE_SIZE
 
-      return if SplitIoClient.configuration.disable_impressions || !store_impressions
+      if !properties.nil?
+        properties, size = validate_properties(properties)
+        properties_size += size
+        return false unless check_properties_size(properties_size)
+      end
 
-      @impressions_repository.add(
-        matching_key,
-        bucketing_key,
-        split_name,
-        treatment,
-        time
-      )
+      if ready? && !@config.localhost_mode && !@splits_repository.traffic_type_exists(traffic_type_name)
+        @config.logger.warn("track: Traffic Type #{traffic_type_name} " \
+          "does not have any corresponding feature flags in this environment, make sure you're tracking " \
+          'your events to a valid traffic type defined in the Split user interface')
+      end
 
-      route_impression(split_name, matching_key, bucketing_key, time, treatment, attributes)
+      @events_repository.add(key.to_s, traffic_type_name.downcase, event_type.to_s, (Time.now.to_f * 1000).to_i, value, properties, properties_size)
+      record_latency(TRACK, start)
+      true
+    rescue StandardError => e
+      @config.log_found_exception(__method__.to_s, e)
+      record_exception(TRACK)
 
-    rescue StandardError => error
-      SplitIoClient.configuration.log_found_exception(__method__.to_s, error)
+      false
     end
 
-    def route_impression(split_name, matching_key, bucketing_key, time, treatment, attributes)
-      impression_router.add(
-        split_name: split_name,
-        matching_key: matching_key,
-        bucketing_key: bucketing_key,
-        time: time,
-        treatment: treatment,
-        attributes: attributes
-      )
+    def block_until_ready(time = nil)
+      @status_manager.wait_until_ready(time) if @status_manager
     end
 
-    def route_impressions(split_names, matching_key, bucketing_key, time, treatments_labels_change_numbers, attributes)
-      impression_router.add_bulk(
-        split_names: split_names,
-        matching_key: matching_key,
-        bucketing_key: bucketing_key,
-        time: time,
-        treatments_labels_change_numbers: treatments_labels_change_numbers,
-        attributes: attributes
-      )
+    def register(sdk_event, handler)
+      @events_manager.register(sdk_event, handler)
     end
 
-    def impression_router
-      @impression_router ||= SplitIoClient::ImpressionRouter.new
+    def unregister(sdk_event, handler)
+      @events_manager.unregister(sdk_event)
     end
 
-    def track(key, traffic_type_name, event_type, value = nil)
-      return false unless valid_client && SplitIoClient::Validators.valid_track_parameters(key, traffic_type_name, event_type, value)
-      begin
-        @events_repository.add(key.to_s, traffic_type_name.downcase, event_type.to_s, (Time.now.to_f * 1000).to_i, value)
-        true
-      rescue StandardError => error
-        SplitIoClient.configuration.log_found_exception(__method__.to_s, error)
-        false
+    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)
@@ -132,7 +204,7 @@ module SplitIoClient
       end
     end
 
-    def parsed_treatment(multiple, treatment_data)
+    def parsed_treatment(treatment_data, multiple = false)
       if multiple
       {
         treatment: treatment_data[:treatment],
@@ -141,78 +213,141 @@ module SplitIoClient
         config: treatment_data[:config]
       }
       else
-        {
-          treatment: treatment_data[:treatment],
-          config: treatment_data[:config]
-        }
+      {
+        treatment: treatment_data[:treatment],
+        config: treatment_data[:config],
+      }
       end
     end
 
     def sanitize_split_names(calling_method, split_names)
+      return nil if !split_names.is_a?(Array)
+
       split_names.compact.uniq.select do |split_name|
-        if (split_name.is_a?(String) || split_name.is_a?(Symbol)) && !split_name.empty?
+        if split_name.nil?
+          false
+        elsif (split_name.is_a?(String) || split_name.is_a?(Symbol)) && !split_name.empty?
           true
         elsif split_name.is_a?(String) && split_name.empty?
-          SplitIoClient.configuration.logger.warn("#{calling_method}: you passed an empty split_name, split_name must be a non-empty String or a Symbol")
+          @config.logger.warn("#{calling_method}: you passed an empty feature_flag_name, flag name must be a non-empty String or a Symbol")
           false
         else
-          SplitIoClient.configuration.logger.warn("#{calling_method}: you passed an invalid split_name, split_name must be a non-empty String or a Symbol")
+          @config.logger.warn("#{calling_method}: you passed an invalid feature_flag_name, flag name must be a non-empty String or a Symbol")
           false
         end
       end
     end
 
-    private
+    def validate_properties(properties, method = 'Event')
+      properties_count = 0
+      size = 0
+
+      fixed_properties = properties.each_with_object({}) { |(key, value), result|
+
+        if(key.is_a?(String) || key.is_a?(Symbol))
+          properties_count += 1
+          size += variable_size(key)
+          if value.is_a?(String) || value.is_a?(Symbol) || value.is_a?(Numeric) || value.is_a?(TrueClass) || value.is_a?(FalseClass) || value.nil?
+            result[key] = value
+            size += variable_size(value)
+          else
+            @config.logger.warn("Property #{key} is of invalid type. Setting value to nil")
+            result[key] = nil
+          end
+        end
+      }
+
+      @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
-        SplitIoClient.configuration.logger.error('Client has already been destroyed - no calls possible')
+        @config.logger.error('Client has already been destroyed - no calls possible')
         return false
       end
-      SplitIoClient.configuration.valid_mode
+      @config.valid_mode
     end
 
-    def treatments(key, split_names, attributes = {}, calling_method = 'get_treatments')
-      return nil unless SplitIoClient::Validators.valid_get_treatments_parameters(calling_method, split_names)
+    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)
 
-      sanitized_split_names = sanitize_split_names(calling_method, split_names)
+      if sanitized_feature_flag_names.nil?
+        @config.logger.error("#{calling_method}: feature_flag_names must be a non-empty Array")
+        return nil
+      end
 
-      if sanitized_split_names.empty?
-        SplitIoClient.configuration.logger.error("#{calling_method}: split_names must be a non-empty Array")
+      if sanitized_feature_flag_names.empty?
+        @config.logger.error("#{calling_method}: feature_flag_names must be a non-empty Array")
         return {}
       end
 
       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)
 
-      evaluator = Engine::Parser::Evaluator.new(@segments_repository, @splits_repository, true)
-      start = Time.now
-      treatments_labels_change_numbers =
-        @splits_repository.get_splits(sanitized_split_names).each_with_object({}) do |(name, data), memo|
-          memo.merge!(name => treatment(key, name, attributes, data, false, true, evaluator))
-        end
-      latency = (Time.now - start) * 1000.0
-      # Measure
-      @adapter.metrics.time('sdk.' + calling_method, latency)
+      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] = check_fallback_treatment(name, '')
+        }
+        return to_return
+      end
 
-      unless SplitIoClient.configuration.disable_impressions
-        time = (Time.now.to_f * 1000.0).to_i
-        @impressions_repository.add_bulk(
-          matching_key, bucketing_key, treatments_labels_change_numbers, time
-        )
+      if !ready?
+        impressions = []
+        to_return = Hash.new
+        sanitized_feature_flag_names.each {|name|
+          treatment_data = check_fallback_treatment(name, Engine::Models::Label::NOT_READY)
+          to_return[name.to_sym] = treatment_data
 
-        route_impressions(sanitized_split_names, matching_key, bucketing_key, time, treatments_labels_change_numbers, attributes)
+          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
       end
 
-      split_names_keys = treatments_labels_change_numbers.keys
-      treatments = treatments_labels_change_numbers.values.map do |v|
+      valid_feature_flag_names = []
+      sanitized_feature_flag_names.each { |feature_flag_name|
+        valid_feature_flag_names << feature_flag_name unless feature_flag_name.nil?
+      }
+      start = Time.now
+
+      feature_flags = @splits_repository.splits(valid_feature_flag_names)
+      treatments = Hash.new
+      invalid_treatments = Hash.new
+      feature_flags.each do |key, feature_flag|
+        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] = 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)
+        treatments[key] =
         {
-          treatment: v[:treatment],
-          config: v[:config]
+          treatment: treatments_labels_change_numbers[:treatment],
+          config: treatments_labels_change_numbers[:config]
         }
+        @impressions_manager.track(impressions) unless impressions.empty?
       end
-      Hash[split_names_keys.zip(treatments)]
+      record_latency(calling_method, start)
+
+      treatments.merge(invalid_treatments)
     end
 
     #
@@ -223,61 +358,173 @@ module SplitIoClient
     # @param attributes [Hash] attributes to pass to the treatment class
     # @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
-    # @param multiple [Hash] internal flag to signal if method is called by get_treatments
-    # @param evaluator [Evaluator] Evaluator class instance, used to cache treatments
-    #
     # @return [String/Hash] Treatment as String or Hash of treatments in case of array of features
-    def treatment(
-        key, split_name, attributes = {}, split_data = nil, store_impressions = true,
-        multiple = false, evaluator = nil, calling_method = 'get_treatment'
-      )
-      control_treatment = { label: Engine::Models::Label::EXCEPTION, treatment: SplitIoClient::Engine::Models::Treatment::CONTROL, config: nil }
-      parsed_control_treatment = parsed_treatment(multiple, control_treatment)
+    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)
 
-      return parsed_control_treatment unless valid_client && SplitIoClient::Validators.valid_get_treatment_parameters(calling_method, key, split_name, matching_key, bucketing_key, attributes)
+      attributes = parsed_attributes(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
-      sanitized_split_name = split_name.to_s.strip
+      sanitized_feature_flag_name = feature_flag_name.to_s.strip
 
-      if split_name.to_s != sanitized_split_name
-        SplitIoClient.configuration.logger.warn("#{calling_method}: split_name #{split_name} has extra whitespace, trimming")
-        split_name = sanitized_split_name
+      if feature_flag_name.to_s != sanitized_feature_flag_name
+        @config.logger.warn("#{calling_method}: feature_flag_name #{feature_flag_name} has extra whitespace, trimming")
+        feature_flag_name = sanitized_feature_flag_name
       end
 
-      evaluator ||= Engine::Parser::Evaluator.new(@segments_repository, @splits_repository)
+      feature_flag = @splits_repository.get_split(feature_flag_name)
+      treatments, impressions_decorator = evaluate_treatment(feature_flag, feature_flag_name, bucketing_key, matching_key, attributes, calling_method, multiple, evaluation_options)
+
+      @impressions_manager.track(impressions_decorator) unless impressions_decorator.nil?
+      treatments
+    end
+
+    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 check_fallback_treatment(feature_flag_name, Engine::Models::Label::NOT_FOUND), nil
+        end
 
-        split = multiple ? split_data : @splits_repository.get_split(split_name)
-
-        if split.nil?
-          SplitIoClient.configuration.logger.warn("split_name: #{split_name} does not exist. Returning CONTROL")
-          return parsed_control_treatment
+        if !feature_flag.nil? && ready?
+          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.")
+          treatment_data = check_fallback_treatment(feature_flag_name, Engine::Models::Label::NOT_READY)
+          impressions_disabled = false
         end
 
-        treatment_data =
-          evaluator.call(
-          { bucketing_key: bucketing_key, matching_key: matching_key }, split, attributes
-        )
+        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_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 }
+
+        impressions_decorator << impression_decorator unless impression_decorator.nil?
+
+        return parsed_treatment(treatment_data, multiple), impressions_decorator
+      end
+      return parsed_treatment(treatment_data, multiple), impressions_decorator
+    end
+
+    def variable_size(value)
+      value.is_a?(String) ? value.length : 0
+    end
+
+    def ready?
+      return @status_manager.ready? if @status_manager
+      true
+    end
+
+    def parsed_attributes(attributes)
+      return attributes || attributes.to_h
+    end
+
+    def record_latency(method, start)
+      bucket = BinarySearchLatencyTracker.get_bucket((Time.now - start) * 1000.0)
+
+      case method
+      when GET_TREATMENT
+        @telemetry_evaluation_producer.record_latency(Telemetry::Domain::Constants::TREATMENT, bucket)
+      when GET_TREATMENTS
+        @telemetry_evaluation_producer.record_latency(Telemetry::Domain::Constants::TREATMENTS, bucket)
+      when GET_TREATMENT_WITH_CONFIG
+        @telemetry_evaluation_producer.record_latency(Telemetry::Domain::Constants::TREATMENT_WITH_CONFIG, bucket)
+      when GET_TREATMENTS_WITH_CONFIG
+        @telemetry_evaluation_producer.record_latency(Telemetry::Domain::Constants::TREATMENTS_WITH_CONFIG, bucket)
+      when GET_TREATMENTS_BY_FLAG_SET
+        @telemetry_evaluation_producer.record_latency(Telemetry::Domain::Constants::TREATMENTS_BY_FLAG_SET, bucket)
+      when GET_TREATMENTS_BY_FLAG_SETS
+        @telemetry_evaluation_producer.record_latency(Telemetry::Domain::Constants::TREATMENTS_BY_FLAG_SETS, bucket)
+      when GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET
+        @telemetry_evaluation_producer.record_latency(Telemetry::Domain::Constants::TREATMENTS_WITH_CONFIG_BY_FLAG_SET, bucket)
+      when GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS
+        @telemetry_evaluation_producer.record_latency(Telemetry::Domain::Constants::TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, bucket)
+      when TRACK
+        @telemetry_evaluation_producer.record_latency(Telemetry::Domain::Constants::TRACK, bucket)
+      end
+    end
 
-        latency = (Time.now - start) * 1000.0
-        store_impression(split_name, matching_key, bucketing_key, treatment_data, store_impressions, attributes)
+    def record_exception(method)
+      case method
+      when GET_TREATMENT
+        @telemetry_evaluation_producer.record_exception(Telemetry::Domain::Constants::TREATMENT)
+      when GET_TREATMENTS
+        @telemetry_evaluation_producer.record_exception(Telemetry::Domain::Constants::TREATMENTS)
+      when GET_TREATMENT_WITH_CONFIG
+        @telemetry_evaluation_producer.record_exception(Telemetry::Domain::Constants::TREATMENT_WITH_CONFIG)
+      when GET_TREATMENTS_WITH_CONFIG
+        @telemetry_evaluation_producer.record_exception(Telemetry::Domain::Constants::TREATMENTS_WITH_CONFIG)
+      when GET_TREATMENTS_BY_FLAG_SET
+        @telemetry_evaluation_producer.record_exception(Telemetry::Domain::Constants::TREATMENTS_BY_FLAG_SET)
+      when GET_TREATMENTS_BY_FLAG_SETS
+        @telemetry_evaluation_producer.record_exception(Telemetry::Domain::Constants::TREATMENTS_BY_FLAG_SETS)
+      when GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET
+        @telemetry_evaluation_producer.record_exception(Telemetry::Domain::Constants::TREATMENTS_WITH_CONFIG_BY_FLAG_SET)
+      when GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS
+        @telemetry_evaluation_producer.record_exception(Telemetry::Domain::Constants::TREATMENTS_WITH_CONFIG_BY_FLAG_SETS)
+      when TRACK
+        @telemetry_evaluation_producer.record_exception(Telemetry::Domain::Constants::TRACK)
+      end
+    end
 
-        # Measure
-        @adapter.metrics.time('sdk.' + calling_method, latency) unless multiple
-      rescue StandardError => error
-        SplitIoClient.configuration.log_found_exception(__method__.to_s, error)
+    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
 
-        store_impression(split_name, matching_key, bucketing_key, control_treatment, store_impressions, attributes)
+    def get_treatment_without_config(treatment)
+      { 
+        label: treatment[:label], 
+        treatment: treatment[:treatment], 
+      }        
+    end
 
-        return parsed_control_treatment
+    def get_fallback_config(fallback_treatment)
+      if fallback_treatment.config != nil
+          return fallback_treatment.config
       end
 
-      parsed_treatment(multiple, treatment_data)
+      return nil
     end
+
   end
 end