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

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: false
+
+module SplitIoClient
+  module SSE
+    module EventSource
+      class EventParser
+        BAD_REQUEST_CODE = 400
+
+        def initialize(config)
+          @config = config
+        end
+
+        def parse(raw_event)
+          type = nil
+          events = []
+          buffer = read_partial_data(raw_event)
+
+          buffer.each do |d|
+            splited_data = d.split(':')
+
+            case splited_data[0]
+            when 'event'
+              type = splited_data[1].strip
+            when 'data'
+              data = parse_event_data(d, type)
+              events << StreamData.new(type, data[:client_id], data[:data], data[:channel]) unless type.nil? || data[:data].nil?
+            end
+          end
+
+          events
+        rescue StandardError => e
+          @config.logger.debug("Error during parsing a event: #{e.inspect}") if @config.debug_enabled
+          []
+        end
+
+        def first_event(raw_data)
+          raw_data.split("\n")[0].split(' ')[1].to_i
+        rescue StandardError => e
+          @config.logger.error("Error parsing first event: #{e.inspect}")
+          BAD_REQUEST_CODE
+        end
+
+        private
+
+        def parse_event_data(data, type)
+          data_value = data.sub('data:', '')
+          event_data = JSON.parse(data_value.strip)
+          client_id = event_data['clientId']&.strip
+          channel = event_data['channel']&.strip
+          parsed_data = JSON.parse(event_data['data']) unless type == 'error'
+          parsed_data = event_data if type == 'error'
+
+          { client_id: client_id, channel: channel, data: parsed_data }
+        end
+
+        def read_partial_data(data)
+          buffer = ''
+          buffer << data
+          buffer.chomp!
+          buffer.split("\n")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module SSE
+    module EventSource
+      class EventTypes
+        SPLIT_UPDATE = 'SPLIT_UPDATE'
+        SPLIT_KILL = 'SPLIT_KILL'
+        SEGMENT_UPDATE = 'SEGMENT_UPDATE'
+        CONTROL = 'CONTROL'
+        RB_SEGMENT_UPDATE = 'RB_SEGMENT_UPDATE'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: false
+
+module SplitIoClient
+  module SSE
+    module EventSource
+      class StreamData
+        attr_reader :event_type, :channel, :data, :client_id
+
+        def initialize(event_type, client_id, data, channel)
+          @event_type = event_type
+          @client_id = client_id
+          @data = data
+          @channel = channel&.gsub(SplitIoClient::Constants::OCCUPANCY_CHANNEL_PREFIX, '')
+        end
+
+        def occupancy?
+          @channel.include? 'control'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'concurrent'
+
+module SplitIoClient
+  module SSE
+    class NotificationManagerKeeper
+      DISABLED = 0
+      ENABLED = 1
+      PAUSED = 2
+
+      def initialize(config, telemetry_runtime_producer, status_queue)
+        @config = config
+        @telemetry_runtime_producer = telemetry_runtime_producer
+        @status_queue = status_queue
+        @publisher_available = Concurrent::AtomicBoolean.new(true)
+        @publishers_pri = Concurrent::AtomicFixnum.new(2)
+        @publishers_sec = Concurrent::AtomicFixnum.new(2)
+      end
+
+      def handle_incoming_occupancy_event(event)
+        if event.data['type'] == 'CONTROL'
+          process_event_control(event.data['controlType'])
+        else
+          process_event_occupancy(event.channel, event.data['metrics']['publishers'])
+        end
+      rescue StandardError => e
+        @config.logger.error(e)
+      end
+
+      private
+
+      def process_event_control(type)
+        case type
+        when 'STREAMING_PAUSED'
+          @telemetry_runtime_producer.record_streaming_event(Telemetry::Domain::Constants::STREAMING_STATUS, PAUSED)
+          push_status(Constants::PUSH_SUBSYSTEM_DOWN)
+        when 'STREAMING_RESUMED'
+          @telemetry_runtime_producer.record_streaming_event(Telemetry::Domain::Constants::STREAMING_STATUS, ENABLED)
+          push_status(Constants::PUSH_SUBSYSTEM_READY) if @publisher_available.value
+        when 'STREAMING_DISABLED'
+          @telemetry_runtime_producer.record_streaming_event(Telemetry::Domain::Constants::STREAMING_STATUS, DISABLED)
+          push_status(Constants::PUSH_SUBSYSTEM_OFF)
+        else
+          @config.logger.error("Incorrect event type: #{incoming_notification}") if @config.debug_enabled
+        end
+      end
+
+      def process_event_occupancy(channel, publishers)
+        @config.logger.debug("Processed occupancy event with #{publishers} publishers. Channel: #{channel}") if @config.debug_enabled
+
+        update_publishers(channel, publishers)
+
+        if !are_publishers_available? && @publisher_available.value
+          @publisher_available.make_false
+          push_status(Constants::PUSH_SUBSYSTEM_DOWN)
+        elsif are_publishers_available? && !@publisher_available.value
+          @publisher_available.make_true
+          push_status(Constants::PUSH_SUBSYSTEM_READY)
+        end
+      end
+
+      def update_publishers(channel, publishers)
+        case channel
+        when Constants::CONTROL_PRI
+          @telemetry_runtime_producer.record_streaming_event(Telemetry::Domain::Constants::OCCUPANCY_PRI, publishers)
+          @publishers_pri.value = publishers
+        when Constants::CONTROL_SEC
+          @telemetry_runtime_producer.record_streaming_event(Telemetry::Domain::Constants::OCCUPANCY_SEC, publishers)
+          @publishers_sec.value = publishers
+        end
+      end
+
+      def are_publishers_available?
+        @publishers_pri.value.positive? || @publishers_sec.value.positive?
+      end
+
+      def push_status(status)
+        @config.logger.debug("Pushing occupancy status: #{status}") if @config.debug_enabled
+        @status_queue.push(status)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module SSE
+    class NotificationProcessor
+      def initialize(config, splits_worker, segments_worker)
+        @config = config
+        @splits_worker = splits_worker
+        @segments_worker = segments_worker
+      end
+
+      def process(incoming_notification)
+        case incoming_notification.data['type']
+        when SSE::EventSource::EventTypes::SPLIT_UPDATE
+          process_split_update(incoming_notification)
+        when SSE::EventSource::EventTypes::RB_SEGMENT_UPDATE
+          process_split_update(incoming_notification)
+        when SSE::EventSource::EventTypes::SPLIT_KILL
+          process_split_kill(incoming_notification)
+        when SSE::EventSource::EventTypes::SEGMENT_UPDATE
+          process_segment_update(incoming_notification)
+        else
+          @config.logger.error("Incorrect event type: #{incoming_notification}")
+        end
+      end
+
+      private
+
+      def process_split_update(notification)
+        @config.logger.debug("#{notification.event_type} notification received: #{notification}") if @config.debug_enabled
+        @splits_worker.add_to_queue(notification)
+      end
+
+      def process_split_kill(notification)
+        @config.logger.debug("SPLIT KILL notification received: #{notification}") if @config.debug_enabled
+        @splits_worker.add_to_queue(notification)
+      end
+
+      def process_segment_update(notification)
+        @config.logger.debug("SEGMENT UPDATE notification received: #{notification}") if @config.debug_enabled
+        change_number = notification.data['changeNumber']
+        segment_name = notification.data['segmentName']
+
+        @segments_worker.add_to_queue(change_number, segment_name)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module SSE
+    class SSEHandler
+      attr_reader :sse_client
+
+      def initialize(config,
+                     splits_worker,
+                     segments_worker,
+                     sse_client)
+        @config = config
+        @splits_worker = splits_worker
+        @segments_worker = segments_worker
+        @sse_client = sse_client
+      end
+
+      def start(token_jwt, channels)
+        @sse_client.start("#{@config.streaming_service_url}?channels=#{channels}&v=1.1&accessToken=#{token_jwt}")
+      end
+
+      def stop
+        @sse_client.close(Constants::PUSH_FORCED_STOP)
+        stop_workers
+      rescue StandardError => e
+        @config.logger.debug("SSEHandler stop error: #{e.inspect}") if @config.debug_enabled
+      end
+
+      def connected?
+        @sse_client&.connected? || false
+      end
+
+      def start_workers
+        @splits_worker.start
+        @segments_worker.start
+      end
+
+      def stop_workers
+        @splits_worker.stop
+        @segments_worker.stop
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module SSE
+    module Workers
+      class SegmentsWorker
+        def initialize(synchronizer, config, segments_repository)
+          @synchronizer = synchronizer
+          @config = config
+          @segments_repository = segments_repository
+          @queue = Queue.new
+          @running = Concurrent::AtomicBoolean.new(false)
+        end
+
+        def add_to_queue(change_number, segment_name)
+          item = { change_number: change_number, segment_name: segment_name }
+          @config.logger.debug("SegmentsWorker add to queue #{item}") if @config.debug_enabled
+          @queue.push(item)
+        end
+
+        def start
+          if @running.value
+            @config.logger.debug('segments worker already running.') if @config.debug_enabled
+            return
+          end
+
+          @running.make_true
+          perform_thread
+        end
+
+        def stop
+          unless @running.value
+            @config.logger.debug('segments worker not running.') if @config.debug_enabled
+            return
+          end
+
+          @running.make_false
+          SplitIoClient::Helpers::ThreadHelper.stop(:segment_update_worker, @config)
+        end
+
+        private
+
+        def perform
+          while (item = @queue.pop)
+            segment_name = item[:segment_name]
+            cn = item[:change_number]
+            @config.logger.debug("SegmentsWorker change_number dequeue #{segment_name}, #{cn}") if @config.debug_enabled
+
+            @synchronizer.fetch_segment(segment_name, cn)
+          end
+        end
+
+        def perform_thread
+          @config.threads[:segment_update_worker] = Thread.new do
+            @config.logger.debug('Starting segments worker ...') if @config.debug_enabled
+            perform
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module SSE
+    module Workers
+      class SplitsWorker
+        def initialize(synchronizer, config, feature_flags_repository, telemetry_runtime_producer,
+                       segment_fetcher, rule_based_segment_repository)
+          @synchronizer = synchronizer
+          @config = config
+          @feature_flags_repository = feature_flags_repository
+          @queue = Queue.new
+          @running = Concurrent::AtomicBoolean.new(false)
+          @telemetry_runtime_producer = telemetry_runtime_producer
+          @segment_fetcher = segment_fetcher
+          @rule_based_segment_repository = rule_based_segment_repository
+        end
+
+        def start
+          if @running.value
+            @config.logger.debug('feature_flags_worker already running.') if @config.debug_enabled
+            return
+          end
+
+          @running.make_true
+          perform_thread
+        end
+
+        def stop
+          unless @running.value
+            @config.logger.debug('feature_flags_worker not running.') if @config.debug_enabled
+            return
+          end
+
+          @running.make_false
+          Helpers::ThreadHelper.stop(:split_update_worker, @config)
+        end
+
+        def add_to_queue(notification)
+          @config.logger.debug("feature_flags_worker add to queue #{notification.data['changeNumber']}") if @config.debug_enabled
+          @queue.push(notification)
+        end
+
+        private
+
+        def perform_thread
+          @config.threads[:split_update_worker] = Thread.new do
+            @config.logger.debug('starting feature_flags_worker ...') if @config.debug_enabled
+            perform
+          end
+        end
+
+        def perform
+          while (notification = @queue.pop)
+            if @config.debug_enabled
+              @config.logger.debug("feature_flags_worker change_number dequeue #{notification.data['changeNumber']}")
+            end
+            case notification.data['type']
+            when SSE::EventSource::EventTypes::SPLIT_UPDATE
+              success = update_feature_flag(notification)
+              @synchronizer.fetch_splits(notification.data['changeNumber'], 0) unless success
+            when SSE::EventSource::EventTypes::RB_SEGMENT_UPDATE
+              success = update_rule_based_segment(notification)
+              @synchronizer.fetch_splits(0, notification.data['changeNumber']) unless success
+            when SSE::EventSource::EventTypes::SPLIT_KILL
+              kill_feature_flag(notification)
+            end
+          end
+        end
+
+        def update_feature_flag(notification)
+          return true if @feature_flags_repository.get_change_number.to_i >= notification.data['changeNumber']
+          return false unless !notification.data['d'].nil? && @feature_flags_repository.get_change_number == notification.data['pcn']
+
+          new_split = update_feature_flag_repository(notification)
+          fetch_segments_if_not_exists(Helpers::Util.segment_names_by_object(new_split, 'IN_SEGMENT'), @feature_flags_repository)
+          if fetch_rule_based_segments_if_not_exists(Helpers::Util.segment_names_by_object(new_split, 'IN_RULE_BASED_SEGMENT'),
+                                                     notification.data['changeNumber'])
+            return true
+          end
+
+          @telemetry_runtime_producer.record_updates_from_sse(Telemetry::Domain::Constants::SPLITS)
+
+          true
+        rescue StandardError => e
+          @config.logger.debug("Failed to update Split: #{e.inspect}") if @config.debug_enabled
+
+          false
+        end
+
+        def update_feature_flag_repository(notification)
+          new_split = return_object_from_json(notification)
+          SplitIoClient::Helpers::RepositoryHelper.update_feature_flag_repository(@feature_flags_repository, [new_split],
+                                                                                  notification.data['changeNumber'], @config, false)
+          new_split
+        end
+
+        def update_rule_based_segment(notification)
+          return true if @rule_based_segment_repository.get_change_number.to_i >= notification.data['changeNumber']
+          return false unless !notification.data['d'].nil? &&
+                              @rule_based_segment_repository.get_change_number == notification.data['pcn']
+
+          new_rb_segment = return_object_from_json(notification)
+          SplitIoClient::Helpers::RepositoryHelper.update_rule_based_segment_repository(@rule_based_segment_repository,
+                                                                                        [new_rb_segment],
+                                                                                        notification.data['changeNumber'], @config)
+          fetch_segments_if_not_exists(Helpers::Util.segment_names_in_rb_segment(new_rb_segment, 'IN_SEGMENT'),
+                                       @rule_based_segment_repository)
+
+          # @telemetry_runtime_producer.record_updates_from_sse(Telemetry::Domain::Constants::SPLITS)
+
+          true
+        rescue StandardError => e
+          @config.logger.debug("Failed to update Split: #{e.inspect}") if @config.debug_enabled
+
+          false
+        end
+
+        def kill_feature_flag(notification)
+          return if @feature_flags_repository.get_change_number.to_i > notification.data['changeNumber']
+
+          if @config.debug_enabled
+            @config.logger.debug("feature_flags_worker kill #{notification.data['splitName']}, #{notification.data['changeNumber']}")
+          end
+          @feature_flags_repository.kill(notification.data['changeNumber'],
+                                         notification.data['splitName'],
+                                         notification.data['defaultTreatment'])
+          @synchronizer.fetch_splits(notification.data['changeNumber'], 0)
+        end
+
+        def return_object_from_json(notification)
+          object_json = Helpers::DecryptionHelper.get_encoded_definition(notification.data['c'], notification.data['d'])
+          JSON.parse(object_json, symbolize_names: true)
+        end
+
+        def fetch_segments_if_not_exists(segment_names, object_repository)
+          return if segment_names.nil?
+
+          object_repository.set_segment_names(segment_names)
+          @segment_fetcher.fetch_segments_if_not_exists(segment_names)
+        end
+
+        def fetch_rule_based_segments_if_not_exists(segment_names, change_number)
+          return false if segment_names.nil? || segment_names.empty? || @rule_based_segment_repository.contains?(segment_names.to_a)
+
+          @synchronizer.fetch_splits(0, change_number)
+
+          true
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/telemetry/domain/constants.rb

