request-log-analyzer 1.5.2 → 1.5.3

data/bin/request-log-analyzer

@@ -70,11 +70,11 @@ rescue CommandLine::Error => e
   puts "Usage: request-log-analyzer [LOGFILES*] <OPTIONS>"
   puts
   puts "Input options:"
-  puts "  --format <format>, -f:     Log file format. amazon_s3, apache, merb, mysql, rack or rails (default)."
   puts "  --after <date>             Only consider requests from <date> or later."
   puts "  --before <date>            Only consider requests before <date>."
-  puts "  --select <field> <value>   Only consider requests where <field> matches <value>."
+  puts "  --format <format>, -f:     Log file format. amazon_s3, apache, merb, mysql, rack or rails."
   puts "  --reject <field> <value>   Only consider requests where <field> does not match <value>."
+  puts "  --select <field> <value>   Only consider requests where <field> matches <value>."
   puts
   puts "Output options:"
   puts "  --boring, -b               Output reports without ASCII colors."
@@ -83,13 +83,17 @@ rescue CommandLine::Error => e
   puts "  --file <filename>          Redirect output to file."
   puts "  --mail <emailaddress>      Send report to an email address."
   puts "  --mailhost <server>        Use the given server as the SMTP server for sending email."
-  puts "  --output <format>          Output format. Supports 'html' and 'fixed_width' (default)."
+  puts "  --no-progress              Hide the progress bar."
+  puts "  --output <format>          Output format. Supports 'html' and 'fixed_width'."
+  puts "  --report-width <amount>    Width of ASCII report. Defaults to terminal width."
+  puts "  --report-amount <amount>   Maximum numer of results per report."
   puts "  --yaml <filename>          Dump the results in YAML format in the given file."
   puts
   puts "Examples:"
-  puts "  request-log-analyzer development.log"
-  puts "  request-log-analyzer -b mongrel.0.log mongrel.1.log mongrel.2.log "
+  puts "  request-log-analyzer production.log"
+  puts "  request-log-analyzer mongrel.0.log mongrel.1.log --output HTML --mail root@localhost"
   puts "  request-log-analyzer --format merb -d requests.db production.log"
+  puts "  request-log-analyzer mysql_slow_query.log --reject query /SQL_NO_CACHE/"
   puts
   puts "To install rake tasks in your Rails application, "
   puts "run the following command in your application's root directory:"

data/lib/request_log_analyzer.rb

@@ -11,7 +11,7 @@ module RequestLogAnalyzer
 
   # The current version of request-log-analyzer.
   # Do not change the value by hand; it will be updated automatically by the gem release script.
-  VERSION = "1.5.2"
+  VERSION = "1.5.3"
 
   # Loads constants in the RequestLogAnalyzer namespace using self.load_default_class_file(base, const)
   # <tt>const</tt>:: The constant that is not yet loaded in the RequestLogAnalyzer namespace. This should be passed as a string or symbol.

data/lib/request_log_analyzer/aggregator/echo.rb

@@ -11,7 +11,8 @@ module RequestLogAnalyzer::Aggregator
 
     # Display every parsed line immediately to the terminal
     def aggregate(request)
-      puts "\nRequest: " + request.lines.inspect
+      puts "\nRequest: \n" + request.lines.map { |l| 
+        "\t#{l[:lineno]}:#{l[:line_type]}: #{l.reject { |(k,v)| [:lineno, :line_type].include?(k) }.inspect}" }.join("\n")
     end
 
     # Capture all warnings during parsing

data/lib/request_log_analyzer/aggregator/summarizer.rb

@@ -26,44 +26,12 @@ module RequestLogAnalyzer::Aggregator
       def method_missing(tracker_method, *args)
         track(tracker_method, *args)
       end
