optimizely-sdk 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 164c4cd46301497d6ad393c5ed49093f9e72d337
-  data.tar.gz: b52ca87752dc4aa840e53c4be5ce7583604eb044
+  metadata.gz: '05059bf31a28b9a72a3f4ecb95808bf46671438b'
+  data.tar.gz: 481be969d392df0eb93bf8157f13d7625912d613
 SHA512:
-  metadata.gz: dbdcbe648b51889c656578e8962c737380b0ab255be1941c5df48bdef9740c8e5e2d0aa2fd814f697e24197b36aaa8759f3882211059f7e2be55facfbd13e5e6
-  data.tar.gz: 064f914a6ddc35ae884b7d3563e7791da2d48030e292796422df5e5191a6de920959dfeca0d0a7bde6646f1ac6a1581526f0ed08df50084eb8da7d73f16b08aa
+  metadata.gz: 5f5099fc8956cdeec7add609b9c13ec2cb1f7e0524889c626001afb9c24ec456f642bcf2307da4114c0747b1714faa70861820d3e0ed9fcb901f164f5400034b
+  data.tar.gz: f327bb0d528621dbcddea84d7a0495e1ceec473a616d5ce3afb5a26386794a45452cf1ce83deca7f0d2f0bab0ed2af6dfa3e08a6ec5313558169c25c78a6772a

data/lib/optimizely.rb

@@ -80,7 +80,7 @@ module Optimizely
       end
 
       @decision_service = DecisionService.new(@config, @user_profile_service)
-      @event_builder = EventBuilderV2.new(@config)
+      @event_builder = EventBuilder.new(@config)
     end
 
     def activate(experiment_key, user_id, attributes = nil)
@@ -108,7 +108,8 @@ module Optimizely
 
       # Create and dispatch impression event
       variation_id = @config.get_variation_id_from_key(experiment_key, variation_key)
-      impression_event = @event_builder.create_impression_event(experiment_key, variation_id, user_id, attributes)
+      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])
@@ -137,6 +138,11 @@ module Optimizely
         return nil
       end
 
+      unless user_id.is_a? String
+        @logger.log(Logger::ERROR, "User id: #{user_id} is not a string")
+        return nil
+      end
+
       unless user_inputs_valid?(attributes)
         @logger.log(Logger::INFO, "Not activating user '#{user_id}.")
         return nil
@@ -150,6 +156,36 @@ module Optimizely
       nil
     end
 
+    def set_forced_variation(experiment_key, user_id, variation_key)
+      # Force a user into a variation for a given experiment.
+      #
+      # experiment_key - String - key identifying the experiment.
+      # user_id - String - The user ID to be used for bucketing.
+      # variation_key - The variation key specifies the variation which the user will 
+      #   be forced into. If nil, then clear the existing experiment-to-variation mapping.
+      #
+      # Returns - Boolean - indicates if the set completed successfully.
+
+      @config.set_forced_variation(experiment_key, user_id, variation_key);
+    end
+
+    def get_forced_variation(experiment_key, user_id)
+      # Gets the forced variation for a given user and experiment.
+      #
+      # experiment_key - String - Key identifying the experiment.
+      # user_id - String - The user ID to be used for bucketing.
+      #
+      # Returns String|nil The forced variation key.
+
+      forced_variation_key = nil
+      forced_variation = @config.get_forced_variation(experiment_key, user_id);
+      if forced_variation
+        forced_variation_key = forced_variation['key']
+      end
+
+      forced_variation_key
+    end
+
     def track(event_key, user_id, attributes = nil, event_tags = nil)
       # Send conversion event to Optimizely.
       #

data/lib/optimizely/audience.rb

@@ -20,17 +20,17 @@ module Optimizely
   module Audience
     module_function
 
-    def user_in_experiment?(config, experiment_key, attributes)
+    def user_in_experiment?(config, experiment, attributes)
       # Determine for given experiment if user satisfies the audiences for the experiment.
       #
       # config - Representation of the Optimizely project config.
-      # experiment_key - Key representing experiment for which visitor is to be bucketed.
+      # experiment - Experiment for which visitor is to be bucketed.
       # attributes - Hash representing user attributes which will be used in determining if
       #              the audience conditions are met.
       #
       # Returns boolean representing if user satisfies audience conditions for any of the audiences or not.
 
-      audience_ids = config.get_audience_ids_for_experiment(experiment_key)
+      audience_ids = experiment['audienceIds']
 
       # Return true if there are no audiences
       return true if audience_ids.empty?

