splitclient-rb 6.3.0 → 8.11.0

data/lib/splitclient-rb/clients/localhost_split_client.rb

@@ -1,183 +0,0 @@
-module SplitIoClient
-  class LocalhostSplitClient
-    include SplitIoClient::LocalhostUtils
-
-    #
-    # variables to if the sdk is being used in localhost mode and store the list of features
-    attr_reader :localhost_mode
-    attr_reader :localhost_mode_features
-
-    #
-    # Creates a new split client instance that reads from the given splits file
-    #
-    # @param splits_file [File] file that contains some splits
-    #
-    # @return [LocalhostSplitIoClient] split.io localhost client instance
-    def initialize(splits_file, reload_rate = nil)
-      @localhost_mode = true
-      @localhost_mode_features = []
-      load_localhost_mode_features(splits_file, reload_rate)
-    end
-
-    #
-    # method that returns the sdk gem version
-    #
-    # @return [string] version value for this sdk
-    def self.sdk_version
-      'ruby-'+SplitIoClient::VERSION
-    end
-
-    #
-    # obtains the treatments and configs for a given set of features
-    #
-    # @param key [string] evaluation key, only used with yaml split files
-    # @param split_names [array] name of the features being validated
-    # @param attributes [hash] kept for consistency with actual SDK client. Omitted in calls
-    #
-    # @return [hash] map of treatments (split_name, treatment)
-    def get_treatments_with_config(key, split_names, attributes = nil)
-      get_localhost_treatments(key, split_names, attributes, 'get_treatments_with_config')
-    end
-
-    #
-    # obtains the treatments for a given set of features
-    #
-    # @param key [string] evaluation key, only used with yaml split files
-    # @param split_names [array] name of the features being validated
-    # @param attributes [hash] kept for consistency with actual SDK client. Omitted in calls
-    #
-    # @return [hash] map of treatments (split_name, treatment_name)
-    def get_treatments(key, split_names, attributes = nil)
-      treatments = get_localhost_treatments(key, split_names, attributes)
-      return treatments if treatments.nil?
-      keys = treatments.keys
-      treats = treatments.map { |_,t| t[:treatment]  }
-      Hash[keys.zip(treats)]
-    end
-
-    #
-    # obtains the treatment for a given feature
-    #
-    # @param key [string] evaluation key, only used with yaml split files
-    # @param split_name [string] name of the feature that is being validated
-    # @param attributes [hash] kept for consistency with actual SDK client. Omitted in calls
-    #
-    # @return [string] corresponding treatment
-    def get_treatment(key, split_name, attributes = nil)
-      get_localhost_treatment(key, split_name, attributes)[:treatment]
-    end
-
-    #
-    # obtains the treatment and config for a given feature
-    #
-    # @param key [string] evaluation key, only used with yaml split files
-    # @param split_name [string] name of the feature that is being validated
-    # @param attributes [hash] kept for consistency with actual SDK client. Omitted in calls
-    #
-    # @return [hash]  corresponding treatment and config
-    def get_treatment_with_config(key, split_name, attributes = nil)
-      get_localhost_treatment(key, split_name, attributes, 'get_treatment_with_config')
-    end
-
-    def track
-    end
-
-    private
-
-    #
-    # method to check if the sdk is running in localhost mode based on api key
-    #
-    # @return [boolean] True if is in localhost mode, false otherwise
-    def is_localhost_mode?
-      true
-    end
-
-    # @param key [string] evaluation key, only used with yaml split files
-    # @param split_name [string] name of the feature that is being validated
-    #
-    # @return [Hash] corresponding treatment and config, control otherwise
-    def get_localhost_treatment(key, split_name, attributes, calling_method = 'get_treatment')
-      control_treatment = { label: Engine::Models::Label::EXCEPTION, treatment: SplitIoClient::Engine::Models::Treatment::CONTROL, config: nil }
-      parsed_control_treatment = parsed_treatment(control_treatment)
-
-      bucketing_key, matching_key = keys_from_key(key)
-      return parsed_control_treatment unless SplitIoClient::Validators.valid_get_treatment_parameters(calling_method, key, split_name, matching_key, bucketing_key, attributes)
-
-      sanitized_split_name = split_name.to_s.strip
-
-      if split_name.to_s != sanitized_split_name
-        SplitIoClient.configuration.logger.warn("get_treatment: split_name #{split_name} has extra whitespace, trimming")
-        split_name = sanitized_split_name
-      end
-
-      treatment = @localhost_mode_features.select { |h| h[:feature] == split_name && has_key(h[:keys], key) }.last
-
-      if treatment.nil?
-        treatment = @localhost_mode_features.select { |h| h[:feature] == split_name && h[:keys] == nil }.last
-      end
-
-      if treatment && treatment[:treatment]
-        {
-          treatment: treatment[:treatment],
-          config: treatment[:config]
-        }
-      else
-        parsed_control_treatment
-      end
-    end
-
-    def get_localhost_treatments(key, split_names, attributes = nil, calling_method = 'get_treatments')
-      return nil unless SplitIoClient::Validators.valid_get_treatments_parameters(calling_method, split_names)
-
-      sanitized_split_names = sanitize_split_names(calling_method, split_names)
-
-      if sanitized_split_names.empty?
-        SplitIoClient.configuration.logger.error("#{calling_method}: split_names must be a non-empty Array")
-        return {}
-      end
-
-      split_names.each_with_object({}) do |split_name, memo|
-        memo.merge!(split_name => get_treatment_with_config(key, split_name, attributes))
-      end
-    end
-
-    def sanitize_split_names(calling_method, split_names)
-      split_names.compact.uniq.select do |split_name|
-        if (split_name.is_a?(String) || split_name.is_a?(Symbol)) && !split_name.empty?
-          true
-        elsif split_name.is_a?(String) && split_name.empty?
-          SplitIoClient.configuration.logger.warn("#{calling_method}: you passed an empty split_name, split_name must be a non-empty String or a Symbol")
-          false
-        else
-          SplitIoClient.configuration.logger.warn("#{calling_method}: you passed an invalid split_name, split_name must be a non-empty String or a Symbol")
-          false
-        end
-      end
-    end
-
-    def parsed_treatment(treatment_data)
-      {
-        treatment: treatment_data[:treatment],
-        config: treatment_data[:config]
-      }
-    end
-
-    def has_key(keys, key)
-      case keys
-        when Array then keys.include? key
-        when String then keys == key
-      else
-        false
-      end
-    end
-
-    def keys_from_key(key)
-      case key
-      when Hash
-        key.values_at(:bucketing_key, :matching_key).map { |k| k.nil? ? nil : k }
-      else
-        [nil, key].map { |k| k.nil? ? nil : k }
-      end
-    end
-  end
-end

