optimizely-sdk 3.1.1 → 3.2.0

data/lib/optimizely/config_manager/async_scheduler.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+#
+#    Copyright 2019, 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 AsyncScheduler
+    attr_reader :running
+
+    def initialize(callback, interval, auto_update, logger = nil)
+      # Sets up AsyncScheduler to execute a callback periodically.
+      #
+      # callback - Main function to be executed periodically.
+      # interval - How many seconds to wait between executions.
+      # auto_update - boolean indicates to run infinitely or only once.
+      # logger - Optional Provides a logger instance.
+
+      @callback = callback
+      @interval = interval
+      @auto_update = auto_update
+      @running = false
+      @thread = nil
+      @logger = logger || NoOpLogger.new
+    end
+
+    def start!
+      # Starts the async scheduler.
+
+      if @running
+        @logger.log(
+          Logger::WARN,
+          'Scheduler is already running. Ignoring .start() call.'
+        )
+        return
+      end
+
+      begin
+        @running = true
+        @thread = Thread.new { execution_wrapper(@callback) }
+      rescue StandardError => e
+        @logger.log(
+          Logger::ERROR,
+          "Couldn't create a new thread for async scheduler. #{e.message}"
+        )
+      end
+    end
+
+    def stop!
+      # Stops the async scheduler.
+
+      # If the scheduler is not running do nothing.
+      return unless @running
+
+      @running = false
+      @thread.exit
+    end
+
+    private
+
+    def execution_wrapper(callback)
+      # Executes the given callback periodically
+
+      loop do
+        begin
+          callback.call
+        rescue
+          @logger.log(
+            Logger::ERROR,
+            'Something went wrong when running passed function.'
+          )
+          stop!
+        end
+        break unless @auto_update
+
+        sleep @interval
+      end
+    end
+  end
+end

