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

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

data/lib/splitclient-rb/split_factory_registry.rb

@@ -47,5 +47,17 @@ module SplitIoClient
     def other_factories
       return !@api_keys_hash.empty?
     end
+
+    def active_factories
+      @api_keys_hash.length
+    end
+
+    def redundant_active_factories
+      to_return = 0
+
+      @api_keys_hash.each { |key| to_return += (key[1]-1) }
+
+      to_return
+    end
   end
 end

data/lib/splitclient-rb/sse/event_source/client.rb

@@ -13,7 +13,7 @@ module SplitIoClient
         KEEP_ALIVE_RESPONSE = "c\r\n:keepalive\n\n\r\n".freeze
         ERROR_EVENT_TYPE = 'error'.freeze
 
-        def initialize(config, read_timeout: DEFAULT_READ_TIMEOUT)
+        def initialize(config, api_key, telemetry_runtime_producer, read_timeout: DEFAULT_READ_TIMEOUT)
           @config = config
           @read_timeout = read_timeout
           @connected = Concurrent::AtomicBoolean.new(false)
@@ -21,6 +21,8 @@ module SplitIoClient
           @socket = nil
           @event_parser = SSE::EventSource::EventParser.new(config)
           @on = { event: ->(_) {}, action: ->(_) {} }
+          @api_key = api_key
+          @telemetry_runtime_producer = telemetry_runtime_producer
 
           yield self if block_given?
         end
@@ -116,6 +118,7 @@ module SplitIoClient
 
           if response_code == OK_CODE && !error_event
             @connected.make_true
+            @telemetry_runtime_producer.record_streaming_event(Telemetry::Domain::Constants::SSE_CONNECTION_ESTABLISHED, nil)
             dispatch_action(Constants::PUSH_CONNECTED)
           end
 
@@ -142,6 +145,10 @@ module SplitIoClient
           req = "GET #{uri.request_uri} HTTP/1.1\r\n"
           req << "Host: #{uri.host}\r\n"
           req << "Accept: text/event-stream\r\n"
+          req << "SplitSDKVersion: #{@config.language}-#{@config.version}\r\n"
+          req << "SplitSDKMachineIP: #{@config.machine_ip}\r\n"
+          req << "SplitSDKMachineName: #{@config.machine_name}\r\n"
+          req << "SplitSDKClientKey: #{@api_key.split(//).last(4).join}\r\n" unless @api_key.nil?
           req << "Cache-Control: no-cache\r\n\r\n"
           @config.logger.debug("Request info: #{req}") if @config.debug_enabled
           req
@@ -158,6 +165,8 @@ module SplitIoClient
 
         def dispatch_error(event)
           @config.logger.error("Event error: #{event.event_type}, #{event.data}")
+          @telemetry_runtime_producer.record_streaming_event(Telemetry::Domain::Constants::ABLY_ERROR, event.data['code'])
+
           if event.data['code'] >= 40_140 && event.data['code'] <= 40_149
             close(Constants::PUSH_RETRYABLE_ERROR)
           elsif event.data['code'] >= 40_000 && event.data['code'] <= 49_999

data/lib/splitclient-rb/sse/notification_manager_keeper.rb

@@ -5,12 +5,17 @@ require 'concurrent'
 module SplitIoClient
   module SSE
     class NotificationManagerKeeper
-      def initialize(config)
+      DISABLED = 0
+      ENABLED = 1
+      PAUSED = 2
+
+      def initialize(config, telemetry_runtime_producer)
         @config = config
         @publisher_available = Concurrent::AtomicBoolean.new(true)
         @publishers_pri = Concurrent::AtomicFixnum.new
         @publishers_sec = Concurrent::AtomicFixnum.new
         @on = { action: ->(_) {} }
+        @telemetry_runtime_producer = telemetry_runtime_producer
 
         yield self if block_given?
       end
