request-log-analyzer 1.1.2 → 1.2.0

data/lib/request_log_analyzer/filter/timespan.rb

@@ -8,9 +8,15 @@ module RequestLogAnalyzer::Filter
    
     attr_reader :before, :after
    
+    def initialize(file_format, options = {})
+      super(file_format, options)
+      setup_filter
+    end
+   
+   
     # Convert the timestamp to the correct formats for quick timestamp comparisons.
     # These are stored in the before and after attr_reader fields.
-    def prepare
+    def setup_filter
       @after  = @options[:after].strftime('%Y%m%d%H%M%S').to_i  if options[:after]     
       @before = @options[:before].strftime('%Y%m%d%H%M%S').to_i if options[:before]
     end

data/lib/request_log_analyzer/filter.rb

@@ -23,10 +23,6 @@ module RequestLogAnalyzer::Filter
       register_file_format(format)
     end
     
-    # Initialize the filter
-    def prepare
-    end
-    
     # Return the request if the request should be kept.
     # Return nil otherwise.
     def filter(request)

data/lib/request_log_analyzer/line_definition.rb

@@ -12,6 +12,10 @@ module RequestLogAnalyzer
       def initialize
         @line_definitions = {}
       end
+
+      def initialize_copy(other)
+        @line_definitions = other.line_definitions.dup
+      end
       
       def method_missing(name, *args, &block)
         if block_given?
@@ -33,7 +37,7 @@ module RequestLogAnalyzer
       @captures = []
       definition.each { |key, value| self.send("#{key.to_s}=".to_sym, value) }
     end
-    
+        
     def self.define(name, &block)
       definition = self.new(name)
       yield(definition) if block_given?
@@ -73,7 +77,13 @@ module RequestLogAnalyzer
     def convert_captured_values(values, request)
       value_hash = {}
       captures.each_with_index do |capture, index|
-        value_hash[capture[:name]] ||= request.convert_value(values[index], capture)
+        converted = request.convert_value(values[index], capture)
+        value_hash[capture[:name]] ||= converted
+        if converted.kind_of?(Hash) && capture[:provides].kind_of?(Hash)
+          capture[:provides].each do |name, type|
+            value_hash[name] ||= request.convert_value(converted[name], { :type => type })
+          end          
+        end
       end
       return value_hash
     end

data/lib/request_log_analyzer/output/fixed_width.rb

@@ -1,5 +1,8 @@
+# coding: utf-8
 module RequestLogAnalyzer::Output
   
+  # Fixed Width output class.
+  # Outputs a fixed width ASCII or UF8 report.
   class FixedWidth < Base
   
     module Monochrome
@@ -126,8 +129,12 @@ module RequestLogAnalyzer::Output
       end
      
       if column_widths.include?(nil)
+        fill_column = columns[column_widths.index(nil)]
         width_left = options[:width] - ((columns.length - 1) * (style[:cell_separator] ? 3 : 1)) - column_widths.compact.inject(0) { |sum, col| sum + col}
-        column_widths[column_widths.index(nil)] = width_left
+        column_widths[column_widths.index(nil)] = case fill_column[:type]
+          when :ratio; width_left # max out
+          else;        [width_left, fill_column[:actual_width]].min
+        end
       end
     
       # Print table header
@@ -156,14 +163,18 @@ module RequestLogAnalyzer::Output
                 bar << colorize(characters[:block] * (width.to_f * (row[index].to_f - column[:treshold])).round, :red) 
                 row_values.push(bar) 
               else
+                # Create a bar by combining block characters
                 row_values.push(characters[:block] * (width.to_f * row[index].to_f).round) 
               end
             else
+              # Too few characters for a ratio bar. Display nothing
               row_values.push('')
             end
           else
-            alignment = (columns[index][:align] == :right ? '' : '-')        
-            row_values.push("%#{alignment}#{width}s" % row[index].to_s[0...width])
+            alignment = (columns[index][:align] == :right ? '' : '-')
+            cell_value = "%#{alignment}#{width}s" % row[index].to_s[0...width]
+            cell_value = colorize(cell_value, :bold, :brown) if columns[index][:highlight]
+            row_values.push(cell_value)
           end
         end
         puts row_values.join(style[:cell_separator] ? " #{characters[:vertical_line]} " : ' ')      

