splitclient-rb 6.3.0 → 8.11.0

data/lib/splitclient-rb/engine/events/events_task.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Engine
+    module Events
+      class EventsTask
+        attr_accessor :running
+
+        def initialize(notify_internal_events, internal_events_queue, config)
+          @notify_internal_events = notify_internal_events
+          @internal_events_queue = internal_events_queue
+          @config = config
+          @running = false
+        end
+
+        def start
+          return if @running
+
+          @config.logger.info('Starting Internal Events Task.')
+          @running = true
+          @config.threads[:internal_events_task] = Thread.new do
+            worker_thread
+          end
+        end
+
+        def stop
+          return unless @running
+
+          @config.logger.info('Stopping Internal Events Task.')
+          @running = false
+        end
+
+        private
+
+        def worker_thread
+          while (event = @internal_events_queue.pop)
+            break unless @running
+
+            @config.logger.debug("Processing sdk internal event: #{event.internal_event}") if @config.debug_enabled
+            begin
+              @notify_internal_events.call(event.internal_event, event.metadata)
+            rescue StandardError => e
+              @config.log_found_exception(__method__.to_s, e)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/engine/events/noop_events_queue.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Engine
+    module Events
+      class NoOpEventsQueue
+        def push(sdk_event)
+          # do nothing
+        end
+      end
+    end
+  end
+end

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-rb/engine/matchers/all_keys_matcher.rb

@@ -12,7 +12,7 @@ module SplitIoClient
     #
     # @return [boolean] true for all instances
     def match?(_args)
-      SplitLogger.log_if_debug('[AllKeysMatcher] is always -> true')
+      @logger.log_if_debug('[AllKeysMatcher] is always -> true')
       true
     end
 

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

@@ -6,7 +6,9 @@ module SplitIoClient
 
     attr_reader :attribute
 
-    def initialize(attribute_hash)
+    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)
@@ -14,16 +16,16 @@ module SplitIoClient
     end
 
     def match?(args)
-      SplitLogger.log_if_debug('[BetweenMatcher] evaluating value and attributes.')
+      @logger.log_if_debug('[BetweenMatcher] evaluating value and attributes.')
 
-      return false unless SplitIoClient::Validators.valid_matcher_arguments(args)
+      return false unless @validator.valid_matcher_arguments(args)
 
       value = formatted_value(args[:value] || args[:attributes][@attribute.to_sym])
-      SplitLogger.log_if_debug("[BetweenMatcher] Value from parameters: #{value}.")
+      @logger.log_if_debug("[BetweenMatcher] Value from parameters: #{value}.")
       return false unless value.is_a?(Integer)
 
       matches = (@start_value..@end_value).cover? value
-      SplitLogger.log_if_debug("[BetweenMatcher] is #{value} between #{@start_value} and #{@end_value} -> #{matches} .")
+      @logger.log_if_debug("[BetweenMatcher] is #{value} between #{@start_value} and #{@end_value} -> #{matches} .")
       matches
     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-rb/engine/matchers/combining_matcher.rb

@@ -7,7 +7,8 @@ module SplitIoClient
   class CombiningMatcher < Matcher
     MATCHER_TYPE = 'COMBINING_MATCHER'
 
-    def initialize(combiner = '', matchers = [])
+    def initialize(logger, combiner = '', matchers = [])
+      super(logger)
       @combiner = combiner
       @matchers = matchers
     end
@@ -23,17 +24,17 @@ module SplitIoClient
     # @return [boolean]
     def match?(args)
       if @matchers.empty?
-        SplitLogger.log_if_debug('[CombiningMatcher] Matchers Empty')
+        @logger.log_if_debug('[CombiningMatcher] Matchers Empty')
         return false
       end
 
       case @combiner
       when Combiners::AND
         matches = eval_and(args)
-        SplitLogger.log_if_debug("[CombiningMatcher] Combiner AND result -> #{matches}")
+        @logger.log_if_debug("[CombiningMatcher] Combiner AND result -> #{matches}")
         return matches
       else
-        SplitLogger.log_if_debug("[CombiningMatcher] Invalid Combiner Type - Combiner -> #{@combiner}")
+        @logger.log_if_debug("[CombiningMatcher] Invalid Combiner Type - Combiner -> #{@combiner}")
         @logger.error('Invalid combiner type')
       end
 
