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

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Engine
+    class FallbackTreatmentCalculator
+      attr_accessor :fallback_treatments_configuration, :label_prefix
+
+      def initialize(fallback_treatment_configuration)
+        @label_prefix = 'fallback - '
+        @fallback_treatments_configuration = fallback_treatment_configuration
+      end
+
+      def resolve(flag_name, label)
+        default_fallback_treatment = Engine::Models::FallbackTreatment.new(
+          Engine::Models::Treatment::CONTROL,
+          nil,
+          label
+        )
+        return default_fallback_treatment if @fallback_treatments_configuration.nil?
+
+        if !@fallback_treatments_configuration.by_flag_fallback_treatment.nil? \
+            && !@fallback_treatments_configuration.by_flag_fallback_treatment.fetch(flag_name, nil).nil?
+          return copy_with_label(
+            @fallback_treatments_configuration.by_flag_fallback_treatment[flag_name],
+            resolve_label(label)
+          )
+        end
+
+        return copy_with_label(@fallback_treatments_configuration.global_fallback_treatment, resolve_label(label)) \
+          unless @fallback_treatments_configuration.global_fallback_treatment.nil?
+
+        default_fallback_treatment
+      end
+
+      private
+
+      def resolve_label(label)
+        return nil if label.nil?
+
+        @label_prefix + label
+      end
+
+      def copy_with_label(fallback_treatment, label)
+        Engine::Models::FallbackTreatment.new(fallback_treatment.treatment, fallback_treatment.config, label)
+      end
+    end
+  end
+end

data/lib/splitclient-rb/engine/impressions/noop_unique_keys_tracker.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Engine
+    module Impressions
+      class NoopUniqueKeysTracker
+        def call
+          # no-op
+        end
+
+        def track(feature_name, key)
+          # no-op
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/engine/impressions/unique_keys_tracker.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Engine
+    module Impressions
+      class UniqueKeysTracker
+        INTERVAL_TO_CLEAR_LONG_TERM_CACHE = 86_400 # 24 hours
+
+        def initialize(config,
+                       filter_adapter,
+                       sender_adapter,
+                       cache)
+          @config = config
+          @filter_adapter = filter_adapter
+          @sender_adapter = sender_adapter
+          @cache = cache
+          @max_bulk_size = config.unique_keys_bulk_size
+          @semaphore = Mutex.new
+          @keys_size = 0
+        end
+
+        def call
+          @config.threads[:unique_keys_sender] = Thread.new { send_bulk_data_thread }
+          @config.threads[:clear_filter] = Thread.new { clear_filter_thread }
+        end
+
+        def track(feature_name, key)
+          return false if @filter_adapter.contains?(feature_name, key)
+
+          @filter_adapter.add(feature_name, key)
+
+          add_or_update(feature_name, key)
+          @keys_size += 1
+
+          send_bulk_data if @keys_size >= @max_bulk_size
+
+          true
+        rescue StandardError => e
+          @config.log_found_exception(__method__.to_s, e)
+          false
+        end
+
+        private
+
+        def send_bulk_data_thread
+          @config.logger.info('Starting Unique Keys Tracker.') if @config.debug_enabled
+          loop do
+            sleep(@config.unique_keys_refresh_rate)
+            send_bulk_data
+          end
+        rescue SplitIoClient::SDKShutdownException
+          send_bulk_data
+          @config.logger.info('Posting unique keys due to shutdown')
+        end
+
+        def clear_filter_thread
+          loop do
+            sleep(INTERVAL_TO_CLEAR_LONG_TERM_CACHE)
+            @config.logger.debug('Starting task to clean the filter cache.') if @config.debug_enabled
+            @filter_adapter.clear
+          end
+        rescue SplitIoClient::SDKShutdownException
+          @filter_adapter.clear
+        end
+
+        def add_or_update(feature_name, key)
+          if @cache[feature_name].nil?
+            @cache[feature_name] = Set.new([key])
+          else
+            @cache[feature_name].add(key)
+          end
+        end
+
+        def clear_cache
+          uniques = @cache.clone
+          keys_size = @keys_size
+          @cache.clear
+          @keys_size = 0
+
+          [uniques, keys_size]
+        end
+
+        def send_bulk_data
+          @semaphore.synchronize do
+            return if @cache.empty?
+
+            uniques, keys_size = clear_cache
+            if keys_size <= @max_bulk_size
+              @sender_adapter.record_uniques_key(uniques)
+              return
+
+            end
+            bulks = flatten_bulks(uniques)
+            bulks_to_post = group_bulks_by_max_size(bulks)
+            @sender_adapter.record_uniques_key(bulks_to_post)
+          end
+        rescue StandardError => e
+          @config.log_found_exception(__method__.to_s, e)
+        end
+
+        def group_bulks_by_max_size(bulks)
+          current_size = 0
+          bulks_to_post = Concurrent::Hash.new
+          bulks.each do |bulk|
+            key, value = bulk.first
+            if (value.size + current_size) > @max_bulk_size
+              @sender_adapter.record_uniques_key(bulks_to_post)
+              bulks_to_post = Concurrent::Hash.new
+              current_size = 0
+            end
+            bulks_to_post[key] = value
+            current_size += value.size
+          end
+
+          bulks_to_post
+        end
+
+        def flatten_bulks(uniques)
+          bulks = []
+          uniques.each_key do |unique_key|
+            bulks += check_keys_and_split_to_bulks(uniques[unique_key], unique_key)
+          end
+
+          bulks
+        end
+
+        def check_keys_and_split_to_bulks(value, key)
+          unique_updated = []
+          if value.size > @max_bulk_size
+            sub_bulks = SplitIoClient::Utilities.split_bulk_to_send(value, @max_bulk_size)
+            sub_bulks.each do |sub_bulk|
+              unique_updated << { key => sub_bulk.to_set }
+            end
+            return unique_updated
+
+          end
+          unique_updated << { key => value }
+
+          unique_updated
+        end
+      end
+    end
+  end
+end

