splitclient-rb 6.3.0 → 8.11.0

data/lib/splitclient-rb/engine/push_manager.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Engine
+    class PushManager
+      def initialize(config, sse_handler, api_key, telemetry_runtime_producer)
+        @config = config
+        @sse_handler = sse_handler
+        @auth_api_client = AuthApiClient.new(@config, telemetry_runtime_producer)
+        @api_key = api_key
+        @back_off = Engine::BackOff.new(@config.auth_retry_back_off_base, 1)
+        @telemetry_runtime_producer = telemetry_runtime_producer
+      end
+
+      def start_sse
+        response = @auth_api_client.authenticate(@api_key)
+        @config.logger.debug("Auth service response push_enabled: #{response[:push_enabled]}") if @config.debug_enabled
+
+        if response[:push_enabled] && @sse_handler.start(response[:token], response[:channels])
+          schedule_next_token_refresh(response[:exp])
+          @back_off.reset
+          record_telemetry(response[:exp])
+
+          return true
+        end
+
+        stop_sse
+        schedule_next_token_refresh(@back_off.interval) if response[:retry]
+        false
+      rescue StandardError => e
+        @config.logger.error("start_sse: #{e.inspect}")
+      end
+
+      def stop_sse
+        @sse_handler.stop
+        SplitIoClient::Helpers::ThreadHelper.stop(:schedule_next_token_refresh, @config)
+      rescue StandardError => e
+        @config.logger.error(e.inspect)
+      end
+
+      private
+
+      def schedule_next_token_refresh(time)
+        @config.threads[:schedule_next_token_refresh] = Thread.new { refresh_token_task(time) }
+      end
+
+      def refresh_token_task(time)
+        @config.logger.debug("schedule_next_token_refresh refresh in #{time} seconds.") if @config.debug_enabled
+
+        sleep(time)
+
+        @config.logger.debug('schedule_next_token_refresh starting ...') if @config.debug_enabled
+        @sse_handler.stop
+
+        start_sse
+      rescue StandardError => e
+        @config.logger.debug("schedule_next_token_refresh error: #{e.inspect}") if @config.debug_enabled
+      end
+
+      def record_telemetry(time)
+        data = (Time.now.to_f * 1000.0).to_i + (time * 1000.0).to_i
+        @telemetry_runtime_producer.record_streaming_event(Telemetry::Domain::Constants::TOKEN_REFRESH, data)
+      end
+    end
+  end
+end

data/lib/splitclient-rb/engine/status_manager.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Engine
+    class StatusManager
+      def initialize(config, internal_events_queue)
+        @config = config
+        @sdk_ready = Concurrent::CountDownLatch.new(1)
+        @internal_events_queue = internal_events_queue
+      end
+
+      def ready?
+        return true if @config.consumer?
+
+        @sdk_ready.wait(0)
+      end
+
+      def ready!
+        return if ready?
+
+        @sdk_ready.count_down
+        @config.logger.info('SplitIO SDK is ready')
+        @internal_events_queue.push(
+          SplitIoClient::Engine::Models::SdkInternalEventNotification.new(
+            SplitIoClient::Engine::Models::SdkInternalEvent::SDK_READY, nil
+          )
+        )
+      end
+
+      def wait_until_ready(seconds = nil)
+        return if @config.consumer?
+
+        timeout = seconds || @config.block_until_ready
+
+        raise SDKBlockerTimeoutExpiredException, 'SDK start up timeout expired' unless @sdk_ready.wait(timeout)
+      end
+    end
+  end
+end

