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

data/lib/splitclient-rb/engine/parser/condition.rb

@@ -0,0 +1,271 @@
+module SplitIoClient
+  #
+  # acts as dto for a condition structure
+  #
+  class Condition < NoMethodError
+    TYPE_ROLLOUT = 'ROLLOUT'.freeze
+    TYPE_WHITELIST = 'WHITELIST'.freeze
+    #
+    # definition of the condition
+    #
+    # @returns [object] condition values
+    attr_accessor :data
+
+    def initialize(condition, config)
+      @data = condition
+      @partitions = set_partitions
+      @config = config
+    end
+
+    def create_condition_matcher(matchers)
+      CombiningMatcher.new(@config.split_logger, combiner, matchers) if combiner
+    end
+
+    #
+    # @return [object] the combiner value for this condition
+    def combiner
+      @data[:matcherGroup][:combiner]
+    end
+
+    #
+    # @return [object] the matcher value for this condition
+    def matcher
+      @data[:matcherGroup][:matchers].first[:matcherType]
+    end
+
+    #
+    # @return [object] the matchers array value for this condition
+    def matchers
+      @data[:matcherGroup][:matchers]
+    end
+
+    #
+    # @return [string] condition type
+    def type
+      @data[:conditionType]
+    end
+
+    def negation_matcher(matcher)
+      NegationMatcher.new(@config.split_logger, matcher)
+    end
+
+    def matcher_all_keys(_params)
+      @matcher_all_keys ||= AllKeysMatcher.new(@config.split_logger)
+    end
+
+    # returns UserDefinedSegmentMatcher[object]
+    def matcher_in_segment(params)
+      matcher = params[:matcher]
+      segment_name = matcher[:userDefinedSegmentMatcherData] && matcher[:userDefinedSegmentMatcherData][:segmentName]
+
+      UserDefinedSegmentMatcher.new(params[:segments_repository], segment_name, @config.split_logger)
+    end
+
+    # returns WhitelistMatcher[object] the whitelist for this condition in case it has a whitelist matcher
+    def matcher_whitelist(params)
+      result = nil
+      matcher = params[:matcher]
+      is_user_whitelist = ((matcher[:keySelector]).nil? || (matcher[:keySelector])[:attribute].nil?)
+      if is_user_whitelist
+        result = (matcher[:whitelistMatcherData])[:whitelist]
+      else
+        attribute = (matcher[:keySelector])[:attribute]
+        white_list = (matcher[:whitelistMatcherData])[:whitelist]
+        result =  { attribute: attribute, value: white_list }
+      end
+      WhitelistMatcher.new(result, @config.split_logger, @config.split_validator)
+    end
+
+    def matcher_equal_to(params)
+      matcher = params[:matcher]
+      attribute = (matcher[:keySelector])[:attribute]
+      value = (matcher[:unaryNumericMatcherData])[:value]
+      data_type = (matcher[:unaryNumericMatcherData])[:dataType]
+      EqualToMatcher.new({attribute: attribute, value: value, data_type: data_type}, @config.split_logger, @config.split_validator)
+    end
+
+    def matcher_greater_than_or_equal_to(params)
+      matcher = params[:matcher]
+      attribute = (matcher[:keySelector])[:attribute]
+      value = (matcher[:unaryNumericMatcherData])[:value]
+      data_type = (matcher[:unaryNumericMatcherData])[:dataType]
+      GreaterThanOrEqualToMatcher.new({attribute: attribute, value: value, data_type: data_type}, @config.split_logger, @config.split_validator)
+    end
+
+    def matcher_less_than_or_equal_to(params)
+      matcher = params[:matcher]
+      attribute = (matcher[:keySelector])[:attribute]
+      value = (matcher[:unaryNumericMatcherData])[:value]
+      data_type = (matcher[:unaryNumericMatcherData])[:dataType]
+      LessThanOrEqualToMatcher.new({attribute: attribute, value: value, data_type: data_type}, @config.split_logger, @config.split_validator)
+    end
+
+    def matcher_between(params)
+      matcher = params[:matcher]
+      attribute = (matcher[:keySelector])[:attribute]
+      start_value = (matcher[:betweenMatcherData])[:start]
+      end_value = (matcher[:betweenMatcherData])[:end]
+      data_type = (matcher[:betweenMatcherData])[:dataType]
+      BetweenMatcher.new({attribute: attribute, start_value: start_value, end_value: end_value, data_type: data_type}, @config.split_logger, @config.split_validator)
+    end
+
+    def matcher_equal_to_set(params)
+      EqualToSetMatcher.new(
+        params[:matcher][:keySelector][:attribute],
+        params[:matcher][:whitelistMatcherData][:whitelist],
+        @config.split_logger
+      )
+    end
+
+    def matcher_contains_any_of_set(params)
+      ContainsAnyMatcher.new(
+        params[:matcher][:keySelector][:attribute],
+        params[:matcher][:whitelistMatcherData][:whitelist],
+        @config.split_logger
+      )
+    end
+
+    def matcher_contains_all_of_set(params)
+      ContainsAllMatcher.new(
+        params[:matcher][:keySelector][:attribute],
+        params[:matcher][:whitelistMatcherData][:whitelist],
+        @config.split_logger
+      )
+    end
+
+    def matcher_part_of_set(params)
+      PartOfSetMatcher.new(
+        params[:matcher][:keySelector][:attribute],
+        params[:matcher][:whitelistMatcherData][:whitelist],
+        @config.split_logger
+      )
+    end
+
+    def matcher_starts_with(params)
+      StartsWithMatcher.new(
+        params[:matcher][:keySelector][:attribute],
+        params[:matcher][:whitelistMatcherData][:whitelist],
+        @config.split_logger
+      )
+    end
+
+    def matcher_ends_with(params)
+      EndsWithMatcher.new(
+        params[:matcher][:keySelector][:attribute],
+        params[:matcher][:whitelistMatcherData][:whitelist],
+        @config.split_logger
+      )
+    end
+
+    def matcher_contains_string(params)
+      ContainsMatcher.new(
+        params[:matcher][:keySelector][:attribute],
+        params[:matcher][:whitelistMatcherData][:whitelist],
+        @config.split_logger, @config.split_validator
+      )
+    end
+
+    def matcher_in_split_treatment(params)
+      DependencyMatcher.new(
+        params[:matcher][:dependencyMatcherData][:split],
+        params[:matcher][:dependencyMatcherData][:treatments],
+        @config.split_logger
+      )
+    end
+
+    def matcher_equal_to_boolean(params)
+      EqualToBooleanMatcher.new(
+        params[:matcher][:keySelector][:attribute],
+        params[:matcher][:booleanMatcherData],
+        @config.split_logger
+      )
+    end
+
+    def matcher_matches_string(params)
+      MatchesStringMatcher.new(
+        params[:matcher][:keySelector][:attribute],
+        params[:matcher][:stringMatcherData],
+        @config.split_logger
+      )
+    end
+
+    def matcher_equal_to_semver(params)
+      EqualToSemverMatcher.new(
+        params[:matcher][:keySelector][:attribute],
+        params[:matcher][:stringMatcherData],
+        @config.split_logger, @config.split_validator
+      )
+    end
+
+    def matcher_greater_than_or_equal_to_semver(params)
+      GreaterThanOrEqualToSemverMatcher.new(
+        params[:matcher][:keySelector][:attribute],
+        params[:matcher][:stringMatcherData],
+        @config.split_logger, @config.split_validator
+      )
+    end
+
+    def matcher_less_than_or_equal_to_semver(params)
+      LessThanOrEqualToSemverMatcher.new(
+        params[:matcher][:keySelector][:attribute],
+        params[:matcher][:stringMatcherData],
+        @config.split_logger, @config.split_validator
+      )
+    end
+
+    def matcher_between_semver(params)
+      BetweenSemverMatcher.new(
+        params[:matcher][:keySelector][:attribute],
+        params[:matcher][:betweenStringMatcherData][:start],
+        params[:matcher][:betweenStringMatcherData][:end],
+        @config.split_logger, @config.split_validator
+      )
+    end
+
+    def matcher_in_list_semver(params)
+      InListSemverMatcher.new(
+        params[:matcher][:keySelector][:attribute],
+        params[:matcher][:whitelistMatcherData][:whitelist],
+        @config.split_logger, @config.split_validator
+      )
+    end
+
+    def matcher_in_rule_based_segment(params)
+      matcher = params[:matcher]
+      segment_name = matcher[:userDefinedSegmentMatcherData] && matcher[:userDefinedSegmentMatcherData][:segmentName]
+
+      RuleBasedSegmentMatcher.new(params[:segments_repository], params[:rule_based_segments_repository], segment_name, @config)
+    end
+
+    #
+    # @return [object] the negate value for this condition
+    def negate
+      @data[:matcherGroup][:matchers].first[:negate]
+    end
+
+    #
+    # @return [object] the array of partitions for this condition
+    attr_reader :partitions
+
+    #
+    # converts the partitions hash for this condition into an array of partition objects
+    #
+    # @return [void]
+    def set_partitions
+      partitions_list = []
+      return partitions_list unless @data.key?(:partitions) or @data.key?('partitions')
+      
+      @data[:partitions].each do |p|
+        partition = SplitIoClient::Partition.new(p)
+        partitions_list << partition
+      end
+      partitions_list
+    end
+
+    #
+    # @return [boolean] true if the condition is empty false otherwise
+    def empty?
+      @data.empty?
+    end
+  end
+end

