amplitude-experiment 1.6.0 → 1.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6d05f9400e7dd25e87eb6f372c0c1c7fa5c083fe392a75dd25152e0ad0c010a1
-  data.tar.gz: 19df424d3a56c5a44d6495282f3e1f5022e1a50c47b4a5e0fcfc53c0535576ea
+  metadata.gz: 6562a2b13fb38d240e3d83762e442a558478db59f3fff36bdff10b6589cfab0d
+  data.tar.gz: 432ea0ff64724c882ad97aae3ce95ae8d8a203f9c90bfe34afd5629e00dbba28
 SHA512:
-  metadata.gz: 4e2e412e261f918990f23890200e9dc7b2cf0ed5b52e38fe585f10a3bd84f3b2d062c21a60dbf6811fdf27c395635f214f433d5dfb77c5573e3ae7e82a803352
-  data.tar.gz: 3bde003e6e5cb0d8b139218d408c5235949bed823f6973fb3f45f3eb542d7adfc7cdfe74f416bf62f06d6cd910eace6490bb6e4e3e6a0b7ef8f4abe686c854b4
+  metadata.gz: 507368b7f4db8a28dfc866e0df203f724a1d2911af19dab24fada0bb7327e362d185057c891d534421c7816ec12953ad6555a0252b9bfa7d4922ffaea16bc935
+  data.tar.gz: d7ad16548702c918919a9d3b4afe874d396c8c5e98fb5010ebb3f8c0f0b476ad86d4568ed4660a74040a5ee85d4a9e01197560039b19d94659ec0e38d67b0868

data/amplitude-experiment.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.require_paths         = ['lib']
   spec.extra_rdoc_files      = ['README.md']
 
-  spec.add_dependency 'concurrent-ruby', '~> 1.2.2'
+  spec.add_dependency 'concurrent-ruby', '~> 1.2'
 
   spec.add_development_dependency 'psych', '~> 4.0'
   spec.add_development_dependency 'rake', '~> 13.0'

data/lib/amplitude/processor.rb

@@ -87,7 +87,7 @@ module AmplitudeAnalytics
         @configuration.callback.call(event, code, message) if @configuration.callback.respond_to?(:call)
         event.callback(code, message)
       rescue StandardError => e
-        @configuration.logger.exception("Error callback for event #{event}: #{e.message}")
+        @configuration.logger.error("Error callback for event #{event}: #{e.message}")
       end
     end
 

data/lib/amplitude/timeline.rb

@@ -49,7 +49,7 @@ module AmplitudeAnalytics
         @plugins[PluginType::DESTINATION].each do |destination|
           destination_futures << destination.flush
         rescue StandardError
-          logger.exception('Error for flush events')
+          logger.error('Error for flush events')
         end
       end
       destination_futures

data/lib/amplitude-experiment.rb

@@ -27,12 +27,7 @@ require 'experiment/cohort/cohort_storage'
 require 'experiment/cohort/cohort_sync_config'
 require 'experiment/deployment/deployment_runner'
 require 'experiment/util/poller'
-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'
+require 'experiment/evaluation'
 
 # Amplitude Experiment Module
 module AmplitudeExperiment

data/lib/experiment/evaluation/evaluation.rb

@@ -1,311 +1,313 @@
 # frozen_string_literal: true
 
-module Evaluation
-  # Engine for evaluating feature flags based on context
-  class Engine
-    def evaluate(context, flags)
-      results = {}
-      target = {
-        'context' => context,
-        'result' => results
-      }
-
-      flags.each do |flag|
-        variant = evaluate_flag(target, flag)
-        results[flag.key] = variant if variant
-      end
+module AmplitudeExperiment
+  module Evaluation
+    # Engine for evaluating feature flags based on context
+    class Engine
+      def evaluate(context, flags)
+        results = {}
+        target = {
+          'context' => context,
+          'result' => results
+        }
+
+        flags.each do |flag|
+          variant = evaluate_flag(target, flag)
+          results[flag.key] = variant if variant
+        end
 
