splitclient-rb 4.5.1-java

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

@@ -0,0 +1,83 @@
+module SplitIoClient
+
+  #
+  # class to handle cached metrics
+  #
+  class Metrics < NoMethodError
+
+    @counter
+    @delta
+
+    #
+    # cached latencies
+    #
+    # @return [object] array of latencies
+    attr_accessor :latencies
+
+    #
+    # cached counts
+    #
+    # @return [object] array of counts
+    attr_accessor :counts
+
+    #
+    # cached gauges
+    #
+    # @return [object] array of gauges
+    attr_accessor :gauges
+
+    #
+    # quese size for cached arrays
+    #
+    # @return [int] queue size
+    attr_accessor :queue_size
+
+    def initialize(queue_size, config, repository)
+      @queue_size = queue_size
+      @binary_search = SplitIoClient::BinarySearchLatencyTracker.new
+
+      @config = config
+
+      @repository = repository
+    end
+
+    #
+    # creates a new entry in the array for cached counts
+    #
+    # @param counter [string] name of the counter
+    # @delta [int] value of the counter
+    #
+    # @return void
+    def count(counter, delta)
+      return if (delta <= 0) || counter.nil? || counter.strip.empty?
+
+      @repository.add_count(counter, delta)
+    end
+
+    #
+    # creates a new entry in the array for cached time metrics
+    #
+    # @param operation [string] name of the operation
+    # @time_in_ms [number] time in miliseconds
+    #
+    # @return void
+    def time(operation, time_in_ms)
+      return if operation.nil? || operation.empty? || time_in_ms < 0
+
+      @repository.add_latency(operation, time_in_ms, @binary_search)
+    end
+
+    #
+    # creates a new entry in the array for cached gauges
+    #
+    # @param gauge [string] name of the gauge
+    # @value [number] value of the gauge
+    #
+    # @return void
+    def gauge(gauge, value)
+      return if gauge.nil? || gauge.empty?
+
+      @repository.add_gauge(gauge, value)
+    end
+  end
+end

data/lib/splitclient-rb/engine/models/label.rb

@@ -0,0 +1,8 @@
+class SplitIoClient::Engine::Models::Label
+  ARCHIVED = 'archived'.freeze
+  NO_RULE_MATCHED = 'default rule'.freeze
+  EXCEPTION = 'exception'.freeze
+  KILLED = 'killed'.freeze
+  NOT_IN_SPLIT = 'not in split'.freeze
+  DEFINITION_NOT_FOUND = 'definition not found'.freeze
+end

data/lib/splitclient-rb/engine/models/split.rb

@@ -0,0 +1,17 @@
+module SplitIoClient
+  module Engine
+    module Models
+      class Split
+        class << self
+          def matchable?(data)
+            data && data[:status] == 'ACTIVE' && data[:killed] == false
+          end
+
+          def archived?(data)
+            data && data[:status] == 'ARCHIVED'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/engine/models/treatment.rb

@@ -0,0 +1,3 @@
+class SplitIoClient::Engine::Models::Treatment
+  CONTROL = 'control'.freeze
+end

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