@@ -22,6 +27,7 @@ module SplitIoClient
           process_event_occupancy(event.channel, event.data['metrics']['publishers'])
         end
       rescue StandardError => e
+        p e
         @config.logger.error(e)
       end
 
@@ -34,10 +40,13 @@ module SplitIoClient
       def process_event_control(type)
         case type
         when 'STREAMING_PAUSED'
+          @telemetry_runtime_producer.record_streaming_event(Telemetry::Domain::Constants::STREAMING_STATUS, PAUSED)
           dispatch_action(Constants::PUSH_SUBSYSTEM_DOWN)
         when 'STREAMING_RESUMED'
+          @telemetry_runtime_producer.record_streaming_event(Telemetry::Domain::Constants::STREAMING_STATUS, ENABLED)
           dispatch_action(Constants::PUSH_SUBSYSTEM_READY) if @publisher_available.value
         when 'STREAMING_DISABLED'
+          @telemetry_runtime_producer.record_streaming_event(Telemetry::Domain::Constants::STREAMING_STATUS, DISABLED)
           dispatch_action(Constants::PUSH_SUBSYSTEM_OFF)
         else
           @config.logger.error("Incorrect event type: #{incoming_notification}")
@@ -59,8 +68,13 @@ module SplitIoClient
       end
 
       def update_publishers(channel, publishers)
-        @publishers_pri.value = publishers if channel == Constants::CONTROL_PRI
-        @publishers_sec.value = publishers if channel == Constants::CONTROL_SEC
+        if channel == Constants::CONTROL_PRI
+          @telemetry_runtime_producer.record_streaming_event(Telemetry::Domain::Constants::OCCUPANCY_PRI, publishers)
+          @publishers_pri.value = publishers
+        elsif channel == Constants::CONTROL_SEC
+          @telemetry_runtime_producer.record_streaming_event(Telemetry::Domain::Constants::OCCUPANCY_SEC, publishers)
+          @publishers_sec.value = publishers
+        end
       end
 
       def are_publishers_available?

data/lib/splitclient-rb/sse/sse_handler.rb

@@ -5,13 +5,17 @@ module SplitIoClient
     class SSEHandler
       attr_reader :sse_client
 
-      def initialize(config, synchronizer, splits_repository, segments_repository, notification_manager_keeper)
-        @config = config
+      def initialize(metadata,
+                     synchronizer,
+                     repositories,
+                     notification_manager_keeper,
+                     telemetry_runtime_producer)
+        @config = metadata[:config]
         @notification_manager_keeper = notification_manager_keeper
-        @splits_worker = SplitIoClient::SSE::Workers::SplitsWorker.new(synchronizer, config, splits_repository)
-        @segments_worker = SplitIoClient::SSE::Workers::SegmentsWorker.new(synchronizer, config, segments_repository)
-        @notification_processor = SplitIoClient::SSE::NotificationProcessor.new(config, @splits_worker, @segments_worker)
-        @sse_client = SSE::EventSource::Client.new(@config) do |client|
+        @splits_worker = SplitIoClient::SSE::Workers::SplitsWorker.new(synchronizer, @config, repositories[:splits])
+        @segments_worker = SplitIoClient::SSE::Workers::SegmentsWorker.new(synchronizer, @config, repositories[:segments])
+        @notification_processor = SplitIoClient::SSE::NotificationProcessor.new(@config, @splits_worker, @segments_worker)
+        @sse_client = SSE::EventSource::Client.new(@config, metadata[:api_key], telemetry_runtime_producer) do |client|
           client.on_event { |event| handle_incoming_message(event) }
           client.on_action { |action| process_action(action) }
         end

