optimizely-sdk 2.0.0.beta → 2.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b6da10a1ad97624a7523adcdc6841b2999ab35d3
-  data.tar.gz: 3865376c1962511db8d8350041fbc830b29b16c6
+  metadata.gz: f57d0b3e13c6c5bc057719cd5fa0689c9b93ade1
+  data.tar.gz: e67d075ed5fc5e42e41e8a5620e4e038ae3f1afd
 SHA512:
-  metadata.gz: bf35c547babd0be1d576bf8926e23fa9e9292b47bf6a74df9a8cda19b00bd2a3da974c7a840dba7d6ac3aa3132b192caa692b727bc5bdfdf3a3a85c933ef58da
-  data.tar.gz: b587d153eb46d6b779ebc298dfde188824f7c5f3fe1cc9c2b4e890878a9c190e9d9051baccbc8d18329670d81c5e5437e53f2d69d4c790a785b8fcb8fa2ac2e3
+  metadata.gz: 5fe41284c79ebc016276afcac83a1d87fb6e7a355738c8ff6c9fb38cd4c7d1a0494c44558394170edd380c0dee42c8accc91d67afb300a6d973a33f03762e984
+  data.tar.gz: 85fa4cb24da1cdd082846b80f4939419023c774e9305d048e9564381e68e4acdf78f76a937885998523afdecf47cce1c09dca3eb7b04ea320c852805d69b44cd

data/lib/optimizely.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 #
-#    Copyright 2016-2017, Optimizely and contributors
+#    Copyright 2016-2018, 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.
@@ -24,11 +26,11 @@ require_relative 'optimizely/helpers/group'
 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
-
     # Boolean representing if the instance represents a usable Optimizely Project
     attr_reader :is_valid
 
@@ -38,6 +40,7 @@ module Optimizely
     attr_reader :event_builder
     attr_reader :event_dispatcher
     attr_reader :logger
+    attr_reader :notification_center
 
     def initialize(datafile, event_dispatcher = nil, logger = nil, error_handler = nil, skip_json_validation = false, user_profile_service = nil)
       # Constructor for Projects.
@@ -82,7 +85,8 @@ module Optimizely
       end
 
       @decision_service = DecisionService.new(@config, @user_profile_service)
-      @event_builder = EventBuilder.new(@config)
+      @event_builder = EventBuilder.new(@config, logger)
+      @notification_center = NotificationCenter.new(@logger, @error_handler)
     end
 
     def activate(experiment_key, user_id, attributes = nil)
@@ -131,6 +135,11 @@ module Optimizely
         return nil
       end
 
+      if user_id.to_s.empty?
+        @logger.log(Logger::ERROR, 'User ID cannot be empty.')
+        return nil
+      end
+
       unless user_inputs_valid?(attributes)
         @logger.log(Logger::INFO, "Not activating user '#{user_id}.")
         return nil
@@ -140,13 +149,39 @@ module Optimizely
 
       unless variation_id.nil?
         variation = @config.get_variation_from_id(experiment_key, variation_id)
-        if variation
-          return variation['key']
-        end
+        return variation['key'] if variation
       end
       nil
     end
 
+    def set_forced_variation(experiment_key, user_id, variation_key)
+      # Force a user into a variation for a given experiment.
+      #
+      # experiment_key - String - key identifying the experiment.
+      # user_id - String - The user ID to be used for bucketing.
+      # variation_key - The variation key specifies the variation which the user will
+      #   be forced into. If nil, then clear the existing experiment-to-variation mapping.
+      #
+      # Returns - Boolean - indicates if the set completed successfully.
+
+      @config.set_forced_variation(experiment_key, user_id, variation_key)
+    end
+
+    def get_forced_variation(experiment_key, user_id)
+      # Gets the forced variation for a given user and experiment.
+      #
+      # experiment_key - String - Key identifying the experiment.
+      # user_id - String - The user ID to be used for bucketing.
+      #
+      # Returns String|nil The forced variation key.
+
+      forced_variation_key = nil
+      forced_variation = @config.get_forced_variation(experiment_key, user_id)
+      forced_variation_key = forced_variation['key'] if forced_variation
+
+      forced_variation_key
+    end
+
     def track(event_key, user_id, attributes = nil, event_tags = nil)
       # Send conversion event to Optimizely.
       #
