optimizely-sdk 5.0.1 → 5.2.0

data/lib/optimizely/decision_service.rb

@@ -29,7 +29,8 @@ module Optimizely
     # 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
+    # 6. Check cmab service
+    # 7. Use Murmurhash3 to bucket the user
 
     attr_reader :bucketer
 
@@ -37,32 +38,39 @@ module Optimizely
     # This contains all the forced variations set by the user by calling setForcedVariation.
     attr_reader :forced_variation_map
 
-    Decision = Struct.new(:experiment, :variation, :source)
+    Decision = Struct.new(:experiment, :variation, :source, :cmab_uuid)
+    CmabDecisionResult = Struct.new(:error, :result, :reasons)
+    VariationResult = Struct.new(:cmab_uuid, :error, :reasons, :variation_id)
+    DecisionResult = Struct.new(:decision, :error, :reasons)
 
     DECISION_SOURCES = {
       'EXPERIMENT' => 'experiment',
       'FEATURE_TEST' => 'feature-test',
-      'ROLLOUT' => 'rollout'
+      'ROLLOUT' => 'rollout',
+      'HOLDOUT' => 'holdout'
     }.freeze
 
-    def initialize(logger, user_profile_service = nil)
+    def initialize(logger, cmab_service, user_profile_service = nil)
       @logger = logger
       @user_profile_service = user_profile_service
       @bucketer = Bucketer.new(logger)
       @forced_variation_map = {}
+      @cmab_service = cmab_service
     end
 
-    def get_variation(project_config, experiment_id, user_context, decide_options = [])
+    def get_variation(project_config, experiment_id, user_context, user_profile_tracker = nil, decide_options = [], reasons = [])
       # Determines variation into which user will be bucketed.
       #
       # project_config - project_config - Instance of ProjectConfig
       # experiment_id - Experiment for which visitor variation needs to be determined
       # user_context - Optimizely user context instance
+      # user_profile_tracker: Tracker for reading and updating user profile of the user.
+      # reasons: Decision reasons.
       #
-      # Returns variation ID where visitor will be bucketed
-      #   (nil if experiment is inactive or user does not meet audience conditions)
-
+      # Returns VariationResult struct
+      user_profile_tracker = UserProfileTracker.new(user_context.user_id, @user_profile_service, @logger) unless user_profile_tracker.is_a?(Optimizely::UserProfileTracker)
       decide_reasons = []
+      decide_reasons.push(*reasons)
       user_id = user_context.user_id
       attributes = user_context.user_attributes
       # By default, the bucketing ID should be the user ID
@@ -70,38 +78,36 @@ module Optimizely
       decide_reasons.push(*bucketing_id_reasons)
       # Check to make sure experiment is active
       experiment = project_config.get_experiment_from_id(experiment_id)
-      return nil, decide_reasons if experiment.nil?
+      return VariationResult.new(nil, false, decide_reasons, nil) if experiment.nil?
 
       experiment_key = experiment['key']
       unless project_config.experiment_running?(experiment)
         message = "Experiment '#{experiment_key}' is not running."
         @logger.log(Logger::INFO, message)
         decide_reasons.push(message)
-        return nil, decide_reasons
+        return VariationResult.new(nil, false, decide_reasons, nil)
       end
 
       # Check if a forced variation is set for the user
       forced_variation, reasons_received = get_forced_variation(project_config, experiment['key'], user_id)
       decide_reasons.push(*reasons_received)
-      return forced_variation['id'], decide_reasons if forced_variation
+      return VariationResult.new(nil, false, decide_reasons, forced_variation['id']) if forced_variation
 
       # Check if user is in a white-listed variation
       whitelisted_variation_id, reasons_received = get_whitelisted_variation_id(project_config, experiment_id, user_id)
       decide_reasons.push(*reasons_received)
-      return whitelisted_variation_id, decide_reasons if whitelisted_variation_id
+      return VariationResult.new(nil, false, decide_reasons, whitelisted_variation_id) if whitelisted_variation_id
 
       should_ignore_user_profile_service = decide_options.include? Optimizely::Decide::OptimizelyDecideOption::IGNORE_USER_PROFILE_SERVICE
       # Check for saved bucketing decisions if decide_options do not include ignoreUserProfileService