data/lib/request_log_analyzer/output/html.rb

@@ -1,5 +1,6 @@
 module RequestLogAnalyzer::Output
   
+  # HTML Output class. Generated a HTML-formatted report, including CSS.
   class HTML < Base
   
     # def initialize(io, options = {})

data/lib/request_log_analyzer/request.rb

@@ -30,6 +30,12 @@ module RequestLogAnalyzer
         end
       end
       
+      def convert_eval(value, capture_definition)
+        eval(value).inject({}) { |h, (k, v)| h[k.to_sym] = v; h} 
+      rescue SyntaxError
+        nil
+      end
+      
       # Slow default method to parse timestamps
       def convert_timestamp(value, capture_definition)
         DateTime.parse(value).strftime('%Y%m%d%H%M%S').to_i unless value.nil?

data/lib/request_log_analyzer/source/database.rb

@@ -0,0 +1,76 @@
+require 'rubygems'
+require 'activerecord'
+
+module RequestLogAnalyzer::Source
+  
+  # Active Resource hook
+  class CompletedLine < ActiveRecord::Base
+    def convert(file_format)
+      RequestLogAnalyzer::Request.create(file_format, self.attributes)
+    end
+  end
+
+  # The Database class gets log data from the database.
+  class Database < Base
+
+    attr_reader :source_files
+    attr_reader :requests
+
+    # Initializes the log file parser instance.
+    # It will apply the language specific FileFormat module to this instance. It will use the line
+    # definitions in this module to parse any input that it is given (see parse_io).
+    #
+    # <tt>format</tt>:: The current file format instance
+    # <tt>options</tt>:: A hash of options that are used by the parser
+    def initialize(format, options = {})      
+      @line_definitions = {}
+      @options          = options
+      @source_files     = options[:source_files]
+      @parsed_requests  = 0
+      @requests         = []
+      
+      self.register_file_format(format)
+    end
+    
+    # Reads the input, which can either be a file, sequence of files or STDIN to parse
+    # lines specified in the FileFormat. This lines will be combined into Request instances,
+    # that will be yielded. The actual parsing occurs in the parse_io method.
+    # <tt>options</tt>:: A Hash of options that will be pased to parse_io.
+    def each_request(options = {}, &block) # :yields: request
+      ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => @source_files)
+
+      @progress_handler.call(:started, @source_files) if @progress_handler
+        RequestLogAnalyzer::Source::CompletedLine.find(:all).each do |request|
+          @parsed_requests += 1
+          yield(request.convert(self.file_format))
+        end
+      
+      @progress_handler.call(:finished, @source_files) if @progress_handler
+    end
+
+    # Add a block to this method to install a progress handler while parsing.
+    # <tt>proc</tt>:: The proc that will be called to handle progress update messages
+    def progress=(proc)
+      @progress_handler = proc
+    end
+
+    # Add a block to this method to install a warning handler while parsing,
+    # <tt>proc</tt>:: The proc that will be called to handle parse warning messages    
+    def warning=(proc)
+      @warning_handler = proc
+    end
+
+    # This method is called by the parser if it encounteres any parsing problems.
+    # It will call the installed warning handler if any. 
+    #
+    # By default, RequestLogAnalyzer::Controller will install a warning handler 
+    # that will pass the warnings to each aggregator so they can do something useful
+    # with it.
+    #
+    # <tt>type</tt>:: The warning type (a Symbol)
+    # <tt>message</tt>:: A message explaining the warning
+    def warn(type, message)
+      @warning_handler.call(type, message, @current_io.lineno) if @warning_handler
+    end
+  end
+end

data/lib/request_log_analyzer/source/log_parser.rb

