splitclient-rb 0.1.3

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

@@ -0,0 +1,129 @@
+module SplitIoClient
+  #
+  # helper class to parse fetched splits
+  #
+  class SplitParser < NoMethodError
+    #
+    # since value for splitChanges last fetch
+    attr_accessor :since
+
+    #
+    # till value for splitChanges last fetch
+    attr_accessor :till
+
+    #
+    # splits data
+    attr_accessor :splits
+
+    #
+    # splits segments data
+    attr_accessor :segments
+
+    def initialize(logger)
+      @splits = []
+      @since = -1
+      @till = -1
+      @logger = logger
+    end
+
+    #
+    # gets all the split names retrived from the endpoint
+    #
+    # @return [object] array of split names
+    def get_split_names
+      @splits.map { |s| s.name }
+    end
+
+    #
+    # @return [boolean] true if the splits content is empty false otherwise
+    def is_empty?
+      @splits.empty? ? true : false
+    end
+
+    #
+    # gets all the segment names that are used within the retrieved splits
+    #
+    # @return [object] array of segment names
+    def get_used_segments
+      segment_names = []
+
+      @splits.each { |s|
+        s.conditions.each { |c|
+          c.matchers.each { |m|
+            m[:userDefinedSegmentMatcherData].each { |seg, name|
+              segment_names << name
+            } unless m[:userDefinedSegmentMatcherData].nil?
+          } unless c.matchers.nil?
+        }
+      }
+      segment_names.uniq
+    end
+
+    #
+    # gets a split parsed object by name
+    #
+    # @param name [string] name of the split
+    #
+    # @return split [object] split object
+    def get_split(name)
+      @splits.find { |s| s.name == name }
+    end
+
+    #
+    # gets the treatment for the given combination of user key and split name
+    # using all parsed data for the splits
+    #
+    # @param id [string] user key
+    # @param name [string] split name
+    # @param default_treatment [string] default treatment value to be returned
+    #
+    # @return treatment [object] treatment for this user key, split pair
+    def get_split_treatment(id, name, default_treatment)
+      split = get_split(name)
+
+      if !split.is_empty? && split.status == 'ACTIVE' && !split.killed?
+        split.conditions.each do |c|
+          unless c.is_empty?
+            matcher = get_matcher_type(c)
+            if matcher.match?(id)
+              result = Splitter.get_treatment(id, split.seed, c.partitions) #'true match - running split'
+              if result.nil?
+                return default_treatment
+              else
+                return result
+              end
+            end
+          end
+        end
+      end
+
+      default_treatment
+    end
+
+    #
+    # gets the matcher type from a condition object
+    #
+    # @param contidion [object] a condition object
+    #
+    # @return matcher [object] the matcher object for the given condition
+    def get_matcher_type(condition)
+      final_matcher = nil
+
+      case condition.matcher
+        when 'ALL_KEYS'
+          final_matcher = AllKeysMatcher.new
+        when 'IN_SEGMENT'
+          segment = @segments.get_segment(condition.matcher_segment)
+          final_matcher = segment.is_empty? ? UserDefinedSegmentMatcher.new(nil) : UserDefinedSegmentMatcher.new(segment)
+        when 'WHITELIST'
+          final_matcher = WhitelistMatcher.new(condition.matcher_whitelist)
+        else
+          @logger.error('Invalid matcher type')
+      end
+
+      final_matcher
+    end
+
+  end
+
+end

data/lib/splitclient-engine/partitions/treatments.rb

@@ -0,0 +1,40 @@
+module SplitIoClient
+
+  #
+  # represents the possible return values for a treatment
+  #
+  class Treatments < NoMethodError
+
+    # Constants to represent treatment values
+    CONTROL = 'control'
+    OFF = 'off'
+    ON = 'on'
+
+    # get the actual value for the given treatment type
+    #
+    # @param type [string] treatment type
+    #
+    # @return [Treatment] treatment type value
+    def self.get_type(type)
+      case type
+        when 'on'
+          return ON
+        when 'off', 'control'
+          return CONTROL
+        else # default return off
+          return CONTROL
+      end
+    end
+
+    # checks if the give treatment matches control type
+    #
+    # @param type [string] treatment type
+    #
+    # @return [boolean] true if matches, false otherwise
+    def self.is_control?(treatment)
+      get_type(treatment).equal?(CONTROL) ? true : false
+    end
+
+  end
+
+end

data/lib/splitclient-rb.rb

