optimizely-sdk 3.3.2 → 3.7.0

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.
@@ -40,6 +40,7 @@ module Optimizely
     Decision = Struct.new(:experiment, :variation, :source)
 
     DECISION_SOURCES = {
+      'EXPERIMENT' => 'experiment',
       'FEATURE_TEST' => 'feature-test',
       'ROLLOUT' => 'rollout'
     }.freeze
@@ -94,7 +95,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 +107,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 +136,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 +177,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 +227,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 +253,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/event/batch_event_processor.rb

@@ -31,7 +31,6 @@ module Optimizely
     DEFAULT_BATCH_INTERVAL = 30_000 # interval in milliseconds
     DEFAULT_QUEUE_CAPACITY = 1000
     DEFAULT_TIMEOUT_INTERVAL = 5 # interval in seconds
-    MAX_NIL_COUNT = 3
 
     FLUSH_SIGNAL = 'FLUSH_SIGNAL'
     SHUTDOWN_SIGNAL = 'SHUTDOWN_SIGNAL'
@@ -62,7 +61,7 @@ module Optimizely
       @notification_center = notification_center
       @current_batch = []
       @started = false
-      start!
+      @stopped = false
     end
 
     def start!
@@ -72,26 +71,37 @@ module Optimizely
       end
       @flushing_interval_deadline = Helpers::DateTimeUtils.create_timestamp + @flush_interval
       @logger.log(Logger::INFO, 'Starting scheduler.')
-      @thread = Thread.new { run }
+      if @wait_mutex.nil?
+        @wait_mutex = Mutex.new
+        @resource = ConditionVariable.new
+      end
+      @thread = Thread.new { run_queue }
       @started = true
+      @stopped = false
     end
 
     def flush
       @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
 
+      # start if the processor hasn't been started
+      start! unless @started
+
       begin
         @event_queue.push(user_event, true)
-      rescue Exception
-        @logger.log(Logger::WARN, 'Payload not accepted by the queue.')
+        @wait_mutex.synchronize { @resource.signal }
+      rescue => e
+        @logger.log(Logger::WARN, 'Payload not accepted by the queue: ' + e.message)
         return
       end
     end
@@ -101,42 +111,20 @@ module Optimizely
 
       @logger.log(Logger::INFO, 'Stopping scheduler.')
       @event_queue << SHUTDOWN_SIGNAL
+      @wait_mutex.synchronize { @resource.signal }
       @thread.join(DEFAULT_TIMEOUT_INTERVAL)
       @started = false
+      @stopped = true
     end
 
     private
 
-    def run
-      # if we receive a number of item nils that reach MAX_NIL_COUNT,
-      # then we hang on the pop via setting use_pop to false
-      @nil_count = 0
-      # hang on pop if true
-      @use_pop = false
-      loop do
-        if Helpers::DateTimeUtils.create_timestamp >= @flushing_interval_deadline
-          @logger.log(Logger::DEBUG, 'Deadline exceeded flushing current batch.')
-          flush_queue!
-          @flushing_interval_deadline = Helpers::DateTimeUtils.create_timestamp + @flush_interval
-          @use_pop = true if @nil_count > MAX_NIL_COUNT
-        end
-
-        item = @event_queue.pop if @event_queue.length.positive? || @use_pop
-
-        if item.nil?
-          # when nil count is greater than MAX_NIL_COUNT, we hang on the pop until there is an item available.
-          # this avoids to much spinning of the loop.
-          @nil_count += 1
-          next
-        end
-
-        # reset nil_count and use_pop if we have received an item.
-        @nil_count = 0
-        @use_pop = false
-
+    def process_queue
+      while @event_queue.length.positive?
+        item = @event_queue.pop
         if item == SHUTDOWN_SIGNAL
           @logger.log(Logger::DEBUG, 'Received shutdown signal.')
-          break
+          return false
         end
 
         if item == FLUSH_SIGNAL
@@ -147,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::ERROR, 'Interrupted while processing buffer.')
-    rescue Exception => e
+    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
 

data/lib/optimizely/event/entity/decision.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,19 +17,21 @@
 #
 module Optimizely
   class Decision
