splitclient-rb 0.1.3

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

@@ -0,0 +1,55 @@
+module SplitIoClient
+
+  #
+  # class to implement the user defined matcher
+  #
+  class WhitelistMatcher < NoMethodError
+
+    # variable that contains the keys of the whitelist
+    @whitelist = []
+
+    def initialize(whitelist)
+      unless whitelist.nil?
+        @whitelist = whitelist
+      end
+    end
+
+    #
+    # evaluates if the key matches the matcher
+    #
+    # @param key [string] key value to be matched
+    #
+    # @return [boolean] evaluation of the key against the whitelist
+    def match?(key)
+      @whitelist.include?(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?(WhitelistMatcher)
+        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
+      'in segment ' + @whitelist.to_s
+    end
+
+  end
+
+end

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

@@ -0,0 +1,122 @@
+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)
+      index = find_bucket_index(millis * 1000)
+      @latencies[index] += 1
+      @latencies
+    end
+
+    # Increment the internal counter for the bucket this latency falls into.
+    # @param micros
+    def add_latency_micros(micros)
+      index = find_bucket_index(micros)
+      @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

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

@@ -0,0 +1,158 @@
+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)
+      @latencies = []
+      @counts = []
+      @gauges = []
+      @queue_size = queue_size
+      @binary_search = SplitIoClient::BinarySearchLatencyTracker.new
+    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
+
+      return if (counter.nil? || counter.strip.empty?)
+
+      counter_hash = @counts.find { |c| c[:name] == counter }
+      if counter_hash.nil?
+        counter_delta = SumAndCount.new
+        counter_delta.add_delta(delta)
+        @counts << {name: counter, delta: counter_delta}
+      else
+        counter_hash[:delta].add_delta(delta)
+      end
+    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)
+
+      if operation.nil? || operation.empty? || time_in_ms < 0
+        return;
+      end
+
+      operation_hash = @latencies.find { |l| l[:operation] == operation }
+      if operation_hash.nil?
+        latencies_for_op = (operation == 'sdk.get_treatment') ? @binary_search.add_latency_millis(time_in_ms) : [time_in_ms]
+        @latencies << {operation: operation, latencies: latencies_for_op}
+      else
+        latencies_for_op = (operation == 'sdk.get_treatment') ? @binary_search.add_latency_millis(time_in_ms) : operation_hash[:latencies].push(time_in_ms)
+      end
+    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)
+      if gauge.nil? || gauge.empty?
+        return
+      end
+
+      gauge_hash = @gauges.find { |g| g[:name] == gauge }
+      if gauge_hash.nil?
+        gauge_value = ValueAndCount.new
+        gauge_value.set_value(value)
+        @gauges << {name: gauge, value: gauge_value}
+      else
+        gauge_hash[:value].set_value(value)
+      end
+    end
+
+  end
+
+  #
+  # small class to act as DTO for counts
+  #
+  class SumAndCount
+    attr_reader :count
+    attr_reader :sum
+
+    def initialize
+      @count = 0
+      @sum = 0
+    end
+
+    def add_delta(delta)
+      @count++
+      @sum += delta
+    end
+
+    def clear
+      @count = 0
+      @sum = 0
+    end
+  end
+
+  #
+  # small class to act as DTO for gauges
+  #
+  class ValueAndCount
+    attr_reader :count
+    attr_reader :value
+
+    def initialize
+      @count = 0
+      @value = 0
+    end
+
+    def set_value(value)
+      @count += 1
+      @value = value
+    end
+
+    def clear
+      @count = 0
+      @value = 0
+    end
+
+  end
+
+end

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

@@ -0,0 +1,90 @@
+module SplitIoClient
+
+  #
+  # acts as dto for a condition structure
+  #
+  class Condition < NoMethodError
+
+    #
+    # definition of the condition
+    #
+    # @returns [object] condition values
+    attr_accessor :data
+
+    def initialize(condition)
+      @data = condition
+      @partitions = set_partitions
+    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 [object] the whitelist for this condition in case it has a whitelist matcher
+    def matcher_whitelist
+      result = nil
+      if self.matcher == 'WHITELIST'
+        result = (@data[:matcherGroup][:matchers].first[:whitelistMatcherData])[:whitelist]
+      end
+      result
+    end
+
+    #
+    # @return [object] the segment for this condition in case it has a segment matcher
+    def matcher_segment
+      result = nil
+      if self.matcher == 'IN_SEGMENT'
+        result = (@data[:matcherGroup][:matchers].first[:userDefinedSegmentMatcherData])[:segmentName]
+      end
+      result
+    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
+    def partitions
+      @partitions
+    end
+
+    #
+    # 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 is_empty?
+      @data.empty? ? true : false
+    end
+
+  end
+
+end

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

@@ -0,0 +1,37 @@
+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? ? true : false
+    end
+  end
+
+end