bigbench 0.0.3 → 0.0.4

data/lib/bigbench/post_processor/graphs.rb

@@ -0,0 +1,209 @@
+module BigBench
+  module PostProcessor
+    module Graphs
+      require 'gruff'
+      
+      DEFAULT = {
+        :folder               => "graphs_#{Time.now.to_i}",
+        :size                 => "1280x720",
+        :line_width           => 1,
+        :dot_radius           => 2,
+        :x_axis_label         => "seconds",
+        :y_axis_label         => nil,
+        :x_axis_label_amount  => 8,
+        :theme => {
+          :colors => ['#6D9CBE', '#A5C361', '#DA4939', '#FFC66D', '#D0D0FF', '#D1FFFD'],
+          :marker_color => 'white',
+          :font_color => 'white',
+          :background_colors => ['#2B2B2B', '#2B2B2B']
+        }
+      }
+      
+      @@line_charts, @@pie_charts = nil, nil
+      
+      # Encapsules the gruff line graph
+      class LineGraph
+        attr_reader :graph
+        attr_accessor :labels
+        
+        def initialize title, options = {}
+          @graph                = Gruff::Line.new(options[:size] || DEFAULT[:size])
+          @graph.title          = title
+          @graph.theme          = options[:theme]               || DEFAULT[:theme]
+          @graph.line_width     = options[:line_width]          || DEFAULT[:line_width]
+          @graph.dot_radius     = options[:dot_radius]          || DEFAULT[:dot_radius]
+          @graph.y_axis_label   = options[:y_axis_label]        || DEFAULT[:y_axis_label]
+          @graph.x_axis_label   = options[:x_axis_label]        || DEFAULT[:x_axis_label]
+          @x_axis_label_amount  = options[:x_axis_label_amount] || DEFAULT[:x_axis_label_amount]
+          @folder               = options[:folder]              || DEFAULT[:folder]
+          
+          Dir.mkdir @folder unless File.directory?(@folder)
+        end
+        
+        def add title, x, y
+          @x = x
+          @graph.data(title, y)
+        end
+        
+        def write file
+          @graph.labels = @labels || calculate_x_labels
+          puts "Writing Graph to #{File.join(@folder, @file = file)}"
+          @graph.write File.join(@folder, @file = file)
+        end
+        
+        def open
+          `open #{File.join(@folder, @file)}`
+        end
+        
+        private
+        
+        def calculate_x_labels
+          step = @x.size / @x_axis_label_amount
+          labels = {}
+          @x_axis_label_amount.times{ |i| element = i * step; labels[element] = element.to_s }
+          labels[@x.last] = @x.last.to_s
+          labels
+        end
+        
+      end
+      
+      # Encapsules the gruff pie graph
+      class PieGraph
+        attr_reader :graph
+        attr_accessor :labels
+        
+        def initialize title, options = {}
+          @graph                = Gruff::Pie.new(options[:size] || DEFAULT[:size])
+          @graph.title          = title
+          @graph.theme          = options[:theme]               || DEFAULT[:theme]
+          @folder               = options[:folder]              || DEFAULT[:folder]
+          
+          Dir.mkdir @folder unless File.directory?(@folder)
+        end
+        
+        def add title, percentage
+          @graph.data(title, percentage)
+        end
+        
+        def write file
+          puts "Writing Graph to #{File.join(@folder, @file = file)}"
+          @graph.write File.join(@folder, @file = file)
+        end
+        
+        def open
+          `open #{File.join(@folder, @file)}`
+        end
+        
+      end
+      
+      def self.run!(options)
+        
+        # Summary
+        line_charts.call "Summary", options
+        pie_charts.call  "Summary", options
+        
+        # Benchmarks
+        each_benchmark do |benchmark|
+          line_charts.call benchmark.name, options
+          pie_charts.call  benchmark.name, options
+        end
+        
+      end
+      
+      private
+      
+      def self.pie_charts
+        return @@pie_charts if @@pie_charts
+        @@pie_charts = proc do |name, options|
+          
+          file = name.gsub(' ', '_').downcase
+        
+          # HTTP Methods
+          methods = PieGraph.new "#{name} - HTTP Methods", options
+          appearing.methods.each{ |method| methods.add method.upcase, cluster(BigBench.config.duration).methods(method.to_sym).first }
+          methods.write "#{file}_methods.png"
+          
+          # HTTP Statuses
+          statuses = PieGraph.new "#{name} - HTTP Statuses", options
+          appearing.statuses.each{ |status| statuses.add status.to_s, cluster(BigBench.config.duration).statuses(status).first }
+          statuses.write "#{file}_statuses.png"
+          
+          # Request Paths
+          paths = PieGraph.new "#{name} - Request Paths", options
+          appearing.paths.each{ |path| paths.add path, cluster(BigBench.config.duration).paths(path).first }
+          paths.write "#{file}_paths.png"
+
+        end
+      end
+      
+      def self.line_charts
+        return @@line_charts if @@line_charts
+        @@line_charts = proc do |name, options|
+          
+          file = name.gsub(' ', '_').downcase
+        
+          # Durations
+          durations = LineGraph.new("#{name} - Durations", options.merge({ :y_axis_label => "milliseconds" }))
+          durations.add "Real",                 cluster.timesteps, cluster.durations.map{ |duration| duration.round(2) }
+          durations.add "Linear Regression",    cluster.timesteps, polynomial_regression.durations.y.map{ |duration| duration.round(2) }
+          durations.add "Quadratic Regression", cluster.timesteps, polynomial_regression(:degree => 2).durations.y.map{ |duration| duration.round(2) }
+          durations.add "Cubic Regression",     cluster.timesteps, polynomial_regression(:degree => 3).durations.y.map{ |duration| duration.round(2) }
+          durations.write "#{file}_durations.png"
+                  
+          # Durations Derivation
+          durations_derivations = LineGraph.new("#{name} - Durations 1. Derivations", options.merge({ :y_axis_label => "milliseconds" }))
+          durations_derivations.add "Linear Regression",    cluster.timesteps, polynomial_regression.durations.derivation(1)
+          durations_derivations.add "Quadratic Regression", cluster.timesteps, polynomial_regression(:degree => 2).durations.derivation(1)
+          durations_derivations.add "Cubic Regression",     cluster.timesteps, polynomial_regression(:degree => 3).durations.derivation(1)
+          durations_derivations.write "#{file}_durations_derivations.png"
+          
+          # Durations Distribution
+          durations_distribution = LineGraph.new("#{name} - Durations Distribution", options.merge({ :x_axis_label => "milliseconds", :y_axis_label => "probability" }))
+          durations_distribution.add "Normal Distribution with mean = #{normal_distribution.durations.mean.round(2)} sd = #{normal_distribution.durations.sd.round(2)}",    cluster.timesteps, normal_distribution.durations.y
+          durations_distribution.labels = {
+            0   => normal_distribution.durations.x[0].round(2).to_s,
+            19  => (normal_distribution.durations.mean - 2 * normal_distribution.durations.sd).round(2).to_s,
+            39  => (normal_distribution.durations.mean - normal_distribution.durations.sd).round(2).to_s, 
+            59  => normal_distribution.durations.mean.round(2).to_s,
+            79  => (normal_distribution.durations.mean + normal_distribution.durations.sd).round(2).to_s,
+            99  => (normal_distribution.durations.mean + 2 * normal_distribution.durations.sd).round(2).to_s,
+            119 => normal_distribution.durations.x[119].round(2).to_s 
+          }
+          durations_distribution.write "#{file}_durations_distribution.png"
+          
+          # Requests Distribution
+          requests_distribution = LineGraph.new("#{name} - Requests Distribution", options.merge({ :x_axis_label => "requests per second", :y_axis_label => "probability" }))
+          requests_distribution.add "Normal Distribution with mean = #{normal_distribution.requests.mean.round(2)} sd = #{normal_distribution.requests.sd.round(2)}",    cluster.timesteps, normal_distribution.requests.y.map{|y| y.round(2) }
+          requests_distribution.labels = {
+            0   => normal_distribution.requests.x[0].round(2).to_s,
+            19  => (normal_distribution.requests.mean - 2 * normal_distribution.requests.sd).round(2).to_s,
+            39  => (normal_distribution.requests.mean - normal_distribution.requests.sd).round(2).to_s, 
+            59  => normal_distribution.requests.mean.round(2).to_s,
+            79  => (normal_distribution.requests.mean + normal_distribution.requests.sd).round(2).to_s,
+            99  => (normal_distribution.requests.mean + 2 * normal_distribution.requests.sd).round(2).to_s,
+            119 => normal_distribution.requests.x[119].round(2).to_s 
+          }
+          requests_distribution.write "#{file}_requests_distribution.png"
+                  
+          # Requests
+          requests = LineGraph.new("#{name} - Requests", options.merge({ :y_axis_label => "requests" }))
+          requests.add "Real",                 cluster.timesteps, cluster.requests.map{ |duration| duration.round(2) }
+          requests.add "Linear Regression",    cluster.timesteps, polynomial_regression.requests.y.map{ |duration| duration.round(2) }
+          requests.add "Quadratic Regression", cluster.timesteps, polynomial_regression(:degree => 2).requests.y.map{ |duration| duration.round(2) }
+          requests.add "Cubic Regression",     cluster.timesteps, polynomial_regression(:degree => 3).requests.y.map{ |duration| duration.round(2) }
+          requests.write "#{file}_requests.png"
+                  
+          # Requests Derivation
+          requests_derivations = LineGraph.new("#{name} - Requests 1. Derivations", options.merge({ :y_axis_label => "requests" }))
+          requests_derivations.add "Linear Regression",    cluster.timesteps, polynomial_regression.requests.derivation(1)
+          requests_derivations.add "Quadratic Regression", cluster.timesteps, polynomial_regression(:degree => 2).requests.derivation(1)
+          requests_derivations.add "Cubic Regression",     cluster.timesteps, polynomial_regression(:degree => 3).requests.derivation(1)
+          requests_derivations.write "#{file}_requests_derivations.png"
+        
+        end
+      end
+      
+      
+    end
+  end
+end