data/lib/splitclient-rb/engine/parser/evaluator.rb

@@ -0,0 +1,112 @@
+module SplitIoClient
+  module Engine
+    module Parser
+      class Evaluator
+        def initialize(segments_repository, splits_repository, rb_segment_repository, config)
+          @splits_repository = splits_repository
+          @segments_repository = segments_repository
+          @rb_segment_repository = rb_segment_repository
+          @config = config
+        end
+
+        def evaluate_feature_flag(keys, feature_flag, attributes = nil)
+          # DependencyMatcher here, split is actually a split_name in this case
+          cache_result = feature_flag.is_a? String
+          feature_flag = @splits_repository.get_split(feature_flag) if cache_result
+          evaluate_treatment(keys, feature_flag, attributes)
+        end
+
+        private
+
+        def evaluate_treatment(keys, feature_flag, attributes)
+          if Models::Split.archived?(feature_flag)
+            return treatment_hash(Models::Label::ARCHIVED, Models::Treatment::CONTROL, feature_flag[:changeNumber])
+          end
+
+          treatment = if Models::Split.matchable?(feature_flag)
+                        match(feature_flag, keys, attributes)
+                      else
+                        treatment_hash(Models::Label::KILLED, feature_flag[:defaultTreatment], feature_flag[:changeNumber], split_configurations(feature_flag[:defaultTreatment], feature_flag))
+                      end
+
+          treatment
+        end
+
+        def split_configurations(treatment, split)
+          return nil if split[:configurations].nil?
+          split[:configurations][treatment.to_sym]
+        end
+
+        def match(split, keys, attributes)
+
+          return treatment_hash(Models::Label::PREREQUISITES_NOT_MET, split[:defaultTreatment], split[:changeNumber], split_configurations(split[:defaultTreatment], split)) unless check_prerequisites_matcher(split, keys, attributes)
+
+          in_rollout = false
+          key = keys[:bucketing_key] ? keys[:bucketing_key] : keys[:matching_key]
+          legacy_algo = (split[:algo] == 1 || split[:algo] == nil) ? true : false
+          splitter = Splitter.new
+
+          split[:conditions].each do |c|
+            condition = SplitIoClient::Condition.new(c, @config)
+
+            next if condition.empty?
+
+            if !in_rollout && condition.type == SplitIoClient::Condition::TYPE_ROLLOUT
+              if split[:trafficAllocation] < 100
+                bucket = splitter.bucket(splitter.count_hash(key, split[:trafficAllocationSeed].to_i, legacy_algo))
+
+                if bucket > split[:trafficAllocation]
+                  return treatment_hash(Models::Label::NOT_IN_SPLIT, split[:defaultTreatment], split[:changeNumber], split_configurations(split[:defaultTreatment], split))
+                end
+              end
+
+              in_rollout = true
+            end
+            condition_matched = Helpers::EvaluatorHelper::matcher_type(condition, @segments_repository, @rb_segment_repository).match?(
+              matching_key: keys[:matching_key],
+              bucketing_key: keys[:bucketing_key],
+              evaluator: self,
+              attributes: attributes
+            )
+
+            next unless condition_matched
+
+            result = splitter.get_treatment(key, split[:seed], condition.partitions, split[:algo])
+
+            return treatment_from_result(result, split, c)
+          end
+
+          treatment_hash(Models::Label::NO_RULE_MATCHED, split[:defaultTreatment], split[:changeNumber], split_configurations(split[:defaultTreatment], split))
+        end
+
+        private
+
+        def treatment_from_result(result, split, condition)
+          if result.nil?
+            return treatment_hash(Models::Label::NO_RULE_MATCHED, split[:defaultTreatment], split[:changeNumber], split_configurations(split[:defaultTreatment], split))
+          else
+            return treatment_hash(condition[:label], result, split[:changeNumber],split_configurations(result, split))
+          end
+        end
+
+        def treatment_hash(label, treatment, change_number = nil, configurations = nil)
+          { label: label, treatment: treatment, change_number: change_number, config: configurations }
+        end
+
+        def check_prerequisites_matcher(split, keys, attributes)
+          if split.key?(:prerequisites) && !split[:prerequisites].nil?
+              prerequisites_matcher = SplitIoClient::PrerequisitesMatcher.new(split[:prerequisites], @config.split_logger) 
+              return prerequisites_matcher.match?(
+                  matching_key: keys[:matching_key],
+                  bucketing_key: keys[:bucketing_key],
+                  evaluator: self,
+                  attributes: attributes
+                )
+          end
+
+          true
+        end
+      end
+    end
+  end
+end

data/lib/{splitclient-engine → splitclient-rb/engine}/parser/partition.rb

@@ -1,5 +1,4 @@
 module SplitIoClient
-
   #
   # acts as dto for a partition structure
   #
@@ -30,8 +29,7 @@ module SplitIoClient
     #
     # @return [boolean] true if the partition is empty false otherwise
     def is_empty?
-      @data.empty? ? true : false
+      @data.empty?
     end
   end
-
-end
+end

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,183 @@
+# 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)
+        @back_off = Engine::BackOff.new(1, 3)
+      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 || reconnect
+          @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
+          wait_interval = @back_off.interval
+          @config.logger.debug("Retrying streaming connection in: #{wait_interval} seconds")
+          sleep(wait_interval)
+          @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
+            @back_off.reset
+            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
+            log_if_debug('Incorrect push status type.')
+          end
+        end
+      rescue StandardError => e
+        @config.logger.error("Push status handler error: #{e.inspect}")
+      end
+    end
+
+    def log_if_debug(msg)
+      @config.logger.debug(msg) if @config.debug_enabled
+    end
+  end
+end