splitclient-rb 6.3.0 → 8.11.0

data/lib/splitclient-rb/split_config.rb

@@ -2,15 +2,6 @@ require 'logger'
 require 'socket'
 
 module SplitIoClient
-
-  class << self
-      attr_accessor :configuration
-  end
-
-  def self.configure(opts={})
-    self.configuration ||= SplitConfig.new(opts)
-  end
-
   #
   # This class manages configuration options for the split client library.
   # If not custom configuration is required the default configuration values will be used
@@ -26,7 +17,6 @@ module SplitIoClient
     # @option opts [Int] :connection_timeout (2) The connect timeout for network connections in seconds.
     # @option opts [Int] :features_refresh_rate The SDK polls Split servers for changes to feature roll-out plans. This parameter controls this polling period in seconds.
     # @option opts [Int] :segments_refresh_rate
-    # @option opts [Int] :metrics_refresh_rate
     # @option opts [Int] :impressions_refresh_rate
     # @option opts [Object] :logger a logger to user for messages from the client. Defaults to stdout
     # @option opts [Boolean] :debug_enabled (false) The value for the debug flag
@@ -41,39 +31,44 @@ module SplitIoClient
       @events_uri = (opts[:events_uri] || SplitConfig.default_events_uri).chomp('/')
       @mode = opts[:mode] || SplitConfig.default_mode
       @redis_url = opts[:redis_url] || SplitConfig.default_redis_url
-      @redis_namespace = opts[:redis_namespace] ? "#{opts[:redis_namespace]}.#{SplitConfig.default_redis_namespace}" : SplitConfig.default_redis_namespace
+      @redis_namespace = opts[:redis_namespace] && opts[:redis_namespace].to_s.length > 0 ? "#{opts[:redis_namespace]}.#{SplitConfig.default_redis_namespace}" : SplitConfig.default_redis_namespace
       @cache_adapter = SplitConfig.init_cache_adapter(
         opts[:cache_adapter] || SplitConfig.default_cache_adapter, :map_adapter, nil, @redis_url
       )
       @connection_timeout = opts[:connection_timeout] || SplitConfig.default_connection_timeout
       @read_timeout = opts[:read_timeout] || SplitConfig.default_read_timeout
-      @features_refresh_rate = opts[:features_refresh_rate] || SplitConfig.default_features_refresh_rate
+
+      @logger = opts[:logger] || SplitConfig.default_logger
+
+      if(opts[:reload_rate])
+        @features_refresh_rate = opts[:reload_rate]
+        @logger.warn('Localhost mode: reload_rate will be deprecated soon in favor of ' \
+          'features_refresh_rate. Take a look in our documentation.'
+        )
+      else
+        @features_refresh_rate = opts[:features_refresh_rate] || SplitConfig.default_features_refresh_rate
+      end
+
       @segments_refresh_rate = opts[:segments_refresh_rate] || SplitConfig.default_segments_refresh_rate
-      @metrics_refresh_rate = opts[:metrics_refresh_rate] || SplitConfig.default_metrics_refresh_rate
 
-      @impressions_refresh_rate = opts[:impressions_refresh_rate] || SplitConfig.default_impressions_refresh_rate
+      @impressions_mode = init_impressions_mode(opts[:impressions_mode], opts[:cache_adapter])
+
+      @impressions_refresh_rate = SplitConfig.init_impressions_refresh_rate(@impressions_mode, opts[:impressions_refresh_rate], SplitConfig.default_impressions_refresh_rate)
       @impressions_queue_size = opts[:impressions_queue_size] || SplitConfig.default_impressions_queue_size
       @impressions_adapter = SplitConfig.init_cache_adapter(
         opts[:cache_adapter] || SplitConfig.default_cache_adapter, :queue_adapter, @impressions_queue_size, @redis_url
       )
       #Safeguard for users of older SDK versions.
-      @disable_impressions = @impressions_queue_size == -1
-      #Safeguard for users of older SDK versions.
       @impressions_bulk_size = opts[:impressions_bulk_size] || @impressions_queue_size > 0 ? @impressions_queue_size : 0
 