data/lib/bigbench/post_processor/statistics.rb

@@ -2,7 +2,7 @@ module BigBench
   module PostProcessor
     module Statistics
       
-      def self.run!
+      def self.run!(options)
         calculate
         puts "\nBigBench Statistics"
         puts Hirb::Helpers::Table.render results, :fields => [:name, :value, :percent], :header_filter => :capitalize
@@ -14,56 +14,36 @@ module BigBench
         
         # Prepare Variables
         @total = {
-          :requests     => 0,
-          :duration     => 0,
-          :errors       => 0,
-          :status_codes => {},
-          :http_methods => {},
-          :url_paths    => {}
+          :requests     => cluster(BigBench.config.duration).requests.first,
+          :duration     => cluster(BigBench.config.duration).durations.first,
+          :errors       => cluster(BigBench.config.duration).statuses(404).first,
+          :status_codes => Hash[*appearing.statuses.map{  |status|  [status, cluster(BigBench.config.duration).statuses(status).first]        }.flatten],
+          :http_methods => Hash[*appearing.methods.map{   |method|  [method, cluster(BigBench.config.duration).methods(method.to_sym).first]  }.flatten],
+          :url_paths    => Hash[*appearing.paths.map{     |path|    [path,   cluster(BigBench.config.duration).paths(path).first]             }.flatten]
         }
         