data/lib/{splitclient-engine → splitclient-rb/engine}/matchers/all_keys_matcher.rb

@@ -1,23 +1,18 @@
-module SplitIoClient
+# frozen_string_literal: true
 
+module SplitIoClient
   #
   # class to implement the all keys matcher
   #
-  class AllKeysMatcher < NoMethodError
-
-    attr_reader :matcher_type
-
-    def initialize
-      @matcher_type = "ALL_KEYS"
-    end
+  class AllKeysMatcher < Matcher
+    MATCHER_TYPE = 'ALL_KEYS'
 
     #
     # evaluates if the key matches the matcher
     #
-    # @param key [string] key value to be matched
-    #
     # @return [boolean] true for all instances
-    def match?(key)
+    def match?(_args)
+      @logger.log_if_debug('[AllKeysMatcher] is always -> true')
       true
     end
 
@@ -26,27 +21,21 @@ module SplitIoClient
     #
     # @param obj [object] object to be evaluated
     #
-    # @returns [boolean] true if obj equals the matcher
+    # @return [boolean] true if obj equals the matcher
     def equals?(obj)
-      if obj.nil?
-        false
-      elsif self.equal?(obj)
+      if obj.instance_of?(AllKeysMatcher)
         true
-      elsif !obj.instance_of?(AllKeysMatcher)
-        false
       else
-        true
+        super(obj)
       end
     end
 
     #
     # function to print string value for this matcher
     #
-    # @reutrn [string] string value of this matcher
+    # @return [string] string value of this matcher
     def to_s
       'in segment all'
     end
-
   end
-
 end