data/lib/splitclient-rb/engine/sync_manager.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Engine
+    class SyncManager
+      SYNC_MODE_STREAMING = 0
+      SYNC_MODE_POLLING = 1
+
+      def initialize(config,
+                     synchronizer,
+                     telemetry_runtime_producer,
+                     telemetry_synchronizer,
+                     status_manager,
+                     sse_handler,
+                     push_manager,
+                     status_queue)
+        @config = config
+        @synchronizer = synchronizer
+        @telemetry_runtime_producer = telemetry_runtime_producer
+        @telemetry_synchronizer = telemetry_synchronizer
+        @status_manager = status_manager
+        @sse_handler = sse_handler
+        @push_manager = push_manager
+        @status_queue = status_queue
+        @sse_connected = Concurrent::AtomicBoolean.new(false)
+      end
+
+      def start
+        start_thread
+        PhusionPassenger.on_event(:starting_worker_process) { |forked| start_thread if forked } if defined?(PhusionPassenger)
+      end
+
+      def start_consumer
+        start_consumer_thread
+        PhusionPassenger.on_event(:starting_worker_process) { |forked| start_consumer_thread if forked } if defined?(PhusionPassenger)
+      end
+
+      private
+
+      def start_thread
+        @config.threads[:start_sdk] = Thread.new do
+          sleep(0.5) until @synchronizer.sync_all(false)
+
+          @status_manager.ready!
+          @telemetry_synchronizer.synchronize_config
+          @synchronizer.start_periodic_data_recording
+          connected = false
+
+          if @config.streaming_enabled
+            @config.logger.debug('Starting Streaming mode ...') if @config.debug_enabled
+            start_push_status_monitor
+            connected = @push_manager.start_sse
+          end
+
+          unless connected
+            @config.logger.debug('Starting Polling mode ...') if @config.debug_enabled
+            @synchronizer.start_periodic_fetch
+            record_telemetry(Telemetry::Domain::Constants::SYNC_MODE, SYNC_MODE_POLLING)
+          end
+        end
+      end
+
+      def start_consumer_thread
+        @config.threads[:start_sdk_consumer] = Thread.new do
+          @status_manager.ready!
+          @telemetry_synchronizer.synchronize_config
+          @synchronizer.start_periodic_data_recording
+        end
+      end
+
+      def process_subsystem_ready
+        @synchronizer.stop_periodic_fetch
+        @synchronizer.sync_all
+        @sse_handler.start_workers
+        record_telemetry(Telemetry::Domain::Constants::SYNC_MODE, SYNC_MODE_STREAMING)
+      end
+
+      def process_subsystem_down
+        @sse_handler.stop_workers
+        @synchronizer.start_periodic_fetch
+        record_telemetry(Telemetry::Domain::Constants::SYNC_MODE, SYNC_MODE_POLLING)
+      end
+
+      def process_push_shutdown
+        @push_manager.stop_sse
+        @sse_handler.stop_workers
+        @synchronizer.start_periodic_fetch
+        record_telemetry(Telemetry::Domain::Constants::SYNC_MODE, SYNC_MODE_POLLING)
+      rescue StandardError => e
+        @config.logger.error("process_push_shutdown error: #{e.inspect}")
+      end
+
+      def process_connected
+        if @sse_connected.value
+          @config.logger.debug('Streaming already connected.') if @config.debug_enabled
+          return
+        end
+
+        @sse_connected.make_true
+        @synchronizer.stop_periodic_fetch
+        @synchronizer.sync_all
+        @sse_handler.start_workers
+        record_telemetry(Telemetry::Domain::Constants::SYNC_MODE, SYNC_MODE_STREAMING)
+      rescue StandardError => e
+        @config.logger.error("process_connected error: #{e.inspect}")
+      end
+
+      def process_forced_stop
+        unless @sse_connected.value
+          @config.logger.debug('Streaming already disconnected.') if @config.debug_enabled
+          return
+        end
+
+        @sse_connected.make_false
+        @synchronizer.start_periodic_fetch
+        record_telemetry(Telemetry::Domain::Constants::SYNC_MODE, SYNC_MODE_POLLING)
+      rescue StandardError => e
+        @config.logger.error("process_connected error: #{e.inspect}")
+      end
+
+      def process_disconnect(reconnect)
+        unless @sse_connected.value
+          @config.logger.debug('Streaming already disconnected.') if @config.debug_enabled
+          return
+        end
+
+        @sse_connected.make_false
+        @sse_handler.stop_workers
+        @synchronizer.start_periodic_fetch
+        record_telemetry(Telemetry::Domain::Constants::SYNC_MODE, SYNC_MODE_POLLING)
+
+        if reconnect
+          @push_manager.stop_sse
+          @synchronizer.sync_all
+          @push_manager.start_sse
+        end
+      rescue StandardError => e
+        @config.logger.error("process_disconnect error: #{e.inspect}")
+      end
+
+      def record_telemetry(type, data)
+        @telemetry_runtime_producer.record_streaming_event(type, data)
+      end
+
+      def start_push_status_monitor
+        @config.threads[:push_status_handler] = Thread.new do
+          @config.logger.debug('Starting push status handler ...') if @config.debug_enabled
+          incoming_push_status_handler
+        end
+      end
+
+      def incoming_push_status_handler
+        while (status = @status_queue.pop)
+          @config.logger.debug("Push status handler dequeue #{status}") if @config.debug_enabled
+
+          case status
+          when Constants::PUSH_CONNECTED
+            process_connected
+          when Constants::PUSH_RETRYABLE_ERROR
+            process_disconnect(true)
+          when Constants::PUSH_FORCED_STOP
+            process_forced_stop
+          when Constants::PUSH_NONRETRYABLE_ERROR
+            process_disconnect(false)
+          when Constants::PUSH_SUBSYSTEM_DOWN
+            process_subsystem_down
+          when Constants::PUSH_SUBSYSTEM_READY
+            process_subsystem_ready
+          when Constants::PUSH_SUBSYSTEM_OFF
+            process_push_shutdown
+          else
+            @config.logger.debug('Incorrect push status type.') if @config.debug_enabled
+          end
+        end
+      rescue StandardError => e
+        @config.logger.error("Push status handler error: #{e.inspect}")
+      end
+    end
+  end
+end