data/lib/optimizely/config_manager/http_project_config_manager.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+#
+#    Copyright 2019, 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 '../config/datafile_project_config'
+require_relative '../error_handler'
+require_relative '../exceptions'
+require_relative '../helpers/constants'
+require_relative '../logger'
+require_relative '../notification_center'
+require_relative '../project_config'
+require_relative 'project_config_manager'
+require_relative 'async_scheduler'
+require 'httparty'
+require 'json'
+module Optimizely
+  class HTTPProjectConfigManager < ProjectConfigManager
+    # Config manager that polls for the datafile and updated ProjectConfig based on an update interval.
+
+    attr_reader :config
+
+    # Initialize config manager. One of sdk_key or url has to be set to be able to use.
+    #
+    # sdk_key - Optional string uniquely identifying the datafile. It's required unless a URL is passed in.
+    # datafile: Optional JSON string representing the project.
+    # polling_interval - Optional floating point number representing time interval in seconds
+    #                  at which to request datafile and set ProjectConfig.
+    # blocking_timeout -
+    # auto_update -
+    # start_by_default -
+    # url - Optional string representing URL from where to fetch the datafile. If set it supersedes the sdk_key.
+    # url_template - Optional string template which in conjunction with sdk_key
+    #               determines URL from where to fetch the datafile.
+    # logger - Provides a logger instance.
+    # error_handler - Provides a handle_error method to handle exceptions.
+    # skip_json_validation - Optional boolean param which allows skipping JSON schema
+    #                       validation upon object invocation. By default JSON schema validation will be performed.
+    def initialize(
+      sdk_key: nil,
+      url: nil,
+      url_template: nil,
+      polling_interval: nil,
+      blocking_timeout: nil,
+      auto_update: true,
+      start_by_default: true,
+      datafile: nil,
+      logger: nil,
+      error_handler: nil,
+      skip_json_validation: false,
+      notification_center: nil
+    )
+      @logger = logger || NoOpLogger.new
+      @error_handler = error_handler || NoOpErrorHandler.new
+      @datafile_url = get_datafile_url(sdk_key, url, url_template)
+      @polling_interval = nil
+      polling_interval(polling_interval)
+      @blocking_timeout = nil
+      blocking_timeout(blocking_timeout)
+      @last_modified = nil
+      @async_scheduler = AsyncScheduler.new(method(:fetch_datafile_config), @polling_interval, auto_update, @logger)
+      @async_scheduler.start! if start_by_default == true
+      @skip_json_validation = skip_json_validation
+      @notification_center = notification_center.is_a?(Optimizely::NotificationCenter) ? notification_center : NotificationCenter.new(@logger, @error_handler)
+      @config = datafile.nil? ? nil : DatafileProjectConfig.create(datafile, @logger, @error_handler, @skip_json_validation)
+      @mutex = Mutex.new
+      @resource = ConditionVariable.new
+    end
+
+    def ready?
+      !@config.nil?
+    end
+
+    def start!
+      @async_scheduler.start!
+    end
+
+    def stop!
+      @async_scheduler.stop!
+    end
+
+    def get_config
+      # Get Project Config.
+
+      # If the background datafile polling thread is running. and config has been initalized,
+      # we simply return config.
+      # If it is not, we wait and block maximum for @blocking_timeout.
+      # If thread is not running, we fetch the datafile and update config.
+      if @async_scheduler.running
+        return @config if ready?
+
+        @mutex.synchronize do
+          @resource.wait(@mutex, @blocking_timeout)
+          return @config
+        end
+      end
+
+      fetch_datafile_config
+      @config
+    end
+
+    private
+
+    def fetch_datafile_config
+      # Fetch datafile, handle response and send notification on config update.
+      config = request_config
+      return unless config
+
+      set_config config
+    end
+
+    def request_config
+      @logger.log(
+        Logger::DEBUG,
+        "Fetching datafile from #{@datafile_url}"
+      )
+      begin
+        headers = {
+          'Content-Type' => 'application/json'
+        }
+
+        headers[Helpers::Constants::HTTP_HEADERS['LAST_MODIFIED']] = @last_modified if @last_modified
+
+        response = HTTParty.get(
+          @datafile_url,
+          headers: headers,
+          timeout: Helpers::Constants::CONFIG_MANAGER['REQUEST_TIMEOUT']
+        )
+      rescue StandardError => e
+        @logger.log(
+          Logger::ERROR,
+          "Fetching datafile from #{@datafile_url} failed. Error: #{e}"
+        )
+        return nil
+      end
+
+      # Leave datafile and config unchanged if it has not been modified.
+      if response.code == '304'
+        @logger.log(
+          Logger::DEBUG,
+          "Not updating config as datafile has not updated since #{@last_modified}."
+        )
+        return
+      end
+
+      @last_modified = response[Helpers::Constants::HTTP_HEADERS['LAST_MODIFIED']]
+
+      config = DatafileProjectConfig.create(response.body, @logger, @error_handler, @skip_json_validation) if response.body
+
+      config
+    end
+
+    def set_config(config)
+      # Send notification if project config is updated.
+      previous_revision = @config.revision if @config
+      return if previous_revision == config.revision
+
+      unless ready?
+        @config = config
+        @mutex.synchronize { @resource.signal }
+      end
+
+      @config = config
+
+      @notification_center.send_notifications(NotificationCenter::NOTIFICATION_TYPES[:OPTIMIZELY_CONFIG_UPDATE])
+
+      @logger.log(Logger::DEBUG, 'Received new datafile and updated config. ' \
+        "Old revision number: #{previous_revision}. New revision number: #{@config.revision}.")
+    end
+
+    def polling_interval(polling_interval)
+      # Sets frequency at which datafile has to be polled and ProjectConfig updated.
+      #
+      # polling_interval - Time in seconds after which to update datafile.
+
+      # If valid set given polling interval, default update interval otherwise.
+
+      if polling_interval.nil?
+        @logger.log(
+          Logger::DEBUG,
+          "Polling interval is not provided. Defaulting to #{Helpers::Constants::CONFIG_MANAGER['DEFAULT_UPDATE_INTERVAL']} seconds."
+        )
+        @polling_interval = Helpers::Constants::CONFIG_MANAGER['DEFAULT_UPDATE_INTERVAL']
+        return
+      end
+
+      unless polling_interval.is_a? Integer
+        @logger.log(
+          Logger::ERROR,
+          "Polling interval '#{polling_interval}' has invalid type. Defaulting to #{Helpers::Constants::CONFIG_MANAGER['DEFAULT_UPDATE_INTERVAL']} seconds."
+        )
+        @polling_interval = Helpers::Constants::CONFIG_MANAGER['DEFAULT_UPDATE_INTERVAL']
+        return
+      end
+
+      unless polling_interval.between?(Helpers::Constants::CONFIG_MANAGER['MIN_SECONDS_LIMIT'], Helpers::Constants::CONFIG_MANAGER['MAX_SECONDS_LIMIT'])
+        @logger.log(
+          Logger::DEBUG,
+          "Polling interval '#{polling_interval}' has invalid range. Defaulting to #{Helpers::Constants::CONFIG_MANAGER['DEFAULT_UPDATE_INTERVAL']} seconds."
+        )
+        @polling_interval = Helpers::Constants::CONFIG_MANAGER['DEFAULT_UPDATE_INTERVAL']
+        return
+      end
+
+      @polling_interval = polling_interval
+    end
+
+    def blocking_timeout(blocking_timeout)
+      # Sets time in seconds to block the get_config call until config has been initialized.
+      #
+      # blocking_timeout - Time in seconds after which to update datafile.
+
+      # If valid set given timeout, default blocking_timeout otherwise.
+
+      if blocking_timeout.nil?
+        @logger.log(
+          Logger::DEBUG,
+          "Blocking timeout is not provided. Defaulting to #{Helpers::Constants::CONFIG_MANAGER['DEFAULT_BLOCKING_TIMEOUT']} seconds."
+        )
+        @polling_interval = Helpers::Constants::CONFIG_MANAGER['DEFAULT_BLOCKING_TIMEOUT']
+        return
+      end
+
+      unless blocking_timeout.is_a? Integer
+        @logger.log(
+          Logger::ERROR,
+          "Blocking timeout '#{blocking_timeout}' has invalid type. Defaulting to #{Helpers::Constants::CONFIG_MANAGER['DEFAULT_BLOCKING_TIMEOUT']} seconds."
+        )
+        @polling_interval = Helpers::Constants::CONFIG_MANAGER['DEFAULT_BLOCKING_TIMEOUT']
+        return
+      end
+
+      unless blocking_timeout.between?(Helpers::Constants::CONFIG_MANAGER['MIN_SECONDS_LIMIT'], Helpers::Constants::CONFIG_MANAGER['MAX_SECONDS_LIMIT'])
+        @logger.log(
+          Logger::DEBUG,
+          "Blocking timeout '#{blocking_timeout}' has invalid range. Defaulting to #{Helpers::Constants::CONFIG_MANAGER['DEFAULT_BLOCKING_TIMEOUT']} seconds."
+        )
+        @polling_interval = Helpers::Constants::CONFIG_MANAGER['DEFAULT_BLOCKING_TIMEOUT']
+        return
+      end
+
+      @blocking_timeout = blocking_timeout
+    end
+
+    def get_datafile_url(sdk_key, url, url_template)
+      # Determines URL from where to fetch the datafile.
+      # sdk_key - Key uniquely identifying the datafile.
+      # url - String representing URL from which to fetch the datafile.
+      # url_template - String representing template which is filled in with
+      #               SDK key to determine URL from which to fetch the datafile.
+      # Returns String representing URL to fetch datafile from.
+      if sdk_key.nil? && url.nil?
+        @logger.log(Logger::ERROR, 'Must provide at least one of sdk_key or url.')
+        @error_handler.handle_error(InvalidInputsError)
+      end
+
+      unless url
+        url_template ||= Helpers::Constants::CONFIG_MANAGER['DATAFILE_URL_TEMPLATE']
+        begin
+          return (url_template % sdk_key)
+        rescue
+          @logger.log(Logger::ERROR, "Invalid url_template #{url_template} provided.")
+          @error_handler.handle_error(InvalidInputsError)
+        end
+      end
+
+      url
+    end
+  end
+end

