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

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

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    class RedisEvaluationProducer < EvaluationProducer
+      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 => error
+        @config.log_found_exception(__method__.to_s, error)
+      end
+
+      def record_exception(method)
+        @adapter.hincrby(exception_key, "#{@sdk_version}/#{@name}/#{@ip}/#{method}", 1)
+      rescue StandardError => error
+        @config.log_found_exception(__method__.to_s, error)
+      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 < InitProducer
+      def initialize(config)
+        @config = config
+        @adapter = config.telemetry_adapter
+      end
+
+      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 } }
+
+        @adapter.add_to_queue(config_key, data.to_json)
+      rescue StandardError => error
+        @config.log_found_exception(__method__.to_s, error)
+      end
+
+      def record_bur_timeout
+        # no-op
+      end
+
+      def record_non_ready_usages
+        # no-op
+      end
+
+      private
+
+      def config_key
+        "#{@config.redis_namespace}.telemetry.config"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    class RedisSynchronizer < Synchronizer
+      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 => error
+        @config.log_found_exception(__method__.to_s, error)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# 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
+
+      def initialize(config)
+        @runtime = SplitIoClient::Telemetry::MemoryRuntimeConsumer.new(config)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# 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
+
+      def initialize(config)
+        @runtime = SplitIoClient::Telemetry::MemoryRuntimeProducer.new(config)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    module Storages
+      class Memory
+        attr_reader :latencies,
+                    :exceptions,
+                    :factory_counters,
+                    :tags,
+                    :impressions_data_records,
+                    :events_data_records,
+                    :last_synchronization,
+                    :http_errors,
+                    :http_latencies,
+                    :auth_rejections,
+                    :token_refreshes,
+                    :streaming_events,
+                    :session_length
+
+        def initialize
+          init_latencies
+          init_exceptions
+          init_factory_counters
+          init_impressions_data_records
+          init_events_data_records
+          init_last_synchronization
+          init_http_errors
+          init_http_latencies
+          init_auth_rejections
+          init_token_refreshes
+          init_streaming_events
+          init_session_length
+          init_tags
+        end
+
+        def init_latencies
+          @latencies = Concurrent::Array.new
+
+          array_size = BinarySearchLatencyTracker::BUCKETS.length
+          @latencies << { method: Domain::Constants::TREATMENT, latencies: Concurrent::Array.new(array_size, 0) }
+          @latencies << { method: Domain::Constants::TREATMENTS, latencies: Concurrent::Array.new(array_size, 0) }
+          @latencies << { method: Domain::Constants::TREATMENT_WITH_CONFIG, latencies: Concurrent::Array.new(array_size, 0) }
+          @latencies << { method: Domain::Constants::TREATMENTS_WITH_CONFIG, latencies: Concurrent::Array.new(array_size, 0) }
+          @latencies << { method: Domain::Constants::TRACK, latencies: Concurrent::Array.new(array_size, 0) }
+        end
+
+        def init_exceptions
+          @exceptions = Concurrent::Array.new
+
+          @exceptions << { method: Domain::Constants::TREATMENT, exceptions: Concurrent::AtomicFixnum.new(0) }
+          @exceptions << { method: Domain::Constants::TREATMENTS, exceptions: Concurrent::AtomicFixnum.new(0) }
+          @exceptions << { method: Domain::Constants::TREATMENT_WITH_CONFIG, exceptions: Concurrent::AtomicFixnum.new(0) }
+          @exceptions << { method: Domain::Constants::TREATMENTS_WITH_CONFIG, exceptions: Concurrent::AtomicFixnum.new(0) }
+          @exceptions << { method: Domain::Constants::TRACK, exceptions: Concurrent::AtomicFixnum.new(0) }
+        end
+
+        def init_factory_counters
+          @factory_counters = Concurrent::Array.new
+
+          @factory_counters << { action: Domain::Constants::BUR_TIMEOUT, counts: Concurrent::AtomicFixnum.new(0) }
+          @factory_counters << { action: Domain::Constants::NON_READY_USAGES, counts: Concurrent::AtomicFixnum.new(0) }
+        end
+
+        def init_impressions_data_records
+          @impressions_data_records = Concurrent::Array.new
+
+          @impressions_data_records << { type: Domain::Constants::IMPRESSIONS_DEDUPE, value: Concurrent::AtomicFixnum.new(0) }
+          @impressions_data_records << { type: Domain::Constants::IMPRESSIONS_DROPPED, value: Concurrent::AtomicFixnum.new(0) }
+          @impressions_data_records << { type: Domain::Constants::IMPRESSIONS_QUEUED, value: Concurrent::AtomicFixnum.new(0) }
+        end
+
+        def init_events_data_records
+          @events_data_records = Concurrent::Array.new
+
+          @events_data_records << { type: Domain::Constants::EVENTS_DROPPED, value: Concurrent::AtomicFixnum.new(0) }
+          @events_data_records << { type: Domain::Constants::EVENTS_QUEUED, value: Concurrent::AtomicFixnum.new(0) }
+        end
+
+        def init_last_synchronization
+          @last_synchronization = Concurrent::Array.new
+
+          @last_synchronization << { type: Domain::Constants::SPLIT_SYNC, value: Concurrent::AtomicFixnum.new(0) }
+          @last_synchronization << { type: Domain::Constants::SEGMENT_SYNC, value: Concurrent::AtomicFixnum.new(0) }
+          @last_synchronization << { type: Domain::Constants::EVENT_SYNC, value: Concurrent::AtomicFixnum.new(0) }
+          @last_synchronization << { type: Domain::Constants::IMPRESSION_COUNT_SYNC, value: Concurrent::AtomicFixnum.new(0) }
+          @last_synchronization << { type: Domain::Constants::IMPRESSIONS_SYNC, value: Concurrent::AtomicFixnum.new(0) }
+          @last_synchronization << { type: Domain::Constants::TELEMETRY_SYNC, value: Concurrent::AtomicFixnum.new(0) }
+          @last_synchronization << { type: Domain::Constants::TOKEN_SYNC, value: Concurrent::AtomicFixnum.new(0) }
+        end
+
+        def init_tags
+          @tags = Concurrent::Array.new
+        end
+
+        def init_http_errors
+          @http_errors = Concurrent::Array.new
+
+          @http_errors << { type: Domain::Constants::SPLIT_SYNC, value: Concurrent::Hash.new }
+          @http_errors << { type: Domain::Constants::SEGMENT_SYNC, value: Concurrent::Hash.new }
+          @http_errors << { type: Domain::Constants::EVENT_SYNC, value: Concurrent::Hash.new }
+          @http_errors << { type: Domain::Constants::IMPRESSION_COUNT_SYNC, value: Concurrent::Hash.new }
+          @http_errors << { type: Domain::Constants::IMPRESSIONS_SYNC, value: Concurrent::Hash.new }
+          @http_errors << { type: Domain::Constants::TELEMETRY_SYNC, value: Concurrent::Hash.new }
+          @http_errors << { type: Domain::Constants::TOKEN_SYNC, value: Concurrent::Hash.new }
+        end
+
+        def init_http_latencies
+          @http_latencies = Concurrent::Array.new
+
+          array_size = BinarySearchLatencyTracker::BUCKETS.length
+          @http_latencies << { type: Domain::Constants::SPLIT_SYNC, value: Concurrent::Array.new(array_size, 0) }
+          @http_latencies << { type: Domain::Constants::SEGMENT_SYNC, value: Concurrent::Array.new(array_size, 0) }
+          @http_latencies << { type: Domain::Constants::EVENT_SYNC, value: Concurrent::Array.new(array_size, 0) }
+          @http_latencies << { type: Domain::Constants::IMPRESSION_COUNT_SYNC, value: Concurrent::Array.new(array_size, 0) }
+          @http_latencies << { type: Domain::Constants::IMPRESSIONS_SYNC, value: Concurrent::Array.new(array_size, 0) }
+          @http_latencies << { type: Domain::Constants::TELEMETRY_SYNC, value: Concurrent::Array.new(array_size, 0) }
+          @http_latencies << { type: Domain::Constants::TOKEN_SYNC, value: Concurrent::Array.new(array_size, 0) }
+        end
+
+        def init_auth_rejections
+          @auth_rejections = Concurrent::AtomicFixnum.new(0)
+        end
+
+        def init_token_refreshes
+          @token_refreshes = Concurrent::AtomicFixnum.new(0)
+        end
+
+        def init_streaming_events
+          @streaming_events = Concurrent::Array.new
+        end
+
+        def init_session_length
+          @session_length = Concurrent::AtomicFixnum.new(0)
+        end
+      end
+    end
+  end
+end