optimizely-sdk 3.3.2 → 3.7.0

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

@@ -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.
@@ -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
@@ -39,6 +40,7 @@ module Optimizely
     attr_reader :revision
     attr_reader :rollouts
     attr_reader :version
+    attr_reader :send_flag_decisions
 
     attr_reader :attribute_key_map
     attr_reader :audience_id_map
@@ -62,6 +64,7 @@ module Optimizely
 
       config = JSON.parse(datafile)
 
+      @datafile = datafile
       @error_handler = error_handler
       @logger = logger
       @version = config['version']
@@ -81,6 +84,18 @@ module Optimizely
       @bot_filtering = config['botFiltering']
       @revision = config['revision']
       @rollouts = config.fetch('rollouts', [])
+      @send_flag_decisions = config.fetch('sendFlagDecisions', false)
+
+      # Json type is represented in datafile as a subtype of string for the sake of backwards compatibility.
+      # Converting it to a first-class json type while creating Project Config
+      @feature_flags.each do |feature_flag|
+        feature_flag['variables'].each do |variable|
+          if variable['type'] == 'string' && variable['subType'] == 'json'
+            variable['type'] = 'json'
+            variable.delete('subType')
+          end
+        end
+      end
 
       # Utility maps for quick lookup
       @attribute_key_map = generate_key_map(@attributes, 'key')
@@ -159,8 +174,9 @@ module Optimizely
         config = new(datafile, logger, error_handler)
       rescue StandardError => e
         default_logger = SimpleLogger.new
-        error_msg = e.class == InvalidDatafileVersionError ? e.message : InvalidInputError.new('datafile').message
-        error_to_handle = e.class == InvalidDatafileVersionError ? InvalidDatafileVersionError : InvalidInputError
+        error_to_handle = e.class == InvalidDatafileVersionError ? e : InvalidInputError.new('datafile')
+        error_msg = error_to_handle.message
+
         default_logger.log(Logger::ERROR, error_msg)
         error_handler.handle_error error_to_handle
         return nil

data/lib/optimizely/config/proxy_config.rb

@@ -0,0 +1,34 @@
+# 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.
+#
+#
+
+module Optimizely
+  class ProxyConfig
+    attr_reader :host, :port, :username, :password
+
+    def initialize(host, port = nil, username = nil, password = nil)
+      # host - DNS name or IP address of proxy
+      # port - port to use to acess the proxy
+      # username - username if authorization is required
+      # password - password if authorization is required
+      @host = host
+      @port = port
+      @username = username
+      @password = password
+    end
+  end
+end

data/lib/optimizely/config_manager/async_scheduler.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.
@@ -19,13 +19,14 @@ module Optimizely
   class AsyncScheduler
     attr_reader :running
 
-    def initialize(callback, interval, auto_update, logger = nil)
+    def initialize(callback, interval, auto_update, logger = nil, error_handler = nil)
       # Sets up AsyncScheduler to execute a callback periodically.
       #
       # callback - Main function to be executed periodically.
       # interval - How many seconds to wait between executions.
       # auto_update - boolean indicates to run infinitely or only once.
       # logger - Optional Provides a logger instance.
+      # error_handler - Optional Provides a handle_error method to handle exceptions.
 
       @callback = callback
       @interval = interval
@@ -33,6 +34,7 @@ module Optimizely
       @running = false
       @thread = nil
       @logger = logger || NoOpLogger.new
+      @error_handler = error_handler || NoOpErrorHandler.new
     end
 
     def start!
@@ -54,6 +56,7 @@ module Optimizely
           Logger::ERROR,
           "Couldn't create a new thread for async scheduler. #{e.message}"
         )
+        @error_handler.handle_error(e)
       end
     end
 
@@ -80,6 +83,7 @@ module Optimizely
             Logger::ERROR,
             "Something went wrong when executing passed callback. #{e.message}"
           )
+          @error_handler.handle_error(e)
           stop!
         end
         break unless @auto_update

