splitclient-rb 7.2.3 → 7.3.0.pre.rc1

data/lib/splitclient-rb/engine/api/client.rb

@@ -8,12 +8,13 @@ module SplitIoClient
       RUBY_ENCODING = '1.9'.respond_to?(:force_encoding)
 
       def initialize(config)
-        @config = config
+        @config = config        
       end
 
-      def get_api(url, api_key, params = {})
+      def get_api(url, api_key, params = {}, cache_control_headers = false)
         api_client.get(url, params) do |req|
           req.headers = common_headers(api_key).merge('Accept-Encoding' => 'gzip')
+          req.headers = req.headers.merge('Cache-Control' => 'no-cache') if cache_control_headers
 
           req.options[:timeout] = @config.read_timeout
           req.options[:open_timeout] = @config.connection_timeout

data/lib/splitclient-rb/engine/api/events.rb

@@ -3,9 +3,10 @@
 module SplitIoClient
   module Api
     class Events < Client
-      def initialize(api_key, config)
+      def initialize(api_key, config, telemetry_runtime_producer)
         super(config)
         @api_key = api_key
+        @telemetry_runtime_producer = telemetry_runtime_producer
       end
 
       def post(events)
@@ -14,6 +15,8 @@ module SplitIoClient
           return
         end
 
