splitclient-rb 1.0.2.wip → 8.11.1.pre.rc1-java

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    class MemoryEvaluationConsumer
+      def initialize(config)
+        @config = config
+        @adapter = config.telemetry_adapter
+      end
+
+      def pop_latencies
+        to_return = @adapter.latencies.each_with_object({}) do |latency, memo|
+          memo[latency[:method]] = latency[:latencies]
+        end
+
+        @adapter.init_latencies
+
+        to_return
+      end
+
+      def pop_exceptions
+        to_return = @adapter.exceptions.each_with_object({}) do |exception, memo|
+          memo[exception[:method]] = exception[:exceptions].value
+        end
+
+        @adapter.init_exceptions
+
+        to_return
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    class MemoryEvaluationProducer
+      def initialize(config)
+        @config = config
+        @adapter = config.telemetry_adapter
+      end
+
+      def record_latency(method, bucket)
+        @adapter.latencies.find { |l| l[:method] == method }[:latencies][bucket] += 1
+      rescue StandardError => e
+        @config.log_found_exception(__method__.to_s, e)
+      end
+
+      def record_exception(method)
+        @adapter.exceptions.find { |l| l[:method] == method }[:exceptions].increment
+      rescue StandardError => e
+        @config.log_found_exception(__method__.to_s, e)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    class MemoryInitConsumer
+      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
+      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 => e
+        @config.log_found_exception(__method__.to_s, e)
+      end
+
+      def record_non_ready_usages
+        find_factory_counters(Domain::Constants::NON_READY_USAGES)[:counts].increment
+      rescue StandardError => e
+        @config.log_found_exception(__method__.to_s, e)
+      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,119 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    class MemoryRuntimeConsumer
+      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
+
+      def pop_updates_from_sse
+        splits = @adapter.updates_from_sse[Domain::Constants::SPLITS]
+        @adapter.updates_from_sse[Domain::Constants::SPLITS] = 0
+
+        UpdatesFromSSE.new(splits)
+      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,87 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    class MemoryRuntimeProducer
+      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 => e
+        @config.log_found_exception(__method__.to_s, e)
+      end
+
+      def record_events_stats(type, count)
+        @adapter.events_data_records.find { |l| l[:type] == type }[:value].value += count unless count.zero?
+      rescue StandardError => e
+        @config.log_found_exception(__method__.to_s, e)
+      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 => e
+        @config.log_found_exception(__method__.to_s, e)
+      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 => _e
+          http_errors[status] = 1
+        end
+      rescue StandardError => e
+        @config.log_found_exception(__method__.to_s, e)
+      end
+
+      def record_sync_latency(type, bucket)
+        @adapter.http_latencies.find { |l| l[:type] == type }[:value][bucket] += 1
+      rescue StandardError => e
+        @config.log_found_exception(__method__.to_s, e)
+      end
+
+      def record_auth_rejections
+        @adapter.auth_rejections.increment
+      rescue StandardError => e
+        @config.log_found_exception(__method__.to_s, e)
+      end
+
+      def record_token_refreshes
+        @adapter.token_refreshes.increment
+      rescue StandardError => e
+        @config.log_found_exception(__method__.to_s, e)
+      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 => e
+        @config.log_found_exception(__method__.to_s, e)
+      end
+
+      def record_session_length(session)
+        @adapter.session_length.value = session
+      rescue StandardError => e
+        @config.log_found_exception(__method__.to_s, e)
+      end
+
+      def record_updates_from_sse(event)
+        @adapter.updates_from_sse[event] += 1
+      rescue StandardError => e
+        @config.log_found_exception(__method__.to_s, e)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    class MemorySynchronizer
+      def initialize(config,
+                     telemtry_consumers,
+                     repositories,
+                     telemetry_api,
+                     flag_sets,
+                     flag_sets_invalid)
+        @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
+        @flag_sets = flag_sets
+        @flag_sets_invalid = flag_sets_invalid
+      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_runtime_consumer.pop_updates_from_sse)
+
+        @telemetry_api.record_stats(format_stats(usage))
+      rescue StandardError => e
+        @config.log_found_exception(__method__.to_s, e)
+      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
+        time_until_ready ||= ((Time.now.to_f - @config.sdk_start_time) * 1000.0).to_i
+
+        init_config = ConfigInit.new(mode,
+                                     'memory',
+                                     active_factories,
+                                     redundant_active_factories,
+                                     @telemetry_runtime_consumer.pop_tags,
+                                     @flag_sets,
+                                     @flag_sets_invalid,
+                                     @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,
+                                     @telemetry_init_consumer.bur_timeouts,
+                                     @telemetry_init_consumer.non_ready_usages)
+
+        @telemetry_api.record_init(fornat_init_config(init_config))
+      rescue StandardError => e
+        @config.log_found_exception(__method__.to_s, e)
+      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,
+          fsT: init.fsT,
+          fsI: init.fsI
+        }
+      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],
+            tf: usage.ml[Telemetry::Domain::Constants::TREATMENTS_BY_FLAG_SET],
+            tfs: usage.ml[Telemetry::Domain::Constants::TREATMENTS_BY_FLAG_SETS],
+            tcf: usage.ml[Telemetry::Domain::Constants::TREATMENTS_WITH_CONFIG_BY_FLAG_SET],
+            tcfs: usage.ml[Telemetry::Domain::Constants::TREATMENTS_WITH_CONFIG_BY_FLAG_SETS],
+            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],
+            tf: usage.me[Telemetry::Domain::Constants::TREATMENTS_BY_FLAG_SET],
+            tfs: usage.me[Telemetry::Domain::Constants::TREATMENTS_BY_FLAG_SETS],
+            tcf: usage.me[Telemetry::Domain::Constants::TREATMENTS_WITH_CONFIG_BY_FLAG_SET],
+            tcfs: usage.me[Telemetry::Domain::Constants::TREATMENTS_WITH_CONFIG_BY_FLAG_SETS],
+            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,
+          ufs: usage.ufs.to_h
+        }
+      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
+        when :debug
+          1
+        else
+          2
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/telemetry/redis/redis_evaluation_producer.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    class RedisEvaluationProducer
+      def initialize(config)
+        @config = config
+        @adapter = config.telemetry_adapter
+
+        @sdk_version = "#{@config.language}-#{@config.version}"
+        @name = @config.machine_name
+        @ip = @config.machine_ip
+      end
+
+      def record_latency(method, bucket)
+        @adapter.hincrby(latency_key, "#{@sdk_version}/#{@name}/#{@ip}/#{method}/#{bucket}", 1)
+      rescue StandardError => e
+        @config.log_found_exception(__method__.to_s, e)
+      end
+
+      def record_exception(method)
+        @adapter.hincrby(exception_key, "#{@sdk_version}/#{@name}/#{@ip}/#{method}", 1)
+      rescue StandardError => e
+        @config.log_found_exception(__method__.to_s, e)
+      end
+
+      private
+
+      def latency_key
+        "#{@config.redis_namespace}.telemetry.latencies"
+      end
+
+      def exception_key
+        "#{@config.redis_namespace}.telemetry.exceptions"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    class RedisInitProducer
+      def initialize(config)
+        @config = config
+        @adapter = config.telemetry_adapter
+      end
+
+      def record_config(config_data)
+        return if config_data.nil?
+
+        data = { t: { oM: config_data.om, st: config_data.st, aF: config_data.af, rF: config_data.rf, t: config_data.t } }
+        field = "#{@config.language}-#{@config.version}/#{@config.machine_name}/#{@config.machine_ip}"
+
+        @adapter.add_to_map(config_key, field, data.to_json)
+      rescue StandardError => e
+        @config.log_found_exception(__method__.to_s, e)
+      end
+
+      def record_bur_timeout
+        # no-op
+      end
+
+      def record_non_ready_usages
+        # no-op
+      end
+
+      private
+
+      def config_key
+        "#{@config.redis_namespace}.telemetry.init"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    class RedisSynchronizer
+      def initialize(config,
+                     telemetry_init_producer)
+        @config = config
+        @telemetry_init_producer = telemetry_init_producer
+      end
+
+      def synchronize_stats
+        # No-op
+      end
+
+      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 => e
+        @config.log_found_exception(__method__.to_s, e)
+      end
+    end
+  end
+end