data/lib/optimizely/config_manager/http_project_config_manager.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.
@@ -19,18 +19,21 @@ require_relative '../config/datafile_project_config'
 require_relative '../error_handler'
 require_relative '../exceptions'
 require_relative '../helpers/constants'
+require_relative '../helpers/http_utils'
 require_relative '../logger'
 require_relative '../notification_center'
 require_relative '../project_config'
+require_relative '../optimizely_config'
 require_relative 'project_config_manager'
 require_relative 'async_scheduler'
-require 'httparty'
+
 require 'json'
+
 module Optimizely
   class HTTPProjectConfigManager < ProjectConfigManager
     # Config manager that polls for the datafile and updated ProjectConfig based on an update interval.
 
-    attr_reader :stopped
+    attr_reader :stopped, :optimizely_config
 
     # Initialize config manager. One of sdk_key or url has to be set to be able to use.
     #
@@ -48,6 +51,8 @@ module Optimizely
     # error_handler - Provides a handle_error method to handle exceptions.
     # skip_json_validation - Optional boolean param which allows skipping JSON schema
     #                       validation upon object invocation. By default JSON schema validation will be performed.
+    # datafile_access_token - access token used to fetch private datafiles
+    # proxy_config - Optional proxy config instancea to configure making web requests through a proxy server.
     def initialize(
       sdk_key: nil,
       url: nil,
@@ -60,10 +65,13 @@ module Optimizely
       logger: nil,
       error_handler: nil,
       skip_json_validation: false,
-      notification_center: nil
+      notification_center: nil,
+      datafile_access_token: nil,
+      proxy_config: nil
     )
       @logger = logger || NoOpLogger.new
       @error_handler = error_handler || NoOpErrorHandler.new
+      @access_token = datafile_access_token
       @datafile_url = get_datafile_url(sdk_key, url, url_template)
       @polling_interval = nil
       polling_interval(polling_interval)
@@ -73,12 +81,14 @@ module Optimizely
       @skip_json_validation = skip_json_validation
       @notification_center = notification_center.is_a?(Optimizely::NotificationCenter) ? notification_center : NotificationCenter.new(@logger, @error_handler)
       @config = datafile.nil? ? nil : DatafileProjectConfig.create(datafile, @logger, @error_handler, @skip_json_validation)
+      @optimizely_config = @config.nil? ? nil : OptimizelyConfig.new(@config).config
       @mutex = Mutex.new
       @resource = ConditionVariable.new
       @async_scheduler = AsyncScheduler.new(method(:fetch_datafile_config), @polling_interval, auto_update, @logger)
       # Start async scheduler in the end to avoid race condition where scheduler executes
       # callback which makes use of variables not yet initialized by the main thread.
       @async_scheduler.start! if start_by_default == true
+      @proxy_config = proxy_config
       @stopped = false
     end
 
@@ -141,21 +151,20 @@ module Optimizely
     end
 
     def request_config
-      @logger.log(
-        Logger::DEBUG,
-        "Fetching datafile from #{@datafile_url}"
-      )
-      begin
-        headers = {
-          'Content-Type' => 'application/json'
-        }
+      @logger.log(Logger::DEBUG, "Fetching datafile from #{@datafile_url}")
+      headers = {}
+      headers['Content-Type'] = 'application/json'
+      headers['If-Modified-Since'] = @last_modified if @last_modified
+      headers['Authorization'] = "Bearer #{@access_token}" unless @access_token.nil?
 
-        headers[Helpers::Constants::HTTP_HEADERS['LAST_MODIFIED']] = @last_modified if @last_modified
+      # Cleaning headers before logging to avoid exposing authorization token
+      cleansed_headers = {}
+      headers.each { |key, value| cleansed_headers[key] = key == 'Authorization' ? '********' : value }
+      @logger.log(Logger::DEBUG, "Datafile request headers: #{cleansed_headers}")
 
