optimizely-sdk 3.3.2 → 3.7.0

data/lib/optimizely/exceptions.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #
-#    Copyright 2016-2019, Optimizely and contributors
+#    Copyright 2016-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.
@@ -81,14 +81,6 @@ module Optimizely
     end
   end
 
-  class InvalidDatafileError < Error
-    # Raised when a public method fails due to an invalid datafile
-
-    def initialize(aborted_method)
-      super("Provided datafile is in an invalid format. Aborting #{aborted_method}.")
-    end
-  end
-
   class InvalidDatafileVersionError < Error
     # Raised when a datafile with an unsupported version is provided
 
@@ -128,4 +120,20 @@ module Optimizely
       super("Optimizely instance is not valid. Failing '#{aborted_method}'.")
     end
   end
+
+  class InvalidAttributeType < Error
+    # Raised when an attribute is not provided in expected type.
+
+    def initialize(msg = 'Provided attribute value is not in the expected data type.')
+      super
+    end
+  end
+
+  class InvalidSemanticVersion < Error
+    # Raised when an invalid value is provided as semantic version.
+
+    def initialize(msg = 'Provided semantic version is invalid.')
+      super
+    end
+  end
 end

data/lib/optimizely/helpers/constants.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #
-#    Copyright 2016-2019, Optimizely and contributors
+#    Copyright 2016-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.
@@ -304,7 +304,8 @@ module Optimizely
         'BOOLEAN' => 'boolean',
         'DOUBLE' => 'double',
         'INTEGER' => 'integer',
