splitclient-rb 6.4.1 → 7.0.0

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

@@ -4,14 +4,15 @@ module SplitIoClient
   module Cache
     module Senders
       class ImpressionsSender
-        def initialize(impressions_repository, api_key)
+        def initialize(impressions_repository, api_key, config)
           @impressions_repository = impressions_repository
           @api_key = api_key
+          @config = config
         end
 
         def call
-          if SplitIoClient.configuration.disable_impressions
-            SplitIoClient.configuration.logger.info('Disabling impressions service by config')
+          if @config.disable_impressions
+            @config.logger.info('Disabling impressions service by config')
             return
           end
 
@@ -31,19 +32,19 @@ module SplitIoClient
         private
 
         def impressions_thread
-          SplitIoClient.configuration.threads[:impressions_sender] = Thread.new do
+          @config.threads[:impressions_sender] = Thread.new do
             begin
-              SplitIoClient.configuration.logger.info('Starting impressions service')
+              @config.logger.info('Starting impressions service')
 
               loop do
                 post_impressions(false)
 
-                sleep(SplitIoClient::Utilities.randomize_interval(SplitIoClient.configuration.impressions_refresh_rate))
+                sleep(SplitIoClient::Utilities.randomize_interval(@config.impressions_refresh_rate))
               end
             rescue SplitIoClient::SDKShutdownException
               post_impressions
 
-              SplitIoClient.configuration.logger.info('Posting impressions due to shutdown')
+              @config.logger.info('Posting impressions due to shutdown')
             end
           end
         end
@@ -54,11 +55,11 @@ module SplitIoClient
 
           impressions_api.post(formatted_impressions)
         rescue StandardError => error
-          SplitIoClient.configuration.log_found_exception(__method__.to_s, error)
+          @config.log_found_exception(__method__.to_s, error)
         end
 
         def impressions_api
-          @impressions_api ||= SplitIoClient::Api::Impressions.new(@api_key)
+          @impressions_api ||= SplitIoClient::Api::Impressions.new(@api_key, @config)
         end
       end
     end

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

@@ -4,9 +4,10 @@ module SplitIoClient
   module Cache
     module Senders
       class MetricsSender
-        def initialize(metrics_repository, api_key)
+        def initialize(metrics_repository, api_key, config)
           @metrics_repository = metrics_repository
           @api_key = api_key
+          @config = config
         end
 
         def call
@@ -24,19 +25,19 @@ module SplitIoClient
         private
 
         def metrics_thread
-          SplitIoClient.configuration.threads[:metrics_sender] = Thread.new do
+          @config.threads[:metrics_sender] = Thread.new do
             begin
-              SplitIoClient.configuration.logger.info('Starting metrics service')
-              
+              @config.logger.info('Starting metrics service')
+
               loop do
                 post_metrics
 
-                sleep(SplitIoClient::Utilities.randomize_interval(SplitIoClient.configuration.metrics_refresh_rate))
+                sleep(SplitIoClient::Utilities.randomize_interval(@config.metrics_refresh_rate))
               end
             rescue SplitIoClient::SDKShutdownException
               post_metrics
 
-              SplitIoClient.configuration.logger.info('Posting metrics due to shutdown')
+              @config.logger.info('Posting metrics due to shutdown')
             end
           end
         end
@@ -44,11 +45,11 @@ module SplitIoClient
         def post_metrics
           metrics_api.post
         rescue StandardError => error
-          SplitIoClient.configuration.log_found_exception(__method__.to_s, error)
+          @config.log_found_exception(__method__.to_s, error)
         end
 
         def metrics_api
-          @metrics_api ||= SplitIoClient::Api::Metrics.new(@api_key, @metrics_repository)
+          @metrics_api ||= SplitIoClient::Api::Metrics.new(@api_key, @metrics_repository, @config)
         end
       end
     end

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

@@ -7,37 +7,46 @@ module SplitIoClient
       class SDKBlocker
         attr_reader :splits_repository
 
-        def initialize(splits_repository, segments_repository)
+        def initialize(splits_repository, segments_repository, config)
           @splits_repository = splits_repository
           @segments_repository = segments_repository
+          @config = config
 
-          @splits_repository.not_ready!
-          @segments_repository.not_ready!
+          if @config.standalone?
+            @splits_repository.not_ready!
+            @segments_repository.not_ready!
+          end
         end
 
         def splits_ready!
-          @splits_repository.ready!
+          if !ready?
+            @splits_repository.ready!
+            @config.logger.info('splits are ready')
+          end
         end
 
         def segments_ready!
-          @segments_repository.ready!
+          if !ready?
+            @segments_repository.ready!
+            @config.logger.info('segments are ready')
+          end
         end
 
