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

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

@@ -1,163 +0,0 @@
-require 'concurrent'
-
-module SplitIoClient
-  module Cache
-    module Repositories
-      module Metrics
-        class MemoryRepository
-          OPERATIONS = %w(sdk.get_treatment sdk.get_treatments sdk.get_treatment_with_config sdk.get_treatments_with_config)
-
-          def initialize(_ = nil, config)
-            @counts = Concurrent::Array.new
-            @latencies = Concurrent::Array.new
-            @gauges = Concurrent::Array.new
-            @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)
-            if (OPERATIONS.include?(operation))
-              index = binary_search.add_latency_millis(time_in_ms, true)
-              increase_latency_bucket(operation, index)
-            else
-              concatenate_latency(operation, 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 fix_latencies
-            # NOOP
-          end
-
-          def clear_counts
-            @counts = Concurrent::Array.new
-          end
-
-          def clear_latencies
-            @latencies = Concurrent::Array.new
-          end
-
-          def clear_gauges
-            @gauges = Concurrent::Array.new
-          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
-
-          private
-
-          def increase_latency_bucket(operation, index)
-            operation_latencies = find_operation_latencies(operation)
-
-            if (operation_latencies.nil?)
-              latencies_array = Array.new(BinarySearchLatencyTracker::BUCKETS.length, 0)
-              latencies_array[index] = 1
-              @latencies << { operation: operation, latencies: latencies_array }
-            else
-              operation_latencies[:latencies][index] += 1
-            end
-          end
-
-          def concatenate_latency(operation, time_in_ms)
-            operation_latencies = find_operation_latencies(operation)
-
-            if (operation_latencies.nil?)
-              @latencies << { operation: operation, latencies: [time_in_ms] }
-            else
-              operation_latencies[:latencies].push(time_in_ms)
-            end
-          end
-
-          def find_operation_latencies(operation)
-            @latencies.find { |l| l[:operation] == operation }
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,131 +0,0 @@
-module SplitIoClient
-  module Cache
-    module Repositories
-      module Metrics
-        class RedisRepository < Repository
-          def initialize(config)
-            @config = config
-            @adapter = config.metrics_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}")
-
-            @adapter.inc("#{prefixed_name}.bucket.#{binary_search.add_latency_millis(time_in_ms, true)}")
-          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
-            keys = @adapter.find_strings_by_prefix(impressions_metrics_key('latency'))
-            return [] if keys.empty?
-
-            collected_latencies = collect_latencies(keys)
-
-            collected_latencies.keys.each_with_object({}) do |operation, latencies|
-              operation_latencies = Array.new(BinarySearchLatencyTracker::BUCKETS.length, 0)
-              collected_latencies[operation].each do |bucket, value|
-                operation_latencies[bucket.to_i] = value.to_i
-              end
-
-              latencies[operation] = operation_latencies
-            end
-          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
-
-          # introduced to fix incorrect latencies
-          def fix_latencies
-            latencies_cleaned_key =  namespace_key('/latencies.cleaned')
-            return if @adapter.exists?(latencies_cleaned_key)
-
-            keys =[]
-
-            23.times do |index|
-              keys.concat @adapter.find_strings_by_pattern(latencies_to_be_deleted_key_pattern_prefix("sdk.get_treatment.#{index}"))
-            end
-
-            keys.concat @adapter.find_strings_by_pattern(latencies_to_be_deleted_key_pattern_prefix('sdk.get_treatments'))
-            keys.concat @adapter.find_strings_by_pattern(latencies_to_be_deleted_key_pattern_prefix('sdk.get_treatment_with_config'))
-            keys.concat @adapter.find_strings_by_pattern(latencies_to_be_deleted_key_pattern_prefix('sdk.get_treatments_with_config'))
-
-            keys.concat @adapter.find_strings_by_pattern(latencies_to_be_deleted_key_pattern_prefix('*.time'))
-
-            @config.logger.info("Found incorrect latency keys, deleting. Keys: #{keys}") unless keys.size == 0
-
-            keys.each_slice(500) do |chunk|
-              @adapter.pipelined do
-                chunk.each do |key|
-                  @adapter.delete key
-                end
-              end
-            end
-
-            @adapter.set_string(latencies_cleaned_key, '1')
-          end
-
-          def latencies_to_be_deleted_key_pattern_prefix(key)
-            "#{@config.redis_namespace}/#{@config.language}-*/latency.#{key}"
-          end
-
-          def clear_gauges
-            # TODO
-          end
-
-          def clear
-            clear_counts
-            clear_latencies
-            clear_gauges
-          end
-
-          private
-
-          def find_latencies(keys)
-            @adapter.multiple_strings(keys).map do |name, data|
-              [name.gsub(impressions_metrics_key('latency.'), ''), data]
-            end.to_h
-          end
-
-          def collect_latencies(keys)
-            find_latencies(keys).each_with_object({}) do |(key, value), collected_latencies|
-              operation, bucket = key.split('.bucket.')
-              collected_latencies[operation] = {} unless collected_latencies[operation]
-              collected_latencies[operation].merge!({bucket => value})
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-module SplitIoClient
-  module Cache
-    module Repositories
-      # Repository which forwards impressions interface to the selected adapter
-      class MetricsRepository < Repository
-        extend Forwardable
-        def_delegators :@repository, :add_count, :add_latency, :add_gauge, :counts, :latencies, :gauges,
-                       :clear_counts, :clear_latencies, :clear_gauges, :clear, :fix_latencies
-
-        def initialize(config)
-          super(config)
-          @repository = case @config.metrics_adapter.class.to_s
-          when 'SplitIoClient::Cache::Adapters::MemoryAdapter'
-            Repositories::Metrics::MemoryRepository.new(@config)
-          when 'SplitIoClient::Cache::Adapters::RedisAdapter'
-            Repositories::Metrics::RedisRepository.new(@config)
-          end
-        end
-
-      end
-    end
-  end
-end