data/lib/splitclient-rb/telemetry/runtime_consumer.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    class RuntimeConsumer
+      extend Forwardable
+      def_delegators :@runtime,
+                     :pop_tags,
+                     :impressions_stats,
+                     :events_stats,
+                     :last_synchronizations,
+                     :pop_http_errors,
+                     :pop_http_latencies,
+                     :pop_auth_rejections,
+                     :pop_token_refreshes,
+                     :pop_streaming_events,
+                     :session_length,
+                     :pop_updates_from_sse
+
+      def initialize(config)
+        @runtime = SplitIoClient::Telemetry::MemoryRuntimeConsumer.new(config)
+      end
+    end
+  end
+end

data/lib/splitclient-rb/telemetry/runtime_producer.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    class RuntimeProducer
+      extend Forwardable
+      def_delegators :@runtime,
+                     :add_tag,
+                     :record_impressions_stats,
+                     :record_events_stats,
+                     :record_successful_sync,
+                     :record_sync_error,
+                     :record_sync_latency,
+                     :record_auth_rejections,
+                     :record_token_refreshes,
+                     :record_streaming_event,
+                     :record_session_length,
+                     :record_updates_from_sse
+
+      def initialize(config)
+        @runtime = SplitIoClient::Telemetry::MemoryRuntimeProducer.new(config)
+      end
+    end
+  end
+end