data/lib/optimizely/bucketer.rb

@@ -35,26 +35,23 @@ module Optimizely
       @config = config
     end
 
-    def bucket(experiment_key, user_id)
+    def bucket(experiment, user_id)
       # Determines ID of variation to be shown for a given experiment key and user ID.
       #
-      # experiment_key - String Key representing experiment for which visitor is to be bucketed.
+      # experiment - Experiment for which visitor is to be bucketed.
       # user_id - String ID for user.
       #
-      # Returns String variation ID in which visitor with ID user_id has been placed. Nil if no variation.
+      # Returns variation in which visitor with ID user_id has been placed. Nil if no variation.
 
       # check if experiment is in a group; if so, check if user is bucketed into specified experiment
-      experiment_id = @config.get_experiment_id(experiment_key)
-      group_id = @config.get_experiment_group_id(experiment_key)
+      experiment_id = experiment['id']
+      experiment_key = experiment['key']
+      group_id = experiment['groupId']
       if group_id
         group = @config.group_key_map.fetch(group_id)
         if Helpers::Group.random_policy?(group)
-          bucketing_id = sprintf(BUCKETING_ID_TEMPLATE, user_id: user_id, entity_id: group_id)
           traffic_allocations = group.fetch('trafficAllocation')
-          bucket_value = generate_bucket_value(bucketing_id)
-          @config.logger.log(Logger::DEBUG, "Assigned experiment bucket #{bucket_value} to user '#{user_id}'.")
-          bucketed_experiment_id = find_bucket(bucket_value, traffic_allocations)
-
+          bucketed_experiment_id = find_bucket(user_id, group_id, traffic_allocations)
           # return if the user is not bucketed into any experiment
           unless bucketed_experiment_id
             @config.logger.log(Logger::INFO, "User '#{user_id}' is in no experiment.")
@@ -78,18 +75,16 @@ module Optimizely
         end
       end
 
-      bucketing_id = sprintf(BUCKETING_ID_TEMPLATE, user_id: user_id, entity_id: experiment_id)
-      bucket_value = generate_bucket_value(bucketing_id)
-      @config.logger.log(Logger::DEBUG, "Assigned variation bucket #{bucket_value} to user '#{user_id}'.")
-      traffic_allocations = @config.get_traffic_allocation(experiment_key)
-      variation_id = find_bucket(bucket_value, traffic_allocations)
+      traffic_allocations = experiment['trafficAllocation']
+      variation_id = find_bucket(user_id, experiment_id, traffic_allocations)
       if variation_id && variation_id != ''
-        variation_key = @config.get_variation_key_from_id(experiment_key, variation_id)
+        variation = @config.get_variation_from_id(experiment_key, variation_id)
+        variation_key = variation ? variation['key'] : nil
         @config.logger.log(
           Logger::INFO,
           "User '#{user_id}' is in variation '#{variation_key}' of experiment '#{experiment_key}'."
         )
-        return variation_id
+        return variation
       end
 
       # Handle the case when the traffic range is empty due to sticky bucketing
@@ -101,16 +96,19 @@ module Optimizely
       nil
     end
 
-    private
-
-    def find_bucket(bucket_value, traffic_allocations)
+    def find_bucket(user_id, parent_id, traffic_allocations)
       # Helper function to find the matching entity ID for a given bucketing value in a list of traffic allocations.
       #
-      # bucket_value - Integer bucket value
+      # 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}'.")
+
       traffic_allocations.each do |traffic_allocation|
         current_end_of_range = traffic_allocation['endOfRange']
         if bucket_value < current_end_of_range
@@ -122,6 +120,8 @@ module Optimizely
       nil
     end
 
+    private
+
     def generate_bucket_value(bucketing_id)
       # Helper function to generate bucket value in half-closed interval [0, MAX_TRAFFIC_VALUE).
       #
@@ -143,4 +143,4 @@ module Optimizely
       MurmurHash3::V32.str_hash(bucketing_id, @bucket_seed) & UNSIGNED_MAX_32_BIT_VALUE
     end
   end
-end
+end

data/lib/optimizely/decision_service.rb

@@ -22,11 +22,12 @@ module Optimizely
     # The decision service contains all logic relating to how a user bucketing decisions is made.
     # This includes all of the following (in order):
     #
