splitclient-rb 1.0.2.wip → 8.11.1.pre.rc1-java

data/lib/splitclient-rb/split_factory.rb

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  class SplitFactory
+    ROOT_PROCESS_ID = Process.pid
+    SINGLETON_WARN = 'We recommend keeping only one instance of the factory at all times (Singleton pattern) and reusing it throughout your application'
+    LOCALHOST_API_KEY = 'localhost'
+
+    include SplitIoClient::Cache::Repositories
+    include SplitIoClient::Cache::Stores
+    include SplitIoClient::Cache::Senders
+    include SplitIoClient::Cache::Fetchers
+
+    attr_reader :adapter, :client, :manager, :config
+
+    def initialize(api_key, config_hash = {})
+      at_exit do
+        unless ENV['SPLITCLIENT_ENV'] == 'test'
+          if (Process.pid == ROOT_PROCESS_ID)
+            @config.logger.info('Split SDK shutdown started...')
+            @client.destroy if @client
+            stop!
+            @config.logger.info('Split SDK shutdown complete')
+          end
+        end
+      end
+
+      @api_key = api_key
+
+      store_flag_sets = config_hash.key?(:flag_sets_filter) ? config_hash[:flag_sets_filter] : []
+      store_flag_sets = [] if !store_flag_sets.is_a?(Array)
+      flag_sets_count = 0
+      flag_sets_invalid = 0
+
+      @config = SplitConfig.new(config_hash.merge(localhost_mode: @api_key == LOCALHOST_API_KEY ))
+
+      if config_hash.key?(:flag_sets_filter)
+        flag_sets_count = store_flag_sets.length()
+        flag_sets_invalid = flag_sets_count - @config.flag_sets_filter.length()
+      end
+
+      raise 'Invalid SDK mode' unless valid_mode
+
+      validate_api_key
+
+      register_factory
+
+      build_events_manager
+      build_telemetry_components
+      build_flag_sets_filter
+      build_repositories
+      build_telemetry_synchronizer(flag_sets_count, flag_sets_invalid)
+      build_impressions_sender_adapter
+      build_unique_keys_tracker
+      build_impressions_components
+
+      @status_manager = Engine::StatusManager.new(@config, @internal_events_queue)
+      @split_validator = SplitIoClient::Validators.new(@config)
+      @evaluator = Engine::Parser::Evaluator.new(@segments_repository, @splits_repository, @rule_based_segment_repository, @config)
+
+      start!
+      fallback_treatment_calculator = SplitIoClient::Engine::FallbackTreatmentCalculator.new(@config.fallback_treatments_configuration) 
+      @client = SplitClient.new(@api_key, repositories, @status_manager, @config, @impressions_manager, @evaluation_producer, @evaluator, @split_validator, fallback_treatment_calculator, @events_manager)
+      @manager = SplitManager.new(@splits_repository, @status_manager, @config)
+    end
+
+    def start!
+      return start_localhost_components if @config.localhost_mode
+
+      if @config.consumer?
+        build_synchronizer
+        build_sync_manager
+
+        @sync_manager.start_consumer
+        return
+      end
+
+      build_fetchers
+      build_synchronizer
+      build_streaming_components
+      build_sync_manager
+
+      @sync_manager.start
+    end
+
+    def stop!
+      @config.threads.each { |_, t| t.exit }
+    end
+
+    def register_factory
+      SplitIoClient.load_factory_registry
+
+      number_of_factories = SplitIoClient.split_factory_registry.number_of_factories_for(@api_key)
+
+      if(number_of_factories > 0)
+        @config.logger.warn("Factory instantiation: You already have #{number_of_factories} factories with this API Key. #{SINGLETON_WARN}")
+      elsif(SplitIoClient.split_factory_registry.other_factories)
+        @config.logger.warn('Factory instantiation: You already have an instance of the Split factory.' \
+          " Make sure you definitely want this additional instance. #{SINGLETON_WARN}")
+      end
+
+      SplitIoClient.split_factory_registry.add(@api_key)
+    end
+
+    def valid_mode
+      valid_startup_mode = false
+      case @config.mode
+      when :consumer
+        if @config.cache_adapter.is_a? SplitIoClient::Cache::Adapters::RedisAdapter
+          if !@config.localhost_mode
+            valid_startup_mode = true
+          else
+            @config.logger.error('Localhost mode cannot be used with Redis. ' \
+              'Use standalone mode and Memory adapter instead.')
+          end
+        else
+          @config.logger.error('Consumer mode cannot be used with Memory adapter. ' \
+            'Use Redis adapter instead.')
+        end
+      when :standalone
+        if @config.cache_adapter.is_a? SplitIoClient::Cache::Adapters::MemoryAdapter
+          valid_startup_mode = true
+        else
+          @config.logger.error('Standalone mode cannot be used with Redis adapter. ' \
+            'Use Memory adapter instead.')
+        end
+      when :producer
+        @config.logger.error('Producer mode is no longer supported. Use Split Synchronizer. ' \
+          'See: https://github.com/splitio/split-synchronizer')
+      else
+        @config.logger.error('Invalid SDK mode selected. ' \
+          "Valid modes are 'standalone with memory adapter' and 'consumer with redis adapter'")
+      end
+
+      valid_startup_mode
+    end
+
+    alias resume! start!
+
+    private
+
+    def validate_api_key
+      if(@api_key.nil?)
+        @config.logger.error('Factory Instantiation: you passed a nil api_key, api_key must be a non-empty String')
+        @config.valid_mode =  false
+      elsif (@api_key.empty?)
+        @config.logger.error('Factory Instantiation: you passed and empty api_key, api_key must be a non-empty String')
+        @config.valid_mode =  false
+      end
+    end
+
+    def repositories
+      {
+        splits: @splits_repository,
+        segments: @segments_repository,
+        impressions: @impressions_repository,
+        events: @events_repository,
+        rule_based_segments: @rule_based_segment_repository
+      }
+    end
+
+    def start_localhost_components
+      LocalhostSplitStore.new(@splits_repository, @config, @status_manager).call
+
+      # Starts thread which loops constantly and cleans up repositories to avoid memory issues in localhost mode
+      LocalhostRepoCleaner.new(@impressions_repository, @events_repository, @config).call
+    end
+
+    def build_telemetry_components
+      @evaluation_consumer = Telemetry::EvaluationConsumer.new(@config)
+      @evaluation_producer = Telemetry::EvaluationProducer.new(@config)
+
+      @init_consumer = Telemetry::InitConsumer.new(@config)
+      @init_producer = Telemetry::InitProducer.new(@config)
+
+      @runtime_consumer = Telemetry::RuntimeConsumer.new(@config)
+      @runtime_producer = Telemetry::RuntimeProducer.new(@config)
+
+      @telemetry_consumers = { init: @init_consumer, evaluation: @evaluation_consumer, runtime: @runtime_consumer }
+    end
+
+    def build_fetchers
+      @split_fetcher = SplitFetcher.new(@splits_repository, @rule_based_segment_repository, @api_key, @config, @runtime_producer)
+      @segment_fetcher = SegmentFetcher.new(@segments_repository, @api_key, @config, @runtime_producer)
+    end
+
+    def build_synchronizer
+      params = {
+        split_fetcher: @split_fetcher,
+        segment_fetcher: @segment_fetcher,
+        imp_counter: @impression_counter,
+        telemetry_synchronizer: @telemetry_synchronizer,
+        impressions_sender_adapter: @impressions_sender_adapter,
+        impressions_api: @impressions_api,
+        unique_keys_tracker: @unique_keys_tracker
+      }
+
+      @synchronizer = Engine::Synchronizer.new(repositories, @config, params)
+    end
+
+    def build_streaming_components
+      @push_status_queue = Queue.new
+      splits_worker = SSE::Workers::SplitsWorker.new(@synchronizer, @config, @splits_repository, @runtime_producer, @segment_fetcher, @rule_based_segment_repository)
+      segments_worker = SSE::Workers::SegmentsWorker.new(@synchronizer, @config, @segments_repository)
+      notification_manager_keeper = SSE::NotificationManagerKeeper.new(@config, @runtime_producer, @push_status_queue)
+      notification_processor = SSE::NotificationProcessor.new(@config, splits_worker, segments_worker)
+      event_parser = SSE::EventSource::EventParser.new(config)
+      sse_client = SSE::EventSource::Client.new(@config, @api_key, @runtime_producer, event_parser, notification_manager_keeper, notification_processor, @push_status_queue)
+      @sse_handler = SSE::SSEHandler.new(@config, splits_worker, segments_worker, sse_client)
+      @push_manager = Engine::PushManager.new(@config, @sse_handler, @api_key, @runtime_producer)
+    end
+
+    def build_sync_manager
+      @sync_manager = Engine::SyncManager.new(@config, @synchronizer, @runtime_producer, @telemetry_synchronizer, @status_manager, @sse_handler, @push_manager, @push_status_queue)
+    end
+
+    def build_repositories
+      if @config.cache_adapter.is_a? SplitIoClient::Cache::Adapters::RedisAdapter
+        @flag_sets_repository = SplitIoClient::Cache::Repositories::RedisFlagSetsRepository.new(@config)
+      else
+        @flag_sets_repository = SplitIoClient::Cache::Repositories::MemoryFlagSetsRepository.new(@config.flag_sets_filter)
+      end
+      @splits_repository = SplitsRepository.new(@config, @flag_sets_repository, @flag_sets_filter, @internal_events_queue)
+      @segments_repository = SegmentsRepository.new(@config, @internal_events_queue)
+      @rule_based_segment_repository = RuleBasedSegmentsRepository.new(@config, @internal_events_queue)
+      @impressions_repository = ImpressionsRepository.new(@config)
+      @events_repository = EventsRepository.new(@config, @api_key, @runtime_producer)
+    end
+
+    def build_telemetry_synchronizer(flag_sets, flag_sets_invalid)
+      @telemetry_api = Api::TelemetryApi.new(@config, @api_key, @runtime_producer)
+      @telemetry_synchronizer = Telemetry::Synchronizer.new(@config, @telemetry_consumers, @init_producer, repositories, @telemetry_api, flag_sets, flag_sets_invalid)
+    end
+
+    def build_unique_keys_tracker
+      bf = Cache::Filter::BloomFilter.new(30_000_000)
+      filter_adapter = Cache::Filter::FilterAdapter.new(@config, bf)
+      cache = Concurrent::Hash.new
+      @unique_keys_tracker = Engine::Impressions::UniqueKeysTracker.new(@config, filter_adapter, @impressions_sender_adapter, cache)
+    end
+
+    def build_impressions_observer
+      if (@config.cache_adapter == :redis && @config.impressions_mode != :optimized)
+        @impression_observer = Observers::NoopImpressionObserver.new
+      else
+        @impression_observer = Observers::ImpressionObserver.new
+      end
+    end
+
+    def build_impression_counter
+      @impression_counter = Engine::Common::ImpressionCounter.new
+    end
+
+    def build_impressions_sender_adapter
+      @impressions_api = Api::Impressions.new(@api_key, @config, @runtime_producer)
+      @impressions_sender_adapter = Cache::Senders::ImpressionsSenderAdapter.new(@config, @telemetry_api, @impressions_api)
+    end
+
+    def build_impressions_components
+      build_impressions_observer
+      build_impression_counter
+
+      @impressions_manager = Engine::Common::ImpressionManager.new(@config, @impressions_repository, @impression_counter, @runtime_producer, @impression_observer, @unique_keys_tracker)
+    end
+
+    def build_flag_sets_filter
+      @flag_sets_filter = SplitIoClient::Cache::Filter::FlagSetsFilter.new(@config.flag_sets_filter)
+    end
+
+    def build_events_manager
+      @events_manager = Engine::Events::EventsManager.new(Engine::Events::EventsManagerConfig.new, 
+                            Engine::Events::EventsDelivery.new(@config), 
+                            @config)
+      if @config.consumer?
+        @internal_events_queue = Engine::Events::NoOpEventsQueue.new
+        return
+      end
+
+      @internal_events_queue = Queue.new
+      @events_task = Engine::Events::EventsTask.new(@events_manager.method(:notify_internal_event), @internal_events_queue, @config)
+      @events_task.start
+    end
+  end
+end

