optimizely-sdk 2.1.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0fde3ad17097c2d63569bade1f3e4095bd8b8d36
-  data.tar.gz: ac971b0cff7db95a591b742a19cc9e9b82e6016d
+  metadata.gz: a6269e81defa38267703852ceb2e5d29de7ddad0
+  data.tar.gz: 2bd5d9f48a01e25dea810ca7b42bfc1c63c2bf40
 SHA512:
-  metadata.gz: d6cfdff4bef0344791fea78458ef57d7aa81e7de2fdaf3eb843e8ae6196f72766f0257bdef37a00feeae802390fd6016e8db96e2b90d5484fbd0d2317a94bdb4
-  data.tar.gz: f721214b5c3e6a71fb1ef21609d5180e232720ad201fca0c31b2baf62c925a76aea13c4c75ea9bdb312f2bb1ec555f93b6067e31fe931df4843b95db230c6655
+  metadata.gz: a81f892eef13d1f9c28a17daf44dc320a6c075e43b24f89e70b7f5d58ef91a2db35013e86b5de2b9be90360dcf53fd8757e7c54652f30b5ded0c71e2fe2bb95d
+  data.tar.gz: 77570a8ef7bb7dcfcbed470742686603cb361dc8fb593d737525e6b93e330084833d4c3b277c535a3c93131d1e10cf18296db70e9bb1246e915ead1456b78af9

data/lib/optimizely.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #
-#    Copyright 2016-2018, Optimizely and contributors
+#    Copyright 2016-2019, Optimizely and contributors
 #
 #    Licensed under the Apache License, Version 2.0 (the "License");
 #    you may not use this file except in compliance with the License.
@@ -201,24 +201,14 @@ module Optimizely
 
       return nil unless user_inputs_valid?(attributes, event_tags)
 
-      experiment_ids = @config.get_experiment_ids_for_event(event_key)
-      if experiment_ids.empty?
-        @config.logger.log(Logger::INFO, "Not tracking user '#{user_id}'.")
+      event = @config.get_event_from_key(event_key)
+      unless event
+        @config.logger.log(Logger::INFO, "Not tracking user '#{user_id}' for event '#{event_key}'.")
         return nil
       end
 
-      # Filter out experiments that are not running or that do not include the user in audience conditions
-
-      experiment_variation_map = get_valid_experiments_for_event(event_key, user_id, attributes)
-
-      # Don't track events without valid experiments attached
-      if experiment_variation_map.empty?
-        @logger.log(Logger::INFO, "There are no valid experiments for event '#{event_key}' to track.")
-        return nil
-      end
-
-      conversion_event = @event_builder.create_conversion_event(event_key, user_id, attributes,
-                                                                event_tags, experiment_variation_map)
+      conversion_event = @event_builder.create_conversion_event(event, user_id, attributes, event_tags)
+      @config.logger.log(Logger::INFO, "Tracking event '#{event_key}' for user '#{user_id}'.")
       @logger.log(Logger::INFO,
                   "Dispatching conversion event to URL #{conversion_event.url} with params #{conversion_event.params}.")
       begin
@@ -258,6 +248,8 @@ module Optimizely
         }, @logger, Logger::ERROR
       )
 
+      return false unless user_inputs_valid?(attributes)
+
       feature_flag = @config.get_feature_flag_from_key(feature_flag_key)
       unless feature_flag
         @logger.log(Logger::ERROR, "No feature flag was found for key '#{feature_flag_key}'.")
@@ -305,7 +297,13 @@ module Optimizely
         return enabled_features
       end
 
