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

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

@@ -6,22 +6,21 @@ require 'cgi'
 module SplitIoClient
   module Engine
     class AuthApiClient
-      def initialize(config)
+      def initialize(config, telemetry_runtime_producer)
         @config = config
         @api_client = SplitIoClient::Api::Client.new(@config)
+        @telemetry_runtime_producer = telemetry_runtime_producer
       end
 
       def authenticate(api_key)
+        start = Time.now
         response = @api_client.get_api(@config.auth_service_url, api_key)
 
-        return process_success(response) if response.success?
+        return process_success(response, start) if response.success?
 
-        if response.status >= 400 && response.status < 500
-          @config.logger.debug("Error connecting to: #{@config.auth_service_url}. Response status: #{response.status}")
-
-          return { push_enabled: false, retry: false }
-        end
+        return process_error(response) if response.status >= 400 && response.status < 500
 
+        @telemetry_runtime_producer.record_sync_error(Telemetry::Domain::Constants::TOKEN_SYNC, response.status.to_i)
         @config.logger.debug("Error connecting to: #{@config.auth_service_url}. Response status: #{response.status}")
         { push_enabled: false, retry: true }
       rescue StandardError => e
@@ -51,9 +50,21 @@ module SplitIoClient
         JWT.decode token, nil, false
       end
 
-      def process_success(response)
+      def process_error(response)
+        @config.logger.debug("Error connecting to: #{@config.auth_service_url}. Response status: #{response.status}")
+        @telemetry_runtime_producer.record_auth_rejections if response.status == 401
+
+        { push_enabled: false, retry: false }
+      end
+
+      def process_success(response, start)
         @config.logger.debug("Success connection to: #{@config.auth_service_url}") if @config.debug_enabled
 
+        bucket = BinarySearchLatencyTracker.get_bucket((Time.now - start) * 1000.0)
+        @telemetry_runtime_producer.record_sync_latency(Telemetry::Domain::Constants::TOKEN_SYNC, bucket)
+        timestamp = (Time.now.to_f * 1000.0).to_i
+        @telemetry_runtime_producer.record_successful_sync(Telemetry::Domain::Constants::TOKEN_SYNC, timestamp)
+
         body_json = JSON.parse(response.body, symbolize_names: true)
         push_enabled = body_json[:pushEnabled]
         token = body_json[:token]
@@ -62,6 +73,8 @@ module SplitIoClient
           decoded_token = decode_token(token)
           channels = channels(decoded_token)
           exp = expiration(decoded_token)
+
+          @telemetry_runtime_producer.record_token_refreshes
         end
 
         { push_enabled: push_enabled, token: token, channels: channels, exp: exp, retry: false }

data/lib/splitclient-rb/engine/common/impressions_manager.rb

@@ -4,11 +4,12 @@ module SplitIoClient
   module Engine
     module Common
       class ImpressionManager
-        def initialize(config, impressions_repository, impression_counter)
+        def initialize(config, impressions_repository, impression_counter, telemetry_runtime_producer)
           @config = config
           @impressions_repository = impressions_repository
           @impression_counter = impression_counter
           @impression_observer = SplitIoClient::Observers::ImpressionObserver.new
+          @telemetry_runtime_producer = telemetry_runtime_producer
         end
 
         # added param time for test
@@ -29,18 +30,41 @@ module SplitIoClient
 
           impression_router.add_bulk(impressions)
 
+          dropped = 0
+          queued = 0
+          dedupe = 0
+
           if optimized? && !redis?
             optimized_impressions = impressions.select { |imp| should_queue_impression?(imp[:i]) }
-            @impressions_repository.add_bulk(optimized_impressions)
+
+            unless optimized_impressions.empty?
+              dropped = @impressions_repository.add_bulk(optimized_impressions)
+              dedupe = impressions.length - optimized_impressions.length
+              queued = optimized_impressions.length - dropped
+            end
           else
-            @impressions_repository.add_bulk(impressions)
+            dropped = @impressions_repository.add_bulk(impressions)
+            queued = impressions.length - dropped
           end
+
+          record_stats(queued, dropped, dedupe)
         rescue StandardError => error
           @config.log_found_exception(__method__.to_s, error)
         end
 
         private
 
+        def record_stats(queued, dropped, dedupe)
+          return if redis?
+
+          imp_queued = Telemetry::Domain::Constants::IMPRESSIONS_QUEUED
+          imp_dropped = Telemetry::Domain::Constants::IMPRESSIONS_DROPPED
+          imp_dedupe = Telemetry::Domain::Constants::IMPRESSIONS_DEDUPE
+          @telemetry_runtime_producer.record_impressions_stats(imp_queued, queued) unless queued.zero?
+          @telemetry_runtime_producer.record_impressions_stats(imp_dropped, dropped) unless dropped.zero?
+          @telemetry_runtime_producer.record_impressions_stats(imp_dedupe, dedupe) unless dedupe.zero?
+        end
+
         # added param time for test
         def impression_data(matching_key, bucketing_key, split_name, treatment, time = nil)
           {

data/lib/splitclient-rb/engine/metrics/binary_search_latency_tracker.rb

@@ -42,75 +42,13 @@ module SplitIoClient
 
     MAX_LATENCY = 7481828
 
-    attr_accessor :latencies
-
-    def initialize
-      @latencies = Array.new(BUCKETS.length, 0)
-    end
-
-    #
-    # Increment the internal counter for the bucket this latency falls into.
-    # @param millis
-    #
-    def add_latency_millis(millis, return_index = false)
-      index = find_bucket_index(millis * 1000)
-
-      return index if return_index
-
-      @latencies[index] += 1
-      @latencies
-    end
-
-    # Increment the internal counter for the bucket this latency falls into.
-    # @param micros
-    def add_latency_micros(micros, return_index = false)
-      index = find_bucket_index(micros)
-
-      return index if return_index
-
-      @latencies[index] += 1
-      @latencies
-    end
-
-    # Returns the list of latencies buckets as an array.
-    #
-    #
-    # @return the list of latencies buckets as an array.
-    def get_latencies
-      @latencies
-    end
-
-    def get_latency(index)
-      return @latencies[index]
-    end
-
-    def clear
-      @latencies = Array.new(BUCKETS.length, 0)
-    end
-
-    #
-    # Returns the counts in the bucket this latency falls into.
-    # The latencies will not be updated.
-    # @param latency
-    # @return the bucket content for the latency.
-    #
-    def get_bucket_for_latency_millis(latency)
-      return @latencies[find_bucket_index(latency * 1000)]
-    end
-
-    #
-    # Returns the counts in the bucket this latency falls into.
-    # The latencies will not be updated.
-    # @param latency
-    # @return the bucket content for the latency.
-    #
-    def get_bucket_for_latency_micros(latency)
-      return @latencies[find_bucket_index(latency)]
+    def self.get_bucket(latency)
+      return find_bucket_index(latency * 1000)
     end
 
     private
 
-    def find_bucket_index(micros)
+    def self.find_bucket_index(micros)
       if (micros > MAX_LATENCY) then
         return BUCKETS.length - 1
       end

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