-      unless should_ignore_user_profile_service
-        user_profile, reasons_received = get_user_profile(user_id)
-        decide_reasons.push(*reasons_received)
-        saved_variation_id, reasons_received = get_saved_variation_id(project_config, experiment_id, user_profile)
+      unless should_ignore_user_profile_service && user_profile_tracker
+        saved_variation_id, reasons_received = get_saved_variation_id(project_config, experiment_id, user_profile_tracker.user_profile)
         decide_reasons.push(*reasons_received)
         if saved_variation_id
           message = "Returning previously activated variation ID #{saved_variation_id} of experiment '#{experiment_key}' for user '#{user_id}' from user profile."
           @logger.log(Logger::INFO, message)
           decide_reasons.push(message)
-          return saved_variation_id, decide_reasons
+          return VariationResult.new(nil, false, decide_reasons, saved_variation_id)
         end
       end
 
@@ -112,27 +118,45 @@ module Optimizely
         message = "User '#{user_id}' does not meet the conditions to be in experiment '#{experiment_key}'."
         @logger.log(Logger::INFO, message)
         decide_reasons.push(message)
-        return nil, decide_reasons
+        return VariationResult.new(nil, false, decide_reasons, nil)
       end
 
-      # Bucket normally
-      variation, bucket_reasons = @bucketer.bucket(project_config, experiment, bucketing_id, user_id)
-      decide_reasons.push(*bucket_reasons)
-      variation_id = variation ? variation['id'] : nil
+      # Check if this is a CMAB experiment
+      # If so, handle CMAB-specific traffic allocation and decision logic.
+      # Otherwise, proceed with standard bucketing logic for non-CMAB experiments.
+      if experiment.key?('cmab')
+        cmab_decision_result = get_decision_for_cmab_experiment(project_config, experiment, user_context, bucketing_id, decide_options)
+        decide_reasons.push(*cmab_decision_result.reasons)
+        if cmab_decision_result.error
+          # CMAB decision failed, return error
+          return VariationResult.new(nil, true, decide_reasons, nil)
+        end
 
-      message = ''
-      if variation_id
-        variation_key = variation['key']
-        message = "User '#{user_id}' is in variation '#{variation_key}' of experiment '#{experiment_id}'."
+        cmab_decision = cmab_decision_result.result
+        variation_id = cmab_decision&.variation_id
+        cmab_uuid = cmab_decision&.cmab_uuid
+        variation = variation_id ? project_config.get_variation_from_id_by_experiment_id(experiment_id, variation_id) : nil
       else
-        message = "User '#{user_id}' is in no variation."
+        # Bucket normally
+        variation, bucket_reasons = @bucketer.bucket(project_config, experiment, bucketing_id, user_id)
+        decide_reasons.push(*bucket_reasons)
+        variation_id = variation ? variation['id'] : nil
+        cmab_uuid = nil
       end
+
+      variation_key = variation['key'] if variation
+      message = if variation_id
+                  "User '#{user_id}' is in variation '#{variation_key}' of experiment '#{experiment_id}'."
+                else
+                  "User '#{user_id}' is in no variation."
+                end
+
       @logger.log(Logger::INFO, message)
-      decide_reasons.push(message)
+      decide_reasons.push(message) if message
 
       # Persist bucketing decision
-      save_user_profile(user_profile, experiment_id, variation_id) unless should_ignore_user_profile_service
-      [variation_id, decide_reasons]
+      user_profile_tracker.update_user_profile(experiment_id, variation_id) unless should_ignore_user_profile_service && user_profile_tracker
+      VariationResult.new(cmab_uuid, false, decide_reasons, variation_id)
     end
 
     def get_variation_for_feature(project_config, feature_flag, user_context, decide_options = [])
@@ -142,30 +166,175 @@ module Optimizely
       # feature_flag - The feature flag the user wants to access
       # user_context - Optimizely user context instance
       #