-      return enabled_features unless Optimizely::Helpers::Validator.inputs_valid?({user_id: user_id}, @logger, Logger::ERROR)
+      return enabled_features unless Optimizely::Helpers::Validator.inputs_valid?(
+        {
+          user_id: user_id
+        }, @logger, Logger::ERROR
+      )
+
+      return enabled_features unless user_inputs_valid?(attributes)
 
       @config.feature_flags.each do |feature|
         enabled_features.push(feature['key']) if is_feature_enabled(
@@ -444,12 +442,14 @@ module Optimizely
         {
           feature_flag_key: feature_flag_key,
           variable_key: variable_key,
-          variable_type: variable_type,
-          user_id: user_id
+          user_id: user_id,
+          variable_type: variable_type
         },
         @logger, Logger::ERROR
       )
 
+      return nil unless user_inputs_valid?(attributes)
+
       feature_flag = @config.get_feature_flag_from_key(feature_flag_key)
       unless feature_flag
         @logger.log(Logger::INFO, "No feature flag was found for key '#{feature_flag_key}'.")
@@ -492,34 +492,6 @@ module Optimizely
       variable_value
     end
 
-    def get_valid_experiments_for_event(event_key, user_id, attributes)
-      # Get the experiments that we should be tracking for the given event.
-      #
-      # event_key - Event key representing the event which needs to be recorded.
-      # user_id - String ID for user.
-      # attributes - Map of attributes of the user.
-      #
-      # Returns Map where each object contains the ID of the experiment to track and the ID of the variation the user
-      # is bucketed into.
-
-      valid_experiments = {}
-      experiment_ids = @config.get_experiment_ids_for_event(event_key)
-      experiment_ids.each do |experiment_id|
-        experiment_key = @config.get_experiment_key(experiment_id)
-        variation_key = get_variation(experiment_key, user_id, attributes)
-
-        if variation_key.nil?
-          @logger.log(Logger::INFO, "Not tracking user '#{user_id}' for experiment '#{experiment_key}'.")
-          next
-        end
-
-        variation_id = @config.get_variation_id_from_key(experiment_key, variation_key)
-        valid_experiments[experiment_id] = variation_id
-      end
-
-      valid_experiments
-    end
-
     def user_inputs_valid?(attributes = nil, event_tags = nil)
       # Helper method to validate user inputs.
       #

data/lib/optimizely/audience.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #
-#    Copyright 2016-2017, Optimizely and contributors
+#    Copyright 2016-2017, 2019, Optimizely and contributors
 #
 #    Licensed under the Apache License, Version 2.0 (the "License");
 #    you may not use this file except in compliance with the License.
@@ -16,7 +16,9 @@
 #    limitations under the License.
 #
 require 'json'
-require_relative './condition'
+require_relative './custom_attribute_condition_evaluator'
+require_relative 'condition_tree_evaluator'
+require_relative 'helpers/constants'
 
 module Optimizely
   module Audience
@@ -30,26 +32,78 @@ module Optimizely
       # attributes - Hash representing user attributes which will be used in determining if
       #              the audience conditions are met.
       #
-      # Returns boolean representing if user satisfies audience conditions for any of the audiences or not.
+      # Returns boolean representing if user satisfies audience conditions for the audiences or not.
 
-      audience_ids = experiment['audienceIds']
+      audience_conditions = experiment['audienceConditions'] || experiment['audienceIds']
+
+      config.logger.log(
+        Logger::DEBUG,
+        format(
+          Helpers::Constants::AUDIENCE_EVALUATION_LOGS['EVALUATING_AUDIENCES_COMBINED'],
+          experiment['key'],
+          audience_conditions
+        )
+      )
 
       # Return true if there are no audiences
-      return true if audience_ids.empty?
+      if audience_conditions.empty?
+        config.logger.log(
+          Logger::INFO,
+          format(
+            Helpers::Constants::AUDIENCE_EVALUATION_LOGS['AUDIENCE_EVALUATION_RESULT_COMBINED'],
+            experiment['key'],
+            'TRUE'
+          )
+        )
+        return true
+      end
+
+      attributes ||= {}
 
