amplitude-experiment 1.6.0 → 1.7.1

data/lib/experiment/evaluation/flag.rb

@@ -2,122 +2,124 @@
 
 require 'json'
 
-module Evaluation
-  class Distribution
-    attr_accessor :variant, :range
-
-    def self.from_hash(hash)
-      new.tap do |dist|
-        dist.variant = hash['variant']
-        dist.range = hash['range']
+module AmplitudeExperiment
+  module Evaluation
+    class Distribution
+      attr_accessor :variant, :range
+
+      def self.from_hash(hash)
+        new.tap do |dist|
+          dist.variant = hash['variant']
+          dist.range = hash['range']
+        end
       end
     end
-  end
 
-  class Allocation
-    attr_accessor :range, :distributions
+    class Allocation
+      attr_accessor :range, :distributions
 
-    def self.from_hash(hash)
-      new.tap do |alloc|
-        alloc.range = hash['range']
-        alloc.distributions = hash['distributions']&.map { |d| Distribution.from_hash(d) }
+      def self.from_hash(hash)
+        new.tap do |alloc|
+          alloc.range = hash['range']
+          alloc.distributions = hash['distributions']&.map { |d| Distribution.from_hash(d) }
+        end
       end
     end
-  end
 
-  class Condition
-    attr_accessor :selector, :op, :values
+    class Condition
+      attr_accessor :selector, :op, :values
 
-    def self.from_hash(hash)
-      new.tap do |cond|
-        cond.selector = hash['selector']
-        cond.op = hash['op']
-        cond.values = hash['values']
+      def self.from_hash(hash)
+        new.tap do |cond|
+          cond.selector = hash['selector']
+          cond.op = hash['op']
+          cond.values = hash['values']
+        end
       end
     end
-  end
 
-  class Bucket
-    attr_accessor :selector, :salt, :allocations
+    class Bucket
+      attr_accessor :selector, :salt, :allocations
 
-    def self.from_hash(hash)
-      new.tap do |bucket|
-        bucket.selector = hash['selector']
-        bucket.salt = hash['salt']
-        bucket.allocations = hash['allocations']&.map { |a| Allocation.from_hash(a) }
+      def self.from_hash(hash)
+        new.tap do |bucket|
+          bucket.selector = hash['selector']
+          bucket.salt = hash['salt']
+          bucket.allocations = hash['allocations']&.map { |a| Allocation.from_hash(a) }
+        end
       end
     end
-  end
 
-  class Segment
-    attr_accessor :bucket, :conditions, :variant, :metadata
+    class Segment
+      attr_accessor :bucket, :conditions, :variant, :metadata
 
-    def self.from_hash(hash)
-      new.tap do |segment|
-        segment.bucket = hash['bucket'] && Bucket.from_hash(hash['bucket'])
-        segment.conditions = hash['conditions']&.map { |c| c.map { |inner| Condition.from_hash(inner) } }
-        segment.variant = hash['variant']
-        segment.metadata = hash['metadata']
+      def self.from_hash(hash)
+        new.tap do |segment|
+          segment.bucket = hash['bucket'] && Bucket.from_hash(hash['bucket'])
+          segment.conditions = hash['conditions']&.map { |c| c.map { |inner| Condition.from_hash(inner) } }
+          segment.variant = hash['variant']
+          segment.metadata = hash['metadata']
+        end
       end
     end
-  end
 
-  class Variant
-    attr_accessor :key, :value, :payload, :metadata
+    class Variant
+      attr_accessor :key, :value, :payload, :metadata
 
-    def [](key)
-      instance_variable_get("@#{key}")
-    end
+      def [](key)
+        instance_variable_get("@#{key}")
+      end
 
-    def self.from_hash(hash)
-      new.tap do |variant|
-        variant.key = hash['key']
-        variant.value = hash['value']
-        variant.payload = hash['payload']
-        variant.metadata = hash['metadata']
+      def self.from_hash(hash)
+        new.tap do |variant|
+          variant.key = hash['key']
+          variant.value = hash['value']
+          variant.payload = hash['payload']
+          variant.metadata = hash['metadata']
+        end
       end
     end
-  end
 
-  class Flag
-    attr_accessor :key, :variants, :segments, :dependencies, :metadata
+    class Flag
+      attr_accessor :key, :variants, :segments, :dependencies, :metadata
+
+      def self.from_hash(hash)
+        new.tap do |flag|
+          flag.key = hash['key']
+          flag.variants = hash['variants'].transform_values { |v| Variant.from_hash(v) }
+          flag.segments = hash['segments'].map { |s| Segment.from_hash(s) }
+          flag.dependencies = hash['dependencies']
+          flag.metadata = hash['metadata']
+        end
+      end
 
