splitclient-rb 6.3.0 → 8.11.0

data/lib/splitclient-rb/cache/senders/events_sender.rb

@@ -4,54 +4,37 @@ module SplitIoClient
   module Cache
     module Senders
       class EventsSender
-        def initialize(events_repository, api_key)
+        def initialize(events_repository, config)
           @events_repository = events_repository
-          @api_key = api_key
+          @config = config
         end
 
-        def call
-          if ENV['SPLITCLIENT_ENV'] == 'test'
-            post_events
-          else
-            events_thread
-
-            if defined?(PhusionPassenger)
-              PhusionPassenger.on_event(:starting_worker_process) do |forked|
-                events_thread if forked
-              end
-            end
-          end
+        def call          
+          events_thread
         end
 
         private
 
         def events_thread
-          SplitIoClient.configuration.threads[:events_sender] = Thread.new do
+          @config.threads[:events_sender] = Thread.new do
             begin
-              SplitIoClient.configuration.logger.info('Starting events service')
-              
+              @config.logger.info('Starting events service')
+
               loop do
-                post_events(false)
+                post_events
 
-                sleep(SplitIoClient::Utilities.randomize_interval(SplitIoClient.configuration.events_push_rate))
+                sleep(SplitIoClient::Utilities.randomize_interval(@config.events_push_rate))
               end
             rescue SplitIoClient::SDKShutdownException
               post_events
 
-              SplitIoClient.configuration.logger.info('Posting events due to shutdown')
+              @config.logger.info('Posting events due to shutdown')
             end
           end
         end
 
-        def post_events(fetch_all_events = true)
-          events = fetch_all_events ? @events_repository.clear : @events_repository.batch
-          events_api.post(events)
-        rescue StandardError => error
-          SplitIoClient.configuration.log_found_exception(__method__.to_s, error)
-        end
-
-        def events_api
-          @events_api ||= SplitIoClient::Api::Events.new(@api_key)
+        def post_events
+          @events_repository.post_events
         end
       end
     end

data/lib/splitclient-rb/cache/senders/impressions_adapter/memory_sender.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Cache
+    module Senders
+      class MemoryImpressionsSender < ImpressionsSenderAdapter
+        def initialize(config, telemetry_api, impressions_api)
+          @config = config
+          @telemetry_api = telemetry_api
+          @impressions_api = impressions_api
+        end
+
+        def record_uniques_key(uniques)
+          uniques_keys = uniques_formatter(uniques)
+
+          @telemetry_api.record_unique_keys(uniques_keys) unless uniques_keys.nil?
+        rescue StandardError => e
+          @config.log_found_exception(__method__.to_s, e)
+        end
+
+        def record_impressions_count(impressions_count)
+          counts = impressions_count_formatter(impressions_count)
+
+          @impressions_api.post_count(counts) unless counts.nil?
+        rescue StandardError => e
+          @config.log_found_exception(__method__.to_s, e)
+        end
+
+        private 
+
+        def uniques_formatter(uniques)
+          return if uniques.nil? || uniques.empty?
+
+          to_return = { keys: [] }
+          uniques.each do |key, value|
+            to_return[:keys] << {
+              f: key,
+              ks: value.to_a
+            }
+          end
+
+          to_return
+        rescue StandardError => e
+          @config.log_found_exception(__method__.to_s, e)
+          nil
+        end
+
+        def impressions_count_formatter(counts)
+          return if counts.nil? || counts.empty?
+
+          formated_counts = {pf: []}
+
+          counts.each do |key, value|              
+            key_splited = key.split('::')
+            
+            formated_counts[:pf] << {
+              f: key_splited[0].to_s, # feature name
+              m: key_splited[1].to_i, # time frame
+              rc: value # count
+            }
+          end
+
+          formated_counts
+        rescue StandardError => e
+          @config.log_found_exception(__method__.to_s, e)
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/senders/impressions_adapter/redis_sender.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Cache
+    module Senders
+      class RedisImpressionsSender < ImpressionsSenderAdapter
+        EXPIRE_SECONDS = 3600
+
+        def initialize(config)
+          @config = config
+          @adapter = @config.impressions_adapter
+        end
+
+        def record_uniques_key(uniques)
+          return if uniques.nil? || uniques.empty?
+
+          size = @adapter.add_to_queue(unique_keys_key, uniques_formatter(uniques))
+
+          @adapter.expire(unique_keys_key, EXPIRE_SECONDS) if uniques.length == size
+        rescue StandardError => e
+          @config.log_found_exception(__method__.to_s, e)
+        end
+
+        def record_impressions_count(impressions_count)
+          return if impressions_count.nil? || impressions_count.empty?
+
+          result = @adapter.redis.pipelined do |pipeline|
+            impressions_count.each do |key, value|
+              pipeline.hincrby(impressions_count_key, key, value)
+            end
+          end
+
+          expire_impressions_count_key(impressions_count, result)
+        rescue StandardError => e
+          @config.log_found_exception(__method__.to_s, e)
+        end
+
+        private
+
+        def expire_impressions_count_key(impressions_count, pipeline_result)
+          total_count = impressions_count.sum { |_, value| value }
+          hlen = pipeline_result.last
+
+          @adapter.expire(impressions_count_key, EXPIRE_SECONDS) if impressions_count.size == hlen && (pipeline_result.sum - hlen) == total_count
+        end
+
+        def uniques_formatter(uniques)
+          to_return = []
+          uniques.each do |key, value|
+            to_return << {
+              f: key,
+              ks: value.to_a
+            }.to_json
+          end
+
+          to_return
+        end
+
+        def impressions_count_key
+          "#{@config.redis_namespace}.impressions.count"
+        end
+
+        def unique_keys_key
+          "#{@config.redis_namespace}.uniquekeys"
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/senders/impressions_count_sender.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Cache
+    module Senders
+      class ImpressionsCountSender
+        def initialize(config, impression_counter, impressions_sender_adapter)
+          @config = config
+          @impression_counter = impression_counter
+          @impressions_sender_adapter = impressions_sender_adapter
+        end
+
+        def call
+          impressions_count_thread
+        end
+
+        private
+
+        def impressions_count_thread
+          @config.threads[:impressions_count_sender] = Thread.new do
+            begin
+              @config.logger.info('Starting impressions count service')
+              loop do
+                sleep(@config.counter_refresh_rate)
+                post_impressions_count                
+              end
+            rescue SplitIoClient::SDKShutdownException
+              post_impressions_count
+
+              @config.logger.info('Posting impressions count due to shutdown')
+            end
+          end
+        end
+
+        def post_impressions_count
+          @impressions_sender_adapter.record_impressions_count(@impression_counter.pop_all)
+        rescue StandardError => e
+          @config.log_found_exception(__method__.to_s, e)
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/senders/impressions_formatter.rb

