optimizely-sdk 3.1.1 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 59701c9db3bbf50b8be0a1126be80e0e870bc242
-  data.tar.gz: 44be0cbee1131b89553f49381c7e382c842a2af9
+  metadata.gz: bb7a6c83f167e9c4e5166a6a4d8d4a9d4a0da2d4
+  data.tar.gz: 0a6b87960154256a3073c319be67779a395df7e4
 SHA512:
-  metadata.gz: aaa90e6631800a4c9a31d372f1eaa1917e2f1b9dbcc0203eb36d8a5e8e1db0b68fc53fc744e4d4f759c13104cd21af9e77967303388e40f1f92d1ea02ac3ea6a
-  data.tar.gz: e71aa8c67ed0cb0fbe0da318bd08335988c535e43f9462a6448061002669f78c431724131e747dbad8ad3ebd01b9e915ea00fc7b2c623919d757ea56400d0ca2
+  metadata.gz: 1b47592ea9b7a94640a3d3d2f876eea4578b726bfc7a644a4ef2427493b510d00e7ebd7f2475cb9fca69c36167afb5691a58465ce639e863caf960e900821e8f
+  data.tar.gz: d4165dbdb6a9982d9fcd6582c34acbab71a9e41a31ec44037a8aead5462f6daad1142b97ee61ab116e5433836bd283c6356c1658885a7c06513c5246f3297091

data/lib/optimizely.rb

@@ -16,6 +16,9 @@
 #    limitations under the License.
 #
 require_relative 'optimizely/audience'
+require_relative 'optimizely/config/datafile_project_config'
+require_relative 'optimizely/config_manager/http_project_config_manager'
+require_relative 'optimizely/config_manager/static_project_config_manager'
 require_relative 'optimizely/decision_service'
 require_relative 'optimizely/error_handler'
 require_relative 'optimizely/event_builder'
@@ -27,13 +30,12 @@ require_relative 'optimizely/helpers/validator'
 require_relative 'optimizely/helpers/variable_type'
 require_relative 'optimizely/logger'
 require_relative 'optimizely/notification_center'
-require_relative 'optimizely/project_config'
 
 module Optimizely
   class Project
     attr_reader :notification_center
     # @api no-doc
-    attr_reader :is_valid, :config, :decision_service, :error_handler,
+    attr_reader :config_manager, :decision_service, :error_handler,
                 :event_builder, :event_dispatcher, :logger
 
     # Constructor for Projects.
@@ -45,38 +47,52 @@ module Optimizely
     #                 By default all exceptions will be suppressed.
     # @param user_profile_service - Optional component which provides methods to store and retreive user profiles.
     # @param skip_json_validation - Optional boolean param to skip JSON schema validation of the provided datafile.
-
-    def initialize(datafile, event_dispatcher = nil, logger = nil, error_handler = nil, skip_json_validation = false, user_profile_service = nil)
-      @is_valid = true
+    # @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 notification_center - Optional Instance of NotificationCenter.
+
+    def initialize(
+      datafile = nil,
+      event_dispatcher = nil,
+      logger = nil,
+      error_handler = nil,
+      skip_json_validation = false,
+      user_profile_service = nil,
+      sdk_key = nil,
+      config_manager = nil,
+      notification_center = nil
+    )
       @logger = logger || NoOpLogger.new
       @error_handler = error_handler || NoOpErrorHandler.new
       @event_dispatcher = event_dispatcher || EventDispatcher.new
       @user_profile_service = user_profile_service
 
       begin
-        validate_instantiation_options(datafile, skip_json_validation)
+        validate_instantiation_options
       rescue InvalidInputError => e
-        @is_valid = false
         @logger = SimpleLogger.new
         @logger.log(Logger::ERROR, e.message)
-        return
-      end
-
-      begin
-        @config = ProjectConfig.new(datafile, @logger, @error_handler)
-      rescue StandardError => e
-        @is_valid = false
-        @logger = SimpleLogger.new
-        error_msg = e.class == InvalidDatafileVersionError ? e.message : InvalidInputError.new('datafile').message
-        error_to_handle = e.class == InvalidDatafileVersionError ? InvalidDatafileVersionError : InvalidInputError
-        @logger.log(Logger::ERROR, error_msg)
-        @error_handler.handle_error error_to_handle
-        return
       end
 