data/lib/splitclient-rb/engine/synchronizer.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Engine
+    class Synchronizer
+      include SplitIoClient::Cache::Fetchers
+      include SplitIoClient::Cache::Senders
+
+      ON_DEMAND_FETCH_BACKOFF_MAX_RETRIES = 10
+
+      def initialize(
+        repositories,
+        config,
+        params
+      )
+        @splits_repository = repositories[:splits]
+        @segments_repository = repositories[:segments]
+        @rule_based_segments_repository = repositories[:rule_based_segments]
+        @impressions_repository = repositories[:impressions]
+        @events_repository = repositories[:events]
+        @config = config
+        @split_fetcher = params[:split_fetcher]
+        @segment_fetcher = params[:segment_fetcher]
+        @impressions_api = params[:impressions_api]
+        @impression_counter = params[:imp_counter]
+        @telemetry_synchronizer = params[:telemetry_synchronizer]
+        @impressions_sender_adapter = params[:impressions_sender_adapter]
+        @unique_keys_tracker = params[:unique_keys_tracker]
+
+        @splits_sync_backoff = Engine::BackOff.new(10, 0, 60)
+        @segments_sync_backoff = Engine::BackOff.new(10, 0, 60)
+      end
+
+      def sync_all(asynchronous = true)
+        unless asynchronous
+          return sync_splits_and_segments
+        end
+
+        @config.threads[:sync_all_thread] = Thread.new do
+          sync_splits_and_segments
+        end
+
+        true
+      end
+
+      def start_periodic_data_recording
+        unless @config.consumer?
+          impressions_sender
+          events_sender
+          start_telemetry_sync_task
+        end
+
+        impressions_count_sender
+        start_unique_keys_tracker_task
+      end
+
+      def start_periodic_fetch
+        @split_fetcher.call
+        @segment_fetcher.call
+      end
+
+      def stop_periodic_fetch
+        @split_fetcher.stop_splits_thread
+        @segment_fetcher.stop_segments_thread
+      end
+
+      def fetch_splits(target_change_number, rbs_target_change_number)
+        return if check_exit_conditions(target_change_number, rbs_target_change_number)
+
+        fetch_options = { cache_control_headers: true, till: nil }
+
+        result = attempt_splits_sync(target_change_number, rbs_target_change_number,
+                                     fetch_options,
+                                     @config.on_demand_fetch_max_retries,
+                                     @config.on_demand_fetch_retry_delay_seconds,
+                                     false)
+
+        attempts = @config.on_demand_fetch_max_retries - result[:remaining_attempts]
+        if result[:success]
+          @segment_fetcher.fetch_segments_if_not_exists(result[:segment_names], true) unless result[:segment_names].empty?
+          @config.logger.debug("Refresh completed in #{attempts} attempts.") if @config.debug_enabled
+
+          return
+        end
+
+        if target_change_number != 0
+          fetch_options[:till] = target_change_number 
+        else
+          fetch_options[:till] = rbs_target_change_number 
+        end
+
+        result = attempt_splits_sync(target_change_number, rbs_target_change_number,
+                                     fetch_options,
+                                     ON_DEMAND_FETCH_BACKOFF_MAX_RETRIES,
+                                     nil,
+                                     true)
+
+        attempts = ON_DEMAND_FETCH_BACKOFF_MAX_RETRIES - result[:remaining_attempts]
+
+        process_result(result, attempts)
+      rescue StandardError => e
+        @config.log_found_exception(__method__.to_s, e)
+      end
+
+      def fetch_segment(name, target_change_number)
+        return if target_change_number <= @segments_repository.get_change_number(name).to_i
+
+        fetch_options = { cache_control_headers: true, till: nil }
+        result = attempt_segment_sync(name,
+                                      target_change_number,
+                                      fetch_options,
+                                      @config.on_demand_fetch_max_retries,
+                                      @config.on_demand_fetch_retry_delay_seconds,
+                                      false)
+
+        attempts = @config.on_demand_fetch_max_retries - result[:remaining_attempts]
+        if result[:success]
+          @config.logger.debug("Segment #{name} refresh completed in #{attempts} attempts.") if @config.debug_enabled
+
+          return
+        end
+
+        fetch_options = { cache_control_headers: true, till: target_change_number }
+        result = attempt_segment_sync(name,
+                                      target_change_number,
+                                      fetch_options,
+                                      ON_DEMAND_FETCH_BACKOFF_MAX_RETRIES,
+                                      nil,
+                                      true)
+
+        attempts = @config.on_demand_fetch_max_retries - result[:remaining_attempts]
+        if result[:success]
+          @config.logger.debug("Segment #{name} refresh completed bypassing the CDN in #{attempts} attempts.") if @config.debug_enabled
+        else
+          @config.logger.debug("No changes fetched for segment #{name} after #{attempts} attempts with CDN bypassed.") if @config.debug_enabled
+        end
+      rescue StandardError => e
+        @config.log_found_exception(__method__.to_s, e)
+      end
+
+      private
+
+      def process_result(result, attempts)
+        if result[:success]
+          @segment_fetcher.fetch_segments_if_not_exists(result[:segment_names], true) unless result[:segment_names].empty?
+          @config.logger.debug("Refresh completed bypassing the CDN in #{attempts} attempts.") if @config.debug_enabled
+        else
+          @config.logger.debug("No changes fetched after #{attempts} attempts with CDN bypassed.") if @config.debug_enabled
+        end
+      end
+
+      def attempt_segment_sync(name, target_cn, fetch_options, max_retries, retry_delay_seconds, with_backoff)
+        remaining_attempts = max_retries
+        @segments_sync_backoff.reset
+
+        loop do
+          remaining_attempts -= 1
+
+          @segment_fetcher.fetch_segment(name, fetch_options)
+
+          return sync_result(true, remaining_attempts) if target_cn <= @segments_repository.get_change_number(name).to_i
+          return sync_result(false, remaining_attempts) if remaining_attempts <= 0
+
+          delay = with_backoff ? @segments_sync_backoff.interval : retry_delay_seconds
+          sleep(delay)
+        end
+      end
+
+      def attempt_splits_sync(target_cn, rbs_target_cn, fetch_options, max_retries, retry_delay_seconds, with_backoff)
+        remaining_attempts = max_retries
+        @splits_sync_backoff.reset
+
+        loop do
+          remaining_attempts -= 1
+
+          result = @split_fetcher.fetch_splits(fetch_options)
+
+          return sync_result(true, remaining_attempts, result[:segment_names]) if check_exit_conditions(target_cn, rbs_target_cn)
+          return sync_result(false, remaining_attempts, result[:segment_names]) if remaining_attempts <= 0
+
+          delay = with_backoff ? @splits_sync_backoff.interval : retry_delay_seconds
+          sleep(delay)
+        end
+      end
+
+      # Starts thread which loops constantly and sends impressions to the Split API
+      def impressions_sender
+        ImpressionsSender.new(@impressions_repository, @config, @impressions_api).call
+      end
+
+      # Starts thread which loops constantly and sends events to the Split API
+      def events_sender
+        EventsSender.new(@events_repository, @config).call
+      end
+
+      # Starts thread which loops constantly and sends impressions count to the Split API
+      def impressions_count_sender
+        ImpressionsCountSender.new(@config, @impression_counter, @impressions_sender_adapter).call
+      end
+
+      def start_telemetry_sync_task
+        Telemetry::SyncTask.new(@config, @telemetry_synchronizer).call
+      end
+
+      def start_unique_keys_tracker_task
+        @unique_keys_tracker.call
+      end
+
+      def sync_result(success, remaining_attempts, segment_names = nil)
+        { success: success, remaining_attempts: remaining_attempts, segment_names: segment_names }
+      end
+
+      def sync_splits_and_segments
+        @config.logger.debug('Synchronizing feature flags and segments ...') if @config.debug_enabled
+        splits_result = @split_fetcher.fetch_splits
+
+        splits_result[:success] && @segment_fetcher.fetch_segments
+      end
+
+      def check_exit_conditions(target_change_number, rbs_target_change_number)
+        return true if rbs_target_change_number == 0 and target_change_number == 0
+
+        return target_change_number <= @splits_repository.get_change_number.to_i if rbs_target_change_number == 0
+          
+        return rbs_target_change_number <= @rule_based_segments_repository.get_change_number.to_i if target_change_number == 0
+
+        return (target_change_number <= @splits_repository.get_change_number.to_i and rbs_target_change_number <= @rule_based_segments_repository.get_change_number.to_i)
+      end
+    end
+  end
+end

