splitclient-rb 4.5.1-java

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

@@ -0,0 +1,74 @@
+require 'net/http/persistent'
+
+module SplitIoClient
+  module Api
+    class Client
+      RUBY_ENCODING = '1.9'.respond_to?(:force_encoding)
+
+      def get_api(url, config, api_key, params = {})
+        api_client.get(url, params) do |req|
+          req.headers = common_headers(api_key, config).merge('Accept-Encoding' => 'gzip')
+
+          req.options[:timeout] = config.read_timeout
+          req.options[:open_timeout] = config.connection_timeout
+
+          config.logger.debug("GET #{url} proxy: #{api_client.proxy}") if config.debug_enabled
+        end
+      rescue StandardError => e
+        config.logger.warn("#{e}\nURL:#{url}\nparams:#{params}")
+
+        false
+      end
+
+      def post_api(url, config, api_key, data, headers = {}, params = {})
+        api_client.post(url) do |req|
+          req.headers = common_headers(api_key, config)
+            .merge('Content-Type' => 'application/json')
+            .merge(headers)
+
+          req.body = data.to_json
+
+          req.options[:timeout] = config.read_timeout
+          req.options[:open_timeout] = config.connection_timeout
+
+          if config.transport_debug_enabled
+            config.logger.debug("POST #{url} #{req.body}")
+          elsif config.debug_enabled
+            config.logger.debug("POST #{url}")
+          end
+        end
+      rescue StandardError => e
+        config.logger.warn("#{e}\nURL:#{url}\ndata:#{data}\nparams:#{params}")
+
+        false
+      end
+
+      private
+
+      def api_client
+        @api_client ||= Faraday.new do |builder|
+          builder.use SplitIoClient::FaradayMiddleware::Gzip
+          builder.adapter :net_http_persistent
+        end
+      end
+
+      def common_headers(api_key, config)
+        {
+          'Authorization' => "Bearer #{api_key}",
+          'SplitSDKVersion' => "#{config.language}-#{config.version}",
+          'SplitSDKMachineName' => config.machine_name,
+          'SplitSDKMachineIP' => config.machine_ip,
+          'Referer' => referer(config)
+        }
+      end
+
+      def referer(config)
+        result = "#{config.language}-#{config.version}"
+
+        result = "#{result}::#{SplitIoClient::SplitConfig.machine_hostname}" unless SplitIoClient::SplitConfig.machine_hostname == 'localhost'
+
+        result
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module SplitIoClient
+  module Api
+    class Events < Client
+      def initialize(api_key, config, events)
+        @config = config
+        @api_key = api_key
+        @events = events
+      end
+
+      def post
+        if @events.empty?
+          @config.logger.debug('No events to report') if @config.debug_enabled
+          return
+        end
+
+        @events.each_slice(@config.events_queue_size) do |event_slice|
+          result = post_api(
+            "#{@config.events_uri}/events/bulk",
+            @config,
+            @api_key,
+            event_slice.map { |event| formatted_event(event[:e]) },
+            'SplitSDKMachineIP' => event_slice[0][:m][:i],
+            'SplitSDKMachineName' => event_slice[0][:m][:n],
+            'SplitSDKVersion' => event_slice[0][:m][:s]
+          )
+
+          if (200..299).include? result.status
+            @config.logger.debug("Events reported: #{event_slice.size}") if @config.debug_enabled
+          else
+            @config.logger.error("Unexpected status code while posting events: #{result.status}")
+          end
+        end
+      end
+
+      private
+
+      def formatted_event(event)
+        {
+          key: event[:key],
+          trafficTypeName: event[:trafficTypeName],
+          eventTypeId: event[:eventTypeId],
+          value: event[:value].to_f,
+          timestamp: event[:timestamp].to_i
+        }
+      end
+    end
+  end
+end

data/lib/splitclient-rb/engine/api/faraday_middleware/gzip.rb

