splitclient-rb 8.4.0 → 8.11.0

data/lib/splitclient-rb/sse/event_source/client.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: false
 
-require 'socketry'
+require 'socket'
+require 'openssl'
 require 'uri'
+require 'timeout'
 
 module SplitIoClient
   module SSE
@@ -36,26 +38,28 @@ module SplitIoClient
 
         def close(status = nil)
           unless connected?
-            @config.logger.error('SSEClient already disconected.') if @config.debug_enabled
+            @config.logger.debug('SSEClient already disconected.') if @config.debug_enabled
             return
           end
+          @config.logger.debug("Closing SSEClient socket") if @config.debug_enabled
 
-          @connected.make_false
-          @socket&.close
           push_status(status)
+          @connected.make_false
+          @socket.sync_close = true if @socket.is_a? OpenSSL::SSL::SSLSocket
+          @socket.close
+          @config.logger.debug("SSEClient socket state #{@socket.state}") if @socket.is_a? OpenSSL::SSL::SSLSocket && @config.debug_enabled
         rescue StandardError => e
           @config.logger.error("SSEClient close Error: #{e.inspect}")
         end
 
         def start(url)
           if connected?
-            @config.logger.debug('SSEClient already running.')
+            @config.logger.debug('SSEClient already running.') if @config.debug_enabled
             return true
           end
 
           @uri = URI(url)
           latch = Concurrent::CountDownLatch.new(1)
-
           connect_thread(latch)
 
           return false unless latch.wait(CONNECT_TIMEOUT)
@@ -74,42 +78,72 @@ module SplitIoClient
 
         def connect_thread(latch)
           @config.threads[:connect_stream] = Thread.new do
-            @config.logger.info('Starting connect_stream thread ...') if @config.debug_enabled
+            @config.logger.info('Starting connect_stream thread ...')
             new_status = connect_stream(latch)
             push_status(new_status)
-            @config.logger.info('connect_stream thread finished.') if @config.debug_enabled
+            @config.logger.info('connect_stream thread finished.')
           end
         end
 
         def connect_stream(latch)
           return Constants::PUSH_NONRETRYABLE_ERROR unless socket_write(latch)
-
           while connected? || @first_event.value
-            begin
-              partial_data = @socket.readpartial(10_000, timeout: @read_timeout)
-
-              read_first_event(partial_data, latch)
-
-              raise 'eof exception' if partial_data == :eof
-            rescue Errno::EBADF, IOError => e
-              @config.logger.error(e.inspect) if @config.debug_enabled
-              return nil
-            rescue StandardError => e
-              return nil if ENV['SPLITCLIENT_ENV'] == 'test'
-
-              @config.logger.error("Error reading partial data: #{e.inspect}") if @config.debug_enabled
-              return Constants::PUSH_RETRYABLE_ERROR
+            begin 
+              if IO.select([@socket], nil, nil, @read_timeout)
+                begin
+                  partial_data = @socket.readpartial(10_000)
+                  read_first_event(partial_data, latch)
+
+                  raise 'eof exception' if partial_data == :eof
+                rescue IO::WaitReadable => e
+                  @config.logger.debug("SSE client IO::WaitReadable transient error: #{e.inspect}") if @config.debug_enabled
+                  IO.select([@socket], nil, nil, @read_timeout)
+                  retry
+                rescue  Errno::EAGAIN => e
+                  @config.logger.debug("SSE client transient error: #{e.inspect}") if @config.debug_enabled
+                  IO.select([@socket], nil, nil, @read_timeout)
+                  retry
+                rescue Errno::ETIMEDOUT => e
+                  @config.logger.error("SSE read operation timed out!: #{e.inspect}")
+                  return Constants::PUSH_RETRYABLE_ERROR
+                rescue EOFError => e
+                  @config.logger.error("SSE read operation EOF Exception!: #{e.inspect}")
+                  raise 'eof exception'
+                rescue Errno::EBADF, IOError => e
+                  @config.logger.error("SSE read operation EBADF or IOError: #{e.inspect}")
+                  return Constants::PUSH_RETRYABLE_ERROR
+                rescue StandardError => e
+                  @config.logger.error("SSE read operation StandardError: #{e.inspect}")
+                  return nil if ENV['SPLITCLIENT_ENV'] == 'test'
+
+                  @config.logger.error("Error reading partial data: #{e.inspect}")
+                  return Constants::PUSH_RETRYABLE_ERROR
+                end
+              else
+                @config.logger.error("SSE read operation timed out, no data available.")
+                return Constants::PUSH_RETRYABLE_ERROR
+              end
+            rescue Errno::EBADF
+              @config.logger.debug("SSE socket is not connected (Errno::EBADF)") if @config.debug_enabled
+              break
+            rescue RuntimeError
+              raise 'eof exception'
+            rescue Exception => e
+              @config.logger.debug("SSE socket is not connected: #{e.inspect}") if @config.debug_enabled
+              break
             end
 
             process_data(partial_data)
           end