-      # Returns Decision struct (nil if the user is not bucketed into any of the experiments on the feature)
+      # Returns DecisionResult struct.
+      holdouts = project_config.get_holdouts_for_flag(feature_flag['id'])
+
+      if holdouts && !holdouts.empty?
+        # Has holdouts - use get_decision_for_flag which checks holdouts first
+        get_decision_for_flag(feature_flag, user_context, project_config, decide_options)
+      else
+        get_variations_for_feature_list(project_config, [feature_flag], user_context, decide_options).first
+      end
+    end
+
+    def get_decision_for_flag(feature_flag, user_context, project_config, decide_options = [], user_profile_tracker = nil, decide_reasons = nil)
+      # Get the decision for a single feature flag.
+      # Processes holdouts, experiments, and rollouts in that order.
+      #
+      # feature_flag - The feature flag to get a decision for
+      # user_context - The user context
+      # project_config - The project config
+      # decide_options - Array of decide options
+      # user_profile_tracker - The user profile tracker
+      # decide_reasons - Array of decision reasons to merge
+      #
+      # Returns a DecisionResult for the feature flag
+
+      reasons = decide_reasons ? decide_reasons.dup : []
+      user_id = user_context.user_id
+
+      # Check holdouts
+      holdouts = project_config.get_holdouts_for_flag(feature_flag['id'])
+
+      holdouts.each do |holdout|
+        holdout_decision = get_variation_for_holdout(holdout, user_context, project_config)
+        reasons.push(*holdout_decision.reasons)
+
+        next unless holdout_decision.decision
+
+        message = "The user '#{user_id}' is bucketed into holdout '#{holdout['key']}' for feature flag '#{feature_flag['key']}'."
+        @logger.log(Logger::INFO, message)
+        reasons.push(message)
+        return DecisionResult.new(holdout_decision.decision, false, reasons)
+      end
+
+      # Check if the feature flag has an experiment and the user is bucketed into that experiment
+      experiment_decision = get_variation_for_feature_experiment(project_config, feature_flag, user_context, user_profile_tracker, decide_options)
+      reasons.push(*experiment_decision.reasons)
+
+      return DecisionResult.new(experiment_decision.decision, experiment_decision.error, reasons) if experiment_decision.decision
+
+      # Check if the feature flag has a rollout and the user is bucketed into that rollout
+      rollout_decision = get_variation_for_feature_rollout(project_config, feature_flag, user_context)
+      reasons.push(*rollout_decision.reasons)
+
+      if rollout_decision.decision
+        # Check if this was a forced decision (last reason contains "forced decision map")
+        is_forced_decision = reasons.last&.include?('forced decision map')
+
+        unless is_forced_decision
+          # Only add the "bucketed into rollout" message for normal bucketing
+          message = "The user '#{user_id}' is bucketed into a rollout for feature flag '#{feature_flag['key']}'."
+          @logger.log(Logger::INFO, message)
+          reasons.push(message)
+        end
+
+        DecisionResult.new(rollout_decision.decision, rollout_decision.error, reasons)
+      else
+        message = "The user '#{user_id}' is not bucketed into a rollout for feature flag '#{feature_flag['key']}'."
+        @logger.log(Logger::INFO, message)
+        DecisionResult.new(nil, false, reasons)
+      end
+    end
+
+    def get_variation_for_holdout(holdout, user_context, project_config)
+      # Get the variation for holdout
+      #
+      # holdout - The holdout configuration
+      # user_context - The user context
+      # project_config - The project config
+      #
+      # Returns a DecisionResult for the holdout
 
       decide_reasons = []
+      user_id = user_context.user_id
+      attributes = user_context.user_attributes
 
-      # check if the feature is being experiment on and whether the user is bucketed into the experiment
-      decision, reasons_received = get_variation_for_feature_experiment(project_config, feature_flag, user_context, decide_options)
-      decide_reasons.push(*reasons_received)
-      return decision, decide_reasons unless decision.nil?
+      if holdout.nil? || holdout['status'].nil? || holdout['status'] != 'Running'
+        key = holdout && holdout['key'] ? holdout['key'] : 'unknown'
+        message = "Holdout '#{key}' is not running."
+        @logger.log(Logger::INFO, message)
+        decide_reasons.push(message)
+        return DecisionResult.new(nil, false, decide_reasons)
+      end
 
-      decision, reasons_received = get_variation_for_feature_rollout(project_config, feature_flag, user_context)
+      bucketing_id, bucketing_id_reasons = get_bucketing_id(user_id, attributes)
+      decide_reasons.push(*bucketing_id_reasons)
+
+      # Check audience conditions
+      user_meets_audience_conditions, reasons_received = Audience.user_meets_audience_conditions?(project_config, holdout, user_context, @logger)
       decide_reasons.push(*reasons_received)
 