-      results
-    end
+        results
+      end
 
-    private
-
-    def evaluate_flag(target, flag)
-      result = nil
-      flag.segments.each do |segment|
-        result = evaluate_segment(target, flag, segment)
-        next unless result
-
-        # Merge all metadata into the result
-        metadata = {}
-        metadata.merge!(flag.metadata) if flag.metadata
-        metadata.merge!(segment.metadata) if segment.metadata
-        metadata.merge!(result.metadata) if result.metadata
-        result.metadata = metadata
-        break
+      private
+
+      def evaluate_flag(target, flag)
+        result = nil
+        flag.segments.each do |segment|
+          result = evaluate_segment(target, flag, segment)
+          next unless result
+
+          # Merge all metadata into the result
+          metadata = {}
+          metadata.merge!(flag.metadata) if flag.metadata
+          metadata.merge!(segment.metadata) if segment.metadata
+          metadata.merge!(result.metadata) if result.metadata
+          result.metadata = metadata
+          break
+        end
+        result
       end
-      result
-    end
 
-    def evaluate_segment(target, flag, segment)
-      if segment.conditions
-        match = evaluate_conditions(target, segment.conditions)
-        if match
+      def evaluate_segment(target, flag, segment)
+        if segment.conditions
+          match = evaluate_conditions(target, segment.conditions)
+          if match
+            variant_key = bucket(target, segment)
+            variant_key ? flag.variants[variant_key] : nil
+          end
+        else
+          # Null conditions always match
           variant_key = bucket(target, segment)
           variant_key ? flag.variants[variant_key] : nil
         end
-      else
-        # Null conditions always match
-        variant_key = bucket(target, segment)
-        variant_key ? flag.variants[variant_key] : nil
       end
-    end
 
-    def evaluate_conditions(target, conditions)
-      # Outer list logic is "or" (||)
-      conditions.any? do |inner_conditions|
-        match = true
-        inner_conditions.each do |condition|
-          match = match_condition(target, condition)
-          break unless match
+      def evaluate_conditions(target, conditions)
+        # Outer list logic is "or" (||)
+        conditions.any? do |inner_conditions|
+          match = true
+          inner_conditions.each do |condition|
+            match = match_condition(target, condition)
+            break unless match
+          end
+          match
         end
-        match
       end
-    end
 
-    def match_condition(target, condition)
-      prop_value = Evaluation.select(target, condition.selector)
-      # Special matching for null properties and set type prop values and operators
-      if !prop_value
-        match_null(condition.op, condition.values)
-      elsif set_operator?(condition.op)
-        prop_value_string_list = coerce_string_array(prop_value)
-        return false unless prop_value_string_list
-
-        match_set(prop_value_string_list, condition.op, condition.values)
-      else
-        prop_value_string = coerce_string(prop_value)
-        if prop_value_string
-          match_string(prop_value_string, condition.op, condition.values)
+      def match_condition(target, condition)
+        prop_value = Evaluation.select(target, condition.selector)
+        # Special matching for null properties and set type prop values and operators
+        if !prop_value
+          match_null(condition.op, condition.values)
+        elsif set_operator?(condition.op)
+          prop_value_string_list = coerce_string_array(prop_value)
+          return false unless prop_value_string_list
+
+          match_set(prop_value_string_list, condition.op, condition.values)
         else
-          false
+          prop_value_string = coerce_string(prop_value)
+          if prop_value_string
+            match_string(prop_value_string, condition.op, condition.values)
+          else
+            false
+          end
         end
       end
-    end
-
-    def get_hash(key)
-      Murmur3.hash32x86(key)
-    end
 
-    def bucket(target, segment)
-      unless segment.bucket
-        # Null bucket means segment is fully rolled out
-        return segment.variant
+      def get_hash(key)
+        Murmur3.hash32x86(key)
       end
 