data/lib/optimizely/config_manager/project_config_manager.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+#
+#    Copyright 2019, 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 ProjectConfigManager
+    # Interface for fetching ProjectConfig instance.
+
+    def config; end
+  end
+end

data/lib/optimizely/config_manager/static_project_config_manager.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+#
+#    Copyright 2019, 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 '../config/datafile_project_config'
+require_relative 'project_config_manager'
+module Optimizely
+  class StaticProjectConfigManager < ProjectConfigManager
+    # Implementation of ProjectConfigManager interface.
+    attr_reader :config
+
+    def initialize(datafile, logger, error_handler, skip_json_validation)
+      # Looks up and sets datafile and config based on response body.
+      #
+      # datafile - JSON string representing the Optimizely project.
+      # logger - Provides a logger instance.
+      # error_handler - Provides a handle_error method to handle exceptions.
+      # skip_json_validation - Optional boolean param which allows skipping JSON schema
+      #                       validation upon object invocation. By default JSON schema validation will be performed.
+      # Returns instance of DatafileProjectConfig, nil otherwise.
+      @config = DatafileProjectConfig.create(
+        datafile,
+        logger,
+        error_handler,
+        skip_json_validation
+      )
+    end
+  end
+end

data/lib/optimizely/decision_service.rb

@@ -32,7 +32,10 @@ module Optimizely
     # 6. Use Murmurhash3 to bucket the user
 
     attr_reader :bucketer
