splitclient-rb 4.5.1-java

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

@@ -0,0 +1,53 @@
+module SplitIoClient
+  class LessThanOrEqualToMatcher
+    MATCHER_TYPE = 'LESS_THAN_OR_EQUAL_TO'.freeze
+
+    attr_reader :attribute
+
+    def initialize(attribute_hash)
+      @attribute = attribute_hash[:attribute]
+      @data_type = attribute_hash[:data_type]
+      @value = formatted_value(attribute_hash[:value], true)
+    end
+
+    def match?(args)
+      return false if !args.key?(:attributes) && !args.key?(:value)
+      return false if args.key?(:value) && args[:value].nil?
+      return false if args.key?(:attributes) && args[:attributes].nil?
+
+      value = formatted_value(args[:value] || args[:attributes][@attribute.to_sym])
+
+      value.is_a?(Integer) ? (value <= @value) : false
+    end
+
+    def equals?(obj)
+      if obj.nil?
+        false
+      elsif !obj.instance_of?(LessThanOrEqualToMatcher)
+        false
+      elsif self.equal?(obj)
+        true
+      else
+        false
+      end
+    end
+
+    def string_type?
+      false
+    end
+
+    private
+
+    def formatted_value(value, sdk_data = false)
+      case @data_type
+      when 'NUMBER'
+        return value
+      when 'DATETIME'
+        value = value / 1000 if sdk_data # sdk returns already miliseconds, turning to seconds to do a correct zero_our
+        return 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/matches_string_matcher.rb

@@ -0,0 +1,24 @@
+module SplitIoClient
+  class MatchesStringMatcher
+    MATCHER_TYPE = 'MATCHES_STRING'.freeze
+
+    attr_reader :attribute
+
+    def initialize(attribute, regexp_string)
+      @attribute = attribute
+      @regexp_string = @regexp_string.is_a?(Regexp) ? regexp_string : Regexp.new(regexp_string)
+    end
+
+    def match?(args)
+      value = args[:value] || args[:attributes].fetch(@attribute) do |a|
+        args[:attributes][a.to_s] || args[:attributes][a.to_sym]
+      end
+
+      (value =~ @regexp_string) != nil
+    end
+
+    def string_type?
+      true
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+module SplitIoClient
+  #
+  # class to implement the negation of a matcher
+  #
+  class NegationMatcher
+    MATCHER_TYPE = 'NEGATION_MATCHER'.freeze
+
+    def initialize(matcher = nil)
+      @matcher = matcher
+    end
+
+    #
+    # evaluates if the key matches the negation of the matcher
+    #
+    # @param key [string] key value to be matched
+    #
+    # @return [boolean] evaluation of the negation matcher
+    def match?(args)
+      !@matcher.match?(args)
+    end
+
+    def respond_to?(method)
+      @matcher.respond_to? method
+    end
+
+    def attribute
+      @matcher.attribute
+    end
+
+    def string_type?
+      @matcher.string_type?
+    end
+
+    #
+    # evaluates if the given object equals the matcher
+    #
+    # @param obj [object] object to be evaluated
+    #
+    # @returns [boolean] true if obj equals the matcher
+    def equals?(obj)
+      if obj.nil?
+        false
+      elsif !obj.instance_of?(NegationMatcher)
+        false
+      elsif self.equal?(obj)
+        true
+      else
+        false
+      end
+    end
+
+    #
+    # function to print string value for this matcher
+    #
+    # @reutrn [string] string value of this matcher
+    def to_s
+      "not #{@matcher}"
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module SplitIoClient
+  class PartOfSetMatcher < SetMatcher
+    MATCHER_TYPE = 'PART_OF_SET'.freeze
+
+    attr_reader :attribute
+
+    def initialize(attribute, remote_array)
+      super(attribute, remote_array)
+    end
+
+    def match?(args)
+      @local_set = local_set(args[:attributes], @attribute)
+
+      return false if @local_set.empty?
+
+      @local_set.subset? @remote_set
+    end
+
+    def string_type?
+      false
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'set'
+
+module SplitIoClient
+  class SetMatcher
+    protected
+
+    def initialize(attribute, remote_array)
+      @attribute = attribute
+      @remote_set = remote_array.to_set
+    end
+
+    def local_set(data, attribute)
+      data = data.fetch(attribute) { |a| data[a.to_s] || data[a.to_sym] }
+      # Allow user to pass individual elements as well
+      local_array = data.kind_of?(Array) ? data : [data]
+
+      local_array.to_set
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module SplitIoClient
+  class StartsWithMatcher
+    MATCHER_TYPE = 'STARTS_WITH'.freeze
+
+    attr_reader :attribute
+
+    def initialize(attribute, prefix_list)
+      @attribute = attribute
+      @prefix_list = prefix_list
+    end
+
+    def match?(args)
+      value = args[:value] || args[:attributes].fetch(@attribute) do |a|
+        args[:attributes][a.to_s] || args[:attributes][a.to_sym]
+      end
+
+      return false if @prefix_list.empty?
+
+      @prefix_list.any? { |prefix| value.to_s.start_with? prefix }
+    end
+
+    def string_type?
+      true
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module SplitIoClient
+  #
+  # class to implement the user defined matcher
+  #
+  class UserDefinedSegmentMatcher
+    MATCHER_TYPE = 'IN_SEGMENT'.freeze
+
+    def initialize(segments_repository, segment_name)
+      @segments_repository = segments_repository
+      @segment_name = segment_name
+    end
+
+    #
+    # evaluates if the key matches the matcher
+    #
+    # @param key [string] key value to be matched
+    #
+    # @return [boolean] evaluation of the key against the segment
+    def match?(args)
+      @segments_repository.in_segment?(@segment_name, args[:value] || args[:matching_key])
+    end
+
+    #
+    # evaluates if the given object equals the matcher
+    #
+    # @param obj [object] object to be evaluated
+    #
+    # @returns [boolean] true if obj equals the matcher
+    def equals?(obj)
+      if obj.nil?
+        false
+      elsif !obj.instance_of?(UserDefinedSegmentMatcher)
+        false
+      elsif self.equal?(obj)
+        true
+      else
+        false
+      end
+    end
+
+    def string_type?
+      false
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+module SplitIoClient
+  #
+  # class to implement the user defined matcher
+  #
+  class WhitelistMatcher < NoMethodError
+    MATCHER_TYPE = 'WHITELIST_MATCHER'
+
+    attr_reader :attribute
+
+    def initialize(whitelist_data)
+      @whitelist = case whitelist_data
+      when Array
+        whitelist_data
+      when Hash
+        @matcher_type = 'ATTR_WHITELIST'
+        @attribute = whitelist_data[:attribute]
+
+        whitelist_data[:value]
+      else
+        []
+      end
+    end
+
+    def match?(args)
+      return @whitelist.include?(args[:value] || args[:matching_key]) unless @matcher_type == 'ATTR_WHITELIST'
+
+      return false if !args.key?(:attributes) && !args.key?(:value)
+      return false if args.key?(:value) && args[:value].nil?
+      return false if args.key?(:attributes) && args[:attributes].nil?
+
+      return @whitelist.include?(args[:value] || args[:attributes][@attribute.to_sym])
+
+      false
+    end
+
+    #
+    # evaluates if the given object equals the matcher
+    #
+    # @param obj [object] object to be evaluated
+    #
+    # @returns [boolean] true if obj equals the matcher
+    def equals?(obj)
+      if obj.nil?
+        false
+      elsif !obj.instance_of?(WhitelistMatcher)
+        false
+      elsif self.equal?(obj)
+        true
+      else
+        false
+      end
+    end
+
+    def string_type?
+      true
+    end
+
+    #
+    # function to print string value for this matcher
+    #
+    # @reutrn [string] string value of this matcher
+    def to_s
+      "in segment #{@whitelist}"
+    end
+  end
+end

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