+          @config.logger.info("SSE read operation exited: #{connected?}")
+
           nil
         end
 
         def socket_write(latch)
           @first_event.make_true
           @socket = socket_connect
-          @socket.write(build_request(@uri))
+          @socket.puts(build_request(@uri))
           true
         rescue StandardError => e
           @config.logger.error("Error during connecting to #{@uri.host}. Error: #{e.inspect}")
@@ -121,7 +155,7 @@ module SplitIoClient
           return unless @first_event.value
 
           response_code = @event_parser.first_event(data)
-          @config.logger.debug("SSE client first event code: #{response_code}")
+          @config.logger.debug("SSE client first event code: #{response_code}") if @config.debug_enabled
 
           error_event = false
           events = @event_parser.parse(data)
@@ -130,6 +164,7 @@ module SplitIoClient
 
           if response_code == OK_CODE && !error_event
             @connected.make_true
+            @config.logger.debug("SSE client first event Connected is true") if @config.debug_enabled
             @telemetry_runtime_producer.record_streaming_event(Telemetry::Domain::Constants::SSE_CONNECTION_ESTABLISHED, nil)
             push_status(Constants::PUSH_CONNECTED)
           end
@@ -138,15 +173,37 @@ module SplitIoClient
         end
 
         def socket_connect
-          return Socketry::SSL::Socket.connect(@uri.host, @uri.port) if @uri.scheme.casecmp('https').zero?
+          tcp_socket = TCPSocket.new(@uri.host, @uri.port)
+          if @uri.scheme.casecmp('https').zero?
+            begin
+              ssl_context = OpenSSL::SSL::SSLContext.new
+              ssl_socket = OpenSSL::SSL::SSLSocket.new(tcp_socket, ssl_context)
+              ssl_socket.hostname = @uri.host
+
+              begin
+                ssl_socket.connect_nonblock
+              rescue IO::WaitReadable
+                IO.select([ssl_socket])
+                retry
+              rescue IO::WaitWritable
+                IO.select(nil, [ssl_socket])
+                retry
+              end
+              return ssl_socket
+
+            rescue Exception => e
+              @config.logger.error("socket connect error: #{e.inspect}")
+              return nil
+            end
+          end
 
-          Socketry::TCP::Socket.connect(@uri.host, @uri.port)
+          tcp_socket
         end
 
         def process_data(partial_data)
+          @config.logger.debug("Event partial data: #{partial_data}") if @config.debug_enabled
           return if partial_data.nil? || partial_data == KEEP_ALIVE_RESPONSE
 
-          @config.logger.debug("Event partial data: #{partial_data}") if @config.debug_enabled
           events = @event_parser.parse(partial_data)
           events.each { |event| process_event(event) }
         rescue StandardError => e
@@ -197,7 +254,7 @@ module SplitIoClient
         def push_status(status)
           return if status.nil?
           
-          @config.logger.debug("Pushing new sse status: #{status}")
+          @config.logger.debug("Pushing new sse status: #{status}") if @config.debug_enabled
           @status_queue.push(status)
         end
       end

data/lib/splitclient-rb/sse/event_source/event_parser.rb

@@ -29,14 +29,14 @@ module SplitIoClient
 
           events
         rescue StandardError => e
-          @config.logger.debug("Error during parsing a event: #{e.inspect}")
+          @config.logger.debug("Error during parsing a event: #{e.inspect}") if @config.debug_enabled
           []
         end
 
         def first_event(raw_data)
           raw_data.split("\n")[0].split(' ')[1].to_i
         rescue StandardError => e
