rwb 0.2.2 → 0.2.3

data/Rakefile

@@ -0,0 +1,62 @@
+require 'rubygems'
+require 'rake/clean'
+require 'rake/rdoctask'
+require 'rake/testtask'
+require 'rake/gempackagetask'
+require 'rubygems'
+
+
+Rake::RDocTask.new do |rd|
+  rd.main = "readme"
+  rd.rdoc_files.include("readme", "lib/**/*.rb")
+end
+
+Rake::TestTask.new(:unittests) do |t|
+  t.test_files = FileList['test/test*.rb']
+  t.warning = true
+  t.verbose = false
+end
+
+task :test => [:unittests]
+
+spec = Gem::Specification.new do |s|
+  s.name = 'rwb'
+  s.version = "0.2.3"
+  s.author = "Pat Eyler"
+  s.email = "pat.eyler@gmail.com"
+  s.homepage = "http://rubyforge.org/projects/rwb"
+  s.platform = Gem::Platform::RUBY
+  s.summary = "Ruby Web Bench, a web performance and load testing framework"
+  s.files = Dir.glob("{test,lib,bin}/**/*").delete_if {|item|
+  item.include?("CVS") || item.include?("rdoc")}
+  s.files +=  ['NEWS', 'README', 'TODO', 'Rakefile']
+  s.require_path = 'lib'
+  s.autorequire = 'rwb'
+  s.has_rdoc = 'true'
+end
+
+if $0==__FILE__
+  Gem::manage_gems
+  Gem::Builder.new(spec).build
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end
+
+
+desc "Perform a cvs update"
+# relies on ssh keys being set up correctly
+task :update do 
+  sh "cvs update"
+end
+
+desc "Perform a cvs commit after running unit tests and
+updating"
+# relies on ssh keys being set up correctly
+task :commit => [:update, :unittests] do |t|
+  msg = "commit from Rake:\n"
+  msg << ENV['MSG']
+  sh "cvs commit -m '#{msg}'"
+end

data/lib/rwb/report.rb

@@ -0,0 +1,100 @@
+module RWB
+  class Runner
+
+    def report_full(sla_levels = @sla_levels)
+      report_header
+      report_overall(sla_levels)
+      report_urls(sla_levels)
+      report_by_time(sla_levels)
+    end
+
+    def report_overall(sla_levels = @sla_levels)
+      results = @new_results.times_by_url
+      
+      puts "Overall results:"
+      print_times(results.sort, sla_levels)
+    end
+
+    def report_urls(sla_levels = @sla_levels)
+      @urls.urls.keys.sort.each do |key|
+        url = @urls.urls[key].to_base
+        results = @new_results.times_by_url(url)
+        puts "Results for #{url}:"
+        if results.length > 0
+          print_times(results.sort, sla_levels)
+        else
+          puts "no results for url"
+        end
+      end
+    end
+
+    def graph_quartiles_urls(scale = nil)
+      @urls.urls.keys.sort.each do |key|
+        url = @urls.urls[key].to_base
+        results = @new_results.times_by_url(url)
+        puts "#{url}:\n\t" + results_quartile(results.sort, scale)
+      end
+    end
+
+    def graph_quartiles_overall
+      results = @new_results.times_by_url
+      puts results_quartile(results.sort)
+    end
+
+    def report_by_time(sla_levels = @sla_levels, granularity = 0.2)
+      start = 0.0
+      stop = granularity
+      results = @new_results.times_by_url
+      puts "Results by time:"
+      while stop <= 1.0
+        first = (results.length * start).to_i
+        last = (results.length * stop).to_i
+        these_results = results.slice(first..last)
+        puts "results for requests #{first} - #{last}"
+        print_times(these_results.sort, sla_levels)
+        start = stop
+        stop += granularity
+      end
+    end
+
+    def print_times(results, levels)
+      times = get_times(results, levels)
+      puts  "\tShortest time:\t#{times.shift} msecs"
+      levels.each_with_index do |num, index|
+        percent = num.to_f * 100.0
+        puts "\t#{percent}%ile time:\t#{times[index]} msecs"
+      end
+      puts  "\tLongest time:\t#{times[-1]} msecs"
+    end
+
+    def get_times(results, levels)
+      times = Array.new
+      times.push(make_milli(results[0]))
+      levels.each do |num|
+        times.push(make_milli(results[(results.length*num - 1).round]))
+      end
+      unless times.last == make_milli(results.last)
+        times.push(make_milli(results.last))
+      end
+      times
+    end
+
+    def make_milli(num)
+      (num * 1000).to_i
+    end
+
+    def report_header
+      print <<EOF
+Concurrency Level:       #{@max_threads}
+Total Requests:          #{@max_runs}
+Total time for testing:  #{@total_time} secs
+Requests per second:     #{@max_runs/@total_time}
+Mean time per request:   #{results_mean}  msecs
+Standard deviation:      #{results_std_dev}
+EOF
+      end
+
+
+
+  end
+end