data/lib/splitclient-rb/engine/matchers/between_matcher.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  class BetweenMatcher < Matcher
+    MATCHER_TYPE = 'BETWEEN'
+
+    attr_reader :attribute
+
+    def initialize(attribute_hash, logger, validator)
+      super(logger)
+      @validator = validator
+      @attribute = attribute_hash[:attribute]
+      @data_type = attribute_hash[:data_type]
+      @start_value = formatted_value(attribute_hash[:start_value], true)
+      @end_value = formatted_value(attribute_hash[:end_value], true)
+    end
+
+    def match?(args)
+      @logger.log_if_debug('[BetweenMatcher] evaluating value and attributes.')
+
+      return false unless @validator.valid_matcher_arguments(args)
+
+      value = formatted_value(args[:value] || args[:attributes][@attribute.to_sym])
+      @logger.log_if_debug("[BetweenMatcher] Value from parameters: #{value}.")
+      return false unless value.is_a?(Integer)
+
+      matches = (@start_value..@end_value).cover? value
+      @logger.log_if_debug("[BetweenMatcher] is #{value} between #{@start_value} and #{@end_value} -> #{matches} .")
+      matches
+    end
+
+    private
+
+    def formatted_value(value, sdk_data = false)
+      case @data_type
+      when 'NUMBER'
+        value
+      when 'DATETIME'
+        value /= 1000 if sdk_data
+
+        SplitIoClient::Utilities.to_milis_zero_out_from_seconds(value)
+      else
+        @logger.error('Invalid data type')
+      end
+    end
+  end
+end

data/lib/splitclient-rb/engine/matchers/between_semver_matcher.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  class BetweenSemverMatcher < Matcher
+    MATCHER_TYPE = 'BETWEEN_SEMVER'
+
+    attr_reader :attribute
+
+    def initialize(attribute, start_value, end_value, logger, validator)
+      super(logger)
+      @validator = validator
+      @attribute = attribute
+      @semver_start = SplitIoClient::Semver.build(start_value, logger)
+      @semver_end = SplitIoClient::Semver.build(end_value, logger)
+      @logger = logger
+    end
+
+    def match?(args)
+      return false unless verify_semver_arg?(args, 'BetweenSemverMatcher')
+
+      value_to_match = SplitIoClient::Semver.build(args[:attributes][@attribute.to_sym], @logger)
+      if value_to_match.nil? || @semver_start.nil? || @semver_end.nil?
+        @logger.error('betweenStringMatcherData is required for BETWEEN_SEMVER matcher type')
+        return false
+
+      end
+      matches = ([0, -1].include?(@semver_start.compare(value_to_match)) &&
+                 [0, 1].include?(@semver_end.compare(value_to_match)))
+      @logger.debug("[BetweenMatcher] #{value_to_match} matches -> #{matches}")
+      matches
+    end
+  end
+end

data/lib/{splitclient-engine → splitclient-rb/engine}/matchers/combiners.rb

@@ -1,13 +1,11 @@
-module SplitIoClient
+# frozen_string_literal: true
 
+module SplitIoClient
   #
   # class to represent combiner values
   #
-  class Combiners < NoMethodError
-
+  class Combiners
     # available combiners of the sdk
     AND = 'AND'
-
   end
-
-end
+end

data/lib/splitclient-rb/engine/matchers/combining_matcher.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  #
+  # class to implement the combining matcher
+  #
+  class CombiningMatcher < Matcher
+    MATCHER_TYPE = 'COMBINING_MATCHER'
+
+    def initialize(logger, combiner = '', matchers = [])
+      super(logger)
+      @combiner = combiner
+      @matchers = matchers
+    end
+
+    #
+    # evaluates if the key matches the matchers within the combiner
+    #
+    # @param matching_key [string] key value to be matched
+    # @param bucketing_key [string] bucketing key to be matched
+    # @param evaluator [instance of Evaluator class]
+    # @param attributes [hash]
+    #
+    # @return [boolean]
+    def match?(args)
+      if @matchers.empty?
+        @logger.log_if_debug('[CombiningMatcher] Matchers Empty')
+        return false
+      end
+
+      case @combiner
+      when Combiners::AND
+        matches = eval_and(args)
+        @logger.log_if_debug("[CombiningMatcher] Combiner AND result -> #{matches}")
+        return matches
+      else
+        @logger.log_if_debug("[CombiningMatcher] Invalid Combiner Type - Combiner -> #{@combiner}")
+        @logger.error('Invalid combiner type')
+      end
+
+      false
+    end
+
+    #
+    # auxiliary method to evaluate each of the matchers within the combiner
+    #
+    # @param matching_key [string] key value to be matched
+    # @param bucketing_key [string] bucketing key to be matched
+    # @param evaluator [Evaluator] used in dependency_matcher
+    # @param attributes [hash]  attributes to pass to the treatment class
+    #
+    # @return [boolean] match value for combiner delegates
+    def eval_and(args)
+      # Convert all keys to symbols
+      args[:attributes] = args[:attributes].each_with_object({}) { |(k, v), memo| memo[k.to_sym] = v } if args && args[:attributes]
+
+      @matchers.all? do |matcher|
+        if match_with_key?(matcher)
+          key = args[:value]
+          key = args[:matching_key] unless args[:matching_key].nil?
+          matcher.match?(value: key)
+        else
+          matcher.match?(args)
+        end
+      end
+    end
+
+    def match_with_key?(matcher)
+      matcher.respond_to?(:attribute) && matcher.attribute.nil? && matcher.string_type?
+    end
+
+    #
+    # function to print string value for this matcher
+    #
+    # @return [string] string value of this matcher
+    def to_s
+      @matcher_list.map(&:to_s).join("#{@combiner} ")
+    end
+  end
+end