@@ -7,15 +7,24 @@ module RequestLogAnalyzer::Source
   # De order in which lines occur is used to combine lines to a single request. If these lines 
   # are mixed, requests cannot be combined properly. This can be the case if data is written to 
   # the log file simultaneously by different mongrel processes. This problem is detected by the 
-  # parser, but the requests that are mixed up cannot be parsed. It will emit warnings when this 
-  # occurs.
+  # parser. It will emit warnings when this occurs. LogParser supports multiple parse strategies 
+  # that deal differently with this problem.
   class LogParser < Base
 
+    # The default parse strategy that will be used to parse the input.
+    DEFAULT_PARSE_STRATEGY = 'assume-correct'
+    
+    # All available parse strategies.
+    PARSE_STRATEGIES = ['cautious', 'assume-correct']
+
     attr_reader :source_files
 
-    # Initializes the parser instance.
+    # Initializes the log file parser instance.
     # It will apply the language specific FileFormat module to this instance. It will use the line
-    # definitions in this module to parse any input.
+    # definitions in this module to parse any input that it is given (see parse_io).
+    #
+    # <tt>format</tt>:: The current file format instance
+    # <tt>options</tt>:: A hash of options that are used by the parser
     def initialize(format, options = {})      
       @line_definitions = {}
       @options          = options
@@ -25,13 +34,18 @@ module RequestLogAnalyzer::Source
       @skipped_requests = 0
       @current_io       = nil
       @source_files     = options[:source_files]
-
-      # install the file format module (see RequestLogAnalyzer::FileFormat)
-      # and register all the line definitions to the parser
+      
+      @options[:parse_strategy] ||= DEFAULT_PARSE_STRATEGY
+      raise "Unknown parse strategy" unless PARSE_STRATEGIES.include?(@options[:parse_strategy])
+      
       self.register_file_format(format)
     end
     
-    def each_request(options = {}, &block)
+    # Reads the input, which can either be a file, sequence of files or STDIN to parse
+    # lines specified in the FileFormat. This lines will be combined into Request instances,
+    # that will be yielded. The actual parsing occurs in the parse_io method.
+    # <tt>options</tt>:: A Hash of options that will be pased to parse_io.
+    def each_request(options = {}, &block) # :yields: request
       
       case @source_files
       when IO;     
@@ -46,35 +60,46 @@ module RequestLogAnalyzer::Source
       end
     end
 
-    # Parses a list of consequent files of the same format
-    def parse_files(files, options = {}, &block)
+    # Parses a list of subsequent files of the same format, by calling parse_file for every
+    # file in the array.
+    # <tt>files</tt>:: The Array of files that should be parsed
+    # <tt>options</tt>:: A Hash of options that will be pased to parse_io.
+    def parse_files(files, options = {}, &block) # :yields: request
       files.each { |file| parse_file(file, options, &block) }
     end
 
-    # Parses a file. 
-    # Creates an IO stream for the provided file, and sends it to parse_io for further handling
+    # Parses a log file. Creates an IO stream for the provided file, and sends it to parse_io for
+    # further handling. This method supports progress updates that can be used to display a progressbar
+    # <tt>file</tt>:: The file that should be parsed.
+    # <tt>options</tt>:: A Hash of options that will be pased to parse_io.    
     def parse_file(file, options = {}, &block)
       @progress_handler.call(:started, file) if @progress_handler
       File.open(file, 'r') { |f| parse_io(f, options, &block) }
       @progress_handler.call(:finished, file) if @progress_handler
     end
 
+
+    # Parses an IO stream. It will simply call parse_io. This function does not support progress updates
+    # because the length of a stream is not known.
+    # <tt>stream</tt>:: The IO stream that should be parsed.
+    # <tt>options</tt>:: A Hash of options that will be pased to parse_io.    
     def parse_stream(stream, options = {}, &block)
       parse_io(stream, options, &block)
     end
 
