optimizely-sdk 1.5.0 → 2.0.0.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3fae777d6ce539eb2e0809dbf38d4784130c8ade
-  data.tar.gz: f65bee6796830490f4ee8f1a86da20ed7b4f01fb
+  metadata.gz: b6da10a1ad97624a7523adcdc6841b2999ab35d3
+  data.tar.gz: 3865376c1962511db8d8350041fbc830b29b16c6
 SHA512:
-  metadata.gz: b8e6f2732d692b1844d3f0c990010aba9858c93b82244803962810d33c78b945f925936874097272705a1a7e724f9d3abad1c4c66ba358573ba32c8bd10d8515
-  data.tar.gz: a8804feff56093f399f87425869a733e9b91b74f502b075a1d790364f47da5e524c36ecde23a626d2b8c977c344e5bd2fb5c93e742ceb5a2cfcf4a50710b9444
+  metadata.gz: bf35c547babd0be1d576bf8926e23fa9e9292b47bf6a74df9a8cda19b00bd2a3da974c7a840dba7d6ac3aa3132b192caa692b727bc5bdfdf3a3a85c933ef58da
+  data.tar.gz: b587d153eb46d6b779ebc298dfde188824f7c5f3fe1cc9c2b4e890878a9c190e9d9051baccbc8d18329670d81c5e5437e53f2d69d4c790a785b8fcb8fa2ac2e3

data/lib/optimizely.rb

@@ -24,7 +24,6 @@ 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
@@ -39,7 +38,6 @@ 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.
@@ -85,7 +83,6 @@ module Optimizely
 
       @decision_service = DecisionService.new(@config, @user_profile_service)
       @event_builder = EventBuilder.new(@config)
-      @notification_center = NotificationCenter.new(@logger, @error_handler)
     end
 
     def activate(experiment_key, user_id, attributes = nil)
@@ -134,11 +131,6 @@ module Optimizely
         return nil
       end
 
-      unless user_id.is_a? String
-        @logger.log(Logger::ERROR, "User id: #{user_id} is not a string")
-        return nil
-      end
-
       unless user_inputs_valid?(attributes)
         @logger.log(Logger::INFO, "Not activating user '#{user_id}.")
         return nil
@@ -155,36 +147,6 @@ module Optimizely
       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);
-      if forced_variation
-        forced_variation_key = forced_variation['key']
-      end
-
-      forced_variation_key
-    end
-
     def track(event_key, user_id, attributes = nil, event_tags = nil)
       # Send conversion event to Optimizely.
       #
@@ -234,10 +196,6 @@ module Optimizely
       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
-      )
     end
 
     def is_feature_enabled(feature_flag_key, user_id, attributes = nil)
@@ -519,11 +477,6 @@ 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)
-      @notification_center.send_notifications(
-          NotificationCenter::NOTIFICATION_TYPES[:ACTIVATE],
-          experiment,user_id, attributes, variation, impression_event
-      )
     end
   end
 end

data/lib/optimizely/bucketer.rb

@@ -20,7 +20,7 @@ module Optimizely
   class Bucketer
     # Optimizely bucketing algorithm that evenly distributes visitors.
 
-    BUCKETING_ID_TEMPLATE = '%{bucketing_id}%{entity_id}'
+    BUCKETING_ID_TEMPLATE = '%{user_id}%{entity_id}'
     HASH_SEED = 1
     MAX_HASH_VALUE = 2**32
     MAX_TRAFFIC_VALUE = 10_000
@@ -35,15 +35,13 @@ module Optimizely
       @config = config
     end
 