data/lib/splitclient-rb/split_factory_builder.rb

@@ -0,0 +1,7 @@
+module SplitIoClient
+  class SplitFactoryBuilder
+    def self.build(api_key, config = {})
+      SplitFactory.new(api_key, config)
+    end
+  end
+end

data/lib/splitclient-rb/split_factory_registry.rb

@@ -0,0 +1,63 @@
+require 'logger'
+require 'socket'
+
+module SplitIoClient
+
+  class << self
+      attr_accessor :split_factory_registry
+  end
+
+  def self.load_factory_registry
+    self.split_factory_registry ||= SplitFactoryRegistry.new
+  end
+
+  #
+  # This class manages configuration options for the split client library.
+  # If not custom configuration is required the default configuration values will be used
+  #
+  class SplitFactoryRegistry
+
+    attr_accessor :api_keys_hash
+
+    def initialize
+      @api_keys_hash = Hash.new
+    end
+
+    def add(api_key)
+      return unless api_key
+
+      @api_keys_hash[api_key] = 0 unless @api_keys_hash[api_key]
+      @api_keys_hash[api_key] += 1
+    end
+
+    def remove(api_key)
+      return unless api_key
+
+      @api_keys_hash[api_key] -= 1 if @api_keys_hash[api_key]
+      @api_keys_hash.delete(api_key) if @api_keys_hash[api_key] == 0
+    end
+
+    def number_of_factories_for(api_key)
+      return 0 unless api_key
+      return 0 unless @api_keys_hash.key?(api_key)
+
+      @api_keys_hash[api_key]
+    end
+
+    def other_factories
+      return !@api_keys_hash.empty?
+    end
+
+    def active_factories
+      @api_keys_hash.length
+    end
+
+    def redundant_active_factories
+      to_return = 0
+
+      @api_keys_hash.each { |key| to_return += (key[1]-1) }
+
+      to_return
+    end
+  end
+end