+        
         @average = {
-          :requests_per_second      => 0,
-          :duration_in_ms           => 0,
-          :errors_in_percent        => 0,
-          :status_codes_in_percent  => {},
-          :http_methods_in_percent  => {},
-          :url_paths_in_percent     => {}
+          :requests_per_second      => statistics.requests.average,
+          :duration_in_ms           => statistics.durations.average,
+          :errors_in_percent        => (@total[:errors].to_f / @total[:requests].to_f) * 100,
+          :status_codes_in_percent  => Hash[*@total[:status_codes].map{ |status, count| [status, (count.to_f / @total[:requests].to_f * 100) ] }.flatten],
+          :http_methods_in_percent  => Hash[*@total[:http_methods].map{ |method, count| [method, (count.to_f / @total[:requests].to_f * 100) ] }.flatten],
+          :url_paths_in_percent     => Hash[*@total[:url_paths].map{    |path,   count| [path,   (count.to_f / @total[:requests].to_f * 100) ] }.flatten]
         }
         
+        require 'pp'
+        pp @average
+        
         @max = {
-          :duration_in_ms => 0
+          :duration_in_ms       => statistics.durations.max,
+          :requests_per_second  => statistics.requests.max
         }
         
         @min = {
-          :duration_in_ms => 9_999_999
-        }
-        
-        # Calculate Values
-        each_tracking do |tracking|
-          @total[:requests] += 1
-          @total[:duration] += tracking[:duration]
-          @total[:errors]   += 1 unless tracking[:status].to_i == 200
-          
-          @total[:status_codes][tracking[:status]] = 0 unless @total[:status_codes].key?(tracking[:status])
-          @total[:status_codes][tracking[:status]] += 1
-          
-          @total[:http_methods][tracking[:method]] = 0 unless @total[:http_methods].key?(tracking[:method])
-          @total[:http_methods][tracking[:method]] += 1
-          
-          @total[:url_paths][tracking[:path]] = 0 unless @total[:url_paths].key?(tracking[:path])
-          @total[:url_paths][tracking[:path]] += 1
-          
-          @max[:duration_in_ms] = tracking[:duration] if tracking[:duration] > @max[:duration_in_ms]
-          @min[:duration_in_ms] = tracking[:duration] if tracking[:duration] < @min[:duration_in_ms]
-        end
-        
-        @average[:requests_per_second]  = @total[:requests] / BigBench.config.duration
-        @average[:duration_in_ms]       = @total[:duration] / @total[:requests]
-        @average[:errors_in_percent]    = (@total[:errors].to_f   / @total[:requests].to_f) * 100
-        @total[:status_codes].each{ |status, count| @average[:status_codes_in_percent][status] = (count.to_f / @total[:requests].to_f) * 100 }
-        @total[:http_methods].each{ |method, count| @average[:http_methods_in_percent][method] = (count.to_f / @total[:requests].to_f) * 100 }
-        @total[:url_paths].each{    |path, count|   @average[:url_paths_in_percent][path]      = (count.to_f / @total[:requests].to_f) * 100 }      
+          :duration_in_ms       => statistics.durations.min,
+          :requests_per_second  => statistics.requests.min
+        }    
       end
       
       # Combines the calculated values to a list
