splitclient-rb 3.1.2 → 3.1.3.pre.rc1

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

@@ -0,0 +1,114 @@
+module SplitIoClient
+  class SplitClient
+  #
+  # Creates a new split client instance that connects to split.io API.
+  #
+  # @param api_key [String] the API key for your split account
+  #
+  # @return [SplitIoClient] split.io client instance
+  def initialize(api_key, config = {}, adapter = nil, splits_repository, segments_repository, impressions_repository, metrics_repository)
+    @config = config
+
+    @splits_repository = splits_repository
+    @segments_repository = segments_repository
+    @impressions_repository = impressions_repository
+    @metrics_repository = metrics_repository
+
+    @adapter = adapter
+  end
+
+  def get_treatments(key, split_names, attributes = nil)
+    bucketing_key, matching_key = keys_from_key(key)
+    bucketing_key = matching_key if bucketing_key.nil?
+
+    treatments =
+      @splits_repository.get_splits(split_names).each_with_object({}) do |(name, data), memo|
+        memo.merge!(name => get_treatment(key, name, attributes, data, false))
+      end
+
+    if @config.impressions_queue_size > 0
+      @impressions_repository.add_bulk(matching_key, bucketing_key, treatments, (Time.now.to_f * 1000.0).to_i)
+    end
+
+    treatments
+  end
+
+  #
+  # obtains the treatment for a given feature
+  #
+  # @param key [String/Hash] user id or hash with matching_key/bucketing_key
+  # @param split_name [String/Array] name of the feature that is being validated or array of them
+  #
+  # @return [String/Hash] Treatment as String or Hash of treatments in case of array of features
+  def get_treatment(key, split_name, attributes = nil, split_data = nil, store_impressions = true)
+    bucketing_key, matching_key = keys_from_key(key)
+    bucketing_key = matching_key if bucketing_key.nil?
+
+    if matching_key.nil?
+      @config.logger.warn('matching_key was null for split_name: ' + split_name.to_s)
+      return Treatments::CONTROL
+    end
+
+    if split_name.nil?
+      @config.logger.warn('split_name was null for key: ' + key)
+      return Treatments::CONTROL
+    end
+
+    start = Time.now
+    result = nil
+
+    begin
+      split = split_data ? split_data : @splits_repository.get_split(split_name)
+
+      result = if split.nil?
+        Treatments::CONTROL
+      else
+        SplitIoClient::Engine::Parser::SplitTreatment.new(@segments_repository).call(
+          { bucketing_key: bucketing_key, matching_key: matching_key }, split, attributes
+        )
+      end
+    rescue StandardError => error
+      @config.log_found_exception(__method__.to_s, error)
+    end
+
+    result = result.nil? ? Treatments::CONTROL : result
+
+    begin
+      latency = (Time.now - start) * 1000.0
+      if @config.impressions_queue_size > 0 && store_impressions
+        # Disable impressions if @config.impressions_queue_size == -1
+        @impressions_repository.add(split_name,
+          'key_name' => matching_key,
+          'bucketing_key' => bucketing_key,
+          'treatment' => result,
+          'time' => (Time.now.to_f * 1000.0).to_i
+        )
+      end
+
+      # Measure
+      @adapter.metrics.time("sdk.get_treatment", latency)
+    rescue StandardError => error
+      @config.log_found_exception(__method__.to_s, error)
+    end
+
+    result
+  end
+
+  def keys_from_key(key)
+    case key.class.to_s
+    when 'Hash'
+      key.values_at(:bucketing_key, :matching_key)
+    when 'String'
+      [key, key]
+    end
+  end
+
+  #
+  # method that returns the sdk gem version
+  #
+  # @return [string] version value for this sdk
+  def self.sdk_version
+    'ruby-'+SplitIoClient::VERSION
+  end
+end
+end

data/lib/splitclient-rb/localhost_split_factory.rb

@@ -1,194 +1,13 @@
-require 'logger'
 module SplitIoClient
+  class LocalhostSplitFactory
+    attr_reader :client, :manager
 
