optimizely-sdk 1.4.0 → 1.5.0

data/lib/optimizely/event_builder.rb

@@ -20,6 +20,9 @@ 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.
 
@@ -69,22 +72,33 @@ module Optimizely
         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
-        }
+        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
+          }
 
-        visitor_attributes.push(feature)
         end
-      end 
+        visitor_attributes.push(feature)
+      end
+    end 
 
-      common_params = {
+    common_params = {
         account_id: @config.account_id,
         project_id: @config.project_id,
         visitors: [
@@ -93,11 +107,12 @@ module Optimizely
             snapshots: [],
             visitor_id: user_id
           }
-          ],
-          revision: @config.revision,
-          client_name: CLIENT_ENGINE,
-          client_version: VERSION
-        }
+        ],
+        anonymize_ip: @config.anonymize_ip,
+        revision: @config.revision,
+        client_name: CLIENT_ENGINE,
+        client_version: VERSION
+      }
 
       common_params
     end

data/lib/optimizely/exceptions.rb

@@ -95,4 +95,13 @@ 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/constants.rb

@@ -298,6 +298,13 @@ module Optimizely
           'revision'
         ]
       }
+
+      VARIABLE_TYPES = {
+        'BOOLEAN' => 'boolean',
+        'DOUBLE' => 'double',
+        'INTEGER' => 'integer',
+        'STRING' => 'string'
+      }
     end
   end
 end

data/lib/optimizely/helpers/variable_type.rb

@@ -0,0 +1,56 @@
+#
+#    Copyright 2017, 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/logger'
+
+module Optimizely
+  module Helpers
+    module VariableType
+      module_function
+
+      def cast_value_to_type(value, variable_type, logger)
+        # Attempts to cast the given value to the specified type
+        #
+        # value - The string value to cast
+        # variable_type - String variable type
+        #
+        # Returns the cast value or nil if not able to cast
+        return_value = nil
+
+        case variable_type
+        when "boolean"
+          return_value = value == "true"
+        when "double"
+          begin
+            return_value = Float(value)
+          rescue => e
+            logger.log(Logger::ERROR, "Unable to cast variable value '#{value}' to type '#{variable_type}': #{e.message}.")
+          end
+        when "integer"
+          begin
+            return_value = Integer(value)
+          rescue => e
+            logger.log(Logger::ERROR, "Unable to cast variable value '#{value}' to type '#{variable_type}': #{e.message}.")
+          end
+        else
+          # default case is string
+          return_value = value
+        end
+
+        return return_value
+      end
+    end
+  end
+end

data/lib/optimizely/notification_center.rb

@@ -0,0 +1,148 @@
+#
+#    Copyright 2017, 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 NotificationCenter
+    attr_reader :notifications
+    attr_reader :notification_id
+
+    NOTIFICATION_TYPES = {
+      ACTIVATE: 'ACTIVATE: experiment, user_id, attributes, variation, event',
+      TRACK: 'TRACK: event_key, user_id, attributes, event_tags, event'
+    }.freeze
+
+    def initialize(logger, error_handler)
+      @notification_id = 1
+      @notifications = {}
+      NOTIFICATION_TYPES.values.each { |value| @notifications[value] = [] }
+      @logger = logger
+      @error_handler = error_handler
+    end
+
+    def add_notification_listener(notification_type, notification_callback)
+      # Adds notification callback to the notification center
+
+      # Args:
+      #  notification_type: one of the constants in NOTIFICATION_TYPES
+      #  notification_callback: function to call when the event is sent
+
+      # Returns:
+      #  notification ID used to remove the notification
+
+      return nil unless notification_type_valid?(notification_type)
+
+      unless notification_callback
+        @logger.log Logger::ERROR, 'Callback can not be empty.'
+        return nil
+      end
+
+      unless notification_callback.is_a? Method
+        @logger.log Logger::ERROR, 'Invalid notification callback given.'
+        return nil
+      end
+
+      @notifications[notification_type].each do |notification|
+        return -1 if notification[:callback] == notification_callback
+      end
+      @notifications[notification_type].push(notification_id: @notification_id, callback: notification_callback)
+      notification_id = @notification_id
+      @notification_id += 1
+      notification_id
+    end
+
+    def remove_notification_listener(notification_id)
+      # Removes previously added notification callback
+
+      # Args:
+      #  notification_id:
+      # Returns:
+      #  The function returns true if found and removed, false otherwise
+      unless notification_id
+        @logger.log Logger::ERROR, 'Notification ID can not be empty.'
+        return nil
+      end
+      @notifications.each do |key, _array|
+        @notifications[key].each do |notification|
+          if notification_id == notification[:notification_id]
+            @notifications[key].delete(notification_id: notification_id, callback: notification[:callback])
+            return true
+          end
+        end
+      end
+      false
+    end
+
+    def clear_notifications(notification_type)
+      # Removes notifications for a certain notification type
+      #
+      # Args:
+      #  notification_type: one of the constants in NOTIFICATION_TYPES
+
+      return nil unless notification_type_valid?(notification_type)
+
+      @notifications[notification_type] = []
+      @logger.log Logger::INFO, "All callbacks for notification type #{notification_type} have been removed."
+    end
+
+    def clean_all_notifications
+      # Removes all notifications
+      @notifications.keys.each { |key| @notifications[key] = [] }
+    end
+
+    def send_notifications(notification_type, *args)
+      # Sends off the notification for the specific event.  Uses var args to pass in a
+      # arbitrary list of parameters according to which notification type was sent
+
+      # Args:
+      #  notification_type: one of the constants in NOTIFICATION_TYPES
+      #  args: list of arguments to the callback
+      return nil unless notification_type_valid?(notification_type)
+
+      @notifications[notification_type].each do |notification|
+        begin
+          notification_callback = notification[:callback]
+          notification_callback.call(*args)
+          @logger.log Logger::INFO, "Notification #{notification_type} sent successfully."
+        rescue => e
+          @logger.log(Logger::ERROR, "Problem calling notify callback. Error: #{e}")
+          return nil
+        end
+      end
+    end
+
+    private
+
+    def notification_type_valid?(notification_type)
+      # Validates notification type
+
+      # Args:
+      #  notification_type: one of the constants in NOTIFICATION_TYPES
+
+      # Returns true if notification_type is valid,  false otherwise
+
+      unless notification_type
+        @logger.log Logger::ERROR, 'Notification type can not be empty.'
+        return false
+      end
+
+      unless @notifications.include?(notification_type)
+        @logger.log Logger::ERROR, 'Invalid notification type.'
+        @error_handler.handle_error InvalidNotificationType
+        return false
+      end
+      true
+    end
+  end
+end

