optimizely-sdk 1.5.0 → 2.0.0.beta

data/lib/optimizely/event_builder.rb

@@ -17,12 +17,8 @@ require_relative './audience'
 require_relative './params'
 require_relative './version'
 require_relative '../optimizely/helpers/event_tag_utils'
-require 'securerandom'
 
 module Optimizely
-
-  RESERVED_ATTRIBUTE_KEY_BUCKETING_ID_EVENT_PARAM_KEY = "optimizely_bucketing_id".freeze
-
   class Event
     # Representation of an event which can be sent to the Optimizely logging endpoint.
 
@@ -45,210 +41,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 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?
-
-        if attribute_key.eql? RESERVED_ATTRIBUTE_KEY_BUCKETING_ID
-          # TODO (Copied from PHP-SDK) (Alda): the type for bucketing ID attribute may change so 
-          # that custom attributes are not overloaded          
-          feature = {
-            entity_id: RESERVED_ATTRIBUTE_KEY_BUCKETING_ID,
-            key: RESERVED_ATTRIBUTE_KEY_BUCKETING_ID_EVENT_PARAM_KEY,
-            type: CUSTOM_ATTRIBUTE_FEATURE_TYPE,
-            value: attribute_value
-          }         
-        else
-          # 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
-          }
-
-        end
-        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
-          }
-        ],
-        anonymize_ip: @config.anonymize_ip,
-        revision: @config.revision,
-        client_name: CLIENT_ENGINE,
-        client_version: VERSION
-      }
-
-      common_params
+    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
     end
   end
 
   class EventBuilder < BaseEventBuilder
-    ENDPOINT = 'https://logx.optimizely.com/v1/events'
+    CONVERSION_EVENT_ENDPOINT = 'https://logx.optimizely.com/log/event'
+    IMPRESSION_EVENT_ENDPOINT = 'https://logx.optimizely.com/log/decision'
     POST_HEADERS = { 'Content-Type' => 'application/json' }
-    ACTIVATE_EVENT_KEY = 'campaign_activated'
 
     def create_impression_event(experiment, variation_id, user_id, attributes)
-      # Create impression Event to be sent to the logging endpoint.
+      # Create conversion Event to be sent to the logging endpoint.
       #
-      # 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.
+      # experiment - 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.
       #
-      # Returns +Event+ encapsulating the impression event.
-
-      event_params = get_common_params(user_id, attributes)
-      impression_params = get_impression_params(experiment, variation_id)
-      event_params[:visitors][0][:snapshots].push(impression_params)
+      # Returns event hash encapsulating the impression event.
 
-      Event.new(:post, ENDPOINT, event_params, POST_HEADERS)
+      @params = {}
+      add_common_params(user_id, attributes)
+      add_decision(experiment, variation_id)
+      add_attributes(attributes)
+      Event.new(:post, IMPRESSION_EVENT_ENDPOINT, @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 -                +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.
+      # 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.
       #
-      # Returns +Event+ encapsulating the conversion event.
-
-      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)
+      # 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
 
-    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
+    def add_common_params(user_id, attributes)
+      super
+      @params['isGlobalHoldback'] = false
+    end
+
+    def add_project_id
+      @params['projectId'] = @config.project_id
+    end
+
+    def add_account_id
+      @params['accountId'] = @config.account_id
+    end
+
+    def add_user_id(user_id)
+      @params['visitorId'] = user_id
+    end
+
+    def add_attributes(attributes)
+      @params['userFeatures'] = []
+
+      return if attributes.nil?
+
+      attributes.keys.each do |attribute_key|
+        # Omit falsy attribute values
+        attribute_value = attributes[attribute_key]
+        next unless attribute_value
+
+        # Skip attributes not in the datafile
+        attribute_id = @config.get_attribute_id(attribute_key)
+        next unless attribute_id
+
+        feature = {
+          'id' => attribute_id,
+          'name' => attribute_key,
+          'type' => 'custom',
+          'value' => attribute_value,
+          'shouldIndex' => true,
+        }
+        @params['userFeatures'].push(feature)
+      end
+    end
 