data/lib/rwb/results.rb

@@ -0,0 +1,164 @@
+module RWB
+
+  class Result
+    attr_reader :id, :timestamp, :url
+    attr_reader :elapsed_time, :response_code
+
+    def initialize(id, timestamp, url, elapsed_time, response_code)
+      @id = id
+      @timestamp = timestamp
+      @url = url
+      @elapsed_time = elapsed_time
+      @response_code = response_code
+    end
+  end
+
+  class RunResults
+    attr_reader :results
+
+    def initialize
+      @results = Array.new
+    end
+ 
+    def add_result(result)
+      @results.push(result)
+    end
+
+    def each_by_response_code(code)
+      @results.each do |result|
+        yield result if result.response_code.to_i == code.to_i
+      end
+    end
+
+    def all_by_response_code(code)
+      coded_results = Array.new
+      @results.each do |result|
+        if result.response_code.to_i == code.to_i
+          coded_results.push(result)
+        end
+      end
+      coded_results
+    end
+
+    def all_by_url(url)
+      coded_results = Array.new
+      @results.each do |result|
+        if result.url.to_s == url.to_s
+          coded_results.push(result)
+        end
+      end
+      coded_results
+    end
+
+    def each_by_url(url)
+      @results.each do |result|
+        yield result if result.url.to_s == url.to_s
+      end
+    end
+
+    def all_with_id
+      id_results = Hash.new
+      @results.each do |result|
+        id_results[result.id] = result
+      end
+      id_results
+    end
+
+    def times_by_url(url =  nil)
+      coded_results = Array.new
+      @results.each do |result|
+        if url
+          if result.url.to_s == url.to_s
+            coded_results.push(result.elapsed_time)
+          end
+        else
+            coded_results.push(result.elapsed_time)
+        end          
+      end
+      coded_results
+    end
+
+  end
+
+  class Runner
+    def results_mean
+      if @results_mean
+        return @results_mean
+      end
+      @results_mean = @new_results.times_by_url.inject(0) do |sum, time|
+        sum += time
+      end
+      @results_mean = @results_mean/@new_results.times_by_url.length
+      make_milli(@results_mean)
+    end
+
+    def results_std_dev
+      if @results_std_dev
+        return @results_std_dev
+      end
+      unless @results_mean
+        results_mean
+      end
+      @results_std_dev = @new_results.times_by_url.inject(0) do |std_dev, time|
+        std_dev += (time - @results_mean) ** 2
+      end
+      @results_std_dev = 
+        Math.sqrt(@results_std_dev/@new_results.times_by_url.length)
+      make_milli(@results_std_dev)
+    end
+
+    def adjust_scale(scale, max)
+      if scale/2 > max
+        scale = scale/2
+        scale = adjust_scale(scale, max)
+      end
+      scale
+    end
+
+    def results_quartile(times, scale = nil)
+      times = times.map { |t| make_milli(t) }
+      size = results_mean + results_std_dev * 2
+      min = times[0]
+      first  = times[(times.length*0.25).to_int - 1]
+      second = times[(times.length*0.5).to_int - 1]
+      third  = times[(times.length*0.75).to_int - 1]
+      max = times[-1]
+      
+      len = max.to_s.length
+      unless scale
+        scale = (max/((10**len).to_f)).ceil * (10**len)
+        scale = adjust_scale(scale, max)
+      end
+      step = scale/50
+      step = 1 if step == 0
+      scale = 50 if scale < 50
+      line = Array.new
+      char = ' '
+      for i in 0..49 do
+        case i
+        when max/step
+          line[i] = ']'
+        when third/step
+          line[i] = '|'
+          char = ' '
+        when second/step
+          line[i] = '+'
+        when first/step
+          line[i] = '|'
+          char = '-'
+        when min/step
+          line[i] = '['
+        when 0
+          line[i] = ':'
+        when 49
+          line[i] = ':'
+        else
+          line[i] = char
+        end
+      end
+      return '0' + line.join('')  + scale.to_s
+    end
+  end
+
+
+end

data/lib/rwb/url.rb