-        def block
+        def block(time = nil)
           begin
-            Timeout::timeout(SplitIoClient.configuration.block_until_ready) do
+            timeout = time || @config.block_until_ready
+            Timeout::timeout(timeout) do
               sleep 0.1 until ready?
             end
           rescue Timeout::Error
             fail SDKBlockerTimeoutExpiredException, 'SDK start up timeout expired'
           end
 
-          SplitIoClient.configuration.logger.info('SplitIO SDK is ready')
-          SplitIoClient.configuration.threads[:split_store].run
-          SplitIoClient.configuration.threads[:segment_store].run
+          @config.logger.info('SplitIO SDK is ready')
         end
 
         def ready?
+          return true if @config.consumer?
           @splits_repository.ready? && @segments_repository.ready?
         end
       end

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

@@ -4,10 +4,11 @@ module SplitIoClient
       class SegmentStore
         attr_reader :segments_repository
 
-        def initialize(segments_repository, api_key, metrics, sdk_blocker = nil)
+        def initialize(segments_repository, api_key, metrics, config, sdk_blocker = nil)
           @segments_repository = segments_repository
           @api_key = api_key
           @metrics = metrics
+          @config = config
           @sdk_blocker = sdk_blocker
         end
 
@@ -28,42 +29,28 @@ module SplitIoClient
         private
 
         def segments_thread
-          SplitIoClient.configuration.threads[:segment_store] = Thread.new do
-            SplitIoClient.configuration.logger.info('Starting segments fetcher service')
-            SplitIoClient.configuration.block_until_ready > 0 ? blocked_store : unblocked_store
-          end
-        end
+          @config.threads[:segment_store] = Thread.new do
+            @config.logger.info('Starting segments fetcher service')
 
-        def blocked_store
-          loop do
-            next unless @sdk_blocker.splits_repository.ready?
+            loop do
+              next unless @sdk_blocker.splits_repository.ready?
 
-            store_segments
-            SplitIoClient.configuration.logger.debug("Segment names: #{@segments_repository.used_segment_names.to_a}") if SplitIoClient.configuration.debug_enabled
+              store_segments
+              @config.logger.debug("Segment names: #{@segments_repository.used_segment_names.to_a}") if @config.debug_enabled
 
-            unless @sdk_blocker.ready?
-              @sdk_blocker.segments_ready!
-              SplitIoClient.configuration.logger.info('segments are ready')
+              sleep_for = random_interval(@config.segments_refresh_rate)
+              @config.logger.debug("Segments store is sleeping for: #{sleep_for} seconds") if @config.debug_enabled
+              sleep(sleep_for)
             end
-
-            sleep_for = random_interval(SplitIoClient.configuration.segments_refresh_rate)
-            SplitIoClient.configuration.logger.debug("Segments store is sleeping for: #{sleep_for} seconds") if SplitIoClient.configuration.debug_enabled
-            sleep(sleep_for)
-          end
-        end
-
-        def unblocked_store
-          loop do
-            store_segments
-
-            sleep(random_interval(SplitIoClient.configuration.segments_refresh_rate))
           end
         end
 
         def store_segments
           segments_api.store_segments_by_names(@segments_repository.used_segment_names)
+
+          @sdk_blocker.segments_ready!
         rescue StandardError => error
-          SplitIoClient.configuration.log_found_exception(__method__.to_s, error)
+          @config.log_found_exception(__method__.to_s, error)
         end
 
         def random_interval(interval)
@@ -73,7 +60,7 @@ module SplitIoClient
         end
 
         def segments_api
-          @segments_api ||= SplitIoClient::Api::Segments.new(@api_key, @metrics, @segments_repository)
+          @segments_api ||= SplitIoClient::Api::Segments.new(@api_key, @metrics, @segments_repository, @config)
         end
       end
     end

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

@@ -4,10 +4,11 @@ module SplitIoClient
       class SplitStore
         attr_reader :splits_repository
 
-        def initialize(splits_repository, api_key, metrics, sdk_blocker = nil)
+        def initialize(splits_repository, api_key, metrics, config, sdk_blocker = nil)
           @splits_repository = splits_repository
           @api_key = api_key
           @metrics = metrics
+          @config = config
           @sdk_blocker = sdk_blocker
         end
 
@@ -28,12 +29,12 @@ module SplitIoClient
         private
 
         def splits_thread
-          SplitIoClient.configuration.threads[:split_store] = Thread.new do
-            SplitIoClient.configuration.logger.info('Starting splits fetcher service')
+          @config.threads[:split_store] = Thread.new do
+            @config.logger.info('Starting splits fetcher service')
             loop do
               store_splits
 