@@ -17,12 +17,10 @@ module SplitIoClient
 
           formatted_impressions = unique_features(filtered_impressions).each_with_object([]) do |feature, memo|
             feature_impressions = feature_impressions(filtered_impressions, feature)
-            ip = feature_impressions.first[:m][:i]
             current_impressions = current_impressions(feature_impressions)
             memo << {
-              testName: feature.to_sym,
-              keyImpressions: current_impressions,
-              ip: ip
+              f: feature.to_sym,
+              i: current_impressions
             }
           end
 
@@ -39,14 +37,28 @@ module SplitIoClient
 
         def current_impressions(feature_impressions)
           feature_impressions.map do |impression|
-            {
-              keyName: impression[:i][:k],
-              treatment: impression[:i][:t],
-              time: impression[:i][:m],
-              bucketingKey: impression[:i][:b],
-              label: impression[:i][:r],
-              changeNumber: impression[:i][:c]
-            }
+            if impression[:i][:properties].nil?
+              impression = {
+                k: impression[:i][:k],
+                t: impression[:i][:t],
+                m: impression[:i][:m],
+                b: impression[:i][:b],
+                r: impression[:i][:r],
+                c: impression[:i][:c],
+                pt: impression[:i][:pt]
+              }
+            else
+              impression = {
+                k: impression[:i][:k],
+                t: impression[:i][:t],
+                m: impression[:i][:m],
+                b: impression[:i][:b],
+                r: impression[:i][:r],
+                c: impression[:i][:c],
+                pt: impression[:i][:pt],
+                properties: impression[:i][:properties].to_json.to_s
+              }
+            end
           end
         end
 
@@ -73,7 +85,9 @@ module SplitIoClient
           "#{impression[:i][:k]}:" \
           "#{impression[:i][:b]}:" \
           "#{impression[:i][:c]}:" \
-          "#{impression[:i][:t]}"
+          "#{impression[:i][:t]}:" \
+          "#{impression[:i][:pt]}" \
+          "#{impression[:i][:properties]}" \
         end
       end
     end

data/lib/splitclient-rb/cache/senders/impressions_sender.rb

@@ -4,46 +4,32 @@ module SplitIoClient
   module Cache
     module Senders
       class ImpressionsSender