-      [decision, decide_reasons]
+      unless user_meets_audience_conditions
+        message = "User '#{user_id}' does not meet the conditions for holdout '#{holdout['key']}'."
+        @logger.log(Logger::DEBUG, message)
+        decide_reasons.push(message)
+        return DecisionResult.new(nil, false, decide_reasons)
+      end
+
+      # Bucket user into holdout variation
+      variation, bucket_reasons = @bucketer.bucket(project_config, holdout, bucketing_id, user_id)
+      decide_reasons.push(*bucket_reasons)
+
+      if variation && !variation['key'].nil? && !variation['key'].empty?
+        message = "The user '#{user_id}' is bucketed into variation '#{variation['key']}' of holdout '#{holdout['key']}'."
+        @logger.log(Logger::INFO, message)
+        decide_reasons.push(message)
+
+        holdout_decision = Decision.new(holdout, variation, DECISION_SOURCES['HOLDOUT'], nil)
+        DecisionResult.new(holdout_decision, false, decide_reasons)
+      else
+        message = "The user '#{user_id}' is not bucketed into holdout '#{holdout['key']}'."
+        @logger.log(Logger::DEBUG, message)
+        decide_reasons.push(message)
+        DecisionResult.new(nil, false, decide_reasons)
+      end
     end
 
-    def get_variation_for_feature_experiment(project_config, feature_flag, user_context, decide_options = [])
+    def get_variations_for_feature_list(project_config, feature_flags, user_context, decide_options = [])
+      # Returns the list of experiment/variation the user is bucketed in for the given list of features.
+      #
+      # Args:
+      #   project_config: Instance of ProjectConfig.
+      #   feature_flags: Array of features for which we are determining if it is enabled or not for the given user.
+      #   user_context: User context for user.
+      #   decide_options: Decide options.
+      #
+      # Returns:
+      #   Array of DecisionResult struct.
+      ignore_ups = decide_options.include? Optimizely::Decide::OptimizelyDecideOption::IGNORE_USER_PROFILE_SERVICE
+      user_profile_tracker = nil
+      unless ignore_ups && @user_profile_service
+        user_id = user_context.user_id
+        user_profile_tracker = UserProfileTracker.new(user_id, @user_profile_service, @logger)
+        user_profile_tracker.load_user_profile
+      end
+
+      decisions = []
+      feature_flags.each do |feature_flag|
+        # check if the feature is being experiment on and whether the user is bucketed into the experiment
+        decision_result = get_variation_for_feature_experiment(project_config, feature_flag, user_context, user_profile_tracker, decide_options)
+        # Only process rollout if no experiment decision was found and no error
+        if decision_result.decision.nil? && !decision_result.error
+          decision_result_rollout = get_variation_for_feature_rollout(project_config, feature_flag, user_context) unless decision_result.decision
+          decision_result.decision = decision_result_rollout.decision
+          decision_result.reasons.push(*decision_result_rollout.reasons)
+        end
+        decisions << decision_result
+      end
+      user_profile_tracker&.save_user_profile
+      decisions
+    end
+
+    def get_variation_for_feature_experiment(project_config, feature_flag, user_context, user_profile_tracker, decide_options = [])
       # Gets the variation the user is bucketed into for the feature flag's experiment.
       #
       # project_config - project_config - Instance of ProjectConfig
       # feature_flag - The feature flag the user wants to access
       # user_context - Optimizely user context instance
       #
-      # Returns Decision struct (nil if the user is not bucketed into any of the experiments on the feature)
-      # or nil if the user is not bucketed into any of the experiments on the feature
+      # Returns a DecisionResult containing the decision (or nil if not bucketed),
+      # an error flag, and an array of decision reasons.
       decide_reasons = []
       user_id = user_context.user_id
       feature_flag_key = feature_flag['key']
@@ -173,7 +342,7 @@ module Optimizely
         message = "The feature flag '#{feature_flag_key}' is not used in any experiments."
         @logger.log(Logger::DEBUG, message)
         decide_reasons.push(message)
-        return nil, decide_reasons
+        return DecisionResult.new(nil, false, decide_reasons)
       end
 
       # Evaluate each experiment and return the first bucketed experiment variation