-    # 1. Checking experiment status
-    # 2. Checking whitelisting
-    # 3. Checking user profile service for past bucketing decisions (sticky bucketing)
-    # 3. Checking audience targeting
-    # 4. Using Murmurhash3 to bucket the user
+    # 1. Check experiment status
+    # 2. Check forced bucketing
+    # 3. Check whitelisting
+    # 4. Check user profile service for past bucketing decisions (sticky bucketing)
+    # 5. Check audience targeting
+    # 6. Use Murmurhash3 to bucket the user
 
     attr_reader :bucketer
     attr_reader :config
@@ -47,16 +48,24 @@ module Optimizely
       # Returns variation ID where visitor will be bucketed (nil if experiment is inactive or user does not meet audience conditions)
 
       # Check to make sure experiment is active
-      unless @config.experiment_running?(experiment_key)
+      experiment = @config.get_experiment_from_key(experiment_key)
+      if experiment.nil?
+        return nil
+      end
+
+      experiment_id = experiment['id']
+      unless @config.experiment_running?(experiment)
         @config.logger.log(Logger::INFO, "Experiment '#{experiment_key}' is not running.")
         return nil
       end
 
-      experiment_id = @config.get_experiment_id(experiment_key)
+      # 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 forced variation
-      forced_variation_id = get_forced_variation_id(experiment_key, user_id)
-      return forced_variation_id if forced_variation_id
+      # 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)
@@ -70,7 +79,7 @@ module Optimizely
       end
 
       # Check audience conditions
-      unless Audience.user_in_experiment?(@config, experiment_key, attributes)
+      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}'."
@@ -79,7 +88,8 @@ module Optimizely
       end
 
       # Bucket normally
-      variation_id = @bucketer.bucket(experiment_key, user_id)
+      variation = @bucketer.bucket(experiment, user_id)
+      variation_id = variation ? variation['id'] : nil
 
       # Persist bucketing decision
       save_user_profile(user_profile, experiment_id, variation_id)
@@ -87,38 +97,38 @@ module Optimizely
     end
 
     private
-    
-    def get_forced_variation_id(experiment_key, user_id)
-      # Determine if a user is forced into a variation for the given experiment and return the ID of that variation
+
+    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
       #
       # 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 forced (nil if no variation)
+      # Returns variation ID into which user_id is whitelisted (nil if no variation)
 
-      forced_variations = @config.get_forced_variations(experiment_key)
+      whitelisted_variations = @config.get_whitelisted_variations(experiment_key)
 
-      return nil unless forced_variations
+      return nil unless whitelisted_variations
 
-      forced_variation_key = forced_variations[user_id]
+      whitelisted_variation_key = whitelisted_variations[user_id]
 
-      return nil unless forced_variation_key
+      return nil unless whitelisted_variation_key
 
-      forced_variation_id = @config.get_variation_id_from_key(experiment_key, forced_variation_key)
+      whitelisted_variation_id = @config.get_variation_id_from_key(experiment_key, whitelisted_variation_key)
 
-      unless forced_variation_id
+      unless whitelisted_variation_id
         @config.logger.log(
           Logger::INFO,
-          "User '#{user_id}' is whitelisted into variation '#{forced_variation_key}', which is not in the datafile."
+          "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 '#{forced_variation_key}' of experiment '#{experiment_key}'."
+        "User '#{user_id}' is whitelisted into variation '#{whitelisted_variation_key}' of experiment '#{experiment_key}'."
       )
-      forced_variation_id
+      whitelisted_variation_id
     end
 
     def get_saved_variation_id(experiment_id, user_profile)
@@ -147,7 +157,7 @@ module Optimizely
       #
       # 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) 