@@ -161,11 +196,9 @@ module Optimizely
         return nil
       end
 
-      if event_tags and event_tags.is_a? Numeric
-        event_tags = {
-          'revenue' => event_tags
-        }
-        @logger.log(Logger::WARN, 'Event value is deprecated in track call. Use event tags to pass in revenue value instead.')
+      if user_id.to_s.empty?
+        @logger.log(Logger::ERROR, 'User ID cannot be empty.')
+        return nil
       end
 
       return nil unless user_inputs_valid?(attributes, event_tags)
@@ -189,13 +222,18 @@ module Optimizely
       conversion_event = @event_builder.create_conversion_event(event_key, user_id, attributes,
                                                                 event_tags, experiment_variation_map)
       @logger.log(Logger::INFO,
-                  'Dispatching conversion event to URL %s with params %s.' % [conversion_event.url,
-                                                                              conversion_event.params])
+                  "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
+      )
+      nil
     end
 
     def is_feature_enabled(feature_flag_key, user_id, attributes = nil)
@@ -213,7 +251,17 @@ module Optimizely
       unless @is_valid
         logger = SimpleLogger.new
         logger.log(Logger::ERROR, InvalidDatafileError.new('is_feature_enabled').message)
-        return nil
+        return false
+      end
+
+      unless feature_flag_key
+        @logger.log(Logger::ERROR, 'Feature flag key cannot be empty.')
+        return false
+      end
+
+      if user_id.to_s.empty?
+        @logger.log(Logger::ERROR, 'User ID cannot be empty.')
+        return false
       end
 
       feature_flag = @config.get_feature_flag_from_key(feature_flag_key)
@@ -223,23 +271,55 @@ module Optimizely
       end
 
       decision = @decision_service.get_variation_for_feature(feature_flag, user_id, attributes)
-      unless decision.nil?
-        variation = decision['variation']
-        experiment = decision['experiment']
-        unless experiment.nil?
-          send_impression(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}'.")
-        end
+      if decision.nil?
+        @logger.log(Logger::INFO,
+                    "Feature '#{feature_flag_key}' is not enabled for user '#{user_id}'.")
+        return false
+      end
 
-        @logger.log(Logger::INFO, "Feature '#{feature_flag_key}' is enabled for user '#{user_id}'.")
-        return true
+      variation = decision['variation']
+      unless variation['featureEnabled']
+        @logger.log(Logger::INFO,
+                    "Feature '#{feature_flag_key}' is not enabled for user '#{user_id}'.")
+        return false
       end
 
-      @logger.log(Logger::INFO,
-                  "Feature '#{feature_flag_key}' is not enabled for user '#{user_id}'.")
-      false
+      if decision.source == Optimizely::DecisionService::DECISION_SOURCE_EXPERIMENT
+        # Send event if Decision came from an experiment.
+        send_impression(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}'.")
+      end
+      @logger.log(Logger::INFO, "Feature '#{feature_flag_key}' is enabled for user '#{user_id}'.")
+
+      true
+    end
+
+    def get_enabled_features(user_id, attributes = nil)
+      # Gets keys of all feature flags which are enabled for the user.
+      # Args:
+      #   user_id: ID for user.
+      #   attributes: Dict representing user attributes.
+      # Returns:
+      #   A List of feature flag keys that are enabled for the user.
+      #
+      enabled_features = []
+
+      unless @is_valid
+        logger = SimpleLogger.new
+        logger.log(Logger::ERROR, InvalidDatafileError.new('get_enabled_features').message)
+        return enabled_features
+      end
+
+      @config.feature_flags.each do |feature|
+        enabled_features.push(feature['key']) if is_feature_enabled(
+          feature['key'],
+          user_id,
+          attributes
+        ) == true
+      end
+      enabled_features.sort
     end
 
     def get_feature_variable_string(feature_flag_key, variable_key, user_id, attributes = nil)
@@ -256,12 +336,12 @@ module Optimizely
       variable_value = get_feature_variable_for_type(
         feature_flag_key,
         variable_key,
-        Optimizely::Helpers::Constants::VARIABLE_TYPES["STRING"],
+        Optimizely::Helpers::Constants::VARIABLE_TYPES['STRING'],
         user_id,
         attributes
       )
 
-      return variable_value
+      variable_value
     end
 
     def get_feature_variable_boolean(feature_flag_key, variable_key, user_id, attributes = nil)