@@ -77,25 +57,25 @@ module BigBench
           { 
             :name => "Total Errors:",
             :value => "#{number_with_delimiter @total[:errors]}",
-            :percent => "#{format "%3.1f", @average[:errors_in_percent]}%" 
+            :percent => "#{format "%3.1f", @average[:errors_in_percent].round(2)}%" 
           },
           {},
           { 
             :name => "Average Requests/Second:",
-            :value => "#{number_with_delimiter @average[:requests_per_second]} Requests/sec"
+            :value => "#{number_with_delimiter @average[:requests_per_second].round(2)} Requests/sec"
           },
           {
             :name => "Average Request Duration:",
-            :value => "#{number_with_delimiter @average[:duration_in_ms]} ms"
+            :value => "#{number_with_delimiter @average[:duration_in_ms].round(2)} ms"
           },
           {},
           {
             :name => "Max Request Duration:",
-            :value => "#{number_with_delimiter @max[:duration_in_ms]} ms"
+            :value => "#{number_with_delimiter @max[:duration_in_ms].round(2)} ms"
           },
           {
             :name => "Min Request Duration:",
-            :value => "#{number_with_delimiter @min[:duration_in_ms]} ms"
+            :value => "#{number_with_delimiter @min[:duration_in_ms].round(2)} ms"
           }
         ] + 
         add_list("Status Codes:", :status_codes, :status_codes_in_percent) +
@@ -112,8 +92,8 @@ module BigBench
         @total[element].map{ |element, count| 
           { 
             :name => "  #{element}", 
-            :value => "#{count}", 
-            :percent => "#{format "%3.1f", @average[element_percent][element]}%"
+            :value => "#{number_with_delimiter count}", 
+            :percent => "#{@average[element_percent][element].round(2)}%"
           }
         }
       end

