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

data/lib/splitclient-rb/telemetry/storages/memory.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    module Storages
+      class Memory
+        attr_reader :latencies,
+                    :exceptions,
+                    :factory_counters,
+                    :tags,
+                    :impressions_data_records,
+                    :events_data_records,
+                    :last_synchronization,
+                    :http_errors,
+                    :http_latencies,
+                    :auth_rejections,
+                    :token_refreshes,
+                    :streaming_events,
+                    :session_length,
+                    :updates_from_sse
+
+        def initialize
+          init_latencies
+          init_exceptions
+          init_factory_counters
+          init_impressions_data_records
+          init_events_data_records
+          init_last_synchronization
+          init_http_errors
+          init_http_latencies
+          init_auth_rejections
+          init_token_refreshes
+          init_streaming_events
+          init_session_length
+          init_tags
+          init_updates_from_sse
+        end
+
+        def init_latencies
+          @latencies = Concurrent::Array.new
+          treatment_with_config_by_flag_set_const = Domain::Constants::TREATMENTS_WITH_CONFIG_BY_FLAG_SET
+          treatment_with_config_by_flag_sets_const = Domain::Constants::TREATMENTS_WITH_CONFIG_BY_FLAG_SETS
+
+          array_size = BinarySearchLatencyTracker::BUCKETS.length
+          @latencies << { method: Domain::Constants::TREATMENT, latencies: Concurrent::Array.new(array_size, 0) }
+          @latencies << { method: Domain::Constants::TREATMENTS, latencies: Concurrent::Array.new(array_size, 0) }
+          @latencies << { method: Domain::Constants::TREATMENT_WITH_CONFIG, latencies: Concurrent::Array.new(array_size, 0) }
+          @latencies << { method: Domain::Constants::TREATMENTS_WITH_CONFIG, latencies: Concurrent::Array.new(array_size, 0) }
+          @latencies << { method: Domain::Constants::TREATMENTS_BY_FLAG_SET, latencies: Concurrent::Array.new(array_size, 0) }
+          @latencies << { method: Domain::Constants::TREATMENTS_BY_FLAG_SETS, latencies: Concurrent::Array.new(array_size, 0) }
+          @latencies << { method: treatment_with_config_by_flag_set_const, latencies: Concurrent::Array.new(array_size, 0) }
+          @latencies << { method: treatment_with_config_by_flag_sets_const, latencies: Concurrent::Array.new(array_size, 0) }
+          @latencies << { method: Domain::Constants::TRACK, latencies: Concurrent::Array.new(array_size, 0) }
+        end
+
+        def init_exceptions
+          @exceptions = Concurrent::Array.new
+          treatment_with_config_by_flag_set_const = Domain::Constants::TREATMENTS_WITH_CONFIG_BY_FLAG_SET
+          treatment_with_config_by_flag_sets_const = Domain::Constants::TREATMENTS_WITH_CONFIG_BY_FLAG_SETS
+
+          @exceptions << { method: Domain::Constants::TREATMENT, exceptions: Concurrent::AtomicFixnum.new(0) }
+          @exceptions << { method: Domain::Constants::TREATMENTS, exceptions: Concurrent::AtomicFixnum.new(0) }
+          @exceptions << { method: Domain::Constants::TREATMENT_WITH_CONFIG, exceptions: Concurrent::AtomicFixnum.new(0) }
+          @exceptions << { method: Domain::Constants::TREATMENTS_WITH_CONFIG, exceptions: Concurrent::AtomicFixnum.new(0) }
+          @exceptions << { method: Domain::Constants::TREATMENTS_BY_FLAG_SET, exceptions: Concurrent::AtomicFixnum.new(0) }
+          @exceptions << { method: Domain::Constants::TREATMENTS_BY_FLAG_SETS, exceptions: Concurrent::AtomicFixnum.new(0) }
+          @exceptions << { method: treatment_with_config_by_flag_set_const, exceptions: Concurrent::AtomicFixnum.new(0) }
+          @exceptions << { method: treatment_with_config_by_flag_sets_const, exceptions: Concurrent::AtomicFixnum.new(0) }
+          @exceptions << { method: Domain::Constants::TRACK, exceptions: Concurrent::AtomicFixnum.new(0) }
+        end
+
+        def init_factory_counters
+          @factory_counters = Concurrent::Array.new
+
+          @factory_counters << { action: Domain::Constants::BUR_TIMEOUT, counts: Concurrent::AtomicFixnum.new(0) }
+          @factory_counters << { action: Domain::Constants::NON_READY_USAGES, counts: Concurrent::AtomicFixnum.new(0) }
+        end
+
+        def init_impressions_data_records
+          @impressions_data_records = Concurrent::Array.new
+
+          @impressions_data_records << { type: Domain::Constants::IMPRESSIONS_DEDUPE, value: Concurrent::AtomicFixnum.new(0) }
+          @impressions_data_records << { type: Domain::Constants::IMPRESSIONS_DROPPED, value: Concurrent::AtomicFixnum.new(0) }
+          @impressions_data_records << { type: Domain::Constants::IMPRESSIONS_QUEUED, value: Concurrent::AtomicFixnum.new(0) }
+        end
+
+        def init_events_data_records
+          @events_data_records = Concurrent::Array.new
+
+          @events_data_records << { type: Domain::Constants::EVENTS_DROPPED, value: Concurrent::AtomicFixnum.new(0) }
+          @events_data_records << { type: Domain::Constants::EVENTS_QUEUED, value: Concurrent::AtomicFixnum.new(0) }
+        end
+
+        def init_last_synchronization
+          @last_synchronization = Concurrent::Array.new
+
+          @last_synchronization << { type: Domain::Constants::SPLIT_SYNC, value: Concurrent::AtomicFixnum.new(0) }
+          @last_synchronization << { type: Domain::Constants::SEGMENT_SYNC, value: Concurrent::AtomicFixnum.new(0) }
+          @last_synchronization << { type: Domain::Constants::EVENT_SYNC, value: Concurrent::AtomicFixnum.new(0) }
+          @last_synchronization << { type: Domain::Constants::IMPRESSION_COUNT_SYNC, value: Concurrent::AtomicFixnum.new(0) }
+          @last_synchronization << { type: Domain::Constants::IMPRESSIONS_SYNC, value: Concurrent::AtomicFixnum.new(0) }
+          @last_synchronization << { type: Domain::Constants::TELEMETRY_SYNC, value: Concurrent::AtomicFixnum.new(0) }
+          @last_synchronization << { type: Domain::Constants::TOKEN_SYNC, value: Concurrent::AtomicFixnum.new(0) }
+        end
+
+        def init_tags
+          @tags = Concurrent::Array.new
+        end
+
+        def init_http_errors
+          @http_errors = Concurrent::Array.new
+
+          @http_errors << { type: Domain::Constants::SPLIT_SYNC, value: Concurrent::Hash.new }
+          @http_errors << { type: Domain::Constants::SEGMENT_SYNC, value: Concurrent::Hash.new }
+          @http_errors << { type: Domain::Constants::EVENT_SYNC, value: Concurrent::Hash.new }
+          @http_errors << { type: Domain::Constants::IMPRESSION_COUNT_SYNC, value: Concurrent::Hash.new }
+          @http_errors << { type: Domain::Constants::IMPRESSIONS_SYNC, value: Concurrent::Hash.new }
+          @http_errors << { type: Domain::Constants::TELEMETRY_SYNC, value: Concurrent::Hash.new }
+          @http_errors << { type: Domain::Constants::TOKEN_SYNC, value: Concurrent::Hash.new }
+        end
+
+        def init_http_latencies
+          @http_latencies = Concurrent::Array.new
+
+          array_size = BinarySearchLatencyTracker::BUCKETS.length
+          @http_latencies << { type: Domain::Constants::SPLIT_SYNC, value: Concurrent::Array.new(array_size, 0) }
+          @http_latencies << { type: Domain::Constants::SEGMENT_SYNC, value: Concurrent::Array.new(array_size, 0) }
+          @http_latencies << { type: Domain::Constants::EVENT_SYNC, value: Concurrent::Array.new(array_size, 0) }
+          @http_latencies << { type: Domain::Constants::IMPRESSION_COUNT_SYNC, value: Concurrent::Array.new(array_size, 0) }
+          @http_latencies << { type: Domain::Constants::IMPRESSIONS_SYNC, value: Concurrent::Array.new(array_size, 0) }
+          @http_latencies << { type: Domain::Constants::TELEMETRY_SYNC, value: Concurrent::Array.new(array_size, 0) }
+          @http_latencies << { type: Domain::Constants::TOKEN_SYNC, value: Concurrent::Array.new(array_size, 0) }
+        end
+
+        def init_auth_rejections
+          @auth_rejections = Concurrent::AtomicFixnum.new(0)
+        end
+
+        def init_token_refreshes
+          @token_refreshes = Concurrent::AtomicFixnum.new(0)
+        end
+
+        def init_streaming_events
+          @streaming_events = Concurrent::Array.new
+        end
+
+        def init_session_length
+          @session_length = Concurrent::AtomicFixnum.new(0)
+        end
+
+        def init_updates_from_sse
+          @updates_from_sse = Concurrent::Hash.new
+
+          @updates_from_sse[Domain::Constants::SPLITS] = 0
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/telemetry/sync_task.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    class SyncTask
+      def initialize(config, telemetry_synchronizer)
+        @config = config
+        @telemetry_synchronizer = telemetry_synchronizer
+      end
+
+      def call
+        stats_thread
+      end
+
+      private
+
+      def stats_thread
+        @config.threads[:telemetry_stats_sender] = Thread.new { telemetry_sync_task }
+      end
+
+      def telemetry_sync_task
+        @config.logger.info('Starting Telemetry Sync Task')
+
+        loop do
+          sleep(@config.telemetry_refresh_rate)
+
+          @telemetry_synchronizer.synchronize_stats
+        end
+      rescue SplitIoClient::SDKShutdownException
+        @telemetry_synchronizer.synchronize_stats
+
+        @config.logger.info('Posting Telemetry due to shutdown')
+      end
+    end
+  end
+end