@@ -0,0 +1,126 @@
+module RWB
+
+  #
+  # The Url class holds individual URLs for testing.  +Url+s are defined by a 
+  # Fixnum representing the weight and a String representing the URL itself.
+  # The weights are not required to be percentages.
+  #
+  #   url = RWB::Url.new(20, "http://www.example.com")
+  class Url
+    attr_reader :weight, :method
+
+    def initialize(weight, url, method='GET')
+      @weight = weight
+      @url = url
+      @method = read_method(method)
+    end
+    
+    def read_method(method = 'GET')
+      method = method.to_s.upcase
+      if method != 'GET' && method != 'POST'
+        return 'GET'
+      else
+        return method
+      end
+    end
+
+    # to_url returns the URL to be requested as a string
+    #
+    #   url.to_url  # => "http://www.example.com" 
+    def to_url
+      @url
+    end
+
+    #
+    # to_base returns a string suitable for creating a +Regexp+ to match
+    # against. 
+    # 
+    #   url.to_base # => "http://www.example.com "
+    #  
+    def to_base
+      @url
+    end
+
+    def to_s
+      @weight.to_s + " " + @url
+    end
+  end
+
+  #
+  # A UrlGroup is a collection of related URLs, for example the URL for a
+  # search tool, with several search queries.   The group is weighted (and
+  # reported on) as a whole, but individual requests are made with random
+  # elements from an array of extensions.
+  #
+  #   urls = UrlGroup.new(20, "http://www.example.com/search?",
+  #           ["foo", "bar", "baz"])
+  #
+  class UrlGroup < RWB::Url
+    
+    def initialize(weight, base, extension_array, method='GET')
+      @weight = weight.to_i
+      @base = base.to_s
+      @extension_array = extension_array
+      @method = read_method(method)
+    end
+
+
+    #
+    # to_url returns a complete URL to be requested.  It takes an optional
+    # seed argument, which must be a Fixnum.  If given, this will seed the
+    # random selection of the extension.
+    #
+    #   urls.to_url(1234)  # => "http://www.example.com/search?baz"
+    #
+    def to_url(seed = nil)
+      if seed
+        srand = seed
+      end
+      @base + @extension_array[rand(@extension_array.length)]
+    end
+
+    #
+    # to_base returns a String suitable for building a Regex to match
+    # against.  This String will not include any extensions.
+    #
+    #   urls.to_base  # => "http://www.example.com/search?"
+    #
+    def to_base
+      @base
+    end
+
+    def to_s
+      @weight.to_s + " " + @base
+    end
+
+  end
+
+
+  class UrlSession < RWB::Url
+    def initialize(weight, session, name, method='GET')
+      @weight = weight
+      @session = session
+      @urls = []
+      @name = name
+      @method = read_method(method)
+    end
+
+    def to_url
+      if @urls == []
+        @urls << @session
+        @urls.flatten!
+      end
+      @urls.shift
+    end
+    
+    def to_base
+      @name
+    end
+
+    def to_s
+      @weight.to_s + " " + @name
+    end
+  end
+
+
+end

data/lib/rwb/warmup.rb

@@ -0,0 +1,48 @@
+module RWB
+
+  class Runner
+    def warmup(num_runs = 1)
+      $stderr.puts "warming up with #{num_runs} runs"
+      for run in 1..num_runs
+        $stderr.print "#{run} "
+        @urls.urls.values.each do |url|
+          url = URI.parse(url.to_url)
+          @http.start(url.host, url.port) do |http|
+            http.request( Net::HTTP::Get.new(url) )
+          end
+        end
+      end
+      $stderr.puts
+    end
+
+    def rand_warmup(num_requests)
+      $stderr.puts "warming up with #{num_requests} requests"
+      checkpoint = num_requests/10
+      for run in 1..num_requests
+        if run % checkpoint == 0
+          $stderr.print "#{run} "
+        end
+        url = URI.parse(@urls.get_url.to_url)
+        @http.start(url.host, url.port) do |http|
+          http.request( Net::HTTP::Get.new(url) )
+        end
+      end
+      $stderr.puts
+    end
+
+    def spec_warmup(urls, num_runs=1)
+      $stderr.puts "warming up with #{num_runs} runs"
+      for run in 1..num_runs
+        $stderr.print "#{run} "
+        urls.each do |url|
+          url = URI.parse(url)
+          @http.start(url.host, url.port) do |http|
+            http.request( Net::HTTP::Get.new(url) )
+          end
+        end
+      end
+      $stderr.puts
+    end
+
+  end
+end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: rwb
 version: !ruby/object:Gem::Version 
-  version: 0.2.2
-date: 2007-01-31 00:00:00 -07:00
+  version: 0.2.3
+date: 2007-02-01 00:00:00 -07:00
 summary: Ruby Web Bench, a web performance and load testing framework
 require_paths: 
 - lib
@@ -28,11 +28,17 @@ cert_chain:
 authors: 
 - Pat Eyler
 files: 
+- test/test_rwb.rb
+- lib/rwb
+- lib/rwb.rb
+- lib/rwb/warmup.rb
+- lib/rwb/report.rb
+- lib/rwb/url.rb
+- lib/rwb/results.rb
 - NEWS
 - README
 - TODO
-- lib/rwb.rb
-- test/test_rwb.rb
+- Rakefile
 test_files: []
 
 rdoc_options: []