splitclient-rb 1.0.2.wip → 8.11.1.pre.rc1-java

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Cache
+    module Senders
+      class ImpressionsSender
+        def initialize(impressions_repository, config, impressions_api)
+          @impressions_repository = impressions_repository
+          @config = config
+          @impressions_api = impressions_api
+        end
+
+        def call
+          impressions_thread
+        end
+
+        private
+
+        def impressions_thread
+          @config.threads[:impressions_sender] = Thread.new do
+            begin
+              @config.logger.info('Starting impressions service')
+
+              loop do
+                post_impressions(false)
+
+                sleep(SplitIoClient::Utilities.randomize_interval(@config.impressions_refresh_rate))
+              end
+            rescue SplitIoClient::SDKShutdownException
+              post_impressions
+
+              @config.logger.info('Posting impressions due to shutdown')
+            end
+          end
+        end
+
+        def post_impressions(fetch_all_impressions = true)
+          formatted_impressions = ImpressionsFormatter.new(@impressions_repository)
+            .call(fetch_all_impressions)
+
+          impressions_api.post(formatted_impressions)
+        rescue StandardError => e
+          @config.log_found_exception(__method__.to_s, e)
+        end
+
+        def impressions_api
+          @impressions_api
+        end
+      end
+    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