-          @config.logger.debug("Error parsing first event: #{e.inspect}")
+          @config.logger.error("Error parsing first event: #{e.inspect}")
           BAD_REQUEST_CODE
         end
 

data/lib/splitclient-rb/sse/event_source/event_types.rb

@@ -8,6 +8,7 @@ module SplitIoClient
         SPLIT_KILL = 'SPLIT_KILL'
         SEGMENT_UPDATE = 'SEGMENT_UPDATE'
         CONTROL = 'CONTROL'
+        RB_SEGMENT_UPDATE = 'RB_SEGMENT_UPDATE'
       end
     end
   end

data/lib/splitclient-rb/sse/notification_manager_keeper.rb

@@ -42,12 +42,12 @@ module SplitIoClient
           @telemetry_runtime_producer.record_streaming_event(Telemetry::Domain::Constants::STREAMING_STATUS, DISABLED)
           push_status(Constants::PUSH_SUBSYSTEM_OFF)
         else
-          @config.logger.error("Incorrect event type: #{incoming_notification}")
+          @config.logger.error("Incorrect event type: #{incoming_notification}") if @config.debug_enabled
         end
       end
 
       def process_event_occupancy(channel, publishers)
-        @config.logger.debug("Processed occupancy event with #{publishers} publishers. Channel: #{channel}")
+        @config.logger.debug("Processed occupancy event with #{publishers} publishers. Channel: #{channel}") if @config.debug_enabled
 
         update_publishers(channel, publishers)
 
@@ -76,7 +76,7 @@ module SplitIoClient
       end
 
       def push_status(status)
-        @config.logger.debug("Pushing occupancy status: #{status}")
+        @config.logger.debug("Pushing occupancy status: #{status}") if @config.debug_enabled
         @status_queue.push(status)
       end
     end

data/lib/splitclient-rb/sse/notification_processor.rb

@@ -13,6 +13,8 @@ module SplitIoClient
         case incoming_notification.data['type']
         when SSE::EventSource::EventTypes::SPLIT_UPDATE
           process_split_update(incoming_notification)
+        when SSE::EventSource::EventTypes::RB_SEGMENT_UPDATE
+          process_split_update(incoming_notification)
         when SSE::EventSource::EventTypes::SPLIT_KILL
           process_split_kill(incoming_notification)
         when SSE::EventSource::EventTypes::SEGMENT_UPDATE
@@ -25,7 +27,7 @@ module SplitIoClient
       private
 
       def process_split_update(notification)
-        @config.logger.debug("SPLIT UPDATE notification received: #{notification}") if @config.debug_enabled
+        @config.logger.debug("#{notification.event_type} notification received: #{notification}") if @config.debug_enabled
         @splits_worker.add_to_queue(notification)
       end
 

data/lib/splitclient-rb/sse/workers/segments_worker.rb

@@ -14,13 +14,13 @@ module SplitIoClient
 
         def add_to_queue(change_number, segment_name)
           item = { change_number: change_number, segment_name: segment_name }
-          @config.logger.debug("SegmentsWorker add to queue #{item}")
+          @config.logger.debug("SegmentsWorker add to queue #{item}") if @config.debug_enabled
           @queue.push(item)
         end
 
         def start
           if @running.value
-            @config.logger.debug('segments worker already running.')
+            @config.logger.debug('segments worker already running.') if @config.debug_enabled
             return
           end
 
@@ -30,7 +30,7 @@ module SplitIoClient
 
         def stop
           unless @running.value
-            @config.logger.debug('segments worker not running.')
+            @config.logger.debug('segments worker not running.') if @config.debug_enabled
             return
           end
 
@@ -44,7 +44,7 @@ module SplitIoClient
           while (item = @queue.pop)
             segment_name = item[:segment_name]
             cn = item[:change_number]
-            @config.logger.debug("SegmentsWorker change_number dequeue #{segment_name}, #{cn}")
+            @config.logger.debug("SegmentsWorker change_number dequeue #{segment_name}, #{cn}") if @config.debug_enabled
 
             @synchronizer.fetch_segment(segment_name, cn)
           end