-      bucketing_value = coerce_string(Evaluation.select(target, segment.bucket.selector))
-      if !bucketing_value || bucketing_value.empty?
-        # Null or empty bucketing value cannot be bucketed
-        return segment.variant
-      end
+      def bucket(target, segment)
+        unless segment.bucket
+          # Null bucket means segment is fully rolled out
+          return segment.variant
+        end
 
-      key_to_hash = "#{segment.bucket.salt}/#{bucketing_value}"
-      hash = get_hash(key_to_hash)
-      allocation_value = hash % 100
-      distribution_value = (hash / 100).floor
+        bucketing_value = coerce_string(Evaluation.select(target, segment.bucket.selector))
+        if !bucketing_value || bucketing_value.empty?
+          # Null or empty bucketing value cannot be bucketed
+          return segment.variant
+        end
+
+        key_to_hash = "#{segment.bucket.salt}/#{bucketing_value}"
+        hash = get_hash(key_to_hash)
+        allocation_value = hash % 100
+        distribution_value = (hash / 100).floor
 
-      segment.bucket.allocations.each do |allocation|
-        allocation_start = allocation.range[0]
-        allocation_end = allocation.range[1]
-        next unless allocation_value >= allocation_start && allocation_value < allocation_end
+        segment.bucket.allocations.each do |allocation|
+          allocation_start = allocation.range[0]
+          allocation_end = allocation.range[1]
+          next unless allocation_value >= allocation_start && allocation_value < allocation_end
 
-        allocation.distributions.each do |distribution|
-          distribution_start = distribution.range[0]
-          distribution_end = distribution.range[1]
-          return distribution.variant if distribution_value >= distribution_start && distribution_value < distribution_end
+          allocation.distributions.each do |distribution|
+            distribution_start = distribution.range[0]
+            distribution_end = distribution.range[1]
+            return distribution.variant if distribution_value >= distribution_start && distribution_value < distribution_end
+          end
         end
-      end
 
-      segment.variant
-    end
+        segment.variant
+      end
 
-    def match_null(op, filter_values)
-      contains_none = contains_none?(filter_values)
-      case op
-      when Operator::IS, Operator::CONTAINS, Operator::LESS_THAN,
-        Operator::LESS_THAN_EQUALS, Operator::GREATER_THAN,
-        Operator::GREATER_THAN_EQUALS, Operator::VERSION_LESS_THAN,
-        Operator::VERSION_LESS_THAN_EQUALS, Operator::VERSION_GREATER_THAN,
-        Operator::VERSION_GREATER_THAN_EQUALS, Operator::SET_IS,
-        Operator::SET_CONTAINS, Operator::SET_CONTAINS_ANY
-        contains_none
-      when Operator::IS_NOT, Operator::DOES_NOT_CONTAIN,
-        Operator::SET_DOES_NOT_CONTAIN, Operator::SET_DOES_NOT_CONTAIN_ANY
-        !contains_none
-      else
-        false
+      def match_null(op, filter_values)
+        contains_none = contains_none?(filter_values)
+        case op
+        when Operator::IS, Operator::CONTAINS, Operator::LESS_THAN,
+          Operator::LESS_THAN_EQUALS, Operator::GREATER_THAN,
+          Operator::GREATER_THAN_EQUALS, Operator::VERSION_LESS_THAN,
+          Operator::VERSION_LESS_THAN_EQUALS, Operator::VERSION_GREATER_THAN,
+          Operator::VERSION_GREATER_THAN_EQUALS, Operator::SET_IS,
+          Operator::SET_CONTAINS, Operator::SET_CONTAINS_ANY
+          contains_none
+        when Operator::IS_NOT, Operator::DOES_NOT_CONTAIN,
+          Operator::SET_DOES_NOT_CONTAIN, Operator::SET_DOES_NOT_CONTAIN_ANY
+          !contains_none
+        else
+          false
+        end
       end
-    end
 