data/lib/bigbench/version.rb

@@ -1,3 +1,3 @@
 module BigBench
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/spec/executor_spec.rb

@@ -77,4 +77,39 @@ describe BigBench::Executor do
     BigBench::Store.test.should be_nil
   end
   
+  it "should re-run the post processors from a receipt" do
+    
+    argv = ["run", "postprocessors", "spec/tests/with_post_processor.rb"]
+    BigBench::Executor.run!(argv)
+    
+    BigBench.benchmarks.size.should == 1
+    BigBench.benchmarks.each{ |benchmark| benchmark.runs.should == 0 }
+    
+    File.exist?(BigBench.config.output).should be_true
+    File.open(BigBench.config.output) do |file|
+      file.each_line{ |json| JSON.parse(json).is_a?(Hash).should be_true }
+    end
+    
+    BigBench.post_processors.each{ |processor| processor.runs.should == 1 }
+    
+  end
+  
+  it "should run a single post processor for a single test" do
+    
+    argv = ["run", "postprocessor", "spec/tests/with_post_processor.rb", "statistics"]
+    BigBench::Executor.run!(argv)
+    
+    BigBench.benchmarks.size.should == 1
+    BigBench.benchmarks.each{ |benchmark| benchmark.runs.should == 0 }
+    
+    File.exist?(BigBench.config.output).should be_true
+    File.open(BigBench.config.output) do |file|
+      file.each_line{ |json| JSON.parse(json).is_a?(Hash).should be_true }
+    end
+    
+    BigBench.post_processors.size.should == 1
+    BigBench.post_processors.first.runs.should == 1
+    
+  end
+  
 end

data/spec/helpers.rb

@@ -5,11 +5,25 @@ require 'net/http'
 require 'eventmachine'
 require 'em-http'
 
-module Helpers  
+module Helpers
+  
+  def validate_normal_distribution distribution
+    center_index, y = (distribution.x.size / 2), distribution.y
+    highest_value = y[center_index] + 1
+    
+    current_value = 0.0
+    y.each do |value|
+      value.should <= highest_value
+    end
+    
+    true
+  end
+  
 end
 
 RSpec.configure do |config|
   config.include Helpers
+  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.before(:each) { 
     BigBench::Configuration.reset!
     BigBench::Benchmark.reset!

data/spec/post_processor_spec.rb

@@ -6,7 +6,7 @@ describe BigBench::PostProcessor do
     lambda{ BigBench.post_process }.should raise_exception BigBench::PostProcessor::InvalidProcessor
   end
   
-  it "should allow to add and run post processor blocks blocks" do    
+  it "should allow to add and run post processor blocks" do    
     BigBench.post_process do
       "Finished test"
     end
@@ -16,7 +16,7 @@ describe BigBench::PostProcessor do
     end
     
     module BigBench::PostProcessor::Test
-      def self.run!
+      def self.run!(options)
         "Post Processor Module"
       end
     end
@@ -30,6 +30,21 @@ describe BigBench::PostProcessor do
     BigBench.post_processors[2].run!.should == "Post Processor Module"
   end
   
+  it "should allow to add and run post processor with options" do
+    
+    module BigBench::PostProcessor::Test
+      def self.run!(options)
+        options[:test]
+      end
+    end
+    
+    BigBench.post_process BigBench::PostProcessor::Test, :test => "hello"
+    
+    BigBench.post_processors.size.should == 1
+    
+    BigBench.post_processors[0].run!.should == "hello"
+  end
+  
   it "should run all post processors" do
     
     BigBench.post_process do
@@ -41,7 +56,7 @@ describe BigBench::PostProcessor do
     end
     
     module BigBench::PostProcessor::Test
-      def self.run!
+      def self.run!(options)
         "Post Processor Module"
       end
     end
@@ -56,7 +71,7 @@ describe BigBench::PostProcessor do
     BigBench.config.output = "spec/tests/result.ljson"
     
     module BigBench::PostProcessor::Test
-      def self.run!
+      def self.run!(options)
         counter = 0
         each_tracking { |tracking| counter += 1 }
         counter