-    # Finds a log line and then parses the information in the line.
-    # Yields a hash containing the information found. 
-    # <tt>*line_types</tt> The log line types to look for (defaults to LOG_LINES.keys).
-    # Yeilds a Hash when it encounters a chunk of information.
-    def parse_io(io, options = {}, &block)
-
-      # parse every line type by default
-      line_types = options[:line_types] || file_format.line_definitions.keys
-
-      # check whether all provided line types are valid
-      unknown = line_types.reject { |line_type| file_format.line_definitions.has_key?(line_type) }
-      raise "Unknown line types: #{unknown.join(', ')}" unless unknown.empty?
+    # This method loops over each line of the input stream. It will try to parse this line as any of
+    # the lines that are defined by the current file format (see RequestLogAnalyazer::FileFormat).
+    # It will then combine these parsed line into requests using heuristics. These requests (see
+    # RequestLogAnalyzer::Request) will then be yielded for further processing in the pipeline.
+    #
+    # - RequestLogAnalyzer::LineDefinition#matches is called to test if a line matches a line definition of the file format.
+    # - update_current_request is used to combine parsed lines into requests using heuristics.
+    # - The method will yield progress updates if a progress handler is installed using progress=
+    # - The method will yield parse warnings if a warning handler is installed using warning=
+    #
+    # <tt>io</tt>:: The IO instance to use as source
+    # <tt>options</tt>:: A hash of options that can be used by the parser.
+    def parse_io(io, options = {}, &block) # :yields: request
 
       @current_io = io
       @current_io.each_line do |line|
@@ -82,11 +107,11 @@ module RequestLogAnalyzer::Source
         @progress_handler.call(:progress, @current_io.pos) if @progress_handler && @current_io.kind_of?(File)
 
         request_data = nil
-        line_types.each do |line_type|
-          line_type_definition = file_format.line_definitions[line_type]
-          break if request_data = line_type_definition.matches(line, @current_io.lineno, self)
+        file_format.line_definitions.each do |line_type, definition|
+          request_data = definition.matches(line, @current_io.lineno, self)
+          break if request_data
         end
-
+        
         if request_data
           @parsed_lines += 1
           update_current_request(request_data, &block)
@@ -98,19 +123,27 @@ module RequestLogAnalyzer::Source
       @current_io = nil
     end
 
-    # Add a block to this method to install a progress handler while parsing
+    # Add a block to this method to install a progress handler while parsing.
+    # <tt>proc</tt>:: The proc that will be called to handle progress update messages
     def progress=(proc)
       @progress_handler = proc
     end
 
-    # Add a block to this method to install a warning handler while parsing
+    # Add a block to this method to install a warning handler while parsing,
+    # <tt>proc</tt>:: The proc that will be called to handle parse warning messages    
     def warning=(proc)
       @warning_handler = proc
     end
 
-    # This method is called by the parser if it encounteres any problems.
-    # It will call the warning handler. The default controller will pass all warnings to every
-    # aggregator that is registered and running
+    # This method is called by the parser if it encounteres any parsing problems.
+    # It will call the installed warning handler if any. 
+    #
+    # By default, RequestLogAnalyzer::Controller will install a warning handler 
+    # that will pass the warnings to each aggregator so they can do something useful
+    # with it.
+    #
+    # <tt>type</tt>:: The warning type (a Symbol)
+    # <tt>message</tt>:: A message explaining the warning
     def warn(type, message)
       @warning_handler.call(type, message, @current_io.lineno) if @warning_handler
     end
@@ -121,25 +154,38 @@ module RequestLogAnalyzer::Source
     # new request when a header line is encountered en will emit the request when a footer line 
     # is encountered.
     #
+    # Combining the lines is done using heuristics. Problems can occur in this process. The
+    # current parse strategy defines how these cases are handled.
+    #
+    # When using the 'assume-correct' parse strategy (default):
+    # - Every line that is parsed before a header line is ignored as it cannot be included in 
+    #   any request. It will emit a :no_current_request warning.
+    # - If a header line is found before the previous requests was closed, the previous request 
+    #   will be yielded and a new request will be started.
+    #
+    # When using the 'cautious' parse strategy:
     # - Every line that is parsed before a header line is ignored as it cannot be included in 
     #   any request. It will emit a :no_current_request warning.
     # - A header line that is parsed before a request is closed by a footer line, is a sign of