-    def match_set(prop_values, op, filter_values)
-      case op
-      when Operator::SET_IS
-        set_equals?(prop_values, filter_values)
-      when Operator::SET_IS_NOT
-        !set_equals?(prop_values, filter_values)
-      when Operator::SET_CONTAINS
-        matches_set_contains_all?(prop_values, filter_values)
-      when Operator::SET_DOES_NOT_CONTAIN
-        !matches_set_contains_all?(prop_values, filter_values)
-      when Operator::SET_CONTAINS_ANY
-        matches_set_contains_any?(prop_values, filter_values)
-      when Operator::SET_DOES_NOT_CONTAIN_ANY
-        !matches_set_contains_any?(prop_values, filter_values)
-      else
-        false
+      def match_set(prop_values, op, filter_values)
+        case op
+        when Operator::SET_IS
+          set_equals?(prop_values, filter_values)
+        when Operator::SET_IS_NOT
+          !set_equals?(prop_values, filter_values)
+        when Operator::SET_CONTAINS
+          matches_set_contains_all?(prop_values, filter_values)
+        when Operator::SET_DOES_NOT_CONTAIN
+          !matches_set_contains_all?(prop_values, filter_values)
+        when Operator::SET_CONTAINS_ANY
+          matches_set_contains_any?(prop_values, filter_values)
+        when Operator::SET_DOES_NOT_CONTAIN_ANY
+          !matches_set_contains_any?(prop_values, filter_values)
+        else
+          false
+        end
       end
-    end
 
-    def match_string(prop_value, op, filter_values)
-      case op
-      when Operator::IS
-        matches_is?(prop_value, filter_values)
-      when Operator::IS_NOT
-        !matches_is?(prop_value, filter_values)
-      when Operator::CONTAINS
-        matches_contains?(prop_value, filter_values)
-      when Operator::DOES_NOT_CONTAIN
-        !matches_contains?(prop_value, filter_values)
-      when Operator::LESS_THAN, Operator::LESS_THAN_EQUALS,
-        Operator::GREATER_THAN, Operator::GREATER_THAN_EQUALS
-        matches_comparable?(prop_value, op, filter_values,
-                            method(:parse_number),
-                            method(:comparator))
-      when Operator::VERSION_LESS_THAN, Operator::VERSION_LESS_THAN_EQUALS,
-        Operator::VERSION_GREATER_THAN, Operator::VERSION_GREATER_THAN_EQUALS
-        matches_comparable?(prop_value, op, filter_values,
-                            SemanticVersion.method(:parse),
-                            method(:comparator))
-      when Operator::REGEX_MATCH
-        matches_regex?(prop_value, filter_values)
-      when Operator::REGEX_DOES_NOT_MATCH
-        !matches_regex?(prop_value, filter_values)
-      else
-        false
+      def match_string(prop_value, op, filter_values)
+        case op
+        when Operator::IS
+          matches_is?(prop_value, filter_values)
+        when Operator::IS_NOT
+          !matches_is?(prop_value, filter_values)
+        when Operator::CONTAINS
+          matches_contains?(prop_value, filter_values)
+        when Operator::DOES_NOT_CONTAIN
+          !matches_contains?(prop_value, filter_values)
+        when Operator::LESS_THAN, Operator::LESS_THAN_EQUALS,
+          Operator::GREATER_THAN, Operator::GREATER_THAN_EQUALS
+          matches_comparable?(prop_value, op, filter_values,
+                              method(:parse_number),
+                              method(:comparator))
+        when Operator::VERSION_LESS_THAN, Operator::VERSION_LESS_THAN_EQUALS,
+          Operator::VERSION_GREATER_THAN, Operator::VERSION_GREATER_THAN_EQUALS
+          matches_comparable?(prop_value, op, filter_values,
+                              SemanticVersion.method(:parse),
+                              method(:comparator))
+        when Operator::REGEX_MATCH
+          matches_regex?(prop_value, filter_values)
+        when Operator::REGEX_DOES_NOT_MATCH
+          !matches_regex?(prop_value, filter_values)
+        else
+          false
+        end
       end
