optimizely-sdk 3.3.1 → 3.5.0

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,24 +65,31 @@ 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)
       @blocking_timeout = nil
       blocking_timeout(blocking_timeout)
       @last_modified = nil
-      @async_scheduler = AsyncScheduler.new(method(:fetch_datafile_config), @polling_interval, auto_update, @logger)
-      @async_scheduler.start! if start_by_default == true
-      @stopped = false
       @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
 
     def ready?
@@ -139,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(
@@ -163,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(
@@ -172,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
@@ -190,6 +209,7 @@ module Optimizely
       end
 
       @config = config
+      @optimizely_config = OptimizelyConfig.new(config).config
 
       @notification_center.send_notifications(NotificationCenter::NOTIFICATION_TYPES[:OPTIMIZELY_CONFIG_UPDATE])
 
@@ -279,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/event/batch_event_processor.rb

@@ -20,7 +20,7 @@ require_relative '../helpers/validator'
 module Optimizely
   class BatchEventProcessor < EventProcessor
     # BatchEventProcessor is a batched implementation of the Interface EventProcessor.
-    # Events passed to the BatchEventProcessor are immediately added to a EventQueue.
+    # Events passed to the BatchEventProcessor are immediately added to an EventQueue.
     # The BatchEventProcessor maintains a single consumer thread that pulls events off of
     # the BlockingQueue and buffers them for either a configured batch size or for a
     # maximum duration before the resulting LogEvent is sent to the NotificationCenter.
@@ -30,13 +30,14 @@ module Optimizely
     DEFAULT_BATCH_SIZE = 10
     DEFAULT_BATCH_INTERVAL = 30_000 # interval in milliseconds
     DEFAULT_QUEUE_CAPACITY = 1000
+    DEFAULT_TIMEOUT_INTERVAL = 5 # interval in seconds
 
     FLUSH_SIGNAL = 'FLUSH_SIGNAL'
     SHUTDOWN_SIGNAL = 'SHUTDOWN_SIGNAL'
 
     def initialize(
       event_queue: SizedQueue.new(DEFAULT_QUEUE_CAPACITY),
-      event_dispatcher: Optimizely::EventDispatcher.new,
+      event_dispatcher: nil,
       batch_size: DEFAULT_BATCH_SIZE,
       flush_interval: DEFAULT_BATCH_INTERVAL,
       logger: NoOpLogger.new,
@@ -44,7 +45,7 @@ module Optimizely
     )
       @event_queue = event_queue
       @logger = logger
-      @event_dispatcher = event_dispatcher
+      @event_dispatcher = event_dispatcher || EventDispatcher.new(logger: @logger)
       @batch_size = if (batch_size.is_a? Integer) && positive_number?(batch_size)
                       batch_size
                     else
@@ -58,11 +59,9 @@ module Optimizely
                           DEFAULT_BATCH_INTERVAL
                         end
       @notification_center = notification_center
-      @mutex = Mutex.new
-      @received = ConditionVariable.new
       @current_batch = []
       @started = false
-      start!
+      @stopped = false
     end
 
     def start!
@@ -71,76 +70,61 @@ module Optimizely
         return
       end
       @flushing_interval_deadline = Helpers::DateTimeUtils.create_timestamp + @flush_interval
-      @thread = Thread.new { run }
+      @logger.log(Logger::INFO, 'Starting scheduler.')
+      if @wait_mutex.nil?
+        @wait_mutex = Mutex.new
+        @resource = ConditionVariable.new
+      end
+      @thread = Thread.new { run_queue }
       @started = true
+      @stopped = false
     end
 
     def flush
-      @mutex.synchronize do
-        @event_queue << FLUSH_SIGNAL
-        @received.signal
-      end
+      @event_queue << FLUSH_SIGNAL
+      @wait_mutex.synchronize { @resource.signal }
     end
 
     def process(user_event)
       @logger.log(Logger::DEBUG, "Received userEvent: #{user_event}")
 
-      if !@started || !@thread.alive?
+      # if the processor has been explicitly stopped. Don't accept tasks
+      if @stopped
         @logger.log(Logger::WARN, 'Executor shutdown, not accepting tasks.')
         return
       end
 
-      @mutex.synchronize do
-        begin
-          @event_queue << user_event
-          @received.signal
-        rescue Exception
-          @logger.log(Logger::WARN, 'Payload not accepted by the queue.')
-          return
-        end
+      # start if the processor hasn't been started
+      start! unless @started
+
+      begin
+        @event_queue.push(user_event, true)
+        @wait_mutex.synchronize { @resource.signal }
+      rescue => e
+        @logger.log(Logger::WARN, 'Payload not accepted by the queue: ' + e.message)
+        return
       end
     end
 
     def stop!
       return unless @started
 
-      @mutex.synchronize do
-        @event_queue << SHUTDOWN_SIGNAL
-        @received.signal
-      end
-
+      @logger.log(Logger::INFO, 'Stopping scheduler.')
+      @event_queue << SHUTDOWN_SIGNAL
+      @wait_mutex.synchronize { @resource.signal }
+      @thread.join(DEFAULT_TIMEOUT_INTERVAL)
       @started = false
-      @logger.log(Logger::WARN, 'Stopping scheduler.')
-      @thread.exit
+      @stopped = true
     end
 
     private
 
-    def run
-      loop do
-        if Helpers::DateTimeUtils.create_timestamp > @flushing_interval_deadline
-          @logger.log(
-            Logger::DEBUG,
-            'Deadline exceeded flushing current batch.'
-          )
-          flush_queue!
-        end
-
-        item = nil
-
-        @mutex.synchronize do
-          @received.wait(@mutex, 0.05)
-          item = @event_queue.pop if @event_queue.length.positive?
-        end
-
-        if item.nil?
-          sleep(0.05)
-          next
-        end
-
+    def process_queue
+      while @event_queue.length.positive?
+        item = @event_queue.pop
         if item == SHUTDOWN_SIGNAL
-          @logger.log(Logger::INFO, 'Received shutdown signal.')
-          break
+          @logger.log(Logger::DEBUG, 'Received shutdown signal.')
+          return false
         end
 
         if item == FLUSH_SIGNAL
@@ -151,15 +135,35 @@ module Optimizely
 
         add_to_batch(item) if item.is_a? Optimizely::UserEvent
       end
+      true
+    end
+
+    def run_queue
+      loop do
+        if Helpers::DateTimeUtils.create_timestamp >= @flushing_interval_deadline
+          @logger.log(Logger::DEBUG, 'Deadline exceeded flushing current batch.')
+
+          break unless process_queue
+
+          flush_queue!
+          @flushing_interval_deadline = Helpers::DateTimeUtils.create_timestamp + @flush_interval
+        end
+
+        break unless process_queue
+
+        # what is the current interval to flush in seconds
+        interval = (@flushing_interval_deadline - Helpers::DateTimeUtils.create_timestamp) * 0.001
+
+        next unless interval.positive?
+
+        @wait_mutex.synchronize { @resource.wait(@wait_mutex, interval) }
+      end
     rescue SignalException
-      @logger.log(Logger::INFO, 'Interrupted while processing buffer.')
-    rescue Exception => e
+      @logger.log(Logger::ERROR, 'Interrupted while processing buffer.')
+    rescue => e
       @logger.log(Logger::ERROR, "Uncaught exception processing buffer. #{e.message}")
     ensure
-      @logger.log(
-        Logger::INFO,
-        'Exiting processing loop. Attempting to flush pending events.'
-      )
+      @logger.log(Logger::INFO, 'Exiting processing loop. Attempting to flush pending events.')
       flush_queue!
     end
 
@@ -168,6 +172,11 @@ module Optimizely
 
       log_event = Optimizely::EventFactory.create_log_event(@current_batch, @logger)
       begin
+        @logger.log(
+          Logger::INFO,
+          'Flushing Queue.'
+        )
+
         @event_dispatcher.dispatch_event(log_event)
         @notification_center&.send_notifications(
           NotificationCenter::NOTIFICATION_TYPES[:LOG_EVENT],
@@ -192,7 +201,7 @@ module Optimizely
       @current_batch << user_event
       return unless @current_batch.length >= @batch_size
 
-      @logger.log(Logger::DEBUG, 'Flushing on max batch size!')
+      @logger.log(Logger::DEBUG, 'Flushing on max batch size.')
       flush_queue!
     end
 

data/lib/optimizely/event_dispatcher.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #
-#    Copyright 2016-2017, 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.
@@ -15,7 +15,8 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 #
-require 'httparty'
+require_relative 'exceptions'
+require_relative 'helpers/http_utils'
 
 module Optimizely
   class NoOpEventDispatcher
@@ -28,26 +29,43 @@ module Optimizely
     # @api constants
     REQUEST_TIMEOUT = 10
 
+    def initialize(logger: nil, error_handler: nil, proxy_config: nil)
+      @logger = logger || NoOpLogger.new
+      @error_handler = error_handler || NoOpErrorHandler.new
+      @proxy_config = proxy_config
+    end
+
     # Dispatch the event being represented by the Event object.
     #
     # @param event - Event object
     def dispatch_event(event)
-      if event.http_verb == :get
-        begin
-          HTTParty.get(event.url, headers: event.headers, query: event.params, timeout: REQUEST_TIMEOUT)
-        rescue Timeout::Error => e
-          return e
-        end
-      elsif event.http_verb == :post
-        begin
-          HTTParty.post(event.url,
-                        body: event.params.to_json,
-                        headers: event.headers,
-                        timeout: REQUEST_TIMEOUT)
-        rescue Timeout::Error => e
-          return e
-        end
+      response = Helpers::HttpUtils.make_request(
+        event.url, event.http_verb, event.params.to_json, event.headers, REQUEST_TIMEOUT, @proxy_config
+      )
+
+      error_msg = "Event failed to dispatch with response code: #{response.code}"
+
+      case response.code.to_i
+      when 400...500
+        @logger.log(Logger::ERROR, error_msg)
+        @error_handler.handle_error(HTTPCallError.new("HTTP Client Error: #{response.code}"))
+
+      when 500...600
+        @logger.log(Logger::ERROR, error_msg)
+        @error_handler.handle_error(HTTPCallError.new("HTTP Server Error: #{response.code}"))
+      else
+        @logger.log(Logger::DEBUG, 'event successfully sent with response code ' + response.code.to_s)
       end
+    rescue Timeout::Error => e
+      @logger.log(Logger::ERROR, "Request Timed out. Error: #{e}")
+      @error_handler.handle_error(e)
+
+      # Returning Timeout error to retain existing behavior.
+      e
+    rescue StandardError => e
+      @logger.log(Logger::ERROR, "Event failed to dispatch. Error: #{e}")
+      @error_handler.handle_error(e)
+      nil
     end
   end
 end