optimizely-sdk 3.5.0 → 3.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c89ea6be1aa10ab05c2d47e74ebe054987e6fc0e08b85417a63b579d80f2fac4
-  data.tar.gz: 1f35f5d10017780db25f46e270d64010d0dc5e245bd4b183ae1da8ee1dfb060d
+  metadata.gz: 4d8204dce32c85bea56820607c0268b363fb86e7506ce685a2675645b4ef581b
+  data.tar.gz: dce7cd63fde5e24e179a74f8f14c6a22ed389028faac38a373af105683b596f0
 SHA512:
-  metadata.gz: d2fd93c8952496d3feb12ec4dd8fb8ced95f7123a94447b646b14e157cdaf82af65adfc193943a6efc7ff77069d4600d5006728c876f9ff0d06d9116ad2c58a1
-  data.tar.gz: a5ffc4c7db14a01e4bc7741eca6c636b6f41e755a7256fae64703e5241bd6ade20190c8f0b83bdc37d7cb18277439659ce09faa68388c7e74db2d6d3463d470a
+  metadata.gz: 5cc88f9802b38a2eb29354507303c6dcdcf6a402f721d24689f1e42a52a79319568974cf3584c6bf94398ff5f1410aacf49a1adf7aa27ef9105f3e7b23d39e3d
+  data.tar.gz: a6f0a7f052bb851ce760c4c88e0fe0dea18c14b42d5bcf457ac9cfefe3eaa2027f1b847c2ab0c133233618502cfe9207b1e82a5b1d65d0d4a678b58f5ea0ff88

data/lib/optimizely.rb

@@ -806,15 +806,16 @@ module Optimizely
                         "Got variable value '#{variable_value}' for variable '#{variable['key']}' of feature flag '#{feature_flag_key}'.")
           else
             @logger.log(Logger::DEBUG,
-                        "Variable '#{variable['key']}' is not used in variation '#{variation['key']}'. Returning the default variable value '#{variable_value}'.")
+                        "Variable value is not defined. Returning the default variable value '#{variable_value}' for variable '#{variable['key']}'.")
+
           end
         else
           @logger.log(Logger::DEBUG,
-                      "Feature '#{feature_flag_key}' for variation '#{variation['key']}' is not enabled. Returning the default variable value '#{variable_value}'.")
+                      "Feature '#{feature_flag_key}' is not enabled for user '#{user_id}'. Returning the default variable value '#{variable_value}'.")
         end
       else
         @logger.log(Logger::INFO,
-                    "User '#{user_id}' was not bucketed into any variation for feature flag '#{feature_flag_key}'. Returning the default variable value '#{variable_value}'.")
+                    "User '#{user_id}' was not bucketed into experiment or rollout for feature flag '#{feature_flag_key}'. Returning the default variable value '#{variable_value}'.")
       end
       variable_value
     end

data/lib/optimizely/audience.rb

@@ -24,23 +24,32 @@ module Optimizely
   module Audience
     module_function
 
-    def user_in_experiment?(config, experiment, attributes, logger)
-      # Determine for given experiment if user satisfies the audiences for the experiment.
+    def user_meets_audience_conditions?(config, experiment, attributes, logger, logging_hash = nil, logging_key = nil)
+      # Determine for given experiment/rollout rule if user satisfies the audience conditions.
       #
       # config - Representation of the Optimizely project config.
-      # experiment - Experiment for which visitor is to be bucketed.
+      # experiment - Experiment/Rollout rule in which user is to be bucketed.
       # attributes - Hash representing user attributes which will be used in determining if
       #              the audience conditions are met.
+      # logger - Provides a logger instance.
+      # logging_hash - Optional string representing logs hash inside Helpers::Constants.
+      #                This defaults to 'EXPERIMENT_AUDIENCE_EVALUATION_LOGS'.
+      # logging_key - Optional string to be logged as an identifier of experiment under evaluation.
+      #               This defaults to experiment['key'].
       #
       # Returns boolean representing if user satisfies audience conditions for the audiences or not.