@@ -0,0 +1,22 @@
+require 'splitclient-rb/version'
+require 'splitclient-rb/split_client'
+require 'splitclient-rb/split_config'
+require 'splitclient-cache/local_store'
+require 'splitclient-engine/parser/split'
+require 'splitclient-engine/parser/condition'
+require 'splitclient-engine/parser/partition'
+require 'splitclient-engine/parser/segment'
+require 'splitclient-engine/parser/split_adapter'
+require 'splitclient-engine/parser/split_parser'
+require 'splitclient-engine/parser/segment_parser'
+require 'splitclient-engine/partitions/treatments'
+require 'splitclient-engine/matchers/combiners'
+require 'splitclient-engine/matchers/combining_matcher'
+require 'splitclient-engine/matchers/all_keys_matcher'
+require 'splitclient-engine/matchers/negation_matcher'
+require 'splitclient-engine/matchers/user_defined_segment_matcher'
+require 'splitclient-engine/matchers/whitelist_matcher'
+require 'splitclient-engine/evaluator/splitter'
+require 'splitclient-engine/impressions/impressions'
+require 'splitclient-engine/metrics/metrics'
+require 'splitclient-engine/metrics/binary_search_latency_tracker'

data/lib/splitclient-rb/split_client.rb

@@ -0,0 +1,170 @@
+require 'logger'
+
+module SplitIoClient
+
+  #
+  # main class for split client sdk
+  #
+  class SplitClient < 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
+
+    #
+    # 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 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 = {})
+      @localhost_mode = false
+      @localhost_mode_features = []
+
+      @config = SplitConfig.new(config)
+
+      if api_key == LOCALHOST_MODE
+        @localhost_mode = true
+        load_localhost_mode_features
+      else
+        @adapter = SplitAdapter.new(api_key, @config)
+      end
+    end
+
+    #
+    # validates the treatment for the provided user key and feature
+    #
+    # @param id [string] user id
+    # @param feature [string] name of the feature that is being validated
+    # @param treatment [string] value of the treatment for this user key and feature
+    #
+    # @return [boolean] true if the user key has valida treatment, false otherwise
+    def is_treatment?(id, feature, treatment)
+      is_treatment = false
+
+      if is_localhost_mode?
+        is_treatment = get_localhost_treatment(feature)
+      else
+        begin
+          is_treatment = (get_treatment(id, feature) == treatment)
+        rescue
+          @config.logger.error("MUST NOT throw this error")
+        end
+      end
+      is_treatment
+    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)
+      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
+
+      start = Time.now
+      result = nil
+
+      begin
+        result = get_treatment_without_exception_handling(id, feature)
+      rescue StandardError => error
+        @config.log_found_exception(__method__.to_s, error)
+      end
+
+      result = result.nil? ? Treatments::CONTROL : result
+
+      begin
+        @adapter.impressions.log(id, feature, result, (Time.now.to_f * 1000.0))
+        latency = (Time.now - start) * 1000.0
+        if (@adapter.impressions.queue.length >= @adapter.impressions.max_number_of_keys)
+          @adapter.impressions_producer.wakeup
+        end
+      rescue StandardError => error
+        @config.log_found_exception(__method__.to_s, error)
+      end
+
+      result
+    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)
+      @adapter.parsed_splits.segments = @adapter.parsed_segments
+      split = @adapter.parsed_splits.get_split(feature)
+
+      if split.nil?
+        return Treatments::CONTROL
+      else
+        default_treatment = split.data[:defaultTreatment]
+        return @adapter.parsed_splits.get_split_treatment(id, feature, default_treatment)
+      end
+    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?
+      @localhost_mode
+    end
+
+    #
+    # method to set localhost mode features by reading .splits file located at home directory
+    #
+    # @returns [void]
+    def load_localhost_mode_features
+      splits_file = File.join(Dir.home, ".splits")
+      if File.exists?(splits_file)
+        line_num=0
+        File.open(splits_file).each do |line|
+          @localhost_mode_features << line.strip 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_mode_features.include?(feature)
+    end
+
+    private :get_treatment_without_exception_handling, :is_localhost_mode?,
+            :load_localhost_mode_features, :get_localhost_treatment
+
+  end
+
+end

data/lib/splitclient-rb/split_config.rb