data/lib/splitclient-rb/sse/workers/splits_worker.rb

@@ -4,7 +4,8 @@ module SplitIoClient
   module SSE
     module Workers
       class SplitsWorker
-        def initialize(synchronizer, config, feature_flags_repository, telemetry_runtime_producer, segment_fetcher)
+        def initialize(synchronizer, config, feature_flags_repository, telemetry_runtime_producer,
+                       segment_fetcher, rule_based_segment_repository)
           @synchronizer = synchronizer
           @config = config
           @feature_flags_repository = feature_flags_repository
@@ -12,11 +13,12 @@ module SplitIoClient
           @running = Concurrent::AtomicBoolean.new(false)
           @telemetry_runtime_producer = telemetry_runtime_producer
           @segment_fetcher = segment_fetcher
+          @rule_based_segment_repository = rule_based_segment_repository
         end
 
         def start
           if @running.value
-            @config.logger.debug('feature_flags_worker already running.')
+            @config.logger.debug('feature_flags_worker already running.') if @config.debug_enabled
             return
           end
 
@@ -26,7 +28,7 @@ module SplitIoClient
 
         def stop
           unless @running.value
-            @config.logger.debug('feature_flags_worker not running.')
+            @config.logger.debug('feature_flags_worker not running.') if @config.debug_enabled
             return
           end
 
@@ -35,7 +37,7 @@ module SplitIoClient
         end
 
         def add_to_queue(notification)
-          @config.logger.debug("feature_flags_worker add to queue #{notification.data['changeNumber']}")
+          @config.logger.debug("feature_flags_worker add to queue #{notification.data['changeNumber']}") if @config.debug_enabled
           @queue.push(notification)
         end
 
@@ -50,11 +52,14 @@ module SplitIoClient
 
         def perform
           while (notification = @queue.pop)
-            @config.logger.debug("feature_flags_worker change_number dequeue #{notification.data['changeNumber']}")
+            @config.logger.debug("feature_flags_worker change_number dequeue #{notification.data['changeNumber']}") if @config.debug_enabled
             case notification.data['type']
             when SSE::EventSource::EventTypes::SPLIT_UPDATE
               success = update_feature_flag(notification)
-              @synchronizer.fetch_splits(notification.data['changeNumber']) unless success
+              @synchronizer.fetch_splits(notification.data['changeNumber'], 0) unless success
+            when SSE::EventSource::EventTypes::RB_SEGMENT_UPDATE
+              success = update_rule_based_segment(notification)
+              @synchronizer.fetch_splits(0, notification.data['changeNumber']) unless success
             when SSE::EventSource::EventTypes::SPLIT_KILL
               kill_feature_flag(notification)
             end
@@ -65,11 +70,12 @@ module SplitIoClient
           return true if @feature_flags_repository.get_change_number.to_i >= notification.data['changeNumber']
           return false unless !notification.data['d'].nil? && @feature_flags_repository.get_change_number == notification.data['pcn']
 
-          new_split = return_split_from_json(notification)
-          SplitIoClient::Helpers::RepositoryHelper.update_feature_flag_repository(@feature_flags_repository,
-                                                                                  [new_split],
-                                                                                  notification.data['changeNumber'], @config)
-          fetch_segments_if_not_exists(new_split)
+          new_split = update_feature_flag_repository(notification)
+          fetch_segments_if_not_exists(Helpers::Util.segment_names_by_object(new_split, 'IN_SEGMENT'), @feature_flags_repository)
+          if fetch_rule_based_segments_if_not_exists(Helpers::Util.segment_names_by_object(new_split, 'IN_RULE_BASED_SEGMENT'),
+                                                     notification.data['changeNumber'])
+            return true
+          end
 
           @telemetry_runtime_producer.record_updates_from_sse(Telemetry::Domain::Constants::SPLITS)
 
@@ -80,30 +86,63 @@ module SplitIoClient
           false
         end
 