-    #   an unprpertly ordered file. All data that is gathered for the request until then is 
-    #   discarded, the next request is ignored as well and a :unclosed_request warning is
+    #   an unproperly ordered file. All data that is gathered for the request until then is 
+    #   discarded and the next request is ignored as well. An :unclosed_request warning is
     #   emitted.
-    def update_current_request(request_data, &block)
+    #
+    # <tt>request_data</tt>:: A hash of data that was parsed from the last line.
+    def update_current_request(request_data, &block) # :yields: request
       if header_line?(request_data)
         unless @current_request.nil?
-          if options[:assume_correct_order]
-            handle_request(@current_request, &block) #yield @current_request
-            @current_request = @file_format.create_request(request_data)
-          else
+          case options[:parse_strategy]
+          when 'assume-correct'
+            handle_request(@current_request, &block)
+            @current_request = @file_format.request(request_data)
+          when 'cautious'
             @skipped_lines += 1
-            warn(:unclosed_request, "Encountered header line, but previous request was not closed!")
+            warn(:unclosed_request, "Encountered header line (#{request_data[:line_definition].name.inspect}), but previous request was not closed!")
             @current_request = nil # remove all data that was parsed, skip next request as well.
           end
         else
-          @current_request = @file_format.create_request(request_data)              
+          @current_request = @file_format.request(request_data)              
         end
       else
         unless @current_request.nil?
@@ -150,26 +196,33 @@ module RequestLogAnalyzer::Source
           end
         else
           @skipped_lines += 1
-          warn(:no_current_request, "Parsebale line found outside of a request!")
+          warn(:no_current_request, "Parsebale line (#{request_data[:line_definition].name.inspect}) found outside of a request!")
         end
       end
     end
     
-    # Handles the parsed request by calling the request handler.
-    # The default controller will send the request to every running aggegator.
-    def handle_request(request, &block)
+    # Handles the parsed request by sending it into the pipeline. 
+    #
+    # - It will call RequestLogAnalyzer::Request#validate on the request instance
+    # - It will send the request into the pipeline, checking whether it was accepted by all the filters.
+    # - It will update the parsed_requests and skipped_requests variables accordingly
+    #
+    # <tt>request</tt>:: The parsed request instance (RequestLogAnalyzer::Request)
+    def handle_request(request, &block) # :yields: request
       @parsed_requests += 1
       request.validate
       accepted = block_given? ? yield(request) : true
       @skipped_requests += 1 if not accepted
     end    
 
-    # Checks whether a given line hash is a header line.
+    # Checks whether a given line hash is a header line according to the current file format.
+    # <tt>hash</tt>:: A hash of data that was parsed from the line.    
     def header_line?(hash)
       hash[:line_definition].header
     end
 
-    # Checks whether a given line hash is a footer line.    
+    # Checks whether a given line hash is a footer line  according to the current file format.    
+    # <tt>hash</tt>:: A hash of data that was parsed from the line.    
     def footer_line?(hash)
       hash[:line_definition].footer
     end 

data/lib/request_log_analyzer/source.rb

@@ -1,11 +1,27 @@
+# The RequestLogAnalyzer::Source module contains all functionality that loads requests from a given source
+# and feed them to the pipeline for further processing. The requests (see RequestLogAnalyzer::Request) that
+# will be parsed from a source, will be piped throug filters (see RequestLogAnalyzer::Filter) and are then 
+# fed to an aggregator (see RequestLogAnalyzer::Aggregator). The source instance is thus the beginning of 
+# the RequestLogAnalyzer chain.
+#
+# - The base class for all sources is RequestLogAnalyzer::Source::Base. All source classes should inherit from this class.
+# - Currently, RequestLogAnalyzer::Source::LogParser is the only implemented source.
 module RequestLogAnalyzer::Source
 