+      logging_hash ||= 'EXPERIMENT_AUDIENCE_EVALUATION_LOGS'
+      logging_key ||= experiment['key']
+
+      logs_hash = Object.const_get "Optimizely::Helpers::Constants::#{logging_hash}"
 
       audience_conditions = experiment['audienceConditions'] || experiment['audienceIds']
 
       logger.log(
         Logger::DEBUG,
         format(
-          Helpers::Constants::AUDIENCE_EVALUATION_LOGS['EVALUATING_AUDIENCES_COMBINED'],
-          experiment['key'],
+          logs_hash['EVALUATING_AUDIENCES_COMBINED'],
+          logging_key,
           audience_conditions
         )
       )
@@ -50,8 +59,8 @@ module Optimizely
         logger.log(
           Logger::INFO,
           format(
-            Helpers::Constants::AUDIENCE_EVALUATION_LOGS['AUDIENCE_EVALUATION_RESULT_COMBINED'],
-            experiment['key'],
+            logs_hash['AUDIENCE_EVALUATION_RESULT_COMBINED'],
+            logging_key,
             'TRUE'
           )
         )
@@ -74,7 +83,7 @@ module Optimizely
         logger.log(
           Logger::DEBUG,
           format(
-            Helpers::Constants::AUDIENCE_EVALUATION_LOGS['EVALUATING_AUDIENCE'],
+            logs_hash['EVALUATING_AUDIENCE'],
             audience_id,
             audience_conditions
           )
@@ -85,7 +94,7 @@ module Optimizely
         result_str = result.nil? ? 'UNKNOWN' : result.to_s.upcase
         logger.log(
           Logger::DEBUG,
-          format(Helpers::Constants::AUDIENCE_EVALUATION_LOGS['AUDIENCE_EVALUATION_RESULT'], audience_id, result_str)
+          format(logs_hash['AUDIENCE_EVALUATION_RESULT'], audience_id, result_str)
         )
         result
       end
@@ -97,8 +106,8 @@ module Optimizely
       logger.log(
         Logger::INFO,
         format(
-          Helpers::Constants::AUDIENCE_EVALUATION_LOGS['AUDIENCE_EVALUATION_RESULT_COMBINED'],
-          experiment['key'],
+          logs_hash['AUDIENCE_EVALUATION_RESULT_COMBINED'],
+          logging_key,
           eval_result.to_s.upcase
         )
       )

data/lib/optimizely/bucketer.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #
-#    Copyright 2016-2017, 2019 Optimizely and contributors
+#    Copyright 2016-2017, 2019-2020 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.
@@ -39,7 +39,7 @@ module Optimizely
       # Determines ID of variation to be shown for a given experiment key and user ID.
       #
       # project_config - Instance of ProjectConfig
-      # experiment - Experiment for which visitor is to be bucketed.
+      # experiment - Experiment or Rollout rule for which visitor is to be bucketed.
       # bucketing_id - String A customer-assigned value used to generate the bucketing key
       # user_id - String ID for user.
       #
@@ -47,6 +47,7 @@ module Optimizely
       return nil if experiment.nil?
 
       # check if experiment is in a group; if so, check if user is bucketed into specified experiment
+      # this will not affect evaluation of rollout rules.
       experiment_id = experiment['id']
       experiment_key = experiment['key']
       group_id = experiment['groupId']
@@ -82,11 +83,6 @@ module Optimizely
       variation_id = find_bucket(bucketing_id, user_id, experiment_id, traffic_allocations)
       if variation_id && variation_id != ''
         variation = project_config.get_variation_from_id(experiment_key, variation_id)
-        variation_key = variation ? variation['key'] : nil
-        @logger.log(
-          Logger::INFO,
-          "User '#{user_id}' is in variation '#{variation_key}' of experiment '#{experiment_key}'."
-        )
         return variation
       end
 
@@ -98,7 +94,6 @@ module Optimizely
         )
       end
 
-      @logger.log(Logger::INFO, "User '#{user_id}' is in no variation.")
       nil
     end
 

data/lib/optimizely/config/datafile_project_config.rb

@@ -24,6 +24,7 @@ module Optimizely
     RUNNING_EXPERIMENT_STATUS = ['Running'].freeze
     RESERVED_ATTRIBUTE_PREFIX = '$opt_'
 
+    attr_reader :datafile
     attr_reader :account_id
     attr_reader :attributes
     attr_reader :audiences
@@ -62,6 +63,7 @@ module Optimizely
 
       config = JSON.parse(datafile)
 
+      @datafile = datafile
       @error_handler = error_handler
       @logger = logger
       @version = config['version']