-  #
-  # main class for localhost split client sdk
-  #
-  class LocalhostSplitFactory < NoMethodError
-    class LocalhostSplitManager < NoMethodError
-      #
-      # constant that defines the localhost mode
-      LOCALHOST_MODE = 'localhost'
-
-      #
-      # object that acts as an api adapter connector. used to get and post to api endpoints
-      attr_reader :adapter
-
-      #
-      # 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
-      #
-      # @return [LocalhostSplitIoManager] split.io localhost manager instance
-      def initialize(splits_file)
-        @localhost_mode = true
-        @localhost_mode_features = []
-        load_localhost_mode_features(splits_file)
-      end
-
-      #
-      # method to set localhost mode features by reading the given .splits
-      #
-      # @param splits_file [File] the .split file that contains the splits
-      # @returns [void]
-      def load_localhost_mode_features(splits_file)
-        if File.exists?(splits_file)
-          line_num=0
-          File.open(splits_file).each do |line|
-            line_data = line.strip.split(" ")
-            @localhost_mode_features << {feature: line_data[0], treatment: line_data[1]} unless line.start_with?('#') || line.strip.empty?
-          end
-        end
-        @localhost_mode_features
-      end
-
-      #
-      # method to get a split view
-      #
-      # @returns a split view
-      def split(split_name)
-        @localhost_mode_features.find {|x| x[:feature] == split_name}
-      end
-
-      #
-      # method to get the split list from the client
-      #
-      # @returns [object] array of splits
-      def splits
-        @localhost_mode_features
-      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.each_with_object([]) do |split, memo|
-          memo << split[:feature]
-        end
-      end
-    end
-
-    class LocalhostSplitClient < NoMethodError
-      #
-      # constant that defines the localhost mode
-      LOCALHOST_MODE = 'localhost'
-
-      #
-      # 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)
-        @localhost_mode = true
-        @localhost_mode_features = []
-        load_localhost_mode_features(splits_file)
-      end
-
-      def get_treatments(key, split_names, attributes = nil)
-        split_names.each_with_object({}) do |name, memo|
-          puts "name #{name} memo #{memo}"
-          memo.merge!(name => get_treatment(key, name, attributes))
-        end
-      end
-
-      #
-      # obtains the treatment for a given feature
-      #
-      # @param id [string] user id
-      # @param feature [string] name of the feature that is being validated
-      #
-      # @return [Treatment]  treatment constant value
-      def get_treatment(id, feature, attributes = nil)
-        unless id
-          @config.logger.warn('id was null for feature: ' + feature)
-          return Treatments::CONTROL
-        end
-
-        unless feature
-          @config.logger.warn('feature was null for id: ' + id)
-          return Treatments::CONTROL
-        end
-        result = get_localhost_treatment(feature)
-      end
-
-
-      #
-      # auxiliary method to get the treatments avoding exceptions
-      #
-      # @param id [string] user id
-      # @param feature [string] name of the feature that is being validated
-      #
-      # @return [Treatment]  tretment constant value
-      def get_treatment_without_exception_handling(id, feature, attributes = nil)
-        get_treatment(id, feature, attributes)
-      end
-
-      #
-      # method that returns the sdk gem version
-      #
-      # @return [string] version value for this sdk
-      def self.sdk_version
-        'RubyClientSDK-'+SplitIoClient::VERSION
-      end
-
-      #
-      # 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
-
-      #
-      # method to set localhost mode features by reading .splits file located at home directory
-      #
-      # @returns [void]
-      def load_localhost_mode_features(splits_file)
-        if File.exists?(splits_file)
-          line_num=0
-          File.open(splits_file).each do |line|
-            line_data = line.strip.split(" ")
-            @localhost_mode_features << {feature: line_data[0], treatment: line_data[1]} unless line.start_with?('#') || line.strip.empty?
-          end
-        end
-      end
-
-      #
-      # method to check the treatment for the given feature in localhost mode
-      #
-      # @return [boolean] true if the feature is available in localhost mode, false otherwise
-      def get_localhost_treatment(feature)
-        localhost_result = Treatments::CONTROL
-        treatment = @localhost_mode_features.select{|h| h[:feature] == feature}.last
-        localhost_result = treatment[:treatment] if !treatment.nil?
-        localhost_result
-      end
-
-      private :get_treatment_without_exception_handling, :is_localhost_mode?,
-              :load_localhost_mode_features, :get_localhost_treatment
-
-    end
-
-    private_constant :LocalhostSplitClient
-    private_constant :LocalhostSplitManager
-
-    def initialize(splits_file)
+    def initialize(splits_file, reload_rate = nil)
       @splits_file = splits_file
-    end
-
-    def client
-      @client ||= LocalhostSplitClient.new(@splits_file)
-    end
+      @reload_rate = reload_rate
 
-    def manager
-      @manager ||= LocalhostSplitManager.new(@splits_file)
+      @client = LocalhostSplitClient.new(@splits_file, @reload_rate)
+      @manager = LocalhostSplitManager.new(@splits_file, @reload_rate)
     end
   end
 end

data/lib/splitclient-rb/localhost_utils.rb

@@ -0,0 +1,36 @@
+module SplitIoClient
+  module LocalhostUtils
+    #
+    # 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(::Utilities.randomize_interval(reload_rate))
+        end
+      end
+    end
+
+    def store_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 }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+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)
+      @localhost_mode_features.find { |x| x[:feature] == split_name }
+    end
+
+    #
+    # method to get the split list from the client
+    #
+    # @returns [object] array of splits
+    def splits
+      @localhost_mode_features
+    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.each_with_object([]) do |split, memo|
+        memo << split[:feature]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+module SplitIoClient
+  class SplitManager
+    #
+    # Creates a new split manager instance that connects to split.io API.
+    #
+    # @param api_key [String] the API key for your split account
+    #
+    # @return [SplitIoManager] split.io client instance
+    def initialize(api_key, config = {}, adapter = nil, splits_repository = nil)
+      @localhost_mode_features = []
+      @config = config
+      @splits_repository = splits_repository
+      @adapter = adapter
+    end
+
+    #
+    # method to get the split list from the client
+    #
+    # @returns [object] array of splits
+    def splits
+      return if @splits_repository.nil?
+
+      @splits_repository.splits.each_with_object([]) do |(name, split), memo|
+        split_model = Engine::Models::Split.new(split)
+
+        memo << build_split_view(name, split) unless split_model.archived?
+      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
+      return if @splits_repository.nil?
+
+      @splits_repository.split_names
+    end
+
+    #
+    # method to get a split view
+    #
+    # @returns a split view
+    def split(split_name)
+      if @splits_repository
+        split = @splits_repository.get_split(split_name)
+
+        build_split_view(split_name, split) unless split.nil? or split_model(split).archived?
+      end
+    end
+
+    def build_split_view(name, split)
+      return {} unless split
+
+      treatments =
+        if split[:conditions] && split[:conditions][0][:partitions]
+          split[:conditions][0][:partitions].map { |partition| partition[:treatment] }
+        else
+          []
+        end
+
+        {
+          name: name,
+          traffic_type_name: split[:trafficTypeName],
+          killed: split[:killed],
+          treatments: treatments,
+          change_number: split[:changeNumber]
+        }
+    end
+
+    private
+
+    def split_model(split)
+      split_model = Engine::Models::Split.new(split)
+    end
+  end
+end