data/lib/optimizely/project_config.rb

@@ -18,9 +18,7 @@ require 'json'
 module Optimizely
 
   V1_CONFIG_VERSION = '1'
-  V2_CONFIG_VERSION = '2'
 
-  SUPPORTED_VERSIONS = [V2_CONFIG_VERSION]
   UNSUPPORTED_VERSIONS = [V1_CONFIG_VERSION]
 
   class ProjectConfig
@@ -31,25 +29,33 @@ module Optimizely
     attr_reader :error_handler
     attr_reader :logger
 
-    attr_reader :parsing_succeeded
-    attr_reader :version
     attr_reader :account_id
-    attr_reader :project_id
     attr_reader :attributes
+    attr_reader :audiences
     attr_reader :events
     attr_reader :experiments
+    attr_reader :feature_flags
     attr_reader :groups
+    attr_reader :parsing_succeeded
+    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 :revision
-    attr_reader :audiences
+    attr_reader :rollouts
+    attr_reader :version
 
     attr_reader :attribute_key_map
     attr_reader :audience_id_map
     attr_reader :event_key_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 :audience_id_map
+    attr_reader :rollout_id_map
+    attr_reader :rollout_experiment_id_map
     attr_reader :variation_id_map
+    attr_reader :variation_id_to_variable_usage_map
     attr_reader :variation_key_map
 
     # Hash of user IDs to a Hash
@@ -75,13 +81,16 @@ module Optimizely
       end
 
       @account_id = config['accountId']
-      @project_id = config['projectId']
-      @attributes = config['attributes']
-      @events = config['events']
+      @attributes = config.fetch('attributes', [])
+      @audiences = config.fetch('audiences', [])
+      @events = config.fetch('events', [])
       @experiments = config['experiments']
-      @revision = config['revision']
-      @audiences = config['audiences']
+      @feature_flags = config.fetch('featureFlags', [])
       @groups = config.fetch('groups', [])
+      @project_id = config['projectId']
+      @anonymize_ip = (config.has_key? 'anonymizeIP')? config['anonymizeIP'] :false
+      @revision = config['revision']
+      @rollouts = config.fetch('rollouts', [])
 
       # Utility maps for quick lookup
       @attribute_key_map = generate_key_map(@attributes, 'key')
@@ -102,9 +111,38 @@ module Optimizely
       @variation_id_to_variable_usage_map = {}
       @variation_id_to_experiment_map = {}
       @experiment_key_map.each do |key, 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 id map for rollouts
+      @rollout_experiment_id_map = {}
+      @rollout_id_map.each do |id, rollout|
+        exps = rollout.fetch('experiments')
+        @rollout_experiment_id_map = @rollout_experiment_id_map.merge(generate_key_map(exps, 'id'))
+      end
+      @all_experiments = @experiment_key_map.merge(@rollout_experiment_id_map)
+      @all_experiments.each do |key, exp|
         variations = exp.fetch('variations')
         @variation_id_map[key] = generate_key_map(variations, 'id')
         @variation_key_map[key] = generate_key_map(variations, 'key')
+
+        variations.each do |variation|
+          variation_id = variation['id']
+          variation_variables = variation['variables']
+          unless variation_variables.nil?
+            @variation_id_to_variable_usage_map[variation_id] = generate_key_map(variation_variables, 'id')
+          end
+        end
+      end
+      @feature_flag_key_map = generate_key_map(@feature_flags, 'key')
+      @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')
       end
       @parsing_succeeded = true
     end
@@ -123,7 +161,7 @@ module Optimizely
       #
       # experiment_key - String key representing the experiment
       #
-      # Returns Experiment
+      # Returns Experiment or nil if not found
 
       experiment = @experiment_key_map[experiment_key]
       return experiment if experiment
@@ -174,28 +212,6 @@ module Optimizely
       nil
     end
 
-    def get_variation_key_from_id(experiment_key, variation_id)
-      # Get variation key given experiment key and variation ID
-      #
-      # experiment_key - Key representing parent experiment of variation
-      # variation_id - ID of the variation
-      #
-      # Returns key of the variation
-
-      variation_id_map = @variation_id_map[experiment_key]
-      if variation_id_map
-        variation = variation_id_map[variation_id]
-        return variation['key'] 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_from_id(experiment_key, variation_id)
       # Get variation given experiment key and variation ID
       #
@@ -298,7 +314,7 @@ module Optimizely
       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
 
@@ -339,7 +355,7 @@ module Optimizely
         return false
       end
 
-      unless @forced_variation_map.has_key? user_id
+      unless @forced_variation_map.has_key? user_id 
         @forced_variation_map[user_id] = {}
       end
       @forced_variation_map[user_id][experiment_id] = variation_id
@@ -383,6 +399,44 @@ module Optimizely
       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
+
     private
 
     def generate_key_map(array, key)