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

data/lib/splitclient-rb/telemetry/memory/memory_init_consumer.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    class MemoryInitConsumer < InitConsumer
+      DEFAULT_VALUE = 0
+
+      def initialize(config)
+        @config = config
+        @adapter = config.telemetry_adapter
+      end
+
+      def non_ready_usages
+        find_counts(Domain::Constants::NON_READY_USAGES)
+      end
+
+      def bur_timeouts
+        find_counts(Domain::Constants::BUR_TIMEOUT)
+      end
+
+      private
+
+      def find_counts(action)
+        @adapter.factory_counters.find { |l| l[:action] == action }[:counts].value
+      end
+    end
+  end
+end

data/lib/splitclient-rb/telemetry/memory/memory_init_producer.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    class MemoryInitProducer < InitProducer
+      def initialize(config)
+        @config = config
+        @adapter = config.telemetry_adapter
+      end
+
+      def record_config
+        # no op
+      end
+
+      def record_bur_timeout
+        find_factory_counters(Domain::Constants::BUR_TIMEOUT)[:counts].increment
+      rescue StandardError => error
+        @config.log_found_exception(__method__.to_s, error)
+      end
+
+      def record_non_ready_usages
+        find_factory_counters(Domain::Constants::NON_READY_USAGES)[:counts].increment
+      rescue StandardError => error
+        @config.log_found_exception(__method__.to_s, error)
+      end
+
+      private
+
+      def find_factory_counters(action)
+        @adapter.factory_counters.find { |l| l[:action] == action }
+      end
+    end
+  end
+end

data/lib/splitclient-rb/telemetry/memory/memory_runtime_consumer.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    class MemoryRuntimeConsumer < RuntimeConsumer
+      DEFAULT_VALUE = 0
+
+      def initialize(config)
+        @config = config
+        @adapter = config.telemetry_adapter
+      end
+
+      def pop_tags
+        to_return = @adapter.tags
+
+        @adapter.init_tags
+
+        to_return
+      end
+
+      def impressions_stats(type)
+        @adapter.impressions_data_records.find { |l| l[:type] == type }[:value].value
+      end
+
+      def events_stats(type)
+        @adapter.events_data_records.find { |l| l[:type] == type }[:value].value
+      end
+
+      def last_synchronizations
+        splits = find_last_synchronization(Domain::Constants::SPLIT_SYNC)
+        segments = find_last_synchronization(Domain::Constants::SEGMENT_SYNC)
+        impressions = find_last_synchronization(Domain::Constants::IMPRESSIONS_SYNC)
+        imp_count = find_last_synchronization(Domain::Constants::IMPRESSION_COUNT_SYNC)
+        events = find_last_synchronization(Domain::Constants::EVENT_SYNC)
+        telemetry = find_last_synchronization(Domain::Constants::TELEMETRY_SYNC)
+        token = find_last_synchronization(Domain::Constants::TOKEN_SYNC)
+
+        LastSynchronization.new(splits, segments, impressions, imp_count, events, telemetry, token)
+      end
+
+      def pop_http_errors
+        splits = find_http_errors(Domain::Constants::SPLIT_SYNC)
+        segments = find_http_errors(Domain::Constants::SEGMENT_SYNC)
+        impressions = find_http_errors(Domain::Constants::IMPRESSIONS_SYNC)
+        imp_count = find_http_errors(Domain::Constants::IMPRESSION_COUNT_SYNC)
+        events = find_http_errors(Domain::Constants::EVENT_SYNC)
+        telemetry = find_http_errors(Domain::Constants::TELEMETRY_SYNC)
+        token = find_http_errors(Domain::Constants::TOKEN_SYNC)
+
+        @adapter.init_http_errors
+
+        HttpErrors.new(splits, segments, impressions, imp_count, events, telemetry, token)
+      end
+
+      def pop_http_latencies
+        splits = find_http_latencies(Domain::Constants::SPLIT_SYNC)
+        segments = find_http_latencies(Domain::Constants::SEGMENT_SYNC)
+        impressions = find_http_latencies(Domain::Constants::IMPRESSIONS_SYNC)
+        imp_count = find_http_latencies(Domain::Constants::IMPRESSION_COUNT_SYNC)
+        events = find_http_latencies(Domain::Constants::EVENT_SYNC)
+        telemetry = find_http_latencies(Domain::Constants::TELEMETRY_SYNC)
+        token = find_http_latencies(Domain::Constants::TOKEN_SYNC)
+
+        @adapter.init_http_latencies
+
+        HttpLatencies.new(splits, segments, impressions, imp_count, events, telemetry, token)
+      end
+
+      def pop_auth_rejections
+        to_return = @adapter.auth_rejections
+
+        @adapter.init_auth_rejections
+
+        to_return.value
+      end
+
+      def pop_token_refreshes
+        to_return = @adapter.token_refreshes
+
+        @adapter.init_token_refreshes
+
+        to_return.value
+      end
+
+      def pop_streaming_events
+        events = @adapter.streaming_events
+
+        @adapter.init_streaming_events.map
+
+        events
+      end
+
+      def session_length
+        @adapter.session_length.value
+      end
+
+      private
+
+      def find_last_synchronization(type)
+        @adapter.last_synchronization.find { |l| l[:type] == type }[:value].value
+      end
+
+      def find_http_errors(type)
+        @adapter.http_errors.find { |l| l[:type] == type }[:value]
+      end
+
+      def find_http_latencies(type)
+        @adapter.http_latencies.find { |l| l[:type] == type }[:value]
+      end
+    end
+  end
+end