data/lib/splitclient-rb/cache/senders/metrics_sender.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module SplitIoClient
-  module Cache
-    module Senders
-      class MetricsSender
-        def initialize(metrics_repository, api_key, config)
-          @metrics_repository = metrics_repository
-          @api_key = api_key
-          @config = config
-        end
-
-        def call
-          metrics_thread
-
-          if defined?(PhusionPassenger)
-            PhusionPassenger.on_event(:starting_worker_process) do |forked|
-              metrics_thread if forked
-            end
-          end
-        end
-
-        private
-
-        def metrics_thread
-          @config.threads[:metrics_sender] = Thread.new do
-            begin
-              @config.logger.info('Starting metrics service')
-
-              loop do
-                post_metrics
-
-                sleep(SplitIoClient::Utilities.randomize_interval(@config.metrics_refresh_rate))
-              end
-            rescue SplitIoClient::SDKShutdownException
-              post_metrics
-
-              @config.logger.info('Posting metrics due to shutdown')
-            end
-          end
-        end
-
-        def post_metrics
-          metrics_api.post
-        rescue StandardError => error
-          @config.log_found_exception(__method__.to_s, error)
-        end
-
-        def metrics_api
-          @metrics_api ||= SplitIoClient::Api::Metrics.new(@api_key, @metrics_repository, @config)
-        end
-      end
-    end
-  end
-end

data/lib/splitclient-rb/engine/api/metrics.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-module SplitIoClient
-  module Api
-    class Metrics < Client
-      def initialize(api_key, metrics_repository, config)
-        super(config)
-        @api_key = api_key
-        @metrics_repository = metrics_repository
-      end
-
-      def post
-        post_latencies
-        post_counts
-      end
-
-      private
-
-      def post_latencies
-        if @metrics_repository.latencies.empty?
-          @config.split_logger.log_if_debug('No latencies to report.')
-        else
-          @metrics_repository.latencies.each do |name, latencies|
-            metrics_time = { name: name, latencies: latencies }
-
-            response = post_api("#{@config.events_uri}/metrics/time", @api_key, metrics_time)
-
-            log_status(response, metrics_time.size)
-          end
-        end
-
-        @metrics_repository.clear_latencies
-      end
-
-      def post_counts
-        if @metrics_repository.counts.empty?
-          @config.split_logger.log_if_debug('No counts to report.')
-        else
-          @metrics_repository.counts.each do |name, count|
-            metrics_count = { name: name, delta: count }
-
-            response = post_api("#{@config.events_uri}/metrics/counter", @api_key, metrics_count)
-
-            log_status(response, metrics_count.size)
-          end
-        end
-        @metrics_repository.clear_counts
-      end
-
-      def log_status(response, info_to_log)
-        if response.success?
-          @config.split_logger.log_if_debug("Metric time reported: #{info_to_log}")
-        else
-          @config.logger.error("Unexpected status code while posting time metrics: #{response.status}" \
-          ' - Check your API key and base URI')
-          raise 'Split SDK failed to connect to backend to post metrics'
-        end
-      end
-    end
-  end
-end

data/lib/splitclient-rb/engine/metrics/metrics.rb

@@ -1,80 +0,0 @@
-module SplitIoClient
-
-  #
-  # class to handle cached metrics
-  #
-  class Metrics < NoMethodError
-
-    @counter
-    @delta
-
-    #
-    # cached latencies
-    #
-    # @return [object] array of latencies
-    attr_accessor :latencies
-
-    #
-    # cached counts
-    #
-    # @return [object] array of counts
-    attr_accessor :counts
-
-    #
-    # cached gauges
-    #
-    # @return [object] array of gauges
-    attr_accessor :gauges
-
-    #
-    # quese size for cached arrays
-    #
-    # @return [int] queue size
-    attr_accessor :queue_size
-
-    def initialize(queue_size, repository)
-      @queue_size = queue_size
-      @binary_search = SplitIoClient::BinarySearchLatencyTracker.new
-      @repository = repository
-    end
-
-    #
-    # creates a new entry in the array for cached counts
-    #
-    # @param counter [string] name of the counter
-    # @delta [int] value of the counter
-    #
-    # @return void
-    def count(counter, delta)
-      return if (delta <= 0) || counter.nil? || counter.strip.empty?
-
-      @repository.add_count(counter, delta)
-    end
-
-    #
-    # creates a new entry in the array for cached time metrics
-    #
-    # @param operation [string] name of the operation
-    # @time_in_ms [number] time in miliseconds
-    #
-    # @return void
-    def time(operation, time_in_ms)
-      return if operation.nil? || operation.empty? || time_in_ms < 0
-
-      @repository.add_latency(operation, time_in_ms, @binary_search)
-    end
-
-    #
-    # creates a new entry in the array for cached gauges
-    #
-    # @param gauge [string] name of the gauge
-    # @value [number] value of the gauge
-    #
-    # @return void
-    def gauge(gauge, value)
-      return if gauge.nil? || gauge.empty?
-
-      @repository.add_gauge(gauge, value)
-    end
-  end
-end