+      # Returns Hash stored user profile (or a default one if lookup fails or user profile service not provided)
 
       user_profile = {
         :user_id => user_id,

data/lib/optimizely/event_builder.rb

@@ -17,6 +17,7 @@ require_relative './audience'
 require_relative './params'
 require_relative './version'
 require_relative '../optimizely/helpers/event_tag_utils'
+require 'securerandom'
 
 module Optimizely
   class Event
@@ -41,197 +42,198 @@ module Optimizely
   end
 
   class BaseEventBuilder
+    CUSTOM_ATTRIBUTE_FEATURE_TYPE = 'custom'
+
     attr_reader :config
-    attr_reader :params
 
     def initialize(config)
       @config = config
-      @params = {}
     end
 
     private
 
-    def add_common_params(user_id, attributes)
-      # Add params which are used in both conversion and impression events.
-      #
-      # user_id - ID for user.
-      # attributes - Hash representing user attributes and values which need to be recorded.
-
-      add_project_id
-      add_account_id
-      add_user_id(user_id)
-      add_attributes(attributes)
-      add_source
-      add_time
+    def get_common_params(user_id, attributes)
+      # Get params which are used in both conversion and impression events.
+      # 
+      # user_id -    +String+ ID for user
+      # attributes - +Hash+ representing user attributes and values which need to be recorded.
+      # 
+      # Returns +Hash+ Common event params
+
+      visitor_attributes = []
+
+      unless attributes.nil?
+
+        attributes.keys.each do |attribute_key|
+        # Omit null attribute value
+        attribute_value = attributes[attribute_key]
+        next if attribute_value.nil?
+
+        # Skip attributes not in the datafile
+        attribute_id = @config.get_attribute_id(attribute_key)
+        next unless attribute_id
+
+        feature = {
+          entity_id: attribute_id,
+          key: attribute_key,
+          type: CUSTOM_ATTRIBUTE_FEATURE_TYPE,
+          value: attribute_value
+        }
+
+        visitor_attributes.push(feature)
+        end
+      end 
+
+      common_params = {
+        account_id: @config.account_id,
+        project_id: @config.project_id,
+        visitors: [
+          {
+            attributes: visitor_attributes,
+            snapshots: [],
+            visitor_id: user_id
+          }
+          ],
+          revision: @config.revision,
+          client_name: CLIENT_ENGINE,
+          client_version: VERSION
+        }
+
+      common_params
     end
   end
 
-  class EventBuilderV2 < BaseEventBuilder
-    CONVERSION_EVENT_ENDPOINT = 'https://logx.optimizely.com/log/event'
-    IMPRESSION_EVENT_ENDPOINT = 'https://logx.optimizely.com/log/decision'
+  class EventBuilder < BaseEventBuilder
+    ENDPOINT = 'https://logx.optimizely.com/v1/events'
     POST_HEADERS = { 'Content-Type' => 'application/json' }
+    ACTIVATE_EVENT_KEY = 'campaign_activated'
 
-    def create_impression_event(experiment_key, variation_id, user_id, attributes)
-      # Create conversion Event to be sent to the logging endpoint.
+    def create_impression_event(experiment, variation_id, user_id, attributes)
+      # Create impression Event to be sent to the logging endpoint.
       #
-      # experiment_key - Experiment for which impression needs to be recorded.
-      # variation_id - ID for variation which would be presented to user.
-      # user_id - ID for user.
-      # attributes - Hash representing user attributes and values which need to be recorded.
+      # 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.
+      # attributes -   +Hash+ representing user attributes and values which need to be recorded.
       #
-      # Returns event hash encapsulating the impression event.
+      # Returns +Event+ encapsulating the impression event.
 
-      @params = {}
-      add_common_params(user_id, attributes)
-      add_decision(experiment_key, variation_id)
-      add_attributes(attributes)
-      Event.new(:post, IMPRESSION_EVENT_ENDPOINT, @params, POST_HEADERS)
+      event_params = get_common_params(user_id, attributes)
+      impression_params = get_impression_params(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_key, user_id, attributes, event_tags, experiment_variation_map)
       # Create conversion Event to be sent to the logging endpoint.
       #
-      # event_key - Event key representing the event which needs to be recorded.
-      # user_id - ID for user.
-      # attributes - Hash representing user attributes and values which need to be recorded.
-      # event_tags - Hash representing metadata associated with the event.
-      # experiment_variation_map - Map of experiment ID to the ID of the variation that the user is bucketed into.
+      # event_key -                +String+ Event key representing the event which needs to be recorded.
+      # user_id -                  +String+ ID for user.
+      # attributes -               +Hash+ representing user attributes and values which need to be recorded.
+      # event_tags -               +Hash+ representing metadata associated with the event.
+      # experiment_variation_map - +Map+ of experiment ID to the ID of the variation that the user is bucketed into.
       #
-      # Returns event hash encapsulating the conversion event.
-
-      @params = {}
-      add_common_params(user_id, attributes)
-      add_conversion_event(event_key)
-      add_event_tags(event_tags)
-      add_layer_states(experiment_variation_map)
-      Event.new(:post, CONVERSION_EVENT_ENDPOINT, @params, POST_HEADERS)
-    end
-
-    private
+      # Returns +Event+ encapsulating the conversion event.
 
-    def add_common_params(user_id, attributes)
-      super
-      @params['isGlobalHoldback'] = false
+      event_params = get_common_params(user_id, attributes)
+      conversion_params = get_conversion_params(event_key, event_tags, experiment_variation_map)
+      event_params[:visitors][0][:snapshots] = conversion_params;
+      
+      Event.new(:post, ENDPOINT, event_params, POST_HEADERS)
     end
 
-    def add_project_id
-      @params['projectId'] = @config.project_id
-    end
+    private
 
-    def add_account_id
-      @params['accountId'] = @config.account_id
-    end
+    def get_impression_params(experiment, variation_id)
+      # Creates object of params specific to impression events
+      #
+      # experiment -   +Hash+ experiment for which impression needs to be recorded
+      # variation_id - +string+ ID for variation which would be presented to user
+      #
+      # Returns +Hash+ Impression event params
+
+      experiment_key = experiment['key']
+      experiment_id = experiment['id']
+
+      impressionEventParams = {
+        decisions: [{
+          campaign_id: @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'],
+          timestamp: get_timestamp(),
+          key: ACTIVATE_EVENT_KEY,
+          uuid: get_uuid()
+        }]
+      }
 
-    def add_user_id(user_id)
-      @params['visitorId'] = user_id
+      impressionEventParams;
     end
 
-    def add_attributes(attributes)
-      @params['userFeatures'] = []
-
-      return if attributes.nil?
+    def get_conversion_params(event_key, event_tags, experiment_variation_map)
+      # Creates object of params specific to conversion events
+      #
+      # event_key -                +String+ Key representing the event which needs to be recorded
+      # event_tags -               +Hash+ Values associated with the event.
+      # experiment_variation_map - +Hash+ Map of experiment IDs to bucketed variation IDs
+      #
+      # Returns +Hash+ Impression event params
 
-      attributes.keys.each do |attribute_key|
-        # Omit falsy attribute values
-        attribute_value = attributes[attribute_key]
-        next unless attribute_value
+      conversionEventParams = []
 
-        # Skip attributes not in the datafile
-        attribute_id = @config.get_attribute_id(attribute_key)
-        next unless attribute_id
+      experiment_variation_map.each do |experiment_id, variation_id|
 
-        feature = {
-          'id' => attribute_id,
-          'name' => attribute_key,
-          'type' => 'custom',
-          'value' => attribute_value,
-          'shouldIndex' => true,
+        single_snapshot = {
+          decisions: [{
+            campaign_id: @config.experiment_id_map[experiment_id]['layerId'],
+            experiment_id: experiment_id,
+            variation_id: variation_id,
+          }],
+          events: [],
         }
-        @params['userFeatures'].push(feature)
-      end
-    end
-
-    def add_decision(experiment_key, variation_id)
-      experiment_id = @config.get_experiment_id(experiment_key)
-      @params['layerId'] = @config.experiment_key_map[experiment_key]['layerId']
-      @params['decision'] = {
-        'variationId' => variation_id,
-        'experimentId' => experiment_id,
-        'isLayerHoldback' => false,
-      }
-    end
-
-    def add_event_tags(event_tags)
-      @params['eventFeatures'] ||= []
-      @params['eventMetrics'] ||= []
 
-      return if event_tags.nil?
+        event_object = {
+          entity_id: @config.event_key_map[event_key]['id'],
+          timestamp: get_timestamp(),
+          uuid: get_uuid(),
+          key: event_key,
+        }
 
-      event_tags.each_pair do |event_tag_key, event_tag_value|
-        next if event_tag_value.nil?
+        if event_tags
+          revenue_value = Helpers::EventTagUtils.get_revenue_value(event_tags)
+          if revenue_value
+            event_object[:revenue] = revenue_value
+          end
 
-        event_feature = {
-          'name' => event_tag_key,
-          'type' => 'custom',
-          'value' => event_tag_value,
-          'shouldIndex' => false,
-        }
-        @params['eventFeatures'].push(event_feature)
+          numeric_value = Helpers::EventTagUtils.get_numeric_value(event_tags)
+          if numeric_value
+            event_object[:value] = numeric_value
+          end
 
-      end
+          event_object[:tags] = event_tags
+        end
 
-      event_value = Helpers::EventTagUtils.get_revenue_value(event_tags)
+        single_snapshot[:events] = [event_object]
 
-      if event_value
-        event_metric = {
-          'name' => 'revenue',
-          'value' => event_value
-        }
-        @params['eventMetrics'].push(event_metric)
+        conversionEventParams.push(single_snapshot)
       end
-
+    
+      conversionEventParams
     end
 
-    def add_conversion_event(event_key)
-      # Add conversion event information to the event.
-      #
-      # event_key - Event key representing the event which needs to be recorded.
-
-      event_id = @config.event_key_map[event_key]['id']
-      event_name = @config.event_key_map[event_key]['key']
+    def get_timestamp
+      # Returns +Integer+ Current timestamp
 
-      @params['eventEntityId'] = event_id
-      @params['eventName'] = event_name
+      (Time.now.to_f * 1000).to_i
     end
 
-    def add_layer_states(experiments_map)
-      # Add layer states information to the event.
-      #
-      # experiments_map - Hash with experiment ID as a key and variation ID as a value.
-
-      @params['layerStates'] = []
-
-      experiments_map.each do |experiment_id, variation_id|
-        layer_state = {
-          'layerId' => @config.experiment_id_map[experiment_id]['layerId'],
-          'decision' => {
-            'variationId' => variation_id,
-            'experimentId' => experiment_id,
-            'isLayerHoldback' => false,
-          },
-          'actionTriggered' => true,
-        }
-        @params['layerStates'].push(layer_state)
-      end
-    end
-
-    def add_source
-      @params['clientEngine'] = 'ruby-sdk'
-      @params['clientVersion'] = VERSION
-    end
+    def get_uuid
+      # Returns +String+ Random UUID
 
-    def add_time
-      @params['timestamp'] = (Time.now.to_f * 1000).to_i
+      SecureRandom.uuid
     end
   end
 end

data/lib/optimizely/helpers/event_tag_utils.rb

@@ -21,23 +21,31 @@ module Optimizely
     module EventTagUtils
       module_function
 
+      REVENUE_EVENT_METRIC_NAME = 'revenue';
+      NUMERIC_EVENT_METRIC_NAME = 'value';
+
+      def isStringNumeric(str)
+        Float(str) != nil rescue false
+      end
+
       def get_revenue_value(event_tags)
         # Grab the revenue value from the event tags. "revenue" is a reserved keyword.
-        #
+        # The revenue value must be an integer.
+        # 
         # event_tags - Hash representing metadata associated with the event.
         # Returns revenue value as an integer number
         # Returns nil if revenue can't be retrieved from the event tags.
 
-        if event_tags.nil? or !Helpers::Validator.attributes_valid?(event_tags)
+        if event_tags.nil? or !Helpers::Validator.event_tags_valid?(event_tags)
           return nil
         end
 
-        unless event_tags.has_key?('revenue')
+        unless event_tags.has_key?(REVENUE_EVENT_METRIC_NAME)
           return nil
         end
 
         logger = SimpleLogger.new
-        raw_value = event_tags['revenue']
+        raw_value = event_tags[REVENUE_EVENT_METRIC_NAME]
 
         unless raw_value.is_a? Numeric
           logger.log(Logger::WARN, "Failed to parse revenue value #{raw_value} from event tags.")
@@ -52,6 +60,59 @@ module Optimizely
         logger.log(Logger::INFO, "Parsed revenue value #{raw_value} from event tags.")
         raw_value
       end
+
+      def get_numeric_value(event_tags, logger = nil)
+        # Grab the numeric event value from the event tags. "value" is a reserved keyword.
+        # The value of 'value' can be a float or a numeric string
+        # 
+        # event_tags - +Hash+ representing metadata associated with the event.
+        # Returns  +Number+ | +nil+ if value can't be retrieved from the event tags.
+        logger = SimpleLogger.new if logger.nil?
+
+        if event_tags.nil?
+          logger.log(Logger::DEBUG,"Event tags is undefined.")
+          return nil
+        end
+
+        if !Helpers::Validator.event_tags_valid?(event_tags)
+          logger.log(Logger::DEBUG,"Event tags is not a dictionary.")
+          return nil
+        end
+
+        if !event_tags.has_key?(NUMERIC_EVENT_METRIC_NAME)
+          logger.log(Logger::DEBUG,"The numeric metric key is not defined in the event tags.")
+          return nil
+        end
+
+        if event_tags[NUMERIC_EVENT_METRIC_NAME].nil?
+          logger.log(Logger::DEBUG,"The numeric metric key is null.")
+          return nil
+        end
+
+        raw_value = event_tags[NUMERIC_EVENT_METRIC_NAME]
+
+        if raw_value === true or raw_value === false
+          logger.log(Logger::DEBUG,"Provided numeric value is a boolean, which is an invalid format.")
+          return nil
+        end
+
+        if raw_value.is_a? Array or  raw_value.is_a? Hash or raw_value.to_f.nan? or raw_value.to_f.infinite?
+            logger.log(Logger::DEBUG,"Provided numeric value is in an invalid format.")
+            return nil
+        end
+
+        if !Helpers::Validator.string_numeric?(raw_value)
+            logger.log(Logger::DEBUG,"Provided numeric value is not a numeric string.")
+            return nil     
+        end
+
+        raw_value = raw_value.to_f
+
+        logger.log(Logger::INFO,"The numeric metric value #{raw_value} will be sent to results.")
+
+        raw_value
+      end
+
     end
   end
-end
+end 

data/lib/optimizely/helpers/validator.rb

@@ -87,6 +87,11 @@ module Optimizely
 
         logger.respond_to?(:log)
       end
+
+      def string_numeric?(str)
+        Float(str) != nil rescue false
+      end
+      
     end
   end
 end

data/lib/optimizely/project_config.rb

@@ -25,10 +25,6 @@ module Optimizely
 
   class ProjectConfig
     # Representation of the Optimizely project config.
-
-    PROJECT_CONFIG_LINK_TEMPLATE = 'https://cdn.optimizely.com/json/%{project_id}.json'
-    REVENUE_GOAL_KEY = 'Total Revenue'
-    REQUEST_TIMEOUT = 10
     RUNNING_EXPERIMENT_STATUS = ['Running']
 
     # Gets project config attributes.
@@ -56,6 +52,12 @@ module Optimizely
     attr_reader :variation_id_map
     attr_reader :variation_key_map
 
+    # 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 initialize(datafile, logger, error_handler)
       # ProjectConfig init method to fetch and set project config data
       #
@@ -96,6 +98,9 @@ module Optimizely
       @audience_id_map = generate_key_map(@audiences, 'id')
       @variation_id_map = {}
       @variation_key_map = {}
+      @forced_variation_map = {}
+      @variation_id_to_variable_usage_map = {}
+      @variation_id_to_experiment_map = {}
       @experiment_key_map.each do |key, exp|
         variations = exp.fetch('variations')
         @variation_id_map[key] = generate_key_map(variations, 'id')
@@ -104,28 +109,24 @@ module Optimizely
       @parsing_succeeded = true
     end
 
-    def experiment_running?(experiment_key)
+    def experiment_running?(experiment)
       # Determine if experiment corresponding to given key is running
       #
-      # experiment_key - String key representing the experiment
+      # experiment - Experiment
       #
       # Returns true if experiment is running
-      experiment = @experiment_key_map[experiment_key]
-      return RUNNING_EXPERIMENT_STATUS.include?(experiment['status']) if experiment
-      @logger.log Logger::ERROR, "Experiment key '#{experiment_key}' is not in datafile."
-      @error_handler.handle_error InvalidExperimentError
-      nil
+      return RUNNING_EXPERIMENT_STATUS.include?(experiment['status'])
     end
 
-    def get_experiment_id(experiment_key)
+    def get_experiment_from_key(experiment_key)
       # Retrieves experiment ID for a given key
       #
       # experiment_key - String key representing the experiment
       #
-      # Returns String ID
+      # Returns Experiment
 
       experiment = @experiment_key_map[experiment_key]
-      return experiment['id'] if experiment
+      return experiment if experiment
       @logger.log Logger::ERROR, "Experiment key '#{experiment_key}' is not in datafile."
       @error_handler.handle_error InvalidExperimentError
       nil
@@ -159,34 +160,6 @@ module Optimizely
       []
     end
 
-    def get_traffic_allocation(experiment_key)
-      # Retrieves traffic allocation for a given experiment Key
-      #
-      # experiment_key - String Key representing the experiment
-      #
-      # Returns traffic allocation for the experiment or nil
-
-      experiment = @experiment_key_map[experiment_key]
-      return experiment['trafficAllocation'] if experiment
-      @logger.log Logger::ERROR, "Experiment key '#{experiment_key}' is not in datafile."
-      @error_handler.handle_error InvalidExperimentError
-      nil
-    end
-
-    def get_audience_ids_for_experiment(experiment_key)
-      # Get audience IDs for the experiment
-      #
-      # experiment_key - Experiment key for which audience IDs are to be determined
-      #
-      # Returns audience IDs corresponding to the experiment.
-
-      experiment = @experiment_key_map[experiment_key]
-      return experiment['audienceIds'] if experiment
-      @logger.log Logger::ERROR, "Experiment key '#{experiment_key}' is not in datafile."
-      @error_handler.handle_error InvalidExperimentError
-      nil
-    end
-
     def get_audience_conditions_from_id(audience_id)
       # Get audience conditions for the provided audience ID
       #
@@ -223,6 +196,28 @@ module Optimizely
       nil
     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
+
+      variation_id_map = @variation_id_map[experiment_key]
+      if variation_id_map
+        variation = variation_id_map[variation_id]
+        return variation if variation
+        @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
       #
@@ -245,12 +240,12 @@ module Optimizely
       nil
     end
 
-    def get_forced_variations(experiment_key)
-      # Retrieves forced variations for a given experiment Key
+    def get_whitelisted_variations(experiment_key)
+      # Retrieves whitelisted variations for a given experiment Key
       #
       # experiment_key - String Key representing the experiment
       #
-      # Returns forced variations for the experiment or nil
+      # Returns whitelisted variations for the experiment or nil
 
       experiment = @experiment_key_map[experiment_key]
       return experiment['forcedVariations'] if experiment
@@ -258,11 +253,98 @@ module Optimizely
       @error_handler.handle_error InvalidExperimentError
     end
 
-    def get_experiment_group_id(experiment_key)
-      experiment = @experiment_key_map[experiment_key]
-      return experiment['groupId'] if experiment
-      @logger.log Logger::ERROR, "Experiment key '#{experiment_key}' is not in datafile."
-      @error_handler.handle_error InvalidExperimentError
+    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.
+
+      # check for nil and empty string user ID
+      if user_id.nil? or user_id.empty?
+        @logger.log(Logger::DEBUG, "User ID is invalid")
+        return nil
+      end
+
+      unless @forced_variation_map.has_key? (user_id)
+        @logger.log(Logger::DEBUG, "User '#{user_id}' is not in the forced variation map.")
+        return nil
+      end
+
+      experimentToVariationMap = @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
+      if experiment_id.nil? or experiment_id.empty?
+        # this case is logged in get_experiment_from_key
+        return nil
+      end
+
+      unless experimentToVariationMap.has_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 = experimentToVariationMap[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
+      if variation_key.empty?
+        # this case is logged in get_variation_from_id
+        return nil
+      end
+
+      @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.
+
+      #  check for null and empty string user ID
+      if user_id.nil? or user_id.empty?
+        @logger.log(Logger::DEBUG, "User ID is invalid")
+        return false
+      end
+
+      experiment = get_experiment_from_key(experiment_key)
+      experiment_id = experiment["id"] if experiment
+      #  check if the experiment exists in the datafile
+      if experiment_id.nil? or experiment_id.empty?
+        return false
+      end
+
+      #  clear the forced variation if the variation key is null
+      if variation_key.nil? or variation_key.empty?
+        @forced_variation_map[user_id].delete(experiment_id) if @forced_variation_map.has_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
+
+      unless @forced_variation_map.has_key? user_id
+        @forced_variation_map[user_id] = {}
+      end
+      @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.")
+      return true
     end
 
     def get_attribute_id(attribute_key)
@@ -273,19 +355,6 @@ module Optimizely
       nil
     end
 
-    def user_in_forced_variation?(experiment_key, user_id)
-      # Determines if a given user is in a forced variation
-      #
-      # experiment_key - String experiment key
-      # user_id - String user ID
-      #
-      # Returns true if user is in a forced variation
-
-      forced_variations = get_forced_variations(experiment_key)
-      return forced_variations.include?(user_id) if forced_variations
-      false
-    end
-
     def parsing_succeeded?
       # Helper method to determine if parsing the datafile was successful.
       #
@@ -309,11 +378,8 @@ module Optimizely
         return true if variation
         @logger.log Logger::ERROR, "Variation ID '#{variation_id}' is not in datafile."
         @error_handler.handle_error InvalidVariationError
-        return false
       end
 
-      @logger.log Logger::ERROR, "Experiment ID '#{experiment_id}' is not in datafile."
-      @error_handler.handle_error InvalidExperimentError
       false
     end
 

data/lib/optimizely/version.rb

@@ -14,5 +14,8 @@
 #    limitations under the License.
 #
 module Optimizely
-  VERSION = '1.3.0'.freeze
+  
+ CLIENT_ENGINE = 'ruby-sdk'.freeze
+ VERSION = '1.4.0'.freeze
+
 end

metadata

@@ -1,16 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: optimizely-sdk
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors:
-- Andrew Delikat
-- Haley Bash
 - Optimizely
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-24 00:00:00.000000000 Z
+date: 2017-10-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -155,7 +153,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.10
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: Ruby SDK for Optimizely's testing framework