[FSSDK-11459] Ruby - Add SDK Multi-Region Support for Data Hosting

Author: esrakartalOpt

lib/optimizely/config/datafile_project_config.rb

@@ -32,7 +32,7 @@ class DatafileProjectConfig < ProjectConfig
                 :group_id_map, :rollout_id_map, :rollout_experiment_id_map, :variation_id_map,
                 :variation_id_to_variable_usage_map, :variation_key_map, :variation_id_map_by_experiment_id,
                 :variation_key_map_by_experiment_id, :flag_variation_map, :integration_key_map, :integrations,
-                :public_key_for_odp, :host_for_odp, :all_segments
+                :public_key_for_odp, :host_for_odp, :all_segments, :region
     # Boolean - denotes if Optimizely should remove the last block of visitors' IP address before storing event data
     attr_reader :anonymize_ip
 
@@ -68,6 +68,7 @@ def initialize(datafile, logger, error_handler)
       @rollouts = config.fetch('rollouts', [])
       @send_flag_decisions = config.fetch('sendFlagDecisions', false)
       @integrations = config.fetch('integrations', [])
+      @region = config.fetch('region', 'US')
 
       # Json type is represented in datafile as a subtype of string for the sake of backwards compatibility.
       # Converting it to a first-class json type while creating Project Config

lib/optimizely/event/event_factory.rb

@@ -28,7 +28,10 @@ class EventFactory
     # 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'
+      }
       POST_HEADERS = {'Content-Type' => 'application/json'}.freeze
       ACTIVATE_EVENT_KEY = 'campaign_activated'
 
@@ -64,9 +67,13 @@ def create_log_event(user_events, logger)
         builder.with_client_name(user_context[:client_name])
         builder.with_anonymize_ip(user_context[:anonymize_ip])
         builder.with_enrich_decisions(true)
+        builder.with_region(user_context[:region])
 
         builder.with_visitors(visitors)
         event_batch = builder.build
+
+        ENDPOINT = ENDPOINTS[user_context[:region].to_sym] || ENDPOINTS[:US]
+
         Event.new(:post, ENDPOINT, event_batch.as_json, POST_HEADERS)
       end
 

lib/optimizely/event/user_event_factory.rb

@@ -33,6 +33,7 @@ def self.create_impression_event(project_config, experiment, variation_id, metad
       #
       # 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 @@ def self.create_conversion_event(project_config, event, user_id, user_attributes
       # 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,

lib/optimizely/event_builder.rb

@@ -107,7 +107,10 @@ def get_common_params(project_config, user_id, attributes)
   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'
+    }
     POST_HEADERS = {'Content-Type' => 'application/json'}.freeze
     ACTIVATE_EVENT_KEY = 'campaign_activated'
 
