optimizely-sdk 3.2.0 → 3.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bb7a6c83f167e9c4e5166a6a4d8d4a9d4a0da2d4
-  data.tar.gz: 0a6b87960154256a3073c319be67779a395df7e4
+  metadata.gz: b6172194b87939a24b453c42267ee0431b7e86f4
+  data.tar.gz: 26fabaaa1ff0a7d6ea4aa2d6728b75dbe85d646c
 SHA512:
-  metadata.gz: 1b47592ea9b7a94640a3d3d2f876eea4578b726bfc7a644a4ef2427493b510d00e7ebd7f2475cb9fca69c36167afb5691a58465ce639e863caf960e900821e8f
-  data.tar.gz: d4165dbdb6a9982d9fcd6582c34acbab71a9e41a31ec44037a8aead5462f6daad1142b97ee61ab116e5433836bd283c6356c1658885a7c06513c5246f3297091
+  metadata.gz: e7deb33a0386fa18352dc926a9920cd1a7a56373dfb5e7f1a03f1161013b867add78d13cdf051d3cde9762710bb9ee9adbc77669dee0a08ca9b9bda461df8f5e
+  data.tar.gz: 2c17a1ca3bef13c7c44e53c1a50ff32991f7abd966d7b9cd7af57708f395ea95a69ecab24090af936488ea21c8810b83c826ba0c01481058bd61a6f5da3d7fbd

data/lib/optimizely.rb

@@ -22,6 +22,9 @@ require_relative 'optimizely/config_manager/static_project_config_manager'
 require_relative 'optimizely/decision_service'
 require_relative 'optimizely/error_handler'
 require_relative 'optimizely/event_builder'
+require_relative 'optimizely/event/forwarding_event_processor'
+require_relative 'optimizely/event/event_factory'
+require_relative 'optimizely/event/user_event_factory'
 require_relative 'optimizely/event_dispatcher'
 require_relative 'optimizely/exceptions'
 require_relative 'optimizely/helpers/constants'
@@ -35,8 +38,8 @@ module Optimizely
   class Project
     attr_reader :notification_center
     # @api no-doc
-    attr_reader :config_manager, :decision_service, :error_handler,
-                :event_builder, :event_dispatcher, :logger
+    attr_reader :config_manager, :decision_service, :error_handler, :event_dispatcher,
+                :event_processor, :logger, :stopped
 
     # Constructor for Projects.
     #
@@ -49,8 +52,9 @@ module Optimizely
     # @param skip_json_validation - Optional boolean param to skip JSON schema validation of the provided datafile.
     # @params sdk_key - Optional string uniquely identifying the datafile corresponding to project and environment combination.
     #                   Must provide at least one of datafile or sdk_key.
-    # @param config_manager - Optional Responds to get_config.
+    # @param config_manager - Optional Responds to 'config' method.
     # @param notification_center - Optional Instance of NotificationCenter.
+    # @param event_processor - Optional Responds to process.
 
     def initialize(
       datafile = nil,
@@ -61,7 +65,8 @@ module Optimizely
       user_profile_service = nil,
       sdk_key = nil,
       config_manager = nil,
-      notification_center = nil
+      notification_center = nil,
+      event_processor = nil
     )
       @logger = logger || NoOpLogger.new
       @error_handler = error_handler || NoOpErrorHandler.new
@@ -77,7 +82,7 @@ module Optimizely
 
       @notification_center = notification_center.is_a?(Optimizely::NotificationCenter) ? notification_center : NotificationCenter.new(@logger, @error_handler)
 