data/lib/splitclient-rb/engine/matchers/contains_all_matcher.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  class ContainsAllMatcher < SetMatcher
+    MATCHER_TYPE = 'CONTAINS_ALL'
+
+    attr_reader :attribute
+
+    def match?(args)
+      if @remote_set.empty?
+        @logger.log_if_debug('[ContainsAllMatcher] Remote Set Empty')
+        return false
+      end
+
+      matches = @remote_set.subset? local_set(args[:attributes], @attribute)
+      @logger.log_if_debug("[ContainsAllMatcher] Remote Set #{@remote_set} contains #{@attribute} -> #{matches}")
+      matches
+    end
+  end
+end

data/lib/splitclient-rb/engine/matchers/contains_any_matcher.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  class ContainsAnyMatcher < SetMatcher
+    MATCHER_TYPE = 'CONTAINS_ANY'
+
+    attr_reader :attribute
+
+    def match?(args)
+      matches = local_set(args[:attributes], @attribute).intersect? @remote_set
+      @logger.log_if_debug("[ContainsAnyMatcher] Remote Set #{@remote_set} contains any \
+        #{@attribute} or #{args[:attributes]}-> #{matches}")
+      matches
+    end
+  end
+end

data/lib/splitclient-rb/engine/matchers/contains_matcher.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  class ContainsMatcher
+    MATCHER_TYPE = 'CONTAINS_WITH'
+
+    attr_reader :attribute
+
+    def initialize(attribute, substr_list, logger, validator)
+      @attribute = attribute
+      @substr_list = substr_list
+      @logger = logger
+      @validator = validator
+    end
+
+    def match?(args)
+      @logger.log_if_debug('[ContainsMatcher] evaluating value and attributes.')
+
+      return false unless @validator.valid_matcher_arguments(args)
+
+      value = get_value(args)
+
+      @logger.log_if_debug("[ContainsMatcher] Value from parameters: #{value}.")
+      return false if @substr_list.empty?
+
+      matches = @substr_list.any? { |substr| value.to_s.include? substr }
+      @logger.log_if_debug("[ContainsMatcher] #{@value} contains any of #{@substr_list} -> #{matches} .")
+      matches
+    end
+
+    def string_type?
+      true
+    end
+
+    private
+
+    def get_value(args)
+      args[:value] || args[:attributes].fetch(@attribute) do |a|
+        args[:attributes][a.to_s] || args[:attributes][a.to_sym]
+      end
+    end
+  end
+end