data/lib/splitclient-rb/exceptions.rb

@@ -1,7 +1,26 @@
 module SplitIoClient
   class SplitIoError < StandardError; end
 
-  class SDKShutdownException < SplitIoError; end
+  class SDKShutdownException < Exception; end
 
   class SDKBlockerTimeoutExpiredException < SplitIoError; end
+
+  class SSEClientException < SplitIoError
+    attr_reader :event
+
+    def initialize(event)
+      @event = event
+    end
+  end
+
+  class ApiException < SplitIoError
+    def initialize(msg, exception_code)
+      @@exception_code = exception_code
+      super(msg)
+    end
+    def exception_code
+      @@exception_code
+    end
+  end
+
 end

data/lib/splitclient-rb/helpers/decryption_helper.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  NO_COMPRESSION = 0
+  GZIP_COMPRESSION = 1
+  ZLIB_COMPRESSION = 2
+
+  module Helpers
+    class DecryptionHelper
+      def self.get_encoded_definition(compression, data)
+        case compression
+        when NO_COMPRESSION
+          Base64.decode64(data)
+        when GZIP_COMPRESSION
+          gz = Zlib::GzipReader.new(StringIO.new(Base64.decode64(data)))
+          gz.read
+        when ZLIB_COMPRESSION
+          Zlib::Inflate.inflate(Base64.decode64(data))
+        else
+          raise StandardError, 'Compression flag value is incorrect'
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/helpers/evaluator_helper.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Helpers
+    class EvaluatorHelper
+      def self.matcher_type(condition, segments_repository, rb_segment_repository)
+        matchers = []
+        segments_repository.adapter.pipelined do
+          condition.matchers.each do |matcher|
+            matchers << if matcher[:negate]
+                          condition.negation_matcher(matcher_instance(matcher[:matcherType], condition,
+                                                                      matcher, segments_repository,
+                                                                      rb_segment_repository))
+                        else
+                          matcher_instance(matcher[:matcherType], condition, matcher, segments_repository, rb_segment_repository)
+                        end
+          end
+        end
+        final_matcher = condition.create_condition_matcher(matchers)
+
+        if final_matcher.nil?
+          config.logger.error('Invalid matcher type')
+        else
+          final_matcher
+        end
+        final_matcher
+      end
+
+      def self.matcher_instance(type, condition, matcher, segments_repository, rb_segment_repository)
+        condition.send(
+          "matcher_#{type.downcase}",
+          matcher: matcher, segments_repository: segments_repository, rule_based_segments_repository: rb_segment_repository
+        )
+      end
+    end
+  end
+end