-        'STRING' => 'string'
+        'STRING' => 'string',
+        'JSON' => 'json'
       }.freeze
 
       INPUT_VARIABLES = {
@@ -334,11 +335,11 @@ module Optimizely
 
       AUDIENCE_EVALUATION_LOGS = {
         'AUDIENCE_EVALUATION_RESULT' => "Audience '%s' evaluated to %s.",
-        'AUDIENCE_EVALUATION_RESULT_COMBINED' => "Audiences for experiment '%s' collectively evaluated to %s.",
         'EVALUATING_AUDIENCE' => "Starting to evaluate audience '%s' with conditions: %s.",
-        'EVALUATING_AUDIENCES_COMBINED' => "Evaluating audiences for experiment '%s': %s.",
         'INFINITE_ATTRIBUTE_VALUE' => 'Audience condition %s evaluated to UNKNOWN because the number value ' \
         "for user attribute '%s' is not in the range [-2^53, +2^53].",
+        'INVALID_SEMANTIC_VERSION' => 'Audience condition %s evaluated as UNKNOWN because an invalid semantic version ' \
+        "was passed for user attribute '%s'.",
         'MISSING_ATTRIBUTE_VALUE' => 'Audience condition %s evaluated as UNKNOWN because no value ' \
         "was passed for user attribute '%s'.",
         'NULL_ATTRIBUTE_VALUE' => 'Audience condition %s evaluated to UNKNOWN because a nil value was passed ' \
@@ -353,15 +354,27 @@ module Optimizely
         'to upgrade to a newer release of the Optimizely SDK.'
       }.freeze
 
+      EXPERIMENT_AUDIENCE_EVALUATION_LOGS = {
+        'AUDIENCE_EVALUATION_RESULT_COMBINED' => "Audiences for experiment '%s' collectively evaluated to %s.",
+        'EVALUATING_AUDIENCES_COMBINED' => "Evaluating audiences for experiment '%s': %s."
+      }.merge(AUDIENCE_EVALUATION_LOGS).freeze
+
+      ROLLOUT_AUDIENCE_EVALUATION_LOGS = {
+        'AUDIENCE_EVALUATION_RESULT_COMBINED' => "Audiences for rule '%s' collectively evaluated to %s.",
+        'EVALUATING_AUDIENCES_COMBINED' => "Evaluating audiences for rule '%s': %s."
+      }.merge(AUDIENCE_EVALUATION_LOGS).freeze
+
       DECISION_NOTIFICATION_TYPES = {
         'AB_TEST' => 'ab-test',
         'FEATURE' => 'feature',
         'FEATURE_TEST' => 'feature-test',
-        'FEATURE_VARIABLE' => 'feature-variable'
+        'FEATURE_VARIABLE' => 'feature-variable',
+        'ALL_FEATURE_VARIABLES' => 'all-feature-variables'
       }.freeze
 
       CONFIG_MANAGER = {
         'DATAFILE_URL_TEMPLATE' => 'https://cdn.optimizely.com/datafiles/%s.json',
+        'AUTHENTICATED_DATAFILE_URL_TEMPLATE' => 'https://config.optimizely.com/datafiles/auth/%s.json',
         # Default time in seconds to block the 'config' method call until 'config' instance has been initialized.
         'DEFAULT_BLOCKING_TIMEOUT' => 15,
         # Default config update interval of 5 minutes

data/lib/optimizely/helpers/http_utils.rb

@@ -0,0 +1,64 @@
+# 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.
+#
+
+require 'net/http'
+
+module Optimizely
+  module Helpers
+    module HttpUtils
+      module_function
+
+      def make_request(url, http_method, request_body = nil, headers = {}, read_timeout = nil, proxy_config = nil)
+        # makes http/https GET/POST request and returns response
+        #
+        uri = URI.parse(url)
+
+        if http_method == :get
+          request = Net::HTTP::Get.new(uri.request_uri)
+        elsif http_method == :post
+          request = Net::HTTP::Post.new(uri.request_uri)
+          request.body = request_body if request_body
+        else
+          return nil
+        end
+
+        # set headers
+        headers&.each do |key, val|
+          request[key] = val
+        end
+
+        # do not try to make request with proxy unless we have at least a host
+        http_class = if proxy_config&.host
+                       Net::HTTP::Proxy(
+                         proxy_config.host,
+                         proxy_config.port,
+                         proxy_config.username,
+                         proxy_config.password
+                       )
+                     else
+                       Net::HTTP
+                     end
+
+        http = http_class.new(uri.host, uri.port)
+        http.read_timeout = read_timeout if read_timeout
+        http.use_ssl = uri.scheme == 'https'
+        http.request(request)
+      end
+    end
+  end
+end

data/lib/optimizely/helpers/variable_type.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #
-#    Copyright 2017, 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.
@@ -48,6 +48,13 @@ module Optimizely
             logger.log(Logger::ERROR, "Unable to cast variable value '#{value}' to type "\
                                       "'#{variable_type}': #{e.message}.")
           end
+        when 'json'
+          begin
+            return_value = JSON.parse(value)
+          rescue => e
+            logger.log(Logger::ERROR, "Unable to cast variable value '#{value}' to type "\
+                                      "'#{variable_type}': #{e.message}.")
+          end
         else
           # default case is string
           return_value = value

data/lib/optimizely/optimizely_config.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+#    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.
+#    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 OptimizelyConfig
+    def initialize(project_config)
+      @project_config = project_config
+    end
+
+    def config
+      experiments_map_object = experiments_map
+      features_map = get_features_map(experiments_map_object)
+      {
+        'datafile' => @project_config.datafile,
+        'experimentsMap' => experiments_map_object,
+        'featuresMap' => features_map,
+        'revision' => @project_config.revision
+      }
+    end
+
+    private
+
+    def experiments_map
+      feature_variables_map = @project_config.feature_flags.reduce({}) do |result_map, feature|
+        result_map.update(feature['id'] => feature['variables'])
+      end
+      @project_config.experiments.reduce({}) do |experiments_map, experiment|
+        experiments_map.update(
+          experiment['key'] => {
+            'id' => experiment['id'],
+            'key' => experiment['key'],
+            'variationsMap' => experiment['variations'].reduce({}) do |variations_map, variation|
+              variation_object = {
+                'id' => variation['id'],
+                'key' => variation['key'],
+                'variablesMap' => get_merged_variables_map(variation, experiment['id'], feature_variables_map)
+              }
+              variation_object['featureEnabled'] = variation['featureEnabled'] if @project_config.feature_experiment?(experiment['id'])
+              variations_map.update(variation['key'] => variation_object)
+            end
+          }
+        )
+      end
+    end
+
+    # Merges feature key and type from feature variables to variation variables.
+    def get_merged_variables_map(variation, experiment_id, feature_variables_map)
+      feature_ids = @project_config.experiment_feature_map[experiment_id]
+      return {} unless feature_ids
+
+      experiment_feature_variables = feature_variables_map[feature_ids[0]]
+      # temporary variation variables map to get values to merge.
+      temp_variables_id_map = {}
+      if variation['variables']
+        temp_variables_id_map = variation['variables'].reduce({}) do |variables_map, variable|
+          variables_map.update(
+            variable['id'] => {
+              'id' => variable['id'],
+              'value' => variable['value']
+            }
+          )
+        end
+      end
+      experiment_feature_variables.reduce({}) do |variables_map, feature_variable|
+        variation_variable = temp_variables_id_map[feature_variable['id']]
+        variable_value = variation['featureEnabled'] && variation_variable ? variation_variable['value'] : feature_variable['defaultValue']
+        variables_map.update(
+          feature_variable['key'] => {
+            'id' => feature_variable['id'],
+            'key' => feature_variable['key'],
+            'type' => feature_variable['type'],
+            'value' => variable_value
+          }
+        )
+      end
+    end
+
+    def get_features_map(all_experiments_map)
+      @project_config.feature_flags.reduce({}) do |features_map, feature|
+        features_map.update(
+          feature['key'] => {
+            'id' => feature['id'],
+            'key' => feature['key'],
+            'experimentsMap' => feature['experimentIds'].reduce({}) do |experiments_map, experiment_id|
+              experiment_key = @project_config.experiment_id_map[experiment_id]['key']
+              experiments_map.update(experiment_key => all_experiments_map[experiment_key])
+            end,
+            'variablesMap' => feature['variables'].reduce({}) do |variables, variable|
+              variables.update(
+                variable['key'] => {
+                  'id' => variable['id'],
+                  'key' => variable['key'],
+                  'type' => variable['type'],
+                  'value' => variable['defaultValue']
+                }
+              )
+            end
+          }
+        )
+      end
+    end
+  end
+end

data/lib/optimizely/optimizely_factory.rb

@@ -17,16 +17,18 @@
 #
 
 require 'optimizely'
+require 'optimizely/error_handler'
 require 'optimizely/event_dispatcher'
 require 'optimizely/event/batch_event_processor'
+require 'optimizely/logger'
+require 'optimizely/notification_center'
+
 module Optimizely
   class OptimizelyFactory
-    attr_reader :max_event_batch_size, :max_event_flush_interval
-
     # Convenience method for setting the maximum number of events contained within a batch.
     # @param batch_size Integer - Sets size of EventQueue.
     # @param logger - Optional LoggerInterface Provides a log method to log messages.
-    def self.max_event_batch_size(batch_size, logger)
+    def self.max_event_batch_size(batch_size, logger = NoOpLogger.new)
       unless batch_size.is_a? Integer
         logger.log(
           Logger::ERROR,
@@ -48,7 +50,7 @@ module Optimizely
     # Convenience method for setting the maximum time interval in milliseconds between event dispatches.
     # @param flush_interval Numeric - Time interval between event dispatches.
     # @param logger - Optional LoggerInterface Provides a log method to log messages.
-    def self.max_event_flush_interval(flush_interval, logger)
+    def self.max_event_flush_interval(flush_interval, logger = NoOpLogger.new)
       unless flush_interval.is_a? Numeric
         logger.log(
           Logger::ERROR,
@@ -67,12 +69,42 @@ module Optimizely
       @max_event_flush_interval = flush_interval
     end
 
+    # Convenience method for setting frequency at which datafile has to be polled and ProjectConfig updated.
+    #
+    # @param polling_interval Numeric - Time in seconds after which to update datafile.
+    def self.polling_interval(polling_interval)
+      @polling_interval = polling_interval
+    end
+
+    # Convenience method for setting timeout to block the config call until config has been initialized.
+    #
+    # @param blocking_timeout Numeric - Time in seconds.
+    def self.blocking_timeout(blocking_timeout)
+      @blocking_timeout = blocking_timeout
+    end
+
     # Returns a new optimizely instance.
     #
     # @params sdk_key - Required String uniquely identifying the fallback datafile corresponding to project.
     # @param fallback datafile - Optional JSON string datafile.
     def self.default_instance(sdk_key, datafile = nil)
-      Optimizely::Project.new(datafile, nil, nil, nil, nil, nil, sdk_key)
+      error_handler = NoOpErrorHandler.new
+      logger = NoOpLogger.new
+      notification_center = NotificationCenter.new(logger, error_handler)
+
+      config_manager = Optimizely::HTTPProjectConfigManager.new(
+        sdk_key: sdk_key,
+        polling_interval: @polling_interval,
+        blocking_timeout: @blocking_timeout,
+        datafile: datafile,
+        logger: logger,
+        error_handler: error_handler,
+        notification_center: notification_center
+      )
+
+      Optimizely::Project.new(
+        datafile, nil, logger, error_handler, nil, nil, sdk_key, config_manager, notification_center
+      )
     end
 
     # Returns a new optimizely instance.
@@ -108,10 +140,27 @@ module Optimizely
       config_manager = nil,
       notification_center = nil
     )
+
+      error_handler ||= NoOpErrorHandler.new
+      logger ||= NoOpLogger.new
+      notification_center = notification_center.is_a?(Optimizely::NotificationCenter) ? notification_center : NotificationCenter.new(logger, error_handler)
+
       event_processor = BatchEventProcessor.new(
         event_dispatcher: event_dispatcher || EventDispatcher.new,
         batch_size: @max_event_batch_size,
         flush_interval: @max_event_flush_interval,
+        logger: logger,
+        notification_center: notification_center
+      )
+
+      config_manager ||= Optimizely::HTTPProjectConfigManager.new(
+        sdk_key: sdk_key,
+        polling_interval: @polling_interval,
+        blocking_timeout: @blocking_timeout,
+        datafile: datafile,
+        logger: logger,
+        error_handler: error_handler,
+        skip_json_validation: skip_json_validation,
         notification_center: notification_center
       )
 

data/lib/optimizely/project_config.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-#    Copyright 2016-2019, Optimizely and contributors
+#    Copyright 2016-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.
@@ -20,6 +20,8 @@ module Optimizely
     # ProjectConfig is an interface capturing the experiment, variation and feature definitions.
     # The default implementation of ProjectConfig can be found in DatafileProjectConfig.
 
+    def datafile; end
+
     def account_id; end
 
     def attributes; end
@@ -44,6 +46,8 @@ module Optimizely
 
     def revision; end
 
+    def send_flag_decisions; end
+
     def rollouts; end
 
     def experiment_running?(experiment); end

data/lib/optimizely/semantic_version.rb

@@ -0,0 +1,166 @@
+# 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.
+#
+
+require_relative 'exceptions'
+
+module Optimizely
+  module SemanticVersion
+    # Semantic Version Operators
+    SEMVER_PRE_RELEASE = '-'
+    SEMVER_BUILD = '+'
+
+    module_function
+
+    def pre_release?(target)
+      # Method to check if the given version is a prerelease
+      #
+      # target - String representing semantic version
+      #
+      # Returns true if the given version is a prerelease
+      #         false if it doesn't
+
+      raise unless target.is_a? String
+
+      prerelease_index = target.index(SEMVER_PRE_RELEASE)
+      build_index = target.index(SEMVER_BUILD)
+
+      return false if prerelease_index.nil?
+      return true if build_index.nil?
+
+      # when both operators are present prerelease should precede the build operator
+      prerelease_index < build_index
+    end
+
+    def build?(target)
+      # Method to check if the given version is a build
+      #
+      # target - String representing semantic version
+      #
+      # Returns true if the given version is a build
+      #         false if it doesn't
+
+      raise unless target.is_a? String
+
+      prerelease_index = target.index(SEMVER_PRE_RELEASE)
+      build_index = target.index(SEMVER_BUILD)
+
+      return false if build_index.nil?
+      return true if prerelease_index.nil?
+
+      # when both operators are present build should precede the prerelease operator
+      build_index < prerelease_index
+    end
+
+    def split_semantic_version(target)
+      # Method to split the given version.
+      #
+      # target - String representing semantic version
+      #
+      # Returns List The array of version split into smaller parts i.e major, minor, patch etc,
+      #         Exception if the given version is invalid.
+
+      target_prefix = target
+      target_suffix = ''
+      target_parts = []
+
+      raise InvalidSemanticVersion if target.include? ' '
+
+      if pre_release?(target)
+        target_parts = target.split(SEMVER_PRE_RELEASE, 2)
+      elsif build? target
+        target_parts = target.split(SEMVER_BUILD, 2)
+      end
+
+      unless target_parts.empty?
+        target_prefix = target_parts[0].to_s
+        target_suffix = target_parts[1..-1]
+      end
+
+      # expect a version string of the form x.y.z
+      dot_count = target_prefix.count('.')
+      raise InvalidSemanticVersion if dot_count > 2
+
+      target_version_parts = target_prefix.split('.')
+      raise InvalidSemanticVersion if target_version_parts.length != dot_count + 1
+
+      target_version_parts.each do |part|
+        raise InvalidSemanticVersion unless Helpers::Validator.string_numeric? part
+      end
+
+      target_version_parts.concat(target_suffix) if target_suffix.is_a?(Array)
+
+      target_version_parts
+    end
+
+    def compare_user_version_with_target_version(target_version, user_version)
+      # Compares target and user versions
+      #
+      # target_version - String representing target version
+      # user_version - String representing user version
+
+      # Returns boolean 0 if user version is equal to target version,
+      #                 1 if user version is greater than target version,
+      #                -1 if user version is less than target version.
+
+      raise InvalidAttributeType unless target_version.is_a? String
+      raise InvalidAttributeType unless user_version.is_a? String
+
+      is_target_version_prerelease = pre_release?(target_version)
+      is_user_version_prerelease = pre_release?(user_version)
+
+      target_version_parts = split_semantic_version(target_version)
+      user_version_parts = split_semantic_version(user_version)
+      user_version_parts_len = user_version_parts.length if user_version_parts
+
+      # Up to the precision of targetedVersion, expect version to match exactly.
+      target_version_parts.each_with_index do |_item, idx|
+        if user_version_parts_len <= idx
+          # even if they are equal at this point. if the target is a prerelease
+          # then user version must be greater than the pre release.
+          return 1 if is_target_version_prerelease
+
+          return -1
+
+        elsif !Helpers::Validator.string_numeric? user_version_parts[idx]
+          # compare strings
+          if user_version_parts[idx] < target_version_parts[idx]
+            return 1 if is_target_version_prerelease && !is_user_version_prerelease
+
+            return -1
+
+          elsif user_version_parts[idx] > target_version_parts[idx]
+            return -1 if is_user_version_prerelease && !is_target_version_prerelease
+
+            return 1
+          end
+
+        else
+          user_version_part = user_version_parts[idx].to_i
+          target_version_part = target_version_parts[idx].to_i
+
+          return 1 if user_version_part > target_version_part
+          return -1 if user_version_part < target_version_part
+        end
+      end
+
+      return -1 if is_user_version_prerelease && !is_target_version_prerelease
+
+      0
+    end
+  end
+end