optimizely-sdk 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: '05059bf31a28b9a72a3f4ecb95808bf46671438b'
-  data.tar.gz: 481be969d392df0eb93bf8157f13d7625912d613
+  metadata.gz: 3fae777d6ce539eb2e0809dbf38d4784130c8ade
+  data.tar.gz: f65bee6796830490f4ee8f1a86da20ed7b4f01fb
 SHA512:
-  metadata.gz: 5f5099fc8956cdeec7add609b9c13ec2cb1f7e0524889c626001afb9c24ec456f642bcf2307da4114c0747b1714faa70861820d3e0ed9fcb901f164f5400034b
-  data.tar.gz: f327bb0d528621dbcddea84d7a0495e1ceec473a616d5ce3afb5a26386794a45452cf1ce83deca7f0d2f0bab0ed2af6dfa3e08a6ec5313558169c25c78a6772a
+  metadata.gz: b8e6f2732d692b1844d3f0c990010aba9858c93b82244803962810d33c78b945f925936874097272705a1a7e724f9d3abad1c4c66ba358573ba32c8bd10d8515
+  data.tar.gz: a8804feff56093f399f87425869a733e9b91b74f502b075a1d790364f47da5e524c36ecde23a626d2b8c977c344e5bd2fb5c93e742ceb5a2cfcf4a50710b9444

data/lib/optimizely.rb

@@ -19,9 +19,12 @@ require_relative 'optimizely/error_handler'
 require_relative 'optimizely/event_builder'
 require_relative 'optimizely/event_dispatcher'
 require_relative 'optimizely/exceptions'
+require_relative 'optimizely/helpers/constants'
 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
@@ -36,6 +39,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.
@@ -81,6 +85,7 @@ 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)
@@ -107,17 +112,8 @@ module Optimizely
       end
 
       # Create and dispatch impression event
-      variation_id = @config.get_variation_id_from_key(experiment_key, variation_key)
       experiment = @config.get_experiment_from_key(experiment_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])
-      begin
-        @event_dispatcher.dispatch_event(impression_event)
-      rescue => e
-        @logger.log(Logger::ERROR, "Unable to dispatch impression event. Error: #{e}")
-      end
+      send_impression(experiment, variation_key, user_id, attributes)
 
       variation_key
     end
@@ -151,7 +147,10 @@ module Optimizely
       variation_id = @decision_service.get_variation(experiment_key, user_id, attributes)
 
       unless variation_id.nil?
-        return @config.get_variation_key_from_id(experiment_key, variation_id)
+        variation = @config.get_variation_from_id(experiment_key, variation_id)
+        if variation
+          return variation['key']
+        end
       end
       nil
     end
@@ -235,10 +234,204 @@ 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)
+      # Determine whether a feature is enabled.
+      # Sends an impression event if the user is bucketed into an experiment using the feature.
+      #
+      # feature_flag_key - String unique key of the feature.
+      # userId - String ID of the user.
+      # attributes - Hash representing visitor attributes and values which need to be recorded.
+      #
+      # Returns True if the feature is enabled.
+      #         False if the feature is disabled.
+      #         False if the feature is not found.
+
+      unless @is_valid
+        logger = SimpleLogger.new
+        logger.log(Logger::ERROR, InvalidDatafileError.new('is_feature_enabled').message)
+        return nil
+      end
+
+      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)
+      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
+
+        @logger.log(Logger::INFO, "Feature '#{feature_flag_key}' is enabled for user '#{user_id}'.")
+        return true
+      end
+
+      @logger.log(Logger::INFO,
+                  "Feature '#{feature_flag_key}' is not enabled for user '#{user_id}'.")
+      false
+    end
+
+    def get_feature_variable_string(feature_flag_key, variable_key, user_id, attributes = nil)
+      # Get the String value of the specified variable in the feature flag.
+      #
+      # feature_flag_key - String key of feature flag the variable belongs to
+      # variable_key - String key of variable for which we are getting the string value
+      # user_id - String user ID
+      # attributes - Hash representing visitor attributes and values which need to be recorded.
+      #
+      # Returns the string variable value.
+      # Returns nil if the feature flag or variable are not found.
+
+      variable_value = get_feature_variable_for_type(
+        feature_flag_key,
+        variable_key,
+        Optimizely::Helpers::Constants::VARIABLE_TYPES["STRING"],
+        user_id,
+        attributes
+      )
+
+      return variable_value
+    end
+
+    def get_feature_variable_boolean(feature_flag_key, variable_key, user_id, attributes = nil)
+      # Get the Boolean value of the specified variable in the feature flag.
+      #
+      # feature_flag_key - String key of feature flag the variable belongs to
+      # variable_key - String key of variable for which we are getting the string value
+      # user_id - String user ID
+      # attributes - Hash representing visitor attributes and values which need to be recorded.
+      #
+      # Returns the boolean variable value.
+      # Returns nil if the feature flag or variable are not found.
+
+      variable_value = get_feature_variable_for_type(
+        feature_flag_key,
+        variable_key,
+        Optimizely::Helpers::Constants::VARIABLE_TYPES["BOOLEAN"],
+        user_id,
+        attributes
+      )
+
+      return variable_value
+    end
+
+    def get_feature_variable_double(feature_flag_key, variable_key, user_id, attributes = nil)
+      # Get the Double value of the specified variable in the feature flag.
+      #
+      # feature_flag_key - String key of feature flag the variable belongs to
+      # variable_key - String key of variable for which we are getting the string value
+      # user_id - String user ID
+      # attributes - Hash representing visitor attributes and values which need to be recorded.
+      #
+      # Returns the double variable value.
+      # Returns nil if the feature flag or variable are not found.
+
+      variable_value = get_feature_variable_for_type(
+        feature_flag_key,
+        variable_key,
+        Optimizely::Helpers::Constants::VARIABLE_TYPES["DOUBLE"],
+        user_id,
+        attributes
+      )
+
+      return variable_value
+    end
+
+    def get_feature_variable_integer(feature_flag_key, variable_key, user_id, attributes = nil)
+      # Get the Integer value of the specified variable in the feature flag.
+      #
+      # feature_flag_key - String key of feature flag the variable belongs to
+      # variable_key - String key of variable for which we are getting the string value
+      # user_id - String user ID
+      # attributes - Hash representing visitor attributes and values which need to be recorded.
+      #
+      # Returns the integer variable value.
+      # Returns nil if the feature flag or variable are not found.
+
+      variable_value = get_feature_variable_for_type(
+        feature_flag_key,
+        variable_key,
+        Optimizely::Helpers::Constants::VARIABLE_TYPES["INTEGER"],
+        user_id,
+        attributes
+      )
+
+      return variable_value
     end
 
     private
 