-              sleep(random_interval(SplitIoClient.configuration.features_refresh_rate))
+              sleep(random_interval(@config.features_refresh_rate))
             end
           end
         end
@@ -48,15 +49,12 @@ module SplitIoClient
           @splits_repository.set_segment_names(data[:segment_names])
           @splits_repository.set_change_number(data[:till])
 
-          SplitIoClient.configuration.logger.debug("segments seen(#{data[:segment_names].length}): #{data[:segment_names].to_a}") if SplitIoClient.configuration.debug_enabled
+          @config.logger.debug("segments seen(#{data[:segment_names].length}): #{data[:segment_names].to_a}") if @config.debug_enabled
 
-          if SplitIoClient.configuration.block_until_ready > 0 && !@sdk_blocker.ready?
-            @sdk_blocker.splits_ready!
-            SplitIoClient.configuration.logger.info('splits are ready')
-          end
+          @sdk_blocker.splits_ready!
 
         rescue StandardError => error
-          SplitIoClient.configuration.log_found_exception(__method__.to_s, error)
+          @config.log_found_exception(__method__.to_s, error)
         end
 
         def random_interval(interval)
@@ -71,7 +69,7 @@ module SplitIoClient
 
         def add_split_unless_archived(split)
           if Engine::Models::Split.archived?(split)
-            SplitIoClient.configuration.logger.debug("Seeing archived split #{split[:name]}") if SplitIoClient.configuration.debug_enabled
+            @config.logger.debug("Seeing archived split #{split[:name]}") if @config.debug_enabled
 
             remove_archived_split(split)
           else
@@ -80,13 +78,13 @@ module SplitIoClient
         end
 
         def remove_archived_split(split)
-          SplitIoClient.configuration.logger.debug("removing split from store(#{split})") if SplitIoClient.configuration.debug_enabled
+          @config.logger.debug("removing split from store(#{split})") if @config.debug_enabled
 
-          @splits_repository.remove_split(split[:name])
+          @splits_repository.remove_split(split)
         end
 
         def store_split(split)
-          SplitIoClient.configuration.logger.debug("storing split (#{split[:name]})") if SplitIoClient.configuration.debug_enabled
+          @config.logger.debug("storing split (#{split[:name]})") if @config.debug_enabled
 
           @splits_repository.add_split(split)
         end
@@ -94,7 +92,7 @@ module SplitIoClient
         private
 
         def splits_api
-          @splits_api ||= SplitIoClient::Api::Splits.new(@api_key, @metrics)
+          @splits_api ||= SplitIoClient::Api::Splits.new(@api_key, @metrics, @config)
         end
       end
     end

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

@@ -13,10 +13,11 @@ module SplitIoClient
     # @param splits_file [File] file that contains some splits
     #
     # @return [LocalhostSplitIoClient] split.io localhost client instance
-    def initialize(splits_file, reload_rate = nil)
+    def initialize(splits_file, config, reload_rate = nil)
       @localhost_mode = true
       @localhost_mode_features = []
       load_localhost_mode_features(splits_file, reload_rate)
+      @config = config
     end
 
     #
@@ -101,12 +102,12 @@ module SplitIoClient
       parsed_control_treatment = parsed_treatment(control_treatment)
 
       bucketing_key, matching_key = keys_from_key(key)
-      return parsed_control_treatment unless SplitIoClient::Validators.valid_get_treatment_parameters(calling_method, key, split_name, matching_key, bucketing_key, attributes)
+      return parsed_control_treatment unless @config.split_validator.valid_get_treatment_parameters(calling_method, key, split_name, matching_key, bucketing_key, attributes)
 
       sanitized_split_name = split_name.to_s.strip
 
       if split_name.to_s != sanitized_split_name
-        SplitIoClient.configuration.logger.warn("get_treatment: split_name #{split_name} has extra whitespace, trimming")
+        @config.logger.warn("get_treatment: split_name #{split_name} has extra whitespace, trimming")
         split_name = sanitized_split_name
       end
 
@@ -127,12 +128,12 @@ module SplitIoClient
     end
 
     def get_localhost_treatments(key, split_names, attributes = nil, calling_method = 'get_treatments')
-      return nil unless SplitIoClient::Validators.valid_get_treatments_parameters(calling_method, split_names)
+      return nil unless @config.split_validator.valid_get_treatments_parameters(calling_method, split_names)
 
       sanitized_split_names = sanitize_split_names(calling_method, split_names)
 
       if sanitized_split_names.empty?
