splitclient-rb 7.2.3.pre.rc2-java → 7.3.0.pre.rc1-java

data/lib/splitclient-rb/engine/push_manager.rb

@@ -3,12 +3,13 @@
 module SplitIoClient
   module Engine
     class PushManager
-      def initialize(config, sse_handler, api_key)
+      def initialize(config, sse_handler, api_key, telemetry_runtime_producer)
         @config = config
         @sse_handler = sse_handler
-        @auth_api_client = AuthApiClient.new(@config)
+        @auth_api_client = AuthApiClient.new(@config, telemetry_runtime_producer)
         @api_key = api_key
         @back_off = SplitIoClient::SSE::EventSource::BackOff.new(@config.auth_retry_back_off_base, 1)
+        @telemetry_runtime_producer = telemetry_runtime_producer
       end
 
       def start_sse
@@ -19,6 +20,8 @@ module SplitIoClient
         if response[:push_enabled] && @sse_handler.start(response[:token], response[:channels])
           schedule_next_token_refresh(response[:exp])
           @back_off.reset
+          record_telemetry(response[:exp])
+
           return true
         end
 
@@ -51,6 +54,11 @@ module SplitIoClient
           end
         end
       end
+
+      def record_telemetry(time)
+        data = (Time.now.to_f * 1000.0).to_i + (time * 1000.0).to_i
+        @telemetry_runtime_producer.record_streaming_event(Telemetry::Domain::Constants::TOKEN_REFRESH, data)
+      end
     end
   end
 end

data/lib/splitclient-rb/engine/sync_manager.rb

@@ -3,29 +3,38 @@
 module SplitIoClient
   module Engine
     class SyncManager
+      SYNC_MODE_STREAMING = 0
+      SYNC_MODE_POLLING = 1
+
       def initialize(
         repositories,
         api_key,
         config,
-        synchronizer
+        synchronizer,
+        telemetry_runtime_producer,
+        sdk_blocker,
+        telemetry_synchronizer
       )
         @synchronizer = synchronizer
-        notification_manager_keeper = SplitIoClient::SSE::NotificationManagerKeeper.new(config) do |manager|
+        notification_manager_keeper = SSE::NotificationManagerKeeper.new(config, telemetry_runtime_producer) do |manager|
           manager.on_action { |action| process_action(action) }
         end