-    end
 
-    def matches_is?(prop_value, filter_values)
-      if contains_booleans?(filter_values)
-        lower = prop_value.downcase
-        return filter_values.any? { |value| value.downcase == lower } if %w[true false].include?(lower)
+      def matches_is?(prop_value, filter_values)
+        if contains_booleans?(filter_values)
+          lower = prop_value.downcase
+          return filter_values.any? { |value| value.downcase == lower } if %w[true false].include?(lower)
+        end
+        filter_values.any? { |value| prop_value == value }
       end
-      filter_values.any? { |value| prop_value == value }
-    end
 
-    def matches_contains?(prop_value, filter_values)
-      filter_values.any? do |filter_value|
-        prop_value.downcase.include?(filter_value.downcase)
+      def matches_contains?(prop_value, filter_values)
+        filter_values.any? do |filter_value|
+          prop_value.downcase.include?(filter_value.downcase)
+        end
       end
-    end
 
-    def matches_comparable?(prop_value, op, filter_values, type_transformer, type_comparator)
-      prop_value_transformed = type_transformer.call(prop_value)
-      filter_values_transformed = filter_values
-                                  .map { |filter_value| type_transformer.call(filter_value) }
-                                  .compact
-
-      if !prop_value_transformed || filter_values_transformed.empty?
-        filter_values.any? { |filter_value| comparator(prop_value, op, filter_value) }
-      else
-        filter_values_transformed.any? do |filter_value_transformed|
-          type_comparator.call(prop_value_transformed, op, filter_value_transformed)
+      def matches_comparable?(prop_value, op, filter_values, type_transformer, type_comparator)
+        prop_value_transformed = type_transformer.call(prop_value)
+        filter_values_transformed = filter_values
+                                    .map { |filter_value| type_transformer.call(filter_value) }
+                                    .compact
+
+        if !prop_value_transformed || filter_values_transformed.empty?
+          filter_values.any? { |filter_value| comparator(prop_value, op, filter_value) }
+        else
+          filter_values_transformed.any? do |filter_value_transformed|
+            type_comparator.call(prop_value_transformed, op, filter_value_transformed)
+          end
         end
       end
-    end
 
-    def comparator(prop_value, op, filter_value)
-      case op
-      when Operator::LESS_THAN, Operator::VERSION_LESS_THAN
-        prop_value < filter_value
-      when Operator::LESS_THAN_EQUALS, Operator::VERSION_LESS_THAN_EQUALS
-        prop_value <= filter_value
-      when Operator::GREATER_THAN, Operator::VERSION_GREATER_THAN
-        prop_value > filter_value
-      when Operator::GREATER_THAN_EQUALS, Operator::VERSION_GREATER_THAN_EQUALS
-        prop_value >= filter_value
-      else
-        false
+      def comparator(prop_value, op, filter_value)
+        case op
+        when Operator::LESS_THAN, Operator::VERSION_LESS_THAN
+          prop_value < filter_value
+        when Operator::LESS_THAN_EQUALS, Operator::VERSION_LESS_THAN_EQUALS
+          prop_value <= filter_value
+        when Operator::GREATER_THAN, Operator::VERSION_GREATER_THAN
+          prop_value > filter_value
+        when Operator::GREATER_THAN_EQUALS, Operator::VERSION_GREATER_THAN_EQUALS
+          prop_value >= filter_value
+        else
+          false
+        end
       end
-    end
 
-    def matches_regex?(prop_value, filter_values)
-      filter_values.any? { |filter_value| !!(Regexp.new(filter_value) =~ prop_value) }
-    end
+      def matches_regex?(prop_value, filter_values)
+        filter_values.any? { |filter_value| !!(Regexp.new(filter_value) =~ prop_value) }
+      end
 
