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

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

@@ -0,0 +1,26 @@
+module SplitIoClient
+  class SplitIoError < StandardError; 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

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Helpers
+    class Util
+      def self.segment_names_by_object(object, matcher_type)
+        object[:conditions].each_with_object(Set.new) do |condition, names|
+          condition[:matcherGroup][:matchers].each do |matcher|
+            next if matcher[:userDefinedSegmentMatcherData].nil? || matcher[:matcherType] != matcher_type
+
+            names << matcher[:userDefinedSegmentMatcherData][:segmentName]
+          end
+        end
+      end
+
+      def self.segment_names_in_rb_segment(object, matcher_type)
+        names = Set.new
+        names.merge segment_names_by_object(object, matcher_type)
+        object[:excluded][:segments].each do |segment|
+          names.add(segment[:name]) if segment[:type] == SplitIoClient::Engine::Models::SegmentType::STANDARD
+        end
+        names
+      end
+    end
+  end
+end

data/lib/splitclient-rb/managers/split_manager.rb

@@ -0,0 +1,121 @@
+module SplitIoClient
+  class SplitManager
+    #
+    # Creates a new split manager instance that connects to split.io API.
+    #
+    # @return [SplitIoManager] split.io client instance
+    def initialize(splits_repository = nil, status_manager, config)
+      @splits_repository = splits_repository
+      @status_manager = status_manager
+      @config = config
+    end
+
+    #
+    # method to get the split list from the client
+    #
+    # @returns [object] array of splits
+    def splits
+      return [] if !@config.valid_mode || @splits_repository.nil?
+
+      if !ready?
+        @config.logger.error("splits: the SDK is not ready, the operation cannot be executed")
+        return []
+      end
+
+      @splits_repository.splits.each_with_object([]) do |(name, split), memo|
+        split_view = build_split_view(name, split)
+
+        next if split_view[:name] == nil
+
+        memo << split_view unless Engine::Models::Split.archived?(split)
+      end
+    end
+
+    #
+    # method to get the list of just split names. Ideal for ietrating and calling client.get_treatment
+    #
+    # @returns [object] array of split names (String)
+    def split_names
+      return [] if !@config.valid_mode || @splits_repository.nil?
+
+      if !ready?
+        @config.logger.error("split_names: the SDK is not ready, the operation cannot be executed")
+        return []
+      end
+
+      @splits_repository.split_names
+    end
+
+    #
+    # method to get a split view
+    #
+    # @returns a split view
+    def split(feature_flag_name)
+      return unless @config.valid_mode && @splits_repository && @config.split_validator.valid_split_parameters(feature_flag_name)
+
+      if !ready?
+        @config.logger.error("split: the SDK is not ready, the operation cannot be executed")
+        return
+      end
+
+      sanitized_feature_flag_name = feature_flag_name.to_s.strip
+
+      if feature_flag_name.to_s != sanitized_feature_flag_name
+        @config.logger.warn("split: feature_flag_name #{feature_flag_name} has extra whitespace, trimming")
+        feature_flag_name = sanitized_feature_flag_name
+      end
+
+      split = @splits_repository.get_split(feature_flag_name)
+
+      if ready? && split.nil?
+        @config.logger.warn("split: you passed #{feature_flag_name} " \
+          'that does not exist in this environment, please double check what feature flags exist in the Split user interface')
+      end
+
+      return if split.nil? || Engine::Models::Split.archived?(split)
+
+      build_split_view(feature_flag_name, split)
+    end
+
+    def block_until_ready(time = nil)
+      @status_manager.wait_until_ready(time) if @status_manager
+    end
+
+    private
+
+    def build_split_view(name, split)
+      return {} unless split
+
+      begin
+        if @config.localhost_mode
+          treatments = split[:conditions]
+            .first[:partitions]
+            .map { |partition| partition[:treatment] }
+        else
+          treatments = split[:conditions]
+            .detect { |c| c[:conditionType] == 'ROLLOUT' }[:partitions]
+            .map { |partition| partition[:treatment] }
+        end
+      rescue StandardError
+        treatments = []
+      end
+        {
+          name: name,
+          traffic_type_name: split[:trafficTypeName],
+          killed: split[:killed],
+          treatments: treatments,
+          change_number: split[:changeNumber],
+          configs: split[:configurations] || {},
+          sets: split[:sets] || [],
+          default_treatment: split[:defaultTreatment],
+          impressions_disabled: split[:impressionsDisabled]
+        }
+    end
+
+    # move to blocker, alongside block until ready to avoid duplication
+    def ready?
+      return @status_manager.ready? if @status_manager
+      true
+    end
+  end
+end

data/lib/splitclient-rb/spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Spec
+    class FeatureFlags
+      SPEC_VERSION = "1.3"
+    end
+  end
+end