splitclient-rb 4.5.1-java

data/lib/splitclient-rb/cache/repositories/events/memory_repository.rb

@@ -0,0 +1,30 @@
+module SplitIoClient
+  module Cache
+    module Repositories
+      module Events
+        class MemoryRepository < EventsRepository
+          EVENTS_SLICE = 100
+
+          def initialize(adapter, config)
+            @adapter = adapter
+            @config = config
+          end
+
+          def add(key, traffic_type, event_type, time, value)
+            @adapter.add_to_queue(m: metadata, e: event(key, traffic_type, event_type, time, value))
+          rescue ThreadError # queue is full
+            if @config.debug_enabled
+              @config.logger.warn("Dropping events. Current size is #{@config.events_queue_size}. " \
+                                  "Consider increasing events_queue_size")
+            end
+            @adapter.clear
+          end
+
+          def clear
+            @adapter.clear
+          end
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/repositories/events/redis_repository.rb

@@ -0,0 +1,29 @@
+module SplitIoClient
+  module Cache
+    module Repositories
+      module Events
+        class RedisRepository < EventsRepository
+          EVENTS_SLICE = 100
+
+          def initialize(adapter, config)
+            @adapter = adapter
+            @config = config
+          end
+
+          def add(key, traffic_type, event_type, time, value)
+            @adapter.add_to_queue(
+              namespace_key('.events'),
+              { m: metadata, e: event(key, traffic_type, event_type, time, value) }.to_json,
+            )
+          end
+
+          def clear
+            @adapter.get_from_queue(namespace_key('.events'), EVENTS_SLICE).map do |e|
+              JSON.parse(e, symbolize_names: true)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/repositories/events_repository.rb

@@ -0,0 +1,41 @@
+module SplitIoClient
+  module Cache
+    module Repositories
+      # Repository which forwards events interface to the selected adapter
+      class EventsRepository < Repository
+        extend Forwardable
+        def_delegators :@adapter, :add, :clear
+
+        def initialize(adapter, config)
+          @config = config
+          @adapter = case adapter.class.to_s
+          when 'SplitIoClient::Cache::Adapters::MemoryAdapter'
+            Repositories::Events::MemoryRepository.new(adapter, config)
+          when 'SplitIoClient::Cache::Adapters::RedisAdapter'
+            Repositories::Events::RedisRepository.new(adapter, config)
+          end
+        end
+
+        protected
+
+        def metadata
+          {
+            s: "#{@config.language}-#{@config.version}",
+            i: @config.machine_ip,
+            n: @config.machine_name
+          }
+        end
+
+        def event(key, traffic_type, event_type, time, value)
+          {
+            key: key,
+            trafficTypeName: traffic_type,
+            eventTypeId: event_type,
+            value: value,
+            timestamp: time
+          }.reject { |_, v| v.nil? }
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/repositories/impressions/memory_repository.rb

@@ -0,0 +1,49 @@
+module SplitIoClient
+  module Cache
+    module Repositories
+      module Impressions
+        class MemoryRepository
+          def initialize(adapter, config)
+            @adapter = adapter
+            @config = config
+          end
+
+          # Store impression data in the selected adapter
+          def add(split_name, data)
+            @adapter.add_to_queue(feature: split_name, impressions: data)
+          rescue ThreadError # queue is full
+            if random_sampler.rand(1..1000) <= 2 # log only 0.2 % of the time
+              @config.logger.warn("Dropping impressions. Current size is #{@config.impressions_queue_size}. " \
+                                  "Consider increasing impressions_queue_size")
+            end
+          end
+
+          def add_bulk(key, bucketing_key, treatments_labels_change_numbers, time)
+            treatments_labels_change_numbers.each do |split_name, treatment_label_number|
+              add(
+                split_name,
+                'keyName' => key,
+                'bucketingKey' => bucketing_key,
+                'treatment' => treatment_label_number[:treatment],
+                'label' => @config.labels_enabled ? treatment_label_number[:label] : nil,
+                'changeNumber' => treatment_label_number[:change_number],
+                'time' => time
+              )
+            end
+          end
+
+          # Get everything from the queue and leave it empty
+          def clear
+            @adapter.clear.map { |impression| impression.update(ip: @config.machine_ip) }
+          end
+
+          private
+
+          def random_sampler
+            @random_sampler ||= Random.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/repositories/impressions/redis_repository.rb