@@ -0,0 +1,48 @@
+# 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 = 'treatmentWithConfig'
+        TREATMENTS_WITH_CONFIG = 'treatmentsWithConfig'
+        TREATMENTS_BY_FLAG_SET = 'treatmentsByFlagSet'
+        TREATMENTS_BY_FLAG_SETS = 'treatmentsByFlagSets'
+        TREATMENTS_WITH_CONFIG_BY_FLAG_SET = 'treatmentWithConfigByFlagSet'
+        TREATMENTS_WITH_CONFIG_BY_FLAG_SETS = 'treatmentsWithConfigByFlagSets'
+        TRACK = 'track'
+
+        SPLITS = 'splits'
+      end
+    end
+  end
+end

data/lib/splitclient-rb/telemetry/domain/structs.rb

@@ -0,0 +1,35 @@
+# 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, st: storage, af: activeFactories, rf: redundantActiveFactories, t: tags, se: streamingEnabled,
+    # rr: refreshRate, uo: urlOverrides, iq: impressionsQueueSize, eq: eventsQueueSize, im: impressionsMode,
+    # il: impressionListenerEnabled, hp: httpProxyDetected, tr: timeUntilSdkReady, bt: burTimeouts,
+    # nr: sdkNotReadyUsage, i: integrations, fsT: Total flagsets, fsI: Invalid flagsets
+    ConfigInit = Struct.new(:om, :st, :af, :rf, :t, :fsT, :fsI, :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, ufs: updates from sse
+    Usage = Struct.new(:ls, :ml, :me, :he, :hl, :tr, :ar, :iq, :ide, :idr, :spc, :sec, :skc, :sl, :eq, :ed, :se, :t, :ufs)
+
+    # t: treatment, ts: treatments, tc: treatmentWithConfig, tcs: treatmentsWithConfig, tr: track
+    ClientMethodLatencies = Struct.new(:t, :ts, :tc, :tcs, :tf, :tfs, :tcf, :tcfs, :tr)
+    ClientMethodExceptions = Struct.new(:t, :ts, :tc, :tcs, :tf, :tfs, :tcf, :tcfs, :tr)
+
+    # sp: splits
+    UpdatesFromSSE = Struct.new(:sp)
+  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