-      # Return false if there are audiences but no attributes
-      return false unless attributes
+      custom_attr_condition_evaluator = CustomAttributeConditionEvaluator.new(attributes, config.logger)
+
+      evaluate_custom_attr = lambda do |condition|
+        return custom_attr_condition_evaluator.evaluate(condition)
+      end
 
-      # Return true if any one of the audience conditions are met
-      @condition_evaluator = ConditionEvaluator.new(attributes)
-      audience_ids.each do |audience_id|
+      evaluate_audience = lambda do |audience_id|
         audience = config.get_audience_from_id(audience_id)
+        return nil unless audience
+
         audience_conditions = audience['conditions']
-        audience_conditions = JSON.parse(audience_conditions)
-        return true if @condition_evaluator.evaluate(audience_conditions)
+        config.logger.log(
+          Logger::DEBUG,
+          format(
+            Helpers::Constants::AUDIENCE_EVALUATION_LOGS['EVALUATING_AUDIENCE'],
+            audience_id,
+            audience_conditions
+          )
+        )
+
+        audience_conditions = JSON.parse(audience_conditions) if audience_conditions.is_a?(String)
+        result = ConditionTreeEvaluator.evaluate(audience_conditions, evaluate_custom_attr)
+        result_str = result.nil? ? 'UNKNOWN' : result.to_s.upcase
+        config.logger.log(
+          Logger::INFO,
+          format(Helpers::Constants::AUDIENCE_EVALUATION_LOGS['AUDIENCE_EVALUATION_RESULT'], audience_id, result_str)
+        )
+        result
       end
 
-      false
+      eval_result = ConditionTreeEvaluator.evaluate(audience_conditions, evaluate_audience)
+
+      eval_result ||= false
+
+      config.logger.log(
+        Logger::INFO,
+        format(
+          Helpers::Constants::AUDIENCE_EVALUATION_LOGS['AUDIENCE_EVALUATION_RESULT_COMBINED'],
+          experiment['key'],
+          eval_result.to_s.upcase
+        )
+      )
+
+      eval_result
     end
   end
 end

data/lib/optimizely/bucketer.rb

@@ -93,7 +93,10 @@ module Optimizely
 
       # Handle the case when the traffic range is empty due to sticky bucketing
       if variation_id == ''
-        @config.logger.log(Logger::DEBUG, 'Bucketed into an empty traffic range. Returning nil.')
+        @config.logger.log(
+          Logger::DEBUG,
+          'Bucketed into an empty traffic range. Returning nil.'
+        )
       end
 
       @config.logger.log(Logger::INFO, "User '#{user_id}' is in no variation.")