@@ -51,12 +52,13 @@ module SplitIoClient
     # @return [boolean] match value for combiner delegates
     def eval_and(args)
       # Convert all keys to symbols
-      if args && args[:attributes]
-        args[:attributes] = args[:attributes].each_with_object({}) { |(k, v), memo| memo[k.to_sym] = v }
-      end
+      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)
-          matcher.match?(value: args[:matching_key])
+          key = args[:value]
+          key = args[:matching_key] unless args[:matching_key].nil?
+          matcher.match?(value: key)
         else
           matcher.match?(args)
         end

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

@@ -6,18 +6,14 @@ module SplitIoClient
 
     attr_reader :attribute
 
-    def initialize(attribute, remote_array)
-      super(attribute, remote_array)
-    end
-
     def match?(args)
       if @remote_set.empty?
-        SplitLogger.log_if_debug('[ContainsAllMatcher] Remote Set Empty')
+        @logger.log_if_debug('[ContainsAllMatcher] Remote Set Empty')
         return false
       end
 
       matches = @remote_set.subset? local_set(args[:attributes], @attribute)
-      SplitLogger.log_if_debug("[ContainsAllMatcher] Remote Set #{@remote_set} contains #{@attribute} -> #{matches}")
+      @logger.log_if_debug("[ContainsAllMatcher] Remote Set #{@remote_set} contains #{@attribute} -> #{matches}")
       matches
     end
   end

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

@@ -6,13 +6,9 @@ module SplitIoClient
 
     attr_reader :attribute
 
-    def initialize(attribute, remote_array)
-      super(attribute, remote_array)
-    end
-
     def match?(args)
       matches = local_set(args[:attributes], @attribute).intersect? @remote_set
-      SplitLogger.log_if_debug("[ContainsAnyMatcher] Remote Set #{@remote_set} contains any \
+      @logger.log_if_debug("[ContainsAnyMatcher] Remote Set #{@remote_set} contains any \
         #{@attribute} or #{args[:attributes]}-> #{matches}")
       matches
     end

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

@@ -6,23 +6,25 @@ module SplitIoClient
 
     attr_reader :attribute
 
-    def initialize(attribute, substr_list)
+    def initialize(attribute, substr_list, logger, validator)
       @attribute = attribute
       @substr_list = substr_list
+      @logger = logger
+      @validator = validator
     end
 
     def match?(args)
-      SplitLogger.log_if_debug('[ContainsMatcher] evaluating value and attributes.')
+      @logger.log_if_debug('[ContainsMatcher] evaluating value and attributes.')
 
-      return false unless SplitIoClient::Validators.valid_matcher_arguments(args)
+      return false unless @validator.valid_matcher_arguments(args)
 
       value = get_value(args)
 
-      SplitLogger.log_if_debug("[ContainsMatcher] Value from parameters: #{value}.")
+      @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 }
-      SplitLogger.log_if_debug("[ContainsMatcher] #{@value} contains any of #{@substr_list} -> #{matches} .")
+      @logger.log_if_debug("[ContainsMatcher] #{@value} contains any of #{@substr_list} -> #{matches} .")
       matches
     end
 

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

@@ -4,17 +4,18 @@ module SplitIoClient
   class DependencyMatcher
     MATCHER_TYPE = 'IN_SPLIT_TREATMENT'
 
-    def initialize(split, treatments)
-      @split = split
+    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].call(keys, @split, args[:attributes])
+      evaluate = args[:evaluator].evaluate_feature_flag(keys, @feature_flag, args[:attributes])
       matches = @treatments.include?(evaluate[:treatment])
-      SplitLogger.log_if_debug("[dependencyMatcher] Parent split #{@split} evaluated to #{evaluate[:treatment]} \
-        with label #{evaluate[:label]}. #{@split} evaluated treatment is part of [#{@treatments}] ? #{matches}.")
+      @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
 

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

@@ -6,23 +6,24 @@ module SplitIoClient
 
     attr_reader :attribute
 
-    def initialize(attribute, suffix_list)
+    def initialize(attribute, suffix_list, logger)
       @attribute = attribute
       @suffix_list = suffix_list
+      @logger = logger
     end
 
     def match?(args)
       value = get_value(args)
 
-      SplitLogger.log_if_debug("[EndsWithMatcher] Value from parameters: #{value}.")
+      @logger.log_if_debug("[EndsWithMatcher] Value from parameters: #{value}.")
 
       if @suffix_list.empty?