@@ -0,0 +1,128 @@
+module SplitIoClient
+
+  #
+  #  Tracks latencies pero bucket of time.
+  #  Each bucket represent a latency greater than the one before
+  #  and each number within each bucket is a number of calls in the range.
+  #
+  #  (1)  1.00
+  #  (2)  1.50
+  #  (3)  2.25
+  #  (4)  3.38
+  #  (5)  5.06
+  #  (6)  7.59
+  #  (7)  11.39
+  #  (8)  17.09
+  #  (9)  25.63
+  #  (10) 38.44
+  #  (11) 57.67
+  #  (12) 86.50
+  #  (13) 129.75
+  #  (14) 194.62
+  #  (15) 291.93
+  #  (16) 437.89
+  #  (17) 656.84
+  #  (18) 985.26
+  #  (19) 1,477.89
+  #  (20) 2,216.84
+  #  (21) 3,325.26
+  #  (22) 4,987.89
+  #  (23) 7,481.83
+  #
+  #  Created by fvitale on 2/17/16 based on java implementation by patricioe.
+  #
+
+  class BinarySearchLatencyTracker < NoMethodError
+
+    BUCKETS = [ 1000,    1500,    2250,   3375,    5063,
+                7594,    11391,   17086,  25629,   38443,
+                57665,   86498,   129746, 194620,  291929,
+                437894,  656841,  985261, 1477892, 2216838,
+                3325257, 4987885, 7481828 ].freeze
+
+    MAX_LATENCY = 7481828
+
+    attr_accessor :latencies
+
+    def initialize
+      @latencies = Array.new(BUCKETS.length, 0)
+    end
+
+    #
+    # Increment the internal counter for the bucket this latency falls into.
+    # @param millis
+    #
+    def add_latency_millis(millis, return_index = false)
+      index = find_bucket_index(millis * 1000)
+
+      return index if return_index
+
+      @latencies[index] += 1
+      @latencies
+    end
+
+    # Increment the internal counter for the bucket this latency falls into.
+    # @param micros
+    def add_latency_micros(micros, return_index = false)
+      index = find_bucket_index(micros)
+
+      return index if return_index
+
+      @latencies[index] += 1
+      @latencies
+    end
+
+    # Returns the list of latencies buckets as an array.
+    #
+    #
+    # @return the list of latencies buckets as an array.
+    def get_latencies
+      @latencies
+    end
+
+    def get_latency(index)
+      return @latencies[index]
+    end
+
+    def clear
+      @latencies = Array.new(BUCKETS.length, 0)
+    end
+
+    #
+    # Returns the counts in the bucket this latency falls into.
+    # The latencies will not be updated.
+    # @param latency
+    # @return the bucket content for the latency.
+    #
+    def get_bucket_for_latency_millis(latency)
+      return @latencies[find_bucket_index(latency * 1000)]
+    end
+
+    #
+    # Returns the counts in the bucket this latency falls into.
+    # The latencies will not be updated.
+    # @param latency
+    # @return the bucket content for the latency.
+    #
+    def get_bucket_for_latency_micros(latency)
+      return @latencies[find_bucket_index(latency)]
+    end
+
+    private
+
+    def find_bucket_index(micros)
+      if (micros > MAX_LATENCY) then
+        return BUCKETS.length - 1
+      end
+
+      if (micros < 1500) then
+        return 0
+      end
+
+      index = BUCKETS.find_index(BUCKETS.bsearch {|x| x >= micros })
+
+      return index
+    end
+
+  end
+end