optimizely-sdk 3.3.2 → 3.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 7a2fc40c97158de70c4ec1d0eee4db872cac0b5a
-  data.tar.gz: f754bd8cd02ef852bf16cc555ceca5a03ebd39f3
+SHA256:
+  metadata.gz: 84b914d98655786586e8f691c82529bb3a8f074a6c157aceff6c2ef0ab4a4e3e
+  data.tar.gz: 484164de6c112f23adc94568371a33f564a99dba714c3141cf156783cb638a5d
 SHA512:
-  metadata.gz: dfafb0abdfa7df11a1e2bd57423b1a543158ecbc3de564f1500274070c00071b1e87edf79f94f4e95b39cedd913e554865e51a783542c8a111ddaca1afd4641b
-  data.tar.gz: 6bb7cba088585ecb5caa429e159b609653563001c90a185c8c22f8b187edce064b8c291a360072facf203118f40b9c3e45cf27d02603d65a444918dbbc5db44e
+  metadata.gz: b56b571c9aed79bdf0fdce664fa8ae24c152e52ac6804f3621c1597701a0293e4e105e0ce2db482d75640e81d7c8d9d1db085d70d0aa8827290277c87c280f68
+  data.tar.gz: a68af4ec2b0f7d02411e543aae1ca8e141d0be7a992e2d57ac6cd3c40e54ed3437ff39df312907914a679c7b75853902d4ab016b562428ae543f0af50730cabf

data/lib/optimizely.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #
-#    Copyright 2016-2019, Optimizely and contributors
+#    Copyright 2016-2020, 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.
@@ -33,6 +33,7 @@ require_relative 'optimizely/helpers/validator'
 require_relative 'optimizely/helpers/variable_type'
 require_relative 'optimizely/logger'
 require_relative 'optimizely/notification_center'
+require_relative 'optimizely/optimizely_config'
 
 module Optimizely
   class Project
@@ -139,7 +140,10 @@ module Optimizely
 
       # Create and dispatch impression event
       experiment = config.get_experiment_from_key(experiment_key)
-      send_impression(config, experiment, variation_key, user_id, attributes)
+      send_impression(
+        config, experiment, variation_key, '', experiment_key, true,
+        Optimizely::DecisionService::DECISION_SOURCES['EXPERIMENT'], user_id, attributes
+      )
 
       variation_key
     end
@@ -315,14 +319,23 @@ module Optimizely
             experiment_key: decision.experiment['key'],
             variation_key: variation['key']
           }
-          # Send event if Decision came from an experiment.
-          send_impression(config, decision.experiment, variation['key'], user_id, attributes)
-        else
-          @logger.log(Logger::DEBUG,
-                      "The user '#{user_id}' is not being experimented on in feature '#{feature_flag_key}'.")
+          # Send event if Decision came from a feature test.
+          send_impression(
+            config, decision.experiment, variation['key'], feature_flag_key, decision.experiment['key'], feature_enabled, source_string, user_id, attributes
+          )
+        elsif decision.source == Optimizely::DecisionService::DECISION_SOURCES['ROLLOUT'] && config.send_flag_decisions
+          send_impression(
+            config, decision.experiment, variation['key'], feature_flag_key, decision.experiment['key'], feature_enabled, source_string, user_id, attributes
+          )
         end
       end
 