data/lib/splitclient-rb/split_logger.rb

@@ -0,0 +1,23 @@
+module SplitIoClient
+  class SplitLogger
+      def initialize(config)
+        @config = config
+      end
+
+      def log_if_debug(message)
+        @config.logger.debug(message) if @config.debug_enabled
+      end
+
+      def log_if_transport(message)
+        @config.logger.debug(message) if @config.transport_debug_enabled
+      end
+
+      def error(message)
+        @config.logger.error(message)
+      end
+
+      def debug(message)
+        @config.logger.debug(message) if @config.debug_enabled
+      end
+  end
+end

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

@@ -0,0 +1,264 @@
+# frozen_string_literal: false
+
+require 'socket'
+require 'openssl'
+require 'uri'
+require 'timeout'
+
+module SplitIoClient
+  module SSE
+    module EventSource
+      class Client
+        DEFAULT_READ_TIMEOUT = 70
+        CONNECT_TIMEOUT = 30
+        OK_CODE = 200
+        KEEP_ALIVE_RESPONSE = "c\r\n:keepalive\n\n\r\n".freeze
+        ERROR_EVENT_TYPE = 'error'.freeze
+
+        def initialize(config,
+                       api_key,
+                       telemetry_runtime_producer,
+                       event_parser,
+                       notification_manager_keeper,
+                       notification_processor,
+                       status_queue,
+                       read_timeout: DEFAULT_READ_TIMEOUT)
+          @config = config
+          @api_key = api_key
+          @telemetry_runtime_producer = telemetry_runtime_producer
+          @event_parser = event_parser
+          @notification_manager_keeper = notification_manager_keeper
+          @notification_processor = notification_processor
+          @status_queue = status_queue
+          @read_timeout = read_timeout
+          @connected = Concurrent::AtomicBoolean.new(false)
+          @first_event = Concurrent::AtomicBoolean.new(true)
+          @socket = nil
+        end
+
+        def close(status = nil)
+          unless connected?
+            @config.logger.debug('SSEClient already disconected.') if @config.debug_enabled
+            return
+          end
+          @config.logger.debug("Closing SSEClient socket") if @config.debug_enabled
+
+          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.') 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)
+
+          connected?
+        rescue StandardError => e
+          @config.logger.error("SSEClient start Error: #{e.inspect}")
+          connected?
+        end
+
+        def connected?
+          @connected.value
+        end
+
+        private
+
+        def connect_thread(latch)
+          @config.threads[:connect_stream] = Thread.new do
+            @config.logger.info('Starting connect_stream thread ...')
+            new_status = connect_stream(latch)
+            push_status(new_status)
+            @config.logger.info('connect_stream thread finished.')
+          end
+        end
+
+        def connect_stream(latch)
+          return Constants::PUSH_RETRYABLE_ERROR unless socket_write(latch)
+          while connected? || @first_event.value
+            begin 
+              if IO.select([@socket], nil, nil, @read_timeout)
+                begin
+                  partial_data = @socket.readpartial(10_000)
+                  read_first_event(partial_data, latch)
+
+                  if partial_data == :eof
+                    @config.logger.error("SSE recived EOF unexpectedly")
+                    return Constants::PUSH_RETRYABLE_ERROR
+                  end
+                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}")
+                  return Constants::PUSH_RETRYABLE_ERROR
+                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 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.puts(build_request(@uri))
+          true
+        rescue StandardError => e
+          @config.logger.error("Error during connecting to #{@uri.host}. Error: #{e.inspect}")
+          latch.count_down
+          false
+        end
+
+        def read_first_event(data, latch)
+          return unless @first_event.value
+
+          response_code = @event_parser.first_event(data)
+          @config.logger.debug("SSE client first event code: #{response_code}") if @config.debug_enabled
+
+          error_event = false
+          events = @event_parser.parse(data)
+          events.each { |e| error_event = true if e.event_type == ERROR_EVENT_TYPE }
+          @first_event.make_false
+
+          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
+
+          latch.count_down
+        end
+
+        def socket_connect
+          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
+
+          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
+
+          events = @event_parser.parse(partial_data)
+          events.each { |event| process_event(event) }
+        rescue StandardError => e
+          @config.logger.error("process_data error: #{e.inspect}")
+        end
+
+        def build_request(uri)
+          req = "GET #{uri.request_uri} HTTP/1.1\r\n"
+          req << "Host: #{uri.host}\r\n"
+          req << "Accept: text/event-stream\r\n"
+          req << "SplitSDKVersion: #{@config.language}-#{@config.version}\r\n"
+          req << "SplitSDKMachineIP: #{@config.machine_ip}\r\n"
+          req << "SplitSDKMachineName: #{@config.machine_name}\r\n"
+          req << "SplitSDKClientKey: #{@api_key.split(//).last(4).join}\r\n" unless @api_key.nil?
+          req << "Cache-Control: no-cache\r\n\r\n"
+          @config.logger.debug("Request info: #{req}") if @config.debug_enabled
+          req
+        end
+
+        def process_event(event)
+          case event.event_type
+          when ERROR_EVENT_TYPE
+            dispatch_error(event)
+          else
+            dispatch_event(event)
+          end
+        end
+
+        def dispatch_error(event)
+          @config.logger.error("Event error: #{event.event_type}, #{event.data}")
+          @telemetry_runtime_producer.record_streaming_event(Telemetry::Domain::Constants::ABLY_ERROR, event.data['code'])
+
+          if event.data['code'] >= 40_140 && event.data['code'] <= 40_149
+            close(Constants::PUSH_RETRYABLE_ERROR)
+          elsif event.data['code'] >= 40_000 && event.data['code'] <= 49_999
+            close(Constants::PUSH_NONRETRYABLE_ERROR)
+          end
+        end
+
+        def dispatch_event(event)
+          if event.occupancy?
+            @notification_manager_keeper.handle_incoming_occupancy_event(event)
+          else
+            @notification_processor.process(event)
+          end
+        end
+
+        def push_status(status)
+          return if status.nil?
+          
+          @config.logger.debug("Pushing new sse status: #{status}") if @config.debug_enabled
+          @status_queue.push(status)
+        end
+      end
+    end
+  end
+end