data/lib/splitclient-rb/telemetry/synchronizer.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    class Synchronizer
+      extend Forwardable
+      def_delegators :@synchronizer,
+                     :synchronize_config,
+                     :synchronize_stats
+
+      def initialize(config,
+                     telemtry_consumers,
+                     telemetry_init_producer,
+                     repositories,
+                     telemetry_api,
+                     flag_sets,
+                     flag_sets_invalid)
+        @synchronizer = case config.telemetry_adapter.class.to_s
+                        when 'SplitIoClient::Cache::Adapters::RedisAdapter'
+                          SplitIoClient::Telemetry::RedisSynchronizer.new(config,
+                                                                          telemetry_init_producer)
+                        else
+                          SplitIoClient::Telemetry::MemorySynchronizer.new(config,
+                                                                           telemtry_consumers,
+                                                                           repositories,
+                                                                           telemetry_api,
+                                                                           flag_sets,
+                                                                           flag_sets_invalid)
+                        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/utilitites.rb

@@ -0,0 +1,49 @@
+module SplitIoClient
+  module Utilities
+    extend self
+
+    # Convert String with Time info to its epoch FixNum previously setting to zero the seconds
+    def to_epoch(value)
+      parsed = Time.parse(value)
+      zeroed = Time.new(parsed.year, parsed.month, parsed.day, parsed.hour, parsed.min, 0, 0)
+
+      zeroed.to_i
+    end
+
+    def to_epoch_milis(value)
+      to_epoch(value) * 1000
+    end
+
+    def to_milis_zero_out_from_seconds(value)
+      parsed_value = Time.strptime(value.to_s, '%s').utc
+      zeroed = Time.new(parsed_value.year, parsed_value.month, parsed_value.day, parsed_value.hour, parsed_value.min, 0, 0)
+
+      zeroed.to_i * 1000
+    rescue StandardError
+      return :non_valid_date_info
+    end
+
+    def to_milis_zero_out_from_hour(value)
+      parsed_value = Time.strptime(value.to_s, '%s').utc
+      zeroed = Time.new(parsed_value.year, parsed_value.month, parsed_value.day, 0, 0, 0, 0)
+
+      zeroed.to_i * 1000
+    rescue StandardError
+      return :non_valid_date_info
+    end
+
+    def randomize_interval(interval)
+      random_factor = Random.new.rand(50..100) / 100.0
+
+      interval * random_factor
+    end
+
+    def split_bulk_to_send(items, divisions)
+      to_return = []
+      items.to_a.each_slice(divisions) {|bulk|
+        to_return.push(bulk.to_set)
+      }
+      to_return
+    end
+  end  
+end