+  # Loads constants that reside in the RequestLogAnalyzer::Source namespace. This function uses
+  # RequestLogAnalyzer::load_default_class_file to load the file in which the constant is declared.
+  # <tt>const</tt>:: The constant to load in the RequestLogAnalyzer::Source namespace.
   def self.const_missing(const)
     RequestLogAnalyzer::load_default_class_file(self, const)
   end
   
+  # The base Source class. All other sources should inherit from this class.
+  #
+  # A source implememtation should at least implement the each_request method, which should yield
+  # RequestLogAnalyzer::Request instances that will be fed through the pipleine.
   class Base
     
+    # Make the Spurce instance aware of the current file format
     include RequestLogAnalyzer::FileFormat::Awareness
 
     # A hash of options
@@ -23,23 +39,29 @@ module RequestLogAnalyzer::Source
     # The number of skipped lines because of warnings
     attr_reader :skipped_lines
 
-    # Base source class used to filter input requests.
-
-    # Initializer
-    # <tt>format</tt> The file format
-    # <tt>options</tt> Are passed to the filters.
+    # Initializer, which will register the file format and save any options given as a hash.
+    # <tt>format</tt>:: The file format instance
+    # <tt>options</tt>:: A hash of options that can be used by a specific Source implementation
     def initialize(format, options = {})
       @options    = options
       register_file_format(format)
     end
     
+    # The prepare method is called before the RequestLogAnalyzer::Source::Base#each_request method is called.
+    # Use this method to implement any initialization that should occur before this source can produce Request
+    # instances.
     def prepare
     end
     
-    def requests(&block)
+    # This function is called to actually produce the requests that will be send into the pipeline. 
+    # The implementation should yield instances of RequestLogAnalyzer::Request.
+    # <tt>options</tt>:: A Hash of options that can be used in the implementation.
+    def each_request(options = {}, &block) # :yields: request
       return true
     end
 
+    # This function is called after RequestLogAnalyzer::Source::Base#each_request finished. Any code to
+    # wrap up, free resources, etc. can be put in this method.
     def finalize
     end
 

data/lib/request_log_analyzer/tracker/duration.rb

@@ -31,26 +31,101 @@ module RequestLogAnalyzer::Tracker
     end
 
     def update(request)
-      category = options[:category].respond_to?(:call) ? options[:category].call(request) : request[options[:category]]
-      duration = options[:duration].respond_to?(:call) ? options[:duration].call(request) : request[options[:duration]]
+      if options[:multiple]
+        categories = request.every(options[:category])
+        durations  = request.every(options[:duration])
+        
+        if categories.length == durations.length
+          categories.each_with_index do |category, index|
+            @categories[category] ||= {:hits => 0, :cumulative => 0.0}
+            @categories[category][:hits] += 1
+            @categories[category][:cumulative] += durations[index]
+          end
+        else
+          raise "Capture mismatch for multiple values in a request"
+        end
+      else
+        category = options[:category].respond_to?(:call) ? options[:category].call(request) : request[options[:category]]
+        duration = options[:duration].respond_to?(:call) ? options[:duration].call(request) : request[options[:duration]]
   
-      if !duration.nil? && !category.nil?
-        @categories[category] ||= {:count => 0, :total_duration => 0.0}
-        @categories[category][:count] += 1
-        @categories[category][:total_duration] += duration
+        if duration.kind_of?(Float) && category.kind_of?(String)
+          @categories[category] ||= {:hits => 0, :cumulative => 0.0, :min => duration, :max => duration }
+          @categories[category][:hits] += 1
+          @categories[category][:cumulative] += duration
+          @categories[category][:min] = duration if duration < @categories[category][:min]
+          @categories[category][:max] = duration if duration > @categories[category][:max]   
+        end
       end
     end
+    
+    def hits(cat)
+      categories[cat][:hits]
+    end
+    
+    def cumulative_duration(cat)
+      categories[cat][:cumulative]
+    end
 