@@ -0,0 +1,55 @@
+require 'faraday'
+
+module SplitIoClient
+  module FaradayMiddleware
+    class Gzip < Faraday::Middleware
+      ACCEPT_ENCODING = 'Accept-Encoding'.freeze
+      CONTENT_ENCODING = 'Content-Encoding'.freeze
+      CONTENT_LENGTH = 'Content-Length'.freeze
+      SUPPORTED_ENCODINGS = 'gzip,deflate'.freeze
+      RUBY_ENCODING = '1.9'.respond_to?(:force_encoding)
+
+      def call(env)
+        env[:request_headers][ACCEPT_ENCODING] ||= SUPPORTED_ENCODINGS
+        @app.call(env).on_complete do |response_env|
+          case response_env[:response_headers][CONTENT_ENCODING]
+          when 'gzip'
+            reset_body(response_env, &method(:uncompress_gzip))
+          when 'deflate'
+            reset_body(response_env, &method(:inflate))
+          end
+        end
+      end
+
+      def reset_body(env)
+        env[:body] = yield(env[:body])
+        env[:response_headers].delete(CONTENT_ENCODING)
+        env[:response_headers][CONTENT_LENGTH] = env[:body].length
+      end
+
+      def uncompress_gzip(body)
+        io = StringIO.new(body)
+        gzip_reader = if RUBY_ENCODING
+          Zlib::GzipReader.new(io, :encoding => 'ASCII-8BIT')
+        else
+          Zlib::GzipReader.new(io)
+        end
+        gzip_reader.read
+      end
+
+      def inflate(body)
+        # Inflate as a DEFLATE (RFC 1950+RFC 1951) stream
+        Zlib::Inflate.inflate(body)
+      rescue Zlib::DataError
+        # Fall back to inflating as a "raw" deflate stream which
+        # Microsoft servers return
+        inflate = Zlib::Inflate.new(-Zlib::MAX_WBITS)
+        begin
+          inflate.inflate(body)
+        ensure
+          inflate.close
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module SplitIoClient
+  module Api
+    class Impressions < Client
+      def initialize(api_key, config, impressions)
+        @config = config
+        @api_key = api_key
+        @impressions = impressions
+      end
+
+      def post
+        if @impressions.empty?
+          @config.logger.debug('No impressions to report') if @config.debug_enabled
+          return
+        end
+
+        impressions_by_ip.each do |ip, impressions|
+          result = post_api("#{@config.events_uri}/testImpressions/bulk", @config, @api_key, impressions, 'SplitSDKMachineIP' => ip)
+
+          if (200..299).include? result.status
+            @config.logger.debug("Impressions reported: #{total_impressions(@impressions)}") if @config.debug_enabled
+          else
+            @config.logger.error("Unexpected status code while posting impressions: #{result.status}")
+          end
+        end
+      end
+
+      def total_impressions(impressions)
+        return 0 if impressions.nil?
+
+        impressions.reduce(0) do |impressions_count, impression|
+          impressions_count += impression[:keyImpressions].length
+        end
+      end
+
+      private
+
+      def impressions_by_ip
+        @impressions.group_by { |impression| impression[:ip] }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+module SplitIoClient
+  module Api
+    class Metrics < Client
+      def initialize(api_key, config, metrics_repository)
+        @config = 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.logger.debug('No latencies to report.') if @config.debug_enabled
+        else
+          @metrics_repository.latencies.each do |name, latencies|
+            metrics_time = { name: name, latencies: latencies }
+
+            result = post_api("#{@config.events_uri}/metrics/time", @config, @api_key, metrics_time)
+
+            log_status(result, metrics_time.size)
+          end
+        end
+
+        @metrics_repository.clear_latencies
+      end
+
+      def post_counts
+        if @metrics_repository.counts.empty?
+          @config.logger.debug('No counts to report.') if @config.debug_enabled
+        else
+          @metrics_repository.counts.each do |name, count|
+            metrics_count = { name: name, delta: count }
+
+            result = post_api("#{@config.events_uri}/metrics/counter", @config, @api_key, metrics_count)
+
+            log_status(result, metrics_count.size)
+          end
+        end
+        @metrics_repository.clear_counts
+      end
+
+      private
+
+      def log_status(result, info_to_log)
+        if result == false
+          @config.logger.error("Failed to make a http request")
+        elsif (200..299).include? result.status
+          @config.logger.debug("Metric time reported: #{info_to_log}") if @config.debug_enabled
+        else
+          @config.logger.error("Unexpected status code while posting time metrics: #{result.status}")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+module SplitIoClient
+  module Api
+    class Segments < Client
+      def initialize(api_key, config, metrics, segments_repository)
+        @config = config
+        @metrics = metrics
+        @api_key = api_key
+        @segments_repository = segments_repository
+      end
+
+      def store_segments_by_names(names)
+        start = Time.now
+        prefix = 'segmentChangeFetcher'
+
+        return if names.nil? || names.empty?
+
+        names.each do |name|
+          since = @segments_repository.get_change_number(name)
+          while true
+            fetch_segments(name, prefix, since).each { |segment| @segments_repository.add_to_segment(segment) }
+            @config.logger.debug("Segment #{name} fetched before: #{since}, till: #{@segments_repository.get_change_number(name)}") if @config.debug_enabled
+
+            break if (since.to_i >= @segments_repository.get_change_number(name).to_i)
+            since = @segments_repository.get_change_number(name)
+          end
+        end
+
+        latency = (Time.now - start) * 1000.0
+        @metrics.time(prefix + '.time', latency)
+      end
+
+      private
+
+      def fetch_segments(name, prefix, since)
+        segments = []
+        segment = get_api("#{@config.base_uri}/segmentChanges/#{name}", @config, @api_key, since: since)
+
+        if segment == false
+          @config.logger.error("Failed to make a http request")
+        elsif segment.status / 100 == 2
+          segment_content = JSON.parse(segment.body, symbolize_names: true)
+          @segments_repository.set_change_number(name, segment_content[:till])
+          @metrics.count(prefix + '.status.' + segment.status.to_s, 1)
+
+          if @config.debug_enabled
+            @config.logger.debug("\'#{segment_content[:name]}\' segment retrieved.")
+            @config.logger.debug("\'#{segment_content[:name]}\' #{segment_content[:added].size} added keys") if segment_content[:added].size > 0
+            @config.logger.debug("\'#{segment_content[:name]}\' #{segment_content[:removed].size} removed keys") if segment_content[:removed].size > 0
+          end
+          @config.logger.debug("#{segment_content}") if @config.transport_debug_enabled
+
+          segments << segment_content
+        else
+          @config.logger.error("Unexpected result from API Call for Segment #{name} status #{segment.status.to_s} since #{since.to_s}")
+          @metrics.count(prefix + '.status.' + segment.status.to_s, 1)
+        end
+
+        segments
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+module SplitIoClient
+  module Api
+    class Splits < Client
+      def initialize(api_key, config, metrics)
+        @api_key = api_key
+        @config = config
+        @metrics = metrics
+      end
+
+      def since(since)
+        start = Time.now
+        prefix = 'splitChangeFetcher'
+        splits = get_api("#{@config.base_uri}/splitChanges", @config, @api_key, since: since)
+
+        if splits == false
+          @config.logger.error("Failed to make a http request")
+        elsif splits.status / 100 == 2
+          result = splits_with_segment_names(splits.body)
+
+          @metrics.count(prefix + '.status.' + splits.status.to_s, 1)
+
+          @config.logger.debug("#{result[:splits].length} splits retrieved. since=#{since}") if @config.debug_enabled and result[:splits].length > 0
+          @config.logger.debug("#{result}") if @config.transport_debug_enabled
+        else
+          @metrics.count(prefix + '.status.' + splits.status.to_s, 1)
+
+          @config.logger.error('Unexpected result from Splits API call')
+        end
+
+        latency = (Time.now - start) * 1000.0
+        @metrics.time(prefix + '.time', latency)
+
+        result
+      end
+
+      private
+
+      def splits_with_segment_names(splits_json)
+        parsed_splits = JSON.parse(splits_json, symbolize_names: true)
+
+        parsed_splits[:segment_names] =
+          parsed_splits[:splits].each_with_object(Set.new) do |split, splits|
+            splits << segment_names(split)
+          end.flatten
+
+        parsed_splits
+      end
+
+      def segment_names(split)
+        split[:conditions].each_with_object(Set.new) do |condition, names|
+          condition[:matcherGroup][:matchers].each do |matcher|
+            next if matcher[:userDefinedSegmentMatcherData].nil?
+
+            names << matcher[:userDefinedSegmentMatcherData][:segmentName]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/engine/evaluator/splitter.rb