+    def add_decision(experiment, variation_id)
       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()
-        }]
+      @params['layerId'] = @config.experiment_key_map[experiment_key]['layerId']
+      @params['decision'] = {
+        'variationId' => variation_id,
+        'experimentId' => experiment_id,
+        'isLayerHoldback' => false,
       }
-
-      impressionEventParams;
     end
 
-    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
+    def add_event_tags(event_tags)
+      @params['eventFeatures'] ||= []
+      @params['eventMetrics'] ||= []
 
-      conversionEventParams = []
+      return if event_tags.nil?
 
-      experiment_variation_map.each do |experiment_id, variation_id|
+      event_tags.each_pair do |event_tag_key, event_tag_value|
+        next if event_tag_value.nil?
 
-        single_snapshot = {
-          decisions: [{
-            campaign_id: @config.experiment_id_map[experiment_id]['layerId'],
-            experiment_id: experiment_id,
-            variation_id: variation_id,
-          }],
-          events: [],
+        event_feature = {
+          'name' => event_tag_key,
+          'type' => 'custom',
+          'value' => event_tag_value,
+          'shouldIndex' => false,
         }
+        @params['eventFeatures'].push(event_feature)
 
-        event_object = {
-          entity_id: @config.event_key_map[event_key]['id'],
-          timestamp: get_timestamp(),
-          uuid: get_uuid(),
-          key: event_key,
+      end
+
+      event_value = Helpers::EventTagUtils.get_revenue_value(event_tags)
+
+      if event_value
+        event_metric = {
+          'name' => 'revenue',
+          'value' => event_value
         }
+        @params['eventMetrics'].push(event_metric)
+      end
 
-        if event_tags
-          revenue_value = Helpers::EventTagUtils.get_revenue_value(event_tags)
-          if revenue_value
-            event_object[:revenue] = revenue_value
-          end
+    end
 
-          numeric_value = Helpers::EventTagUtils.get_numeric_value(event_tags)
-          if numeric_value
-            event_object[:value] = numeric_value
-          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_object[:tags] = event_tags
-        end
+      event_id = @config.event_key_map[event_key]['id']
+      event_name = @config.event_key_map[event_key]['key']
 
-        single_snapshot[:events] = [event_object]
+      @params['eventEntityId'] = event_id
+      @params['eventName'] = event_name
+    end
 
-        conversionEventParams.push(single_snapshot)
+    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
-    
-      conversionEventParams
     end
 
-    def get_timestamp
-      # Returns +Integer+ Current timestamp
-
-      (Time.now.to_f * 1000).to_i
+    def add_source
+      @params['clientEngine'] = 'ruby-sdk'
+      @params['clientVersion'] = VERSION
     end
 
-    def get_uuid
-      # Returns +String+ Random UUID
-
-      SecureRandom.uuid
+    def add_time
+      @params['timestamp'] = (Time.now.to_f * 1000).to_i
     end
   end
 end

data/lib/optimizely/exceptions.rb

@@ -95,13 +95,4 @@ module Optimizely
       super("Provided #{type} is in an invalid format.")
     end
   end
-  
-  class InvalidNotificationType < Error
-    # Raised when an invalid notification type is provided
-  
-    def initialize(msg = 'Provided notification type is invalid.')
-      super
-    end
-  end
-  
 end

data/lib/optimizely/helpers/event_tag_utils.rb

@@ -21,31 +21,23 @@ 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.event_tags_valid?(event_tags)
+        if event_tags.nil? or !Helpers::Validator.attributes_valid?(event_tags)
           return nil
         end
 
-        unless event_tags.has_key?(REVENUE_EVENT_METRIC_NAME)
+        unless event_tags.has_key?('revenue')
           return nil
         end
 
         logger = SimpleLogger.new
-        raw_value = event_tags[REVENUE_EVENT_METRIC_NAME]
+        raw_value = event_tags['revenue']
 
         unless raw_value.is_a? Numeric
           logger.log(Logger::WARN, "Failed to parse revenue value #{raw_value} from event tags.")
@@ -60,59 +52,6 @@ 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