@@ -278,12 +358,12 @@ module Optimizely
       variable_value = get_feature_variable_for_type(
         feature_flag_key,
         variable_key,
-        Optimizely::Helpers::Constants::VARIABLE_TYPES["BOOLEAN"],
+        Optimizely::Helpers::Constants::VARIABLE_TYPES['BOOLEAN'],
         user_id,
         attributes
       )
 
-      return variable_value
+      variable_value
     end
 
     def get_feature_variable_double(feature_flag_key, variable_key, user_id, attributes = nil)
@@ -300,12 +380,12 @@ module Optimizely
       variable_value = get_feature_variable_for_type(
         feature_flag_key,
         variable_key,
-        Optimizely::Helpers::Constants::VARIABLE_TYPES["DOUBLE"],
+        Optimizely::Helpers::Constants::VARIABLE_TYPES['DOUBLE'],
         user_id,
         attributes
       )
 
-      return variable_value
+      variable_value
     end
 
     def get_feature_variable_integer(feature_flag_key, variable_key, user_id, attributes = nil)
@@ -322,12 +402,12 @@ module Optimizely
       variable_value = get_feature_variable_for_type(
         feature_flag_key,
         variable_key,
-        Optimizely::Helpers::Constants::VARIABLE_TYPES["INTEGER"],
+        Optimizely::Helpers::Constants::VARIABLE_TYPES['INTEGER'],
         user_id,
         attributes
       )
 
-      return variable_value
+      variable_value
     end
 
     private
@@ -343,7 +423,23 @@ module Optimizely
       # attributes - Hash representing visitor attributes and values which need to be recorded.
       #
       # Returns the type-casted variable value.
-      # Returns nil if the feature flag or variable are not found.
+      # Returns nil if the feature flag or variable or user ID is empty
+      #             in case of variable type mismatch
+
+      unless feature_flag_key
+        @logger.log(Logger::ERROR, 'Feature flag key cannot be empty.')
+        return nil
+      end
+
+      unless variable_key
+        @logger.log(Logger::ERROR, 'Variable key cannot be empty.')
+        return nil
+      end
+
+      if user_id.to_s.empty?
+        @logger.log(Logger::ERROR, 'User ID cannot be empty.')
+        return nil
+      end
 
       feature_flag = @config.get_feature_flag_from_key(feature_flag_key)
       unless feature_flag
@@ -351,43 +447,40 @@ module Optimizely
         return nil
       end
 
-      variable_value = nil
       variable = @config.get_feature_variable(feature_flag, variable_key)
-      unless variable.nil?
-        variable_value = variable['defaultValue']
 
+      # Error message logged in ProjectConfig- get_feature_flag_from_key
+      return nil if variable.nil?
+
+      # Returns nil if type differs
+      if variable['type'] != variable_type
+        @logger.log(Logger::WARN,
+                    "Requested variable as type '#{variable_type}' but variable '#{variable_key}' is of type '#{variable['type']}'.")
+        return nil
+      else
         decision = @decision_service.get_variation_for_feature(feature_flag, user_id, attributes)
-        unless decision
-          @logger.log(Logger::INFO,
-            "User '#{user_id}' was not bucketed into any variation for feature flag '#{feature_flag_key}'. Returning the default variable value '#{variable_value}'.")
-        else
+        variable_value = variable['defaultValue']
+        if decision
           variation = decision['variation']
           variation_variable_usages = @config.variation_id_to_variable_usage_map[variation['id']]
           variable_id = variable['id']
-          unless variation_variable_usages and variation_variable_usages.key?(variable_id)
-            variation_key = variation['key']
-            @logger.log(Logger::DEBUG,
-              "Variable '#{variable_key}' is not used in variation '#{variation_key}'. Returning the default variable value '#{variable_value}'."
-            )
-          else
+          if variation_variable_usages&.key?(variable_id)
             variable_value = variation_variable_usages[variable_id]['value']
             @logger.log(Logger::INFO,
-              "Got variable value '#{variable_value}' for variable '#{variable_key}' of feature flag '#{feature_flag_key}'.")
+                        "Got variable value '#{variable_value}' for variable '#{variable_key}' of feature flag '#{feature_flag_key}'.")
+          else
+            @logger.log(Logger::DEBUG,
+                        "Variable '#{variable_key}' is not used in variation '#{variation['key']}'. Returning the default variable value '#{variable_value}'.")
           end
