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

data/lib/splitclient-rb/cache/stores/sdk_blocker.rb

@@ -11,6 +11,7 @@ module SplitIoClient
           @splits_repository = splits_repository
           @segments_repository = segments_repository
           @config = config
+          @internal_ready = Concurrent::CountDownLatch.new(1)
 
           if @config.standalone?
             @splits_repository.not_ready!
@@ -49,6 +50,14 @@ module SplitIoClient
           return true if @config.consumer?
           @splits_repository.ready? && @segments_repository.ready?
         end
+
+        def sdk_internal_ready
+          @internal_ready.count_down
+        end
+
+        def wait_unitil_internal_ready
+          @internal_ready.wait
+        end
       end
     end
   end

data/lib/splitclient-rb/clients/split_client.rb

@@ -1,6 +1,11 @@
 module SplitIoClient
   EVENTS_SIZE_THRESHOLD = 32768
   EVENT_AVERAGE_SIZE = 1024
+  GET_TREATMENT = 'get_treatment'
+  GET_TREATMENTS = 'get_treatments'
+  GET_TREATMENT_WITH_CONFIG = 'get_treatment_with_config'
+  GET_TREATMENTS_WITH_CONFIG = 'get_treatments_with_config'
+  TRACK = 'track'
 
   class SplitClient
     #
@@ -9,18 +14,17 @@ module SplitIoClient
     # @param api_key [String] the API key for your split account
     #
     # @return [SplitIoClient] split.io client instance
-    def initialize(api_key, metrics, splits_repository, segments_repository, impressions_repository, metrics_repository, events_repository, sdk_blocker, config, impressions_manager)
+    def initialize(api_key, repositories, sdk_blocker, config, impressions_manager, telemetry_evaluation_producer)
       @api_key = api_key
-      @metrics = metrics
-      @splits_repository = splits_repository
-      @segments_repository = segments_repository
-      @impressions_repository = impressions_repository
-      @metrics_repository = metrics_repository
-      @events_repository = events_repository
+      @splits_repository = repositories[:splits]
+      @segments_repository = repositories[:segments]
+      @impressions_repository = repositories[:impressions]
+      @events_repository = repositories[:events]
       @sdk_blocker = sdk_blocker
       @destroyed = false
       @config = config
       @impressions_manager = impressions_manager
+      @telemetry_evaluation_producer = telemetry_evaluation_producer
     end
 
     def get_treatment(
@@ -28,7 +32,7 @@ module SplitIoClient
         multiple = false, evaluator = nil
       )
       impressions = []
-      result = treatment(key, split_name, attributes, split_data, store_impressions, multiple, evaluator, 'get_treatment', impressions)
+      result = treatment(key, split_name, attributes, split_data, store_impressions, multiple, evaluator, GET_TREATMENT, impressions)
       @impressions_manager.track(impressions)
 
       if multiple
@@ -43,7 +47,7 @@ module SplitIoClient
         multiple = false, evaluator = nil
       )
       impressions = []
-      result = treatment(key, split_name, attributes, split_data, store_impressions, multiple, evaluator, 'get_treatment_with_config', impressions)
+      result = treatment(key, split_name, attributes, split_data, store_impressions, multiple, evaluator, GET_TREATMENT_WITH_CONFIG, impressions)
       @impressions_manager.track(impressions)
 
       result
@@ -58,7 +62,7 @@ module SplitIoClient
     end
 
     def get_treatments_with_config(key, split_names, attributes = {})
-      treatments(key, split_names, attributes,'get_treatments_with_config')
+      treatments(key, split_names, attributes, GET_TREATMENTS_WITH_CONFIG)
     end
 
     def destroy
@@ -85,6 +89,7 @@ module SplitIoClient
     def track(key, traffic_type_name, event_type, value = nil, properties = nil)
       return false unless valid_client && @config.split_validator.valid_track_parameters(key, traffic_type_name, event_type, value, properties)
 
+      start = Time.now
       properties_size = EVENT_AVERAGE_SIZE
 
       if !properties.nil?
@@ -102,13 +107,14 @@ module SplitIoClient
           'your events to a valid traffic type defined in the Split console')
       end
 
-      begin
-        @events_repository.add(key.to_s, traffic_type_name.downcase, event_type.to_s, (Time.now.to_f * 1000).to_i, value, properties, properties_size)
-        true
-      rescue StandardError => error
-        @config.log_found_exception(__method__.to_s, error)
-        false
-      end
+      @events_repository.add(key.to_s, traffic_type_name.downcase, event_type.to_s, (Time.now.to_f * 1000).to_i, value, properties, properties_size)
+      record_latency(TRACK, start)
+      true
+    rescue StandardError => error
+      @config.log_found_exception(__method__.to_s, error)
+      record_exception(TRACK)
+
+      false
     end
 
     def keys_from_key(key)