@@ -183,26 +352,34 @@ module Optimizely
           message = "Feature flag experiment with ID '#{experiment_id}' is not in the datafile."
           @logger.log(Logger::DEBUG, message)
           decide_reasons.push(message)
-          return nil, decide_reasons
+          return DecisionResult.new(nil, false, decide_reasons)
         end
 
         experiment_id = experiment['id']
-        variation_id, reasons_received = get_variation_from_experiment_rule(project_config, feature_flag_key, experiment, user_context, decide_options)
+        variation_result = get_variation_from_experiment_rule(project_config, feature_flag_key, experiment, user_context, user_profile_tracker, decide_options)
+        error = variation_result.error
+        reasons_received = variation_result.reasons
+        variation_id = variation_result.variation_id
+        cmab_uuid = variation_result.cmab_uuid
         decide_reasons.push(*reasons_received)
 
+        # If there's an error, return immediately instead of falling back to next experiment
+        return DecisionResult.new(nil, error, decide_reasons) if error
+
         next unless variation_id
 
         variation = project_config.get_variation_from_id_by_experiment_id(experiment_id, variation_id)
         variation = project_config.get_variation_from_flag(feature_flag['key'], variation_id, 'id') if variation.nil?
 
-        return Decision.new(experiment, variation, DECISION_SOURCES['FEATURE_TEST']), decide_reasons
+        decision = Decision.new(experiment, variation, DECISION_SOURCES['FEATURE_TEST'], cmab_uuid)
+        return DecisionResult.new(decision, error, decide_reasons)
       end
 
       message = "The user '#{user_id}' is not bucketed into any of the experiments on the feature '#{feature_flag_key}'."
       @logger.log(Logger::INFO, message)
       decide_reasons.push(message)
 
-      [nil, decide_reasons]
+      DecisionResult.new(nil, false, decide_reasons)
     end
 
     def get_variation_for_feature_rollout(project_config, feature_flag, user_context)
@@ -213,7 +390,8 @@ module Optimizely
       # feature_flag - The feature flag the user wants to access
       # user_context - Optimizely user context instance
       #
-      # Returns the Decision struct or nil if not bucketed into any of the targeting rules
+      # Returns a DecisionResult containing the decision (or nil if not bucketed),
+      # an error flag, and an array of decision reasons.
       decide_reasons = []
 
       rollout_id = feature_flag['rolloutId']
@@ -222,7 +400,7 @@ module Optimizely
         message = "Feature flag '#{feature_flag_key}' is not used in a rollout."
         @logger.log(Logger::DEBUG, message)
         decide_reasons.push(message)
-        return nil, decide_reasons
+        return DecisionResult.new(nil, false, decide_reasons)
       end
 
       rollout = project_config.get_rollout_from_id(rollout_id)
@@ -230,10 +408,10 @@ module Optimizely
         message = "Rollout with ID '#{rollout_id}' is not in the datafile '#{feature_flag['key']}'"
         @logger.log(Logger::DEBUG, message)
         decide_reasons.push(message)
-        return nil, decide_reasons
+        return DecisionResult.new(nil, false, decide_reasons)
       end
 
-      return nil, decide_reasons if rollout['experiments'].empty?
+      return DecisionResult.new(nil, false, decide_reasons) if rollout['experiments'].empty?
 
       index = 0
       rollout_rules = rollout['experiments']
@@ -242,17 +420,17 @@ module Optimizely
         decide_reasons.push(*reasons_received)
         if variation
           rule = rollout_rules[index]
-          feature_decision = Decision.new(rule, variation, DECISION_SOURCES['ROLLOUT'])
-          return [feature_decision, decide_reasons]
+          feature_decision = Decision.new(rule, variation, DECISION_SOURCES['ROLLOUT'], nil)
+          return DecisionResult.new(feature_decision, false, decide_reasons)
         end
 
         index = skip_to_everyone_else ? (rollout_rules.length - 1) : (index + 1)
       end
 
-      [nil, decide_reasons]
+      DecisionResult.new(nil, false, decide_reasons)
     end
 
-    def get_variation_from_experiment_rule(project_config, flag_key, rule, user, options = [])
+    def get_variation_from_experiment_rule(project_config, flag_key, rule, user, user_profile_tracker, options = [])
       # Determine which variation the user is in for a given rollout.
       # Returns the variation from experiment rules.
       #
