kronk 1.4.0 → 1.5.0

data/lib/kronk/player/benchmark.rb

@@ -0,0 +1,261 @@
+class Kronk
+
+  ##
+  # Returns benchmarks for a set of Player results.
+  # * Total time taken
+  # * Complete requests
+  # * Failed requests
+  # * Total bytes transferred
+  # * Requests per second
+  # * Time per request
+  # * Transfer rate
+  # * Connection times (min mean median max)
+  # * Percentage of requests within a certain time
+  # * Slowest endpoints
+
+  class Player::Benchmark < Player::Output
+
+    class ResultSet
+
+      attr_reader :byterate, :count, :fastest, :hostname, :precision,
+                  :slowest, :total_bytes
+
+      def initialize uri, start_time
+        @times = Hash.new(0)
+        @count = 0
+        @r5XX  = 0
+        @r4XX  = 0
+
+        @precision = 3
+
+        @slowest = nil
+        @fastest = nil
+
+        @paths = {}
+
+        @total_bytes = 0
+        @byterate    = 0
+
+        @start_time = start_time
+        @total_time = 0
+
+        @hostname = "#{uri.scheme}://#{uri.host}:#{uri.port}" if uri
+      end
+
+
+      def add_result resp
+        time = (resp.time * 1000).round
+
+        @times[time] += 1
+        @count += 1
+
+        @r5XX += 1 if resp.code =~ /^5\d\d$/
+        @r4XX += 1 if resp.code =~ /^4\d\d$/
+
+        @slowest = time if !@slowest || @slowest < time
+        @fastest = time if !@fastest || @fastest > time
+
+        log_path resp.uri.path, time if resp.uri
+
+        @total_bytes += resp.raw.bytes.count
+
+        @byterate = (@byterate * (@count-1) + resp.byterate) / @count
+
+        @total_time = (Time.now - @start_time).to_f
+      end
+
+
+      def log_path path, time
+        path = "/" if !path || path.empty?
+        @paths[path] ||= [0, 0]
+        pcount = @paths[path][1] + 1
+        @paths[path][0] = (@paths[path][0] * @paths[path][1] + time) / pcount
+        @paths[path][0] = @paths[path][0].round @precision
+        @paths[path][1] = pcount
+      end
+
+
+      def deviation
+        return @deviation if @deviation
+
+        mdiff = @times.to_a.inject(0) do |sum, (time, count)|
+                  sum + ((time-self.mean)**2) * count
+                end
+
+        @deviation = ((mdiff / @count)**0.5).round @precision
+      end
+
+
+      def mean
+        @mean ||= (self.sum / @count).round @precision
+      end
+
+
+      def median
+        @median ||= ((@slowest + @fastest) / 2).round @precision
+      end
+
+
+      def percentages
+        return @percentages if @percentages
+
+        @percentages = {}
+
+        perc_list   = [50, 66, 75, 80, 90, 95, 98, 99]
+        times_count = 0
+        target_perc = perc_list.first
+
+        i = 0
+        @times.keys.sort.each do |time|
+          times_count += @times[time]
+
+          if target_perc <= (100 * times_count / @count)
+            @percentages[target_perc] = time
+            i += 1
+            target_perc = perc_list[i]
+
+            break unless target_perc
+          end
+        end
+
+        perc_list.each{|i| @percentages[i] ||= self.slowest }
+        @percentages[100] = self.slowest
+        @percentages
+      end
+
+
+      def req_per_sec
+        (@count / @total_time).round @precision
+      end
+
+
+      def transfer_rate
+        ((@total_bytes / 1000) / @total_time).round @precision
+      end
+
+
+      def sum
+        @sum ||= @times.inject(0){|sum, (time,count)| sum + time * count}
+      end
+
+
+      def slowest_paths
+        @paths.to_a.sort{|x,y| y[1] <=> x[1]}[0..9]
+      end
+
+
+      def to_s
+        out = <<-STR
+Host:          #{@hostname || "<IO>"}
+Completed:     #{@count}
+400s:          #{@r4XX}
+500s:          #{@r5XX}
+Req/Sec:       #{self.req_per_sec}
+Total Bytes:   #{@total_bytes}
+Transfer Rate: #{self.transfer_rate} Kbytes/sec
+
+Connection Times (ms)
+  Min:       #{self.fastest}
+  Mean:      #{self.mean}
+  [+/-sd]:   #{self.deviation}
+  Median:    #{self.median}
+  Max:       #{self.slowest}
+
+Request Percentages (ms)
+   50%    #{self.percentages[50]}
+   66%    #{self.percentages[66]}
+   75%    #{self.percentages[75]}
+   80%    #{self.percentages[80]}
+   90%    #{self.percentages[90]}
+   95%    #{self.percentages[95]}
+   98%    #{self.percentages[98]}
+   99%    #{self.percentages[99]}
+  100%    #{self.percentages[100]} (longest request)
+        STR
+
+        out << "
+Avg. Slowest Paths (ms, #)
+#{slowest_paths.map{|arr| "  #{(arr[1])}  #{arr[0]}"}.join "\n" }" if @hostname
+
+        out
+      end
+    end
+
+
+    def initialize player
+      @player  = player
+      @results = []
+      @count   = 0
+
+      @div = nil
+      @div = @player.number / 10 if @player.number
+      @div = 100 if !@div || @div < 10
+    end
+
+
+    def start
+      puts "Benchmarking..."
+      super
+    end
+
+
+    def result kronk, mutex
+      kronk.responses.each_with_index do |resp, i|
+        mutex.synchronize do
+          @count += 1
+          @results[i] ||= ResultSet.new(resp.uri, @start_time)
+          @results[i].add_result resp
+
+          puts "#{@count} requests" if @count % @div == 0
+        end
+      end
+    end
+
+
+    def error err, kronk, mutex
+      mutex.synchronize do
+        @count += 1
+      end
+    end
+
+
+    def completed
+      puts "Finished!"
+
+      render_head
+      render_body
+
+      true
+    end
+
+
+    def render_body
+      if @results.length > 1
+        puts Diff.new(@results[0].to_s, @results[1].to_s).formatted
+      else
+        puts @results.first.to_s
+      end
+    end
+
+
+    def render_head
+      puts <<-STR
+
+Benchmark Time:      #{(Time.now - @start_time).to_f} sec
+Number of Requests:  #{@count}
+Concurrency:         #{@player.concurrency}
+      STR
+    end
+  end
+end
+
+
+if Float.instance_method(:round).arity == 0
+class Float
+  def round ndigits=0
+    num, dec = self.to_s.split(".")
+    num = "#{num}.#{dec[0,ndigits]}".sub(/\.$/, "")
+    Float num
+  end
+end
+end

data/lib/kronk/player/input_reader.rb

@@ -0,0 +1,54 @@
+class Kronk
+
+  ##
+  # Reads an IO stream and parses it with the given parser.
+  # Parser must respond to the following:
+  # * start_new?(line) - Returns true when line is the beginning of a new
+  #   http request.
+  # * parse(str) - Parses the raw string into value Kronk#request options.
+
+  class Player::InputReader
+
+    attr_accessor :io, :parser, :buffer
+
+    def initialize string_or_io, parser=nil
+      @buffer = []
+      @parser = parser || Kronk::Player::RequestParser
+      @io     = string_or_io
+      @io     = StringIO.new(@io) if String === @io
+    end
+
+
+    ##
+    # Parse the next request in the IO instance.
+
+    def get_next
+      return if eof?
+
+      @buffer << @io.gets if @buffer.empty?
+
+      until @io.eof?
+        line = @io.gets
+        next unless line
+
+        if @parser.start_new?(line) || @buffer.empty?
+          @buffer << line
+          break
+        else
+          @buffer.last << line
+        end
+      end
+
+      return if @buffer.empty?
+      @parser.parse(@buffer.slice!(0)) || self.get_next
+    end
+
+
+    ##
+    # Returns true if there is no more input to read from.
+
+    def eof?
+      !@io || (@io.closed? || @io.eof?) && @buffer.empty?
+    end
+  end
+end

data/lib/kronk/player/output.rb

@@ -0,0 +1,49 @@
+class Kronk
+
+  ##
+  # Generic base class to inherit from for creating a player output.
+
+  class Player::Output
+
+    ##
+    # New instance initializes @player and @start_time
+
+    def initialize player
+      @player     = player
+      @start_time = Time.now
+    end
+
+
+    ##
+    # Called right before the queue starts being processed.
+    # Sets @start_time to Time.now.
+
+    def start
+      @start_time = Time.now
+    end
+
+
+    ##
+    # Called after kronk was run without errors.
+
+    def result kronk, mutex=nil
+    end
+
+
+    ##
+    # Called if an error was raised while running kronk.
+
+    def error err, kronk=nil, mutex=nil
+    end
+
+
+    ##
+    # Called after the queue is done being processed.
+    # If the return value is true-ish, command will exit with status 0,
+    # otherwise exits with status 1.
+
+    def completed
+      true
+    end
+  end
+end

data/lib/kronk/player/request_parser.rb

@@ -0,0 +1,24 @@
+class Kronk
+
+  ##
+  # Stream-friendly HTTP Request parser for piping into the Kronk player.
+  # Uses Kronk::Request for parsing.
+
+  class Player::RequestParser
+
+    ##
+    # Returns true-ish if the line given is the start of a new request.
+
+    def self.start_new? line
+      line =~ Request::REQUEST_LINE_MATCHER
+    end
+
+
+    ##
+    # Parse a single http request kronk options hash.
+
+    def self.parse string
+      Kronk::Request.parse_to_hash string
+    end
+  end
+end

data/lib/kronk/player/stream.rb

@@ -0,0 +1,50 @@
+class Kronk
+
+  ##
+  # Outputs Player results as a stream of Kronk outputs
+  # in chunked form, each chunk being one response and the number
+  # of octets being expressed in plain decimal form.
+  #
+  #   out   = Player::StreamOutput.new
+  #
+  #   io1   = StringIO.new "this is the first chunk"
+  #   io2   = StringIO.new "this is the rest"
+  #
+  #   kronk = Kronk.new
+  #   kronk.retrieve io1
+  #   out.result kronk
+  #   #=> "23\r\nthis is the first chunk\r\n"
+  #
+  #   kronk.retrieve io2
+  #   out.result kronk
+  #   #=> "16\r\nthis is the rest\r\n"
+  #
+  # Note: This output class will not render errors.
+
+  class Player::Stream < Player::Output
+
+    def result kronk, mutex=nil
+      output =
+        if kronk.diff
+          kronk.diff.formatted
+
+        elsif kronk.response
+          kronk.response.stringify kronk.options
+        end
+
+      output = "#{output.length}\r\n#{output}\r\n"
+
+      mutex.synchronize do
+        $stdout << output
+      end
+
+      output
+    end
+
+
+    def completed
+      $stdout.flush
+      true
+    end
+  end
+end

data/lib/kronk/player/suite.rb

@@ -0,0 +1,123 @@
+class Kronk
+
+  ##
+  # Outputs Player requests and results in a test-suite like format.
+
+  class Player::Suite < Player::Output
+
+    def start
+      @results = []
+      $stdout.puts "Started"
+      super
+    end
+
+
+    def result kronk, mutex=nil
+      status = "."
+
+      @results <<
+        if kronk.diff
+          status = "F"             if kronk.diff.count > 0
+          text   = diff_text kronk if status == "F"
+          time   =
+            (kronk.responses[0].time.to_f + kronk.responses[1].time.to_f) / 2
+
+          [status, time, text]
+
+        elsif kronk.response
+          status = "F"             if !kronk.response.success?
+          text   = resp_text kronk if status == "F"
+          [status, kronk.response.time, text]
+        end
+
+      $stdout << status
+      $stdout.flush
+    end
+
+
+    def error err, kronk=nil, mutex=nil
+      status = "E"
+      @results << [status, 0, error_text(err, kronk)]
+
+      $stdout << status
+      $stdout.flush
+    end
+
+
+    def completed
+      player_time   = (Time.now - @start_time).to_f
+      total_time    = 0
+      bad_count     = 0
+      failure_count = 0
+      error_count   = 0
+      err_buffer    = ""
+
+      @results.each do |(status, time, text)|
+        case status
+        when "F"
+          total_time    += time.to_f
+          bad_count     += 1
+          failure_count += 1
+          err_buffer << "\n  #{bad_count}) Failure:\n#{text}"
+
+        when "E"
+          bad_count   += 1
+          error_count += 1
+          err_buffer << "\n  #{bad_count}) Error:\n#{text}"
+
+        else
+          total_time += time.to_f
+        end
+      end
+
+      non_error_count = @results.length - error_count
+
+      avg_time = non_error_count > 0 ? total_time / non_error_count  : "n/a"
+      avg_qps  = non_error_count > 0 ? non_error_count / player_time : "n/a"
+
+      $stdout.puts "\nFinished in #{player_time} seconds.\n"
+      $stderr.puts err_buffer unless err_buffer.empty?
+      $stdout.puts "\n#{@results.length} cases, " +
+                   "#{failure_count} failures, #{error_count} errors"
+
+      $stdout.puts "Avg Time: #{avg_time}"
+      $stdout.puts "Avg QPS: #{avg_qps}"
+
+      return bad_count == 0
+    end
+
+
+    private
+
+
+    def resp_text kronk
+      <<-STR
+  Request: #{kronk.response.code} - #{kronk.response.uri}
+  Options: #{kronk.options.inspect}
+      STR
+    end
+
+
+    def diff_text kronk
+      <<-STR
+  Request: #{kronk.responses[0].code} - #{kronk.responses[0].uri}
+           #{kronk.responses[1].code} - #{kronk.responses[1].uri}
+  Options: #{kronk.options.inspect}
+  Diffs: #{kronk.diff.count}
+      STR
+    end
+
+
+    def error_text err, kronk=nil
+      str = "#{err.class}: #{err.message}"
+
+      if kronk
+        str << "\n  Options: #{kronk.options.inspect}\n\n"
+      else
+        str << "\n #{err.backtrace}\n\n"
+      end
+
+      str
+    end
+  end
+end