-        response = HTTParty.get(
-          @datafile_url,
-          headers: headers,
-          timeout: Helpers::Constants::CONFIG_MANAGER['REQUEST_TIMEOUT']
+      begin
+        response = Helpers::HttpUtils.make_request(
+          @datafile_url, :get, nil, headers, Helpers::Constants::CONFIG_MANAGER['REQUEST_TIMEOUT'], @proxy_config
         )
       rescue StandardError => e
         @logger.log(
@@ -165,6 +174,9 @@ module Optimizely
         return nil
       end
 
+      response_code = response.code.to_i
+      @logger.log(Logger::DEBUG, "Datafile response status code #{response_code}")
+
       # Leave datafile and config unchanged if it has not been modified.
       if response.code == '304'
         @logger.log(
@@ -174,9 +186,14 @@ module Optimizely
         return
       end
 
-      @last_modified = response[Helpers::Constants::HTTP_HEADERS['LAST_MODIFIED']]
-
-      config = DatafileProjectConfig.create(response.body, @logger, @error_handler, @skip_json_validation) if response.body
+      if response_code >= 200 && response_code < 400
+        @logger.log(Logger::DEBUG, 'Successfully fetched datafile, generating Project config')
+        config = DatafileProjectConfig.create(response.body, @logger, @error_handler, @skip_json_validation)
+        @last_modified = response[Helpers::Constants::HTTP_HEADERS['LAST_MODIFIED']]
+        @logger.log(Logger::DEBUG, "Saved last modified header value from response: #{@last_modified}.")
+      else
+        @logger.log(Logger::DEBUG, "Datafile fetch failed, status: #{response.code}, message: #{response.message}")
+      end
 
       config
     end
@@ -192,6 +209,7 @@ module Optimizely
       end
 
       @config = config
+      @optimizely_config = OptimizelyConfig.new(config).config
 
       @notification_center.send_notifications(NotificationCenter::NOTIFICATION_TYPES[:OPTIMIZELY_CONFIG_UPDATE])
 
@@ -281,17 +299,19 @@ module Optimizely
       #               SDK key to determine URL from which to fetch the datafile.
       # Returns String representing URL to fetch datafile from.
       if sdk_key.nil? && url.nil?
-        @logger.log(Logger::ERROR, 'Must provide at least one of sdk_key or url.')
-        @error_handler.handle_error(InvalidInputsError)
+        error_msg = 'Must provide at least one of sdk_key or url.'
+        @logger.log(Logger::ERROR, error_msg)
+        @error_handler.handle_error(InvalidInputsError.new(error_msg))
       end
 
       unless url
-        url_template ||= Helpers::Constants::CONFIG_MANAGER['DATAFILE_URL_TEMPLATE']
+        url_template ||= @access_token.nil? ? Helpers::Constants::CONFIG_MANAGER['DATAFILE_URL_TEMPLATE'] : Helpers::Constants::CONFIG_MANAGER['AUTHENTICATED_DATAFILE_URL_TEMPLATE']
         begin
           return (url_template % sdk_key)
         rescue
-          @logger.log(Logger::ERROR, "Invalid url_template #{url_template} provided.")
-          @error_handler.handle_error(InvalidInputsError)
+          error_msg = "Invalid url_template #{url_template} provided."
+          @logger.log(Logger::ERROR, error_msg)
+          @error_handler.handle_error(InvalidInputsError.new(error_msg))
         end
       end
 

data/lib/optimizely/config_manager/static_project_config_manager.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.
@@ -17,11 +17,13 @@
 #
 
 require_relative '../config/datafile_project_config'
+require_relative '../optimizely_config'
 require_relative 'project_config_manager'
+
 module Optimizely
   class StaticProjectConfigManager < ProjectConfigManager
     # Implementation of ProjectConfigManager interface.
-    attr_reader :config
+    attr_reader :config, :optimizely_config
 
     def initialize(datafile, logger, error_handler, skip_json_validation)
       # Looks up and sets datafile and config based on response body.
@@ -38,6 +40,8 @@ module Optimizely
         error_handler,
         skip_json_validation
       )
+
+      @optimizely_config = @config.nil? ? nil : OptimizelyConfig.new(@config).config
     end
   end
 end

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(