-    def self.from_hash(hash)
-      new.tap do |flag|
-        flag.key = hash['key']
-        flag.variants = hash['variants'].transform_values { |v| Variant.from_hash(v) }
-        flag.segments = hash['segments'].map { |s| Segment.from_hash(s) }
-        flag.dependencies = hash['dependencies']
-        flag.metadata = hash['metadata']
+      # Used for testing
+      def ==(other)
+        key == other.key
       end
     end
 
-    # Used for testing
-    def ==(other)
-      key == other.key
+    module Operator
+      IS = 'is'
+      IS_NOT = 'is not'
+      CONTAINS = 'contains'
+      DOES_NOT_CONTAIN = 'does not contain'
+      LESS_THAN = 'less'
+      LESS_THAN_EQUALS = 'less or equal'
+      GREATER_THAN = 'greater'
+      GREATER_THAN_EQUALS = 'greater or equal'
+      VERSION_LESS_THAN = 'version less'
+      VERSION_LESS_THAN_EQUALS = 'version less or equal'
+      VERSION_GREATER_THAN = 'version greater'
+      VERSION_GREATER_THAN_EQUALS = 'version greater or equal'
+      SET_IS = 'set is'
+      SET_IS_NOT = 'set is not'
+      SET_CONTAINS = 'set contains'
+      SET_DOES_NOT_CONTAIN = 'set does not contain'
+      SET_CONTAINS_ANY = 'set contains any'
+      SET_DOES_NOT_CONTAIN_ANY = 'set does not contain any'
+      REGEX_MATCH = 'regex match'
+      REGEX_DOES_NOT_MATCH = 'regex does not match'
     end
   end
-
-  module Operator
-    IS = 'is'
-    IS_NOT = 'is not'
-    CONTAINS = 'contains'
-    DOES_NOT_CONTAIN = 'does not contain'
-    LESS_THAN = 'less'
-    LESS_THAN_EQUALS = 'less or equal'
-    GREATER_THAN = 'greater'
-    GREATER_THAN_EQUALS = 'greater or equal'
-    VERSION_LESS_THAN = 'version less'
-    VERSION_LESS_THAN_EQUALS = 'version less or equal'
-    VERSION_GREATER_THAN = 'version greater'
-    VERSION_GREATER_THAN_EQUALS = 'version greater or equal'
-    SET_IS = 'set is'
-    SET_IS_NOT = 'set is not'
-    SET_CONTAINS = 'set contains'
-    SET_DOES_NOT_CONTAIN = 'set does not contain'
-    SET_CONTAINS_ANY = 'set contains any'
-    SET_DOES_NOT_CONTAIN_ANY = 'set does not contain any'
-    REGEX_MATCH = 'regex match'
-    REGEX_DOES_NOT_MATCH = 'regex does not match'
-  end
 end

data/lib/experiment/evaluation/murmur3.rb

@@ -1,104 +1,108 @@
 # frozen_string_literal: true
 
 # Implements 32-bit x86 MurmurHash3
-class Murmur3
-  C1_32 = -0x3361d2af
-  C2_32 = 0x1b873593
-  R1_32 = 15
-  R2_32 = 13
-  M_32 = 5
-  N_32 = -0x19ab949c
+module AmplitudeExperiment
+  module Evaluation
+    class Murmur3
+      C1_32 = -0x3361d2af
+      C2_32 = 0x1b873593
+      R1_32 = 15
+      R2_32 = 13
+      M_32 = 5
+      N_32 = -0x19ab949c
 
-  class << self
-    def hash32x86(input, seed = 0)
-      data = string_to_utf8_bytes(input)
-      length = data.length
-      n_blocks = length >> 2
-      hash = seed
+      class << self
+        def hash32x86(input, seed = 0)
+          data = string_to_utf8_bytes(input)
+          length = data.length
+          n_blocks = length >> 2
+          hash = seed
 
-      # Process body
-      n_blocks.times do |i|
-        index = i << 2
-        k = read_int_le(data, index)
-        hash = mix32(k, hash)
-      end
+          # Process body
+          n_blocks.times do |i|
+            index = i << 2
+            k = read_int_le(data, index)
+            hash = mix32(k, hash)
+          end
 
-      # Process tail
-      index = n_blocks << 2
-      k1 = 0
+          # Process tail
+          index = n_blocks << 2
+          k1 = 0
 