-      @decision_service = DecisionService.new(@config, @user_profile_service)
-      @event_builder = EventBuilder.new(@config, @logger)
-      @notification_center = NotificationCenter.new(@logger, @error_handler)
+      @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
+                        elsif sdk_key
+                          HTTPProjectConfigManager.new(
+                            sdk_key: sdk_key,
+                            datafile: datafile,
+                            logger: @logger,
+                            error_handler: @error_handler,
+                            skip_json_validation: skip_json_validation,
+                            notification_center: @notification_center
+                          )
+                        else
+                          StaticProjectConfigManager.new(datafile, @logger, @error_handler, skip_json_validation)
+                        end
+      @decision_service = DecisionService.new(@logger, @user_profile_service)
+      @event_builder = EventBuilder.new(@logger)
     end
 
     # Buckets visitor and sends impression event to Optimizely.
@@ -89,8 +105,8 @@ module Optimizely
     # @return [nil] if experiment is not Running, if user is not in experiment, or if datafile is invalid.
 
     def activate(experiment_key, user_id, attributes = nil)
-      unless @is_valid
-        @logger.log(Logger::ERROR, InvalidDatafileError.new('activate').message)
+      unless is_valid
+        @logger.log(Logger::ERROR, InvalidProjectConfigError.new('activate').message)
         return nil
       end
 
@@ -101,7 +117,9 @@ module Optimizely
         }, @logger, Logger::ERROR
       )
 
-      variation_key = get_variation(experiment_key, user_id, attributes)
+      config = project_config
+
+      variation_key = get_variation_with_config(experiment_key, user_id, attributes, config)
 
       if variation_key.nil?
         @logger.log(Logger::INFO, "Not activating user '#{user_id}'.")
@@ -109,8 +127,8 @@ module Optimizely
       end
 
       # Create and dispatch impression event
-      experiment = @config.get_experiment_from_key(experiment_key)
-      send_impression(experiment, variation_key, user_id, attributes)
+      experiment = config.get_experiment_from_key(experiment_key)
+      send_impression(config, experiment, variation_key, user_id, attributes)
 
       variation_key
     end
@@ -125,8 +143,8 @@ module Optimizely
     # @return [nil] if experiment is not Running, if user is not in experiment, or if datafile is invalid.
 
     def get_variation(experiment_key, user_id, attributes = nil)
-      unless @is_valid
-        @logger.log(Logger::ERROR, InvalidDatafileError.new('get_variation').message)
+      unless is_valid
+        @logger.log(Logger::ERROR, InvalidProjectConfigError.new('get_variation').message)
         return nil
       end
 
@@ -137,30 +155,9 @@ module Optimizely
         }, @logger, Logger::ERROR
       )
 
-      experiment = @config.get_experiment_from_key(experiment_key)
-      return nil if experiment.nil?
-
-      unless user_inputs_valid?(attributes)
-        @logger.log(Logger::INFO, "Not activating user '#{user_id}.")
-        return nil
-      end
-
-      variation_id = @decision_service.get_variation(experiment_key, user_id, attributes)
-      variation = @config.get_variation_from_id(experiment_key, variation_id) unless variation_id.nil?
-      variation_key = variation['key'] if variation
-      decision_notification_type = if @config.feature_experiment?(experiment['id'])
-                                     Helpers::Constants::DECISION_NOTIFICATION_TYPES['FEATURE_TEST']
-                                   else
-                                     Helpers::Constants::DECISION_NOTIFICATION_TYPES['AB_TEST']
-                                   end
-      @notification_center.send_notifications(
-        NotificationCenter::NOTIFICATION_TYPES[:DECISION],
-        decision_notification_type, user_id, (attributes || {}),
-        experiment_key: experiment_key,
-        variation_key: variation_key
-      )
+      config = project_config
 
-      variation_key
+      get_variation_with_config(experiment_key, user_id, attributes, config)
     end
 
     # Force a user into a variation for a given experiment.
@@ -173,7 +170,18 @@ module Optimizely
     # @return [Boolean] indicates if the set completed successfully.
 
     def set_forced_variation(experiment_key, user_id, variation_key)