data/lib/splitclient-rb/engine/matchers/dependency_matcher.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  class DependencyMatcher
+    MATCHER_TYPE = 'IN_SPLIT_TREATMENT'
+
+    def initialize(feature_flag, treatments, logger)
+      @feature_flag = feature_flag
+      @treatments = treatments
+      @logger = logger
+    end
+
+    def match?(args)
+      keys = { matching_key: args[:matching_key], bucketing_key: args[:bucketing_key] }
+      evaluate = args[:evaluator].evaluate_feature_flag(keys, @feature_flag, args[:attributes])
+      matches = @treatments.include?(evaluate[:treatment])
+      @logger.log_if_debug("[dependencyMatcher] Parent feature flag #{@feature_flag} evaluated to #{evaluate[:treatment]} \
+        with label #{evaluate[:label]}. #{@feature_flag} evaluated treatment is part of [#{@treatments}] ? #{matches}.")
+      matches
+    end
+
+    def string_type?
+      false
+    end
+  end
+end

data/lib/splitclient-rb/engine/matchers/ends_with_matcher.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  class EndsWithMatcher
+    MATCHER_TYPE = 'ENDS_WITH'
+
+    attr_reader :attribute
+
+    def initialize(attribute, suffix_list, logger)
+      @attribute = attribute
+      @suffix_list = suffix_list
+      @logger = logger
+    end
+
+    def match?(args)
+      value = get_value(args)
+
+      @logger.log_if_debug("[EndsWithMatcher] Value from parameters: #{value}.")
+
+      if @suffix_list.empty?
+        @logger.log_if_debug('[EndsWithMatcher] Sufix List empty.')
+        return false
+      end
+
+      matches = @suffix_list.any? { |suffix| value.to_s.end_with? suffix }
+      @logger.log_if_debug("[EndsWithMatcher] #{value} ends with any #{@suffix_list}")
+      matches
+    end
+
+    def string_type?
+      true
+    end
+
+    private
+
+    def get_value(args)
+      args[:value] || args[:attributes].fetch(@attribute) do |a|
+        args[:attributes][a.to_s] || args[:attributes][a.to_sym]
+      end
+    end
+  end
+end

data/lib/splitclient-rb/engine/matchers/equal_to_boolean_matcher.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  class EqualToBooleanMatcher
+    MATCHER_TYPE = 'EQUAL_TO_BOOLEAN'
+
+    attr_reader :attribute
+
+    def initialize(attribute, boolean, logger)
+      @attribute = attribute
+      @boolean = boolean
+      @logger = logger
+    end
+
+    def match?(args)
+      value = get_value(args)
+      value = false if value.to_s.casecmp('false').zero?
+      value = true if value.to_s.casecmp('true').zero?
+
+      matches = value == @boolean
+      @logger.log_if_debug("[EqualToBooleanMatcher] #{value} equals to #{@boolean} -> #{matches}")
+      matches
+    end
+
+    def string_type?
+      false
+    end
+
+    private
+
+    def get_value(args)
+      args[:attributes].fetch(@attribute) do |a|
+        args[:attributes][a.to_s] || args[:attributes][a.to_sym]
+      end
+    end
+  end
+end

data/lib/splitclient-rb/engine/matchers/equal_to_matcher.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  class EqualToMatcher < Matcher
+    MATCHER_TYPE = 'EQUAL_TO'
+
+    attr_reader :attribute
+
+    def initialize(attribute_hash, logger, validator)
+      super(logger)
+      @validator = validator
+      @attribute = attribute_hash[:attribute]
+      @data_type = attribute_hash[:data_type]
+      @value = formatted_value(attribute_hash[:value], true)
+    end
+
+    def match?(args)
+      @logger.log_if_debug('[EqualsToMatcher] evaluating value and attributes.')
+
+      return false unless @validator.valid_matcher_arguments(args)
+
+      value = formatted_value(args[:value] || args[:attributes][@attribute.to_sym])
+
+      matches = value.is_a?(Integer) ? (value == @value) : false
+      @logger.log_if_debug("[EqualsToMatcher] #{value} equals to #{@value} -> #{matches}")
+      matches
+    end
+
+    private
+
+    def formatted_value(value, sdk_data = false)
+      case @data_type
+      when 'NUMBER'
+        value
+      when 'DATETIME'
+        value /= 1000 if sdk_data
+
+        SplitIoClient::Utilities.to_milis_zero_out_from_hour value
+      else
+        @logger.error('Invalid data type')
+      end
+    end
+  end
+end