-      case length - index
-      when 3
-        k1 ^= data[index + 2] << 16
-        k1 ^= data[index + 1] << 8
-        k1 ^= data[index]
-        k1 = (k1 * C1_32) & 0xffffffff
-        k1 = rotate_left(k1, R1_32)
-        k1 = (k1 * C2_32) & 0xffffffff
-        hash ^= k1
-      when 2
-        k1 ^= data[index + 1] << 8
-        k1 ^= data[index]
-        k1 = (k1 * C1_32) & 0xffffffff
-        k1 = rotate_left(k1, R1_32)
-        k1 = (k1 * C2_32) & 0xffffffff
-        hash ^= k1
-      when 1
-        k1 ^= data[index]
-        k1 = (k1 * C1_32) & 0xffffffff
-        k1 = rotate_left(k1, R1_32)
-        k1 = (k1 * C2_32) & 0xffffffff
-        hash ^= k1
-      end
+          case length - index
+          when 3
+            k1 ^= data[index + 2] << 16
+            k1 ^= data[index + 1] << 8
+            k1 ^= data[index]
+            k1 = (k1 * C1_32) & 0xffffffff
+            k1 = rotate_left(k1, R1_32)
+            k1 = (k1 * C2_32) & 0xffffffff
+            hash ^= k1
+          when 2
+            k1 ^= data[index + 1] << 8
+            k1 ^= data[index]
+            k1 = (k1 * C1_32) & 0xffffffff
+            k1 = rotate_left(k1, R1_32)
+            k1 = (k1 * C2_32) & 0xffffffff
+            hash ^= k1
+          when 1
+            k1 ^= data[index]
+            k1 = (k1 * C1_32) & 0xffffffff
+            k1 = rotate_left(k1, R1_32)
+            k1 = (k1 * C2_32) & 0xffffffff
+            hash ^= k1
+          end
 
-      hash ^= length
-      fmix32(hash) & 0xffffffff
-    end
+          hash ^= length
+          fmix32(hash) & 0xffffffff
+        end
 
-    private
+        private
 
-    def mix32(k, hash)
-      k = (k * C1_32) & 0xffffffff
-      k = rotate_left(k, R1_32)
-      k = (k * C2_32) & 0xffffffff
-      hash ^= k
-      hash = rotate_left(hash, R2_32)
-      ((hash * M_32) + N_32) & 0xffffffff
-    end
+        def mix32(k, hash)
+          k = (k * C1_32) & 0xffffffff
+          k = rotate_left(k, R1_32)
+          k = (k * C2_32) & 0xffffffff
+          hash ^= k
+          hash = rotate_left(hash, R2_32)
+          ((hash * M_32) + N_32) & 0xffffffff
+        end
 
-    def fmix32(hash)
-      hash ^= hash >> 16
-      hash = (hash * -0x7a143595) & 0xffffffff
-      hash ^= hash >> 13
-      hash = (hash * -0x3d4d51cb) & 0xffffffff
-      hash ^= hash >> 16
-      hash
-    end
+        def fmix32(hash)
+          hash ^= hash >> 16
+          hash = (hash * -0x7a143595) & 0xffffffff
+          hash ^= hash >> 13
+          hash = (hash * -0x3d4d51cb) & 0xffffffff
+          hash ^= hash >> 16
+          hash
+        end
 
-    def rotate_left(x, n, width = 32)
-      n = n % width if n > width
-      mask = (0xffffffff << (width - n)) & 0xffffffff
-      r = ((x & mask) >> (width - n)) & 0xffffffff
-      ((x << n) | r) & 0xffffffff
-    end
+        def rotate_left(x, n, width = 32)
+          n %= width if n > width
+          mask = (0xffffffff << (width - n)) & 0xffffffff
+          r = ((x & mask) >> (width - n)) & 0xffffffff
+          ((x << n) | r) & 0xffffffff
+        end
 
-    def read_int_le(data, index = 0)
-      n = (data[index] << 24) |
-          (data[index + 1] << 16) |
-          (data[index + 2] << 8) |
-          data[index + 3]
-      reverse_bytes(n)
-    end
+        def read_int_le(data, index = 0)
+          n = (data[index] << 24) |
+              (data[index + 1] << 16) |
+              (data[index + 2] << 8) |
+              data[index + 3]
+          reverse_bytes(n)
+        end
 
-    def reverse_bytes(n)
-      ((n & -0x1000000) >> 24) |
-        ((n & 0x00ff0000) >> 8) |
-        ((n & 0x0000ff00) << 8) |
-        ((n & 0x000000ff) << 24)
-    end
+        def reverse_bytes(n)
+          ((n & -0x1000000) >> 24) |
+            ((n & 0x00ff0000) >> 8) |
+            ((n & 0x0000ff00) << 8) |
+            ((n & 0x000000ff) << 24)
+        end
 
