Add "init" telemetry [memory & redis]

.rubocop.yml

@@ -13,6 +13,8 @@ Metrics/MethodLength:
 
 Metrics/ClassLength:
   Max: 150
+  Exclude:
+    - lib/splitclient-rb/telemetry/memory/memory_synchronizer.rb
 
 Metrics/CyclomaticComplexity:
   Max: 8

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

@@ -9,8 +9,20 @@ def initialize(config, api_key, telemetry_runtime_producer)
         @telemetry_runtime_producer = telemetry_runtime_producer
       end
 
-      def record_init
-        # TODO: implement
+      def record_init(config_init)
+        start = Time.now
+        response = post_api("#{@config.telemetry_service_url}/metrics/config", @api_key, config_init)
+
+        if response.success?
+          @config.split_logger.log_if_debug("Telemetry post success: record init.")
+
+          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 config: #{response.status}.")
+        end
       end
 
       def record_stats(stats)
@@ -25,7 +37,7 @@ def record_stats(stats)
           @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: #{response.status}.")
+          @config.logger.error("Unexpected status code while posting telemetry usage: #{response.status}.")
         end
       end
     end

lib/splitclient-rb/split_config.rb

@@ -111,6 +111,8 @@ def initialize(opts = {})
       @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
 
@@ -274,6 +276,8 @@ def initialize(opts = {})
 
     attr_accessor :telemetry_service_url
 
+    attr_accessor :sdk_start_time
+
     def self.default_impressions_mode
       :optimized
     end

lib/splitclient-rb/split_factory.rb

@@ -38,7 +38,7 @@ def initialize(api_key, config_hash = {})
       @impression_counter = SplitIoClient::Engine::Common::ImpressionCounter.new
       @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, @splits_repository, @segments_repository, @telemetry_api)
+      @telemetry_synchronizer = Telemetry::Synchronizer.new(@config, @telemetry_consumers, @init_producer, repositories, @telemetry_api)
 
       start!
 

lib/splitclient-rb/split_factory_registry.rb

@@ -47,5 +47,17 @@ def number_of_factories_for(api_key)
     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

lib/splitclient-rb/telemetry/memory/memory_synchronizer.rb

@@ -5,15 +5,14 @@ module Telemetry
     class MemorySynchronizer < Synchronizer
       def initialize(config,
                      telemtry_consumers,
-                     splits_repository,
-                     segments_repository,
+                     repositories,
                      telemetry_api)
         @config = config
         @telemetry_init_consumer = telemtry_consumers[:init]
         @telemetry_runtime_consumer = telemtry_consumers[:runtime]
         @telemtry_evaluation_consumer = telemtry_consumers[:evaluation]
-        @splits_repository = splits_repository
-        @segments_repository = segments_repository
+        @splits_repository = repositories[:splits]
+        @segments_repository = repositories[:segments]
         @telemetry_api = telemetry_api
       end
 
@@ -39,16 +38,83 @@ def synchronize_stats
 
         @telemetry_api.record_stats(format_stats(usage))
       rescue StandardError => error
-        p error
         @config.log_found_exception(__method__.to_s, error)
       end
 
-      def synchronize_config(init_config, timed_until_ready, factory_instances, tags)
-        # implement
+      def synchronize_config(active_factories = nil, redundant_active_factories = nil, time_until_ready = nil)
+        rates = Rates.new(@config.features_refresh_rate,
+                          @config.segments_refresh_rate,
+                          @config.impressions_refresh_rate,
+                          @config.events_push_rate,
+                          @config.telemetry_refresh_rate)
+
+        url_overrides = UrlOverrides.new(@config.base_uri != SplitConfig.default_base_uri.chomp('/'),
+                                         @config.events_uri != SplitConfig.default_events_uri.chomp('/'),
+                                         @config.auth_service_url != SplitConfig.default_auth_service_url,
+                                         @config.streaming_service_url != SplitConfig.default_streaming_service_url,
+                                         @config.telemetry_service_url != SplitConfig.default_telemetry_service_url)
+
+        active_factories ||= SplitIoClient.split_factory_registry.active_factories
+        redundant_active_factories ||= SplitIoClient.split_factory_registry.redundant_active_factories
+
+        init_config = ConfigInit.new(@config.mode,
+                                     'memory',
+                                     active_factories,
+                                     redundant_active_factories,
+                                     @telemetry_runtime_consumer.pop_tags,
+                                     @config.streaming_enabled,
+                                     rates,
+                                     url_overrides,
+                                     @config.impressions_queue_size,
+                                     @config.events_queue_size,
+                                     @config.impressions_mode,
+                                     !@config.impression_listener.nil?,
+                                     http_proxy_detected?,
+                                     time_until_ready || Time.now - @config.sdk_start_time,
+                                     @telemetry_init_consumer.bur_timeouts,
+                                     @telemetry_init_consumer.non_ready_usages)
+
+        @telemetry_api.record_init(fornat_init_config(init_config))
+      rescue StandardError => error
+        @config.log_found_exception(__method__.to_s, error)
       end
 
       private
 