-    attr_reader :campaign_id, :experiment_id, :variation_id
+    attr_reader :campaign_id, :experiment_id, :variation_id, :metadata
 
-    def initialize(campaign_id:, experiment_id:, variation_id:)
+    def initialize(campaign_id:, experiment_id:, variation_id:, metadata:)
       @campaign_id = campaign_id
       @experiment_id = experiment_id
       @variation_id = variation_id
+      @metadata = metadata
     end
 
     def as_json
       {
         campaign_id: @campaign_id,
         experiment_id: @experiment_id,
-        variation_id: @variation_id
+        variation_id: @variation_id,
+        metadata: @metadata
       }
     end
   end

data/lib/optimizely/event/entity/impression_event.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,7 +19,7 @@ require_relative 'user_event'
 require 'optimizely/helpers/date_time_utils'
 module Optimizely
   class ImpressionEvent < UserEvent
-    attr_reader :user_id, :experiment_layer_id, :experiment_id, :variation_id,
+    attr_reader :user_id, :experiment_layer_id, :experiment_id, :variation_id, :metadata,
                 :visitor_attributes, :bot_filtering
 
     def initialize(
@@ -28,6 +28,7 @@ module Optimizely
       experiment_layer_id:,
       experiment_id:,
       variation_id:,
+      metadata:,
       visitor_attributes:,
       bot_filtering:
     )
@@ -38,6 +39,7 @@ module Optimizely
       @experiment_layer_id = experiment_layer_id
       @experiment_id = experiment_id
       @variation_id = variation_id
+      @metadata = metadata
       @visitor_attributes = visitor_attributes
       @bot_filtering = bot_filtering
     end

data/lib/optimizely/event/event_factory.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.
@@ -101,10 +101,11 @@ module Optimizely
       private
 
       def create_impression_event_visitor(impression_event)
-        decision = Optimizely::Decision.new(
+        decision = Decision.new(
           campaign_id: impression_event.experiment_layer_id,
           experiment_id: impression_event.experiment_id,
-          variation_id: impression_event.variation_id
+          variation_id: impression_event.variation_id,
+          metadata: impression_event.metadata
         )
 
         snapshot_event = Optimizely::SnapshotEvent.new(

data/lib/optimizely/event/user_event_factory.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.
@@ -22,7 +22,7 @@ require_relative 'event_factory'
 module Optimizely
   class UserEventFactory
     # UserEventFactory builds ImpressionEvent and ConversionEvent objects from a given user_event.
-    def self.create_impression_event(project_config, experiment, variation_id, user_id, user_attributes)
+    def self.create_impression_event(project_config, experiment, variation_id, metadata, user_id, user_attributes)
       # Create impression Event to be sent to the logging endpoint.
       #
       # project_config - Instance of ProjectConfig
@@ -42,13 +42,14 @@ module Optimizely
       ).as_json
 
       visitor_attributes = Optimizely::EventFactory.build_attribute_list(user_attributes, project_config)
-      experiment_layer_id = project_config.experiment_key_map[experiment['key']]['layerId']
+      experiment_layer_id = experiment['layerId']
       Optimizely::ImpressionEvent.new(
         event_context: event_context,
         user_id: user_id,
         experiment_layer_id: experiment_layer_id,
         experiment_id: experiment['id'],
         variation_id: variation_id,
+        metadata: metadata,
         visitor_attributes: visitor_attributes,
         bot_filtering: project_config.bot_filtering
       )

data/lib/optimizely/event_dispatcher.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.
@@ -16,8 +16,7 @@
 #    limitations under the License.
 #
 require_relative 'exceptions'
-
-require 'httparty'
+require_relative 'helpers/http_utils'
 
 module Optimizely
   class NoOpEventDispatcher
@@ -30,28 +29,23 @@ module Optimizely
     # @api constants
     REQUEST_TIMEOUT = 10
 
-    def initialize(logger: nil, error_handler: nil)
+    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
-        response = HTTParty.get(event.url, headers: event.headers, query: event.params, timeout: REQUEST_TIMEOUT)
-
-      elsif event.http_verb == :post
-        response = HTTParty.post(event.url,
-                                 body: event.params.to_json,
-                                 headers: event.headers,
-                                 timeout: REQUEST_TIMEOUT)
-      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
+      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}"))