@@ -0,0 +1,210 @@
+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)
+      @data = condition
+      @partitions = set_partitions
+    end
+
+    def create_condition_matcher(matchers)
+      CombiningMatcher.new(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(matcher)
+    end
+
+    def matcher_all_keys(_params)
+      @matcher_all_keys ||= AllKeysMatcher.new
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    end
+
+    def matcher_equal_to_set(params)
+      EqualToSetMatcher.new(
+        params[:matcher][:keySelector][:attribute],
+        params[:matcher][:whitelistMatcherData][:whitelist]
+      )
+    end
+
+    def matcher_contains_any_of_set(params)
+      ContainsAnyMatcher.new(
+        params[:matcher][:keySelector][:attribute],
+        params[:matcher][:whitelistMatcherData][:whitelist]
+      )
+    end
+
+    def matcher_contains_all_of_set(params)
+      ContainsAllMatcher.new(
+        params[:matcher][:keySelector][:attribute],
+        params[:matcher][:whitelistMatcherData][:whitelist]
+      )
+    end
+
+    def matcher_part_of_set(params)
+      PartOfSetMatcher.new(
+        params[:matcher][:keySelector][:attribute],
+        params[:matcher][:whitelistMatcherData][:whitelist]
+      )
+    end
+
+    def matcher_starts_with(params)
+      StartsWithMatcher.new(
+        params[:matcher][:keySelector][:attribute],
+        params[:matcher][:whitelistMatcherData][:whitelist]
+      )
+    end
+
+    def matcher_ends_with(params)
+      EndsWithMatcher.new(
+        params[:matcher][:keySelector][:attribute],
+        params[:matcher][:whitelistMatcherData][:whitelist]
+      )
+    end
+
+    def matcher_contains_string(params)
+      ContainsMatcher.new(
+        params[:matcher][:keySelector][:attribute],
+        params[:matcher][:whitelistMatcherData][:whitelist]
+      )
+    end
+
+    def matcher_in_split_treatment(params)
+      DependencyMatcher.new(
+        params[:matcher][:dependencyMatcherData][:split],
+        params[:matcher][:dependencyMatcherData][:treatments]
+      )
+    end
+
+    def matcher_equal_to_boolean(params)
+      EqualToBooleanMatcher.new(
+        params[:matcher][:keySelector][:attribute],
+        params[:matcher][:booleanMatcherData]
+      )
+    end
+
+    def matcher_matches_string(params)
+      MatchesStringMatcher.new(
+        params[:matcher][:keySelector][:attribute],
+        params[:matcher][:stringMatcherData]
+      )
+    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 = []
+      @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,118 @@
+module SplitIoClient
+  module Engine
+    module Parser
+      class Evaluator
+        def initialize(segments_repository, splits_repository, multiple = false)
+          @splits_repository = splits_repository
+          @segments_repository = segments_repository
+          @multiple = multiple
+          @cache = {}
+        end
+
+        def call(keys, split, attributes = nil)
+          # DependencyMatcher here, split is actually a split_name in this case
+          cache_result = split.is_a? String
+          split = @splits_repository.get_split(split) if cache_result
+          digest = Digest::MD5.hexdigest("#{{matching_key: keys[:matching_key]}}#{split}#{attributes}")
+
+          if Models::Split.archived?(split)
+            return treatment_hash(Models::Label::ARCHIVED, Models::Treatment::CONTROL, split[:changeNumber])
+          end
+
+          treatment = if Models::Split.matchable?(split)
+            if @multiple && @cache[digest]
+              @cache[digest]
+            else
+              match(split, keys, attributes)
+            end
+          else
+            treatment_hash(Models::Label::KILLED, split[:defaultTreatment], split[:changeNumber])
+          end
+
+          @cache[digest] = treatment if cache_result
+
+          treatment
+        end
+
+        private
+
+        def match(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)
+
+            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])
+                end
+              end
+
+              in_rollout = true
+            end
+
+            condition_matched = matcher_type(condition).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])
+
+            if result.nil?
+              return treatment_hash(Models::Label::NO_RULE_MATCHED, split[:defaultTreatment], split[:changeNumber])
+            else
+              return treatment_hash(c[:label], result, split[:changeNumber])
+            end
+          end
+
+          treatment_hash(Models::Label::NO_RULE_MATCHED, split[:defaultTreatment], split[:changeNumber])
+        end
+
+        def matcher_type(condition)
+          matchers = []
+
+          @segments_repository.adapter.pipelined do
+            condition.matchers.each do |matcher|
+              matchers << if matcher[:negate]
+                condition.negation_matcher(matcher_instance(matcher[:matcherType], condition, matcher))
+              else
+                matcher_instance(matcher[:matcherType], condition, matcher)
+              end
+            end
+          end
+
+          final_matcher = condition.create_condition_matcher(matchers)
+
+          if final_matcher.nil?
+            @logger.error('Invalid matcher type')
+          else
+            final_matcher
+          end
+        end
+
+        def treatment_hash(label, treatment, change_number = nil)
+          { label: label, treatment: treatment, change_number: change_number }
+        end
+
+        def matcher_instance(type, condition, matcher)
+          condition.send(
+            "matcher_#{type.downcase}",
+            matcher: matcher, segments_repository: @segments_repository
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module SplitIoClient
+  #
+  # acts as dto for a partition structure
+  #
+  class Partition < NoMethodError
+
+    #
+    # definition of the condition
+    #
+    # @returns [object] condition values
+    attr_accessor :data
+
+    def initialize(partition)
+      @data = partition
+    end
+
+    #
+    # @return [object] the treatment value for this partition
+    def treatment
+      @data[:treatment]
+    end
+
+    #
+    # @return [object] the size value for this partition
+    def size
+      @data[:size]
+    end
+
+    #
+    # @return [boolean] true if the partition is empty false otherwise
+    def is_empty?
+      @data.empty?
+    end
+  end
+end