-        SplitIoClient.configuration.logger.error("#{calling_method}: split_names must be a non-empty Array")
+        @config.logger.error("#{calling_method}: split_names must be a non-empty Array")
         return {}
       end
 
@@ -146,10 +147,10 @@ module SplitIoClient
         if (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 split_name, split_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 split_name, split_name must be a non-empty String or a Symbol")
           false
         end
       end

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

@@ -9,14 +9,16 @@ module SplitIoClient
     # @param api_key [String] the API 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)
+    def initialize(api_key, adapter = nil, splits_repository, segments_repository, impressions_repository, metrics_repository, events_repository, sdk_blocker, config)
+      @api_key = api_key
       @splits_repository = splits_repository
       @segments_repository = segments_repository
       @impressions_repository = impressions_repository
       @metrics_repository = metrics_repository
       @events_repository = events_repository
+      @sdk_blocker = sdk_blocker
       @destroyed = false
-
+      @config = config
       @adapter = adapter
     end
 
@@ -52,27 +54,30 @@ module SplitIoClient
     end
 
     def destroy
-      SplitIoClient.configuration.logger.info('Split client shutdown started...') if SplitIoClient.configuration.debug_enabled
+      @config.logger.info('Split client shutdown started...') if @config.debug_enabled
 
-      SplitIoClient.configuration.threads.select { |name, thread| name.to_s.end_with? 'sender' }.values.each do |thread|
+      @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
 
-      SplitIoClient.configuration.logger.info('Split client shutdown complete') if SplitIoClient.configuration.debug_enabled
-      SplitIoClient.configuration.valid_mode = false
+      SplitIoClient.load_factory_registry
+      SplitIoClient.split_factory_registry.remove(@api_key)
+
+      @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
 
-      return if SplitIoClient.configuration.disable_impressions || !store_impressions
+      return if @config.disable_impressions || !store_impressions
 
       @impressions_repository.add(
         matching_key,
@@ -85,7 +90,7 @@ module SplitIoClient
       route_impression(split_name, matching_key, bucketing_key, time, treatment, attributes)
 
     rescue StandardError => error
-      SplitIoClient.configuration.log_found_exception(__method__.to_s, error)
+      @config.log_found_exception(__method__.to_s, error)
     end
 
     def route_impression(split_name, matching_key, bucketing_key, time, treatment, attributes)
@@ -111,11 +116,11 @@ module SplitIoClient
     end
 
     def impression_router
-      @impression_router ||= SplitIoClient::ImpressionRouter.new
+      @impression_router ||= SplitIoClient::ImpressionRouter.new(@config)
     end
 
     def track(key, traffic_type_name, event_type, value = nil, properties = nil)
-      return false unless valid_client && SplitIoClient::Validators.valid_track_parameters(key, traffic_type_name, event_type, value, properties)
+      return false unless valid_client && @config.split_validator.valid_track_parameters(key, traffic_type_name, event_type, value, properties)
 
       properties_size = EVENT_AVERAGE_SIZE
 
@@ -123,16 +128,22 @@ module SplitIoClient
         properties, size = validate_properties(properties)
         properties_size += size
         if (properties_size > EVENTS_SIZE_THRESHOLD)
-          SplitIoClient.configuration.logger.error("The maximum size allowed for the properties is #{EVENTS_SIZE_THRESHOLD}. Current is #{properties_size}. Event not queued")
+          @config.logger.error("The maximum size allowed for the properties is #{EVENTS_SIZE_THRESHOLD}. Current is #{properties_size}. Event not queued")
           return false
         end
       end
 
+      if ready? && !@splits_repository.traffic_type_exists(traffic_type_name)
+        @config.logger.warn("track: Traffic Type #{traffic_type_name} " \
+          "does not have any corresponding Splits in this environment, make sure you're tracking " \
+          'your events to a valid traffic type defined in the Split console')
+      end
+
       begin
         @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)
         true
       rescue StandardError => error
-        SplitIoClient.configuration.log_found_exception(__method__.to_s, error)
+        @config.log_found_exception(__method__.to_s, error)
         false
       end
     end
@@ -167,15 +178,19 @@ module SplitIoClient
         if (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 split_name, split_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 split_name, split_name must be a non-empty String or a Symbol")
           false
         end
       end
     end
 
+    def block_until_ready(time = nil)
+      @sdk_blocker.block(time) if @sdk_blocker && !@sdk_blocker.ready?
+    end
+
     private
 
     def validate_properties(properties)
@@ -191,32 +206,32 @@ module SplitIoClient
             result[key] = value
             size += variable_size(value)
           else
-            SplitIoClient.configuration.logger.warn("Property #{key} is of invalid type. Setting value to nil")
+            @config.logger.warn("Property #{key} is of invalid type. Setting value to nil")
             result[key] = nil
           end
         end
       }
 
-      SplitIoClient.configuration.logger.warn('Event has more than 300 properties. Some of them will be trimmed when processed') if properties_count > 300
+      @config.logger.warn('Event has more than 300 properties. Some of them will be trimmed when processed') if properties_count > 300
 
       return fixed_properties, 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)