data/lib/splitclient-rb/telemetry/domain/constants.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    module Domain
+      class Constants
+        BUR_TIMEOUT = 'bur_timeout'
+        NON_READY_USAGES = 'non_ready_usages'
+
+        IMPRESSIONS_DROPPED = 'impressions_dropped'
+        IMPRESSIONS_DEDUPE = 'impressions_deduped'
+        IMPRESSIONS_QUEUED = 'impressions_queued'
+
+        EVENTS_DROPPED = 'events_dropped'
+        EVENTS_QUEUED = 'events_queued'
+
+        SPLIT_SYNC = 'split_sync'
+        SEGMENT_SYNC = 'segment_sync'
+        IMPRESSIONS_SYNC = 'impressions_sync'
+        IMPRESSION_COUNT_SYNC = 'impression_count_sync'
+        EVENT_SYNC = 'event_sync'
+        TELEMETRY_SYNC = 'telemetry_sync'
+        TOKEN_SYNC = 'token_sync'
+
+        SSE_CONNECTION_ESTABLISHED = 0
+        OCCUPANCY_PRI = 10
+        OCCUPANCY_SEC = 20
+        STREAMING_STATUS = 30
+        CONNECTION_ERROR = 40
+        TOKEN_REFRESH = 50
+        ABLY_ERROR = 60
+        SYNC_MODE = 70
+
+        TREATMENT = 'treatment'
+        TREATMENTS = 'treatments'
+        TREATMENT_WITH_CONFIG = 'treatment_with_config'
+        TREATMENTS_WITH_CONFIG = 'treatments_with_config'
+        TRACK = 'track'
+      end
+    end
+  end
+end

data/lib/splitclient-rb/telemetry/domain/structs.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    # sp: splits, se: segments, im: impressions, ic:impression count, ev: events, te: telemetry, to: token.
+    LastSynchronization = Struct.new(:sp, :se, :im, :ic, :ev, :te, :to)
+    HttpErrors = Struct.new(:sp, :se, :im, :ic, :ev, :te, :to)
+    HttpLatencies = Struct.new(:sp, :se, :im, :ic, :ev, :te, :to)
+
+    # sp: splits, se: segmentos, im: impressions, ev: events, t: telemetry
+    Rates = Struct.new(:sp, :se, :im, :ev, :te)
+
+    # s: sdkUrl, e: eventsUrl, a: authUrl, st: streamUrl, t: telemetryUrl
+    UrlOverrides = Struct.new(:s, :e, :a, :st, :t)
+
+    # om: operationMode, se: streamingEnabled, st: storage, rr: refreshRate, uo: urlOverrides, iq: impressionsQueueSize,
+    # eq: eventsQueueSize, im: impressionsMode, il: impressionListenerEnabled, hp: httpProxyDetected, af: activeFactories,
+    # rf: redundantActiveFactories, tr: timeUntilSdkReady, bt: burTimeouts, nr: sdkNotReadyUsage, t: tags, i: integrations
+    ConfigInit = Struct.new(:om, :st, :af, :rf, :t, :se, :rr, :uo, :iq, :eq, :im, :il, :hp, :tr, :bt, :nr, :i)
+
+    # ls: lastSynchronization, ml: clientMethodLatencies, me: clientMethodExceptions, he: httpErros, hl: httpLatencies,
+    # tr: tokenRefreshes, ar: authRejections, iq: impressionsQueued, ide: impressionsDeduped, idr: impressionsDropped,
+    # spc: splitsCount, sec: segmentCount, skc: segmentKeyCount, sl: sessionLengthMs, eq: eventsQueued, ed: eventsDropped,
+    # se: streamingEvents, t: tags
+    Usage = Struct.new(:ls, :ml, :me, :he, :hl, :tr, :ar, :iq, :ide, :idr, :spc, :sec, :skc, :sl, :eq, :ed, :se, :t)
+
+    # t: treatment, ts: treatments, tc: treatmentWithConfig, tcs: treatmentsWithConfig, tr: track
+    ClientMethodLatencies = Struct.new(:t, :ts, :tc, :tcs, :tr)
+    ClientMethodExceptions = Struct.new(:t, :ts, :tc, :tcs, :tr)
+  end
+end