-      @metrics_adapter = SplitConfig.init_cache_adapter(
-        opts[:cache_adapter] || SplitConfig.default_cache_adapter, :map_adapter, nil, @redis_url
-      )
-
-      @logger = opts[:logger] || SplitConfig.default_logger
       @debug_enabled = opts[:debug_enabled] || SplitConfig.default_debug
       @transport_debug_enabled = opts[:transport_debug_enabled] || SplitConfig.default_debug
-      @block_until_ready = opts[:ready] || opts[:block_until_ready] || 0
+      @block_until_ready = SplitConfig.default_block_until_ready
 
-      @logger.warn 'no ready parameter has been set - incorrect control treatments could be logged' if block_until_ready == 0 && !mode.equal?(:consumer) 
+      @ip_addresses_enabled = opts[:ip_addresses_enabled].nil? ? SplitConfig.default_ip_addresses_enabled : opts[:ip_addresses_enabled]
 
-      @machine_name = opts[:machine_name] || SplitConfig.machine_hostname
-      @machine_ip = opts[:machine_ip] || SplitConfig.machine_ip
+      @machine_name = SplitConfig.machine_hostname(@ip_addresses_enabled, opts[:machine_name], opts[:cache_adapter] || SplitConfig.default_cache_adapter)
+      @machine_ip = SplitConfig.machine_ip(@ip_addresses_enabled, opts[:machine_ip], opts[:cache_adapter] || SplitConfig.default_cache_adapter)
 
       @cache_ttl = opts[:cache_ttl] || SplitConfig.cache_ttl
       @max_cache_size = opts[:max_cache_size] || SplitConfig.max_cache_size
@@ -95,8 +90,41 @@ module SplitIoClient
       @events_adapter = SplitConfig.init_cache_adapter(
         opts[:cache_adapter] || SplitConfig.default_cache_adapter, :queue_adapter, @events_queue_size, @redis_url
       )
+
+      @telemetry_adapter = SplitConfig.init_telemetry_adapter(
+        opts[:cache_adapter] || SplitConfig.default_cache_adapter, @redis_url
+      )
+
+      @split_file = opts[:split_file] || SplitConfig.default_split_file
+
       @valid_mode = true
+      @split_logger = SplitIoClient::SplitLogger.new(self)
+      @split_validator = SplitIoClient::Validators.new(self)
+      @localhost_mode = opts[:localhost_mode]
+
+      @streaming_enabled = consumer? ? false : (opts[:streaming_enabled].nil? ? SplitConfig.default_streaming_enabled : opts[:streaming_enabled])
+      @streaming_service_url = opts[:streaming_service_url] || SplitConfig.default_streaming_service_url
+      @auth_service_url = opts[:auth_service_url] || SplitConfig.default_auth_service_url
+      @auth_retry_back_off_base = SplitConfig.init_auth_retry_back_off(opts[:auth_retry_back_off_base] || SplitConfig.default_auth_retry_back_off_base)
+      @streaming_reconnect_back_off_base = SplitConfig.init_streaming_reconnect_back_off(opts[:streaming_reconnect_back_off_base] || SplitConfig.default_streaming_reconnect_back_off_base)
 
+      @telemetry_refresh_rate = SplitConfig.init_telemetry_refresh_rate(opts[:telemetry_refresh_rate])
+      @telemetry_service_url = opts[:telemetry_service_url] || SplitConfig.default_telemetry_service_url
+
+      @unique_keys_refresh_rate = SplitConfig.default_unique_keys_refresh_rate(@cache_adapter)
+      # @unique_keys_cache_max_size = SplitConfig.default_unique_keys_cache_max_size
+      @unique_keys_bulk_size = SplitConfig.default_unique_keys_bulk_size(@cache_adapter)
+
+      @counter_refresh_rate = SplitConfig.default_counter_refresh_rate(@cache_adapter)
+
+      @sdk_start_time = Time.now.to_f
+
+      @on_demand_fetch_retry_delay_seconds = SplitConfig.default_on_demand_fetch_retry_delay_seconds
+      @on_demand_fetch_max_retries = SplitConfig.default_on_demand_fetch_max_retries
+
+      @flag_sets_filter = SplitConfig.sanitize_flag_set_filter(opts[:flag_sets_filter], @split_validator, opts[:cache_adapter], @logger)
+
+      @fallback_treatments_configuration = SplitConfig.sanitize_fallback_config(opts[:fallback_treatments], @split_validator, @logger)
       startup_log
     end
 