data/lib/optimizely/custom_attribute_condition_evaluator.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #
-#    Copyright 2019, Optimizely and contributors
+#    Copyright 2019-2020, 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.
@@ -15,8 +15,10 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 #
+require_relative 'exceptions'
 require_relative 'helpers/constants'
 require_relative 'helpers/validator'
+require_relative 'semantic_version'
 
 module Optimizely
   class CustomAttributeConditionEvaluator
@@ -26,15 +28,29 @@ module Optimizely
     EXACT_MATCH_TYPE = 'exact'
     EXISTS_MATCH_TYPE = 'exists'
     GREATER_THAN_MATCH_TYPE = 'gt'
+    GREATER_EQUAL_MATCH_TYPE = 'ge'
     LESS_THAN_MATCH_TYPE = 'lt'
+    LESS_EQUAL_MATCH_TYPE = 'le'
     SUBSTRING_MATCH_TYPE = 'substring'
+    SEMVER_EQ = 'semver_eq'
+    SEMVER_GE = 'semver_ge'
+    SEMVER_GT = 'semver_gt'
+    SEMVER_LE = 'semver_le'
+    SEMVER_LT = 'semver_lt'
 
     EVALUATORS_BY_MATCH_TYPE = {
       EXACT_MATCH_TYPE => :exact_evaluator,
       EXISTS_MATCH_TYPE => :exists_evaluator,
       GREATER_THAN_MATCH_TYPE => :greater_than_evaluator,
+      GREATER_EQUAL_MATCH_TYPE => :greater_than_or_equal_evaluator,
       LESS_THAN_MATCH_TYPE => :less_than_evaluator,
-      SUBSTRING_MATCH_TYPE => :substring_evaluator
+      LESS_EQUAL_MATCH_TYPE => :less_than_or_equal_evaluator,
+      SUBSTRING_MATCH_TYPE => :substring_evaluator,
+      SEMVER_EQ => :semver_equal_evaluator,
+      SEMVER_GE => :semver_greater_than_or_equal_evaluator,
+      SEMVER_GT => :semver_greater_than_evaluator,
+      SEMVER_LE => :semver_less_than_or_equal_evaluator,
+      SEMVER_LT => :semver_less_than_evaluator
     }.freeze
 
     attr_reader :user_attributes
@@ -95,7 +111,35 @@ module Optimizely
         return nil
       end
 
-      send(EVALUATORS_BY_MATCH_TYPE[condition_match], leaf_condition)
+      begin
+        send(EVALUATORS_BY_MATCH_TYPE[condition_match], leaf_condition)
+      rescue InvalidAttributeType
+        condition_name = leaf_condition['name']
+        user_value = @user_attributes[condition_name]
+
+        @logger.log(
+          Logger::WARN,
+          format(
+            Helpers::Constants::AUDIENCE_EVALUATION_LOGS['UNEXPECTED_TYPE'],
+            leaf_condition,
+            user_value.class,
+            condition_name
+          )
+        )
+        return nil
+      rescue InvalidSemanticVersion
+        condition_name = leaf_condition['name']
+
+        @logger.log(
+          Logger::WARN,
+          format(
+            Helpers::Constants::AUDIENCE_EVALUATION_LOGS['INVALID_SEMANTIC_VERSION'],
+            leaf_condition,
+            condition_name
+          )
+        )
+        return nil
+      end
     end
 
     def exact_evaluator(condition)
@@ -122,16 +166,7 @@ module Optimizely
 
       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
+        raise InvalidAttributeType
       end
 
       if user_provided_value.is_a?(Numeric) && !Helpers::Validator.finite_number?(user_provided_value)
@@ -173,6 +208,20 @@ module Optimizely
       user_provided_value > condition_value
     end
 
+    def greater_than_or_equal_evaluator(condition)
+      # Evaluate the given greater than or equal match condition for the given user attributes.
+      # Returns boolean true if the user attribute value is greater than or equal to the condition value,
+      #                 false if the user attribute value is less than 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,
@@ -187,6 +236,20 @@ module Optimizely
       user_provided_value < condition_value
     end
 
+    def less_than_or_equal_evaluator(condition)
+      # Evaluate the given less than or equal match condition for the given user attributes.
+      # Returns boolean true if the user attribute value is less than or equal to the condition value,
+      #                 false if the user attribute value is greater than 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,
@@ -204,22 +267,66 @@ module Optimizely
         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