-        @sse_handler = SplitIoClient::SSE::SSEHandler.new(
-          config,
+        @sse_handler = SSE::SSEHandler.new(
+          { config: config, api_key: api_key },
           @synchronizer,
-          repositories[:splits],
-          repositories[:segments],
-          notification_manager_keeper
+          repositories,
+          notification_manager_keeper,
+          telemetry_runtime_producer
         ) do |handler|
           handler.on_action { |action| process_action(action) }
         end
 
-        @push_manager = PushManager.new(config, @sse_handler, api_key)
+        @push_manager = PushManager.new(config, @sse_handler, api_key, telemetry_runtime_producer)
         @sse_connected = Concurrent::AtomicBoolean.new(false)
         @config = config
+        @telemetry_runtime_producer = telemetry_runtime_producer
+        @sdk_blocker = sdk_blocker
+        @telemetry_synchronizer = telemetry_synchronizer
       end
 
       def start
@@ -35,6 +44,8 @@ module SplitIoClient
         elsif @config.standalone?
           start_poll
         end
+
+        synchronize_telemetry_config
       end
 
       private
@@ -42,7 +53,7 @@ module SplitIoClient
       # Starts tasks if stream is enabled.
       def start_stream
         @config.logger.debug('Starting push mode ...')
-        sync_all_thread
+        @synchronizer.sync_all
         @synchronizer.start_periodic_data_recording
 
         start_sse_connection_thread
@@ -52,21 +63,11 @@ module SplitIoClient
         @config.logger.debug('Starting polling mode ...')
         @synchronizer.start_periodic_fetch
         @synchronizer.start_periodic_data_recording
+        record_telemetry(Telemetry::Domain::Constants::SYNC_MODE, SYNC_MODE_POLLING)
       rescue StandardError => e
         @config.logger.error("start_poll error : #{e.inspect}")
       end
 
-      # Starts thread which fetch splits and segments once and trigger task to periodic data recording.
-      def sync_all_thread
-        @config.threads[:sync_manager_start_stream] = Thread.new do
-          begin
-            @synchronizer.sync_all
-          rescue StandardError => e
-            @config.logger.error("sync_all_thread error : #{e.inspect}")
-          end
-        end
-      end
-
       # Starts thread which connect to sse and after that fetch splits and segments once.
       def start_sse_connection_thread
         @config.threads[:sync_manager_start_sse] = Thread.new do
@@ -108,17 +109,20 @@ module SplitIoClient
         @synchronizer.stop_periodic_fetch
         @synchronizer.sync_all
         @sse_handler.start_workers
+        record_telemetry(Telemetry::Domain::Constants::SYNC_MODE, SYNC_MODE_STREAMING)
       end
 
       def process_subsystem_down
         @sse_handler.stop_workers
         @synchronizer.start_periodic_fetch
+        record_telemetry(Telemetry::Domain::Constants::SYNC_MODE, SYNC_MODE_POLLING)
       end
 
       def process_push_shutdown
         @push_manager.stop_sse
         @sse_handler.stop_workers
         @synchronizer.start_periodic_fetch
+        record_telemetry(Telemetry::Domain::Constants::SYNC_MODE, SYNC_MODE_POLLING)
       rescue StandardError => e
         @config.logger.error("process_push_shutdown error: #{e.inspect}")
       end
@@ -133,6 +137,7 @@ module SplitIoClient
         @synchronizer.stop_periodic_fetch
         @synchronizer.sync_all
         @sse_handler.start_workers
+        record_telemetry(Telemetry::Domain::Constants::SYNC_MODE, SYNC_MODE_STREAMING)
       rescue StandardError => e
         @config.logger.error("process_connected error: #{e.inspect}")
       end
@@ -146,6 +151,7 @@ module SplitIoClient
         @sse_connected.make_false
         @sse_handler.stop_workers
         @synchronizer.start_periodic_fetch
+        record_telemetry(Telemetry::Domain::Constants::SYNC_MODE, SYNC_MODE_POLLING)
 
         if reconnect
           @synchronizer.sync_all
@@ -154,6 +160,22 @@ module SplitIoClient
       rescue StandardError => e
         @config.logger.error("process_disconnect error: #{e.inspect}")
       end
+
+      def record_telemetry(type, data)
+        @telemetry_runtime_producer.record_streaming_event(type, data)
+      end
+
+      def synchronize_telemetry_config
+        @config.threads[:telemetry_config_sender] = Thread.new do
+          begin
+            @sdk_blocker.wait_unitil_internal_ready unless @config.consumer?
+            @telemetry_synchronizer.synchronize_config
+          rescue SplitIoClient::SDKShutdownException
+            @telemetry_synchronizer.synchronize_config
+            @config.logger.info('Posting Telemetry config due to shutdown')
+          end
+        end
+      end
     end
   end
 end

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

@@ -6,6 +6,8 @@ module SplitIoClient
       include SplitIoClient::Cache::Fetchers
       include SplitIoClient::Cache::Senders
 
+      FORCE_CACHE_CONTROL_HEADERS = true
+
       def initialize(
         repositories,
         api_key,
@@ -16,30 +18,30 @@ module SplitIoClient
         @splits_repository = repositories[:splits]
         @segments_repository = repositories[:segments]
         @impressions_repository = repositories[:impressions]
-        @metrics_repository = repositories[:metrics]
         @events_repository = repositories[:events]
         @api_key = api_key
         @config = config
         @sdk_blocker = sdk_blocker
         @split_fetcher = params[:split_fetcher]
         @segment_fetcher = params[:segment_fetcher]
-        @impressions_api = SplitIoClient::Api::Impressions.new(@api_key, @config)
+        @impressions_api = SplitIoClient::Api::Impressions.new(@api_key, @config, params[:telemetry_runtime_producer])
         @impression_counter = params[:imp_counter]
+        @telemetry_synchronizer = params[:telemetry_synchronizer]
       end
 
       def sync_all
         @config.threads[:sync_all_thread] = Thread.new do
           @config.logger.debug('Synchronizing Splits and Segments ...') if @config.debug_enabled
           @split_fetcher.fetch_splits
-          fetch_segments
+          @segment_fetcher.fetch_segments
         end
       end
 
       def start_periodic_data_recording
         impressions_sender
-        metrics_sender
         events_sender
         impressions_count_sender
+        start_telemetry_sync_task
       end
 
       def start_periodic_fetch
@@ -53,12 +55,12 @@ module SplitIoClient
       end
 
       def fetch_splits
-        segment_names = @split_fetcher.fetch_splits
-        @segment_fetcher.fetch_segments_if_not_exists(segment_names) unless segment_names.empty?
+        segment_names = @split_fetcher.fetch_splits(FORCE_CACHE_CONTROL_HEADERS)
+        @segment_fetcher.fetch_segments_if_not_exists(segment_names, FORCE_CACHE_CONTROL_HEADERS) unless segment_names.empty?
       end
 
       def fetch_segment(name)
-        @segment_fetcher.fetch_segment(name)
+        @segment_fetcher.fetch_segment(name, FORCE_CACHE_CONTROL_HEADERS)
       end
 
       private
@@ -72,11 +74,6 @@ module SplitIoClient
         ImpressionsSender.new(@impressions_repository, @config, @impressions_api).call
       end
 
-      # Starts thread which loops constantly and sends metrics to the Split API
-      def metrics_sender
-        MetricsSender.new(@metrics_repository, @api_key, @config).call
-      end
-
       # Starts thread which loops constantly and sends events to the Split API
       def events_sender
         EventsSender.new(@events_repository, @config).call
@@ -86,6 +83,10 @@ module SplitIoClient
       def impressions_count_sender
         ImpressionsCountSender.new(@config, @impression_counter, @impressions_api).call
       end
+
+      def start_telemetry_sync_task
+        Telemetry::SyncTask.new(@config, @telemetry_synchronizer).call
+      end
     end
   end
 end

data/lib/splitclient-rb/split_config.rb

@@ -17,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
@@ -51,7 +50,6 @@ module SplitIoClient
       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_mode = init_impressions_mode(opts[:impressions_mode])
 
@@ -63,10 +61,6 @@ module SplitIoClient
       #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
-      )
-
       @debug_enabled = opts[:debug_enabled] || SplitConfig.default_debug
       @transport_debug_enabled = opts[:transport_debug_enabled] || SplitConfig.default_debug
       @block_until_ready = SplitConfig.default_block_until_ready
@@ -97,6 +91,10 @@ module SplitIoClient
         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
@@ -110,6 +108,11 @@ module SplitIoClient
       @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
+
+      @sdk_start_time = Time.now
+
       startup_log
     end
 
@@ -148,12 +151,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
     #
@@ -224,7 +221,6 @@ 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
@@ -274,6 +270,14 @@ module SplitIoClient
 
     attr_accessor :impressions_mode
 
+    attr_accessor :telemetry_adapter
+
+    attr_accessor :telemetry_refresh_rate
+
+    attr_accessor :telemetry_service_url
+
+    attr_accessor :sdk_start_time
+
     def self.default_impressions_mode
       :optimized
     end
@@ -296,6 +300,12 @@ module SplitIoClient
       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
@@ -359,6 +369,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
@@ -377,10 +402,6 @@ module SplitIoClient
       :memory
     end
 
-    def self.default_metrics_adapter
-      :memory
-    end
-
     #
     # The default read timeout value
     #
@@ -405,10 +426,6 @@ module SplitIoClient
       60
     end
 
-    def self.default_metrics_refresh_rate
-      60
-    end
-
     def self.default_impressions_refresh_rate
       60
     end
@@ -433,6 +450,14 @@ module SplitIoClient
       500
     end
 
+    def self.default_telemetry_refresh_rate
+      3600      
+    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

data/lib/splitclient-rb/split_factory.rb

@@ -28,25 +28,25 @@ module SplitIoClient
 
       raise 'Invalid SDK mode' unless valid_mode
 
+      build_telemetry_components
+
       @splits_repository = SplitsRepository.new(@config)
       @segments_repository = SegmentsRepository.new(@config)
       @impressions_repository = ImpressionsRepository.new(@config)
-      @events_repository = EventsRepository.new(@config, @api_key)
-      @metrics_repository = MetricsRepository.new(@config)
+      @events_repository = EventsRepository.new(@config, @api_key, @runtime_producer)
       @sdk_blocker = SDKBlocker.new(@splits_repository, @segments_repository, @config)
-      @metrics = Metrics.new(100, @metrics_repository)
       @impression_counter = SplitIoClient::Engine::Common::ImpressionCounter.new
-      @impressions_manager = SplitIoClient::Engine::Common::ImpressionManager.new(@config, @impressions_repository, @impression_counter)
+      @impressions_manager = SplitIoClient::Engine::Common::ImpressionManager.new(@config, @impressions_repository, @impression_counter, @runtime_producer)
+      @telemetry_api = SplitIoClient::Api::TelemetryApi.new(@config, @api_key, @runtime_producer)
+      @telemetry_synchronizer = Telemetry::Synchronizer.new(@config, @telemetry_consumers, @init_producer, repositories, @telemetry_api)
 
       start!
 
-      @client = SplitClient.new(@api_key, @metrics, @splits_repository, @segments_repository, @impressions_repository, @metrics_repository, @events_repository, @sdk_blocker, @config, @impressions_manager)
+      @client = SplitClient.new(@api_key, repositories, @sdk_blocker, @config, @impressions_manager, @evaluation_producer)
       @manager = SplitManager.new(@splits_repository, @sdk_blocker, @config)
 
       validate_api_key
 
-      RedisMetricsFixer.new(@metrics_repository, @config).call
-
       register_factory
     end
 
@@ -54,12 +54,18 @@ module SplitIoClient
       if @config.localhost_mode
         start_localhost_components
       else
-        split_fetcher = SplitFetcher.new(@splits_repository, @api_key, @metrics, config, @sdk_blocker)
-        segment_fetcher = SegmentFetcher.new(@segments_repository, @api_key, @metrics, config, @sdk_blocker)
-        params = { split_fetcher: split_fetcher, segment_fetcher: segment_fetcher, imp_counter: @impression_counter }
+        split_fetcher = SplitFetcher.new(@splits_repository, @api_key, config, @sdk_blocker, @runtime_producer)
+        segment_fetcher = SegmentFetcher.new(@segments_repository, @api_key, config, @sdk_blocker, @runtime_producer)
+        params = { 
+          split_fetcher: split_fetcher,
+          segment_fetcher: segment_fetcher,
+          imp_counter: @impression_counter,
+          telemetry_runtime_producer: @runtime_producer,
+          telemetry_synchronizer: @telemetry_synchronizer
+        }
 
         synchronizer = SplitIoClient::Engine::Synchronizer.new(repositories, @api_key, @config, @sdk_blocker, params)
-        SplitIoClient::Engine::SyncManager.new(repositories, @api_key, @config, synchronizer).start
+        SplitIoClient::Engine::SyncManager.new(repositories, @api_key, @config, synchronizer, @runtime_producer, @sdk_blocker, @telemetry_synchronizer).start
       end
     end
 
@@ -135,7 +141,6 @@ module SplitIoClient
         segments: @segments_repository,
         impressions: @impressions_repository,
         events: @events_repository,
-        metrics: @metrics_repository
       }
     end
 
@@ -143,7 +148,20 @@ module SplitIoClient
       LocalhostSplitStore.new(@splits_repository, @config, @sdk_blocker).call
 
       # Starts thread which loops constantly and cleans up repositories to avoid memory issues in localhost mode
-      LocalhostRepoCleaner.new(@impressions_repository, @metrics_repository, @events_repository, @config).call
+      LocalhostRepoCleaner.new(@impressions_repository, @events_repository, @config).call
     end
+
+    def build_telemetry_components
+      @evaluation_consumer = Telemetry::EvaluationConsumer.new(@config)
+      @evaluation_producer = Telemetry::EvaluationProducer.new(@config)
+
+      @init_consumer = Telemetry::InitConsumer.new(@config)
+      @init_producer = Telemetry::InitProducer.new(@config)
+
+      @runtime_consumer = Telemetry::RuntimeConsumer.new(@config)
+      @runtime_producer = Telemetry::RuntimeProducer.new(@config)
+
+      @telemetry_consumers = { init: @init_consumer, evaluation: @evaluation_consumer, runtime: @runtime_consumer }
+    end    
   end
 end