-    attr_reader :config
+
+    # Hash of user IDs to a Hash of experiments to variations.
+    # This contains all the forced variations set by the user by calling setForcedVariation.
+    attr_reader :forced_variation_map
 
     Decision = Struct.new(:experiment, :variation, :source)
 
@@ -41,15 +44,17 @@ module Optimizely
       'ROLLOUT' => 'rollout'
     }.freeze
 
-    def initialize(config, user_profile_service = nil)
-      @config = config
+    def initialize(logger, user_profile_service = nil)
+      @logger = logger
       @user_profile_service = user_profile_service
-      @bucketer = Bucketer.new(@config)
+      @bucketer = Bucketer.new(logger)
+      @forced_variation_map = {}
     end
 
-    def get_variation(experiment_key, user_id, attributes = nil)
+    def get_variation(project_config, experiment_key, user_id, attributes = nil)
       # Determines variation into which user will be bucketed.
       #
+      # project_config - project_config - Instance of ProjectConfig
       # experiment_key - Experiment for which visitor variation needs to be determined
       # user_id - String ID for user
       # attributes - Hash representing user attributes
@@ -60,28 +65,28 @@ module Optimizely
       # By default, the bucketing ID should be the user ID
       bucketing_id = get_bucketing_id(user_id, attributes)
       # Check to make sure experiment is active
-      experiment = @config.get_experiment_from_key(experiment_key)
+      experiment = project_config.get_experiment_from_key(experiment_key)
       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.")
+      unless project_config.experiment_running?(experiment)
+        @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)
+      forced_variation = get_forced_variation(project_config, 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)
+      whitelisted_variation_id = get_whitelisted_variation_id(project_config, 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)
+      saved_variation_id = get_saved_variation_id(project_config, experiment_id, user_profile)
       if saved_variation_id