-    def contains_none?(filter_values)
-      filter_values.any? { |filter_value| filter_value == '(none)' }
-    end
+      def contains_none?(filter_values)
+        filter_values.any? { |filter_value| filter_value == '(none)' }
+      end
 
-    def contains_booleans?(filter_values)
-      filter_values.any? do |filter_value|
-        case filter_value.downcase
-        when 'true', 'false'
-          true
-        else
-          false
+      def contains_booleans?(filter_values)
+        filter_values.any? do |filter_value|
+          case filter_value.downcase
+          when 'true', 'false'
+            true
+          else
+            false
+          end
         end
       end
-    end
 
-    def parse_number(value)
-      Float(value)
-    rescue StandardError
-      nil
-    end
+      def parse_number(value)
+        Float(value)
+      rescue StandardError
+        nil
+      end
 
-    def coerce_string(value)
-      return nil if value.nil?
-      return value.to_json if value.is_a?(Hash)
+      def coerce_string(value)
+        return nil if value.nil?
+        return value.to_json if value.is_a?(Hash)
 
-      value.to_s
-    end
+        value.to_s
+      end
 
-    def coerce_string_array(value)
-      if value.is_a?(Array)
-        value.map { |e| coerce_string(e) }.compact
-      else
-        string_value = value.to_s
-        begin
-          parsed_value = JSON.parse(string_value)
-          if parsed_value.is_a?(Array)
-            parsed_value.map { |e| coerce_string(e) }.compact
-          else
+      def coerce_string_array(value)
+        if value.is_a?(Array)
+          value.map { |e| coerce_string(e) }.compact
+        else
+          string_value = value.to_s
+          begin
+            parsed_value = JSON.parse(string_value)
+            if parsed_value.is_a?(Array)
+              parsed_value.map { |e| coerce_string(e) }.compact
+            else
+              s = coerce_string(string_value)
+              s ? [s] : nil
+            end
+          rescue JSON::ParserError
             s = coerce_string(string_value)
             s ? [s] : nil
           end
-        rescue JSON::ParserError
-          s = coerce_string(string_value)
-          s ? [s] : nil
         end
       end
-    end
 
-    def set_operator?(op)
-      case op
-      when Operator::SET_IS, Operator::SET_IS_NOT,
-        Operator::SET_CONTAINS, Operator::SET_DOES_NOT_CONTAIN,
-        Operator::SET_CONTAINS_ANY, Operator::SET_DOES_NOT_CONTAIN_ANY
-        true
-      else
-        false
+      def set_operator?(op)
+        case op
+        when Operator::SET_IS, Operator::SET_IS_NOT,
+          Operator::SET_CONTAINS, Operator::SET_DOES_NOT_CONTAIN,
+          Operator::SET_CONTAINS_ANY, Operator::SET_DOES_NOT_CONTAIN_ANY
+          true
+        else
+          false
+        end
       end
-    end
 
-    def set_equals?(xa, ya)
-      xs = Set.new(xa)
-      ys = Set.new(ya)
-      xs.size == ys.size && ys.all? { |y| xs.include?(y) }
-    end
+      def set_equals?(xa, ya)
+        xs = Set.new(xa)
+        ys = Set.new(ya)
+        xs.size == ys.size && ys.all? { |y| xs.include?(y) }
+      end
 
-    def matches_set_contains_all?(prop_values, filter_values)
-      return false if prop_values.length < filter_values.length
+      def matches_set_contains_all?(prop_values, filter_values)
+        return false if prop_values.length < filter_values.length
 
-      filter_values.all? { |filter_value| matches_is?(filter_value, prop_values) }
-    end
+        filter_values.all? { |filter_value| matches_is?(filter_value, prop_values) }
+      end
 
-    def matches_set_contains_any?(prop_values, filter_values)
-      filter_values.any? { |filter_value| matches_is?(filter_value, prop_values) }
+      def matches_set_contains_any?(prop_values, filter_values)
+        filter_values.any? { |filter_value| matches_is?(filter_value, prop_values) }
+      end
     end
   end
 end