+    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.
+      #
+      # feature_flag_key - String key of feature flag the variable belongs to
+      # variable_key - String key of variable for which we are getting the string value
+      # variable_type - String requested type for feature variable
+      # user_id - String user ID
+      # 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.
+
+      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_value = nil
+      variable = @config.get_feature_variable(feature_flag, variable_key)
+      unless variable.nil?
+        variable_value = variable['defaultValue']
+
+        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
+          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
+            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}'.")
+          end
+        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)
+      end
+
+      return variable_value
+    end
+
     def get_valid_experiments_for_event(event_key, user_id, attributes)
       # Get the experiments that we should be tracking for the given event.
       #
@@ -313,5 +506,24 @@ module Optimizely
       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)
     end
+
+    def send_impression(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)
+      @logger.log(Logger::INFO,
+                  'Dispatching impression event to URL %s with params %s.' % [impression_event.url,
+                                                                              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/bucketer.rb

@@ -20,7 +20,7 @@ module Optimizely
   class Bucketer
     # Optimizely bucketing algorithm that evenly distributes visitors.
 
-    BUCKETING_ID_TEMPLATE = '%{user_id}%{entity_id}'
+    BUCKETING_ID_TEMPLATE = '%{bucketing_id}%{entity_id}'
     HASH_SEED = 1
     MAX_HASH_VALUE = 2**32
     MAX_TRAFFIC_VALUE = 10_000
@@ -35,13 +35,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 +53,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 +78,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 +98,18 @@ 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 = 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}'.")
 
       traffic_allocations.each do |traffic_allocation|
         current_end_of_range = traffic_allocation['endOfRange']
@@ -122,25 +124,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
+end

data/lib/optimizely/decision_service.rb

@@ -16,6 +16,9 @@
 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.
     #
@@ -28,16 +31,16 @@ module Optimizely
     # 4. Check user profile service for past bucketing decisions (sticky bucketing)
     # 5. Check audience targeting
     # 6. Use 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.
       #
@@ -46,58 +49,250 @@ 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)
-      if experiment.nil?
-        return nil
-      end
-
+      return nil if experiment.nil?
+      
       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 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, user_id)
+      variation = @bucketer.bucket(experiment, bucketing_id, 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.
+      #
+      # feature_flag - The feature flag the user wants to access
+      # user_id - String ID for the user
+      # 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?
+      
+      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}'."
+        )
+        # return decision with nil experiment so we don't track impressions for it
+        return {
+         'experiment' => nil,
+         'variation' => variation
+        }
+      else
+        @config.logger.log(
+         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.
+      #
+      # feature_flag - The feature flag the user wants to access
+      # user_id - String ID for the user
+      # attributes - Hash representing user attributes
+      #
+      # 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
+        experiment_id = feature_flag['experimentIds'][0]
+        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."
+          )
+          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)
+          group = @config.group_key_map[group_id]
+          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}'."
+            )
+            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']
+          variation_id = get_variation(experiment_key, user_id, attributes)
+          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}'."
+            )
+            return {
+             '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}'."
+            )
+          end
+        end
+      else
+        @config.logger.log(
+         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.
+      #
+      # feature_flag - The feature flag the user wants to access
+      # user_id - String ID for the user
+      # 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']
+      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."
+        )
+        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}'."
+            )
+            # move onto the next targeting rule
+            next
+          end
+          
+          @config.logger.log(
+           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."
+          )
+          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'."
+          )
+          return variation
+        end
+        
+        @config.logger.log(
+         Logger::DEBUG,
+         "User '#{user_id}' does not meet conditions for targeting rule 'Everyone Else'."
+        )
+      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
       #
@@ -105,32 +300,32 @@ module Optimizely
       # 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
         @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 '#{whitelisted_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 '#{whitelisted_variation_key}' of experiment '#{experiment_key}'."
       )
       whitelisted_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
       #
@@ -139,56 +334,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}'.")
@@ -197,4 +392,4 @@ module Optimizely
       end
     end
   end
-end
+end