-      @config_manager = if config_manager.respond_to?(:get_config)
+      @config_manager = if config_manager.respond_to?(:config)
                           config_manager
                         elsif sdk_key
                           HTTPProjectConfigManager.new(
@@ -91,8 +96,14 @@ module Optimizely
                         else
                           StaticProjectConfigManager.new(datafile, @logger, @error_handler, skip_json_validation)
                         end
+
       @decision_service = DecisionService.new(@logger, @user_profile_service)
-      @event_builder = EventBuilder.new(@logger)
+
+      @event_processor = if event_processor.respond_to?(:process)
+                           event_processor
+                         else
+                           ForwardingEventProcessor.new(@event_dispatcher, @logger, @notification_center)
+                         end
     end
 
     # Buckets visitor and sends impression event to Optimizely.
@@ -243,20 +254,17 @@ module Optimizely
         return nil
       end
 
-      conversion_event = @event_builder.create_conversion_event(config, event, user_id, attributes, event_tags)
+      user_event = UserEventFactory.create_conversion_event(config, event, user_id, attributes, event_tags)
+      @event_processor.process(user_event)
       @logger.log(Logger::INFO, "Tracking event '#{event_key}' for user '#{user_id}'.")
-      @logger.log(Logger::INFO,
-                  "Dispatching conversion event to URL #{conversion_event.url} with params #{conversion_event.params}.")
-      begin
-        @event_dispatcher.dispatch_event(conversion_event)
-      rescue => e
-        @logger.log(Logger::ERROR, "Unable to dispatch conversion event. Error: #{e}")
-      end
 
-      @notification_center.send_notifications(
-        NotificationCenter::NOTIFICATION_TYPES[:TRACK],
-        event_key, user_id, attributes, event_tags, conversion_event
-      )
+      if @notification_center.notification_count(NotificationCenter::NOTIFICATION_TYPES[:TRACK]).positive?
+        log_event = EventFactory.create_log_event(user_event, @logger)
+        @notification_center.send_notifications(
+          NotificationCenter::NOTIFICATION_TYPES[:TRACK],
+          event_key, user_id, attributes, event_tags, log_event
+        )
+      end
       nil
     end
 
@@ -369,6 +377,32 @@ module Optimizely
       enabled_features
     end
 
+    # Get the value of the specified variable in the feature flag.
+    #
+    # @param feature_flag_key - String key of feature flag the variable belongs to
+    # @param variable_key - String key of variable for which we are getting the value
+    # @param user_id - String user ID
+    # @param attributes - Hash representing visitor attributes and values which need to be recorded.
+    #
+    # @return [*] the type-casted variable value.
+    # @return [nil] if the feature flag or variable are not found.
+
+    def get_feature_variable(feature_flag_key, variable_key, user_id, attributes = nil)
+      unless is_valid
+        @logger.log(Logger::ERROR, InvalidProjectConfigError.new('get_feature_variable').message)
+        return nil
+      end
+      variable_value = get_feature_variable_for_type(
+        feature_flag_key,
+        variable_key,
+        nil,
+        user_id,
+        attributes
+      )
+
+      variable_value
+    end
+
     # Get the String value of the specified variable in the feature flag.
     #
     # @param feature_flag_key - String key of feature flag the variable belongs to
@@ -481,6 +515,14 @@ module Optimizely
       config.is_a?(Optimizely::ProjectConfig)
     end
 
+    def close
+      return if @stopped
+
+      @stopped = true
+      @config_manager.stop! if @config_manager.respond_to?(:stop!)
+      @event_processor.stop! if @event_processor.respond_to?(:stop!)
+    end
+
     private
 
     def get_variation_with_config(experiment_key, user_id, attributes, config)
@@ -556,6 +598,9 @@ module Optimizely
       return nil if variable.nil?
 
       feature_enabled = false
+
+      # If variable_type is nil, set it equal to variable['type']
+      variable_type ||= variable['type']
       # Returns nil if type differs
       if variable['type'] != variable_type
         @logger.log(Logger::WARN,
@@ -663,18 +708,16 @@ module Optimizely
     def send_impression(config, experiment, variation_key, user_id, attributes = nil)
       experiment_key = experiment['key']
       variation_id = config.get_variation_id_from_key(experiment_key, variation_key)
-      impression_event = @event_builder.create_impression_event(config, experiment, variation_id, user_id, attributes)
-      @logger.log(Logger::INFO,
-                  "Dispatching impression event to URL #{impression_event.url} with params #{impression_event.params}.")
-      begin
-        @event_dispatcher.dispatch_event(impression_event)
-      rescue => e
-        @logger.log(Logger::ERROR, "Unable to dispatch impression event. Error: #{e}")
-      end
+      user_event = UserEventFactory.create_impression_event(config, experiment, variation_id, user_id, attributes)
+      @event_processor.process(user_event)
+      return unless @notification_center.notification_count(NotificationCenter::NOTIFICATION_TYPES[:ACTIVATE]).positive?
+
+      @logger.log(Logger::INFO, "Activating user '#{user_id}' in experiment '#{experiment_key}'.")
       variation = config.get_variation_from_id(experiment_key, variation_id)
+      log_event = EventFactory.create_log_event(user_event, @logger)
       @notification_center.send_notifications(
         NotificationCenter::NOTIFICATION_TYPES[:ACTIVATE],
-        experiment, user_id, attributes, variation, impression_event
+        experiment, user_id, attributes, variation, log_event
       )
     end
 

data/lib/optimizely/config_manager/http_project_config_manager.rb

@@ -30,7 +30,7 @@ module Optimizely
   class HTTPProjectConfigManager < ProjectConfigManager
     # Config manager that polls for the datafile and updated ProjectConfig based on an update interval.
 
-    attr_reader :config
+    attr_reader :stopped
 
     # Initialize config manager. One of sdk_key or url has to be set to be able to use.
     #
@@ -38,9 +38,9 @@ module Optimizely
     # datafile: Optional JSON string representing the project.
     # polling_interval - Optional floating point number representing time interval in seconds
     #                  at which to request datafile and set ProjectConfig.
-    # blocking_timeout -
-    # auto_update -
-    # start_by_default -
+    # blocking_timeout - Optional Time in seconds to block the config call until config object has been initialized.
+    # auto_update - Boolean indicates to run infinitely or only once.
+    # start_by_default - Boolean indicates to start by default AsyncScheduler.
     # url - Optional string representing URL from where to fetch the datafile. If set it supersedes the sdk_key.
     # url_template - Optional string template which in conjunction with sdk_key
     #               determines URL from where to fetch the datafile.
@@ -72,6 +72,7 @@ module Optimizely
       @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)
@@ -84,20 +85,36 @@ module Optimizely
     end
 
     def start!
+      if @stopped
+        @logger.log(Logger::WARN, 'Not starting. Already stopped.')
+        return
+      end
+
       @async_scheduler.start!
+      @stopped = false
     end
 
     def stop!
+      if @stopped
+        @logger.log(Logger::WARN, 'Not pausing. Manager has not been started.')
+        return
+      end
+
       @async_scheduler.stop!
+      @config = nil
+      @stopped = true
     end
 
-    def get_config
+    def config
       # Get Project Config.
 
+      # if stopped is true, then simply return @config.
       # If the background datafile polling thread is running. and config has been initalized,
-      # we simply return config.
+      # we simply return @config.
       # If it is not, we wait and block maximum for @blocking_timeout.
       # If thread is not running, we fetch the datafile and update config.
+      return @config if @stopped
+
       if @async_scheduler.running
         return @config if ready?
 
@@ -196,7 +213,7 @@ module Optimizely
         return
       end
 
-      unless polling_interval.is_a? Integer
+      unless polling_interval.is_a? Numeric
         @logger.log(
           Logger::ERROR,
           "Polling interval '#{polling_interval}' has invalid type. Defaulting to #{Helpers::Constants::CONFIG_MANAGER['DEFAULT_UPDATE_INTERVAL']} seconds."
@@ -205,7 +222,7 @@ module Optimizely
         return
       end
 
-      unless polling_interval.between?(Helpers::Constants::CONFIG_MANAGER['MIN_SECONDS_LIMIT'], Helpers::Constants::CONFIG_MANAGER['MAX_SECONDS_LIMIT'])
+      unless polling_interval.positive? && polling_interval <= Helpers::Constants::CONFIG_MANAGER['MAX_SECONDS_LIMIT']
         @logger.log(
           Logger::DEBUG,
           "Polling interval '#{polling_interval}' has invalid range. Defaulting to #{Helpers::Constants::CONFIG_MANAGER['DEFAULT_UPDATE_INTERVAL']} seconds."
@@ -218,9 +235,9 @@ module Optimizely
     end
 
     def blocking_timeout(blocking_timeout)
-      # Sets time in seconds to block the get_config call until config has been initialized.
+      # Sets time in seconds to block the config call until config has been initialized.
       #
-      # blocking_timeout - Time in seconds after which to update datafile.
+      # blocking_timeout - Time in seconds to block the config call.
 
       # If valid set given timeout, default blocking_timeout otherwise.
 
@@ -229,7 +246,7 @@ module Optimizely
           Logger::DEBUG,
           "Blocking timeout is not provided. Defaulting to #{Helpers::Constants::CONFIG_MANAGER['DEFAULT_BLOCKING_TIMEOUT']} seconds."
         )
-        @polling_interval = Helpers::Constants::CONFIG_MANAGER['DEFAULT_BLOCKING_TIMEOUT']
+        @blocking_timeout = Helpers::Constants::CONFIG_MANAGER['DEFAULT_BLOCKING_TIMEOUT']
         return
       end
 
@@ -238,7 +255,7 @@ module Optimizely
           Logger::ERROR,
           "Blocking timeout '#{blocking_timeout}' has invalid type. Defaulting to #{Helpers::Constants::CONFIG_MANAGER['DEFAULT_BLOCKING_TIMEOUT']} seconds."
         )
-        @polling_interval = Helpers::Constants::CONFIG_MANAGER['DEFAULT_BLOCKING_TIMEOUT']
+        @blocking_timeout = Helpers::Constants::CONFIG_MANAGER['DEFAULT_BLOCKING_TIMEOUT']
         return
       end
 
@@ -247,7 +264,7 @@ module Optimizely
           Logger::DEBUG,
           "Blocking timeout '#{blocking_timeout}' has invalid range. Defaulting to #{Helpers::Constants::CONFIG_MANAGER['DEFAULT_BLOCKING_TIMEOUT']} seconds."
         )