-
-      # Track the frequency of a specific category
-      # <tt>category_field</tt> Field to track
-      # <tt>options</tt> options are passed to new frequency tracker
-      def frequency(category_field, options = {})
-        if category_field.kind_of?(Symbol)
-          track(:frequency, options.merge(:category => category_field))
-        elsif category_field.kind_of?(Hash)
-          track(:frequency, category_field.merge(options))
-        end
-      end
-
-      # Track the duration of a specific category
-      # <tt>duration_field</tt> Field to track
-      # <tt>options</tt> options are passed to new frequency tracker
-      def duration(duration_field, options = {})
-        if duration_field.kind_of?(Symbol)
-          track(:duration, options.merge(:duration => duration_field))
-        elsif duration_field.kind_of?(Hash)
-          track(:duration, duration_field.merge(options))
-        end
-      end
-
-      # Track the frequency of a specific category
-      # <tt>category_field</tt> Field to track
-      # <tt>options</tt> options are passed to new frequency tracker
-      def count(category_field, options = {})
-        if category_field.kind_of?(Symbol)
-          track(:count, options.merge(:category => category_field))
-        elsif category_field.kind_of?(Hash)
-          track(:count, category_field.merge(options))
-        end
-      end
-
+      
       # Helper function to initialize a tracker and add it to the tracker array.
       # <tt>tracker_class</tt> The class to include
       # <tt>optiont</tt> The options to pass to the trackers.
-      def track(tracker_klass, options = {})
+      def track(tracker_klass, value_field = {}, other_options = {})
+        options = value_field.kind_of?(Symbol) ? other_options.merge(:value => value_field) : value_field.merge(other_options) 
         tracker_klass = RequestLogAnalyzer::Tracker.const_get(RequestLogAnalyzer::to_camelcase(tracker_klass)) if tracker_klass.kind_of?(Symbol)
         @trackers << tracker_klass.new(options)
       end
@@ -125,7 +93,7 @@ module RequestLogAnalyzer::Aggregator
     def report(output)
       report_header(output)
       if source.parsed_requests > 0
-        @trackers.each { |tracker| tracker.report(output) }
+        @trackers.each { |tracker| output.report_tracker(tracker) }
       else
         output.puts
         output.puts('There were no requests analyzed.')
@@ -156,7 +124,7 @@ module RequestLogAnalyzer::Aggregator
       if has_log_ordering_warnings?
         output.title("Parse warnings")
 
-        output.puts "Parseable lines were encountered without a header line before it. It"
+        output.puts "Parsable lines were encountered without a header line before it. It"
         output.puts "could be that logging is not setup correctly for your application."
         output.puts "Visit this website for logging configuration tips:"
         output.puts output.link("http://github.com/wvanbergen/request-log-analyzer/wikis/configure-logging")

data/lib/request_log_analyzer/controller.rb

@@ -53,8 +53,9 @@ module RequestLogAnalyzer
       
       # Handle output format casing
       if options[:output].class == String
-        options[:output] = 'HTML' if options[:output] == 'html'
-        options[:output] = 'FixedWidth' if options[:output] == 'fixedwidth' || options[:output] == 'fixed_width'
+        options[:output] = 'FancyHTML'  if options[:output] =~ /^fancy_?html$/i
+        options[:output] = 'HTML'       if options[:output] =~ /^html$/i
+        options[:output] = 'FixedWidth' if options[:output] =~ /^fixed_?width$/i
       end
       
       # Register sources
@@ -142,7 +143,7 @@ module RequestLogAnalyzer
       # Set the output class
       output_args   = {}
       output_object = nil
-      if options[:output].is_a? Class
+      if options[:output].is_a?(Class)
         output_class = options[:output]
       else
         output_class = RequestLogAnalyzer::Output::const_get(options[:output])

data/lib/request_log_analyzer/file_format.rb

@@ -88,10 +88,77 @@ module RequestLogAnalyzer::FileFormat
 
     # As Apache matches several simular formats, subtracting 1 will make a specific matcher have a higher score
     score -= 1 if parser.file_format.class == RequestLogAnalyzer::FileFormat::Apache