-      @config.set_forced_variation(experiment_key, user_id, variation_key)
+      unless is_valid
+        @logger.log(Logger::ERROR, InvalidProjectConfigError.new('set_forced_variation').message)
+        return nil
+      end
+
+      input_values = {experiment_key: experiment_key, user_id: user_id}
+      input_values[:variation_key] = variation_key unless variation_key.nil?
+      return false unless Optimizely::Helpers::Validator.inputs_valid?(input_values, @logger, Logger::ERROR)
+
+      config = project_config
+
+      @decision_service.set_forced_variation(config, experiment_key, user_id, variation_key)
     end
 
     # Gets the forced variation for a given user and experiment.
@@ -184,8 +192,22 @@ module Optimizely
     # @return [String] The forced variation key.
 
     def get_forced_variation(experiment_key, user_id)
+      unless is_valid
+        @logger.log(Logger::ERROR, InvalidProjectConfigError.new('get_forced_variation').message)
+        return nil
+      end
+
+      return nil unless Optimizely::Helpers::Validator.inputs_valid?(
+        {
+          experiment_key: experiment_key,
+          user_id: user_id
+        }, @logger, Logger::ERROR
+      )
+
+      config = project_config
+
       forced_variation_key = nil
-      forced_variation = @config.get_forced_variation(experiment_key, user_id)
+      forced_variation = @decision_service.get_forced_variation(config, experiment_key, user_id)
       forced_variation_key = forced_variation['key'] if forced_variation
 
       forced_variation_key
@@ -199,8 +221,8 @@ module Optimizely
     # @param event_tags - Hash representing metadata associated with the event.
 
     def track(event_key, user_id, attributes = nil, event_tags = nil)
-      unless @is_valid
-        @logger.log(Logger::ERROR, InvalidDatafileError.new('track').message)
+      unless is_valid
+        @logger.log(Logger::ERROR, InvalidProjectConfigError.new('track').message)
         return nil
       end
 
@@ -213,14 +235,16 @@ module Optimizely
 
       return nil unless user_inputs_valid?(attributes, event_tags)
 
-      event = @config.get_event_from_key(event_key)
+      config = project_config
+
+      event = config.get_event_from_key(event_key)
       unless event
-        @config.logger.log(Logger::INFO, "Not tracking user '#{user_id}' for event '#{event_key}'.")
+        @logger.log(Logger::INFO, "Not tracking user '#{user_id}' for event '#{event_key}'.")
         return nil
       end
 
-      conversion_event = @event_builder.create_conversion_event(event, user_id, attributes, event_tags)
-      @config.logger.log(Logger::INFO, "Tracking event '#{event_key}' for user '#{user_id}'.")
+      conversion_event = @event_builder.create_conversion_event(config, event, user_id, attributes, event_tags)
+      @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
@@ -248,8 +272,8 @@ module Optimizely
     # @return [False] if the feature is not found.
 
     def is_feature_enabled(feature_flag_key, user_id, attributes = nil)
-      unless @is_valid
-        @logger.log(Logger::ERROR, InvalidDatafileError.new('is_feature_enabled').message)
+      unless is_valid
+        @logger.log(Logger::ERROR, InvalidProjectConfigError.new('is_feature_enabled').message)
         return false
       end
 
@@ -262,13 +286,15 @@ module Optimizely
 
       return false unless user_inputs_valid?(attributes)
 
-      feature_flag = @config.get_feature_flag_from_key(feature_flag_key)
+      config = project_config
+
+      feature_flag = config.get_feature_flag_from_key(feature_flag_key)
       unless feature_flag
         @logger.log(Logger::ERROR, "No feature flag was found for key '#{feature_flag_key}'.")
         return false
       end
 
-      decision = @decision_service.get_variation_for_feature(feature_flag, user_id, attributes)
+      decision = @decision_service.get_variation_for_feature(config, feature_flag, user_id, attributes)
 
       feature_enabled = false
       source_string = Optimizely::DecisionService::DECISION_SOURCES['ROLLOUT']
@@ -282,7 +308,7 @@ module Optimizely
             variation_key: variation['key']
           }
           # Send event if Decision came from an experiment.
-          send_impression(decision.experiment, variation['key'], user_id, attributes)
+          send_impression(config, decision.experiment, variation['key'], user_id, attributes)
         else
           @logger.log(Logger::DEBUG,
                       "The user '#{user_id}' is not being experimented on in feature '#{feature_flag_key}'.")