+      return nil unless @config.split_validator.valid_get_treatments_parameters(calling_method, split_names)
 
       sanitized_split_names = sanitize_split_names(calling_method, split_names)
 
       if sanitized_split_names.empty?
-        SplitIoClient.configuration.logger.error("#{calling_method}: split_names must be a non-empty Array")
+        @config.logger.error("#{calling_method}: split_names must be a non-empty Array")
         return {}
       end
 
@@ -224,7 +239,7 @@ module SplitIoClient
       bucketing_key = bucketing_key ? bucketing_key.to_s : nil
       matching_key = matching_key ? matching_key.to_s : nil
 
-      evaluator = Engine::Parser::Evaluator.new(@segments_repository, @splits_repository, true)
+      evaluator = Engine::Parser::Evaluator.new(@segments_repository, @splits_repository, @config, true)
       start = Time.now
       treatments_labels_change_numbers =
         @splits_repository.get_splits(sanitized_split_names).each_with_object({}) do |(name, data), memo|
@@ -234,7 +249,7 @@ module SplitIoClient
       # Measure
       @adapter.metrics.time('sdk.' + calling_method, latency)
 
-      unless SplitIoClient.configuration.disable_impressions
+      unless @config.disable_impressions
         time = (Time.now.to_f * 1000.0).to_i
         @impressions_repository.add_bulk(
           matching_key, bucketing_key, treatments_labels_change_numbers, time
@@ -269,38 +284,48 @@ module SplitIoClient
         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)
+      control_treatment = { treatment: Engine::Models::Treatment::CONTROL }
+
+      parsed_control_exception = parsed_treatment(multiple,
+        control_treatment.merge({ label: Engine::Models::Label::EXCEPTION }))
 
       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)
+      return parsed_control_exception unless valid_client && @config.split_validator.valid_get_treatment_parameters(calling_method, key, split_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
 
       if split_name.to_s != sanitized_split_name
-        SplitIoClient.configuration.logger.warn("#{calling_method}: split_name #{split_name} has extra whitespace, trimming")
+        @config.logger.warn("#{calling_method}: split_name #{split_name} has extra whitespace, trimming")
         split_name = sanitized_split_name
       end
 
-      evaluator ||= Engine::Parser::Evaluator.new(@segments_repository, @splits_repository)
+      evaluator ||= Engine::Parser::Evaluator.new(@segments_repository, @splits_repository, @config)
 
       begin
         start = Time.now
 
         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 split.nil? && ready?
+          @config.logger.warn("#{calling_method}: you passed #{split_name} that " \
+            'does not exist in this environment, please double check what Splits exist in the web console')
+
+          return parsed_treatment(multiple, control_treatment.merge({ label: Engine::Models::Label::NOT_FOUND }))
         end
 
         treatment_data =
+        if !split.nil? && ready?
           evaluator.call(
-          { bucketing_key: bucketing_key, matching_key: matching_key }, split, attributes
-        )
+            { bucketing_key: bucketing_key, matching_key: matching_key }, split, attributes
+          )
+        else
+          @config.logger.error("#{calling_method}: the SDK is not ready, the operation cannot be executed")
+
+          control_treatment.merge({ label: Engine::Models::Label::NOT_READY })
+        end
 
         latency = (Time.now - start) * 1000.0
         store_impression(split_name, matching_key, bucketing_key, treatment_data, store_impressions, attributes)
@@ -308,11 +333,11 @@ module SplitIoClient
         # Measure
         @adapter.metrics.time('sdk.' + calling_method, latency) unless multiple
       rescue StandardError => error
-        SplitIoClient.configuration.log_found_exception(__method__.to_s, error)
+        @config.log_found_exception(__method__.to_s, error)
 
         store_impression(split_name, matching_key, bucketing_key, control_treatment, store_impressions, attributes)
 
-        return parsed_control_treatment
+        return parsed_control_exception
       end
 
       parsed_treatment(multiple, treatment_data)
@@ -321,5 +346,10 @@ module SplitIoClient
     def variable_size(value)
       value.is_a?(String) ? value.length : 0
     end
+
+    def ready?
+      return @sdk_blocker.ready? if @sdk_blocker
+      true
+    end
   end
 end