data/lib/splitclient-rb/helpers/repository_helper.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Helpers
+    class RepositoryHelper
+      def self.update_feature_flag_repository(feature_flag_repository, feature_flags, change_number, config, clear_storage)
+        to_add = []
+        to_delete = []
+        feature_flags.each do |feature_flag|
+          if Engine::Models::Split.archived?(feature_flag) || !feature_flag_repository.flag_set_filter.intersect?(feature_flag[:sets])
+            config.logger.debug("removing feature flag from store(#{feature_flag})") if config.debug_enabled
+            to_delete.push(feature_flag)
+            next
+          end
+
+          feature_flag = check_missing_elements(feature_flag, config)
+
+          config.logger.debug("storing feature flag (#{feature_flag[:name]})") if config.debug_enabled
+          to_add.push(feature_flag)
+        end
+        feature_flag_repository.clear if clear_storage
+        feature_flag_repository.update(to_add, to_delete, change_number)
+      end
+
+      def self.check_missing_elements(feature_flag, config)
+        unless feature_flag.key?(:impressionsDisabled)
+          feature_flag[:impressionsDisabled] = false
+          if config.debug_enabled
+            config.logger.debug("feature flag (#{feature_flag[:name]}) does not have impressionsDisabled field, setting it to false")
+          end
+        end
+
+        unless feature_flag.key?(:prerequisites)
+          feature_flag[:prerequisites] = []
+          if config.debug_enabled
+            config.logger.debug("feature flag (#{feature_flag[:name]}) does not have prerequisites field, setting it to empty array")
+          end
+        end
+
+        feature_flag
+      end
+
+      def self.update_rule_based_segment_repository(rule_based_segment_repository, rule_based_segments, change_number, config)
+        to_add = []
+        to_delete = []
+        rule_based_segments.each do |rule_based_segment|
+          if Engine::Models::Split.archived?(rule_based_segment)
+            config.logger.debug("removing rule based segment from store(#{rule_based_segment})") if config.debug_enabled
+            to_delete.push(rule_based_segment)
+            next
+          end
+
+          config.logger.debug("storing rule based segment (#{rule_based_segment[:name]})") if config.debug_enabled
+          to_add.push(rule_based_segment)
+        end
+
+        rule_based_segment_repository.update(to_add, to_delete, change_number)
+      end
+    end
+  end
+end

data/lib/splitclient-rb/helpers/thread_helper.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Helpers
+    class ThreadHelper
+      def self.stop(thread_sym, config)
+        thread = config.threads[thread_sym]
+
+        unless thread.nil?
+          config.logger.debug("Stopping #{thread_sym} thread...") if config.debug_enabled
+          Thread.kill(thread)
+        end
+      rescue StandardError => e
+        config.logger.error(e.inspect)
+      end
+
+      def self.alive?(thread_sym, config)
+        thread = config.threads[thread_sym]
+
+        thread.nil? ? false : thread.alive?
+      end
+    end
+  end
+end