@@ -0,0 +1,123 @@
+module SplitIoClient
+  # Misc class in charge of providing hash functions and
+  # determination of treatment based on concept of buckets
+  # based on provided key
+  #
+  class Splitter < NoMethodError
+    def initialize
+      @murmur_hash = case RUBY_PLATFORM
+      when 'java' 
+        Proc.new { |key, seed| Java::MurmurHash3.murmurhash3_x86_32(key, seed) }
+      else
+        Proc.new { |key, seed| Digest::MurmurHashMRI3_x86_32.rawdigest(key, [seed].pack('L')) }
+      end
+    end
+    
+    #
+    # Checks if the partiotion size is 100%
+    #
+    # @param partitions [object] array of partitions
+    #
+    # @return [boolean] true if partition is 100% false otherwise
+    def hundred_percent_one_treatment?(partitions)
+      (partitions.size != 1) ? false : (partitions.first.size == 100)
+    end
+
+    #
+    # gets the appropriate treatment based on id, seed and partition value
+    #
+    # @param id [string] user key
+    # @param seed [number] seed for the user key
+    # @param partitions [object] array of partitions
+    #
+    # @return traetment [object] treatment value
+    def get_treatment(id, seed, partitions, legacy_algo)
+      legacy = [1, nil].include?(legacy_algo)
+
+      if partitions.empty?
+        return SplitIoClient::Engine::Models::Treatment::CONTROL
+      end
+
+      if hundred_percent_one_treatment?(partitions)
+        return (partitions.first).treatment
+      end
+
+      return get_treatment_for_key(bucket(count_hash(id, seed, legacy_algo)), partitions)
+    end
+
+    # returns a hash value for the give key, seed pair
+    #
+    # @param key [String] user key
+    # @param seed [Fixnum] seed for the user key
+    #
+    # @return hash [String] hash value
+    def count_hash(key, seed, legacy)
+      legacy ? legacy_hash(key, seed) : murmur_hash(key, seed)
+    end
+
+    def murmur_hash(key, seed)
+      @murmur_hash.call(key, seed)
+    end
+
+    def legacy_hash(key, seed)
+      h = 0
+
+      for i in 0..key.length-1
+        h = to_int32(31 * h + key[i].ord)
+      end
+
+      h^seed
+    end
+
+    #
+    # misc method to convert ruby number to int 32 since overflow is handled different to java
+    #
+    # @param number [number] ruby number value
+    #
+    # @return [int] returns the int 32 value of the provided number
+    def to_int32(number)
+      begin
+        sign = number < 0 ? -1 : 1
+        abs = number.abs
+        return 0 if abs == 0 || abs == Float::INFINITY
+      rescue
+        return 0
+      end
+
+      pos_int = sign * abs.floor
+      int_32bit = pos_int % 2**32
+
+      return int_32bit - 2**32 if int_32bit >= 2**31
+      int_32bit
+    end
+
+    #
+    # returns the treatment for a bucket given the partitions
+    #
+    # @param bucket [number] bucket value
+    # @param parittions [object] array of partitions
+    #
+    # @return treatment [treatment] treatment value for this bucket and partitions
+    def get_treatment_for_key(bucket, partitions)
+      buckets_covered_thus_far = 0
+      partitions.each do |p|
+        unless p.is_empty?
+          buckets_covered_thus_far += p.size
+          return p.treatment if buckets_covered_thus_far >= bucket
+        end
+      end
+
+      return SplitIoClient::Engine::Models::Treatment::CONTROL
+    end
+
+    #
+    # returns bucket value for the given hash value
+    #
+    # @param hash_value [string] hash value
+    #
+    # @return bucket [number] bucket number
+    def bucket(hash_value)
+      (hash_value.abs % 100) + 1
+    end
+  end
+end