-        @config.logger.log(
+        @logger.log(
           Logger::INFO,
           "Returning previously activated variation ID #{saved_variation_id} of experiment '#{experiment_key}' for user '#{user_id}' from user profile."
         )
@@ -89,8 +94,8 @@ module Optimizely
       end
 
       # Check audience conditions
-      unless Audience.user_in_experiment?(@config, experiment, attributes)
-        @config.logger.log(
+      unless Audience.user_in_experiment?(project_config, experiment, attributes, @logger)
+        @logger.log(
           Logger::INFO,
           "User '#{user_id}' does not meet the conditions to be in experiment '#{experiment_key}'."
         )
@@ -98,7 +103,7 @@ module Optimizely
       end
 
       # Bucket normally
-      variation = @bucketer.bucket(experiment, bucketing_id, user_id)
+      variation = @bucketer.bucket(project_config, experiment, bucketing_id, user_id)
       variation_id = variation ? variation['id'] : nil
 
       # Persist bucketing decision
@@ -106,9 +111,10 @@ module Optimizely
       variation_id
     end
 
-    def get_variation_for_feature(feature_flag, user_id, attributes = nil)
+    def get_variation_for_feature(project_config, feature_flag, user_id, attributes = nil)
       # Get the variation the user is bucketed into for the given FeatureFlag.
       #
+      # project_config - project_config - Instance of ProjectConfig
       # feature_flag - The feature flag the user wants to access
       # user_id - String ID for the user
       # attributes - Hash representing user attributes
@@ -116,19 +122,19 @@ module Optimizely
       # Returns Decision struct (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)
+      decision = get_variation_for_feature_experiment(project_config, feature_flag, user_id, attributes)
       return decision unless decision.nil?
 
       feature_flag_key = feature_flag['key']
-      decision = get_variation_for_feature_rollout(feature_flag, user_id, attributes)
+      decision = get_variation_for_feature_rollout(project_config, feature_flag, user_id, attributes)
       if decision
-        @config.logger.log(
+        @logger.log(
           Logger::INFO,
           "User '#{user_id}' is bucketed into a rollout for feature flag '#{feature_flag_key}'."
         )
         return decision
       end
-      @config.logger.log(
+      @logger.log(
         Logger::INFO,
         "User '#{user_id}' is not bucketed into a rollout for feature flag '#{feature_flag_key}'."
       )
@@ -136,9 +142,10 @@ module Optimizely
       nil
     end
 
-    def get_variation_for_feature_experiment(feature_flag, user_id, attributes = nil)
+    def get_variation_for_feature_experiment(project_config, feature_flag, user_id, attributes = nil)
       # Gets the variation the user is bucketed into for the feature flag's experiment.
       #
+      # project_config - project_config - Instance of ProjectConfig
       # feature_flag - The feature flag the user wants to access
       # user_id - String ID for the user
       # attributes - Hash representing user attributes
@@ -147,7 +154,7 @@ module Optimizely
       # or nil if the user is not bucketed into any of the experiments on the feature
       feature_flag_key = feature_flag['key']
       if feature_flag['experimentIds'].empty?
-        @config.logger.log(
+        @logger.log(
           Logger::DEBUG,
           "The feature flag '#{feature_flag_key}' is not used in any experiments."
         )
@@ -156,9 +163,9 @@ module Optimizely
 
       # Evaluate each experiment and return the first bucketed experiment variation
       feature_flag['experimentIds'].each do |experiment_id|
-        experiment = @config.experiment_id_map[experiment_id]
+        experiment = project_config.experiment_id_map[experiment_id]
         unless experiment
-          @config.logger.log(
+          @logger.log(
             Logger::DEBUG,
             "Feature flag experiment with ID '#{experiment_id}' is not in the datafile."
           )
@@ -166,19 +173,19 @@ module Optimizely
         end
 
         experiment_key = experiment['key']
-        variation_id = get_variation(experiment_key, user_id, attributes)
+        variation_id = get_variation(project_config, experiment_key, user_id, attributes)
 
         next unless variation_id
 
-        variation = @config.variation_id_map[experiment_key][variation_id]
-        @config.logger.log(
+        variation = project_config.variation_id_map[experiment_key][variation_id]
+        @logger.log(
           Logger::INFO,
           "The user '#{user_id}' is bucketed into experiment '#{experiment_key}' of feature '#{feature_flag_key}'."
         )
         return Decision.new(experiment, variation, DECISION_SOURCES['FEATURE_TEST'])
       end
 
-      @config.logger.log(
+      @logger.log(
         Logger::INFO,
         "The user '#{user_id}' is not bucketed into any of the experiments on the feature '#{feature_flag_key}'."
       )
@@ -186,10 +193,11 @@ module Optimizely
       nil
     end
 
-    def get_variation_for_feature_rollout(feature_flag, user_id, attributes = nil)
+    def get_variation_for_feature_rollout(project_config, 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.
       #
+      # project_config - project_config - Instance of ProjectConfig
       # feature_flag - The feature flag the user wants to access
       # user_id - String ID for the user
       # attributes - Hash representing user attributes
@@ -199,16 +207,16 @@ module Optimizely
       rollout_id = feature_flag['rolloutId']
       if rollout_id.nil? || rollout_id.empty?
         feature_flag_key = feature_flag['key']
-        @config.logger.log(
+        @logger.log(
           Logger::DEBUG,
           "Feature flag '#{feature_flag_key}' is not used in a rollout."
         )
         return nil
       end
 
-      rollout = @config.get_rollout_from_id(rollout_id)
+      rollout = project_config.get_rollout_from_id(rollout_id)
       if rollout.nil?
-        @config.logger.log(
+        @logger.log(
           Logger::DEBUG,
           "Rollout with ID '#{rollout_id}' is not in the datafile '#{feature_flag['key']}'"
         )
@@ -224,12 +232,12 @@ module Optimizely
       number_of_rules.times do |index|
         rollout_rule = rollout_rules[index]
         audience_id = rollout_rule['audienceIds'][0]
-        audience = @config.get_audience_from_id(audience_id)
+        audience = project_config.get_audience_from_id(audience_id)
         audience_name = audience['name']
 
         # Check that user meets audience conditions for targeting rule
-        unless Audience.user_in_experiment?(@config, rollout_rule, attributes)
-          @config.logger.log(
+        unless Audience.user_in_experiment?(project_config, rollout_rule, attributes, @logger)
+          @logger.log(
             Logger::DEBUG,
             "User '#{user_id}' does not meet the conditions to be in rollout rule for audience '#{audience_name}'."
           )
@@ -238,7 +246,7 @@ module Optimizely
         end
 
         # Evaluate if user satisfies the traffic allocation for this rollout rule
-        variation = @bucketer.bucket(rollout_rule, bucketing_id, user_id)
+        variation = @bucketer.bucket(project_config, rollout_rule, bucketing_id, user_id)
         return Decision.new(rollout_rule, variation, DECISION_SOURCES['ROLLOUT']) unless variation.nil?
 
         break
@@ -247,33 +255,114 @@ module Optimizely
       # get last rule which is the everyone else rule
       everyone_else_experiment = rollout_rules[number_of_rules]
       # Check that user meets audience conditions for last rule
-      unless Audience.user_in_experiment?(@config, everyone_else_experiment, attributes)
+      unless Audience.user_in_experiment?(project_config, everyone_else_experiment, attributes, @logger)
         audience_id = everyone_else_experiment['audienceIds'][0]
-        audience = @config.get_audience_from_id(audience_id)
+        audience = project_config.get_audience_from_id(audience_id)
         audience_name = audience['name']
-        @config.logger.log(
+        @logger.log(
           Logger::DEBUG,
           "User '#{user_id}' does not meet the conditions to be in rollout rule for audience '#{audience_name}'."
         )
         return nil
       end
-      variation = @bucketer.bucket(everyone_else_experiment, bucketing_id, user_id)
+      variation = @bucketer.bucket(project_config, everyone_else_experiment, bucketing_id, user_id)
       return Decision.new(everyone_else_experiment, variation, DECISION_SOURCES['ROLLOUT']) unless variation.nil?
 
       nil
     end
 
+    def set_forced_variation(project_config, experiment_key, user_id, variation_key)
+      # Sets a Hash of user IDs to a Hash of experiments to forced variations.
+      #
+      # project_config - Instance of ProjectConfig
+      # experiment_key - String Key for experiment
+      # user_id - String ID for user.
+      # variation_key - String Key for variation. If null, then clear the existing experiment-to-variation mapping
+      #
+      # Returns a boolean value that indicates if the set completed successfully
+
+      experiment = project_config.get_experiment_from_key(experiment_key)
+      experiment_id = experiment['id'] if experiment
+      #  check if the experiment exists in the datafile
+      return false if experiment_id.nil? || experiment_id.empty?
+
+      #  clear the forced variation if the variation key is null
+      if variation_key.nil?
+        @forced_variation_map[user_id].delete(experiment_id) if @forced_variation_map.key? user_id
+        @logger.log(Logger::DEBUG, "Variation mapped to experiment '#{experiment_key}' has been removed for user "\
+                    "'#{user_id}'.")
+        return true
+      end
+
+      variation_id = project_config.get_variation_id_from_key(experiment_key, variation_key)
+
+      #  check if the variation exists in the datafile
+      unless variation_id
+        #  this case is logged in get_variation_id_from_key
+        return false
+      end
+
+      @forced_variation_map[user_id] = {} unless @forced_variation_map.key? user_id
+      @forced_variation_map[user_id][experiment_id] = variation_id
+      @logger.log(Logger::DEBUG, "Set variation '#{variation_id}' for experiment '#{experiment_id}' and "\
+                  "user '#{user_id}' in the forced variation map.")
+      true
+    end
+
+    def get_forced_variation(project_config, experiment_key, user_id)
+      # Gets the forced variation for the given user and experiment.
+      #
+      # project_config - Instance of ProjectConfig
+      # experiment_key - String Key for experiment
+      # user_id - String ID for user
+      #
+      # Returns Variation The variation which the given user and experiment should be forced into
+
+      unless @forced_variation_map.key? user_id
+        @logger.log(Logger::DEBUG, "User '#{user_id}' is not in the forced variation map.")
+        return nil
+      end
+
+      experiment_to_variation_map = @forced_variation_map[user_id]
+      experiment = project_config.get_experiment_from_key(experiment_key)
+      experiment_id = experiment['id'] if experiment
+      # check for nil and empty string experiment ID
+      # this case is logged in get_experiment_from_key
+      return nil if experiment_id.nil? || experiment_id.empty?
+
+      unless experiment_to_variation_map.key? experiment_id
+        @logger.log(Logger::DEBUG, "No experiment '#{experiment_key}' mapped to user '#{user_id}' "\
+                    'in the forced variation map.')
+        return nil
+      end
+
+      variation_id = experiment_to_variation_map[experiment_id]
+      variation_key = ''
+      variation = project_config.get_variation_from_id(experiment_key, variation_id)
+      variation_key = variation['key'] if variation
+
+      # check if the variation exists in the datafile
+      # this case is logged in get_variation_from_id
+      return nil if variation_key.empty?
+
+      @logger.log(Logger::DEBUG, "Variation '#{variation_key}' is mapped to experiment '#{experiment_key}' "\
+                  "and user '#{user_id}' in the forced variation map")
+
+      variation
+    end
+
     private
 
-    def get_whitelisted_variation_id(experiment_key, user_id)
+    def get_whitelisted_variation_id(project_config, experiment_key, user_id)
       # Determine if a user is whitelisted into a variation for the given experiment and return the ID of that variation
       #
+      # project_config - project_config - Instance of ProjectConfig
       # 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)
+      whitelisted_variations = project_config.get_whitelisted_variations(experiment_key)
 
       return nil unless whitelisted_variations
 
@@ -281,26 +370,27 @@ module Optimizely
 
       return nil unless whitelisted_variation_key
 
-      whitelisted_variation_id = @config.get_variation_id_from_key(experiment_key, whitelisted_variation_key)
+      whitelisted_variation_id = project_config.get_variation_id_from_key(experiment_key, whitelisted_variation_key)
 
       unless whitelisted_variation_id
-        @config.logger.log(
+        @logger.log(
           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.log(
         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)
+    def get_saved_variation_id(project_config, experiment_id, user_profile)
       # Retrieve variation ID of stored bucketing decision for a given experiment from a given user profile
       #
+      # project_config - project_config - Instance of ProjectConfig
       # experiment_id - String experiment ID
       # user_profile - Hash user profile
       #
@@ -311,9 +401,9 @@ module Optimizely
       return nil unless decision
 
       variation_id = decision[:variation_id]
-      return variation_id if @config.variation_id_exists?(experiment_id, variation_id)
+      return variation_id if project_config.variation_id_exists?(experiment_id, variation_id)
 
-      @config.logger.log(
+      @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."
       )
@@ -337,7 +427,7 @@ module Optimizely
       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}.")
+        @logger.log(Logger::ERROR, "Error while looking up user profile for user ID '#{user_id}': #{e}.")
       end
 
       user_profile
@@ -358,9 +448,9 @@ module Optimizely
           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}'.")
+        @logger.log(Logger::INFO, "Saved variation ID #{variation_id} of experiment ID #{experiment_id} for user '#{user_id}'.")
       rescue => e
-        @config.logger.log(Logger::ERROR, "Error while saving user profile for user ID '#{user_id}': #{e}.")
+        @logger.log(Logger::ERROR, "Error while saving user profile for user ID '#{user_id}': #{e}.")
       end
     end
 
@@ -378,7 +468,7 @@ module Optimizely
       if bucketing_id
         return bucketing_id if bucketing_id.is_a?(String)
 
-        @config.logger.log(Logger::WARN, 'Bucketing ID attribute is not a string. Defaulted to user ID.')
+        @logger.log(Logger::WARN, 'Bucketing ID attribute is not a string. Defaulted to user ID.')
       end
       user_id
     end