+        else
+          @logger.log(Logger::INFO,
+                      "User '#{user_id}' was not bucketed into any variation for feature flag '#{feature_flag_key}'. Returning the default variable value '#{variable_value}'.")
         end
       end
 
-      unless variable_value.nil?
-        actual_variable_type = variable['type']
-        unless variable_type == actual_variable_type
-          @logger.log(Logger::WARN,
-            "Requested variable type '#{variable_type}' but variable '#{variable_key}' is of type '#{actual_variable_type}'.")
-        end
+      variable_value = Helpers::VariableType.cast_value_to_type(variable_value, variable_type, @logger)
 
-        variable_value = Helpers::VariableType.cast_value_to_type(variable_value, variable_type, @logger)
-      end
-
-      return variable_value
+      variable_value
     end
 
     def get_valid_experiments_for_event(event_key, user_id, attributes)
@@ -426,13 +519,9 @@ module Optimizely
       #
       # Returns boolean True if inputs are valid. False otherwise.
 
-      if !attributes.nil? && !attributes_valid?(attributes)
-        return false
-      end
+      return false if !attributes.nil? && !attributes_valid?(attributes)
 
-      if !event_tags.nil? && !event_tags_valid?(event_tags)
-        return false
-      end
+      return false if !event_tags.nil? && !event_tags_valid?(event_tags)
 
       true
     end
@@ -457,12 +546,12 @@ module Optimizely
 
     def validate_instantiation_options(datafile, skip_json_validation)
       unless skip_json_validation
-        raise InvalidInputError.new('datafile') unless Helpers::Validator.datafile_valid?(datafile)
+        raise InvalidInputError, 'datafile' unless Helpers::Validator.datafile_valid?(datafile)
       end
 
-      raise InvalidInputError.new('logger') unless Helpers::Validator.logger_valid?(@logger)
-      raise InvalidInputError.new('error_handler') unless Helpers::Validator.error_handler_valid?(@error_handler)
-      raise InvalidInputError.new('event_dispatcher') unless Helpers::Validator.event_dispatcher_valid?(@event_dispatcher)
+      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)
     end
 
     def send_impression(experiment, variation_key, user_id, attributes = nil)
@@ -470,13 +559,17 @@ module Optimizely
       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)
       @logger.log(Logger::INFO,
-                  'Dispatching impression event to URL %s with params %s.' % [impression_event.url,
-                                                                              impression_event.params])
+                  "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
+      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
   end
 end

data/lib/optimizely/audience.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 #
-#    Copyright 2016, Optimizely and contributors
+#    Copyright 2016-2017, 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.
@@ -41,8 +43,9 @@ module Optimizely
       # Return true if any one of the audience conditions are met
       @condition_evaluator = ConditionEvaluator.new(attributes)
       audience_ids.each do |audience_id|
-        audience_conditions = config.get_audience_conditions_from_id(audience_id)
-        audience_conditions = JSON.load(audience_conditions)
+        audience = config.get_audience_from_id(audience_id)
+        audience_conditions = audience['conditions']
+        audience_conditions = JSON.parse(audience_conditions)
         return true if @condition_evaluator.evaluate(audience_conditions)
       end
 

data/lib/optimizely/bucketer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 #
 #    Copyright 2016-2017, Optimizely and contributors
 #
@@ -20,7 +22,7 @@ module Optimizely
   class Bucketer
     # Optimizely bucketing algorithm that evenly distributes visitors.
 
-    BUCKETING_ID_TEMPLATE = '%{user_id}%{entity_id}'
+    BUCKETING_ID_TEMPLATE = '%<bucketing_id>s%<entity_id>s'
     HASH_SEED = 1
     MAX_HASH_VALUE = 2**32
     MAX_TRAFFIC_VALUE = 10_000
@@ -35,13 +37,15 @@ module Optimizely
       @config = config
     end
 
-    def bucket(experiment, user_id)
+    def bucket(experiment, bucketing_id, user_id)
       # Determines ID of variation to be shown for a given experiment key and user ID.
       #
       # experiment - Experiment for which visitor is to be bucketed.