-    
+
     score
   end
 
+  # This module contains some methods to construct regular expressions for log fragments
+  # that are commonly used, like IP addresses and timestamp.
+  #
+  # You need to extend (or include in an unlikely case) this module in your file format 
+  # to use these regular expression constructors.
+  module CommonRegularExpressions
+
+    TIMESTAMP_PARTS = {
+      'a' => '(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)',
+      'b' => '(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)',
+      'y' => '\d{2}', 'Y' => '\d{4}', 'm' => '\d{2}', 'd' => '\d{2}',
+      'H' => '\d{2}', 'M' => '\d{2}', 'S' => '\d{2}', 'k' => '(?:\d| )\d',
+      'z' => '(?:[+-]\d{4}|[A-Z]{3,4})',
+      'Z' => '(?:[+-]\d{4}|[A-Z]{3,4})',
+      '%' => '%'
+    }
+
+    # Create a regular expression for a timestamp, generated by a strftime call.
+    # Provide the format string to construct a matching regular expression.
+    # Set blank to true to allow and empty string, or set blank to a string to set
+    # a substitute for the nil value.
+    def timestamp(format_string, blank = false)
+      regexp = ''
+      format_string.scan(/([^%]*)(?:%([A-Za-z%]))?/) do |literal, variable|
+        regexp << Regexp.quote(literal)
+        if variable
+          if TIMESTAMP_PARTS.has_key?(variable)
+            regexp << TIMESTAMP_PARTS[variable]
+          else
+            raise "Unknown variable: %#{variable}"
+          end
+        end
+      end
+
+      regexp = Regexp.new(regexp)
+      return case blank
+        when String then Regexp.union(regexp, Regexp.new(Regexp.quote(blank)))
+        when true   then Regexp.union(regexp, //)
+        else regexp
+      end
+    end
+
+    # Construct a regular expression to parse IPv4 and IPv6 addresses.
+    #
+    # Allow nil values if the blank option is given. This can be true to 
+    # allow an empty string or to a string substitute for the nil value.
+    def ip_address(blank = false)
+
+      # IP address regexp copied from Resolv::IPv4 and Resolv::IPv6, 
+      # but adjusted to work for the purpose of request-log-analyzer.
+      ipv4_regexp                     = /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/
+      ipv6_regex_8_hex                = /(?:[0-9A-Fa-f]{1,4}:){7}[0-9A-Fa-f]{1,4}/
+      ipv6_regex_compressed_hex       = /(?:(?:[0-9A-Fa-f]{1,4}(?::[0-9A-Fa-f]{1,4})*)?)::(?:(?:[0-9A-Fa-f]{1,4}(?::[0-9A-Fa-f]{1,4})*)?)/
+      ipv6_regex_6_hex_4_dec          = /(?:(?:[0-9A-Fa-f]{1,4}:){6})#{ipv4_regexp}/
+      ipv6_regex_compressed_hex_4_dec = /(?:(?:[0-9A-Fa-f]{1,4}(?::[0-9A-Fa-f]{1,4})*)?)::(?:(?:[0-9A-Fa-f]{1,4}:)*)#{ipv4_regexp}/
+      ipv6_regexp                     = Regexp.union(ipv6_regex_8_hex, ipv6_regex_compressed_hex, ipv6_regex_6_hex_4_dec, ipv6_regex_compressed_hex_4_dec)
+
+      # Allow the field to be blank if this option is given. This can be true to 
+      # allow an empty string or a string alternative for the nil value.
+      ip_regexp = case blank
+        when String then Regexp.union(ipv4_regexp, ipv6_regexp, Regexp.new(Regexp.quote(blank)))
+        when true   then Regexp.union(ipv4_regexp, ipv6_regexp, //)
+        else             Regexp.union(ipv4_regexp, ipv6_regexp)
+      end
+    end
+  end
+
   # Base class for all log file format definitions. This class provides functions for subclasses to
   # define their LineDefinitions and to define a summary report.
   #

data/lib/request_log_analyzer/file_format/amazon_s3.rb

@@ -5,11 +5,13 @@ module RequestLogAnalyzer::FileFormat
   # Access logs are disabled by default on Amazon S3. To enable logging, see
   # http://docs.amazonwebservices.com/AmazonS3/latest/index.html?ServerLogs.html
   class AmazonS3 < Base
+    
+    extend CommonRegularExpressions
 
     line_definition :access do |line|
       line.header = true
       line.footer = true
-      line.regexp = /^([^\ ]+) ([^\ ]+) \[(\d{2}\/[A-Za-z]{3}\/\d{4}.\d{2}:\d{2}:\d{2})(?: .\d{4})?\] ([\d\.:]+) ([^\ ]+) ([^\ ]+) (\w+(?:\.\w+)*) ([^\ ]+) "([^"]+)" (\d+) ([^\ ]+) (\d+) (\d+) (\d+) (\d+) "([^"]+)" "([^"]+)"/
+      line.regexp = /^([^\ ]+) ([^\ ]+) \[(#{timestamp('%d/%b/%Y:%H:%M:%S %z')})?\] (#{ip_address}) ([^\ ]+) ([^\ ]+) (\w+(?:\.\w+)*) ([^\ ]+) "([^"]+)" (\d+) ([^\ ]+) (\d+) (\d+) (\d+) (\d+) "([^"]+)" "([^"]+)"/
       line.captures << { :name => :bucket_owner,    :type => :string } <<
                        { :name => :bucket,          :type => :string } <<
                        { :name => :timestamp,       :type => :timestamp } <<

data/lib/request_log_analyzer/file_format/apache.rb

@@ -14,6 +14,8 @@ module RequestLogAnalyzer::FileFormat
   # command line option.
   class Apache < Base
 
+    extend CommonRegularExpressions
+
     # A hash of predefined Apache log formats
     LOG_FORMAT_DEFAULTS = {
       :common   => '%h %l %u %t "%r" %>s %b',
@@ -23,17 +25,20 @@ module RequestLogAnalyzer::FileFormat
       :agent    => '%{User-agent}i'
     }
 
+    # I have encountered two timestamp types, with timezone and without. Parse both.
+    APACHE_TIMESTAMP = Regexp.union(timestamp('%d/%b/%Y:%H:%M:%S %z'), timestamp('%d/%b/%Y %H:%M:%S'))
+
     # A hash that defines how the log format directives should be parsed.
     LOG_DIRECTIVES = {
       '%' => { :regexp => '%', :captures => [] },
       'h' => { :regexp => '([A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)+)',  :captures => [{:name => :remote_host, :type => :string}] },
-      'a' => { :regexp => '([\d\.:]+)', :captures => [{:name => :remote_ip, :type => :string}] },
+      'a' => { :regexp => "(#{ip_address})", :captures => [{:name => :remote_ip, :type => :string}] },
       'b' => { :regexp => '(\d+|-)', :captures => [{:name => :bytes_sent, :type => :traffic}] },
       'c' => { :regexp => '(\+|\-|\X)', :captures => [{:name => :connection_status, :type => :integer}] },
       'D' => { :regexp => '(\d+|-)', :captures => [{:name => :duration, :type => :duration, :unit => :musec}] },
       'l' => { :regexp => '([\w-]+)', :captures => [{:name => :remote_logname, :type => :nillable_string}] },
       'T' => { :regexp => '((?:\d+(?:\.\d+))|-)', :captures => [{:name => :duration, :type => :duration, :unit => :sec}] },
-      't' => { :regexp => '\[(\d{2}\/[A-Za-z]{3}\/\d{4}.\d{2}:\d{2}:\d{2})(?: .\d{4})?\]', :captures => [{:name => :timestamp, :type => :timestamp}] },
+      't' => { :regexp => "\\[(#{APACHE_TIMESTAMP})?\\]", :captures => [{:name => :timestamp, :type => :timestamp}] },
       's' => { :regexp => '(\d{3})', :captures => [{:name => :http_status, :type => :integer}] },
       'u' => { :regexp => '(\w+|-)', :captures => [{:name => :user, :type => :nillable_string}] },
       'U' => { :regexp => '(\/\S*)', :captures => [{:name => :path, :type => :string}] },

data/lib/request_log_analyzer/file_format/merb.rb

@@ -5,11 +5,13 @@ module RequestLogAnalyzer::FileFormat
   # the different request durations that can be used for analysis.
   class Merb < Base
 
+    extend CommonRegularExpressions
+
     # ~ Started request handling: Fri Aug 29 11:10:23 +0200 2008
     line_definition :started do |line|
       line.header = true
       line.teaser = /Started request handling\:/
-      line.regexp = /Started request handling\:\ (.+)/
+      line.regexp = /Started request handling\:\ (#{timestamp('%a %b %d %H:%M:%S %z %Y')})/
       line.captures << { :name => :timestamp, :type => :timestamp }
     end
 

data/lib/request_log_analyzer/file_format/mysql.rb

@@ -2,17 +2,19 @@ module RequestLogAnalyzer::FileFormat
 
   class Mysql < Base
 
+    extend CommonRegularExpressions
+
     line_definition :time do |line|
       line.header = :alternative
       line.teaser = /\# Time: /
-      line.regexp = /\# Time: (\d{6}\s+\d{1,2}:\d{2}:\d{2})/
+      line.regexp = /\# Time: (#{timestamp('%y%m%d %k:%M:%S')})/
       line.captures << { :name => :timestamp, :type => :timestamp }
     end
 
     line_definition :user_host do |line|
       line.header = :alternative
       line.teaser = /\# User\@Host\: /
-      line.regexp = /\# User\@Host\: ([\w-]+)\[[\w-]+\] \@ ([\w\.-]*) \[([\d\.]*)\]/
+      line.regexp = /\# User\@Host\: ([\w-]+)\[[\w-]+\] \@ ([\w\.-]*) \[(#{ip_address(true)})\]/
       line.captures << { :name => :user, :type => :string } << 
                        { :name => :host, :type => :string } <<
                        { :name => :ip,   :type => :string }
@@ -53,9 +55,12 @@ module RequestLogAnalyzer::FileFormat
       analyze.frequency :user, :title => "Users with most queries"
       analyze.duration :query_time, :category => PER_USER, :title => 'Query time per user'
       analyze.duration :query_time, :category => PER_USER_QUERY, :title => 'Query time'
-      # => analyze.duration :lock_time,  :category => PER_USER_QUERY, :title => 'Lock time'
-      analyze.count :category => PER_USER_QUERY, :title => "Rows examined", :field => :rows_examined
-      analyze.count :category => PER_USER_QUERY, :title => "Rows sent",     :field => :rows_sent
+      
+      analyze.duration :lock_time,  :category => PER_USER_QUERY, :title => 'Lock time',
+                       :if => lambda { |request| request[:lock_time] > 0.0 }
+      
+      analyze.numeric_value :rows_examined, :category => PER_USER_QUERY, :title => "Rows examined"
+      analyze.numeric_value :rows_sent,     :category => PER_USER_QUERY, :title => "Rows sent"
     end
   
     class Request < RequestLogAnalyzer::Request

data/lib/request_log_analyzer/file_format/rack.rb

@@ -5,7 +5,5 @@ module RequestLogAnalyzer::FileFormat
     def self.create(*args)
       super(:rack, *args)
     end
-
   end
-
-end
+end

data/lib/request_log_analyzer/file_format/rails.rb

@@ -7,6 +7,8 @@ module RequestLogAnalyzer::FileFormat
   # method as first argument.
   class Rails < Base
 
+    extend CommonRegularExpressions
+
     # Creates a Rails FileFormat instance.
     #
     # The lines that will be parsed can be defined by the argument to this function, 
@@ -64,11 +66,11 @@ module RequestLogAnalyzer::FileFormat
       end
 
       if lines.has_key?(:rendered)
-        analyze.duration :render_duration, :category => :render_file, :multiple_per_request => true, :title => 'Partial rendering duration'
+        analyze.duration :render_duration, :category => :render_file, :multiple => true, :title => 'Partial rendering duration'
       end
 
       if lines.has_key?(:query_executed)
-        analyze.duration :query_duration, :category => :query_sql, :multiple_per_request => true, :title => 'Query duration'
+        analyze.duration :query_duration, :category => :query_sql, :multiple => true, :title => 'Query duration'
       end
       
       return analyze.trackers + report_definer.trackers
@@ -86,7 +88,7 @@ module RequestLogAnalyzer::FileFormat
     LINE_DEFINITIONS = {
       :processing => RequestLogAnalyzer::LineDefinition.new(:processing, :header => true,
             :teaser   => /Processing /,
-            :regexp   => /Processing ((?:\w+::)?\w+)#(\w+)(?: to (\w+))? \(for ([\d\.:]+) at (\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d)\) \[([A-Z]+)\]/,
+            :regexp   => /Processing ((?:\w+::)*\w+)#(\w+)(?: to (\w+))? \(for (#{ip_address}) at (#{timestamp('%Y-%m-%d %H:%M:%S')})\) \[([A-Z]+)\]/,
             :captures => [{ :name => :controller, :type  => :string },
                           { :name => :action,     :type  => :string },
                           { :name => :format,     :type  => :string, :default => 'html' },
@@ -170,7 +172,5 @@ module RequestLogAnalyzer::FileFormat
         sql.gsub(/\b\d+\b/, ':int').gsub(/`([^`]+)`/, '\1').gsub(/'[^']*'/, ':string').rstrip
       end
     end
-
   end
-
 end

data/lib/request_log_analyzer/output.rb

@@ -56,6 +56,10 @@ module RequestLogAnalyzer::Output
       @options = options
       @style   = options[:style] || { :cell_separator => true, :table_border => false }
     end
+    
+    def report_tracker(tracker)
+      tracker.report(self)
+    end
 
     # Apply a style block.. with style :)
     def with_style(temp_style = {})

data/lib/request_log_analyzer/output/fancy_html.rb

@@ -0,0 +1,31 @@
+begin 
+  require 'rubygems'
+  require 'gchart'
+rescue LoadError
+  $stderr.puts "The FancyHTML output format requires the googlechart gem:"
+  $stderr.puts "  (sudo) gem install googlecharts"
+end
+
+module RequestLogAnalyzer::Output
+  
+  class FancyHTML < HTML
+    
+    # Load class files if needed
+    def self.const_missing(const)
+      RequestLogAnalyzer::load_default_class_file(self, const)
+    end
+    
+    def report_tracker(tracker)
+      case tracker
+      when RequestLogAnalyzer::Tracker::HourlySpread then report_hourly_spread(tracker)
+      else tracker.report(self)
+      end
+    end
+    
+    def report_hourly_spread(tracker)
+      title tracker.title
+      puts tag(:img, nil, :width => '700', :height => '120', :src =>
+          Gchart.sparkline(:data => tracker.hour_frequencies, :size => '700x120', :line_colors => '0077CC'))
+    end
+  end
+end

data/lib/request_log_analyzer/tracker.rb

@@ -98,109 +98,4 @@ module RequestLogAnalyzer::Tracker
       nil
     end
   end
-  
-  module StatisticsTracking
-    
-    # Update sthe running calculation of statistics with the newly found numeric value.
-    # <tt>category</tt>:: The category for which to update the running statistics calculations
-    # <tt>number</tt>:: The numeric value to update the calculations with.
-    def update_statistics(category, number)
-      @categories[category] ||= {:hits => 0, :sum => 0, :mean => 0.0, :sum_of_squares => 0.0, :min => number, :max => number }
-      delta = number - @categories[category][:mean]
-
-      @categories[category][:hits]           += 1
-      @categories[category][:mean]           += (delta / @categories[category][:hits])
-      @categories[category][:sum_of_squares] += delta * (number - @categories[category][:mean])
-      @categories[category][:sum]            += number
-      @categories[category][:min]             = number if number < @categories[category][:min]
-      @categories[category][:max]             = number if number > @categories[category][:max]
-    end
-    
-    # Get the number of hits of a specific category.
-    # <tt>cat</tt> The category
-    def hits(cat)
-      @categories[cat][:hits]
-    end
-
-    # Get the total duration of a specific category.
-    # <tt>cat</tt> The category
-    def sum(cat)
-      @categories[cat][:sum]
-    end
-
-    # Get the minimal duration of a specific category.
-    # <tt>cat</tt> The category
-    def min(cat)
-      @categories[cat][:min]
-    end
-
-    # Get the maximum duration of a specific category.
-    # <tt>cat</tt> The category
-    def max(cat)
-      @categories[cat][:max]
-    end
-
-    # Get the average duration of a specific category.
-    # <tt>cat</tt> The category
-    def mean(cat)
-      @categories[cat][:mean]
-    end
-
-    # Get the standard deviation of the duration of a specific category.
-    # <tt>cat</tt> The category
-    def stddev(cat)
-      Math.sqrt(variance(cat))
-    end
-
-    # Get the variance of the duration of a specific category.
-    # <tt>cat</tt> The category
-    def variance(cat)
-      return 0.0 if @categories[cat][:hits] <= 1
-      (@categories[cat][:sum_of_squares] / (@categories[cat][:hits] - 1))
-    end
-
-    # Get the average duration of a all categories.
-    def mean_overall
-      sum_overall / hits_overall
-    end
-
-    # Get the cumlative duration of a all categories.
-    def sum_overall
-      @categories.inject(0.0) { |sum, (name, cat)| sum + cat[:sum] }
-    end
-
-    # Get the total hits of a all categories.
-    def hits_overall
-      @categories.inject(0) { |sum, (name, cat)| sum + cat[:hits] }
-    end
-    
-    # Return categories sorted by a given key.
-    # <tt>by</tt> The key to sort on. This parameter can be omitted if a sorting block is provided instead
-    def sorted_by(by = nil)
-      if block_given?
-        categories.sort { |a, b| yield(b[1]) <=> yield(a[1]) }
-      else
-        categories.sort { |a, b| send(by, b[0]) <=> send(by, a[0]) }
-      end
-    end
-    
-    # Returns the column header for a statistics table to report on the statistics result
-    def statistics_header(options)
-      [
-        {:title => options[:title], :width => :rest},
-        {:title => 'Hits',   :align => :right, :highlight => (options[:highlight] == :hits),   :min_width => 4},
-        {:title => 'Sum',    :align => :right, :highlight => (options[:highlight] == :sum),    :min_width => 6},
-        {:title => 'Mean',   :align => :right, :highlight => (options[:highlight] == :mean),   :min_width => 6},
-        {:title => 'StdDev', :align => :right, :highlight => (options[:highlight] == :stddev), :min_width => 6},
-        {:title => 'Min',    :align => :right, :highlight => (options[:highlight] == :min),    :min_width => 6},
-        {:title => 'Max',    :align => :right, :highlight => (options[:highlight] == :max),    :min_width => 6}
-      ]
-    end
-    
-    # Returns a row of statistics information for a report table, given a category
-    def statistics_row(cat)
-      [cat, hits(cat), display_value(sum(cat)), display_value(mean(cat)), display_value(stddev(cat)),
-                display_value(min(cat)), display_value(max(cat))]
-    end
-  end
 end