+      if decision.nil? && config.send_flag_decisions
+        send_impression(
+          config, nil, '', feature_flag_key, '', feature_enabled, source_string, user_id, attributes
+        )
+      end
+
       @notification_center.send_notifications(
         NotificationCenter::NOTIFICATION_TYPES[:DECISION],
         Helpers::Constants::DECISION_NOTIFICATION_TYPES['FEATURE'],
@@ -429,6 +442,32 @@ module Optimizely
       variable_value
     end
 
+    # Get the Json value of the specified variable in the feature flag in a Dict.
+    #
+    # @param feature_flag_key - String key of feature flag the variable belongs to
+    # @param variable_key - String key of variable for which we are getting the string value
+    # @param user_id - String user ID
+    # @param attributes - Hash representing visitor attributes and values which need to be recorded.
+    #
+    # @return [Dict] the Dict containing variable value.
+    # @return [nil] if the feature flag or variable are not found.
+
+    def get_feature_variable_json(feature_flag_key, variable_key, user_id, attributes = nil)
+      unless is_valid
+        @logger.log(Logger::ERROR, InvalidProjectConfigError.new('get_feature_variable_json').message)
+        return nil
+      end
+      variable_value = get_feature_variable_for_type(
+        feature_flag_key,
+        variable_key,
+        Optimizely::Helpers::Constants::VARIABLE_TYPES['JSON'],
+        user_id,
+        attributes
+      )
+
+      variable_value
+    end
+
     # Get the Boolean value of the specified variable in the feature flag.
     #
     # @param feature_flag_key - String key of feature flag the variable belongs to
@@ -483,6 +522,71 @@ module Optimizely
       variable_value
     end
 
+    # Get values of all the variables in the feature flag and returns them in a Dict
+    #
+    # @param feature_flag_key - String key of feature flag
+    # @param user_id - String user ID
+    # @param attributes - Hash representing visitor attributes and values which need to be recorded.
+    #
+    # @return [Dict] the Dict containing all the varible values
+    # @return [nil] if the feature flag is not found.
+
+    def get_all_feature_variables(feature_flag_key, user_id, attributes = nil)
+      unless is_valid
+        @logger.log(Logger::ERROR, InvalidProjectConfigError.new('get_all_feature_variables').message)
+        return nil
+      end
+
+      return nil unless Optimizely::Helpers::Validator.inputs_valid?(
+        {
+          feature_flag_key: feature_flag_key,
+          user_id: user_id
+        },
+        @logger, Logger::ERROR
+      )
+
+      return nil unless user_inputs_valid?(attributes)
+
+      config = project_config
+
+      feature_flag = config.get_feature_flag_from_key(feature_flag_key)
+      unless feature_flag
+        @logger.log(Logger::INFO, "No feature flag was found for key '#{feature_flag_key}'.")
+        return nil
+      end
+
+      decision = @decision_service.get_variation_for_feature(config, feature_flag, user_id, attributes)
+      variation = decision ? decision['variation'] : nil
+      feature_enabled = variation ? variation['featureEnabled'] : false
+      all_variables = {}
+
+      feature_flag['variables'].each do |variable|
+        variable_value = get_feature_variable_for_variation(feature_flag_key, feature_enabled, variation, variable, user_id)
+        all_variables[variable['key']] = Helpers::VariableType.cast_value_to_type(variable_value, variable['type'], @logger)
+      end
+
+      source_string = Optimizely::DecisionService::DECISION_SOURCES['ROLLOUT']
+      if decision && decision['source'] == Optimizely::DecisionService::DECISION_SOURCES['FEATURE_TEST']
+        source_info = {
+          experiment_key: decision.experiment['key'],
+          variation_key: variation['key']
+        }
+        source_string = Optimizely::DecisionService::DECISION_SOURCES['FEATURE_TEST']
+      end
+
+      @notification_center.send_notifications(
+        NotificationCenter::NOTIFICATION_TYPES[:DECISION],
+        Helpers::Constants::DECISION_NOTIFICATION_TYPES['ALL_FEATURE_VARIABLES'], user_id, (attributes || {}),
+        feature_key: feature_flag_key,
+        feature_enabled: feature_enabled,
+        source: source_string,
+        variable_values: all_variables,
+        source_info: source_info || {}
+      )
+
+      all_variables
+    end
+
     # Get the Integer value of the specified variable in the feature flag.
     #
     # @param feature_flag_key - String key of feature flag the variable belongs to
@@ -523,6 +627,57 @@ module Optimizely
       @event_processor.stop! if @event_processor.respond_to?(:stop!)
     end
 
+    def get_optimizely_config
+      # Get OptimizelyConfig object containing experiments and features data
+      # Returns Object
+      #
+      # OptimizelyConfig Object Schema
+      # {
+      #   'experimentsMap' => {
+      #     'my-fist-experiment' => {
+      #       'id' => '111111',
+      #       'key' => 'my-fist-experiment'
+      #       'variationsMap' => {
+      #         'variation_1' => {
+      #           'id' => '121212',
+      #           'key' => 'variation_1',
+      #           'variablesMap' => {
+      #             'age' => {
+      #               'id' => '222222',
+      #               'key' => 'age',
+      #               'type' => 'integer',
+      #               'value' => '0',
+      #             }
+      #           }
+      #         }
+      #       }
+      #     }
+      #   },
+      #   'featuresMap' => {
+      #     'awesome-feature' => {
+      #       'id' => '333333',
+      #       'key' => 'awesome-feature',
+      #       'experimentsMap' => Object,
+      #       'variablesMap' => Object,
+      #     }
+      #   },
+      #   'revision' => '13',
+      # }
+      #
+      unless is_valid
+        @logger.log(Logger::ERROR, InvalidProjectConfigError.new('get_optimizely_config').message)
+        return nil
+      end
+
+      # config_manager might not contain optimizely_config if its supplied by the consumer
+      # Generating a new OptimizelyConfig object in this case as a fallback
+      if @config_manager.respond_to?(:optimizely_config)
+        @config_manager.optimizely_config
+      else
+        OptimizelyConfig.new(project_config).config
+      end
+    end
+
     private
 
     def get_variation_with_config(experiment_key, user_id, attributes, config)
@@ -597,8 +752,6 @@ module Optimizely
       # Error message logged in DatafileProjectConfig- get_feature_flag_from_key
       return nil if variable.nil?
 
-      feature_enabled = false
-
       # If variable_type is nil, set it equal to variable['type']
       variable_type ||= variable['type']
       # Returns nil if type differs
@@ -606,43 +759,24 @@ module Optimizely
         @logger.log(Logger::WARN,
                     "Requested variable as type '#{variable_type}' but variable '#{variable_key}' is of type '#{variable['type']}'.")
         return nil
-      else
-        source_string = Optimizely::DecisionService::DECISION_SOURCES['ROLLOUT']
-        decision = @decision_service.get_variation_for_feature(config, feature_flag, user_id, attributes)
-        variable_value = variable['defaultValue']
-        if decision
-          variation = decision['variation']
-          if decision['source'] == Optimizely::DecisionService::DECISION_SOURCES['FEATURE_TEST']
-            source_info = {
-              experiment_key: decision.experiment['key'],
-              variation_key: variation['key']
-            }
-            source_string = Optimizely::DecisionService::DECISION_SOURCES['FEATURE_TEST']
-          end
-          feature_enabled = variation['featureEnabled']
-          if feature_enabled == true
-            variation_variable_usages = config.variation_id_to_variable_usage_map[variation['id']]
-            variable_id = variable['id']
-            if variation_variable_usages&.key?(variable_id)
-              variable_value = variation_variable_usages[variable_id]['value']
-              @logger.log(Logger::INFO,
-                          "Got variable value '#{variable_value}' for variable '#{variable_key}' of feature flag '#{feature_flag_key}'.")
-            else
-              @logger.log(Logger::DEBUG,
-                          "Variable '#{variable_key}' is not used in variation '#{variation['key']}'. Returning the default variable value '#{variable_value}'.")
-            end
-          else
-            @logger.log(Logger::DEBUG,
-                        "Feature '#{feature_flag_key}' for variation '#{variation['key']}' is not enabled. Returning the default variable value '#{variable_value}'.")
-          end
-        else
-          @logger.log(Logger::INFO,
-                      "User '#{user_id}' was not bucketed into any variation for feature flag '#{feature_flag_key}'. Returning the default variable value '#{variable_value}'.")
-        end
       end
 
+      decision = @decision_service.get_variation_for_feature(config, feature_flag, user_id, attributes)
+      variation = decision ? decision['variation'] : nil
+      feature_enabled = variation ? variation['featureEnabled'] : false
+
+      variable_value = get_feature_variable_for_variation(feature_flag_key, feature_enabled, variation, variable, user_id)
       variable_value = Helpers::VariableType.cast_value_to_type(variable_value, variable_type, @logger)
 
+      source_string = Optimizely::DecisionService::DECISION_SOURCES['ROLLOUT']
+      if decision && decision['source'] == Optimizely::DecisionService::DECISION_SOURCES['FEATURE_TEST']
+        source_info = {
+          experiment_key: decision.experiment['key'],
+          variation_key: variation['key']
+        }
+        source_string = Optimizely::DecisionService::DECISION_SOURCES['FEATURE_TEST']
+      end
+
       @notification_center.send_notifications(
         NotificationCenter::NOTIFICATION_TYPES[:DECISION],
         Helpers::Constants::DECISION_NOTIFICATION_TYPES['FEATURE_VARIABLE'], user_id, (attributes || {}),
@@ -658,6 +792,46 @@ module Optimizely
       variable_value
     end
 
+    def get_feature_variable_for_variation(feature_flag_key, feature_enabled, variation, variable, user_id)
+      # Helper method to get the non type-casted value for a variable attached to a
+      # feature flag. Returns appropriate variable value depending on whether there
+      # was a matching variation, feature was enabled or not or varible was part of the
+      # available variation or not. Also logs the appropriate message explaining how it
+      # evaluated the value of the variable.
+      #
+      # feature_flag_key - String key of feature flag the variable belongs to
+      # feature_enabled - Boolean indicating if feature is enabled or not
+      # variation - varition returned by decision service
+      # user_id - String user ID
+      #
+      # Returns string value of the variable.
+
+      config = project_config
+      variable_value = variable['defaultValue']
+      if variation
+        if feature_enabled == true
+          variation_variable_usages = config.variation_id_to_variable_usage_map[variation['id']]
+          variable_id = variable['id']
+          if variation_variable_usages&.key?(variable_id)
+            variable_value = variation_variable_usages[variable_id]['value']
+            @logger.log(Logger::INFO,
+                        "Got variable value '#{variable_value}' for variable '#{variable['key']}' of feature flag '#{feature_flag_key}'.")
+          else
+            @logger.log(Logger::DEBUG,
+                        "Variable value is not defined. Returning the default variable value '#{variable_value}' for variable '#{variable['key']}'.")
+
+          end
+        else
+          @logger.log(Logger::DEBUG,
+                      "Feature '#{feature_flag_key}' is not enabled for user '#{user_id}'. Returning the default variable value '#{variable_value}'.")
+        end
+      else
+        @logger.log(Logger::INFO,
+                    "User '#{user_id}' was not bucketed into experiment or rollout for feature flag '#{feature_flag_key}'. Returning the default variable value '#{variable_value}'.")
+      end
+      variable_value
+    end
+
     def user_inputs_valid?(attributes = nil, event_tags = nil)
       # Helper method to validate user inputs.
       #
@@ -705,15 +879,43 @@ module Optimizely
       raise InvalidInputError, 'event_dispatcher'
     end
 
-    def send_impression(config, experiment, variation_key, user_id, attributes = nil)
+    def send_impression(config, experiment, variation_key, flag_key, rule_key, enabled, rule_type, user_id, attributes = nil)
+      if experiment.nil?
+        experiment = {
+          'id' => '',
+          'key' => '',
+          'layerId' => '',
+          'status' => '',
+          'variations' => [],
+          'trafficAllocation' => [],
+          'audienceIds' => [],
+          'audienceConditions' => [],
+          'forcedVariations' => {}
+        }
+      end
+
       experiment_key = experiment['key']
-      variation_id = config.get_variation_id_from_key(experiment_key, variation_key)
-      user_event = UserEventFactory.create_impression_event(config, experiment, variation_id, user_id, attributes)
+
+      variation_id = ''
+      variation_id = config.get_variation_id_from_key(experiment_key, variation_key) if experiment_key != ''
+
+      metadata = {
+        flag_key: flag_key,
+        rule_key: rule_key,
+        rule_type: rule_type,
+        variation_key: variation_key,
+        enabled: enabled
+      }
+
+      user_event = UserEventFactory.create_impression_event(config, experiment, variation_id, metadata, user_id, attributes)
       @event_processor.process(user_event)
       return unless @notification_center.notification_count(NotificationCenter::NOTIFICATION_TYPES[:ACTIVATE]).positive?
 
       @logger.log(Logger::INFO, "Activating user '#{user_id}' in experiment '#{experiment_key}'.")
-      variation = config.get_variation_from_id(experiment_key, variation_id)
+
+      experiment = nil if experiment_key == ''
+      variation = nil
+      variation = config.get_variation_from_id(experiment_key, variation_id) unless experiment.nil?
       log_event = EventFactory.create_log_event(user_event, @logger)
       @notification_center.send_notifications(
         NotificationCenter::NOTIFICATION_TYPES[:ACTIVATE],

data/lib/optimizely/audience.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #
-#    Copyright 2016-2017, 2019, Optimizely and contributors
+#    Copyright 2016-2017, 2019-2020, 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.
@@ -24,23 +24,32 @@ module Optimizely
   module Audience
     module_function
 
-    def user_in_experiment?(config, experiment, attributes, logger)
-      # Determine for given experiment if user satisfies the audiences for the experiment.
+    def user_meets_audience_conditions?(config, experiment, attributes, logger, logging_hash = nil, logging_key = nil)
+      # Determine for given experiment/rollout rule if user satisfies the audience conditions.
       #
       # config - Representation of the Optimizely project config.
-      # experiment - Experiment for which visitor is to be bucketed.
+      # experiment - Experiment/Rollout rule in which user is to be bucketed.
       # attributes - Hash representing user attributes which will be used in determining if
       #              the audience conditions are met.
+      # logger - Provides a logger instance.
+      # logging_hash - Optional string representing logs hash inside Helpers::Constants.
+      #                This defaults to 'EXPERIMENT_AUDIENCE_EVALUATION_LOGS'.
+      # logging_key - Optional string to be logged as an identifier of experiment under evaluation.
+      #               This defaults to experiment['key'].
       #
       # Returns boolean representing if user satisfies audience conditions for the audiences or not.
+      logging_hash ||= 'EXPERIMENT_AUDIENCE_EVALUATION_LOGS'
+      logging_key ||= experiment['key']
+
+      logs_hash = Object.const_get "Optimizely::Helpers::Constants::#{logging_hash}"
 
       audience_conditions = experiment['audienceConditions'] || experiment['audienceIds']
 
       logger.log(
         Logger::DEBUG,
         format(
-          Helpers::Constants::AUDIENCE_EVALUATION_LOGS['EVALUATING_AUDIENCES_COMBINED'],
-          experiment['key'],
+          logs_hash['EVALUATING_AUDIENCES_COMBINED'],
+          logging_key,
           audience_conditions
         )
       )
@@ -50,8 +59,8 @@ module Optimizely
         logger.log(
           Logger::INFO,
           format(
-            Helpers::Constants::AUDIENCE_EVALUATION_LOGS['AUDIENCE_EVALUATION_RESULT_COMBINED'],
-            experiment['key'],
+            logs_hash['AUDIENCE_EVALUATION_RESULT_COMBINED'],
+            logging_key,
             'TRUE'
           )
         )
@@ -74,7 +83,7 @@ module Optimizely
         logger.log(
           Logger::DEBUG,
           format(
-            Helpers::Constants::AUDIENCE_EVALUATION_LOGS['EVALUATING_AUDIENCE'],
+            logs_hash['EVALUATING_AUDIENCE'],
             audience_id,
             audience_conditions
           )
@@ -84,8 +93,8 @@ module Optimizely
         result = ConditionTreeEvaluator.evaluate(audience_conditions, evaluate_custom_attr)
         result_str = result.nil? ? 'UNKNOWN' : result.to_s.upcase
         logger.log(
-          Logger::INFO,
-          format(Helpers::Constants::AUDIENCE_EVALUATION_LOGS['AUDIENCE_EVALUATION_RESULT'], audience_id, result_str)
+          Logger::DEBUG,
+          format(logs_hash['AUDIENCE_EVALUATION_RESULT'], audience_id, result_str)
         )
         result
       end
@@ -97,8 +106,8 @@ module Optimizely
       logger.log(
         Logger::INFO,
         format(
-          Helpers::Constants::AUDIENCE_EVALUATION_LOGS['AUDIENCE_EVALUATION_RESULT_COMBINED'],
-          experiment['key'],
+          logs_hash['AUDIENCE_EVALUATION_RESULT_COMBINED'],
+          logging_key,
           eval_result.to_s.upcase
         )
       )