@@ -267,13 +445,11 @@ module Optimizely
       context = Optimizely::OptimizelyUserContext::OptimizelyDecisionContext.new(flag_key, rule['key'])
       variation, forced_reasons = validated_forced_decision(project_config, context, user)
       reasons.push(*forced_reasons)
+      return VariationResult.new(nil, false, reasons, variation['id']) if variation
 
-      return [variation['id'], reasons] if variation
-
-      variation_id, response_reasons = get_variation(project_config, rule['id'], user, options)
-      reasons.push(*response_reasons)
-
-      [variation_id, reasons]
+      variation_result = get_variation(project_config, rule['id'], user, user_profile_tracker, options)
+      variation_result.reasons = reasons + variation_result.reasons
+      variation_result
     end
 
     def get_variation_from_delivery_rule(project_config, flag_key, rules, rule_index, user_context)
@@ -441,6 +617,51 @@ module Optimizely
 
     private
 
+    def get_decision_for_cmab_experiment(project_config, experiment, user_context, bucketing_id, decide_options = [])
+      # Determines the CMAB (Contextual Multi-Armed Bandit) decision for a given experiment and user context.
+      #
+      # This method first checks if the user is bucketed into the CMAB experiment based on traffic allocation.
+      # If the user is not bucketed, it returns a CmabDecisionResult indicating exclusion.
+      # If the user is bucketed, it attempts to fetch a CMAB decision using the CMAB service.
+      # In case of errors during CMAB decision retrieval, it logs the error and returns a result indicating failure.
+      #
+      # @param project_config [ProjectConfig] The current project configuration.
+      # @param experiment [Hash] The experiment configuration hash.
+      # @param user_context [OptimizelyUserContext] The user context object containing user information.
+      # @param bucketing_id [String] The bucketing ID used for traffic allocation.
+      # @param decide_options [Array] Optional array of decision options.
+      #
+      # @return [CmabDecisionResult] The result of the CMAB decision process, including decision error status, decision data, and reasons.
+      decide_reasons = []
+      user_id = user_context.user_id
+
+      # Check if user is in CMAB traffic allocation
+      bucketed_entity_id, bucket_reasons = @bucketer.bucket_to_entity_id(
+        project_config, experiment, bucketing_id, user_id
+      )
+      decide_reasons.push(*bucket_reasons)
+      unless bucketed_entity_id
+        message = "User \"#{user_context.user_id}\" not in CMAB experiment \"#{experiment['key']}\" due to traffic allocation."
+        @logger.log(Logger::INFO, message)
+        decide_reasons.push(message)
+        return CmabDecisionResult.new(false, nil, decide_reasons)
+      end
+
+      # User is in CMAB allocation, proceed to CMAB decision
+      begin
+        cmab_decision, reasons = @cmab_service.get_decision(
+          project_config, user_context, experiment['id'], decide_options
+        )
+        decide_reasons.push(*reasons)
+        CmabDecisionResult.new(false, cmab_decision, decide_reasons)
+      rescue StandardError => e
+        error_message = "Failed to fetch CMAB data for experiment #{experiment['key']}."
+        decide_reasons.push(error_message)
+        @logger&.log(Logger::ERROR, "#{error_message} #{e}")
+        CmabDecisionResult.new(true, nil, decide_reasons)
+      end
+    end
+
     def get_whitelisted_variation_id(project_config, experiment_id, user_id)
       # Determine if a user is whitelisted into a variation for the given experiment and return the ID of that variation
       #

data/lib/optimizely/event/entity/event_context.rb

@@ -26,7 +26,8 @@ module Optimizely
       anonymize_ip:,
       revision:,
       client_name:,
-      client_version:
+      client_version:,
+      region:
     )
       @account_id = account_id
       @project_id = project_id
@@ -34,6 +35,7 @@ module Optimizely
       @revision = revision
       @client_name = client_name
       @client_version = client_version
+      @region = region
     end
 
     def as_json
@@ -43,7 +45,8 @@ module Optimizely
         anonymize_ip: @anonymize_ip,
         revision: @revision,
         client_name: @client_name,
-        client_version: @client_version
+        client_version: @client_version,
+        region: @region
       }
     end
   end

data/lib/optimizely/event/event_factory.rb

@@ -28,7 +28,10 @@ module Optimizely
     # EventFactory builds LogEvent objects from a given user_event.
     class << self
       CUSTOM_ATTRIBUTE_FEATURE_TYPE = 'custom'