data/lib/splitclient-rb/validators.rb

@@ -0,0 +1,361 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  class Validators
+
+    Flagset_regex = /^[a-z0-9][_a-z0-9]{0,49}$/
+    Fallback_treatment_regex = /^[0-9]+[.a-zA-Z0-9_-]*$|^[a-zA-Z]+[a-zA-Z0-9_-]*$/
+    Fallback_treatment_size = 100
+
+    def initialize(config)
+      @config = config
+    end
+
+    def valid_get_treatment_parameters(method, key, split_name, matching_key, bucketing_key, attributes)
+      valid_key?(method, key) &&
+        valid_split_name?(method, split_name) &&
+        valid_matching_key?(method, matching_key) &&
+        valid_bucketing_key?(method, key, bucketing_key) &&
+        valid_attributes?(method, attributes)
+    end
+
+    def valid_get_treatments_parameters(method, key, split_names, matching_key, bucketing_key, attributes)
+      valid_key?(method, key) &&
+        valid_split_names?(method, split_names)
+        valid_matching_key?(method, matching_key) &&
+        valid_bucketing_key?(method, key, bucketing_key) &&
+        valid_attributes?(method, attributes)
+    end
+
+    def valid_track_parameters(key, traffic_type_name, event_type, value, properties)
+      valid_track_key?(key) &&
+        valid_traffic_type_name?(traffic_type_name) &&
+        valid_event_type?(event_type) &&
+        valid_value?(value) &&
+        valid_properties?(properties)
+    end
+
+    def valid_split_parameters(split_name)
+      valid_split_name?(:split, split_name)
+    end
+
+    def valid_matcher_arguments(args)
+      return false if !args.key?(:attributes) && !args.key?(:value)
+      return false if args.key?(:value) && args[:value].nil?
+      return false if args.key?(:attributes) && args[:attributes].nil?
+      true
+    end
+
+    def valid_flag_sets(method, flag_sets)
+      if flag_sets.nil? || !flag_sets.is_a?(Array)
+        @config.logger.error("#{method}: FlagSets must be a non-empty list.")
+        return []
+      end
+      if flag_sets.empty?
+        @config.logger.error("#{method}: FlagSets must be a non-empty list.")
+        return []
+      end
+      without_nil = Array.new
+      flag_sets.each { |flag_set|
+        if !flag_set.nil?
+          without_nil.push(flag_set) 
+          next
+        end
+        
+        log_nil("flag set", method)
+      }
+      if without_nil.length() == 0
+        log_invalid_flag_set_type(method)
+        return []
+      end
+      valid_flag_sets = Set[]
+      without_nil.compact.uniq.select do |flag_set|
+        if flag_set.nil? || !flag_set.is_a?(String)
+          log_invalid_flag_set_type(method)
+        elsif flag_set.is_a?(String) && flag_set.empty?
+          log_invalid_flag_set_type(method)
+        elsif !flag_set.empty? && string_match?(flag_set.strip.downcase, method, Flagset_regex, :log_invalid_match)
+          valid_flag_sets.add(flag_set.strip.downcase)
+        else
+          log_invalid_flag_set_type(method)
+        end
+      end
+      !valid_flag_sets.empty? ? valid_flag_sets.to_a.sort :  []
+    end
+
+    def validate_fallback_treatment(method, fallback_treatment)
+      if !fallback_treatment.is_a? Engine::Models::FallbackTreatment
+          @config.logger.warn("#{method}: Fallback treatment instance should be FallbackTreatment, input is discarded")
+          return false
+      end
+
+      if !fallback_treatment.treatment.is_a? String
+          @config.logger.warn("#{method}: Fallback treatment value should be str type, input is discarded")
+          return false
+      end    
+
+      return false unless string_match?(fallback_treatment.treatment, method, Fallback_treatment_regex, :log_invalid_fallback_treatment)
+
+      if fallback_treatment.treatment.size > Fallback_treatment_size
+          @config.logger.warn("#{method}: Fallback treatment size should not exceed #{Fallback_treatment_size} characters")
+          return false
+      end
+      
+      true
+    end
+
+    def valid_split_name?(method, split_name)
+      if split_name.nil?
+        log_nil(:split_name, method)
+        return false
+      end
+
+      unless string?(split_name)
+        log_invalid_type(:split_name, method)
+        return false
+      end
+
+      if empty_string?(split_name)
+        log_empty_string(:split_name, method)
+        return false
+      end
+
+      true
+    end
+
+    private
+
+    def string?(value)
+      value.is_a?(String) || value.is_a?(Symbol)
+    end
+
+    def empty_string?(value)
+      value.is_a?(String) && value.empty?
+    end
+
+    def number_or_string?(value)
+      (value.is_a?(Numeric) && !value.to_f.nan?) || string?(value)
+    end
+
+    def string_match?(value, method, regex_exp, log_if_invalid)
+      if regex_exp.match(value) == nil
+        method(log_if_invalid).call(value, method)
+        false
+      else
+        true
+      end
+    end
+
+    def log_invalid_match(key, method)
+      @config.logger.error("#{method}: you passed #{key}, flag set must adhere to the regular expression #{Flagset_regex}. " +
+      "This means flag set must be alphanumeric, cannot be more than 50 characters long, and can only include a dash, underscore, " +
+      "period, or colon as separators of alphanumeric characters.")
+    end
+
+    def log_nil(key, method)
+      msg_text = String.new("#{method}: you passed a nil #{key}, #{key} must be a non-empty String")
+      msg_text << " or a Symbol" if !key.equal?("flag set")
+      @config.logger.error(msg_text)
+    end
+
+    def log_empty_string(key, method)
+      @config.logger.error("#{method}: you passed an empty #{key}, #{key} must be a non-empty String or a Symbol")
+    end
+
+    def log_invalid_type(key, method)
+      @config.logger.error("#{method}: you passed an invalid #{key} type, #{key} must be a non-empty String or a Symbol")
+    end
+
+    def log_invalid_flag_set_type(method)
+      @config.logger.warn("#{method}: you passed an invalid flag set type, flag set must be a non-empty String")
+    end
+
+    def log_convert_numeric(key, method, value)
+      @config.logger.warn("#{method}: #{key} \"#{value}\" is not of type String, converting")
+    end
+
+    def log_key_too_long(key, method)
+      @config.logger.error("#{method}: #{key} is too long - must be #{@config.max_key_size} characters or less")
+    end
+
+    def valid_key?(method, key)
+      if key.nil?
+        log_nil(:key, method)
+        return false
+      end
+
+      true
+    end
+
+    def valid_matching_key?(method, matching_key)
+      if matching_key.nil?
+        log_nil(:matching_key, method)
+        return false
+      end
+
+      unless number_or_string?(matching_key)
+        log_invalid_type(:matching_key, method)
+        return false
+      end
+
+      if empty_string?(matching_key)
+        log_empty_string(:matching_key, method)
+        return false
+      end
+
+      log_convert_numeric(:matching_key, method, matching_key) if matching_key.is_a? Numeric
+
+      if matching_key.size > @config.max_key_size
+        log_key_too_long(:matching_key, method)
+        return false
+      end
+
+      true
+    end
+
+    def valid_bucketing_key?(method, key, bucketing_key)
+      if key.is_a? Hash
+        if bucketing_key.nil?
+          log_nil(:bucketing_key, method)
+          return false
+        end
+
+        unless number_or_string?(bucketing_key)
+          log_invalid_type(:bucketing_key, method)
+          return false
+        end
+
+        if empty_string?(bucketing_key)
+          log_empty_string(:bucketing_key, method)
+          return false
+        end
+
+        log_convert_numeric(:bucketing_key, method, bucketing_key) if bucketing_key.is_a? Numeric
+
+        if bucketing_key.size > @config.max_key_size
+          log_key_too_long(:bucketing_key, method)
+          return false
+        end
+      end
+
+      true
+    end
+
+    def valid_split_names?(method, split_names)
+      unless !split_names.nil? && split_names.is_a?(Array)
+        @config.logger.error("#{method}: feature_flag_names must be a non-empty Array")
+        return false
+      end
+
+      true
+    end
+
+    def valid_attributes?(method, attributes)
+      unless attributes.nil? || attributes.is_a?(Hash)
+        @config.logger.error("#{method}: attributes must be of type Hash")
+        return false
+      end
+
+      true
+    end
+
+    def valid_track_key?(key)
+      if key.nil?
+        log_nil(:key, :track)
+        return false
+      end
+
+      unless number_or_string?(key)
+        log_invalid_type(:key, :track)
+        return false
+      end
+
+      if empty_string?(key)
+        log_empty_string(:key, :track)
+        return false
+      end
+
+      log_convert_numeric(:key, :track, key) if key.is_a? Numeric
+
+      if key.size > @config.max_key_size
+        log_key_too_long(:key, :track)
+        return false
+      end
+
+      true
+    end
+
+    def valid_event_type?(event_type)
+      if event_type.nil?
+        log_nil(:event_type, :track)
+        return false
+      end
+
+      unless string?(event_type)
+        log_invalid_type(:event_type, :track)
+        return false
+      end
+
+      if event_type.empty?
+        log_empty_string(:event_type, :track)
+        return false
+      end
+
+      if (event_type.to_s =~ /^[a-zA-Z0-9][-_.:a-zA-Z0-9]{0,79}$/).nil?
+        @config.logger.error("track: you passed '#{event_type}', " \
+          'event_type must adhere to the regular expression ^[a-zA-Z0-9][-_.:a-zA-Z0-9]{0,79}$. ' \
+          'This means an event name must be alphanumeric, cannot be more than 80 characters long, ' \
+          'and can only include a dash, underscore, period, or colon as separators of alphanumeric characters')
+        return false
+      end
+
+      true
+    end
+
+    def valid_traffic_type_name?(traffic_type_name)
+      if traffic_type_name.nil?
+        log_nil(:traffic_type_name, :track)
+        return false
+      end
+
+      unless string?(traffic_type_name)
+        log_invalid_type(:traffic_type_name, :track)
+        return false
+      end
+
+      if traffic_type_name.empty?
+        log_empty_string(:traffic_type_name, :track)
+        return false
+      end
+
+      unless traffic_type_name == traffic_type_name.downcase
+        @config.logger.warn('track: traffic_type_name should be all lowercase - ' \
+          'converting string to lowercase')
+      end
+
+      true
+    end
+
+    def valid_value?(value)
+      unless (value.is_a?(Numeric) && !value.to_f.nan?) || value.nil?
+        @config.logger.error('track: value must be Numeric')
+        return false
+      end
+
+      true
+    end
+
+    def valid_properties?(properties)
+      unless properties.is_a?(Hash) || properties.nil?
+        @config.logger.error('track: properties must be a Hash')
+        return false
+      end
+
+      true
+    end
+
+    def log_invalid_fallback_treatment(key, method)
+      @config.logger.warn("#{method}: Invalid treatment #{key}, Fallback treatment should match regex #{Fallback_treatment_regex}")
+    end
+  end
+end

data/lib/splitclient-rb/version.rb

@@ -1,3 +1,3 @@
 module SplitIoClient
-  VERSION = '1.0.2.wip'
+  VERSION = '8.11.1-rc1'
 end