-    def string_to_utf8_bytes(str)
-      str.encode('UTF-8').bytes
+        def string_to_utf8_bytes(str)
+          str.encode('UTF-8').bytes
+        end
+      end
     end
   end
 end

data/lib/experiment/evaluation/select.rb

@@ -1,16 +1,18 @@
 # frozen_string_literal: true
 
 # Selects a value from a nested object using an array of selector keys
-module Evaluation
-  def self.select(selectable, selector)
-    return nil if selector.nil? || selector.empty?
+module AmplitudeExperiment
+  module Evaluation
+    def self.select(selectable, selector)
+      return nil if selector.nil? || selector.empty?
 
-    selector.each do |selector_element|
-      return nil if selector_element.nil? || selectable.nil?
+      selector.each do |selector_element|
+        return nil if selector_element.nil? || selectable.nil?
 
-      selectable = selectable[selector_element]
-    end
+        selectable = selectable[selector_element]
+      end
 
-    selectable.nil? ? nil : selectable
+      selectable.nil? ? nil : selectable
+    end
   end
 end

data/lib/experiment/evaluation/semantic_version.rb

@@ -1,52 +1,56 @@
 # frozen_string_literal: true
 
-class SemanticVersion
-  include Comparable
+module AmplitudeExperiment
+  module Evaluation
+    class SemanticVersion
+      include Comparable
 
-  attr_reader :major, :minor, :patch, :pre_release
+      attr_reader :major, :minor, :patch, :pre_release
 
-  MAJOR_MINOR_REGEX = '(\d+)\.(\d+)'
-  PATCH_REGEX = '(\d+)'
-  PRERELEASE_REGEX = '(-(([-\w]+\.?)*))?'
-  VERSION_PATTERN = /^#{MAJOR_MINOR_REGEX}(\.#{PATCH_REGEX}#{PRERELEASE_REGEX})?$/.freeze
+      MAJOR_MINOR_REGEX = '(\d+)\.(\d+)'
+      PATCH_REGEX = '(\d+)'
+      PRERELEASE_REGEX = '(-(([-\w]+\.?)*))?'
+      VERSION_PATTERN = /^#{MAJOR_MINOR_REGEX}(\.#{PATCH_REGEX}#{PRERELEASE_REGEX})?$/.freeze
 
-  def initialize(major, minor, patch, pre_release = nil)
-    @major = major
-    @minor = minor
-    @patch = patch
-    @pre_release = pre_release
-  end
+      def initialize(major, minor, patch, pre_release = nil)
+        @major = major
+        @minor = minor
+        @patch = patch
+        @pre_release = pre_release
+      end
 
-  def self.parse(version)
-    return nil if version.nil?
+      def self.parse(version)
+        return nil if version.nil?
 
-    match = VERSION_PATTERN.match(version)
-    return nil unless match
+        match = VERSION_PATTERN.match(version)
+        return nil unless match
 
-    major = match[1].to_i
-    minor = match[2].to_i
-    patch = match[4]&.to_i || 0
-    pre_release = match[5]
+        major = match[1].to_i
+        minor = match[2].to_i
+        patch = match[4]&.to_i || 0
+        pre_release = match[5]
 
-    new(major, minor, patch, pre_release)
-  end
+        new(major, minor, patch, pre_release)
+      end
 
-  def <=>(other)
-    return nil unless other.is_a?(SemanticVersion)
+      def <=>(other)
+        return nil unless other.is_a?(SemanticVersion)
 
-    result = major <=> other.major
-    return result unless result.zero?
+        result = major <=> other.major
+        return result unless result.zero?
 
-    result = minor <=> other.minor
-    return result unless result.zero?
+        result = minor <=> other.minor
+        return result unless result.zero?
 
-    result = patch <=> other.patch
-    return result unless result.zero?
+        result = patch <=> other.patch
+        return result unless result.zero?
 
-    return 1 if !pre_release && other.pre_release
-    return -1 if pre_release && !other.pre_release
-    return 0 if !pre_release && !other.pre_release
+        return 1 if !pre_release && other.pre_release
+        return -1 if pre_release && !other.pre_release
+        return 0 if !pre_release && !other.pre_release
 
-    pre_release <=> other.pre_release
+        pre_release <=> other.pre_release
+      end
+    end
   end
 end

data/lib/experiment/evaluation/topological_sort.rb

@@ -1,56 +1,53 @@
 # frozen_string_literal: true
 