-    def bucket(experiment, bucketing_id, user_id)
+    def bucket(experiment, 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']
@@ -53,7 +51,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(bucketing_id, user_id, group_id, traffic_allocations)
+          bucketed_experiment_id = find_bucket(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.")
@@ -78,7 +76,7 @@ module Optimizely
       end
 
       traffic_allocations = experiment['trafficAllocation']
-      variation_id = find_bucket(bucketing_id, user_id, experiment_id, traffic_allocations)
+      variation_id = find_bucket(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
@@ -98,18 +96,18 @@ module Optimizely
       nil
     end
 
-    def find_bucket(bucketing_id, user_id, parent_id, traffic_allocations)
+    def find_bucket(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_key = sprintf(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}'.")
+
+      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}'.")
 
       traffic_allocations.each do |traffic_allocation|
         current_end_of_range = traffic_allocation['endOfRange']
@@ -124,25 +122,25 @@ module Optimizely
 
     private
 
-    def generate_bucket_value(bucketing_key)
+    def generate_bucket_value(bucketing_id)
       # Helper function to generate bucket value in half-closed interval [0, MAX_TRAFFIC_VALUE).
       #
-      # bucketing_key - String - Value used to generate bucket value
+      # bucketing_id - String ID for bucketing.
       #
-      # Returns bucket value corresponding to the provided bucketing key.
+      # Returns bucket value corresponding to the provided bucketing ID.
 
-      ratio = (generate_unsigned_hash_code_32_bit(bucketing_key)).to_f / MAX_HASH_VALUE
+      ratio = (generate_unsigned_hash_code_32_bit(bucketing_id)).to_f / MAX_HASH_VALUE
       (ratio * MAX_TRAFFIC_VALUE).to_i
     end
 
-    def generate_unsigned_hash_code_32_bit(bucketing_key)
+    def generate_unsigned_hash_code_32_bit(bucketing_id)
       # Helper function to retreive hash code
       #
-      # bucketing_key - String - Value used for the key of the murmur hash
+      # bucketing_id - String ID for bucketing.
       #
       # Returns hash code which is a 32 bit unsigned integer.
 
-      MurmurHash3::V32.str_hash(bucketing_key, @bucket_seed) & UNSIGNED_MAX_32_BIT_VALUE
+      MurmurHash3::V32.str_hash(bucketing_id, @bucket_seed) & UNSIGNED_MAX_32_BIT_VALUE
     end
   end
 end

data/lib/optimizely/decision_service.rb

@@ -16,31 +16,27 @@
 require_relative './bucketer'
 
 module Optimizely
-  
-  RESERVED_ATTRIBUTE_KEY_BUCKETING_ID = "\$opt_bucketing_id".freeze
-  
   class DecisionService
     # Optimizely's decision service that determines into which variation of an experiment a user will be allocated.
     #
     # The decision service contains all logic relating to how a user bucketing decisions is made.
     # This includes all of the following (in order):
     #
-    # 1. Check experiment status
-    # 2. Check forced bucketing
-    # 3. Check whitelisting
-    # 4. Check user profile service for past bucketing decisions (sticky bucketing)
-    # 5. Check audience targeting
-    # 6. Use Murmurhash3 to bucket the user
-    
+    # 1. Checking experiment status
+    # 2. Checking whitelisting
+    # 3. Checking user profile service for past bucketing decisions (sticky bucketing)
+    # 3. Checking audience targeting
+    # 4. Using Murmurhash3 to bucket the user
+
     attr_reader :bucketer
     attr_reader :config
-    
+
     def initialize(config, user_profile_service = nil)
       @config = config
       @user_profile_service = user_profile_service
       @bucketer = Bucketer.new(@config)
     end
-    
+
     def get_variation(experiment_key, user_id, attributes = nil)
       # Determines variation into which user will be bucketed.
       #
@@ -49,65 +45,52 @@ module Optimizely
       # attributes - Hash representing user attributes
       #
       # Returns variation ID where visitor will be bucketed (nil if experiment is inactive or user does not meet audience conditions)
-      
-      # By default, the bucketing ID should be the user ID
-      bucketing_id = user_id;
-      
-      # If the bucketing ID key is defined in attributes, then use that in place of the userID
-      if attributes and attributes[RESERVED_ATTRIBUTE_KEY_BUCKETING_ID].is_a? String
-        unless attributes[RESERVED_ATTRIBUTE_KEY_BUCKETING_ID].empty?
-          bucketing_id = attributes[RESERVED_ATTRIBUTE_KEY_BUCKETING_ID]
-          @config.logger.log(Logger::DEBUG, "Setting the bucketing ID '#{bucketing_id}'")
-        end
-      end
-      
+
       # Check to make sure experiment is active
       experiment = @config.get_experiment_from_key(experiment_key)
-      return nil if experiment.nil?
-      
+      if experiment.nil?
+        return nil
+      end
+
       experiment_id = experiment['id']
       unless @config.experiment_running?(experiment)
         @config.logger.log(Logger::INFO, "Experiment '#{experiment_key}' is not running.")
         return nil
       end
-      
-      # Check if a forced variation is set for the user
-      forced_variation = @config.get_forced_variation(experiment_key, user_id)
-      return forced_variation['id'] if forced_variation
-      
-      # Check if user is in a white-listed variation
-      whitelisted_variation_id = get_whitelisted_variation_id(experiment_key, user_id)
-      return whitelisted_variation_id if whitelisted_variation_id
-      
+
+      # Check if user is in a forced variation
+      forced_variation_id = get_forced_variation_id(experiment_key, user_id)
+      return forced_variation_id if forced_variation_id
+
       # Check for saved bucketing decisions
       user_profile = get_user_profile(user_id)
       saved_variation_id = get_saved_variation_id(experiment_id, user_profile)
       if saved_variation_id
         @config.logger.log(
-         Logger::INFO,
-         "Returning previously activated variation ID #{saved_variation_id} of experiment '#{experiment_key}' for user '#{user_id}' from user profile."
+          Logger::INFO,
+          "Returning previously activated variation ID #{saved_variation_id} of experiment '#{experiment_key}' for user '#{user_id}' from user profile."
         )
         return saved_variation_id
       end
-      
+
       # Check audience conditions
       unless Audience.user_in_experiment?(@config, experiment, attributes)
         @config.logger.log(
-         Logger::INFO,
-         "User '#{user_id}' does not meet the conditions to be in experiment '#{experiment_key}'."
+          Logger::INFO,
+          "User '#{user_id}' does not meet the conditions to be in experiment '#{experiment_key}'."
         )
         return nil
       end
-      
+
       # Bucket normally
-      variation = @bucketer.bucket(experiment, bucketing_id, user_id)
+      variation = @bucketer.bucket(experiment, user_id)
       variation_id = variation ? variation['id'] : nil
-      
+
       # Persist bucketing decision
       save_user_profile(user_profile, experiment_id, variation_id)
       variation_id
     end
-    
+
     def get_variation_for_feature(feature_flag, user_id, attributes = nil)
       # Get the variation the user is bucketed into for the given FeatureFlag.
       #
@@ -116,33 +99,35 @@ module Optimizely
       # attributes - Hash representing user attributes
       #
       # Returns hash with the experiment and variation where visitor will be bucketed (nil if the user is not bucketed into any of the experiments on the feature)
-      
+
       # check if the feature is being experiment on and whether the user is bucketed into the experiment
       decision = get_variation_for_feature_experiment(feature_flag, user_id, attributes)
-      return decision unless decision.nil?
-      
+      unless decision.nil?
+        return decision
+      end
+
       feature_flag_key = feature_flag['key']
       variation = get_variation_for_feature_rollout(feature_flag, user_id, attributes)
       if variation
         @config.logger.log(
-         Logger::INFO,
-         "User '#{user_id}' is in the rollout for feature flag '#{feature_flag_key}'."
+          Logger::INFO,
+          "User '#{user_id}' is in the rollout for feature flag '#{feature_flag_key}'."
         )
         # return decision with nil experiment so we don't track impressions for it
         return {
-         'experiment' => nil,
-         'variation' => variation
+          'experiment' => nil,
+          'variation' => variation
         }
       else
         @config.logger.log(
-         Logger::INFO,
-         "User '#{user_id}' is not in the rollout for feature flag '#{feature_flag_key}'."
+          Logger::INFO,
+          "User '#{user_id}' is not in the rollout for feature flag '#{feature_flag_key}'."
         )
       end
-      
+
       return nil
     end
-    
+
     def get_variation_for_feature_experiment(feature_flag, user_id, attributes = nil)
       # Gets the variation the user is bucketed into for the feature flag's experiment.
       #
@@ -152,7 +137,7 @@ module Optimizely
       #
       # Returns a hash with the experiment and variation where visitor will be bucketed
       # or nil if the user is not bucketed into any of the experiments on the feature
-      
+
       feature_flag_key = feature_flag['key']
       unless feature_flag['experimentIds'].empty?
         # check if experiment is part of mutex group
@@ -160,12 +145,12 @@ module Optimizely
         experiment = @config.experiment_id_map[experiment_id]
         unless experiment
           @config.logger.log(
-           Logger::DEBUG,
-           "Feature flag experiment with ID '#{experiment_id}' is not in the datafile."
+            Logger::DEBUG,
+            "Feature flag experiment with ID '#{experiment_id}' is not in the datafile."
           )
           return nil
         end
-        
+
         group_id = experiment['groupId']
         # if experiment is part of mutex group we first determine which experiment (if any) in the group the user is part of
         if group_id and @config.group_key_map.has_key?(group_id)
@@ -173,15 +158,15 @@ module Optimizely
           bucketed_experiment_id = @bucketer.find_bucket(user_id, group_id, group['trafficAllocation'])
           if bucketed_experiment_id.nil?
             @config.logger.log(
-             Logger::INFO,
-             "The user '#{user_id}' is not bucketed into any of the experiments on the feature '#{feature_flag_key}'."
+              Logger::INFO,
+              "The user '#{user_id}' is not bucketed into any of the experiments on the feature '#{feature_flag_key}'."
             )
             return nil
           end
         else
           bucketed_experiment_id = experiment_id
         end
-        
+
         if feature_flag['experimentIds'].include?(bucketed_experiment_id)
           experiment = @config.experiment_id_map[bucketed_experiment_id]
           experiment_key = experiment['key']
@@ -189,30 +174,30 @@ module Optimizely
           unless variation_id.nil?
             variation = @config.variation_id_map[experiment_key][variation_id]
             @config.logger.log(
-             Logger::INFO,
-             "The user '#{user_id}' is bucketed into experiment '#{experiment_key}' of feature '#{feature_flag_key}'."
+              Logger::INFO,
+              "The user '#{user_id}' is bucketed into experiment '#{experiment_key}' of feature '#{feature_flag_key}'."
             )
             return {
-             'variation' => variation,
-             'experiment' => experiment
+              'variation' => variation,
+              'experiment' => experiment
             }
           else
             @config.logger.log(
-             Logger::INFO,
-             "The user '#{user_id}' is not bucketed into any of the experiments on the feature '#{feature_flag_key}'."
+              Logger::INFO,
+              "The user '#{user_id}' is not bucketed into any of the experiments on the feature '#{feature_flag_key}'."
             )
           end
         end
       else
         @config.logger.log(
-         Logger::DEBUG,
-         "The feature flag '#{feature_flag_key}' is not used in any experiments."
+          Logger::DEBUG,
+          "The feature flag '#{feature_flag_key}' is not used in any experiments."
         )
       end
-      
+
       return nil
     end
-    
+
     def get_variation_for_feature_rollout(feature_flag, user_id, attributes = nil)
       # Determine which variation the user is in for a given rollout.
       # Returns the variation of the first experiment the user qualifies for.
@@ -222,110 +207,110 @@ module Optimizely
       # attributes - Hash representing user attributes
       #
       # Returns the variation the user is bucketed into or nil if not bucketed into any of the targeting rules
-      
+
       rollout_id = feature_flag['rolloutId']
+      feature_flag_key = feature_flag['key']
       if rollout_id.nil? or rollout_id.empty?
-        feature_flag_key = feature_flag['key']
         @config.logger.log(
-         Logger::DEBUG,
-         "Feature flag '#{feature_flag_key}' is not part of a rollout."
+          Logger::DEBUG,
+          "Feature flag '#{feature_flag_key}' is not part of a rollout."
         )
         return nil
       end
-      
+
       rollout = @config.get_rollout_from_id(rollout_id)
       unless rollout.nil? or rollout['experiments'].empty?
         rollout_experiments = rollout['experiments']
         number_of_rules = rollout_experiments.length - 1
-        
+
         # Go through each experiment in order and try to get the variation for the user
         for index in (0...number_of_rules)
           experiment = rollout_experiments[index]
           experiment_key = experiment['key']
-          
+
           # Check that user meets audience conditions for targeting rule
           unless Audience.user_in_experiment?(@config, experiment, attributes)
             @config.logger.log(
-             Logger::DEBUG,
-             "User '#{user_id}' does not meet the conditions to be in experiment '#{experiment_key}'."
+              Logger::DEBUG,
+              "User '#{user_id}' does not meet the conditions to be in experiment '#{experiment_key}' of rollout with feature flag '#{feature_flag_key}'."
             )
             # move onto the next targeting rule
             next
           end
-          
+
           @config.logger.log(
-           Logger::DEBUG,
-           "User '#{user_id}' meets conditions for targeting rule '#{index + 1}'."
+            Logger::DEBUG,
+            "User '#{user_id}' meets conditions for targeting rule '#{index + 1}'."
           )
           variation = @bucketer.bucket(experiment, user_id)
           unless variation.nil?
             variation_key = variation['key']
             return variation
           end
-          
+
           # User failed traffic allocation, jump to Everyone Else rule
           @config.logger.log(
-           Logger::DEBUG,
-           "User '#{user_id}' is not in the traffic group for the targeting rule. Checking 'Eveyrone Else' rule now."
+            Logger::DEBUG,
+            "User '#{user_id}' is not in the traffic group for the targeting rule. Checking 'Eveyrone Else' rule now."
           )
           break
         end
-        
+
         # Evalute the "Everyone Else" rule, which is the last rule.
         everyone_else_experiment = rollout_experiments[number_of_rules]
         variation = @bucketer.bucket(everyone_else_experiment, user_id)
         unless variation.nil?
           @config.logger.log(
-           Logger::DEBUG,
-           "User '#{user_id}' meets conditions for targeting rule 'Everyone Else'."
+            Logger::DEBUG,
+            "User '#{user_id}' meets conditions for targeting rule 'Everyone Else' of rollout with feature flag '#{feature_flag_key}'."
           )
           return variation
         end
-        
+
         @config.logger.log(
-         Logger::DEBUG,
-         "User '#{user_id}' does not meet conditions for targeting rule 'Everyone Else'."
+          Logger::DEBUG,
+          "User '#{user_id}' does not meet conditions for targeting rule 'Everyone Else' of rollout with feature flag '#{feature_flag_key}'."
         )
       end
-      
+
       return nil
     end
-    
+
     private
-    
-    def get_whitelisted_variation_id(experiment_key, user_id)
-      # Determine if a user is whitelisted into a variation for the given experiment and return the ID of that variation
+
+    def get_forced_variation_id(experiment_key, user_id)
+      # Determine if a user is forced into a variation for the given experiment and return the ID of that variation
       #
       # experiment_key - Key representing the experiment for which user is to be bucketed
       # user_id - ID for the user
       #
-      # Returns variation ID into which user_id is whitelisted (nil if no variation)
-      
-      whitelisted_variations = @config.get_whitelisted_variations(experiment_key)
-      
-      return nil unless whitelisted_variations
-      
-      whitelisted_variation_key = whitelisted_variations[user_id]
-      
-      return nil unless whitelisted_variation_key
-      
-      whitelisted_variation_id = @config.get_variation_id_from_key(experiment_key, whitelisted_variation_key)
-      
-      unless whitelisted_variation_id
+      # Returns variation ID into which user_id is forced (nil if no variation)
+
+      forced_variations = @config.get_forced_variations(experiment_key)
+
+      return nil unless forced_variations
+
+      forced_variation_key = forced_variations[user_id]
+
+      return nil unless forced_variation_key
+
+      forced_variation_id = @config.get_variation_id_from_key(experiment_key, forced_variation_key)
+
+      unless forced_variation_id
         @config.logger.log(
-         Logger::INFO,
-         "User '#{user_id}' is whitelisted into variation '#{whitelisted_variation_key}', which is not in the datafile."
+          Logger::INFO,
+          "User '#{user_id}' is whitelisted into variation '#{forced_variation_key}', which is not in the datafile."
         )
         return nil
       end
-      
+
       @config.logger.log(
-       Logger::INFO,
-       "User '#{user_id}' is whitelisted into variation '#{whitelisted_variation_key}' of experiment '#{experiment_key}'."
+        Logger::INFO,
+        "User '#{user_id}' is whitelisted into variation '#{forced_variation_key}' of experiment '#{experiment_key}'."
       )
-      whitelisted_variation_id
+      forced_variation_id
     end
-    
+
     def get_saved_variation_id(experiment_id, user_profile)
       # Retrieve variation ID of stored bucketing decision for a given experiment from a given user profile
       #
@@ -334,56 +319,56 @@ module Optimizely
       #
       # Returns string variation ID (nil if no decision is found)
       return nil unless user_profile[:experiment_bucket_map]
-      
+
       decision = user_profile[:experiment_bucket_map][experiment_id]
       return nil unless decision
       variation_id = decision[:variation_id]
       return variation_id if @config.variation_id_exists?(experiment_id, variation_id)
-      
+
       @config.logger.log(
-       Logger::INFO,
-       "User '#{user_profile['user_id']}' was previously bucketed into variation ID '#{variation_id}' for experiment '#{experiment_id}', but no matching variation was found. Re-bucketing user."
+        Logger::INFO,
+        "User '#{user_profile['user_id']}' was previously bucketed into variation ID '#{variation_id}' for experiment '#{experiment_id}', but no matching variation was found. Re-bucketing user."
       )
       nil
     end
-    
+
     def get_user_profile(user_id)
       # Determine if a user is forced into a variation for the given experiment and return the ID of that variation
       #
       # user_id - String ID for the user
       #
       # Returns Hash stored user profile (or a default one if lookup fails or user profile service not provided)
-      
+
       user_profile = {
-       :user_id => user_id,
-       :experiment_bucket_map => {}
+        :user_id => user_id,
+        :experiment_bucket_map => {}
       }
-      
+
       return user_profile unless @user_profile_service
-      
+
       begin
         user_profile = @user_profile_service.lookup(user_id) || user_profile
       rescue => e
         @config.logger.log(Logger::ERROR, "Error while looking up user profile for user ID '#{user_id}': #{e}.")
       end
-      
+
       user_profile
     end
-    
-    
+
+
     def save_user_profile(user_profile, experiment_id, variation_id)
       # Save a given bucketing decision to a given user profile
       #
       # user_profile - Hash user profile
       # experiment_id - String experiment ID
       # variation_id - String variation ID
-      
+
       return unless @user_profile_service
-      
+
       user_id = user_profile[:user_id]
       begin
         user_profile[:experiment_bucket_map][experiment_id] = {
-         :variation_id => variation_id
+          :variation_id => variation_id
         }
         @user_profile_service.save(user_profile)
         @config.logger.log(Logger::INFO, "Saved variation ID #{variation_id} of experiment ID #{experiment_id} for user '#{user_id}'.")
@@ -392,4 +377,4 @@ module Optimizely
       end
     end
   end
-end
+end