+        start = Time.now
+
         events.each_slice(@config.events_queue_size) do |events_slice|
           response = post_api(
             "#{@config.events_uri}/events/bulk",
@@ -23,7 +26,13 @@ module SplitIoClient
 
           if response.success?
             @config.split_logger.log_if_debug("Events reported: #{events_slice.size}")
+
+            bucket = BinarySearchLatencyTracker.get_bucket((Time.now - start) * 1000.0)
+            @telemetry_runtime_producer.record_sync_latency(Telemetry::Domain::Constants::EVENT_SYNC, bucket)
+            @telemetry_runtime_producer.record_successful_sync(Telemetry::Domain::Constants::EVENT_SYNC, (Time.now.to_f * 1000.0).to_i)
           else
+            @telemetry_runtime_producer.record_sync_error(Telemetry::Domain::Constants::EVENT_SYNC, response.status)
+
             @config.logger.error("Unexpected status code while posting events: #{response.status}." \
             ' - Check your API key and base URI')
             raise 'Split SDK failed to connect to backend to post events'

data/lib/splitclient-rb/engine/api/impressions.rb

@@ -3,9 +3,10 @@
 module SplitIoClient
   module Api
     class Impressions < Client
-      def initialize(api_key, config)
+      def initialize(api_key, config, telemetry_runtime_producer)
+        super(config)
         @api_key = api_key
-        @config = config
+        @telemetry_runtime_producer = telemetry_runtime_producer
       end
 
       def post(impressions)
@@ -14,11 +15,19 @@ module SplitIoClient
           return
         end
 
+        start = Time.now
+
         response = post_api("#{@config.events_uri}/testImpressions/bulk", @api_key, impressions, impressions_headers)
 
         if response.success?
           @config.split_logger.log_if_debug("Impressions reported: #{total_impressions(impressions)}")
+          
+          bucket = BinarySearchLatencyTracker.get_bucket((Time.now - start) * 1000.0)
+          @telemetry_runtime_producer.record_sync_latency(Telemetry::Domain::Constants::IMPRESSIONS_SYNC, bucket)
+          @telemetry_runtime_producer.record_successful_sync(Telemetry::Domain::Constants::IMPRESSIONS_SYNC, (Time.now.to_f * 1000.0).to_i)
         else
+          @telemetry_runtime_producer.record_sync_error(Telemetry::Domain::Constants::IMPRESSIONS_SYNC, response.status)
+
           @config.logger.error("Unexpected status code while posting impressions: #{response.status}." \
           ' - Check your API key and base URI')
           raise 'Split SDK failed to connect to backend to post impressions'
@@ -31,11 +40,19 @@ module SplitIoClient
           return
         end
 
+        start = Time.now
+
         response = post_api("#{@config.events_uri}/testImpressions/count", @api_key, impressions_count)
 
         if response.success?
           @config.split_logger.log_if_debug("Impressions count sent: #{impressions_count[:pf].length}")
+
+          bucket = BinarySearchLatencyTracker.get_bucket((Time.now - start) * 1000.0)
+          @telemetry_runtime_producer.record_sync_latency(Telemetry::Domain::Constants::IMPRESSION_COUNT_SYNC, bucket)
+          @telemetry_runtime_producer.record_successful_sync(Telemetry::Domain::Constants::IMPRESSION_COUNT_SYNC, (Time.now.to_f * 1000.0).to_i)
         else
+          @telemetry_runtime_producer.record_sync_error(Telemetry::Domain::Constants::IMPRESSION_COUNT_SYNC, response.status)
+
           @config.logger.error("Unexpected status code while posting impressions count: #{response.status}." \
           ' - Check your API key and base URI')
           raise 'Split SDK failed to connect to backend to post impressions'

data/lib/splitclient-rb/engine/api/segments.rb

@@ -4,24 +4,20 @@ module SplitIoClient
   module Api
     # Retrieves segment changes from the Split Backend
     class Segments < Client
-      METRICS_PREFIX = 'segmentChangeFetcher'
-
-      def initialize(api_key, metrics, segments_repository, config)
+      def initialize(api_key, segments_repository, config, telemetry_runtime_producer)
         super(config)
-        @metrics = metrics
         @api_key = api_key
         @segments_repository = segments_repository
+        @telemetry_runtime_producer = telemetry_runtime_producer
       end
 
-      def fetch_segments_by_names(names)
-        start = Time.now
-
+      def fetch_segments_by_names(names, cache_control_headers = false)
         return if names.nil? || names.empty?
 
         names.each do |name|
           since = @segments_repository.get_change_number(name)
           loop do
-            segment = fetch_segment_changes(name, since)
+            segment = fetch_segment_changes(name, since, cache_control_headers)
             @segments_repository.add_to_segment(segment)
 
             @config.split_logger.log_if_debug("Segment #{name} fetched before: #{since}, \
@@ -32,19 +28,17 @@ module SplitIoClient
             since = @segments_repository.get_change_number(name)
           end
         end
-
-        latency = (Time.now - start) * 1000.0
-        @metrics.time(METRICS_PREFIX + '.time', latency)
       end
 
       private
 
-      def fetch_segment_changes(name, since)
-        response = get_api("#{@config.base_uri}/segmentChanges/#{name}", @api_key, since: since)
+      def fetch_segment_changes(name, since, cache_control_headers = false)
+        start = Time.now
+        response = get_api("#{@config.base_uri}/segmentChanges/#{name}", @api_key, { since: since }, cache_control_headers)
+
         if response.success?
           segment = JSON.parse(response.body, symbolize_names: true)
           @segments_repository.set_change_number(name, segment[:till])
-          @metrics.count(METRICS_PREFIX + '.status.' + response.status.to_s, 1)
 
           @config.split_logger.log_if_debug("\'#{segment[:name]}\' segment retrieved.")
           unless segment[:added].empty?
@@ -55,15 +49,23 @@ module SplitIoClient
           end
           @config.split_logger.log_if_transport("Segment changes response: #{segment.to_s}")
 
+          bucket = BinarySearchLatencyTracker.get_bucket((Time.now - start) * 1000.0)
+          @telemetry_runtime_producer.record_sync_latency(Telemetry::Domain::Constants::SEGMENT_SYNC, bucket)
+          @telemetry_runtime_producer.record_successful_sync(Telemetry::Domain::Constants::SEGMENT_SYNC, (Time.now.to_f * 1000.0).to_i)
+
           segment
         elsif response.status == 403
-            @config.logger.error('Factory Instantiation: You passed a browser type api_key, ' \
-              'please grab an api key from the Split console that is of type sdk')
-            @config.valid_mode =  false
+          @telemetry_runtime_producer.record_sync_error(Telemetry::Domain::Constants::SEGMENT_SYNC, response.status)
+
+          @config.logger.error('Factory Instantiation: You passed a browser type api_key, ' \
+            'please grab an api key from the Split console that is of type sdk')
+          @config.valid_mode =  false
         else
+          @telemetry_runtime_producer.record_sync_error(Telemetry::Domain::Constants::SEGMENT_SYNC, response.status)
+
           @config.logger.error("Unexpected status code while fetching segments: #{response.status}." \
           "Since #{since} - Check your API key and base URI")
-          @metrics.count(METRICS_PREFIX + '.status.' + response.status.to_s, 1)
+
           raise 'Split SDK failed to connect to backend to fetch segments'
         end
       end

data/lib/splitclient-rb/engine/api/splits.rb

@@ -4,35 +4,35 @@ module SplitIoClient
   module Api
     # Retrieves split definitions from the Split Backend
     class Splits < Client
-      METRICS_PREFIX = 'splitChangeFetcher'
-
-      def initialize(api_key, metrics, config)
+      def initialize(api_key, config, telemetry_runtime_producer)
         super(config)
         @api_key = api_key
-        @metrics = metrics
+        @telemetry_runtime_producer = telemetry_runtime_producer
       end
 
-      def since(since)
+      def since(since, cache_control_headers = false)
         start = Time.now
 
-        response = get_api("#{@config.base_uri}/splitChanges", @api_key, since: since)
+        response = get_api("#{@config.base_uri}/splitChanges", @api_key, { since: since }, cache_control_headers)
         if response.success?
           result = splits_with_segment_names(response.body)
 
-          @metrics.count(METRICS_PREFIX + '.status.' + response.status.to_s, 1)
           unless result[:splits].empty?
             @config.split_logger.log_if_debug("#{result[:splits].length} splits retrieved. since=#{since}")
           end
           @config.split_logger.log_if_transport("Split changes response: #{result.to_s}")
 
-          latency = (Time.now - start) * 1000.0
-          @metrics.time(METRICS_PREFIX + '.time', latency)
+          bucket = BinarySearchLatencyTracker.get_bucket((Time.now - start) * 1000.0)
+          @telemetry_runtime_producer.record_sync_latency(Telemetry::Domain::Constants::SPLIT_SYNC, bucket)
+          @telemetry_runtime_producer.record_successful_sync(Telemetry::Domain::Constants::SPLIT_SYNC, (Time.now.to_f * 1000.0).to_i)
 
           result
         else
-          @metrics.count(METRICS_PREFIX + '.status.' + response.status.to_s, 1)
+          @telemetry_runtime_producer.record_sync_error(Telemetry::Domain::Constants::SPLIT_SYNC, response.status)
+
           @config.logger.error("Unexpected status code while fetching splits: #{response.status}. " \
           'Check your API key and base URI')
+
           raise 'Split SDK failed to connect to backend to fetch split definitions'
         end
       end

data/lib/splitclient-rb/engine/api/telemetry_api.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Api
+    class TelemetryApi < Client
+      def initialize(config, api_key, telemetry_runtime_producer)
+        super(config)
+        @api_key = api_key
+        @telemetry_runtime_producer = telemetry_runtime_producer
+      end
+
+      def record_init(config_init)
+        post_telemetry("#{@config.telemetry_service_url}/metrics/config", config_init, 'init')
+      end
+
+      def record_stats(stats)
+        post_telemetry("#{@config.telemetry_service_url}/metrics/usage", stats, 'stats')
+      end
+
+      private
+
+      def post_telemetry(url, obj, method)
+        start = Time.now
+        response = post_api(url, @api_key, obj)
+
+        if response.success?
+          @config.split_logger.log_if_debug("Telemetry post succeeded: record #{method}.")
+          
+          bucket = BinarySearchLatencyTracker.get_bucket((Time.now - start) * 1000.0)
+          @telemetry_runtime_producer.record_sync_latency(Telemetry::Domain::Constants::TELEMETRY_SYNC, bucket)
+          @telemetry_runtime_producer.record_successful_sync(Telemetry::Domain::Constants::TELEMETRY_SYNC, (Time.now.to_f * 1000.0).to_i)
+        else
+          @telemetry_runtime_producer.record_sync_error(Telemetry::Domain::Constants::TELEMETRY_SYNC, response.status)
+          @config.logger.error("Unexpected status code while posting telemetry #{method}: #{response.status}.")
+        end
+      end
+    end
+  end
+end

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