-        SplitLogger.log_if_debug('[EndsWithMatcher] Sufix List empty.')
+        @logger.log_if_debug('[EndsWithMatcher] Sufix List empty.')
         return false
       end
 
       matches = @suffix_list.any? { |suffix| value.to_s.end_with? suffix }
-      SplitLogger.log_if_debug("[EndsWithMatcher] #{value} ends with any #{@suffix_list}")
+      @logger.log_if_debug("[EndsWithMatcher] #{value} ends with any #{@suffix_list}")
       matches
     end
 

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

@@ -6,9 +6,10 @@ module SplitIoClient
 
     attr_reader :attribute
 
-    def initialize(attribute, boolean)
+    def initialize(attribute, boolean, logger)
       @attribute = attribute
       @boolean = boolean
+      @logger = logger
     end
 
     def match?(args)
@@ -17,7 +18,7 @@ module SplitIoClient
       value = true if value.to_s.casecmp('true').zero?
 
       matches = value == @boolean
-      SplitLogger.log_if_debug("[EqualToBooleanMatcher] #{value} equals to #{@boolean} -> #{matches}")
+      @logger.log_if_debug("[EqualToBooleanMatcher] #{value} equals to #{@boolean} -> #{matches}")
       matches
     end
 

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

@@ -6,21 +6,23 @@ module SplitIoClient
 
     attr_reader :attribute
 
-    def initialize(attribute_hash)
+    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)
-      SplitLogger.log_if_debug('[EqualsToMatcher] evaluating value and attributes.')
+      @logger.log_if_debug('[EqualsToMatcher] evaluating value and attributes.')
 
-      return false unless SplitIoClient::Validators.valid_matcher_arguments(args)
+      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
-      SplitLogger.log_if_debug("[EqualsToMatcher] #{value} equals to #{@value} -> #{matches}")
+      @logger.log_if_debug("[EqualsToMatcher] #{value} equals to #{@value} -> #{matches}")
       matches
     end
 

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  class EqualToSemverMatcher < Matcher
+    MATCHER_TYPE = 'EQUAL_TO_SEMVER'
+
+    attr_reader :attribute
+
+    def initialize(attribute, string_value, logger, validator)
+      super(logger)
+      @validator = validator
+      @attribute = attribute
+      @semver = SplitIoClient::Semver.build(string_value, logger)
+      @logger = logger
+    end
+
+    def match?(args)
+      return false unless verify_semver_arg?(args, 'EqualsToSemverMatcher')
+
+      value_to_match = SplitIoClient::Semver.build(args[:attributes][@attribute.to_sym], @logger)
+      return false unless check_semver_value_to_match(value_to_match, MATCHER_TYPE)
+
+      matches = (@semver.version == value_to_match.version)
+      @logger.debug("[EqualsToSemverMatcher] #{value_to_match} matches -> #{matches}")
+      matches
+    end
+  end
+end

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

@@ -6,14 +6,10 @@ module SplitIoClient
 
     attr_reader :attribute
 
-    def initialize(attribute, remote_array)
-      super(attribute, remote_array)
-    end
-
     def match?(args)
       set = local_set(args[:attributes], @attribute)
       matches = set == @remote_set
-      SplitLogger.log_if_debug("[EqualsToSetMatcher] #{set} equals to #{@remote_set} -> #{matches}")
+      @logger.log_if_debug("[EqualsToSetMatcher] #{set} equals to #{@remote_set} -> #{matches}")
       matches
     end
   end

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

@@ -6,21 +6,23 @@ module SplitIoClient
 
     attr_reader :attribute
 
-    def initialize(attribute_hash)
+    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)
-      SplitLogger.log_if_debug('[GreaterThanOrEqualToMatcher] evaluating value and attributes.')
+      @logger.log_if_debug('[GreaterThanOrEqualToMatcher] evaluating value and attributes.')
 
-      return false unless SplitIoClient::Validators.valid_matcher_arguments(args)
+      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
-      SplitLogger.log_if_debug("[GreaterThanOrEqualToMatcher] #{value} greater than or equal to #{@value} -> #{matches}")
+      @logger.log_if_debug("[GreaterThanOrEqualToMatcher] #{value} greater than or equal to #{@value} -> #{matches}")
       matches
     end