data/lib/splitclient-rb/telemetry/memory/memory_runtime_producer.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    class MemoryRuntimeProducer < RuntimeProducer
+      def initialize(config)
+        @config = config
+        @adapter = config.telemetry_adapter
+      end
+
+      def add_tag(tag)
+        return if tag.length >= 9
+
+        @adapter.tags << tag
+      end
+
+      def record_impressions_stats(type, count)
+        @adapter.impressions_data_records.find { |l| l[:type] == type }[:value].value += count unless count.zero?
+      rescue StandardError => error
+        @config.log_found_exception(__method__.to_s, error)
+      end
+
+      def record_events_stats(type, count)
+        @adapter.events_data_records.find { |l| l[:type] == type }[:value].value += count unless count.zero?
+      rescue StandardError => error
+        @config.log_found_exception(__method__.to_s, error)
+      end
+
+      def record_successful_sync(type, value = nil)
+        value = (Time.now.to_f * 1000.0).to_i if value.nil?
+
+        @adapter.last_synchronization.find { |l| l[:type] == type }[:value] = Concurrent::AtomicFixnum.new(value)
+      rescue StandardError => error
+        @config.log_found_exception(__method__.to_s, error)
+      end
+
+      def record_sync_error(type, status)
+        http_errors = @adapter.http_errors.find { |l| l[:type] == type }[:value]
+
+        begin
+          http_errors[status] += 1
+        rescue StandardError => _
+          http_errors[status] = 1
+        end
+      rescue StandardError => error
+        @config.log_found_exception(__method__.to_s, error)
+      end
+
+      def record_sync_latency(type, bucket)
+        @adapter.http_latencies.find { |l| l[:type] == type }[:value][bucket] += 1
+      rescue StandardError => error
+        @config.log_found_exception(__method__.to_s, error)
+      end
+
+      def record_auth_rejections
+        @adapter.auth_rejections.increment
+      rescue StandardError => error
+        @config.log_found_exception(__method__.to_s, error)
+      end
+
+      def record_token_refreshes
+        @adapter.token_refreshes.increment
+      rescue StandardError => error
+        @config.log_found_exception(__method__.to_s, error)
+      end
+
+      def record_streaming_event(type, data = nil, timestamp = nil)
+        timestamp ||= (Time.now.to_f * 1000.0).to_i
+        @adapter.streaming_events << { e: type, d: data, t: timestamp } unless @adapter.streaming_events.length >= 19
+      rescue StandardError => error
+        @config.log_found_exception(__method__.to_s, error)
+      end
+
+      def record_session_length(session)
+        @adapter.session_length.value = session
+      rescue StandardError => error
+        @config.log_found_exception(__method__.to_s, error)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    class MemorySynchronizer < Synchronizer
+      def initialize(config,
+                     telemtry_consumers,
+                     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 = repositories[:splits]
+        @segments_repository = repositories[:segments]
+        @telemetry_api = telemetry_api
+      end
+
+      def synchronize_stats
+        usage = Usage.new(@telemetry_runtime_consumer.last_synchronizations,
+                          @telemtry_evaluation_consumer.pop_latencies,
+                          @telemtry_evaluation_consumer.pop_exceptions,
+                          @telemetry_runtime_consumer.pop_http_errors,
+                          @telemetry_runtime_consumer.pop_http_latencies,
+                          @telemetry_runtime_consumer.pop_token_refreshes,
+                          @telemetry_runtime_consumer.pop_auth_rejections,
+                          @telemetry_runtime_consumer.impressions_stats(Domain::Constants::IMPRESSIONS_QUEUED),
+                          @telemetry_runtime_consumer.impressions_stats(Domain::Constants::IMPRESSIONS_DEDUPE),
+                          @telemetry_runtime_consumer.impressions_stats(Domain::Constants::IMPRESSIONS_DROPPED),
+                          @splits_repository.splits_count,
+                          @segments_repository.segments_count,
+                          @segments_repository.segment_keys_count,
+                          @telemetry_runtime_consumer.session_length,
+                          @telemetry_runtime_consumer.events_stats(Domain::Constants::EVENTS_QUEUED),
+                          @telemetry_runtime_consumer.events_stats(Domain::Constants::EVENTS_DROPPED),
+                          @telemetry_runtime_consumer.pop_streaming_events,
+                          @telemetry_runtime_consumer.pop_tags)
+
+        @telemetry_api.record_stats(format_stats(usage))
+      rescue StandardError => error
+        @config.log_found_exception(__method__.to_s, error)
+      end
+
+      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(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,
+                                     impressions_mode,
+                                     !@config.impression_listener.nil?,
+                                     http_proxy_detected?,
+                                     time_until_ready || Time.now.to_i - @config.sdk_start_time.to_i,
+                                     @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,
+          mL: {
+            t: usage.ml[Telemetry::Domain::Constants::TREATMENT],
+            ts: usage.ml[Telemetry::Domain::Constants::TREATMENTS],
+            tc: usage.ml[Telemetry::Domain::Constants::TREATMENT_WITH_CONFIG],
+            tcs: usage.ml[Telemetry::Domain::Constants::TREATMENTS_WITH_CONFIG],
+            tr: usage.ml[Telemetry::Domain::Constants::TRACK]
+          },
+          mE: {
+            t: usage.me[Telemetry::Domain::Constants::TREATMENT],
+            ts: usage.me[Telemetry::Domain::Constants::TREATMENTS],
+            tc: usage.me[Telemetry::Domain::Constants::TREATMENT_WITH_CONFIG],
+            tcs: usage.me[Telemetry::Domain::Constants::TREATMENTS_WITH_CONFIG],
+            tr: usage.me[Telemetry::Domain::Constants::TRACK]
+          },
+          hE: {
+            sp: usage.he.sp,
+            se: usage.he.se,
+            im: usage.he.im,
+            ic: usage.he.ic,
+            ev: usage.he.ev,
+            te: usage.he.te,
+            to: usage.he.to
+          },
+          hL: {
+            sp: usage.hl.sp,
+            se: usage.hl.se,
+            im: usage.hl.im,
+            ic: usage.hl.ic,
+            ev: usage.hl.ev,
+            te: usage.hl.te,
+            to: usage.hl.to
+          },
+          tR: usage.tr,
+          aR: usage.ar,
+          iQ: usage.iq,
+          iDe: usage.ide,
+          iDr: usage.idr,
+          spC: usage.spc,
+          seC: usage.sec,
+          skC: usage.skc,
+          sL: usage.sl,
+          eQ: usage.eq,
+          eD: usage.ed,
+          sE: usage.se,
+          t: usage.t
+        }
+      end
+
+      def http_proxy_detected?
+        !ENV['HTTP_PROXY'].nil? || !ENV['HTTPS_PROXY'].nil?
+      end
+
+      def mode
+        case @config.mode
+        when :customer
+          1
+        else
+          0
+        end
+      end
+
+      def impressions_mode
+        case @config.impressions_mode
+        when :optimized
+          0
+        else
+          1
+        end
+      end
+    end
+  end
+end