@@ -122,10 +125,13 @@ def create_impression_event(project_config, experiment, variation_id, user_id, a
       #
       # 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)
 
+      ENDPOINT = ENDPOINTS[region]
+
       Event.new(:post, ENDPOINT, event_params, POST_HEADERS)
     end
 
@@ -140,10 +146,13 @@ def create_conversion_event(project_config, event, user_id, attributes, event_ta
       #
       # 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]
 
+      ENDPOINT = ENDPOINTS[region]
+
       Event.new(:post, ENDPOINT, event_params, POST_HEADERS)
     end
 

lib/optimizely/project_config.rb

@@ -62,6 +62,8 @@ def host_for_odp; end
 
     def all_segments; end
 
+    def region; end
+
     def experiment_running?(experiment); end
 
     def get_experiment_from_key(experiment_key); end

spec/config/datafile_project_config_spec.rb

@@ -57,6 +57,7 @@
       expect(project_config.sdk_key).to eq(config_body['sdkKey'])
       expect(project_config.environment_key).to eq(config_body['environmentKey'])
       expect(project_config.send_flag_decisions).to eq(config_body['sendFlagDecisions'])
+      expect(project_config.region).to eq(config_body['region'])
 
       expected_attribute_key_map = {
         'browser_type' => config_body['attributes'][0],
@@ -756,6 +757,23 @@
       expect(project_config.rollout_experiment_id_map).to eq(expected_rollout_experiment_id_map)
     end
 
+    it 'should use US region when no region is specified in datafile' do
+      project_config = Optimizely::DatafileProjectConfig.new(config_body_JSON, logger, error_handler)
+      expect(project_config.region).to eq('US')
+    end
+
+    it 'should parse region specified in datafile correctly' do
+      project_configUS = Optimizely::DatafileProjectConfig.new(config_body_JSON, logger, error_handler)
+      expect(project_config.region).to eq('US')
+
+      config_bodyEU = config_body.dup
+      config_bodyEU['region'] = 'EU'
+      config_body_JSON = JSON.dump(config_bodyEU)
+      project_configEU = Optimizely::DatafileProjectConfig.new(config_body_JSON, logger, error_handler)
+
+      expect(project_config.region).to eq('EU')
+    end
+
     it 'should initialize properties correctly upon creating project with typed audience dict' do
       project_config = Optimizely::DatafileProjectConfig.new(JSON.dump(OptimizelySpec::CONFIG_DICT_WITH_TYPED_AUDIENCES), logger, error_handler)
       config_body = OptimizelySpec::CONFIG_DICT_WITH_TYPED_AUDIENCES

spec/event/event_factory_spec.rb

@@ -34,7 +34,10 @@
     allow(Time).to receive(:now).and_return(time_now)
     allow(SecureRandom).to receive(:uuid).and_return('a68cf1ad-0393-4e18-af87-efe8f01a7c9c')
 
-    @expected_endpoint = 'https://logx.optimizely.com/v1/events'
+    @expected_endpoints[:US] = {
+      US: 'https://logx.optimizely.com/v1/events',
+      EU: 'https://eu.logx.optimizely.com/v1/events'
+    }
     @expected_impression_params = {
       account_id: '12001',
       project_id: '111001',
@@ -111,7 +114,7 @@
     impression_event = Optimizely::UserEventFactory.create_impression_event(project_config, experiment, '111128', metadata, 'test_user', nil)
     log_event = Optimizely::EventFactory.create_log_event(impression_event, spy_logger)
     expect(log_event.params).to eq(@expected_impression_params)
-    expect(log_event.url).to eq(@expected_endpoint)
+    expect(log_event.url).to eq(@expected_endpoints[:US])
     expect(log_event.http_verb).to eq(:post)
   end
 
@@ -134,7 +137,7 @@
                                                                             'browser_type' => 'firefox')
     log_event = Optimizely::EventFactory.create_log_event(impression_event, spy_logger)
     expect(log_event.params).to eq(@expected_impression_params)
-    expect(log_event.url).to eq(@expected_endpoint)
+    expect(log_event.url).to eq(@expected_endpoints[:US])
     expect(log_event.http_verb).to eq(:post)
   end
 
@@ -184,7 +187,7 @@
     impression_event = Optimizely::UserEventFactory.create_impression_event(project_config, experiment, '111128', metadata, 'test_user', attributes)
     log_event = Optimizely::EventFactory.create_log_event(impression_event, spy_logger)
     expect(log_event.params).to eq(@expected_impression_params)
-    expect(log_event.url).to eq(@expected_endpoint)
+    expect(log_event.url).to eq(@expected_endpoints[:US])
     expect(log_event.http_verb).to eq(:post)
   end
 
@@ -225,7 +228,7 @@
     impression_event = Optimizely::UserEventFactory.create_impression_event(project_config, experiment, '111128', metadata, 'test_user', attributes)
     log_event = Optimizely::EventFactory.create_log_event(impression_event, spy_logger)
     expect(log_event.params).to eq(@expected_impression_params)
-    expect(log_event.url).to eq(@expected_endpoint)
+    expect(log_event.url).to eq(@expected_endpoints[:US])
     expect(log_event.http_verb).to eq(:post)
   end
 
@@ -248,7 +251,7 @@
                                                                             'browser_type' => false)
     log_event = Optimizely::EventFactory.create_log_event(impression_event, spy_logger)
     expect(log_event.params).to eq(@expected_impression_params)
-    expect(log_event.url).to eq(@expected_endpoint)
+    expect(log_event.url).to eq(@expected_endpoints[:US])
     expect(log_event.http_verb).to eq(:post)
   end
 
@@ -270,7 +273,7 @@
     impression_event = Optimizely::UserEventFactory.create_impression_event(project_config, experiment, '111128', metadata, 'test_user', 'browser_type' => 0)
     log_event = Optimizely::EventFactory.create_log_event(impression_event, spy_logger)
     expect(log_event.params).to eq(@expected_impression_params)
-    expect(log_event.url).to eq(@expected_endpoint)
+    expect(log_event.url).to eq(@expected_endpoints[:US])
     expect(log_event.http_verb).to eq(:post)
   end
 
@@ -286,15 +289,15 @@
                                                                             invalid_attribute: 'sorry_not_sorry')
     log_event = Optimizely::EventFactory.create_log_event(impression_event, spy_logger)
     expect(log_event.params).to eq(@expected_impression_params)
-    expect(log_event.url).to eq(@expected_endpoint)
+    expect(log_event.url).to eq(@expected_endpoints[:US])
     expect(log_event.http_verb).to eq(:post)
   end
 
   it 'should create a valid Event when create_conversion_event is called' do
     conversion_event = Optimizely::UserEventFactory.create_conversion_event(project_config, event, 'test_user', nil, nil)
     log_event = Optimizely::EventFactory.create_log_event(conversion_event, spy_logger)
     expect(log_event.params).to eq(@expected_conversion_params)
-    expect(log_event.url).to eq(@expected_endpoint)
+    expect(log_event.url).to eq(@expected_endpoints[:US])
     expect(log_event.http_verb).to eq(:post)
   end
 
@@ -309,7 +312,7 @@
     conversion_event = Optimizely::UserEventFactory.create_conversion_event(project_config, event, 'test_user', {'browser_type' => 'firefox'}, nil)
     log_event = Optimizely::EventFactory.create_log_event(conversion_event, spy_logger)
     expect(log_event.params).to eq(@expected_conversion_params)
-    expect(log_event.url).to eq(@expected_endpoint)
+    expect(log_event.url).to eq(@expected_endpoints[:US])
     expect(log_event.http_verb).to eq(:post)
   end
 
@@ -322,7 +325,7 @@
     conversion_event = Optimizely::UserEventFactory.create_conversion_event(project_config, event, 'test_user', nil, event_tags)
     log_event = Optimizely::EventFactory.create_log_event(conversion_event, spy_logger)
     expect(log_event.params).to eq(@expected_conversion_params)
-    expect(log_event.url).to eq(@expected_endpoint)
+    expect(log_event.url).to eq(@expected_endpoints[:US])
     expect(log_event.http_verb).to eq(:post)
   end
 
@@ -335,7 +338,7 @@
     conversion_event = Optimizely::UserEventFactory.create_conversion_event(project_config, event, 'test_user', nil, event_tags)
     log_event = Optimizely::EventFactory.create_log_event(conversion_event, spy_logger)
     expect(log_event.params).to eq(@expected_conversion_params)
-    expect(log_event.url).to eq(@expected_endpoint)
+    expect(log_event.url).to eq(@expected_endpoints[:US])
     expect(log_event.http_verb).to eq(:post)
   end
 
@@ -347,7 +350,7 @@
     conversion_event = Optimizely::UserEventFactory.create_conversion_event(project_config, event, 'test_user', nil, event_tags)
     log_event = Optimizely::EventFactory.create_log_event(conversion_event, spy_logger)
     expect(log_event.params).to eq(@expected_conversion_params)
-    expect(log_event.url).to eq(@expected_endpoint)
+    expect(log_event.url).to eq(@expected_endpoints[:US])
     expect(log_event.http_verb).to eq(:post)
   end
 
@@ -359,7 +362,7 @@
     conversion_event = Optimizely::UserEventFactory.create_conversion_event(project_config, event, 'test_user', nil, event_tags)
     log_event = Optimizely::EventFactory.create_log_event(conversion_event, spy_logger)
     expect(log_event.params).to eq(@expected_conversion_params)
-    expect(log_event.url).to eq(@expected_endpoint)
+    expect(log_event.url).to eq(@expected_endpoints[:US])
     expect(log_event.http_verb).to eq(:post)
   end
 
@@ -375,7 +378,7 @@
     conversion_event = Optimizely::UserEventFactory.create_conversion_event(project_config, event, 'test_user', nil, event_tags)
     log_event = Optimizely::EventFactory.create_log_event(conversion_event, spy_logger)
     expect(log_event.params).to eq(@expected_conversion_params)
-    expect(log_event.url).to eq(@expected_endpoint)
+    expect(log_event.url).to eq(@expected_endpoints[:US])
     expect(log_event.http_verb).to eq(:post)
   end
 
@@ -390,7 +393,7 @@
     conversion_event = Optimizely::UserEventFactory.create_conversion_event(project_config, event, 'test_user', nil, event_tags)
     log_event = Optimizely::EventFactory.create_log_event(conversion_event, spy_logger)
     expect(log_event.params).to eq(@expected_conversion_params)
-    expect(log_event.url).to eq(@expected_endpoint)
+    expect(log_event.url).to eq(@expected_endpoints[:US])
     expect(log_event.http_verb).to eq(:post)
   end
 
@@ -404,7 +407,7 @@
     conversion_event = Optimizely::UserEventFactory.create_conversion_event(project_config, event, 'test_user', nil, event_tags)
     log_event = Optimizely::EventFactory.create_log_event(conversion_event, spy_logger)
     expect(log_event.params).to eq(@expected_conversion_params)
-    expect(log_event.url).to eq(@expected_endpoint)
+    expect(log_event.url).to eq(@expected_endpoints[:US])
     expect(log_event.http_verb).to eq(:post)
   end
 
@@ -418,7 +421,7 @@
     conversion_event = Optimizely::UserEventFactory.create_conversion_event(project_config, event, 'test_user', nil, event_tags)
     log_event = Optimizely::EventFactory.create_log_event(conversion_event, spy_logger)
     expect(log_event.params).to eq(@expected_conversion_params)
-    expect(log_event.url).to eq(@expected_endpoint)
+    expect(log_event.url).to eq(@expected_endpoints[:US])
     expect(log_event.http_verb).to eq(:post)
   end
 
@@ -432,7 +435,7 @@
     conversion_event = Optimizely::UserEventFactory.create_conversion_event(project_config, event, 'test_user', nil, event_tags)
     log_event = Optimizely::EventFactory.create_log_event(conversion_event, spy_logger)
     expect(log_event.params).to eq(@expected_conversion_params)
-    expect(log_event.url).to eq(@expected_endpoint)
+    expect(log_event.url).to eq(@expected_endpoints[:US])
     expect(log_event.http_verb).to eq(:post)
   end
 
@@ -447,7 +450,7 @@
     conversion_event = Optimizely::UserEventFactory.create_conversion_event(project_config, event, 'test_user', nil, event_tags)
     log_event = Optimizely::EventFactory.create_log_event(conversion_event, spy_logger)
     expect(log_event.params).to eq(@expected_conversion_params)
-    expect(log_event.url).to eq(@expected_endpoint)
+    expect(log_event.url).to eq(@expected_endpoints[:US])
     expect(log_event.http_verb).to eq(:post)
   end
 
@@ -461,7 +464,7 @@
     conversion_event = Optimizely::UserEventFactory.create_conversion_event(project_config, event, 'test_user', nil, event_tags)
     log_event = Optimizely::EventFactory.create_log_event(conversion_event, spy_logger)
     expect(log_event.params).to eq(@expected_conversion_params)
-    expect(log_event.url).to eq(@expected_endpoint)
+    expect(log_event.url).to eq(@expected_endpoints[:US])
     expect(log_event.http_verb).to eq(:post)
   end
 
@@ -487,7 +490,7 @@
     conversion_event = Optimizely::UserEventFactory.create_conversion_event(project_config, event, 'test_user', {'browser_type' => 'firefox'}, event_tags)
     log_event = Optimizely::EventFactory.create_log_event(conversion_event, spy_logger)
     expect(log_event.params).to eq(@expected_conversion_params)
-    expect(log_event.url).to eq(@expected_endpoint)
+    expect(log_event.url).to eq(@expected_endpoints[:US])
     expect(log_event.http_verb).to eq(:post)
   end
 
@@ -520,7 +523,7 @@
     impression_event = Optimizely::UserEventFactory.create_impression_event(project_config, experiment, '111128', metadata, 'test_user', user_attributes)
     log_event = Optimizely::EventFactory.create_log_event(impression_event, spy_logger)
     expect(log_event.params).to eq(@expected_impression_params)
-    expect(log_event.url).to eq(@expected_endpoint)
+    expect(log_event.url).to eq(@expected_endpoints[:US])
     expect(log_event.http_verb).to eq(:post)
   end
 
@@ -556,7 +559,7 @@
     impression_event = Optimizely::UserEventFactory.create_impression_event(project_config, experiment, '111128', metadata, 'test_user', user_attributes)
     log_event = Optimizely::EventFactory.create_log_event(impression_event, spy_logger)
     expect(log_event.params).to eq(@expected_impression_params)
-    expect(log_event.url).to eq(@expected_endpoint)
+    expect(log_event.url).to eq(@expected_endpoints[:US])
     expect(log_event.http_verb).to eq(:post)
   end
 
@@ -594,7 +597,7 @@
     )
     log_event = Optimizely::EventFactory.create_log_event(impression_event, spy_logger)
     expect(log_event.params).to eq(@expected_impression_params)