+      # bucketing_id - String A customer-assigned value used to generate the bucketing key
       # user_id - String ID for user.
       #
       # Returns variation in which visitor with ID user_id has been placed. Nil if no variation.
+      return nil if experiment.nil?
 
       # check if experiment is in a group; if so, check if user is bucketed into specified experiment
       experiment_id = experiment['id']
@@ -51,7 +55,7 @@ module Optimizely
         group = @config.group_key_map.fetch(group_id)
         if Helpers::Group.random_policy?(group)
           traffic_allocations = group.fetch('trafficAllocation')
-          bucketed_experiment_id = find_bucket(user_id, group_id, traffic_allocations)
+          bucketed_experiment_id = find_bucket(bucketing_id, user_id, group_id, traffic_allocations)
           # return if the user is not bucketed into any experiment
           unless bucketed_experiment_id
             @config.logger.log(Logger::INFO, "User '#{user_id}' is in no experiment.")
@@ -76,7 +80,7 @@ module Optimizely
       end
 
       traffic_allocations = experiment['trafficAllocation']
-      variation_id = find_bucket(user_id, experiment_id, traffic_allocations)
+      variation_id = find_bucket(bucketing_id, user_id, experiment_id, traffic_allocations)
       if variation_id && variation_id != ''
         variation = @config.get_variation_from_id(experiment_key, variation_id)
         variation_key = variation ? variation['key'] : nil
@@ -96,18 +100,19 @@ module Optimizely
       nil
     end
 
-    def find_bucket(user_id, parent_id, traffic_allocations)
+    def find_bucket(bucketing_id, user_id, parent_id, traffic_allocations)
       # Helper function to find the matching entity ID for a given bucketing value in a list of traffic allocations.
       #
+      # bucketing_id - String A customer-assigned value user to generate bucketing key
       # user_id - String ID for user
       # parent_id - String entity ID to use for bucketing ID
       # traffic_allocations - Array of traffic allocations
       #
       # Returns entity ID corresponding to the provided bucket value or nil if no match is found.
-
-      bucketing_id = sprintf(BUCKETING_ID_TEMPLATE, user_id: user_id, entity_id: parent_id)
-      bucket_value = generate_bucket_value(bucketing_id)
-      @config.logger.log(Logger::DEBUG, "Assigned bucket #{bucket_value} to user '#{user_id}'.")
+      bucketing_key = format(BUCKETING_ID_TEMPLATE, bucketing_id: bucketing_id, entity_id: parent_id)
+      bucket_value = generate_bucket_value(bucketing_key)
+      @config.logger.log(Logger::DEBUG, "Assigned bucket #{bucket_value} to user '#{user_id}' "\
+                         "with bucketing ID: '#{bucketing_id}'.")
 
       traffic_allocations.each do |traffic_allocation|
         current_end_of_range = traffic_allocation['endOfRange']
@@ -122,25 +127,25 @@ module Optimizely
 
     private
 
-    def generate_bucket_value(bucketing_id)
+    def generate_bucket_value(bucketing_key)
       # Helper function to generate bucket value in half-closed interval [0, MAX_TRAFFIC_VALUE).
       #
-      # bucketing_id - String ID for bucketing.
+      # bucketing_key - String - Value used to generate bucket value
       #
-      # Returns bucket value corresponding to the provided bucketing ID.
+      # Returns bucket value corresponding to the provided bucketing key.
 
-      ratio = (generate_unsigned_hash_code_32_bit(bucketing_id)).to_f / MAX_HASH_VALUE
+      ratio = generate_unsigned_hash_code_32_bit(bucketing_key).to_f / MAX_HASH_VALUE
       (ratio * MAX_TRAFFIC_VALUE).to_i
     end
 
-    def generate_unsigned_hash_code_32_bit(bucketing_id)
+    def generate_unsigned_hash_code_32_bit(bucketing_key)
       # Helper function to retreive hash code
       #
-      # bucketing_id - String ID for bucketing.
+      # bucketing_key - String - Value used for the key of the murmur hash
       #
       # Returns hash code which is a 32 bit unsigned integer.
 
-      MurmurHash3::V32.str_hash(bucketing_id, @bucket_seed) & UNSIGNED_MAX_32_BIT_VALUE
+      MurmurHash3::V32.str_hash(bucketing_key, @bucket_seed) & UNSIGNED_MAX_32_BIT_VALUE
     end
   end
 end