@@ -209,10 +215,8 @@ module SplitIoClient
         @splits_repository.get_splits(sanitized_split_names).each_with_object({}) do |(name, data), memo|
           memo.merge!(name => treatment(key, name, attributes, data, false, true, evaluator, calling_method, impressions))
         end
-      latency = (Time.now - start) * 1000.0
-      # Measure
-      @metrics.time('sdk.' + calling_method, latency)
 
+      record_latency(calling_method, start)
       @impressions_manager.track(impressions)
 
       split_names_keys = treatments_labels_change_numbers.keys
@@ -283,17 +287,15 @@ module SplitIoClient
           control_treatment.merge({ label: Engine::Models::Label::NOT_READY })
         end
 
-        latency = (Time.now - start) * 1000.0
+        record_latency(calling_method, start) unless multiple
         
         impression = @impressions_manager.build_impression(matching_key, bucketing_key, split_name, treatment_data, { attributes: attributes, time: nil })
         impressions << impression unless impression.nil?
-
-        # Measure
-        @metrics.time('sdk.' + calling_method, latency) unless multiple
       rescue StandardError => error
-        p error
         @config.log_found_exception(__method__.to_s, error)
 
+        record_exception(calling_method)
+
         impression = @impressions_manager.build_impression(matching_key, bucketing_key, split_name, control_treatment, { attributes: attributes, time: nil })
         impressions << impression unless impression.nil?
 
@@ -315,5 +317,37 @@ module SplitIoClient
     def parsed_attributes(attributes)
       return attributes || attributes.to_h
     end
+
+    def record_latency(method, start)
+      bucket = BinarySearchLatencyTracker.get_bucket((Time.now - start) * 1000.0)
+      
+      case method
+      when GET_TREATMENT
+        @telemetry_evaluation_producer.record_latency(Telemetry::Domain::Constants::TREATMENT, bucket)
+      when GET_TREATMENTS
+        @telemetry_evaluation_producer.record_latency(Telemetry::Domain::Constants::TREATMENTS, bucket)
+      when GET_TREATMENT_WITH_CONFIG
+        @telemetry_evaluation_producer.record_latency(Telemetry::Domain::Constants::TREATMENT_WITH_CONFIG, bucket)
+      when GET_TREATMENTS_WITH_CONFIG
+        @telemetry_evaluation_producer.record_latency(Telemetry::Domain::Constants::TREATMENTS_WITH_CONFIG, bucket)
+      when TRACK
+        @telemetry_evaluation_producer.record_latency(Telemetry::Domain::Constants::TRACK, bucket)
+      end      
+    end
+
+    def record_exception(method)
+      case method
+      when GET_TREATMENT
+        @telemetry_evaluation_producer.record_exception(Telemetry::Domain::Constants::TREATMENT)
+      when GET_TREATMENTS
+        @telemetry_evaluation_producer.record_exception(Telemetry::Domain::Constants::TREATMENTS)
+      when GET_TREATMENT_WITH_CONFIG
+        @telemetry_evaluation_producer.record_exception(Telemetry::Domain::Constants::TREATMENT_WITH_CONFIG)
+      when GET_TREATMENTS_WITH_CONFIG
+        @telemetry_evaluation_producer.record_exception(Telemetry::Domain::Constants::TREATMENTS_WITH_CONFIG)
+      when TRACK
+        @telemetry_evaluation_producer.record_exception(Telemetry::Domain::Constants::TRACK)
+      end
+    end
   end
 end

data/lib/splitclient-rb/constants.rb

@@ -6,5 +6,10 @@ class SplitIoClient::Constants
   CONTROL_SEC = 'control_sec'
   OCCUPANCY_CHANNEL_PREFIX = '[?occupancy=metrics.publishers]'
   FETCH_BACK_OFF_BASE_RETRIES = 1
+  PUSH_CONNECTED = 'PUSH_CONNECTED'
+  PUSH_RETRYABLE_ERROR = 'PUSH_RETRYABLE_ERROR'
+  PUSH_NONRETRYABLE_ERROR = 'PUSH_NONRETRYABLE_ERROR'
+  PUSH_SUBSYSTEM_DOWN = 'PUSH_SUBSYSTEM_DOWN'
+  PUSH_SUBSYSTEM_READY = 'PUSH_SUBSYSTEM_READY'
+  PUSH_SUBSYSTEM_OFF = 'PUSH_SUBSYSTEM_OFF'
 end
-  

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