data/lib/splitclient-rb/engine/api/faraday_adapter/patched_net_http_persistent.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module SplitIoClient
-  module FaradayAdapter
-    class PatchedNetHttpPersistent < Faraday::Adapter::NetHttpPersistent
-      ##
-      # Borrowed directly from the latest `NetHttpPersistent` adapter implementation.
-      #
-      # https://github.com/lostisland/faraday/blob/master/lib/faraday/adapter/net_http_persistent.rb
-      #
-      def net_http_connection(env)
-        @cached_connection ||=
-          if Net::HTTP::Persistent.instance_method(:initialize).parameters.first == [:key, :name]
-            Net::HTTP::Persistent.new(name: 'Faraday')
-          else
-            Net::HTTP::Persistent.new('Faraday')
-          end
-
-        proxy_uri                = proxy_uri(env)
-        @cached_connection.proxy = proxy_uri if @cached_connection.proxy_uri != proxy_uri
-        @cached_connection
-      end
-
-      def proxy_uri(env)
-        proxy_uri = nil
-        if (proxy = env[:request][:proxy])
-          proxy_uri      = ::URI::HTTP === proxy[:uri] ? proxy[:uri].dup : ::URI.parse(proxy[:uri].to_s)
-          proxy_uri.user = proxy_uri.password = nil
-          # awful patch for net-http-persistent 2.8 not unescaping user/password
-          (
-          class << proxy_uri;
-            self;
-          end).class_eval do
-            define_method(:user) { proxy[:user] }
-            define_method(:password) { proxy[:password] }
-          end if proxy[:user]
-        end
-        proxy_uri
-      end
-
-      def with_net_http_connection(env)
-        yield net_http_connection(env)
-      end
-    end
-  end
-end

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

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-module SplitIoClient
-  module Api
-    class Metrics < Client
-      def initialize(api_key, metrics_repository)
-        @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?
-          SplitLogger.log_if_debug('No latencies to report.')
-        else
-          @metrics_repository.latencies.each do |name, latencies|
-            metrics_time = { name: name, latencies: latencies }
-
-            response = post_api("#{SplitIoClient.configuration.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?
-          SplitLogger.log_if_debug('No counts to report.')
-        else
-          @metrics_repository.counts.each do |name, count|
-            metrics_count = { name: name, delta: count }
-
-            response = post_api("#{SplitIoClient.configuration.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?
-          SplitLogger.log_if_debug("Metric time reported: #{info_to_log}")
-        else
-          SplitLogger.log_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

data/lib/splitclient-rb/engine/parser/split_adapter.rb

@@ -1,81 +0,0 @@
-require 'json'
-require 'thread'
-
-include SplitIoClient::Cache::Stores
-include SplitIoClient::Cache::Senders
-
-module SplitIoClient
-  #
-  # acts as an api adapater to connect to split endpoints
-  # uses a configuration object that can be modified when creating the client instance
-  # also, uses safe threads to execute fetches and post give the time execution values from the config
-  #
-  class SplitAdapter < NoMethodError
-    attr_reader :splits_repository, :segments_repository, :impressions_repository, :metrics
-
-    #
-    # Creates a new split api adapter instance that consumes split api endpoints
-    #
-    # @param api_key [String] the API key for your split account
-    # @param splits_repository [SplitsRepository] SplitsRepository instance to store splits in
-    # @param segments_repository [SegmentsRepository] SegmentsRepository instance to store segments in
-    # @param impressions_repository [ImpressionsRepository] ImpressionsRepository instance to store impressions in
-    # @param metrics_repository [MetricsRepository] MetricsRepository instance to store metrics in
-    # @param sdk_blocker [SDKBlocker] SDKBlocker instance which blocks splits_repository/segments_repository
-    #
-    # @return [SplitIoClient] split.io client instance
-    def initialize(
-      api_key,
-      splits_repository,
-      segments_repository,
-      impressions_repository,
-      metrics_repository,
-      events_repository,
-      sdk_blocker
-    )
-      @api_key = api_key
-      @splits_repository = splits_repository
-      @segments_repository = segments_repository
-      @impressions_repository = impressions_repository
-      @metrics_repository = metrics_repository
-      @events_repository = events_repository
-      @metrics = Metrics.new(100, @metrics_repository)
-      @sdk_blocker = sdk_blocker
-
-      start_standalone_components if SplitIoClient.configuration.mode == :standalone
-    end
-
-    def start_standalone_components
-      split_store
-      segment_store
-      metrics_sender
-      impressions_sender
-      events_sender
-    end
-
-    # Starts thread which loops constantly and stores splits in the splits_repository of choice
-    def split_store
-      SplitStore.new(@splits_repository, @api_key, @metrics, @sdk_blocker).call
-    end
-
-    # Starts thread which loops constantly and stores segments in the segments_repository of choice
-    def segment_store
-      SegmentStore.new(@segments_repository, @api_key, @metrics, @sdk_blocker).call
-    end
-
-    # Starts thread which loops constantly and sends impressions to the Split API
-    def impressions_sender
-      ImpressionsSender.new(@impressions_repository, @api_key).call
-    end
-
-    # Starts thread which loops constantly and sends metrics to the Split API
-    def metrics_sender
-      MetricsSender.new(@metrics_repository, @api_key).call
-    end
-
-    # Starts thread which loops constantly and sends events to the Split API
-    def events_sender
-      EventsSender.new(@events_repository, @api_key).call
-    end
-  end
-end

data/lib/splitclient-rb/localhost_split_factory.rb

@@ -1,13 +0,0 @@
-module SplitIoClient
-  class LocalhostSplitFactory
-    attr_reader :client, :manager
-
-    def initialize(splits_file, reload_rate = nil, logger = nil)
-      @splits_file = splits_file
-      @reload_rate = reload_rate
-
-      @client = LocalhostSplitClient.new(@splits_file, @reload_rate)
-      @manager = LocalhostSplitManager.new(@splits_file, @reload_rate)
-    end
-  end
-end

data/lib/splitclient-rb/localhost_utils.rb

@@ -1,59 +0,0 @@
-module SplitIoClient
-  module LocalhostUtils
-
-    require 'yaml'
-    #
-    # method to set localhost mode features by reading the given .splits
-    #
-    # @param splits_file [File] the .split file that contains the splits
-    # @param reload_rate [Integer] the number of seconds to reload splits_file
-    # @return nil
-    def load_localhost_mode_features(splits_file, reload_rate = nil)
-      return @localhost_mode_features unless File.exists?(splits_file)
-
-      store_features(splits_file)
-
-      return unless reload_rate
-
-      Thread.new do
-        loop do
-          @localhost_mode_features = []
-          store_features(splits_file)
-
-          sleep(SplitIoClient::Utilities.randomize_interval(reload_rate))
-        end
-      end
-    end
-
-    def store_features(splits_file)
-      yaml_extensions = [".yml", ".yaml"]
-      if yaml_extensions.include? File.extname(splits_file)
-        store_yaml_features(splits_file)
-      else
-        store_plain_text_features(splits_file)
-      end
-    end
-
-    private
-
-    def store_plain_text_features(splits_file)
-      File.open(splits_file).each do |line|
-        feature, treatment = line.strip.split(' ')
-
-        next if line.start_with?('#') || line.strip.empty?
-
-        @localhost_mode_features << { feature: feature, treatment: treatment, key: nil, config: nil }
-      end
-    end
-
-    def store_yaml_features(splits_file)
-      YAML.load(File.read(splits_file)).each do |feature|
-        feat_symbolized_keys = feature[feature.keys.first].inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
-
-        feat_symbolized_keys[:config] = feat_symbolized_keys[:config].to_json
-
-        @localhost_mode_features << { feature: feature.keys.first }.merge(feat_symbolized_keys)
-      end
-    end
-  end
-end

data/lib/splitclient-rb/managers/localhost_split_manager.rb

@@ -1,60 +0,0 @@
-module SplitIoClient
-  class LocalhostSplitManager
-    include SplitIoClient::LocalhostUtils
-
-    #
-    # Creates a new split manager instance that holds the splits from a given file
-    #
-    # @param splits_file [File] the .split file that contains the splits
-    # @param reload_rate [Integer] the number of seconds to reload splits_file
-    #
-    # @return [LocalhostSplitIoManager] split.io localhost manager instance
-    def initialize(splits_file, reload_rate = nil)
-      @localhost_mode = true
-      @localhost_mode_features = []
-
-      load_localhost_mode_features(splits_file, reload_rate)
-    end
-
-    #
-    # method to get a split view
-    #
-    # @returns a split view
-    def split(split_name)
-      features = @localhost_mode_features.find_all { |feat| feat[:feature] == split_name }
-
-      return nil if features.nil?
-
-      treatments = features.map { |feat| feat[:treatment] }
-
-      configs = Hash[ features.map { |feat| [ feat[:treatment].to_sym, feat[:config] ] } ]
-
-      {
-        change_number: nil,
-        killed:       false,
-        name:         split_name,
-        traffic_type:  nil,
-        treatments:   treatments,
-        configs: configs
-      }
-    end
-
-    #
-    # method to get the split list from the client
-    #
-    # @returns Array of split view
-    def splits
-      split_names.map do |split_name|
-        split(split_name)
-      end
-    end
-
-    #
-    # method to get the list of just split names. Ideal for ietrating and calling client.get_treatment
-    #
-    # @returns [object] array of split names (String)
-    def split_names
-      @localhost_mode_features.map{ |feat| feat[:feature]}.uniq
-    end
-  end
-end