splitclient-rb 7.0.0.pre.rc3-java → 7.0.1-java

data/lib/splitclient-rb/cache/stores/localhost_split_builder.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Cache
+    module Stores
+      class LocalhostSplitBuilder
+        class << self
+          def build_splits(splits)
+            splits.map do |feature, treatments|
+              build_split(feature, treatments)
+            end
+          end
+
+          private
+
+          def build_split(feature, treatments)
+            {
+              name: feature,
+              status: 'ACTIVE',
+              killed: false,
+              trafficAllocation: 100,
+              seed: 2_089_907_429,
+              defaultTreatment: 'control_treatment',
+              configurations: build_configurations(treatments),
+              conditions: build_conditions(treatments)
+            }
+          end
+
+          def build_configurations(treatments)
+            treatments.reduce({}) do |hash, treatment|
+              hash.merge(treatment[:treatment].to_sym => treatment[:config])
+            end
+          end
+
+          def build_conditions(treatments)
+            conditions = treatments.map do |treatment|
+              if treatment[:keys]
+                build_whitelist_treatment(treatment[:treatment], Array(treatment[:keys]))
+              else
+                build_rollout_treatment
+              end
+                .merge(partitions: build_partitions(treatment[:treatment], treatments))
+            end
+
+            conditions.sort_by { |condition| condition[:conditionType] }.reverse!
+          end
+
+          def build_whitelist_treatment(treatment_name, whitelist_keys)
+            {
+              conditionType: 'WHITELIST',
+              matcherGroup: {
+                combiner: 'AND',
+                matchers: [{
+                  keySelector: nil,
+                  matcherType: 'WHITELIST',
+                  negate: false,
+                  whitelistMatcherData: {
+                    whitelist: whitelist_keys
+                  }
+                }]
+              },
+              label: "whitelisted #{treatment_name}"
+            }
+          end
+
+          def build_rollout_treatment
+            {
+              conditionType: 'ROLLOUT',
+              matcherGroup: {
+                combiner: 'AND',
+                matchers: [
+                  {
+                    matcherType: 'ALL_KEYS',
+                    negate: false
+                  }
+                ]
+              },
+              label: 'default rule'
+            }
+          end
+
+          def build_partitions(current_treatment_name, treatments)
+            treatments.map do |treatment|
+              {
+                treatment: treatment[:treatment],
+                size: treatment[:treatment] == current_treatment_name ? 100 : 0
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/stores/localhost_split_store.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Cache
+    module Stores
+      class LocalhostSplitStore
+        attr_reader :splits_repository
+
+        def initialize(splits_repository, config, sdk_blocker = nil)
+          @splits_repository = splits_repository
+          @config = config
+          @sdk_blocker = sdk_blocker
+        end
+
+        def call
+          if ENV['SPLITCLIENT_ENV'] == 'test'
+            store_splits
+          else
+            splits_thread
+
+            if defined?(PhusionPassenger)
+              PhusionPassenger.on_event(:starting_worker_process) do |forked|
+                splits_thread if forked
+              end
+            end
+          end
+        end
+
+        private
+
+        def splits_thread
+          @config.threads[:split_store] = Thread.new do
+            @config.logger.info('Starting splits fetcher service')
+            loop do
+              store_splits
+
+              sleep(StoreUtils.random_interval(@config.features_refresh_rate))
+            end
+          end
+        end
+
+        def store_splits
+          load_features.each do |split|
+            store_split(split)
+          end
+
+          if @sdk_blocker
+            @sdk_blocker.splits_ready!
+            @sdk_blocker.segments_ready!
+          end
+        rescue StandardError => error
+          @config.logger.error('Error while parsing the split file. ' \
+            'Check that the input file matches the expected format')
+          @config.log_found_exception(__method__.to_s, error)
+        end
+
+        def store_split(split)
+          @config.logger.debug("storing split (#{split[:name]})") if @config.debug_enabled
+
+          @splits_repository.add_split(split)
+        end
+
+        def load_features
+          yaml_extensions = ['.yml', '.yaml']
+          if yaml_extensions.include? File.extname(@config.split_file)
+            parse_yaml_features
+          else
+            @config.logger.warn('Localhost mode: .split mocks ' \
+              'will be deprecated soon in favor of YAML files, which provide more ' \
+              'targeting power. Take a look in our documentation.')
+
+            parse_plain_text_features
+          end
+        end
+
+        def parse_plain_text_features
+          splits = File.open(@config.split_file).each_with_object({}) do |line, memo|
+            feature, treatment = line.strip.split(' ')
+
+            next if line.start_with?('#') || line.strip.empty?
+
+            memo[feature] = [{ treatment: treatment }]
+          end
+
+          LocalhostSplitBuilder.build_splits(splits)
+        end
+
+        def parse_yaml_features
+          splits = YAML.safe_load(File.read(@config.split_file)).each_with_object({}) do |feature, memo|
+            feat_symbolized_keys = symbolize_feat_keys(feature)
+
+            feat_name = feature.keys.first
+
+            if memo[feat_name]
+              memo[feat_name] << feat_symbolized_keys
+            else
+              memo[feat_name] = [feat_symbolized_keys]
+            end
+          end
+
+          LocalhostSplitBuilder.build_splits(splits)
+        end
+
+        def symbolize_feat_keys(yaml_feature)
+          yaml_feature.values.first.each_with_object({}) do |(k, v), memo|
+            memo[k.to_sym] = k == 'config' ? v.to_json : v
+          end
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/stores/segment_store.rb

@@ -38,7 +38,7 @@ module SplitIoClient
               store_segments
               @config.logger.debug("Segment names: #{@segments_repository.used_segment_names.to_a}") if @config.debug_enabled
 
-              sleep_for = random_interval(@config.segments_refresh_rate)
+              sleep_for = StoreUtils.random_interval(@config.segments_refresh_rate)
               @config.logger.debug("Segments store is sleeping for: #{sleep_for} seconds") if @config.debug_enabled
               sleep(sleep_for)
             end
@@ -53,12 +53,6 @@ module SplitIoClient
           @config.log_found_exception(__method__.to_s, error)
         end
 
-        def random_interval(interval)
-          random_factor = Random.new.rand(50..100) / 100.0
-
-          interval * random_factor
-        end
-
         def segments_api
           @segments_api ||= SplitIoClient::Api::Segments.new(@api_key, @metrics, @segments_repository, @config)
         end

data/lib/splitclient-rb/cache/stores/split_store.rb

@@ -34,7 +34,7 @@ module SplitIoClient
             loop do
               store_splits
 
-              sleep(random_interval(@config.features_refresh_rate))
+              sleep(StoreUtils.random_interval(@config.features_refresh_rate))
             end
           end
         end
@@ -57,12 +57,6 @@ module SplitIoClient
           @config.log_found_exception(__method__.to_s, error)
         end
 
-        def random_interval(interval)
-          random_factor = Random.new.rand(50..100) / 100.0
-
-          interval * random_factor
-        end
-
         def splits_since(since)
           splits_api.since(since)
         end

data/lib/splitclient-rb/cache/stores/store_utils.rb

@@ -0,0 +1,13 @@
+module SplitIoClient
+  module Cache
+    module Stores
+      class StoreUtils
+        def self.random_interval(interval)
+          random_factor = Random.new.rand(50..100) / 100.0
+
+          interval * random_factor
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/clients/split_client.rb

@@ -74,11 +74,9 @@ module SplitIoClient
       @destroyed = true
     end
 
-    def store_impression(split_name, matching_key, bucketing_key, treatment, store_impressions, attributes)
+    def store_impression(split_name, matching_key, bucketing_key, treatment, attributes)
       time = (Time.now.to_f * 1000.0).to_i
 
-      return if @config.disable_impressions || !store_impressions
-
       @impressions_repository.add(
         matching_key,
         bucketing_key,
@@ -133,7 +131,7 @@ module SplitIoClient
         end
       end
 
-      if ready? && !@splits_repository.traffic_type_exists(traffic_type_name)
+      if ready? && !@config.localhost_mode && !@splits_repository.traffic_type_exists(traffic_type_name)
         @config.logger.warn("track: Traffic Type #{traffic_type_name} " \
           "does not have any corresponding Splits in this environment, make sure you're tracking " \
           'your events to a valid traffic type defined in the Split console')
@@ -249,14 +247,12 @@ module SplitIoClient
       # Measure
       @adapter.metrics.time('sdk.' + calling_method, latency)
 
-      unless @config.disable_impressions
-        time = (Time.now.to_f * 1000.0).to_i
-        @impressions_repository.add_bulk(
-          matching_key, bucketing_key, treatments_labels_change_numbers, time
-        )
+      time = (Time.now.to_f * 1000.0).to_i
+      @impressions_repository.add_bulk(
+        matching_key, bucketing_key, treatments_labels_change_numbers, time
+      )
 
-        route_impressions(sanitized_split_names, matching_key, bucketing_key, time, treatments_labels_change_numbers, attributes)
-      end
+      route_impressions(sanitized_split_names, matching_key, bucketing_key, time, treatments_labels_change_numbers, attributes)
 
       split_names_keys = treatments_labels_change_numbers.keys
       treatments = treatments_labels_change_numbers.values.map do |v|
@@ -291,6 +287,8 @@ module SplitIoClient
 
       bucketing_key, matching_key = keys_from_key(key)
 
+      attributes = parsed_attributes(attributes)
+
       return parsed_control_exception unless valid_client && @config.split_validator.valid_get_treatment_parameters(calling_method, key, split_name, matching_key, bucketing_key, attributes)
 
       bucketing_key = bucketing_key ? bucketing_key.to_s : nil
@@ -328,14 +326,15 @@ module SplitIoClient
         end
 
         latency = (Time.now - start) * 1000.0
-        store_impression(split_name, matching_key, bucketing_key, treatment_data, store_impressions, attributes)
+
+        store_impression(split_name, matching_key, bucketing_key, treatment_data, attributes) if store_impressions
 
         # Measure
         @adapter.metrics.time('sdk.' + calling_method, latency) unless multiple
       rescue StandardError => error
         @config.log_found_exception(__method__.to_s, error)
 
-        store_impression(split_name, matching_key, bucketing_key, control_treatment, store_impressions, attributes)
+        store_impression(split_name, matching_key, bucketing_key, control_treatment, attributes) if store_impressions
 
         return parsed_control_exception
       end
@@ -351,5 +350,9 @@ module SplitIoClient
       return @sdk_blocker.ready? if @sdk_blocker
       true
     end
+
+    def parsed_attributes(attributes)
+      return attributes || attributes.to_h
+    end
   end
 end

data/lib/splitclient-rb/engine/api/client.rb

@@ -30,6 +30,12 @@ module SplitIoClient
           req.headers = common_headers(api_key)
                         .merge('Content-Type' => 'application/json')
                         .merge(headers)
+          
+          machine_ip = @config.machine_ip
+          machine_name = @config.machine_name
+
+          req.headers = req.headers.merge('SplitSDKMachineIP' => machine_ip) unless machine_ip.empty? || machine_ip == 'unknown'
+          req.headers = req.headers.merge('SplitSDKMachineName' => machine_name) unless machine_name.empty? || machine_name == 'unknown'
 
           req.body = data.to_json
 
@@ -78,19 +84,8 @@ module SplitIoClient
         {
           'Authorization' => "Bearer #{api_key}",
           'SplitSDKVersion' => "#{@config.language}-#{@config.version}",
-          'SplitSDKMachineName' => @config.machine_name,
-          'SplitSDKMachineIP' => @config.machine_ip,
-          'Referer' => referer
         }
       end
-
-      def referer
-        result = "#{@config.language}-#{@config.version}"
-
-        result = "#{result}::#{SplitIoClient::SplitConfig.machine_hostname}" unless SplitIoClient::SplitConfig.machine_hostname == 'localhost'
-
-        result
-      end
     end
   end
 end

data/lib/splitclient-rb/engine/api/events.rb

@@ -18,10 +18,7 @@ module SplitIoClient
           response = post_api(
             "#{@config.events_uri}/events/bulk",
             @api_key,
-            events_slice.map { |event| formatted_event(event[:e]) },
-            'SplitSDKMachineIP' => events_slice[0][:m][:i],
-            'SplitSDKMachineName' => events_slice[0][:m][:n],
-            'SplitSDKVersion' => events_slice[0][:m][:s]
+            events_slice.map { |event| formatted_event(event[:e]) }
           )
 
           if response.success?
@@ -42,7 +39,8 @@ module SplitIoClient
           trafficTypeName: event[:trafficTypeName],
           eventTypeId: event[:eventTypeId],
           value: event[:value].to_f,
-          timestamp: event[:timestamp].to_i
+          timestamp: event[:timestamp].to_i,
+          properties: event[:properties]
         }
       end
     end

data/lib/splitclient-rb/engine/api/impressions.rb

@@ -15,7 +15,7 @@ module SplitIoClient
         end
 
         impressions_by_ip(impressions).each do |ip, impressions_ip|
-          response = post_api("#{@config.events_uri}/testImpressions/bulk", @api_key, impressions_ip, 'SplitSDKMachineIP' => ip)
+          response = post_api("#{@config.events_uri}/testImpressions/bulk", @api_key, impressions_ip)
 
           if response.success?
             @config.split_logger.log_if_debug("Impressions reported: #{total_impressions(impressions)}")

data/lib/splitclient-rb/engine/parser/split_adapter.rb

@@ -44,7 +44,9 @@ module SplitIoClient
       @sdk_blocker = sdk_blocker
       @config = config
 
-      start_standalone_components if @config.standalone?
+      start_localhost_components if @config.localhost_mode
+
+      start_standalone_components if @config.standalone? && !@config.localhost_mode
     end
 
     def start_standalone_components
@@ -55,6 +57,21 @@ module SplitIoClient
       events_sender
     end
 
+    def start_localhost_components
+      localhost_split_store
+      localhost_repo_cleaner
+    end
+
+    # Starts thread which loops constantly and retrieves splits from a file source
+    def localhost_split_store
+      LocalhostSplitStore.new(@splits_repository, @config, @sdk_blocker).call
+    end
+
+    # Starts thread which loops constantly and cleans up repositories to avoid memory issues in localhost mode
+    def localhost_repo_cleaner
+      LocalhostRepoCleaner.new(@impressions_repository, @metrics_repository, @events_repository, @config).call
+    end
+
     # Starts thread which loops constantly and stores splits in the splits_repository of choice
     def split_store
       SplitStore.new(@splits_repository, @api_key, @metrics, @config, @sdk_blocker).call

data/lib/splitclient-rb/managers/split_manager.rb

@@ -3,13 +3,9 @@ module SplitIoClient
     #
     # Creates a new split manager instance that connects to split.io API.
     #
-    # @param api_key [String] the API key for your split account
-    #
     # @return [SplitIoManager] split.io client instance
-    def initialize(api_key, adapter = nil, splits_repository = nil, sdk_blocker, config)
-      @localhost_mode_features = []
+    def initialize(splits_repository = nil, sdk_blocker, config)
       @splits_repository = splits_repository
-      @adapter = adapter
       @sdk_blocker = sdk_blocker
       @config = config
     end
@@ -91,13 +87,18 @@ module SplitIoClient
       return {} unless split
 
       begin
-        treatments = split[:conditions]
-          .detect { |c| c[:conditionType] == 'ROLLOUT' }[:partitions]
-          .map { |partition| partition[:treatment] }
+        if @config.localhost_mode
+          treatments = split[:conditions]
+            .first[:partitions]
+            .map { |partition| partition[:treatment] }
+        else
+          treatments = split[:conditions]
+            .detect { |c| c[:conditionType] == 'ROLLOUT' }[:partitions]
+            .map { |partition| partition[:treatment] }
+        end
       rescue StandardError
         treatments = []
       end
-
         {
           name: name,
           traffic_type_name: split[:trafficTypeName],