@@ -135,12 +163,6 @@ module SplitIoClient
     # @return [Object] Impressions adapter instance
     attr_accessor :impressions_adapter
 
-    #
-    # The cache adapter to store metrics in
-    #
-    # @return [Symbol] Metrics adapter
-    attr_accessor :metrics_adapter
-
     #
     # The cache adapter to store events in
     #
@@ -160,6 +182,20 @@ module SplitIoClient
     # @return [Logger] The configured logger
     attr_accessor :logger
 
+    #
+    # The split logger. The client library uses the split logger
+    # to use common functions around the logger
+    #
+    # @return [SplitLogger] The configured logger
+    attr_accessor :split_logger
+
+    #
+    # The split validator. The client library uses the split validator
+    # to validate inputs accross the sdk
+    #
+    # @return [SplitValidator] The validator
+    attr_accessor :split_validator
+
     #
     # The boolean that represents the state of the debug log level
     #
@@ -197,19 +233,17 @@ module SplitIoClient
 
     attr_accessor :features_refresh_rate
     attr_accessor :segments_refresh_rate
-    attr_accessor :metrics_refresh_rate
     attr_accessor :impressions_refresh_rate
 
     attr_accessor :impression_listener
     attr_accessor :impression_listener_refresh_rate
 
     #
-    # How big the impressions queue is before dropping impressions. -1 to disable it.
+    # How big the impressions queue is before dropping impressions
     #
     # @return [Integer]
     attr_accessor :impressions_queue_size
     attr_accessor :impressions_bulk_size
-    attr_accessor :disable_impressions
 
     attr_accessor :redis_url
     attr_accessor :redis_namespace
@@ -230,6 +264,118 @@ module SplitIoClient
     # @return [Integer]
     attr_accessor :events_queue_size
 
+    attr_accessor :split_file
+
+    attr_accessor :localhost_mode
+
+    attr_accessor :ip_addresses_enabled
+
+    attr_accessor :auth_service_url
+
+    attr_accessor :auth_retry_back_off_base
+
+    attr_accessor :streaming_service_url
+
+    attr_accessor :streaming_reconnect_back_off_base
+
+    attr_accessor :streaming_enabled
+
+    attr_accessor :impressions_mode
+
+    attr_accessor :telemetry_adapter
+
+    attr_accessor :telemetry_refresh_rate
+
+    attr_accessor :telemetry_service_url
+
+    attr_accessor :sdk_start_time
+
+    attr_accessor :on_demand_fetch_retry_delay_seconds
+    attr_accessor :on_demand_fetch_max_retries
+
+    attr_accessor :unique_keys_refresh_rate
+    #attr_accessor :unique_keys_cache_max_size
+    attr_accessor :unique_keys_bulk_size
+
+    attr_accessor :counter_refresh_rate
+
+    #
+    # Flagsets filter
+    #
+    # @return [Array]
+    attr_accessor :flag_sets_filter
+
+    attr_accessor :fallback_treatments_configuration
+
+    def self.default_counter_refresh_rate(adapter)
+      return 300 if adapter == :redis # Send bulk impressions count - Refresh rate: 5 min.
+
+      1800 # Send bulk impressions count - Refresh rate: 30 min.
+    end
+
+    def self.default_on_demand_fetch_retry_delay_seconds
+      0.05
+    end
+
+    def self.default_on_demand_fetch_max_retries
+      10
+    end
+
+    def init_impressions_mode(impressions_mode, adapter)
+      case impressions_mode
+      when :optimized
+        return :optimized
+      when :none
+       return :none
+      when :debug
+        return :debug
+      else
+        default = adapter == :redis ? :debug : :optimized
+        @logger.error("You passed an invalid impressions_mode, impressions_mode should be one of the following values: :debug, :optimized or :none. Defaulting to #{default} mode") unless impressions_mode.nil?
+        return default
+      end
+    end
+
+    def self.init_impressions_refresh_rate(impressions_mode, refresh_rate, default_rate)
+      return (refresh_rate.nil? || refresh_rate <= 0 ? default_rate : refresh_rate) if impressions_mode == :debug
+
+      return refresh_rate.nil? || refresh_rate <= 0 ? SplitConfig.default_impressions_refresh_rate_optimized : [default_rate, refresh_rate].max
+    end
+
+    def self.init_telemetry_refresh_rate(refresh_rate)
+      return SplitConfig.default_telemetry_refresh_rate if refresh_rate.nil? || refresh_rate < 60
+
+      refresh_rate
+    end
+
+    def self.default_streaming_enabled
+      true
+    end
+
+    def self.default_streaming_service_url
+      'https://streaming.split.io/event-stream'
+    end
+
+    def self.default_auth_service_url
+      'https://auth.split.io/api/v2/auth'
+    end
+
+    def self.default_auth_retry_back_off_base
+      1
+    end
+
+    def self.default_streaming_reconnect_back_off_base
+      1
+    end
+
+    def self.init_auth_retry_back_off(auth_retry_back_off)
+      auth_retry_back_off < 1 ? SplitConfig.default_auth_retry_back_off_base : auth_retry_back_off
+    end
+
+    def self.init_streaming_reconnect_back_off(streaming_reconnect_back_off)
+      streaming_reconnect_back_off < 1 ? SplitConfig.default_streaming_reconnect_back_off_base : streaming_reconnect_back_off
+    end
+
     #
     # The default split client configuration
     #