+        def update_feature_flag_repository(notification)
+          new_split = return_object_from_json(notification)
+          SplitIoClient::Helpers::RepositoryHelper.update_feature_flag_repository(@feature_flags_repository, [new_split],
+                                                                                  notification.data['changeNumber'], @config, false)
+          new_split
+        end
+
+        def update_rule_based_segment(notification)
+          return true if @rule_based_segment_repository.get_change_number.to_i >= notification.data['changeNumber']
+          return false unless !notification.data['d'].nil? &&
+                              @rule_based_segment_repository.get_change_number == notification.data['pcn']
+
+          new_rb_segment = return_object_from_json(notification)
+          SplitIoClient::Helpers::RepositoryHelper.update_rule_based_segment_repository(@rule_based_segment_repository,
+                                                                                        [new_rb_segment],
+                                                                                        notification.data['changeNumber'], @config)
+          fetch_segments_if_not_exists(Helpers::Util.segment_names_in_rb_segment(new_rb_segment, 'IN_SEGMENT'),
+                                       @rule_based_segment_repository)
+
+          # @telemetry_runtime_producer.record_updates_from_sse(Telemetry::Domain::Constants::SPLITS)
+
+          true
+        rescue StandardError => e
+          @config.logger.debug("Failed to update Split: #{e.inspect}") if @config.debug_enabled
+
+          false
+        end
+
         def kill_feature_flag(notification)
           return if @feature_flags_repository.get_change_number.to_i > notification.data['changeNumber']
 
-          @config.logger.debug("feature_flags_worker kill #{notification.data['splitName']}, #{notification.data['changeNumber']}")
-          @feature_flags_repository.kill(
-            notification.data['changeNumber'],
-            notification.data['splitName'],
-            notification.data['defaultTreatment']
-          )
-          @synchronizer.fetch_splits(notification.data['changeNumber'])
+          @config.logger.debug("feature_flags_worker kill #{notification.data['splitName']}, #{notification.data['changeNumber']}") if @config.debug_enabled
+          @feature_flags_repository.kill(notification.data['changeNumber'],
+                                         notification.data['splitName'],
+                                         notification.data['defaultTreatment'])
+          @synchronizer.fetch_splits(notification.data['changeNumber'], 0)
         end
 
-        def return_split_from_json(notification)
-          split_json = Helpers::DecryptionHelper.get_encoded_definition(notification.data['c'], notification.data['d'])
-          JSON.parse(split_json, symbolize_names: true)
+        def return_object_from_json(notification)
+          object_json = Helpers::DecryptionHelper.get_encoded_definition(notification.data['c'], notification.data['d'])
+          JSON.parse(object_json, symbolize_names: true)
         end
 
-        def fetch_segments_if_not_exists(feature_flag)
-          segment_names = Helpers::Util.segment_names_by_feature_flag(feature_flag)
+        def fetch_segments_if_not_exists(segment_names, object_repository)
           return if segment_names.nil?
 
-          @feature_flags_repository.set_segment_names(segment_names)
+          object_repository.set_segment_names(segment_names)
           @segment_fetcher.fetch_segments_if_not_exists(segment_names)
         end
+
+        def fetch_rule_based_segments_if_not_exists(segment_names, change_number)
+          return false if segment_names.nil? || segment_names.empty? || @rule_based_segment_repository.contains?(segment_names.to_a)
+
+          @synchronizer.fetch_splits(0, change_number)
+
+          true
+        end
       end
     end
   end

data/lib/splitclient-rb/utilitites.rb

@@ -38,16 +38,12 @@ module SplitIoClient
       interval * random_factor
     end
 
-    def split_bulk_to_send(hash, divisions)
-      count = 0
-
-      hash.each_with_object([]) do |key_value, final|
-        final[count % divisions] ||= {}
-        final[count % divisions][key_value[0]] = key_value[1]
-        count += 1
-      end
-    rescue StandardError
-      []
+    def split_bulk_to_send(items, divisions)
+      to_return = []
+      items.to_a.each_slice(divisions) {|bulk|
+        to_return.push(bulk.to_set)
+      }
+      to_return
     end
   end  
 end

data/lib/splitclient-rb/validators.rb

@@ -4,6 +4,8 @@ module SplitIoClient
   class Validators
 
     Flagset_regex = /^[a-z0-9][_a-z0-9]{0,49}$/