-        def initialize(impressions_repository, api_key)
+        def initialize(impressions_repository, config, impressions_api)
           @impressions_repository = impressions_repository
-          @api_key = api_key
+          @config = config
+          @impressions_api = impressions_api
         end
 
         def call
-          if SplitIoClient.configuration.disable_impressions
-            SplitIoClient.configuration.logger.info('Disabling impressions service by config')
-            return
-          end
-
-          if ENV['SPLITCLIENT_ENV'] == 'test'
-            post_impressions
-          else
-            impressions_thread
-
-            if defined?(PhusionPassenger)
-              PhusionPassenger.on_event(:starting_worker_process) do |forked|
-                impressions_thread if forked
-              end
-            end
-          end
+          impressions_thread
         end
 
         private
 
         def impressions_thread
-          SplitIoClient.configuration.threads[:impressions_sender] = Thread.new do
+          @config.threads[:impressions_sender] = Thread.new do
             begin
-              SplitIoClient.configuration.logger.info('Starting impressions service')
+              @config.logger.info('Starting impressions service')
 
               loop do
                 post_impressions(false)
 
-                sleep(SplitIoClient::Utilities.randomize_interval(SplitIoClient.configuration.impressions_refresh_rate))
+                sleep(SplitIoClient::Utilities.randomize_interval(@config.impressions_refresh_rate))
               end
             rescue SplitIoClient::SDKShutdownException
               post_impressions
 
-              SplitIoClient.configuration.logger.info('Posting impressions due to shutdown')
+              @config.logger.info('Posting impressions due to shutdown')
             end
           end
         end
@@ -53,12 +39,12 @@ module SplitIoClient
             .call(fetch_all_impressions)
 
           impressions_api.post(formatted_impressions)
-        rescue StandardError => error
-          SplitIoClient.configuration.log_found_exception(__method__.to_s, error)
+        rescue StandardError => e
+          @config.log_found_exception(__method__.to_s, e)
         end
 
         def impressions_api
-          @impressions_api ||= SplitIoClient::Api::Impressions.new(@api_key)
+          @impressions_api
         end
       end
     end

data/lib/splitclient-rb/cache/senders/impressions_sender_adapter.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Cache
+    module Senders
+      class ImpressionsSenderAdapter
+        extend Forwardable
+        def_delegators :@sender, :record_uniques_key, :record_impressions_count
+
+        def initialize(config, telemetry_api, impressions_api)
+          @sender = case config.telemetry_adapter.class.to_s
+                    when 'SplitIoClient::Cache::Adapters::RedisAdapter'
+                      Cache::Senders::RedisImpressionsSender.new(config)
+                    else
+                      Cache::Senders::MemoryImpressionsSender.new(config, telemetry_api, impressions_api)
+                    end
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/senders/localhost_repo_cleaner.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Cache
+    module Senders
+      class LocalhostRepoCleaner
+        def initialize(impressions_repository, events_repository, config)
+          @impressions_repository = impressions_repository
+          @events_repository = events_repository
+          @config = config
+        end
+
+        def call
+          if ENV['SPLITCLIENT_ENV'] == 'test'
+            clear_repositories
+          else
+            cleaner_thread
+
+            if defined?(PhusionPassenger)
+              PhusionPassenger.on_event(:starting_worker_process) do |forked|
+                cleaner_thread if forked
+              end
+            end
+          end
+        end
+
+        private
+
+        def cleaner_thread
+          @config.threads[:repo_cleaner] = Thread.new do
+            @config.logger.info('Starting repositories cleanup service')
+            loop do
+              clear_repositories
+
+              sleep(SplitIoClient::Utilities.randomize_interval(@config.features_refresh_rate))
+            end
+          end
+        end
+
+        def clear_repositories
+          @impressions_repository.clear
+          @events_repository.clear
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+# 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),
+              prerequisites: []
+            }
+          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,110 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Cache
+    module Stores
+      class LocalhostSplitStore
+        require 'yaml'
+        attr_reader :splits_repository
+
+        def initialize(splits_repository, config, status_manager = nil)
+          @splits_repository = splits_repository
+          @config = config
+          @status_manager = status_manager
+        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 feature flags 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
+
+          @status_manager.ready! if @status_manager
+        rescue StandardError => e
+          @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, e)
+        end
+
+        def store_split(split)
+          @config.logger.debug("storing feature flag (#{split[:name]})") if @config.debug_enabled
+
+          @splits_repository.update([split], [], -1)
+        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/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