data/lib/optimizely/condition_tree_evaluator.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+#
+#    Copyright 2019, Optimizely and contributors
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+module Optimizely
+  module ConditionTreeEvaluator
+    # Operator types
+    AND_CONDITION = 'and'
+    OR_CONDITION = 'or'
+    NOT_CONDITION = 'not'
+
+    EVALUATORS_BY_OPERATOR_TYPE = {
+      AND_CONDITION => :and_evaluator,
+      OR_CONDITION => :or_evaluator,
+      NOT_CONDITION => :not_evaluator
+    }.freeze
+
+    module_function
+
+    def evaluate(conditions, leaf_evaluator)
+      # Top level method to evaluate audience conditions.
+      #
+      # conditions - Nested array of and/or conditions.
+      #              Example: ['and', operand_1, ['or', operand_2, operand_3]]
+      #
+      # leaf_evaluator - Function which will be called to evaluate leaf condition values.
+      #
+      # Returns boolean if the given user attributes match/don't match the given conditions,
+      #         nil if the given conditions are invalid or can't be evaluated.
+
+      if conditions.is_a? Array
+        first_operator =  conditions[0]
+        rest_of_conditions = conditions[1..-1]
+
+        # Operator to apply is not explicit - assume 'or'
+        unless EVALUATORS_BY_OPERATOR_TYPE.include?(conditions[0])
+          first_operator = OR_CONDITION
+          rest_of_conditions = conditions
+        end
+
+        return send(EVALUATORS_BY_OPERATOR_TYPE[first_operator], rest_of_conditions, leaf_evaluator)
+      end
+
+      leaf_evaluator.call(conditions)
+    end
+
+    def and_evaluator(conditions, leaf_evaluator)
+      # Evaluates an array of conditions as if the evaluator had been applied
+      # to each entry and the results AND-ed together.
+      #
+      # conditions - Array of conditions ex: [operand_1, operand_2]
+      #
+      # leaf_evaluator - Function which will be called to evaluate leaf condition values.
+      #
+      # Returns boolean if the user attributes match/don't match the given conditions,
+      #         nil if the user attributes and conditions can't be evaluated.
+
+      found_nil = false
+      conditions.each do |condition|
+        result = evaluate(condition, leaf_evaluator)
+        return result if result == false
+
+        found_nil = true if result.nil?
+      end
+
+      found_nil ? nil : true
+    end
+
+    def not_evaluator(single_condition, leaf_evaluator)
+      # Evaluates an array of conditions as if the evaluator had been applied
+      # to a single entry and NOT was applied to the result.
+      #
+      # single_condition - Array of a single condition ex: [operand_1]
+      #
+      # leaf_evaluator - Function which will be called to evaluate leaf condition values.
+      #
+      # Returns boolean if the user attributes match/don't match the given conditions,
+      #         nil if the user attributes and conditions can't be evaluated.
+
+      return nil if single_condition.empty?
+
+      result = evaluate(single_condition[0], leaf_evaluator)
+      result.nil? ? nil : !result
+    end
+
+    def or_evaluator(conditions, leaf_evaluator)
+      # Evaluates an array of conditions as if the evaluator had been applied
+      # to each entry and the results OR-ed together.
+      #
+      # conditions - Array of conditions ex: [operand_1, operand_2]
+      #
+      # leaf_evaluator - Function which will be called to evaluate leaf condition values.
+      #
+      # Returns boolean if the user attributes match/don't match the given conditions,
+      #         nil if the user attributes and conditions can't be evaluated.
+
+      found_nil = false
+      conditions.each do |condition|
+        result = evaluate(condition, leaf_evaluator)
+        return result if result == true
+
+        found_nil = true if result.nil?
+      end
+
+      found_nil ? nil : false
+    end
+  end
+end

