optimizely-sdk 3.4.0 → 3.8.0

data/lib/optimizely/audience.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.
@@ -24,38 +24,37 @@ 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.
+      decide_reasons = []
+      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'],
-          audience_conditions
-        )
-      )
+      message = format(logs_hash['EVALUATING_AUDIENCES_COMBINED'], logging_key, audience_conditions)
+      logger.log(Logger::DEBUG, message)
 
       # Return true if there are no audiences
       if audience_conditions.empty?
-        logger.log(
-          Logger::INFO,
-          format(
-            Helpers::Constants::AUDIENCE_EVALUATION_LOGS['AUDIENCE_EVALUATION_RESULT_COMBINED'],
-            experiment['key'],
-            'TRUE'
-          )
-        )
-        return true
+        message = format(logs_hash['AUDIENCE_EVALUATION_RESULT_COMBINED'], logging_key, 'TRUE')
+        logger.log(Logger::INFO, message)
+        decide_reasons.push(message)
+        return true, decide_reasons
       end
 
       attributes ||= {}
@@ -71,39 +70,28 @@ module Optimizely
         return nil unless audience
 
         audience_conditions = audience['conditions']
-        logger.log(
-          Logger::DEBUG,
-          format(
-            Helpers::Constants::AUDIENCE_EVALUATION_LOGS['EVALUATING_AUDIENCE'],
-            audience_id,
-            audience_conditions
-          )
-        )
+        message = format(logs_hash['EVALUATING_AUDIENCE'], audience_id, audience_conditions)
+        logger.log(Logger::DEBUG, message)
+        decide_reasons.push(message)
 
         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
-        logger.log(
-          Logger::INFO,
-          format(Helpers::Constants::AUDIENCE_EVALUATION_LOGS['AUDIENCE_EVALUATION_RESULT'], audience_id, result_str)
-        )
+        message = format(logs_hash['AUDIENCE_EVALUATION_RESULT'], audience_id, result_str)
+        logger.log(Logger::DEBUG, message)
+        decide_reasons.push(message)
+
         result
       end
 
       eval_result = ConditionTreeEvaluator.evaluate(audience_conditions, evaluate_audience)
-
       eval_result ||= false
 
-      logger.log(
-        Logger::INFO,
-        format(
-          Helpers::Constants::AUDIENCE_EVALUATION_LOGS['AUDIENCE_EVALUATION_RESULT_COMBINED'],
-          experiment['key'],
-          eval_result.to_s.upcase
-        )
-      )
+      message = format(logs_hash['AUDIENCE_EVALUATION_RESULT_COMBINED'], logging_key, eval_result.to_s.upcase)
+      logger.log(Logger::INFO, message)
+      decide_reasons.push(message)
 
-      eval_result
+      [eval_result, decide_reasons]
     end
   end
 end

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,14 +39,17 @@ 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.
       #
       # Returns variation in which visitor with ID user_id has been placed. Nil if no variation.
-      return nil if experiment.nil?
+      return nil, [] if experiment.nil?
+
+      decide_reasons = []
 
       # 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']
@@ -54,52 +57,49 @@ module Optimizely
         group = project_config.group_id_map.fetch(group_id)
         if Helpers::Group.random_policy?(group)
           traffic_allocations = group.fetch('trafficAllocation')
-          bucketed_experiment_id = find_bucket(bucketing_id, user_id, group_id, traffic_allocations)
+          bucketed_experiment_id, find_bucket_reasons = find_bucket(bucketing_id, user_id, group_id, traffic_allocations)
+          decide_reasons.push(*find_bucket_reasons)
+
           # return if the user is not bucketed into any experiment
           unless bucketed_experiment_id
-            @logger.log(Logger::INFO, "User '#{user_id}' is in no experiment.")
-            return nil
+            message = "User '#{user_id}' is in no experiment."
+            @logger.log(Logger::INFO, message)
+            decide_reasons.push(message)
+            return nil, decide_reasons
           end
 
           # return if the user is bucketed into a different experiment than the one specified
           if bucketed_experiment_id != experiment_id
-            @logger.log(
-              Logger::INFO,
-              "User '#{user_id}' is not in experiment '#{experiment_key}' of group #{group_id}."
-            )
-            return nil
+            message = "User '#{user_id}' is not in experiment '#{experiment_key}' of group #{group_id}."
+            @logger.log(Logger::INFO, message)
+            decide_reasons.push(message)
+            return nil, decide_reasons
           end
 
           # continue bucketing if the user is bucketed into the experiment specified
-          @logger.log(
-            Logger::INFO,
-            "User '#{user_id}' is in experiment '#{experiment_key}' of group #{group_id}."
-          )
+          message = "User '#{user_id}' is in experiment '#{experiment_key}' of group #{group_id}."
+          @logger.log(Logger::INFO, message)
+          decide_reasons.push(message)
         end
       end
 
       traffic_allocations = experiment['trafficAllocation']
-      variation_id = find_bucket(bucketing_id, user_id, experiment_id, traffic_allocations)
+      variation_id, find_bucket_reasons = find_bucket(bucketing_id, user_id, experiment_id, traffic_allocations)
+      decide_reasons.push(*find_bucket_reasons)
+
       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
+        return variation, decide_reasons
       end
 
       # Handle the case when the traffic range is empty due to sticky bucketing
       if variation_id == ''
-        @logger.log(
-          Logger::DEBUG,
-          'Bucketed into an empty traffic range. Returning nil.'
-        )
+        message = 'Bucketed into an empty traffic range. Returning nil.'
+        @logger.log(Logger::DEBUG, message)
+        decide_reasons.push(message)
       end
 
-      @logger.log(Logger::INFO, "User '#{user_id}' is in no variation.")
-      nil
+      [nil, decide_reasons]
     end
 
     def find_bucket(bucketing_id, user_id, parent_id, traffic_allocations)
@@ -110,21 +110,24 @@ module Optimizely
       # parent_id - String entity ID to use for bucketing ID
       # traffic_allocations - Array of traffic allocations
       #
-      # Returns entity ID corresponding to the provided bucket value or nil if no match is found.
+      # Returns and array of two values where first value is the entity ID corresponding to the provided bucket value
+      # or nil if no match is found. The second value contains the array of reasons stating how the deicision was taken
+      decide_reasons = []
       bucketing_key = format(BUCKETING_ID_TEMPLATE, bucketing_id: bucketing_id, entity_id: parent_id)
       bucket_value = generate_bucket_value(bucketing_key)
-      @logger.log(Logger::DEBUG, "Assigned bucket #{bucket_value} to user '#{user_id}' "\
-                         "with bucketing ID: '#{bucketing_id}'.")
+
+      message = "Assigned bucket #{bucket_value} to user '#{user_id}' with bucketing ID: '#{bucketing_id}'."
+      @logger.log(Logger::DEBUG, message)
 
       traffic_allocations.each do |traffic_allocation|
         current_end_of_range = traffic_allocation['endOfRange']
         if bucket_value < current_end_of_range
           entity_id = traffic_allocation['entityId']
-          return entity_id
+          return entity_id, decide_reasons
         end
       end
 
-      nil
+      [nil, decide_reasons]
     end
 
     private

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

@@ -19,14 +19,16 @@ 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.
@@ -49,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,
@@ -61,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)
@@ -81,6 +88,7 @@ module Optimizely
       # 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
 
@@ -143,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(
@@ -167,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(
@@ -176,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
@@ -284,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