@@ -265,6 +411,21 @@ module SplitIoClient
       end
     end
 
+    def self.init_telemetry_adapter(adapter, redis_url)
+      case adapter
+      when :memory
+        Telemetry::Storages::Memory.new
+      when :redis
+        begin
+          require 'redis'
+        rescue LoadError
+          fail StandardError, 'To use Redis as a cache adapter you must include it in your Gemfile'
+        end
+
+        SplitIoClient::Cache::Adapters::RedisAdapter.new(redis_url)
+      end
+    end
+
     def self.map_memory_adapter(name, queue_size)
       case name
       when :map_adapter
@@ -283,10 +444,6 @@ module SplitIoClient
       :memory
     end
 
-    def self.default_metrics_adapter
-      :memory
-    end
-
     #
     # The default read timeout value
     #
@@ -304,19 +461,19 @@ module SplitIoClient
     end
 
     def self.default_features_refresh_rate
-      5
+      60
     end
 
     def self.default_segments_refresh_rate
       60
     end
 
-    def self.default_metrics_refresh_rate
+    def self.default_impressions_refresh_rate
       60
     end
 
-    def self.default_impressions_refresh_rate
-      60
+    def self.default_impressions_refresh_rate_optimized
+      300
     end
 
     def self.default_impression_listener_refresh_rate
@@ -335,6 +492,47 @@ module SplitIoClient
       500
     end
 
+    def self.default_telemetry_refresh_rate
+      3600
+    end
+
+    def self.default_unique_keys_refresh_rate(adapter)
+      return 300 if adapter == :redis
+
+      900
+    end
+
+#    def self.default_unique_keys_cache_max_size
+#      30000
+#    end
+
+    def self.default_unique_keys_bulk_size(adapter)
+      return 2000 if adapter == :redis
+
+      5000
+    end
+
+    def self.default_telemetry_service_url
+      'https://telemetry.split.io/api/v1'
+    end
+
+    def self.default_split_file
+      File.join(Dir.home, '.split')
+    end
+
+    def self.default_offline_refresh_rate
+      5
+    end
+
+    def self.sanitize_flag_set_filter(flag_sets, validator, adapter, logger)
+      return [] if flag_sets.nil?
+      if adapter == :redis
+        logger.warn("config: : flag_sets_filter is not applicable for Consumer modes where the SDK does not keep rollout data in sync. FlagSet filter was discarded")
+        return []
+      end
+      return validator.valid_flag_sets(:config, flag_sets)
+    end
+
     #
     # The default logger object
     #
@@ -343,14 +541,12 @@ module SplitIoClient
       if defined?(Rails) && Rails.logger
         Rails.logger
       elsif ENV['SPLITCLIENT_ENV'] == 'test'
-        Logger.new('/dev/null')  
+        Logger.new('/dev/null')
       else
        Logger.new($stdout)
        end
     end
 
-
-
     #
     # The default debug value
     #