+      raise InvalidAttributeType unless user_provided_value.is_a?(String)
 
       user_provided_value.include? condition_value
     end
 
+    def semver_equal_evaluator(condition)
+      # Evaluate the given semantic version equal match target version for the user version.
+      # Returns boolean true if the user version is equal to the target version,
+      #                 false if the user version is not equal to the target version
+
+      target_version = condition['value']
+      user_version = @user_attributes[condition['name']]
+
+      SemanticVersion.compare_user_version_with_target_version(target_version, user_version).zero?
+    end
+
+    def semver_greater_than_evaluator(condition)
+      # Evaluate the given semantic version greater than match target version for the user version.
+      # Returns boolean true if the user version is greater than the target version,
+      #                 false if the user version is less than or equal to the target version
+
+      target_version = condition['value']
+      user_version = @user_attributes[condition['name']]
+
+      SemanticVersion.compare_user_version_with_target_version(target_version, user_version).positive?
+    end
+
+    def semver_greater_than_or_equal_evaluator(condition)
+      # Evaluate the given semantic version greater than or equal to match target version for the user version.
+      # Returns boolean true if the user version is greater than or equal to the target version,
+      #                 false if the user version is less than the target version
+
+      target_version = condition['value']
+      user_version = @user_attributes[condition['name']]
+
+      SemanticVersion.compare_user_version_with_target_version(target_version, user_version) >= 0
+    end
+
+    def semver_less_than_evaluator(condition)
+      # Evaluate the given semantic version less than match target version for the user version.
+      # Returns boolean true if the user version is less than the target version,
+      #                 false if the user version is greater than or equal to the target version
+
+      target_version = condition['value']
+      user_version = @user_attributes[condition['name']]
+
+      SemanticVersion.compare_user_version_with_target_version(target_version, user_version).negative?
+    end
+
+    def semver_less_than_or_equal_evaluator(condition)
+      # Evaluate the given semantic version less than or equal to match target version for the user version.
+      # Returns boolean true if the user version is less than or equal to the target version,
+      #                 false if the user version is greater than the target version
+
+      target_version = condition['value']
+      user_version = @user_attributes[condition['name']]
+
+      SemanticVersion.compare_user_version_with_target_version(target_version, user_version) <= 0
+    end
+
     private
 
     def valid_numeric_values?(user_value, condition_value, condition)
@@ -234,18 +341,7 @@ module Optimizely
         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