+    def min_duration(cat)
+      categories[cat][:min]
+    end
+
+    def max_duration(cat)
+      categories[cat][:max]
+    end
+
+    def average_duration(cat)
+      categories[cat][:cumulative] / categories[cat][:hits]  
+    end
+    
+    def overall_average_duration
+      overall_cumulative_duration / overall_hits
+    end
+    
+    def overall_cumulative_duration
+      categories.inject(0.0) { |sum, (name, cat)| sum + cat[:cumulative] }  
+    end
+    
+    def overall_hits
+      categories.inject(0) { |sum, (name, cat)| sum + cat[:hits] }
+    end
+
+    def sorted_by_hits
+      sorted_by(:hits)
+    end
+
+    def sorted_by_cumulative
+      sorted_by(:cumulative)
+    end
+
+    def sorted_by_average
+      sorted_by { |cat| cat[:cumulative] / cat[:hits] }
+    end
+          
+    def sorted_by(by = nil) 
+      if block_given?
+        categories.sort { |a, b| yield(b[1]) <=> yield(a[1]) } 
+      else
+        categories.sort { |a, b| b[1][by] <=> a[1][by] } 
+      end
+    end
+    
+    # Builds a result table using a provided sorting function 
     def report_table(output, amount = 10, options = {}, &block)
     
       output.title(options[:title])
     
       top_categories = @categories.sort { |a, b| yield(b[1]) <=> yield(a[1]) }.slice(0...amount)
-      output.table({:title => 'Action'}, {:title => 'Hits', :align => :right, :min_width => 4}, 
-            {:title => 'Cumulative', :align => :right, :min_width => 10}, {:title => 'Average', :align => :right, :min_width => 8}) do |rows|
+      output.table({:title => 'Category', :width => :rest}, 
+            {:title => 'Hits',       :align => :right, :highlight => (options[:sort] == :hits), :min_width => 4}, 
+            {:title => 'Cumulative', :align => :right, :highlight => (options[:sort] == :cumulative), :min_width => 10}, 
+            {:title => 'Average',    :align => :right, :highlight => (options[:sort] == :average), :min_width => 8},
+            {:title => 'Min',        :align => :right, :highlight => (options[:sort] == :min)}, 
+            {:title => 'Max',        :align => :right, :highlight => (options[:sort] == :max)}) do |rows|
       
         top_categories.each do |(cat, info)|
-          rows << [cat, info[:count], "%0.02fs" % info[:total_duration], "%0.02fs" % (info[:total_duration] / info[:count])]
+          rows << [cat, info[:hits], "%0.02fs" % info[:cumulative], "%0.02fs" % (info[:cumulative] / info[:hits]),
+                    "%0.02fs" % info[:min], "%0.02fs" % info[:max]]
         end        
       end
 
@@ -59,19 +134,19 @@ module RequestLogAnalyzer::Tracker
     def report(output)
 
       options[:title]  ||= 'Request duration'
-      options[:report] ||= [:total, :average]
+      options[:report] ||= [:cumulative, :average]
       options[:top]    ||= 20
   
       options[:report].each do |report|
         case report
         when :average
-          report_table(output, options[:top], :title => "#{options[:title]} - top #{options[:top]} by average time") { |request| request[:total_duration] / request[:count] }  
-        when :total
-          report_table(output, options[:top], :title => "#{options[:title]} - top #{options[:top]} by cumulative time") { |request| request[:total_duration] }
+          report_table(output, options[:top], :title => "#{options[:title]} - top #{options[:top]} by average time", :sort => :average) { |cat| cat[:cumulative] / cat[:hits] }  
+        when :cumulative
+          report_table(output, options[:top], :title => "#{options[:title]} - top #{options[:top]} by cumulative time", :sort => :cumulative) { |cat| cat[:cumulative] }
         when :hits
-          report_table(output, options[:top], :title => "#{options[:title]} - top #{options[:top]} by hits") { |request| request[:count] }
+          report_table(output, options[:top], :title => "#{options[:title]} - top #{options[:top]} by hits", :sort => :hits) { |cat| cat[:hits] }
         else
-          output << "Unknown duration report specified\n"
+          raise "Unknown duration report specified: #{report}!"
         end
       end
     end