@@ -318,9 +344,8 @@ module Optimizely
 
     def get_enabled_features(user_id, attributes = nil)
       enabled_features = []
-
-      unless @is_valid
-        @logger.log(Logger::ERROR, InvalidDatafileError.new('get_enabled_features').message)
+      unless is_valid
+        @logger.log(Logger::ERROR, InvalidProjectConfigError.new('get_enabled_features').message)
         return enabled_features
       end
 
@@ -332,7 +357,9 @@ module Optimizely
 
       return enabled_features unless user_inputs_valid?(attributes)
 
-      @config.feature_flags.each do |feature|
+      config = project_config
+
+      config.feature_flags.each do |feature|
         enabled_features.push(feature['key']) if is_feature_enabled(
           feature['key'],
           user_id,
@@ -353,11 +380,10 @@ module Optimizely
     # @return [nil] if the feature flag or variable are not found.
 
     def get_feature_variable_string(feature_flag_key, variable_key, user_id, attributes = nil)
-      unless @is_valid
-        @logger.log(Logger::ERROR, InvalidDatafileError.new('get_feature_variable_string').message)
+      unless is_valid
+        @logger.log(Logger::ERROR, InvalidProjectConfigError.new('get_feature_variable_string').message)
         return nil
       end
-
       variable_value = get_feature_variable_for_type(
         feature_flag_key,
         variable_key,
@@ -380,8 +406,8 @@ module Optimizely
     # @return [nil] if the feature flag or variable are not found.
 
     def get_feature_variable_boolean(feature_flag_key, variable_key, user_id, attributes = nil)
-      unless @is_valid
-        @logger.log(Logger::ERROR, InvalidDatafileError.new('get_feature_variable_boolean').message)
+      unless is_valid
+        @logger.log(Logger::ERROR, InvalidProjectConfigError.new('get_feature_variable_boolean').message)
         return nil
       end
 
@@ -407,8 +433,8 @@ module Optimizely
     # @return [nil] if the feature flag or variable are not found.
 
     def get_feature_variable_double(feature_flag_key, variable_key, user_id, attributes = nil)
-      unless @is_valid
-        @logger.log(Logger::ERROR, InvalidDatafileError.new('get_feature_variable_double').message)
+      unless is_valid
+        @logger.log(Logger::ERROR, InvalidProjectConfigError.new('get_feature_variable_double').message)
         return nil
       end
 
@@ -434,10 +460,11 @@ module Optimizely
     # @return [nil] if the feature flag or variable are not found.
 
     def get_feature_variable_integer(feature_flag_key, variable_key, user_id, attributes = nil)
-      unless @is_valid
-        @logger.log(Logger::ERROR, InvalidDatafileError.new('get_feature_variable_integer').message)
+      unless is_valid
+        @logger.log(Logger::ERROR, InvalidProjectConfigError.new('get_feature_variable_integer').message)
         return nil
       end
+
       variable_value = get_feature_variable_for_type(
         feature_flag_key,
         variable_key,
@@ -449,8 +476,46 @@ module Optimizely
       variable_value
     end
 
+    def is_valid
+      config = project_config
+      config.is_a?(Optimizely::ProjectConfig)
+    end
+
     private
 
+    def get_variation_with_config(experiment_key, user_id, attributes, config)
+      # Gets variation where visitor will be bucketed.
+      #
+      # experiment_key - Experiment for which visitor variation needs to be determined.
+      # user_id - String ID for user.
+      # attributes - Hash representing user attributes.
+      # config - Instance of DatfileProjectConfig
+      #
+      # Returns [variation key] where visitor will be bucketed.
+      # Returns [nil] if experiment is not Running, if user is not in experiment, or if datafile is invalid.
+      experiment = config.get_experiment_from_key(experiment_key)
+      return nil if experiment.nil?
+
+      return nil unless user_inputs_valid?(attributes)
+
+      variation_id = @decision_service.get_variation(config, experiment_key, user_id, attributes)
+      variation = config.get_variation_from_id(experiment_key, variation_id) unless variation_id.nil?
+      variation_key = variation['key'] if variation
+      decision_notification_type = if config.feature_experiment?(experiment['id'])
+                                     Helpers::Constants::DECISION_NOTIFICATION_TYPES['FEATURE_TEST']
+                                   else
+                                     Helpers::Constants::DECISION_NOTIFICATION_TYPES['AB_TEST']
+                                   end
+      @notification_center.send_notifications(
+        NotificationCenter::NOTIFICATION_TYPES[:DECISION],
+        decision_notification_type, user_id, (attributes || {}),
+        experiment_key: experiment_key,
+        variation_key: variation_key
+      )
+
+      variation_key
+    end
+
     def get_feature_variable_for_type(feature_flag_key, variable_key, variable_type, user_id, attributes = nil)
       # Get the variable value for the given feature variable and cast it to the specified type
       # The default value is returned if the feature flag is not enabled for the user.
@@ -477,15 +542,17 @@ module Optimizely
 
       return nil unless user_inputs_valid?(attributes)
 
-      feature_flag = @config.get_feature_flag_from_key(feature_flag_key)
+      config = project_config
+
+      feature_flag = config.get_feature_flag_from_key(feature_flag_key)
       unless feature_flag
         @logger.log(Logger::INFO, "No feature flag was found for key '#{feature_flag_key}'.")
         return nil
       end
 
-      variable = @config.get_feature_variable(feature_flag, variable_key)
+      variable = config.get_feature_variable(feature_flag, variable_key)
 
-      # Error message logged in ProjectConfig- get_feature_flag_from_key
+      # Error message logged in DatafileProjectConfig- get_feature_flag_from_key
       return nil if variable.nil?
 
       feature_enabled = false
@@ -496,7 +563,7 @@ module Optimizely
         return nil
       else
         source_string = Optimizely::DecisionService::DECISION_SOURCES['ROLLOUT']
-        decision = @decision_service.get_variation_for_feature(feature_flag, user_id, attributes)
+        decision = @decision_service.get_variation_for_feature(config, feature_flag, user_id, attributes)
         variable_value = variable['defaultValue']
         if decision
           variation = decision['variation']
@@ -509,7 +576,7 @@ module Optimizely
           end
           feature_enabled = variation['featureEnabled']
           if feature_enabled == true
-            variation_variable_usages = @config.variation_id_to_variable_usage_map[variation['id']]
+            variation_variable_usages = config.variation_id_to_variable_usage_map[variation['id']]
             variable_id = variable['id']
             if variation_variable_usages&.key?(variable_id)
               variable_value = variation_variable_usages[variable_id]['value']
@@ -579,20 +646,24 @@ module Optimizely
       true
     end
 
-    def validate_instantiation_options(datafile, skip_json_validation)
-      unless skip_json_validation
-        raise InvalidInputError, 'datafile' unless Helpers::Validator.datafile_valid?(datafile)
+    def validate_instantiation_options
+      raise InvalidInputError, 'logger' unless Helpers::Validator.logger_valid?(@logger)
+
+      unless Helpers::Validator.error_handler_valid?(@error_handler)
+        @error_handler = NoOpErrorHandler.new
+        raise InvalidInputError, 'error_handler'
       end
 
-      raise InvalidInputError, 'logger' unless Helpers::Validator.logger_valid?(@logger)
-      raise InvalidInputError, 'error_handler' unless Helpers::Validator.error_handler_valid?(@error_handler)
-      raise InvalidInputError, 'event_dispatcher' unless Helpers::Validator.event_dispatcher_valid?(@event_dispatcher)
+      return if Helpers::Validator.event_dispatcher_valid?(@event_dispatcher)
+
+      @event_dispatcher = EventDispatcher.new
+      raise InvalidInputError, 'event_dispatcher'
     end
 
-    def send_impression(experiment, variation_key, user_id, attributes = nil)
+    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(experiment, variation_id, user_id, attributes)
+      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
@@ -600,11 +671,15 @@ module Optimizely
       rescue => e
         @logger.log(Logger::ERROR, "Unable to dispatch impression event. Error: #{e}")
       end
-      variation = @config.get_variation_from_id(experiment_key, variation_id)
+      variation = config.get_variation_from_id(experiment_key, variation_id)
       @notification_center.send_notifications(
         NotificationCenter::NOTIFICATION_TYPES[:ACTIVATE],
         experiment, user_id, attributes, variation, impression_event
       )
     end
+
+    def project_config
+      @config_manager.config
+    end
   end
 end