-        @polling_interval = Helpers::Constants::CONFIG_MANAGER['DEFAULT_BLOCKING_TIMEOUT']
+        @blocking_timeout = Helpers::Constants::CONFIG_MANAGER['DEFAULT_BLOCKING_TIMEOUT']
         return
       end
 

data/lib/optimizely/event/batch_event_processor.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+#
+#    Copyright 2019, Optimizely and contributors
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+require_relative 'event_processor'
+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.
+    # 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.
+
+    attr_reader :event_queue, :event_dispatcher, :current_batch, :started, :batch_size, :flush_interval
+
+    DEFAULT_BATCH_SIZE = 10
+    DEFAULT_BATCH_INTERVAL = 30_000 # interval in milliseconds
+    DEFAULT_QUEUE_CAPACITY = 1000
+
+    FLUSH_SIGNAL = 'FLUSH_SIGNAL'
+    SHUTDOWN_SIGNAL = 'SHUTDOWN_SIGNAL'
+
+    def initialize(
+      event_queue: SizedQueue.new(DEFAULT_QUEUE_CAPACITY),
+      event_dispatcher: Optimizely::EventDispatcher.new,
+      batch_size: DEFAULT_BATCH_SIZE,
+      flush_interval: DEFAULT_BATCH_INTERVAL,
+      logger: NoOpLogger.new,
+      notification_center: nil
+    )
+      @event_queue = event_queue
+      @logger = logger
+      @event_dispatcher = event_dispatcher
+      @batch_size = if (batch_size.is_a? Integer) && positive_number?(batch_size)
+                      batch_size
+                    else
+                      @logger.log(Logger::DEBUG, "Setting to default batch_size: #{DEFAULT_BATCH_SIZE}.")
+                      DEFAULT_BATCH_SIZE
+                    end
+      @flush_interval = if positive_number?(flush_interval)
+                          flush_interval
+                        else
+                          @logger.log(Logger::DEBUG, "Setting to default flush_interval: #{DEFAULT_BATCH_INTERVAL} ms.")
+                          DEFAULT_BATCH_INTERVAL
+                        end
+      @notification_center = notification_center
+      @mutex = Mutex.new
+      @received = ConditionVariable.new
+      @current_batch = []
+      @started = false
+      start!
+    end
+
+    def start!
+      if @started == true
+        @logger.log(Logger::WARN, 'Service already started.')
+        return
+      end
+      @flushing_interval_deadline = Helpers::DateTimeUtils.create_timestamp + @flush_interval
+      @thread = Thread.new { run }
+      @started = true
+    end
+
+    def flush
+      @mutex.synchronize do
+        @event_queue << FLUSH_SIGNAL
+        @received.signal
+      end
+    end
+
+    def process(user_event)
+      @logger.log(Logger::DEBUG, "Received userEvent: #{user_event}")
+
+      if !@started || !@thread.alive?
+        @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
+      end
+    end
+
+    def stop!
+      return unless @started
+
+      @mutex.synchronize do
+        @event_queue << SHUTDOWN_SIGNAL
+        @received.signal
+      end
+
+      @started = false
+      @logger.log(Logger::WARN, 'Stopping scheduler.')
+      @thread.exit
+    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
+
+        if item == SHUTDOWN_SIGNAL
+          @logger.log(Logger::INFO, 'Received shutdown signal.')
+          break
+        end
+
+        if item == FLUSH_SIGNAL
+          @logger.log(Logger::DEBUG, 'Received flush signal.')
+          flush_queue!
+          next
+        end
+
+        add_to_batch(item) if item.is_a? Optimizely::UserEvent
+      end
+    rescue SignalException
+      @logger.log(Logger::INFO, 'Interrupted while processing buffer.')
+    rescue Exception => e
+      @logger.log(Logger::ERROR, "Uncaught exception processing buffer. #{e.message}")
+    ensure
+      @logger.log(
+        Logger::INFO,
+        'Exiting processing loop. Attempting to flush pending events.'
+      )
+      flush_queue!
+    end
+
+    def flush_queue!
+      return if @current_batch.empty?
+
+      log_event = Optimizely::EventFactory.create_log_event(@current_batch, @logger)
+      begin
+        @event_dispatcher.dispatch_event(log_event)
+        @notification_center&.send_notifications(
+          NotificationCenter::NOTIFICATION_TYPES[:LOG_EVENT],
+          log_event
+        )
+      rescue StandardError => e
+        @logger.log(Logger::ERROR, "Error dispatching event: #{log_event} #{e.message}.")
+      end
+      @current_batch = []
+    end
+
+    def add_to_batch(user_event)
+      if should_split?(user_event)
+        flush_queue!
+        @current_batch = []
+      end
+
+      # Reset the deadline if starting a new batch.
+      @flushing_interval_deadline = (Helpers::DateTimeUtils.create_timestamp + @flush_interval) if @current_batch.empty?
+
+      @logger.log(Logger::DEBUG, "Adding user event: #{user_event} to batch.")
+      @current_batch << user_event
+      return unless @current_batch.length >= @batch_size
+
+      @logger.log(Logger::DEBUG, 'Flushing on max batch size!')
+      flush_queue!
+    end
+
+    def should_split?(user_event)
+      return false if @current_batch.empty?
+
+      current_context = @current_batch.last.event_context
+      new_context = user_event.event_context
+
+      # Revisions should match
+      unless current_context[:revision] == new_context[:revision]
+        @logger.log(Logger::DEBUG, 'Revisions mismatched: Flushing current batch.')
+        return true
+      end
+
+      # Projects should match
+      unless current_context[:project_id] == new_context[:project_id]
+        @logger.log(Logger::DEBUG, 'Project Ids mismatched: Flushing current batch.')
+        return true
+      end
+      false
+    end
+
+    def positive_number?(value)
+      # Returns true if the given value is positive finite number.
+      #   false otherwise.
+      Helpers::Validator.finite_number?(value) && value.positive?
+    end
+  end
+end