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

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

@@ -4,6 +4,8 @@ module SplitIoClient
   module SSE
     module EventSource
       class EventParser
+        BAD_REQUEST_CODE = 400
+
         def initialize(config)
           @config = config
         end
@@ -27,10 +29,17 @@ module SplitIoClient
 
           events
         rescue StandardError => e
-          @config.logger.error("Error during parsing a event: #{e.inspect}")
+          @config.logger.debug("Error during parsing a event: #{e.inspect}")
           []
         end
 
+        def first_event(raw_data)
+          raw_data.split("\n")[0].split(' ')[1].to_i
+        rescue StandardError => e
+          @config.logger.debug("Error parsing first event: #{e.inspect}")
+          BAD_REQUEST_CODE
+        end
+
         private
 
         def parse_event_data(data, type)

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

@@ -1,14 +1,21 @@
 # frozen_string_literal: true
 
-require 'concurrent/atomics'
+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)
-        @on = { occupancy: ->(_) {}, push_shutdown: ->(_) {} }
+        @publishers_pri = Concurrent::AtomicFixnum.new
+        @publishers_sec = Concurrent::AtomicFixnum.new
+        @on = { action: ->(_) {} }
+        @telemetry_runtime_producer = telemetry_runtime_producer
 
         yield self if block_given?
       end
@@ -16,19 +23,16 @@ module SplitIoClient
       def handle_incoming_occupancy_event(event)
         if event.data['type'] == 'CONTROL'
           process_event_control(event.data['controlType'])
-        elsif event.channel == SplitIoClient::Constants::CONTROL_PRI
-          process_event_occupancy(event.data['metrics']['publishers'])
+        else
+          process_event_occupancy(event.channel, event.data['metrics']['publishers'])
         end
       rescue StandardError => e
+        p e
         @config.logger.error(e)
       end
 
-      def on_occupancy(&action)
-        @on[:occupancy] = action
-      end
-
-      def on_push_shutdown(&action)
-        @on[:push_shutdown] = action
+      def on_action(&action)
+        @on[:action] = action
       end
 
       private
@@ -36,35 +40,50 @@ module SplitIoClient
       def process_event_control(type)
         case type
         when 'STREAMING_PAUSED'
-          dispatch_occupancy_event(false)
+          @telemetry_runtime_producer.record_streaming_event(Telemetry::Domain::Constants::STREAMING_STATUS, PAUSED)
+          dispatch_action(Constants::PUSH_SUBSYSTEM_DOWN)
         when 'STREAMING_RESUMED'
-          dispatch_occupancy_event(true) if @publisher_available.value
+          @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'
-          dispatch_push_shutdown
+          @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}")
         end
       end
 
-      def process_event_occupancy(publishers)
-        @config.logger.debug("Occupancy process event with #{publishers} publishers") if @config.debug_enabled
-        if publishers <= 0 && @publisher_available.value
+      def process_event_occupancy(channel, publishers)
+        @config.logger.debug("Processed occupancy event with #{publishers} publishers. Channel: #{channel}")
+
+        update_publishers(channel, publishers)
+
+        if !are_publishers_available? && @publisher_available.value
           @publisher_available.make_false
-          dispatch_occupancy_event(false)
-        elsif publishers >= 1 && !@publisher_available.value
+          dispatch_action(Constants::PUSH_SUBSYSTEM_DOWN)
+        elsif are_publishers_available? && !@publisher_available.value
           @publisher_available.make_true
-          dispatch_occupancy_event(true)
+          dispatch_action(Constants::PUSH_SUBSYSTEM_READY)
+        end
+      end
+
+      def update_publishers(channel, publishers)
+        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 dispatch_occupancy_event(push_enable)
-        @config.logger.debug("Dispatching occupancy event with publisher avaliable: #{push_enable}")
-        @on[:occupancy].call(push_enable)
+      def are_publishers_available?
+        @publishers_pri.value.positive? || @publishers_sec.value.positive?
       end
 
-      def dispatch_push_shutdown
-        @config.logger.debug('Dispatching push shutdown')
-        @on[:push_shutdown].call
+      def dispatch_action(action)
+        @config.logger.debug("Dispatching action: #{action}")
+        @on[:action].call(action)
       end
     end
   end

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

@@ -5,19 +5,22 @@ 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_connected { process_connected }
-          client.on_disconnect { |reconnect| process_disconnect(reconnect) }
+          client.on_action { |action| process_action(action) }
         end
 