-class CycleError < StandardError
-  attr_accessor :path
-
-  def initialize(path)
-    super("Detected a cycle between flags #{path}")
-    self.path = path
-  end
-end
+require_relative '../error'
 
 # Performs topological sorting of feature flags based on their dependencies
-class TopologicalSort
-  # Sort flags topologically based on their dependencies
-  def self.sort(flags, flag_keys = nil)
-    available = flags.clone
-    result = []
-    starting_keys = flag_keys.nil? || flag_keys.empty? ? flags.keys : flag_keys
-
-    starting_keys.each do |flag_key|
-      traversal = parent_traversal(flag_key, available)
-      result.concat(traversal) if traversal
-    end
-
-    result
-  end
-
-  # Perform depth-first traversal of flag dependencies
-  def self.parent_traversal(flag_key, available, path = [])
-    flag = available[flag_key]
-    return nil unless flag
-
-    # No dependencies - return flag and remove from available
-    if !flag.dependencies || flag.dependencies.empty?
-      available.delete(flag.key)
-      return [flag]
+module AmplitudeExperiment
+  module Evaluation
+    class TopologicalSort
+      # Sort flags topologically based on their dependencies
+      def self.sort(flags, flag_keys = nil)
+        available = flags.clone
+        result = []
+        starting_keys = flag_keys.nil? || flag_keys.empty? ? flags.keys : flag_keys
+
+        starting_keys.each do |flag_key|
+          traversal = parent_traversal(flag_key, available)
+          result.concat(traversal) if traversal
+        end
+
+        result
+      end
+
+      # Perform depth-first traversal of flag dependencies
+      def self.parent_traversal(flag_key, available, path = [])
+        flag = available[flag_key]
+        return nil unless flag
+
+        # No dependencies - return flag and remove from available
+        if !flag.dependencies || flag.dependencies.empty?
+          available.delete(flag.key)
+          return [flag]
+        end
+
+        # Check for cycles
+        path.push(flag.key)
+        result = []
+
+        flag.dependencies.each do |parent_key|
+          raise CycleError, path if path.any? { |p| p == parent_key }
+
+          traversal = parent_traversal(parent_key, available, path)
+          result.concat(traversal) if traversal
+        end
+
+        result.push(flag)
+        path.pop
+        available.delete(flag.key)
+
+        result
+      end
     end
-
-    # Check for cycles
-    path.push(flag.key)
-    result = []
-
-    flag.dependencies.each do |parent_key|
-      raise CycleError, path if path.any? { |p| p == parent_key }
-
-      traversal = parent_traversal(parent_key, available, path)
-      result.concat(traversal) if traversal
-    end
-
-    result.push(flag)
-    path.pop
-    available.delete(flag.key)
-
-    result
   end
 end

data/lib/experiment/evaluation.rb

@@ -0,0 +1,6 @@
+require 'experiment/evaluation/evaluation'
+require 'experiment/evaluation/flag'
+require 'experiment/evaluation/murmur3'
+require 'experiment/evaluation/select'
+require 'experiment/evaluation/semantic_version'
+require 'experiment/evaluation/topological_sort'

data/lib/experiment/local/client.rb

@@ -1,6 +1,8 @@
 require 'uri'
 require 'logger'
+
 require_relative '../../amplitude'
+require_relative '../evaluation'
 
 module AmplitudeExperiment
   FLAG_TYPE_MUTUAL_EXCLUSION_GROUP = 'mutual-exclusion-group'.freeze
@@ -14,14 +16,9 @@ module AmplitudeExperiment
     def initialize(api_key, config = nil)
       @api_key = api_key
       @config = config || LocalEvaluationConfig.new
+      @logger = @config.logger
       @flags = nil
       @flags_mutex = Mutex.new
-      @logger = Logger.new($stdout)
-      @logger.level = if @config.debug
-                        Logger::DEBUG
-                      else
-                        Logger::INFO
-                      end
       raise ArgumentError, 'Experiment API key is empty' if @api_key.nil? || @api_key.empty?
 
       @engine = Evaluation::Engine.new
@@ -68,7 +65,7 @@ module AmplitudeExperiment
       flags = @flag_config_storage.flag_configs
       return {} if flags.nil?
 
-      sorted_flags = TopologicalSort.sort(flags, flag_keys)
+      sorted_flags = Evaluation::TopologicalSort.sort(flags, flag_keys)
       required_cohorts_in_storage(sorted_flags)
       user = enrich_user_with_cohorts(user, flags) if @config.cohort_sync_config
       context = AmplitudeExperiment.user_to_evaluation_context(user)