optimizely-sdk 3.1.1 → 3.2.0

data/lib/optimizely/event_builder.rb

@@ -48,26 +48,16 @@ module Optimizely
   class BaseEventBuilder
     CUSTOM_ATTRIBUTE_FEATURE_TYPE = 'custom'
 
-    attr_reader :config
-    attr_reader :logger
-
-    def initialize(config, logger)
-      @config = config
+    def initialize(logger)
       @logger = logger
     end
 
     private
 
-    def bot_filtering
-      # Get bot filtering bool
-      #
-      # Returns 'botFiltering' value in the datafile.
-      @config.bot_filtering
-    end
-
-    def get_common_params(user_id, attributes)
+    def get_common_params(project_config, user_id, attributes)
       # Get params which are used in both conversion and impression events.
       #
+      # project_config - +Object+ Instance of ProjectConfig
       # user_id -    +String+ ID for user
       # attributes - +Hash+ representing user attributes and values which need to be recorded.
       #
@@ -79,7 +69,7 @@ module Optimizely
         # Omit attribute values that are not supported by the log endpoint.
         attribute_value = attributes[attribute_key]
         if Helpers::Validator.attribute_valid?(attribute_key, attribute_value)
-          attribute_id = @config.get_attribute_id attribute_key
+          attribute_id = project_config.get_attribute_id attribute_key
           if attribute_id
             visitor_attributes.push(
               entity_id: attribute_id,
@@ -91,18 +81,18 @@ module Optimizely
         end
       end
       # Append Bot Filtering Attribute
-      if bot_filtering == true || bot_filtering == false
+      if project_config.bot_filtering == true || project_config.bot_filtering == false
         visitor_attributes.push(
           entity_id: Optimizely::Helpers::Constants::CONTROL_ATTRIBUTES['BOT_FILTERING'],
           key: Optimizely::Helpers::Constants::CONTROL_ATTRIBUTES['BOT_FILTERING'],
           type: CUSTOM_ATTRIBUTE_FEATURE_TYPE,
-          value: bot_filtering
+          value: project_config.bot_filtering
         )
       end
 
       common_params = {
-        account_id: @config.account_id,
-        project_id: @config.project_id,
+        account_id: project_config.account_id,
+        project_id: project_config.project_id,
         visitors: [
           {
             attributes: visitor_attributes,
@@ -110,8 +100,8 @@ module Optimizely
             visitor_id: user_id
           }
         ],
-        anonymize_ip: @config.anonymize_ip,
-        revision: @config.revision,
+        anonymize_ip: project_config.anonymize_ip,
+        revision: project_config.revision,
         client_name: CLIENT_ENGINE,
         enrich_decisions: true,
         client_version: VERSION
@@ -126,9 +116,10 @@ module Optimizely
     POST_HEADERS = {'Content-Type' => 'application/json'}.freeze
     ACTIVATE_EVENT_KEY = 'campaign_activated'
 
-    def create_impression_event(experiment, variation_id, user_id, attributes)
+    def create_impression_event(project_config, experiment, variation_id, user_id, attributes)
       # Create impression Event to be sent to the logging endpoint.
       #
+      # project_config - +Object+ Instance of ProjectConfig
       # experiment -   +Object+ Experiment for which impression needs to be recorded.
       # variation_id - +String+ ID for variation which would be presented to user.
       # user_id -      +String+ ID for user.
@@ -136,16 +127,17 @@ module Optimizely
       #
       # Returns +Event+ encapsulating the impression event.
 
-      event_params = get_common_params(user_id, attributes)
-      impression_params = get_impression_params(experiment, variation_id)
+      event_params = get_common_params(project_config, user_id, attributes)
+      impression_params = get_impression_params(project_config, experiment, variation_id)
       event_params[:visitors][0][:snapshots].push(impression_params)
 
       Event.new(:post, ENDPOINT, event_params, POST_HEADERS)
     end
 
-    def create_conversion_event(event, user_id, attributes, event_tags)
+    def create_conversion_event(project_config, event, user_id, attributes, event_tags)
       # Create conversion Event to be sent to the logging endpoint.
       #
+      # project_config -           +Object+ Instance of ProjectConfig
       # event -                    +Object+ Event which needs to be recorded.
       # user_id -                  +String+ ID for user.
       # attributes -               +Hash+ representing user attributes and values which need to be recorded.
@@ -153,7 +145,7 @@ module Optimizely
       #
       # Returns +Event+ encapsulating the conversion event.
 
-      event_params = get_common_params(user_id, attributes)
+      event_params = get_common_params(project_config, user_id, attributes)
       conversion_params = get_conversion_params(event, event_tags)
       event_params[:visitors][0][:snapshots] = [conversion_params]
 
@@ -162,9 +154,10 @@ module Optimizely
 
     private
 
-    def get_impression_params(experiment, variation_id)
+    def get_impression_params(project_config, experiment, variation_id)
       # Creates object of params specific to impression events
       #
+      # project_config - +Object+ Instance of ProjectConfig
       # experiment -   +Hash+ experiment for which impression needs to be recorded
       # variation_id - +string+ ID for variation which would be presented to user
       #
@@ -175,12 +168,12 @@ module Optimizely
 
       impression_event_params = {
         decisions: [{
-          campaign_id: @config.experiment_key_map[experiment_key]['layerId'],
+          campaign_id: project_config.experiment_key_map[experiment_key]['layerId'],
           experiment_id: experiment_id,
           variation_id: variation_id
         }],
         events: [{
-          entity_id: @config.experiment_key_map[experiment_key]['layerId'],
+          entity_id: project_config.experiment_key_map[experiment_key]['layerId'],
           timestamp: create_timestamp,
           key: ACTIVATE_EVENT_KEY,
           uuid: create_uuid

data/lib/optimizely/exceptions.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #
-#    Copyright 2016-2018, Optimizely and contributors
+#    Copyright 2016-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.
@@ -105,4 +105,20 @@ module Optimizely
       super
     end
   end
+
+  class InvalidInputsError < Error
+    # Raised when an invalid inputs are provided during Project instantiation
+
+    def initialize(msg)
+      super msg
+    end
+  end
+
+  class InvalidProjectConfigError < Error
+    # Raised when a public method fails due to an invalid datafile
+
+    def initialize(aborted_method)
+      super("Optimizely instance is not valid. Failing '#{aborted_method}'.")
+    end
+  end
 end

data/lib/optimizely/helpers/constants.rb

@@ -359,6 +359,25 @@ module Optimizely
         'FEATURE_TEST' => 'feature-test',
         'FEATURE_VARIABLE' => 'feature-variable'
       }.freeze
+
+      CONFIG_MANAGER = {
+        'DATAFILE_URL_TEMPLATE' => 'https://cdn.optimizely.com/datafiles/%s.json',
+        # Default time in seconds to block the get_config call until config has been initialized.
+        'DEFAULT_BLOCKING_TIMEOUT' => 15,
+        # Default config update interval of 5 minutes
+        'DEFAULT_UPDATE_INTERVAL' => 5 * 60,
+        # Maximum update interval or blocking timeout: 30 days
+        'MAX_SECONDS_LIMIT' => 2_592_000,
+        # Minimum update interval or blocking timeout: 1 second
+        'MIN_SECONDS_LIMIT' => 1,
+        # Time in seconds before which request for datafile times out
+        'REQUEST_TIMEOUT' => 10
+      }.freeze
+
+      HTTP_HEADERS = {
+        'IF_MODIFIED_SINCE' => 'If-Modified-Since',
+        'LAST_MODIFIED' => 'Last-Modified'
+      }.freeze
     end
   end
 end

data/lib/optimizely/notification_center.rb

@@ -24,6 +24,7 @@ module Optimizely
       # DEPRECATED: ACTIVATE notification type is deprecated since relase 3.1.0.
       ACTIVATE: 'ACTIVATE: experiment, user_id, attributes, variation, event',
       DECISION: 'DECISION: type, user_id, attributes, decision_info',
+      OPTIMIZELY_CONFIG_UPDATE: 'optimizely_config_update',
       TRACK: 'TRACK: event_key, user_id, attributes, event_tags, event'
     }.freeze
 

data/lib/optimizely/optimizely_factory.rb

@@ -0,0 +1,73 @@
+# 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 'optimizely'
+module Optimizely
+  class OptimizelyFactory
+    # Returns a new optimizely instance.
+    #
+    # @params sdk_key - Required String uniquely identifying the fallback datafile corresponding to project.
+    # @param fallback datafile - Optional JSON string datafile.
+    def self.default_instance(sdk_key, datafile = nil)
+      Optimizely::Project.new(datafile, nil, nil, nil, nil, nil, sdk_key)
+    end
+
+    # Returns a new optimizely instance.
+    #
+    # @param config_manager - Required ConfigManagerInterface Responds to get_config.
+    def self.default_instance_with_config_manager(config_manager)
+      Optimizely::Project.new(nil, nil, nil, nil, nil, nil, nil, config_manager)
+    end
+
+    # Returns a new optimizely instance.
+    #
+    # @params sdk_key - Required String uniquely identifying the datafile corresponding to project.
+    # @param fallback datafile - Optional JSON string datafile.
+    # @param event_dispatcher - Optional EventDispatcherInterface Provides a dispatch_event method which if given a URL and params sends a request to it.
+    # @param logger - Optional LoggerInterface Provides a log method to log messages. By default nothing would be logged.
+    # @param error_handler - Optional ErrorHandlerInterface which provides a handle_error method to handle exceptions.
+    #                 By default all exceptions will be suppressed.
+    # @param skip_json_validation - Optional Boolean param to skip JSON schema validation of the provided datafile.
+    # @param user_profile_service - Optional UserProfileServiceInterface Provides methods to store and retreive user profiles.
+    # @param config_manager - Optional ConfigManagerInterface Responds to get_config.
+    # @param notification_center - Optional Instance of NotificationCenter.
+    def self.custom_instance(
+      sdk_key,
+      datafile = nil,
+      event_dispatcher = nil,
+      logger = nil,
+      error_handler = nil,
+      skip_json_validation = false,
+      user_profile_service = nil,
+      config_manager = nil,
+      notification_center = nil
+    )
+      Optimizely::Project.new(
+        datafile,
+        event_dispatcher,
+        logger,
+        error_handler,
+        skip_json_validation,
+        user_profile_service,
+        sdk_key,
+        config_manager,
+        notification_center
+      )
+    end
+  end
+end

data/lib/optimizely/project_config.rb

@@ -14,469 +14,64 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 #
-require 'json'
-require_relative 'helpers/constants'
-require_relative 'helpers/validator'
 
 module Optimizely
   class ProjectConfig
-    # Representation of the Optimizely project config.
-    RUNNING_EXPERIMENT_STATUS = ['Running'].freeze
-    RESERVED_ATTRIBUTE_PREFIX = '$opt_'
+    # ProjectConfig is an interface capturing the experiment, variation and feature definitions.
+    # The default implementation of ProjectConfig can be found in DatafileProjectConfig.
 
-    # Gets project config attributes.
-    attr_reader :error_handler
-    attr_reader :logger
+    def account_id; end
 
-    attr_reader :account_id
-    attr_reader :attributes
-    attr_reader :audiences
-    attr_reader :typed_audiences
-    attr_reader :events
-    attr_reader :experiments
-    attr_reader :feature_flags
-    attr_reader :groups
-    attr_reader :project_id
-    # Boolean - denotes if Optimizely should remove the last block of visitors' IP address before storing event data
-    attr_reader :anonymize_ip
-    attr_reader :bot_filtering
-    attr_reader :revision
-    attr_reader :rollouts
-    attr_reader :version
+    def attributes; end
 
-    attr_reader :attribute_key_map
-    attr_reader :audience_id_map
-    attr_reader :event_key_map
-    attr_reader :experiment_feature_map
-    attr_reader :experiment_id_map
-    attr_reader :experiment_key_map
-    attr_reader :feature_flag_key_map
-    attr_reader :feature_variable_key_map
-    attr_reader :group_key_map
-    attr_reader :rollout_id_map
-    attr_reader :rollout_experiment_key_map
-    attr_reader :variation_id_map
-    attr_reader :variation_id_to_variable_usage_map
-    attr_reader :variation_key_map
+    def audiences; end
 
-    # Hash of user IDs to a Hash
-    # of experiments to variations. This contains all the forced variations
-    # set by the user by calling setForcedVariation (it is not the same as the
-    # whitelisting forcedVariations data structure in the Experiments class).
-    attr_reader :forced_variation_map
+    def typed_audiences; end
 
-    def initialize(datafile, logger, error_handler)
-      # ProjectConfig init method to fetch and set project config data
-      #
-      # datafile - JSON string representing the project
+    def events; end
 
-      config = JSON.parse(datafile)
+    def experiments; end
 
-      @error_handler = error_handler
-      @logger = logger
-      @version = config['version']
+    def feature_flags; end
 
-      raise InvalidDatafileVersionError, @version unless Helpers::Constants::SUPPORTED_VERSIONS.value?(@version)
+    def groups; end
 
-      @account_id = config['accountId']
-      @attributes = config.fetch('attributes', [])
-      @audiences = config.fetch('audiences', [])
-      @typed_audiences = config.fetch('typedAudiences', [])
-      @events = config.fetch('events', [])
-      @experiments = config['experiments']
-      @feature_flags = config.fetch('featureFlags', [])
-      @groups = config.fetch('groups', [])
-      @project_id = config['projectId']
-      @anonymize_ip = config.key?('anonymizeIP') ? config['anonymizeIP'] : false
-      @bot_filtering = config['botFiltering']
-      @revision = config['revision']
-      @rollouts = config.fetch('rollouts', [])
+    def project_id; end
 
-      # Utility maps for quick lookup
-      @attribute_key_map = generate_key_map(@attributes, 'key')
-      @event_key_map = generate_key_map(@events, 'key')
-      @group_key_map = generate_key_map(@groups, 'id')
-      @group_key_map.each do |key, group|
-        exps = group.fetch('experiments')
-        exps.each do |exp|
-          @experiments.push(exp.merge('groupId' => key))
-        end
-      end
-      @experiment_key_map = generate_key_map(@experiments, 'key')
-      @experiment_id_map = generate_key_map(@experiments, 'id')
-      @audience_id_map = generate_key_map(@audiences, 'id')
-      @audience_id_map = @audience_id_map.merge(generate_key_map(@typed_audiences, 'id')) unless @typed_audiences.empty?
-      @variation_id_map = {}
-      @variation_key_map = {}
-      @forced_variation_map = {}
-      @variation_id_to_variable_usage_map = {}
-      @variation_id_to_experiment_map = {}
-      @experiment_key_map.each_value do |exp|
-        # Excludes experiments from rollouts
-        variations = exp.fetch('variations')
-        variations.each do |variation|
-          variation_id = variation['id']
-          @variation_id_to_experiment_map[variation_id] = exp
-        end
-      end
-      @rollout_id_map = generate_key_map(@rollouts, 'id')
-      # split out the experiment key map for rollouts
-      @rollout_experiment_key_map = {}
-      @rollout_id_map.each_value do |rollout|
-        exps = rollout.fetch('experiments')
-        @rollout_experiment_key_map = @rollout_experiment_key_map.merge(generate_key_map(exps, 'key'))
-      end
-      @all_experiments = @experiment_key_map.merge(@rollout_experiment_key_map)
-      @all_experiments.each do |key, exp|
-        variations = exp.fetch('variations')
-        variations.each do |variation|
-          variation_id = variation['id']
-          variation['featureEnabled'] = variation['featureEnabled'] == true
-          variation_variables = variation['variables']
-          next if variation_variables.nil?
+    def anonymize_ip; end
 
-          @variation_id_to_variable_usage_map[variation_id] = generate_key_map(variation_variables, 'id')
-        end
-        @variation_id_map[key] = generate_key_map(variations, 'id')
-        @variation_key_map[key] = generate_key_map(variations, 'key')
-      end
-      @feature_flag_key_map = generate_key_map(@feature_flags, 'key')
-      @experiment_feature_map = {}
-      @feature_variable_key_map = {}
-      @feature_flag_key_map.each do |key, feature_flag|
-        @feature_variable_key_map[key] = generate_key_map(feature_flag['variables'], 'key')
-        feature_flag['experimentIds'].each do |experiment_id|
-          @experiment_feature_map[experiment_id] = [feature_flag['id']]
-        end
-      end
-    end
+    def bot_filtering; end
 
-    def experiment_running?(experiment)
-      # Determine if experiment corresponding to given key is running
-      #
-      # experiment - Experiment
-      #
-      # Returns true if experiment is running
-      RUNNING_EXPERIMENT_STATUS.include?(experiment['status'])
-    end
+    def revision; end
 
-    def get_experiment_from_key(experiment_key)
-      # Retrieves experiment ID for a given key
-      #
-      # experiment_key - String key representing the experiment
-      #
-      # Returns Experiment or nil if not found
+    def rollouts; end
 
-      experiment = @experiment_key_map[experiment_key]
-      return experiment if experiment
+    def experiment_running?(experiment); end
 
-      @logger.log Logger::ERROR, "Experiment key '#{experiment_key}' is not in datafile."
-      @error_handler.handle_error InvalidExperimentError
-      nil
-    end
+    def get_experiment_from_key(experiment_key); end
 
-    def get_experiment_key(experiment_id)
-      # Retrieves experiment key for a given ID.
-      #
-      # experiment_id - String ID representing the experiment.
-      #
-      # Returns String key.
+    def get_experiment_key(experiment_id); end
 
-      experiment = @experiment_id_map[experiment_id]
-      return experiment['key'] unless experiment.nil?
+    def get_event_from_key(event_key); end
 
-      @logger.log Logger::ERROR, "Experiment id '#{experiment_id}' is not in datafile."
-      @error_handler.handle_error InvalidExperimentError
-      nil
-    end
+    def get_audience_from_id(audience_id); end
 
-    def get_event_from_key(event_key)
-      # Get event for the provided event key.
-      #
-      # event_key - Event key for which event is to be determined.
-      #
-      # Returns Event corresponding to the provided event key.
+    def get_variation_from_id(experiment_key, variation_id); end
 
-      event = @event_key_map[event_key]
-      return event if event
+    def get_variation_id_from_key(experiment_key, variation_key); end
 
-      @logger.log Logger::ERROR, "Event '#{event_key}' is not in datafile."
-      @error_handler.handle_error InvalidEventError
-      nil
-    end
+    def get_whitelisted_variations(experiment_key); end
 
-    def get_audience_from_id(audience_id)
-      # Get audience for the provided audience ID
-      #
-      # audience_id - ID of the audience
-      #
-      # Returns the audience
+    def get_attribute_id(attribute_key); end
 
-      audience = @audience_id_map[audience_id]
-      return audience if audience
+    def variation_id_exists?(experiment_id, variation_id); end
 
-      @logger.log Logger::ERROR, "Audience '#{audience_id}' is not in datafile."
-      @error_handler.handle_error InvalidAudienceError
-      nil
-    end
+    def get_feature_flag_from_key(feature_flag_key); end
 
-    def get_variation_from_id(experiment_key, variation_id)
-      # Get variation given experiment key and variation ID
-      #
-      # experiment_key - Key representing parent experiment of variation
-      # variation_id - ID of the variation
-      #
-      # Returns the variation or nil if not found
+    def get_feature_variable(feature_flag, variable_key); end
 
-      variation_id_map = @variation_id_map[experiment_key]
-      if variation_id_map
-        variation = variation_id_map[variation_id]
-        return variation if variation
+    def get_rollout_from_id(rollout_id); end
 
-        @logger.log Logger::ERROR, "Variation id '#{variation_id}' is not in datafile."
-        @error_handler.handle_error InvalidVariationError
-        return nil
-      end
-
-      @logger.log Logger::ERROR, "Experiment key '#{experiment_key}' is not in datafile."
-      @error_handler.handle_error InvalidExperimentError
-      nil
-    end
-
-    def get_variation_id_from_key(experiment_key, variation_key)
-      # Get variation ID given experiment key and variation key
-      #
-      # experiment_key - Key representing parent experiment of variation
-      # variation_key - Key of the variation
-      #
-      # Returns ID of the variation
-
-      variation_key_map = @variation_key_map[experiment_key]
-      if variation_key_map
-        variation = variation_key_map[variation_key]
-        return variation['id'] if variation
-
-        @logger.log Logger::ERROR, "Variation key '#{variation_key}' is not in datafile."
-        @error_handler.handle_error InvalidVariationError
-        return nil
-      end
-
-      @logger.log Logger::ERROR, "Experiment key '#{experiment_key}' is not in datafile."
-      @error_handler.handle_error InvalidExperimentError
-      nil
-    end
-
-    def get_whitelisted_variations(experiment_key)
-      # Retrieves whitelisted variations for a given experiment Key
-      #
-      # experiment_key - String Key representing the experiment
-      #
-      # Returns whitelisted variations for the experiment or nil
-
-      experiment = @experiment_key_map[experiment_key]
-      return experiment['forcedVariations'] if experiment
-
-      @logger.log Logger::ERROR, "Experiment key '#{experiment_key}' is not in datafile."
-      @error_handler.handle_error InvalidExperimentError
-    end
-
-    def get_forced_variation(experiment_key, user_id)
-      # Gets the forced variation for the given user and experiment.
-      #
-      # 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.
-
-      return nil unless Optimizely::Helpers::Validator.inputs_valid?(
-        {
-          experiment_key: experiment_key,
-          user_id: user_id
-        }, @logger, Logger::DEBUG
-      )
-
-      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 = 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 = 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
-
-    def set_forced_variation(experiment_key, user_id, variation_key)
-      # Sets a Hash of user IDs to a Hash of experiments to forced variations.
-      #
-      # 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.
-
-      input_values = {experiment_key: experiment_key, user_id: user_id}
-      input_values[:variation_key] = variation_key unless variation_key.nil?
-      return false unless Optimizely::Helpers::Validator.inputs_valid?(input_values, @logger, Logger::DEBUG)
-
-      experiment = 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 = 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_attribute_id(attribute_key)
-      # Get attribute ID for the provided attribute key.
-      #
-      # Args:
-      #   Attribute key for which attribute is to be fetched.
-      #
-      # Returns:
-      #   Attribute ID corresponding to the provided attribute key.
-      attribute = @attribute_key_map[attribute_key]
-      has_reserved_prefix = attribute_key.to_s.start_with?(RESERVED_ATTRIBUTE_PREFIX)
-      unless attribute.nil?
-        if has_reserved_prefix
-          @logger.log(Logger::WARN, "Attribute '#{attribute_key}' unexpectedly has reserved prefix '#{RESERVED_ATTRIBUTE_PREFIX}'; "\
-                      'using attribute ID instead of reserved attribute name.')
-        end
-        return attribute['id']
-      end
-      return attribute_key if has_reserved_prefix
-
-      @logger.log Logger::ERROR, "Attribute key '#{attribute_key}' is not in datafile."
-      @error_handler.handle_error InvalidAttributeError
-      nil
-    end
-
-    def variation_id_exists?(experiment_id, variation_id)
-      # Determines if a given experiment ID / variation ID pair exists in the datafile
-      #
-      # experiment_id - String experiment ID
-      # variation_id - String variation ID
-      #
-      # Returns true if variation is in datafile
-
-      experiment_key = get_experiment_key(experiment_id)
-      variation_id_map = @variation_id_map[experiment_key]
-      if variation_id_map
-        variation = variation_id_map[variation_id]
-        return true if variation
-
-        @logger.log Logger::ERROR, "Variation ID '#{variation_id}' is not in datafile."
-        @error_handler.handle_error InvalidVariationError
-      end
-
-      false
-    end
-
-    def get_feature_flag_from_key(feature_flag_key)
-      # Retrieves the feature flag with the given key
-      #
-      # feature_flag_key - String feature key
-      #
-      # Returns feature flag if found, otherwise nil
-      feature_flag = @feature_flag_key_map[feature_flag_key]
-      return feature_flag if feature_flag
-
-      @logger.log Logger::ERROR, "Feature flag key '#{feature_flag_key}' is not in datafile."
-      nil
-    end
-
-    def get_feature_variable(feature_flag, variable_key)
-      # Retrieves the variable with the given key for the given feature
-      #
-      # feature_flag - The feature flag for which we are retrieving the variable
-      # variable_key - String variable key
-      #
-      # Returns variable if found, otherwise nil
-      feature_flag_key = feature_flag['key']
-      variable = @feature_variable_key_map[feature_flag_key][variable_key]
-      return variable if variable
-
-      @logger.log Logger::ERROR, "No feature variable was found for key '#{variable_key}' in feature flag "\
-                  "'#{feature_flag_key}'."
-      nil
-    end
-
-    def get_rollout_from_id(rollout_id)
-      # Retrieves the rollout with the given ID
-      #
-      # rollout_id - String rollout ID
-      #
-      # Returns the rollout if found, otherwise nil
-      rollout = @rollout_id_map[rollout_id]
-      return rollout if rollout
-
-      @logger.log Logger::ERROR, "Rollout with ID '#{rollout_id}' is not in the datafile."
-      nil
-    end
-
-    def feature_experiment?(experiment_id)
-      # Determines if given experiment is a feature test.
-      #
-      # experiment_id - String experiment ID
-      #
-      # Returns true if experiment belongs to  any feature,
-      #              false otherwise.
-      @experiment_feature_map.key?(experiment_id)
-    end
-
-    private
-
-    def generate_key_map(array, key)
-      # Helper method to generate map from key to hash in array of hashes
-      #
-      # array - Array consisting of hash
-      # key - Key in each hash which will be key in the map
-      #
-      # Returns map mapping key to hash
-
-      Hash[array.map { |obj| [obj[key], obj] }]
-    end
+    def feature_experiment?(experiment_id); end
   end
 end