-        @on = { connected: ->(_) {}, disconnect: ->(_) {} }
+        @on = { action: ->(_) {} }
 
         yield self if block_given?
       end
@@ -48,22 +51,14 @@ module SplitIoClient
         @segments_worker.stop
       end
 
-      def on_connected(&action)
-        @on[:connected] = action
-      end
-
-      def on_disconnect(&action)
-        @on[:disconnect] = action
-      end
-
-      def process_disconnect(reconnect)
-        @on[:disconnect].call(reconnect)
+      def on_action(&action)
+        @on[:action] = action
       end
 
       private
 
-      def process_connected
-        @on[:connected].call
+      def process_action(action)
+        @on[:action].call(action)
       end
 
       def handle_incoming_message(notification)

data/lib/splitclient-rb/sse/workers/segments_worker.rb

@@ -48,12 +48,13 @@ module SplitIoClient
         def perform
           while (item = @queue.pop)
             segment_name = item[:segment_name]
-            change_number = item[:change_number]
-            since = @segments_repository.get_change_number(segment_name)
+            cn = item[:change_number]
+            @config.logger.debug("SegmentsWorker change_number dequeue #{segment_name}, #{cn}")
 
-            unless since >= change_number
-              @config.logger.debug("SegmentsWorker fetch_segment with #{since}")
+            attempt = 0
+            while cn > @segments_repository.get_change_number(segment_name).to_i && attempt <= Workers::MAX_RETRIES_ALLOWED
               @synchronizer.fetch_segment(segment_name)
+              attempt += 1
             end
           end
         end

data/lib/splitclient-rb/sse/workers/splits_worker.rb

@@ -3,6 +3,8 @@
 module SplitIoClient
   module SSE
     module Workers
+      MAX_RETRIES_ALLOWED = 10
+
       class SplitsWorker
         def initialize(synchronizer, config, splits_repository)
           @synchronizer = synchronizer
@@ -59,11 +61,12 @@ module SplitIoClient
 
         def perform
           while (change_number = @queue.pop)
-            since = @splits_repository.get_change_number
+            @config.logger.debug("SplitsWorker change_number dequeue #{change_number}")
 
-            unless since.to_i >= change_number
-              @config.logger.debug("SplitsWorker fetch_splits with #{since}")
+            attempt = 0
+            while change_number > @splits_repository.get_change_number.to_i && attempt <= Workers::MAX_RETRIES_ALLOWED
               @synchronizer.fetch_splits
+              attempt += 1
             end
           end
         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

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    class EvaluationConsumer
+      extend Forwardable
+      def_delegators :@evaluation, :pop_latencies, :pop_exceptions
+
+      def initialize(config)
+        @evaluation = SplitIoClient::Telemetry::MemoryEvaluationConsumer.new(config)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    class EvaluationProducer
+      extend Forwardable
+      def_delegators :@evaluation,
+                     :record_latency,
+                     :record_exception
+
+      def initialize(config)
+        @evaluation = case config.telemetry_adapter.class.to_s
+                      when 'SplitIoClient::Cache::Adapters::RedisAdapter'
+                        SplitIoClient::Telemetry::RedisEvaluationProducer.new(config)
+                      else
+                        SplitIoClient::Telemetry::MemoryEvaluationProducer.new(config)
+                      end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    class InitConsumer
+      extend Forwardable
+      def_delegators :@init, :non_ready_usages, :bur_timeouts
+
+      def initialize(config)
+        @init = SplitIoClient::Telemetry::MemoryInitConsumer.new(config)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    class InitProducer
+      extend Forwardable
+      def_delegators :@init, :record_config, :record_non_ready_usages, :record_bur_timeout
+
+      def initialize(config)
+        @init = case config.telemetry_adapter.class.to_s
+                when 'SplitIoClient::Cache::Adapters::RedisAdapter'
+                  SplitIoClient::Telemetry::RedisInitProducer.new(config)
+                else
+                  SplitIoClient::Telemetry::MemoryInitProducer.new(config)
+                end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Telemetry
+    class MemoryEvaluationConsumer < EvaluationConsumer
+      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 < EvaluationProducer
+      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 => error
+        @config.log_found_exception(__method__.to_s, error)
+      end
+
+      def record_exception(method)
+        @adapter.exceptions.find { |l| l[:method] == method }[:exceptions].increment
+      rescue StandardError => error
+        @config.log_found_exception(__method__.to_s, error)
+      end
+    end
+  end
+end