data/lib/optimizely/custom_attribute_condition_evaluator.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+#
+#    Copyright 2019, Optimizely and contributors
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+require_relative 'helpers/constants'
+require_relative 'helpers/validator'
+
+module Optimizely
+  class CustomAttributeConditionEvaluator
+    CUSTOM_ATTRIBUTE_CONDITION_TYPE = 'custom_attribute'
+
+    # Conditional match types
+    EXACT_MATCH_TYPE = 'exact'
+    EXISTS_MATCH_TYPE = 'exists'
+    GREATER_THAN_MATCH_TYPE = 'gt'
+    LESS_THAN_MATCH_TYPE = 'lt'
+    SUBSTRING_MATCH_TYPE = 'substring'
+
+    EVALUATORS_BY_MATCH_TYPE = {
+      EXACT_MATCH_TYPE => :exact_evaluator,
+      EXISTS_MATCH_TYPE => :exists_evaluator,
+      GREATER_THAN_MATCH_TYPE => :greater_than_evaluator,
+      LESS_THAN_MATCH_TYPE => :less_than_evaluator,
+      SUBSTRING_MATCH_TYPE => :substring_evaluator
+    }.freeze
+
+    attr_reader :user_attributes
+
+    def initialize(user_attributes, logger)
+      @user_attributes = user_attributes
+      @logger = logger
+    end
+
+    def evaluate(leaf_condition)
+      # Top level method to evaluate audience conditions.
+      #
+      # conditions - Nested array of and/or conditions.
+      #              Example: ['and', operand_1, ['or', operand_2, operand_3]]
+      #
+      # Returns boolean if the given user attributes match/don't match the given conditions,
+      #         nil if the given conditions can't be evaluated.
+
+      unless leaf_condition['type'] == CUSTOM_ATTRIBUTE_CONDITION_TYPE
+        @logger.log(
+          Logger::WARN,
+          format(Helpers::Constants::AUDIENCE_EVALUATION_LOGS['UNKNOWN_CONDITION_TYPE'], leaf_condition)
+        )
+        return nil
+      end
+
+      condition_match = leaf_condition['match'] || EXACT_MATCH_TYPE
+
+      if !@user_attributes.key?(leaf_condition['name']) && condition_match != EXISTS_MATCH_TYPE
+        @logger.log(
+          Logger::DEBUG,
+          format(
+            Helpers::Constants::AUDIENCE_EVALUATION_LOGS['MISSING_ATTRIBUTE_VALUE'],
+            leaf_condition,
+            leaf_condition['name']
+          )
+        )
+        return nil
+      end
+
+      if @user_attributes[leaf_condition['name']].nil? && condition_match != EXISTS_MATCH_TYPE
+        @logger.log(
+          Logger::DEBUG,
+          format(
+            Helpers::Constants::AUDIENCE_EVALUATION_LOGS['NULL_ATTRIBUTE_VALUE'],
+            leaf_condition,
+            leaf_condition['name']
+          )
+        )
+        return nil
+      end
+
+      unless EVALUATORS_BY_MATCH_TYPE.include?(condition_match)
+        @logger.log(
+          Logger::WARN,
+          format(Helpers::Constants::AUDIENCE_EVALUATION_LOGS['UNKNOWN_MATCH_TYPE'], leaf_condition)
+        )
+        return nil
+      end
+
+      send(EVALUATORS_BY_MATCH_TYPE[condition_match], leaf_condition)
+    end
+
+    def exact_evaluator(condition)
+      # Evaluate the given exact match condition for the given user attributes.
+      #
+      # Returns boolean true if numbers values matched, i.e 2 is equal to 2.0
+      #                 true if the user attribute value is equal (===) to the condition value,
+      #                 false if the user attribute value is not equal (!==) to the condition value,
+      #                 nil if the condition value or user attribute value has an invalid type,
+      #                 or if there is a mismatch between the user attribute type and the condition value type.
+
+      condition_value = condition['value']
+
+      user_provided_value = @user_attributes[condition['name']]
+
+      if !value_type_valid_for_exact_conditions?(condition_value) ||
+         (condition_value.is_a?(Numeric) && !Helpers::Validator.finite_number?(condition_value))
+        @logger.log(
+          Logger::WARN,
+          format(Helpers::Constants::AUDIENCE_EVALUATION_LOGS['UNKNOWN_CONDITION_VALUE'], condition)
+        )
+        return nil
+      end
+
+      if !value_type_valid_for_exact_conditions?(user_provided_value) ||
+         !Helpers::Validator.same_types?(condition_value, user_provided_value)
+        @logger.log(
+          Logger::WARN,
+          format(
+            Helpers::Constants::AUDIENCE_EVALUATION_LOGS['UNEXPECTED_TYPE'],
+            condition,
+            user_provided_value.class,
+            condition['name']
+          )
+        )
+        return nil
+      end
+
+      if user_provided_value.is_a?(Numeric) && !Helpers::Validator.finite_number?(user_provided_value)
+        @logger.log(
+          Logger::WARN,
+          format(
+            Helpers::Constants::AUDIENCE_EVALUATION_LOGS['INFINITE_ATTRIBUTE_VALUE'],
+            condition,
+            condition['name']
+          )
+        )
+        return nil
+      end
+
+      condition_value == user_provided_value
+    end
+
+    def exists_evaluator(condition)
+      # Evaluate the given exists match condition for the given user attributes.
+      # Returns boolean true if both:
+      #                    1) the user attributes have a value for the given condition, and
+      #                    2) the user attribute value is neither nil nor undefined
+      #                 Returns false otherwise
+
+      !@user_attributes[condition['name']].nil?
+    end
+
+    def greater_than_evaluator(condition)
+      # Evaluate the given greater than match condition for the given user attributes.
+      # Returns boolean true if the user attribute value is greater than the condition value,
+      #                 false if the user attribute value is less than or equal to the condition value,
+      #                 nil if the condition value isn't a number or the user attribute value isn't a number.
+
+      condition_value = condition['value']
+      user_provided_value = @user_attributes[condition['name']]
+
+      return nil unless valid_numeric_values?(user_provided_value, condition_value, condition)
+
+      user_provided_value > condition_value
+    end
+
+    def less_than_evaluator(condition)
+      # Evaluate the given less than match condition for the given user attributes.
+      # Returns boolean true if the user attribute value is less than the condition value,
+      #                 false if the user attribute value is greater than or equal to the condition value,
+      #                 nil if the condition value isn't a number or the user attribute value isn't a number.
+
+      condition_value = condition['value']
+      user_provided_value = @user_attributes[condition['name']]
+
+      return nil unless valid_numeric_values?(user_provided_value, condition_value, condition)
+
+      user_provided_value < condition_value
+    end
+
+    def substring_evaluator(condition)
+      # Evaluate the given substring match condition for the given user attributes.
+      # Returns boolean true if the condition value is a substring of the user attribute value,
+      #                 false if the condition value is not a substring of the user attribute value,
+      #                 nil if the condition value isn't a string or the user attribute value isn't a string.
+
+      condition_value = condition['value']
+      user_provided_value = @user_attributes[condition['name']]
+
+      unless condition_value.is_a?(String)
+        @logger.log(
+          Logger::WARN,
+          format(Helpers::Constants::AUDIENCE_EVALUATION_LOGS['UNKNOWN_CONDITION_VALUE'], condition)
+        )
+        return nil
+      end
+
+      unless user_provided_value.is_a?(String)
+        @logger.log(
+          Logger::WARN,
+          format(
+            Helpers::Constants::AUDIENCE_EVALUATION_LOGS['UNEXPECTED_TYPE'],
+            condition,
+            user_provided_value.class,
+            condition['name']
+          )
+        )
+        return nil
+      end
+
+      user_provided_value.include? condition_value
+    end
+
+    private
+
+    def valid_numeric_values?(user_value, condition_value, condition)
+      # Returns true if user and condition values are valid numeric.
+      #         false otherwise.
+
+      unless Helpers::Validator.finite_number?(condition_value)
+        @logger.log(
+          Logger::WARN,
+          format(Helpers::Constants::AUDIENCE_EVALUATION_LOGS['UNKNOWN_CONDITION_VALUE'], condition)
+        )
+        return false
+      end
+
+      unless user_value.is_a?(Numeric)
+        @logger.log(
+          Logger::WARN,
+          format(
+            Helpers::Constants::AUDIENCE_EVALUATION_LOGS['UNEXPECTED_TYPE'],
+            condition,
+            user_value.class,
+            condition['name']
+          )
+        )
+        return false
+      end
+
+      unless Helpers::Validator.finite_number?(user_value)
+        @logger.log(
+          Logger::WARN,
+          format(
+            Helpers::Constants::AUDIENCE_EVALUATION_LOGS['INFINITE_ATTRIBUTE_VALUE'],
+            condition,
+            condition['name']
+          )
+        )
+        return false
+      end
+
+      true
+    end
+
+    def value_type_valid_for_exact_conditions?(value)
+      # Returns true if the value is valid for exact conditions. Valid values include
+      #  strings or booleans or is a number.
+      #  false otherwise.
+
+      (Helpers::Validator.boolean? value) || (value.is_a? String) || value.is_a?(Numeric)
+    end
+  end
+end