@@ -0,0 +1,193 @@
+require 'logger'
+require 'socket'
+
+module SplitIoClient
+  #
+  # This class manages configuration options for the split client library.
+  # If not custom configuration is required the default configuration values will be used
+  #
+  class SplitConfig
+    #
+    # Constructor for creating custom split client config
+    #
+    # @param opts [Hash] optional hash with configuration options
+    # @option opts [String] :base_uri ("https://sdk.split.io/api/") The base URL for split API end points
+    # @option opts [Int] :read_timeout (10) The read timeout for network connections in seconds.
+    # @option opts [Int] :connection_timeout (2) The connect timeout for network connections in seconds.
+    # @option opts [Object] :local_store A cache store for the Faraday HTTP caching library. Defaults to the Rails cache in a Rails environment, or a thread-safe in-memory store otherwise.
+    # @option opts [Int] :features_refresh_rate The SDK polls Split servers for changes to feature roll-out plans. This parameter controls this polling period in seconds.
+    # @option opts [Int] :segments_refresh_rate
+    # @option opts [Int] :metrics_refresh_rate
+    # @option opts [Int] :impressions_refresh_rate
+    # @option opts [Object] :logger a logger to user for messages from the client. Defaults to stdout
+    # @option opts [Boolean] :debug_enabled (false) The value for the debug flag
+    #
+    # @return [type] SplitConfig with configuration options
+    def initialize(opts = {})
+      @base_uri = (opts[:base_uri] || SplitConfig.default_base_uri).chomp('/')
+      @local_store = opts[:local_store] || SplitConfig.default_local_store
+      @connection_timeout = opts[:connection_timeout] || SplitConfig.default_connection_timeout
+      @read_timeout = opts[:read_timeout] || SplitConfig.default_read_timeout
+      @features_refresh_rate = opts[:features_refresh_rate] || SplitConfig.default_features_refresh_rate
+      @segments_refresh_rate = opts[:segments_refresh_rate] || SplitConfig.default_segments_refresh_rate
+      @metrics_refresh_rate = opts[:metrics_refresh_rate] || SplitConfig.default_metrics_refresh_rate
+      @impressions_refresh_rate = opts[:impressions_refresh_rate] || SplitConfig.default_impressions_refresh_rate
+      @logger = opts[:logger] || SplitConfig.default_logger
+      @debug_enabled = opts[:debug_enabled] || SplitConfig.default_debug
+      @machine_name = SplitConfig.get_hostname
+      @machine_ip = SplitConfig.get_ip
+    end
+
+    #
+    # The base URL for split API end points
+    #
+    # @return [String] The configured base URL for the split API end points
+    attr_reader :base_uri
+
+    #
+    # The store for the Faraday HTTP caching library. Stores should respond to
+    # 'read', 'write' and 'delete' requests.
+    #
+    # @return [Object] The configured store for the Faraday HTTP caching library.
+    attr_reader :local_store
+
+    #
+    # The read timeout for network connections in seconds.
+    #
+    # @return [Int] The timeout in seconds.
+    attr_reader :read_timeout
+
+    #
+    # The connection timeout for network connections in seconds.
+    #
+    # @return [Int] The connect timeout in seconds.
+    attr_reader :connection_timeout
+
+    #
+    # The configured logger. The client library uses the log to
+    # print warning and error messages.
+    #
+    # @return [Logger] The configured logger
+    attr_reader :logger
+
+    #
+    # The boolean that represents the state of the debug log level
+    #
+    # @return [Boolean] The value for the debug flag
+    attr_reader :debug_enabled
+
+    attr_reader :machine_ip
+    attr_reader :machine_name
+
+    attr_reader :features_refresh_rate
+    attr_reader :segments_refresh_rate
+    attr_reader :metrics_refresh_rate
+    attr_reader :impressions_refresh_rate
+
+    #
+    # The default split client configuration
+    #
+    # @return [Config] The default split client configuration.
+    def self.default
+      SplitConfig.new
+    end
+
+    #
+    # The default base uri for api calls
+    #
+    # @return [string] The default base uri
+    def self.default_base_uri
+      'https://sdk.split.io/api/'
+    end
+
+    # @return [LocalStore] configuration value for local cache store
+    def self.default_local_store
+      defined?(Rails) && Rails.respond_to?(:cache) ? Rails.cache : LocalStore.new
+    end
+
+    #
+    # The default read timeout value
+    #
+    # @return [int]
+    def self.default_read_timeout
+      5
+    end
+
+    #
+    # The default connection timeout value
+    #
+    # @return [int]
+    def self.default_connection_timeout
+      5
+    end
+
+    def self.default_features_refresh_rate
+      30
+    end
+
+    def self.default_segments_refresh_rate
+      60
+    end
+
+    def self.default_metrics_refresh_rate
+      60
+    end
+
+    def self.default_impressions_refresh_rate
+      60
+    end
+
+    #
+    # The default logger object
+    #
+    # @return [object]
+    def self.default_logger
+      Logger.new($stdout)
+    end
+
+    #
+    # The default debug value
+    #
+    # @return [boolean]
+    def self.default_debug
+      false
+    end
+
+    #
+    # custom logger of exceptions
+    #
+    # @return [void]
+    def log_found_exception(caller, exn)
+      error_traceback = "#{exn.inspect} #{exn}\n\t#{exn.backtrace.join("\n\t")}"
+      error = "[splitclient-rb] Unexpected exception in #{caller}: #{error_traceback}"
+      @logger.error(error)
+    end
+
+    #
+    # gets the hostname where the sdk gem is running
+    #
+    # @return [string]
+    def self.get_hostname
+      begin
+        Socket.gethostname
+      rescue
+        #unable to get hostname
+        'localhost'
+      end
+    end
+
+    #
+    # gets the ip where the sdk gem is running
+    #
+    # @return [string]
+    def self.get_ip
+      begin
+        Socket::getaddrinfo(Socket.gethostname, 'echo', Socket::AF_INET)[0][3]
+      rescue
+        #unable to get local ip
+        '127.0.0.0'
+      end
+    end
+
+  end
+end