-    expect(log_event.url).to eq(@expected_endpoint)
+    expect(log_event.url).to eq(@expected_endpoints[:US])
     expect(log_event.http_verb).to eq(:post)
   end
 
@@ -620,7 +623,7 @@
     conversion_event = Optimizely::UserEventFactory.create_conversion_event(project_config, event, 'test_user', user_attributes, nil)
     log_event = Optimizely::EventFactory.create_log_event(conversion_event, spy_logger)
     expect(log_event.params).to eq(@expected_conversion_params)
-    expect(log_event.url).to eq(@expected_endpoint)
+    expect(log_event.url).to eq(@expected_endpoints[:US])
     expect(log_event.http_verb).to eq(:post)
   end
 
@@ -642,7 +645,7 @@
     conversion_event = Optimizely::UserEventFactory.create_conversion_event(project_config, event, 'test_user', user_attributes, nil)
     log_event = Optimizely::EventFactory.create_log_event(conversion_event, spy_logger)
     expect(log_event.params).to eq(@expected_conversion_params)
-    expect(log_event.url).to eq(@expected_endpoint)
+    expect(log_event.url).to eq(@expected_endpoints[:US])
     expect(log_event.http_verb).to eq(:post)
   end
 
@@ -671,7 +674,7 @@
     conversion_event = Optimizely::UserEventFactory.create_conversion_event(project_config, event, 'test_user', user_attributes, nil)
     log_event = Optimizely::EventFactory.create_log_event(conversion_event, spy_logger)
     expect(log_event.params).to eq(@expected_conversion_params)
-    expect(log_event.url).to eq(@expected_endpoint)
+    expect(log_event.url).to eq(@expected_endpoints[:US])
     expect(log_event.http_verb).to eq(:post)
   end
 end