-      ENDPOINT = 'https://logx.optimizely.com/v1/events'
+      ENDPOINTS = {
+        US: 'https://logx.optimizely.com/v1/events',
+        EU: 'https://eu.logx.optimizely.com/v1/events'
+      }.freeze
       POST_HEADERS = {'Content-Type' => 'application/json'}.freeze
       ACTIVATE_EVENT_KEY = 'campaign_activated'
 
@@ -67,7 +70,10 @@ module Optimizely
 
         builder.with_visitors(visitors)
         event_batch = builder.build
-        Event.new(:post, ENDPOINT, event_batch.as_json, POST_HEADERS)
+
+        endpoint = ENDPOINTS[user_context[:region].to_s.upcase.to_sym] || ENDPOINTS[:US]
+
+        Event.new(:post, endpoint, event_batch.as_json, POST_HEADERS)
       end
 
       def build_attribute_list(user_attributes, project_config)

data/lib/optimizely/event/user_event_factory.rb

@@ -33,6 +33,7 @@ module Optimizely
       #
       # Returns Event encapsulating the impression event.
       event_context = Optimizely::EventContext.new(
+        region: project_config.region,
         account_id: project_config.account_id,
         project_id: project_config.project_id,
         anonymize_ip: project_config.anonymize_ip,
@@ -67,6 +68,7 @@ module Optimizely
       # Returns Event encapsulating the conversion event.
 
       event_context = Optimizely::EventContext.new(
+        region: project_config.region,
         account_id: project_config.account_id,
         project_id: project_config.project_id,
         anonymize_ip: project_config.anonymize_ip,

data/lib/optimizely/event_builder.rb

@@ -78,7 +78,7 @@ module Optimizely
         )
       end
       # Append Bot Filtering Attribute
-      if project_config.bot_filtering == true || project_config.bot_filtering == false
+      if [true, false].include?(project_config.bot_filtering)
         visitor_attributes.push(
           entity_id: Optimizely::Helpers::Constants::CONTROL_ATTRIBUTES['BOT_FILTERING'],
           key: Optimizely::Helpers::Constants::CONTROL_ATTRIBUTES['BOT_FILTERING'],
@@ -101,13 +101,17 @@ module Optimizely
         revision: project_config.revision,
         client_name: CLIENT_ENGINE,
         enrich_decisions: true,
-        client_version: VERSION
+        client_version: VERSION,
+        region: project_config.region || 'US'
       }
     end
   end
 
   class EventBuilder < BaseEventBuilder
-    ENDPOINT = 'https://logx.optimizely.com/v1/events'
+    ENDPOINTS = {
+      US: 'https://logx.optimizely.com/v1/events',
+      EU: 'https://eu.logx.optimizely.com/v1/events'
+    }.freeze
     POST_HEADERS = {'Content-Type' => 'application/json'}.freeze
     ACTIVATE_EVENT_KEY = 'campaign_activated'
 
@@ -122,11 +126,14 @@ module Optimizely
       #
       # Returns +Event+ encapsulating the impression event.
 
+      region = project_config.region || 'US'
       event_params = get_common_params(project_config, user_id, attributes)
       impression_params = get_impression_params(project_config, experiment, variation_id)
       event_params[:visitors][0][:snapshots].push(impression_params)
 
-      Event.new(:post, ENDPOINT, event_params, POST_HEADERS)
+      endpoint = ENDPOINTS[region.to_s.upcase.to_sym]
+
+      Event.new(:post, endpoint, event_params, POST_HEADERS)
     end
 
     def create_conversion_event(project_config, event, user_id, attributes, event_tags)
@@ -140,11 +147,14 @@ module Optimizely
       #
       # Returns +Event+ encapsulating the conversion event.
 
+      region = project_config.region || 'US'
       event_params = get_common_params(project_config, user_id, attributes)
       conversion_params = get_conversion_params(event, event_tags)
       event_params[:visitors][0][:snapshots] = [conversion_params]
 
-      Event.new(:post, ENDPOINT, event_params, POST_HEADERS)
+      endpoint = ENDPOINTS[region.to_s.upcase.to_sym]
+
+      Event.new(:post, endpoint, event_params, POST_HEADERS)
     end
 
     private