+      raise InvalidAttributeType unless user_value.is_a?(Numeric)
 
       unless Helpers::Validator.finite_number?(user_value)
         @logger.log(

data/lib/optimizely/decision_service.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #
-#    Copyright 2017-2019, Optimizely and contributors
+#    Copyright 2017-2020, 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.
@@ -94,7 +94,7 @@ module Optimizely
       end
 
       # Check audience conditions
-      unless Audience.user_in_experiment?(project_config, experiment, attributes, @logger)
+      unless Audience.user_meets_audience_conditions?(project_config, experiment, attributes, @logger)
         @logger.log(
           Logger::INFO,
           "User '#{user_id}' does not meet the conditions to be in experiment '#{experiment_key}'."
@@ -106,6 +106,16 @@ module Optimizely
       variation = @bucketer.bucket(project_config, experiment, bucketing_id, user_id)
       variation_id = variation ? variation['id'] : nil
 
+      if variation_id
+        variation_key = variation['key']
+        @logger.log(
+          Logger::INFO,
+          "User '#{user_id}' is in variation '#{variation_key}' of experiment '#{experiment_key}'."
+        )
+      else
+        @logger.log(Logger::INFO, "User '#{user_id}' is in no variation.")
+      end
+
       # Persist bucketing decision
       save_user_profile(user_profile, experiment_id, variation_id)
       variation_id
@@ -125,21 +135,9 @@ module Optimizely
       decision = get_variation_for_feature_experiment(project_config, feature_flag, user_id, attributes)
       return decision unless decision.nil?
 
-      feature_flag_key = feature_flag['key']
       decision = get_variation_for_feature_rollout(project_config, feature_flag, user_id, attributes)
-      if decision
-        @logger.log(
-          Logger::INFO,
-          "User '#{user_id}' is bucketed into a rollout for feature flag '#{feature_flag_key}'."
-        )
-        return decision
-      end
-      @logger.log(
-        Logger::INFO,
-        "User '#{user_id}' is not bucketed into a rollout for feature flag '#{feature_flag_key}'."
-      )
 
-      nil
+      decision
     end
 
     def get_variation_for_feature_experiment(project_config, feature_flag, user_id, attributes = nil)
@@ -178,10 +176,7 @@ module Optimizely
         next unless variation_id
 
         variation = project_config.variation_id_map[experiment_key][variation_id]
-        @logger.log(
-          Logger::INFO,
-          "The user '#{user_id}' is bucketed into experiment '#{experiment_key}' of feature '#{feature_flag_key}'."
-        )
+
         return Decision.new(experiment, variation, DECISION_SOURCES['FEATURE_TEST'])
       end
 
@@ -231,20 +226,23 @@ module Optimizely
       # Go through each experiment in order and try to get the variation for the user
       number_of_rules.times do |index|
         rollout_rule = rollout_rules[index]
-        audience_id = rollout_rule['audienceIds'][0]
-        audience = project_config.get_audience_from_id(audience_id)
-        audience_name = audience['name']
+        logging_key = index + 1
 
         # Check that user meets audience conditions for targeting rule
-        unless Audience.user_in_experiment?(project_config, rollout_rule, attributes, @logger)
+        unless Audience.user_meets_audience_conditions?(project_config, rollout_rule, attributes, @logger, 'ROLLOUT_AUDIENCE_EVALUATION_LOGS', logging_key)
           @logger.log(
             Logger::DEBUG,
-            "User '#{user_id}' does not meet the conditions to be in rollout rule for audience '#{audience_name}'."
+            "User '#{user_id}' does not meet the audience conditions for targeting rule '#{logging_key}'."
           )
           # move onto the next targeting rule
           next
         end
 
+        @logger.log(
+          Logger::DEBUG,
+          "User '#{user_id}' meets the audience conditions for targeting rule '#{logging_key}'."
+        )
+
         # Evaluate if user satisfies the traffic allocation for this rollout rule
         variation = @bucketer.bucket(project_config, rollout_rule, bucketing_id, user_id)
         return Decision.new(rollout_rule, variation, DECISION_SOURCES['ROLLOUT']) unless variation.nil?
@@ -254,17 +252,20 @@ module Optimizely
 
       # get last rule which is the everyone else rule
       everyone_else_experiment = rollout_rules[number_of_rules]
+      logging_key = 'Everyone Else'
       # Check that user meets audience conditions for last rule
-      unless Audience.user_in_experiment?(project_config, everyone_else_experiment, attributes, @logger)
-        audience_id = everyone_else_experiment['audienceIds'][0]
-        audience = project_config.get_audience_from_id(audience_id)
-        audience_name = audience['name']
+      unless Audience.user_meets_audience_conditions?(project_config, everyone_else_experiment, attributes, @logger, 'ROLLOUT_AUDIENCE_EVALUATION_LOGS', logging_key)
         @logger.log(
           Logger::DEBUG,
-          "User '#{user_id}' does not meet the conditions to be in rollout rule for audience '#{audience_name}'."
+          "User '#{user_id}' does not meet the audience conditions for targeting rule '#{logging_key}'."
         )
         return nil
       end
+
+      @logger.log(
+        Logger::DEBUG,
+        "User '#{user_id}' meets the audience conditions for targeting rule '#{logging_key}'."
+      )
       variation = @bucketer.bucket(project_config, everyone_else_experiment, bucketing_id, user_id)
       return Decision.new(everyone_else_experiment, variation, DECISION_SOURCES['ROLLOUT']) unless variation.nil?
 

data/lib/optimizely/exceptions.rb

@@ -120,4 +120,20 @@ module Optimizely
       super("Optimizely instance is not valid. Failing '#{aborted_method}'.")
     end
   end
+
+  class InvalidAttributeType < Error
+    # Raised when an attribute is not provided in expected type.
+
+    def initialize(msg = 'Provided attribute value is not in the expected data type.')
+      super
+    end
+  end
+
+  class InvalidSemanticVersion < Error
+    # Raised when an invalid value is provided as semantic version.
+
+    def initialize(msg = 'Provided semantic version is invalid.')
+      super
+    end
+  end
 end

data/lib/optimizely/helpers/constants.rb

@@ -335,11 +335,11 @@ module Optimizely
 
       AUDIENCE_EVALUATION_LOGS = {
         'AUDIENCE_EVALUATION_RESULT' => "Audience '%s' evaluated to %s.",
-        'AUDIENCE_EVALUATION_RESULT_COMBINED' => "Audiences for experiment '%s' collectively evaluated to %s.",
         'EVALUATING_AUDIENCE' => "Starting to evaluate audience '%s' with conditions: %s.",
-        'EVALUATING_AUDIENCES_COMBINED' => "Evaluating audiences for experiment '%s': %s.",
         'INFINITE_ATTRIBUTE_VALUE' => 'Audience condition %s evaluated to UNKNOWN because the number value ' \
         "for user attribute '%s' is not in the range [-2^53, +2^53].",
+        'INVALID_SEMANTIC_VERSION' => 'Audience condition %s evaluated as UNKNOWN because an invalid semantic version ' \
+        "was passed for user attribute '%s'.",
         'MISSING_ATTRIBUTE_VALUE' => 'Audience condition %s evaluated as UNKNOWN because no value ' \
         "was passed for user attribute '%s'.",
         'NULL_ATTRIBUTE_VALUE' => 'Audience condition %s evaluated to UNKNOWN because a nil value was passed ' \
@@ -354,6 +354,16 @@ module Optimizely
         'to upgrade to a newer release of the Optimizely SDK.'
       }.freeze
 
+      EXPERIMENT_AUDIENCE_EVALUATION_LOGS = {
+        'AUDIENCE_EVALUATION_RESULT_COMBINED' => "Audiences for experiment '%s' collectively evaluated to %s.",
+        'EVALUATING_AUDIENCES_COMBINED' => "Evaluating audiences for experiment '%s': %s."
+      }.merge(AUDIENCE_EVALUATION_LOGS).freeze
+
+      ROLLOUT_AUDIENCE_EVALUATION_LOGS = {
+        'AUDIENCE_EVALUATION_RESULT_COMBINED' => "Audiences for rule '%s' collectively evaluated to %s.",
+        'EVALUATING_AUDIENCES_COMBINED' => "Evaluating audiences for rule '%s': %s."
+      }.merge(AUDIENCE_EVALUATION_LOGS).freeze
+
       DECISION_NOTIFICATION_TYPES = {
         'AB_TEST' => 'ab-test',
         'FEATURE' => 'feature',

data/lib/optimizely/optimizely_config.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-#    Copyright 2019, Optimizely and contributors
+#    Copyright 2019-2020, 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.
@@ -25,6 +25,7 @@ module Optimizely
       experiments_map_object = experiments_map
       features_map = get_features_map(experiments_map_object)
       {
+        'datafile' => @project_config.datafile,
         'experimentsMap' => experiments_map_object,
         'featuresMap' => features_map,
         'revision' => @project_config.revision

data/lib/optimizely/project_config.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-#    Copyright 2016-2019, Optimizely and contributors
+#    Copyright 2016-2020, 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.
@@ -20,6 +20,8 @@ module Optimizely
     # ProjectConfig is an interface capturing the experiment, variation and feature definitions.
     # The default implementation of ProjectConfig can be found in DatafileProjectConfig.
 
+    def datafile; end
+
     def account_id; end
 
     def attributes; end

data/lib/optimizely/semantic_version.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+#
+#    Copyright 2020, 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 'exceptions'
+
+module Optimizely
+  module SemanticVersion
+    # Semantic Version Operators
+    SEMVER_PRE_RELEASE = '-'
+    SEMVER_BUILD = '+'
+
+    module_function
+
+    def pre_release?(target)
+      # Method to check if the given version is a prerelease
+      #
+      # target - String representing semantic version
+      #
+      # Returns true if the given version is a prerelease
+      #         false if it doesn't
+
+      raise unless target.is_a? String
+
+      prerelease_index = target.index(SEMVER_PRE_RELEASE)
+      build_index = target.index(SEMVER_BUILD)
+
+      return false if prerelease_index.nil?
+      return true if build_index.nil?
+
+      # when both operators are present prerelease should precede the build operator
+      prerelease_index < build_index
+    end
+
+    def build?(target)
+      # Method to check if the given version is a build
+      #
+      # target - String representing semantic version
+      #
+      # Returns true if the given version is a build
+      #         false if it doesn't
+
+      raise unless target.is_a? String
+
+      prerelease_index = target.index(SEMVER_PRE_RELEASE)
+      build_index = target.index(SEMVER_BUILD)
+
+      return false if build_index.nil?
+      return true if prerelease_index.nil?
+
+      # when both operators are present build should precede the prerelease operator
+      build_index < prerelease_index
+    end
+
+    def split_semantic_version(target)
+      # Method to split the given version.
+      #
+      # target - String representing semantic version
+      #
+      # Returns List The array of version split into smaller parts i.e major, minor, patch etc,
+      #         Exception if the given version is invalid.
+
+      target_prefix = target
+      target_suffix = ''
+      target_parts = []
+
+      raise InvalidSemanticVersion if target.include? ' '
+
+      if pre_release?(target)
+        target_parts = target.split(SEMVER_PRE_RELEASE, 2)
+      elsif build? target
+        target_parts = target.split(SEMVER_BUILD, 2)
+      end
+
+      unless target_parts.empty?
+        target_prefix = target_parts[0].to_s
+        target_suffix = target_parts[1..-1]
+      end
+
+      # expect a version string of the form x.y.z
+      dot_count = target_prefix.count('.')
+      raise InvalidSemanticVersion if dot_count > 2
+
+      target_version_parts = target_prefix.split('.')
+      raise InvalidSemanticVersion if target_version_parts.length != dot_count + 1
+
+      target_version_parts.each do |part|
+        raise InvalidSemanticVersion unless Helpers::Validator.string_numeric? part
+      end
+
+      target_version_parts.concat(target_suffix) if target_suffix.is_a?(Array)
+
+      target_version_parts
+    end
+
+    def compare_user_version_with_target_version(target_version, user_version)
+      # Compares target and user versions
+      #
+      # target_version - String representing target version
+      # user_version - String representing user version
+
+      # Returns boolean 0 if user version is equal to target version,
+      #                 1 if user version is greater than target version,
+      #                -1 if user version is less than target version.
+
+      raise InvalidAttributeType unless target_version.is_a? String
+      raise InvalidAttributeType unless user_version.is_a? String
+
+      is_target_version_prerelease = pre_release?(target_version)
+      is_user_version_prerelease = pre_release?(user_version)
+
+      target_version_parts = split_semantic_version(target_version)
+      user_version_parts = split_semantic_version(user_version)
+      user_version_parts_len = user_version_parts.length if user_version_parts
+
+      # Up to the precision of targetedVersion, expect version to match exactly.
+      target_version_parts.each_with_index do |_item, idx|
+        if user_version_parts_len <= idx
+          # even if they are equal at this point. if the target is a prerelease
+          # then user version must be greater than the pre release.
+          return 1 if is_target_version_prerelease
+
+          return -1
+
+        elsif !Helpers::Validator.string_numeric? user_version_parts[idx]
+          # compare strings
+          if user_version_parts[idx] < target_version_parts[idx]
+            return 1 if is_target_version_prerelease && !is_user_version_prerelease
+
+            return -1
+
+          elsif user_version_parts[idx] > target_version_parts[idx]
+            return -1 if is_user_version_prerelease && !is_target_version_prerelease
+
+            return 1
+          end
+
+        else
+          user_version_part = user_version_parts[idx].to_i
+          target_version_part = target_version_parts[idx].to_i
+
+          return 1 if user_version_part > target_version_part
+          return -1 if user_version_part < target_version_part
+        end
+      end
+
+      return -1 if is_user_version_prerelease && !is_target_version_prerelease
+
+      0
+    end
+  end
+end

data/lib/optimizely/version.rb

@@ -17,5 +17,5 @@
 #
 module Optimizely
   CLIENT_ENGINE = 'ruby-sdk'
-  VERSION = '3.5.0'
+  VERSION = '3.6.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: optimizely-sdk
 version: !ruby/object:Gem::Version
-  version: 3.5.0
+  version: 3.6.0
 platform: ruby
 authors:
 - Optimizely
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-09 00:00:00.000000000 Z
+date: 2020-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -174,6 +174,7 @@ files:
 - lib/optimizely/optimizely_factory.rb
 - lib/optimizely/params.rb
 - lib/optimizely/project_config.rb
+- lib/optimizely/semantic_version.rb
 - lib/optimizely/user_profile_service.rb
 - lib/optimizely/version.rb
 homepage: https://www.optimizely.com/