@@ -0,0 +1,78 @@
+module SplitIoClient
+  module Cache
+    module Repositories
+      module Impressions
+        class RedisRepository < Repository
+          IMPRESSIONS_SLICE = 1000
+
+          def initialize(adapter, config)
+            @adapter = adapter
+            @config = config
+          end
+
+          # Store impression data in Redis
+          def add(split_name, data)
+            @adapter.add_to_set(
+              impressions_metrics_key("impressions.#{split_name}"),
+              data.to_json
+            )
+          end
+
+          def add_bulk(key, bucketing_key, treatments_labels_change_numbers, time)
+            @adapter.redis.pipelined do
+              treatments_labels_change_numbers.each_slice(IMPRESSIONS_SLICE) do |treatments_labels_change_numbers_slice|
+                treatments_labels_change_numbers_slice.each do |split_name, treatment_label_change_number|
+                  add(split_name,
+                      'keyName' => key,
+                      'bucketingKey' => bucketing_key,
+                      'treatment' => treatment_label_change_number[:treatment],
+                      'label' => @config.labels_enabled ? treatment_label_change_number[:label] : nil,
+                      'changeNumber' => treatment_label_change_number[:change_number],
+                      'time' => time)
+                end
+              end
+            end
+          end
+
+          # Get random impressions from redis in batches of size @config.impressions_queue_size,
+          # delete fetched impressions afterwards
+          def clear
+            impressions = impression_keys.each_with_object([]) do |key, memo|
+              ip = key.split('/')[-2] # 'prefix/sdk_lang/ip/impressions.name' -> ip
+              if ip.nil?
+                @config.logger.warn("Impressions IP parse error for key: #{key}")
+                next
+              end
+              split_name = key.split('.').last
+              members = @adapter.random_set_elements(key, @config.impressions_queue_size)
+              members.each do |impression|
+                parsed_impression = JSON.parse(impression)
+
+                memo << {
+                  feature: split_name.to_sym,
+                  impressions: parsed_impression,
+                  ip: ip
+                }
+              end
+
+              @adapter.delete_from_set(key, members)
+            end
+
+            impressions
+          rescue StandardError => e
+            @config.logger.error("Exception while clearing impressions cache: #{e}")
+          end
+
+          private
+
+          # Get all sets by prefix
+          def impression_keys
+            @adapter.find_sets_by_prefix("#{@config.redis_namespace}/*/impressions.*")
+          rescue StandardError => e
+            @config.logger.error("Exception while fetching impression_keys: #{e}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/repositories/impressions_repository.rb

@@ -0,0 +1,21 @@
+module SplitIoClient
+  module Cache
+    module Repositories
+      # Repository which forwards impressions interface to the selected adapter
+      class ImpressionsRepository < Repository
+        extend Forwardable
+        def_delegators :@adapter, :add, :add_bulk, :clear, :empty?
+
+        def initialize(adapter, config)
+          @config = config
+          @adapter = case adapter.class.to_s
+          when 'SplitIoClient::Cache::Adapters::MemoryAdapter'
+            Repositories::Impressions::MemoryRepository.new(adapter, config)
+          when 'SplitIoClient::Cache::Adapters::RedisAdapter'
+            Repositories::Impressions::RedisRepository.new(adapter, config)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/repositories/metrics/memory_repository.rb

@@ -0,0 +1,129 @@
+module SplitIoClient
+  module Cache
+    module Repositories
+      module Metrics
+        class MemoryRepository
+          def initialize(_ = nil, adapter, config)
+            @counts = []
+            @latencies = []
+            @gauges = []
+
+            @config = config
+          end
+
+          def add_count(counter, delta)
+            counter_hash = @counts.find { |c| c[:name] == counter }
+            if counter_hash.nil?
+              counter_delta = SumAndCount.new
+              counter_delta.add_delta(delta)
+              @counts << { name: counter, delta: counter_delta }
+            else
+              counter_hash[:delta].add_delta(delta)
+            end
+          end
+
+          def add_latency(operation, time_in_ms, binary_search)
+            operation_hash = @latencies.find { |l| l[:operation] == operation }
+            if operation_hash.nil?
+              latencies_for_op = (operation == 'sdk.get_treatment') ? binary_search.add_latency_millis(time_in_ms) : [time_in_ms]
+              @latencies << { operation: operation, latencies: latencies_for_op }
+            else
+              latencies_for_op = (operation == 'sdk.get_treatment') ? binary_search.add_latency_millis(time_in_ms) : operation_hash[:latencies].push(time_in_ms)
+            end
+          end
+
+          def add_gauge(gauge, value)
+            gauge_hash = @gauges.find { |g| g[:name] == gauge }
+            if gauge_hash.nil?
+              gauge_value = ValueAndCount.new
+              gauge_value.set_value(value)
+              @gauges << { name: gauge, value: gauge_value }
+            else
+              gauge_hash[:value].set_value(value)
+            end
+          end
+
+          def counts
+            @counts.each_with_object({}) do |count, memo|
+              memo[count[:name]] = count[:delta].sum
+            end
+          end
+
+          def latencies
+            @latencies.each_with_object({}) do |latency, memo|
+              memo[latency[:operation]] = latency[:latencies]
+            end
+          end
+
+          def gauges
+            # TODO
+          end
+
+          def clear_counts
+            @counts = []
+          end
+
+          def clear_latencies
+            @latencies = []
+          end
+
+          def clear_gauges
+            @gauges = []
+          end
+
+          def clear
+            clear_counts
+            clear_latencies
+            clear_gauges
+          end
+
+          #
+          # small class to act as DTO for counts
+          #
+          class SumAndCount
+            attr_reader :count
+            attr_reader :sum
+
+            def initialize
+              @count = 0
+              @sum = 0
+            end
+
+            def add_delta(delta)
+              @count += 1
+              @sum += delta
+            end
+
+            def clear
+              @count = 0
+              @sum = 0
+            end
+          end
+
+          #
+          # small class to act as DTO for gauges
+          #
+          class ValueAndCount
+            attr_reader :count
+            attr_reader :value
+
+            def initialize
+              @count = 0
+              @value = 0
+            end
+
+            def set_value(value)
+              @count += 1
+              @value = value
+            end
+
+            def clear
+              @count = 0
+              @value = 0
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/repositories/metrics/redis_repository.rb

@@ -0,0 +1,98 @@
+module SplitIoClient
+  module Cache
+    module Repositories
+      module Metrics
+        class RedisRepository < Repository
+          def initialize(adapter = nil, config)
+            @config = config
+            @adapter = adapter
+          end
+
+          def add_count(counter, delta)
+            prefixed_name = impressions_metrics_key("count.#{counter}")
+            counts = @adapter.find_strings_by_prefix(prefixed_name)
+
+            @adapter.inc(prefixed_name, delta)
+          end
+
+          def add_latency(operation, time_in_ms, binary_search)
+            prefixed_name = impressions_metrics_key("latency.#{operation}")
+            latencies = @adapter.find_strings_by_prefix(prefixed_name)
+
+            if operation == 'sdk.get_treatment'
+              @adapter.inc("#{prefixed_name}.#{binary_search.add_latency_millis(time_in_ms, true)}")
+              return
+            end
+
+            @adapter.append_to_string(prefixed_name, "#{time_in_ms},")
+          end
+
+          def add_gauge(gauge, value)
+            # TODO
+          end
+
+          def counts
+            keys = @adapter.find_strings_by_prefix(impressions_metrics_key("count"))
+
+            return [] if keys.empty?
+
+            @adapter.multiple_strings(keys).map do |name, data|
+              [name.gsub(impressions_metrics_key('count.'), ''), data]
+            end.to_h
+          end
+
+          def latencies
+            collected_latencies = {}
+            latencies_array = Array.new(BinarySearchLatencyTracker::BUCKETS.length, 0)
+            keys = @adapter.find_strings_by_prefix(impressions_metrics_key('latency'))
+
+            return [] if keys.empty?
+
+            found_latencies = @adapter.multiple_strings(keys).map do |name, data|
+              [name.gsub(impressions_metrics_key('latency.'), ''), data]
+            end.to_h
+
+            found_latencies.each do |key, value|
+              if key.start_with?('sdk.get_treatment')
+                index = key.gsub('sdk.get_treatment.', '').to_i
+                latencies_array[index] = value.to_i
+
+                next
+              end
+
+              collected_latencies[key] = value.split(',').map(&:to_f)
+            end
+
+            collected_latencies['sdk.get_treatment'] = latencies_array unless latencies_array.reduce(:+) == 0
+
+            collected_latencies
+          end
+
+          def gauges
+            # TODO
+          end
+
+          def clear_counts
+            keys = @adapter.find_strings_by_prefix(impressions_metrics_key('count'))
+            @adapter.delete(keys)
+          end
+
+          def clear_latencies
+            keys = @adapter.find_strings_by_prefix(impressions_metrics_key('latency'))
+            @adapter.delete(keys)
+          end
+
+          def clear_gauges
+            # TODO
+          end
+
+          def clear
+            clear_counts
+            clear_latencies
+            clear_gauges
+          end
+        end
+      end
+    end
+  end
+end