+    Fallback_treatment_regex = /^[0-9]+[.a-zA-Z0-9_-]*$|^[a-zA-Z]+[a-zA-Z0-9_-]*$/
+    Fallback_treatment_size = 100
 
     def initialize(config)
       @config = config
@@ -55,8 +57,12 @@ module SplitIoClient
       end
       without_nil = Array.new
       flag_sets.each { |flag_set|
-        without_nil.push(flag_set) if !flag_set.nil?
-        log_nil("flag set", method) if flag_set.nil?
+        if !flag_set.nil?
+          without_nil.push(flag_set) 
+          next
+        end
+        
+        log_nil("flag set", method)
       }
       if without_nil.length() == 0
         log_invalid_flag_set_type(method)
@@ -68,7 +74,7 @@ module SplitIoClient
           log_invalid_flag_set_type(method)
         elsif flag_set.is_a?(String) && flag_set.empty?
           log_invalid_flag_set_type(method)
-        elsif !flag_set.empty? && string_match?(flag_set.strip.downcase, method)
+        elsif !flag_set.empty? && string_match?(flag_set.strip.downcase, method, Flagset_regex, :log_invalid_match)
           valid_flag_sets.add(flag_set.strip.downcase)
         else
           log_invalid_flag_set_type(method)
@@ -77,6 +83,46 @@ module SplitIoClient
       !valid_flag_sets.empty? ? valid_flag_sets.to_a.sort :  []
     end
 
+    def validate_fallback_treatment(method, fallback_treatment)
+      if !fallback_treatment.is_a? Engine::Models::FallbackTreatment
+          @config.logger.warn("#{method}: Fallback treatment instance should be FallbackTreatment, input is discarded")
+          return false
+      end
+
+      if !fallback_treatment.treatment.is_a? String
+          @config.logger.warn("#{method}: Fallback treatment value should be str type, input is discarded")
+          return false
+      end    
+
+      return false unless string_match?(fallback_treatment.treatment, method, Fallback_treatment_regex, :log_invalid_fallback_treatment)
+
+      if fallback_treatment.treatment.size > Fallback_treatment_size
+          @config.logger.warn("#{method}: Fallback treatment size should not exceed #{Fallback_treatment_size} characters")
+          return false
+      end
+      
+      true
+    end
+
+    def valid_split_name?(method, split_name)
+      if split_name.nil?
+        log_nil(:split_name, method)
+        return false
+      end
+
+      unless string?(split_name)
+        log_invalid_type(:split_name, method)
+        return false
+      end
+
+      if empty_string?(split_name)
+        log_empty_string(:split_name, method)
+        return false
+      end
+
+      true
+    end
+
     private
 
     def string?(value)
@@ -91,9 +137,9 @@ module SplitIoClient
       (value.is_a?(Numeric) && !value.to_f.nan?) || string?(value)
     end
 
-    def string_match?(value, method)
-      if Flagset_regex.match(value) == nil
-        log_invalid_match(value, method)
+    def string_match?(value, method, regex_exp, log_if_invalid)
+      if regex_exp.match(value) == nil
+        method(log_if_invalid).call(value, method)
         false
       else
         true
@@ -132,25 +178,6 @@ module SplitIoClient
       @config.logger.error("#{method}: #{key} is too long - must be #{@config.max_key_size} characters or less")
     end
 
-    def valid_split_name?(method, split_name)
-      if split_name.nil?
-        log_nil(:split_name, method)
-        return false
-      end
-
-      unless string?(split_name)
-        log_invalid_type(:split_name, method)
-        return false
-      end
-
-      if empty_string?(split_name)
-        log_empty_string(:split_name, method)
-        return false
-      end
-
-      true
-    end
-
     def valid_key?(method, key)
       if key.nil?
         log_nil(:key, method)
@@ -326,5 +353,9 @@ module SplitIoClient
 
       true
     end
+
+    def log_invalid_fallback_treatment(key, method)
+      @config.logger.warn("#{method}: Invalid treatment #{key}, Fallback treatment should match regex #{Fallback_treatment_regex}")
+    end
   end
 end

data/lib/splitclient-rb/version.rb

@@ -1,3 +1,3 @@
 module SplitIoClient
-  VERSION = '8.4.0'
+  VERSION = '8.11.0'
 end