+      def fornat_init_config(init)
+        {
+          oM: init.om,
+          sE: init.se,
+          st: init.st,
+          rR: {
+            sp: init.rr.sp,
+            se: init.rr.se,
+            im: init.rr.im,
+            ev: init.rr.ev,
+            te: init.rr.te
+          },
+          iQ: init.iq,
+          eQ: init.eq,
+          iM: init.im,
+          uO: {
+            s: init.uo.s,
+            e: init.uo.e,
+            a: init.uo.a,
+            st: init.uo.st,
+            t: init.uo.t
+          },
+          iL: init.il,
+          hP: init.hp,
+          aF: init.af,
+          rF: init.rf,
+          tR: init.tr,
+          bT: init.bt,
+          nR: init.nr,
+          t: init.t,
+          i: init.i
+        }
+      end
+
       def format_stats(usage)
         {
           lS: usage.ls.to_h,
@@ -99,6 +165,10 @@ def format_stats(usage)
           t: usage.t
         }
       end
+
+      def http_proxy_detected?
+        !ENV['HTTP_PROXY'].nil? || !ENV['HTTPS_PROXY'].nil?
+      end
     end
   end
 end

lib/splitclient-rb/telemetry/redis/redis_init_producer.rb

@@ -12,7 +12,7 @@ def record_config(config_data)
         return if config_data.nil?
 
         data = { m: { i: @config.machine_ip, n: @config.machine_name, s: "#{@config.language}-#{@config.version}" },
-                 t: { om: config_data.om, st: config_data.st, af: config_data.af, rf: config_data.rf, t: config_data.t } }
+                 t: { oM: config_data.om, st: config_data.st, aF: config_data.af, rF: config_data.rf, t: config_data.t } }
 
         @adapter.add_to_queue(config_key, data.to_json)
       rescue StandardError => error

lib/splitclient-rb/telemetry/redis/redis_synchronizer.rb

@@ -3,16 +3,25 @@
 module SplitIoClient
   module Telemetry
     class RedisSynchronizer < Synchronizer
-      def initialize(telemetry_init_consumer)
-        @telemetry_init_consumer = telemetry_init_consumer
+      def initialize(config,
+                     telemetry_init_producer)
+        @config = config
+        @telemetry_init_producer = telemetry_init_producer
       end
 
       def synchronize_stats
         # No-op
       end
 
-      def synchronize_config(init_config, timed_until_ready, factory_instances, tags)
-        # implement
+      def synchronize_config(active_factories = nil, redundant_active_factories = nil, tags = nil)
+        active_factories ||= SplitIoClient.split_factory_registry.active_factories
+        redundant_active_factories ||= SplitIoClient.split_factory_registry.redundant_active_factories
+
+        init_config = ConfigInit.new(@config.mode, 'redis', active_factories, redundant_active_factories, tags)
+
+        @telemetry_init_producer.record_config(init_config)
+      rescue StandardError => error
+        @config.log_found_exception(__method__.to_s, error)
       end
     end
   end

lib/splitclient-rb/telemetry/synchronizer.rb

@@ -10,17 +10,17 @@ class Synchronizer
 
       def initialize(config,
                      telemtry_consumers,
-                     splits_repository,
-                     segments_repository,
+                     telemetry_init_producer,
+                     repositories,
                      telemetry_api)
         @synchronizer = case config.telemetry_adapter.class.to_s
                         when 'SplitIoClient::Cache::Adapters::RedisAdapter'
-                          SplitIoClient::Telemetry::RedisSynchronizer.new(telemtry_consumers[:init])
+                          SplitIoClient::Telemetry::RedisSynchronizer.new(config,
+                                                                          telemetry_init_producer)
                         else
                           SplitIoClient::Telemetry::MemorySynchronizer.new(config,
                                                                            telemtry_consumers,
-                                                                           splits_repository,
-                                                                           segments_repository,
+                                                                           repositories,
                                                                            telemetry_api)
                         end
       end

spec/splitclient/split_factory_spec.rb

@@ -180,5 +180,27 @@
 
       expect(SplitIoClient.split_factory_registry.number_of_factories_for('API_KEY')).to eq 0
     end
+
+    it 'active and redundant factories' do
+      stub_request(:get, 'https://sdk.split.io/api/splitChanges?since=-1')
+        .to_return(status: 200, body: [])
+
+      described_class.new('API_KEY', options)
+
+      described_class.new('ANOTHER_API_KEY', options)
+      described_class.new('ANOTHER_API_KEY', options)
+
+      described_class.new('ANOTHER_API_KEY-2', options)
+      described_class.new('ANOTHER_API_KEY-2', options)
+      described_class.new('ANOTHER_API_KEY-2', options)
+
+      described_class.new('API_KEY-2', options)
+      described_class.new('API_KEY-2', options)
+      described_class.new('API_KEY-2', options)
+      described_class.new('API_KEY-2', options)
+
+      expect(SplitIoClient.split_factory_registry.active_factories).to be(4)
+      expect(SplitIoClient.split_factory_registry.redundant_active_factories).to be(6)
+    end
   end
 end