@@ -375,6 +571,22 @@ module SplitIoClient
       'SPLITIO'
     end
 
+    #
+    # The default block until ready value
+    #
+    # @return [int]
+    def self.default_block_until_ready
+      15
+    end
+
+    #
+    # The default ip addresses enabled value
+    #
+    # @return [boolean]
+    def self.default_ip_addresses_enabled
+      true
+    end
+
     #
     # The default transport_debug_enabled value
     #
@@ -429,27 +641,97 @@ module SplitIoClient
       @logger.info("Loaded cache class: #{@cache_adapter.class}")
     end
 
+    def standalone?
+      @mode.equal?(:standalone)
+    end
+
+    def consumer?
+      @mode.equal?(:consumer)
+    end
+
+    def sdk_url_overriden?
+      return @base_uri != SplitConfig.default_base_uri
+    end
+    
     #
     # gets the hostname where the sdk gem is running
     #
     # @return [string]
-    def self.machine_hostname
-      Socket.gethostname
-    rescue
-      'localhost'.freeze
+    def self.machine_hostname(ip_addresses_enabled, machine_name, adapter)
+      if ip_addresses_enabled
+        begin
+          return machine_name || Socket.gethostname
+        rescue
+          return 'unknown'.freeze
+        end
+      else
+        case adapter
+        when :redis
+          return 'NA'.freeze
+        end
+      end
+
+      return ''.freeze
     end
 
     #
     # gets the ip where the sdk gem is running
     #
     # @return [string]
-    def self.machine_ip
-      loopback_ip = Socket.ip_address_list.find { |ip| ip.ipv4_loopback? }
-      private_ip = Socket.ip_address_list.find { |ip| ip.ipv4_private? }
+    def self.machine_ip(ip_addresses_enabled, ip, adapter)
+      if ip_addresses_enabled
+        begin
+          return ip unless ip.nil? || ip.to_s.empty?
 
-      addr_info = private_ip || loopback_ip
+          loopback_ip = Socket.ip_address_list.find { |ip| ip.ipv4_loopback? }
+          private_ip = Socket.ip_address_list.find { |ip| ip.ipv4_private? }
+
+          addr_info = private_ip || loopback_ip
+
+          return addr_info.ip_address
+        rescue
+          return 'unknown'.freeze
+        end
+      else
+        case adapter
+        when :redis
+          return 'NA'.freeze
+        end
+      end
+
+      return ''.freeze
+    end
+
+    def self.sanitize_fallback_config(fallback_config, validator, logger)
+      return fallback_config if fallback_config.nil?
+      
+      processed = Engine::Models::FallbackTreatmentsConfiguration.new
+      if !fallback_config.is_a?(Engine::Models::FallbackTreatmentsConfiguration)
+        logger.warn('Config: fallbackTreatments parameter should be of `FallbackTreatmentsConfiguration` class.')
+        return processed        
+      end
+
+      sanitized_global_fallback_treatment = fallback_config.global_fallback_treatment
+      if !fallback_config.global_fallback_treatment.nil? && !validator.validate_fallback_treatment('Config', fallback_config.global_fallback_treatment)
+        logger.warn('Config: global fallbacktreatment parameter is discarded.')
+        sanitized_global_fallback_treatment = nil
+      end
+
+      sanitized_flag_fallback_treatments = nil
+      if !fallback_config.by_flag_fallback_treatment.nil? && fallback_config.by_flag_fallback_treatment.is_a?(Hash)
+        sanitized_flag_fallback_treatments = Hash.new
+        for feature_name in fallback_config.by_flag_fallback_treatment.keys()
+          if !validator.valid_split_name?('Config', feature_name) || !validator.validate_fallback_treatment('Config', fallback_config.by_flag_fallback_treatment[feature_name])
+            logger.warn("Config: fallback treatment parameter for feature flag #{feature_name} is discarded.")
+            next
+          end   
+
+          sanitized_flag_fallback_treatments[feature_name] = fallback_config.by_flag_fallback_treatment[feature_name]
+        end
+      end          
+      processed = Engine::Models::FallbackTreatmentsConfiguration.new(sanitized_global_fallback_treatment, sanitized_flag_fallback_treatments)
 
-      addr_info.ip_address
+      processed
     end
   end
 end