splitclient-rb 6.4.1.pre.rc3-java → 7.0.0-java

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

data/lib/splitclient-rb/engine/api/client.rb

@@ -7,17 +7,21 @@ module SplitIoClient
     class Client
       RUBY_ENCODING = '1.9'.respond_to?(:force_encoding)
 
+      def initialize(config)
+        @config = config
+      end
+
       def get_api(url, api_key, params = {})
         api_client.get(url, params) do |req|
           req.headers = common_headers(api_key).merge('Accept-Encoding' => 'gzip')
 
-          req.options[:timeout] = SplitIoClient.configuration.read_timeout
-          req.options[:open_timeout] = SplitIoClient.configuration.connection_timeout
+          req.options[:timeout] = @config.read_timeout
+          req.options[:open_timeout] = @config.connection_timeout
 
-          SplitLogger.log_if_debug("GET #{url} proxy: #{api_client.proxy}")
+          @config.split_logger.log_if_debug("GET #{url} proxy: #{api_client.proxy}")
         end
       rescue StandardError => e
-        SplitIoClient.configuration.logger.warn("#{e}\nURL:#{url}\nparams:#{params}")
+        @config.logger.warn("#{e}\nURL:#{url}\nparams:#{params}")
         raise e, 'Split SDK failed to connect to backend to retrieve information', e.backtrace
       end
 
@@ -29,14 +33,14 @@ module SplitIoClient
 
           req.body = data.to_json
 
-          req.options[:timeout] = SplitIoClient.configuration.read_timeout
-          req.options[:open_timeout] = SplitIoClient.configuration.connection_timeout
+          req.options[:timeout] = @config.read_timeout
+          req.options[:open_timeout] = @config.connection_timeout
 
-          SplitLogger.log_if_transport("POST #{url} #{req.body}")
-          SplitLogger.log_if_debug("POST #{url}")
+          @config.split_logger.log_if_transport("POST #{url} #{req.body}")
+          @config.split_logger.log_if_debug("POST #{url}")
         end
       rescue StandardError => e
-        SplitIoClient.configuration.logger.warn("#{e}\nURL:#{url}\ndata:#{data}\nparams:#{params}")
+        @config.logger.warn("#{e}\nURL:#{url}\ndata:#{data}\nparams:#{params}")
         raise e, 'Split SDK failed to connect to backend to post information', e.backtrace
       end
 
@@ -73,15 +77,15 @@ module SplitIoClient
       def common_headers(api_key)
         {
           'Authorization' => "Bearer #{api_key}",
-          'SplitSDKVersion' => "#{SplitIoClient.configuration.language}-#{SplitIoClient.configuration.version}",
-          'SplitSDKMachineName' => SplitIoClient.configuration.machine_name,
-          'SplitSDKMachineIP' => SplitIoClient.configuration.machine_ip,
+          'SplitSDKVersion' => "#{@config.language}-#{@config.version}",
+          'SplitSDKMachineName' => @config.machine_name,
+          'SplitSDKMachineIP' => @config.machine_ip,
           'Referer' => referer
         }
       end
 
       def referer
-        result = "#{SplitIoClient.configuration.language}-#{SplitIoClient.configuration.version}"
+        result = "#{@config.language}-#{@config.version}"
 
         result = "#{result}::#{SplitIoClient::SplitConfig.machine_hostname}" unless SplitIoClient::SplitConfig.machine_hostname == 'localhost'
 

data/lib/splitclient-rb/engine/api/events.rb

@@ -3,19 +3,20 @@
 module SplitIoClient
   module Api
     class Events < Client
-      def initialize(api_key)
+      def initialize(api_key, config)
+        super(config)
         @api_key = api_key
       end
 
       def post(events)
         if events.empty?
-          SplitLogger.log_if_debug('No events to report')
+          @config.split_logger.log_if_debug('No events to report')
           return
         end
 
-        events.each_slice(SplitIoClient.configuration.events_queue_size) do |events_slice|
+        events.each_slice(@config.events_queue_size) do |events_slice|
           response = post_api(
-            "#{SplitIoClient.configuration.events_uri}/events/bulk",
+            "#{@config.events_uri}/events/bulk",
             @api_key,
             events_slice.map { |event| formatted_event(event[:e]) },
             'SplitSDKMachineIP' => events_slice[0][:m][:i],
@@ -24,9 +25,9 @@ module SplitIoClient
           )
 
           if response.success?
-            SplitLogger.log_if_debug("Events reported: #{events_slice.size}")
+            @config.split_logger.log_if_debug("Events reported: #{events_slice.size}")
           else
-            SplitLogger.log_error("Unexpected status code while posting events: #{response.status}." \
+            @config.logger.error("Unexpected status code while posting events: #{response.status}." \
             ' - Check your API key and base URI')
             raise 'Split SDK failed to connect to backend to post events'
           end

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

@@ -3,23 +3,24 @@
 module SplitIoClient
   module Api
     class Impressions < Client
-      def initialize(api_key)
+      def initialize(api_key, config)
         @api_key = api_key
+        @config = config
       end
 
       def post(impressions)
         if impressions.empty?
-          SplitLogger.log_if_debug('No impressions to report')
+          @config.split_logger.log_if_debug('No impressions to report')
           return
         end
 
         impressions_by_ip(impressions).each do |ip, impressions_ip|
-          response = post_api("#{SplitIoClient.configuration.events_uri}/testImpressions/bulk", @api_key, impressions_ip, 'SplitSDKMachineIP' => ip)
+          response = post_api("#{@config.events_uri}/testImpressions/bulk", @api_key, impressions_ip, 'SplitSDKMachineIP' => ip)
 
           if response.success?
-            SplitLogger.log_if_debug("Impressions reported: #{total_impressions(impressions)}")
+            @config.split_logger.log_if_debug("Impressions reported: #{total_impressions(impressions)}")
           else
-            SplitLogger.log_error("Unexpected status code while posting impressions: #{response.status}." \
+            @config.logger.error("Unexpected status code while posting impressions: #{response.status}." \
             ' - Check your API key and base URI')
             raise 'Split SDK failed to connect to backend to post impressions'
           end