request-log-analyzer 1.3.4 → 1.4.0

data/lib/request_log_analyzer/source/log_parser.rb

@@ -1,13 +1,13 @@
 module RequestLogAnalyzer::Source
-  
+
   # The LogParser class reads log data from a given source and uses a file format definition
-  # to parse all relevent information about requests from the file. A FileFormat module should 
+  # to parse all relevent information about requests from the file. A FileFormat module should
   # be provided that contains the definitions of the lines that occur in the log data.
   #
-  # 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. It will emit warnings when this occurs. LogParser supports multiple parse strategies 
+  # 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. It will emit warnings when this occurs. LogParser supports multiple parse strategies
   # that deal differently with this problem.
   class LogParser < Base
 
@@ -15,7 +15,7 @@ module RequestLogAnalyzer::Source
 
     # 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']
 
@@ -27,42 +27,44 @@ module RequestLogAnalyzer::Source
     #
     # <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
+    def initialize(format, options = {})
+      super(format, options)
       @parsed_lines     = 0
       @parsed_requests  = 0
       @skipped_lines    = 0
       @skipped_requests = 0
+      @current_request  = nil
+      @current_source   = nil
       @current_file     = nil
       @current_lineno   = nil
       @source_files     = options[:source_files]
-      
+      @progress_handler = nil
+
       @options[:parse_strategy] ||= DEFAULT_PARSE_STRATEGY
       raise "Unknown parse strategy" unless PARSE_STRATEGIES.include?(@options[:parse_strategy])
-      
-      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, request
-      
+
       case @source_files
       when IO
-        puts "Parsing from the standard input. Press CTRL+C to finish." # FIXME: not here
-        parse_stream(@source_files, options, &block) 
+        if @source_files == $stdin
+          puts "Parsing from the standard input. Press CTRL+C to finish." # FIXME: not here
+        end
+        parse_stream(@source_files, options, &block)
       when String
-        parse_file(@source_files, options, &block) 
+        parse_file(@source_files, options, &block)
       when Array
-        parse_files(@source_files, options, &block) 
+        parse_files(@source_files, options, &block)
       else
         raise "Unknown source provided"
       end
     end
-    
+
     # Make sure the Enumerable methods work as expected
     alias_method :each, :each_request
 
@@ -73,12 +75,12 @@ module RequestLogAnalyzer::Source
     def parse_files(files, options = {}, &block) # :yields: request
       files.each { |file| parse_file(file, options, &block) }
     end
-    
+
     # Check if a file has a compressed extention in the filename.
     # If recognized, return the command string used to decompress the file
     def decompress_file?(filename)
       nice_command = "nice -n 5"
-      
+
       return "#{nice_command} gunzip -c -d #{filename}" if filename.match(/\.tar.gz$/) || filename.match(/\.tgz$/) || filename.match(/\.gz$/)
       return "#{nice_command} bunzip2 -c -d #{filename}" if filename.match(/\.bz2$/)
       return "#{nice_command} unzip -p #{filename}" if filename.match(/\.zip$/)
@@ -97,27 +99,32 @@ module RequestLogAnalyzer::Source
     # <tt>options</tt>:: A Hash of options that will be pased to parse_io.
     def parse_file(file, options = {}, &block)
 
-      @progress_handler = @dormant_progress_handler
       @current_source = File.expand_path(file)
-      @progress_handler.call(:started, file)                  if @progress_handler
       @source_changes_handler.call(:started, @current_source) if @source_changes_handler
-      
+
       if decompress_file?(file).empty?
+
+        @progress_handler = @dormant_progress_handler
+        @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
+        @progress_handler = nil
       else
         IO.popen(decompress_file?(file), 'r') { |f| parse_io(f, options, &block) }
       end
-      
+
       @source_changes_handler.call(:finished, @current_source) if @source_changes_handler
-      @progress_handler.call(:finished, file)                  if @progress_handler
+
       @current_source = nil
-      @progress_handler = nil
+
     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.    
+    # <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
@@ -137,16 +144,16 @@ module RequestLogAnalyzer::Source
     def parse_io(io, options = {}, &block) # :yields: request
       @current_lineno = 1
       while line = io.gets
-        @progress_handler.call(:progress, io.pos) if @progress_handler && @current_lineno % 127 == 0
-        
+        @progress_handler.call(:progress, io.pos) if @progress_handler && @current_lineno % 255 == 0
+
         if request_data = file_format.parse_line(line) { |wt, message| warn(wt, message) }
           @parsed_lines += 1
           update_current_request(request_data.merge(:source => @current_source, :lineno => @current_lineno), &block)
         end
-        
+
         @current_lineno += 1
       end
-      
+
       warn(:unfinished_request_on_eof, "End of file reached, but last request was not completed!") unless @current_request.nil?
       @current_lineno = nil
     end
@@ -162,7 +169,7 @@ module RequestLogAnalyzer::Source
     def warning=(proc)
       @warning_handler = proc
     end
-    
+
     # Add a block to this method to install a source change handler while parsing,
     # <tt>proc</tt>:: The proc that will be called to handle source changes
     def source_changes=(proc)
@@ -170,9 +177,9 @@ module RequestLogAnalyzer::Source
     end
 
     # This method is called by the parser if it encounteres any parsing problems.
-    # It will call the installed warning handler if any. 
+    # It will call the installed warning handler if any.
     #
-    # By default, RequestLogAnalyzer::Controller will install a warning handler 
+    # 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.
     #
@@ -184,24 +191,24 @@ module RequestLogAnalyzer::Source
 
     protected
 
-    # Combines the different lines of a request into a single Request object. It will start a 
-    # new request when a header line is encountered en will emit the request when a footer line 
+    # Combines the different lines of a request into a single Request object. It will start a
+    # 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 
+    # - 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 
+    # - 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 
+    # - 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 unproperly ordered file. All data that is gathered for the request until then 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.
     #
@@ -228,7 +235,7 @@ module RequestLogAnalyzer::Source
           @current_request << request_data
           if footer_line?(request_data)
             handle_request(@current_request, &block) # yield @current_request
-            @current_request = nil 
+            @current_request = nil
           end
         else
           @skipped_lines += 1
@@ -236,8 +243,8 @@ module RequestLogAnalyzer::Source
         end
       end
     end
-    
-    # Handles the parsed request by sending it into the pipeline. 
+
+    # 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.
@@ -249,19 +256,19 @@ module RequestLogAnalyzer::Source
       request.validate
       accepted = block_given? ? yield(request) : true
       @skipped_requests += 1 unless accepted
-    end    
+    end
 
     # 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.    
+    # <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  according to the current file format.    
-    # <tt>hash</tt>:: A hash of data that was parsed from the 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 
+    end
   end
 
 end

data/lib/request_log_analyzer/source.rb

@@ -1,7 +1,7 @@
 # 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 
+# 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.
@@ -14,15 +14,12 @@ module RequestLogAnalyzer::Source
   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
     attr_reader :options
@@ -42,23 +39,24 @@ module RequestLogAnalyzer::Source
     # The total number of skipped requests because of filters.
     attr_reader :skipped_requests
 
-
+    # The FileFormat instance that describes the format of this source.
+    attr_reader :file_format
 
     # 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)
+      @options     = options
+      @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
-    
-    # This function is called to actually produce the requests that will be send into the pipeline. 
+
+    # 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

data/lib/request_log_analyzer/tracker/duration.rb

@@ -3,12 +3,11 @@ module RequestLogAnalyzer::Tracker
   # Analyze the duration of a specific attribute
   #
   # === Options
-  # * <tt>:amount</tt> The amount of lines in the report
   # * <tt>:category</tt> Proc that handles request categorization for given fileformat (REQUEST_CATEGORIZER)
   # * <tt>:duration</tt> The field containing the duration in the request hash.
   # * <tt>:if</tt> Proc that has to return !nil for a request to be passed to the tracker.
   # * <tt>:line_type</tt> The line type that contains the duration field (determined by the category proc).
-  # * <tt>:title</tt> Title do be displayed above the report  
+  # * <tt>:title</tt> Title do be displayed above the report
   # * <tt>:unless</tt> Handle request if this proc is false for the handled request.
   #
   # The items in the update request hash are set during the creation of the Duration tracker.
@@ -21,141 +20,62 @@ module RequestLogAnalyzer::Tracker
   #  EmployeeController#index.html [GET]            |    5802 |  1477.32s |     0.25s
   #  .............
   class Duration < Base
-    
+
+    include RequestLogAnalyzer::Tracker::StatisticsTracking
+
     attr_reader :categories
 
     # Check if duration and catagory option have been received,
     def prepare
       raise "No duration field set up for category tracker #{self.inspect}" unless options[:duration]
-      raise "No categorizer set up for duration tracker #{self.inspect}" unless options[:category]
+      raise "No categorizer set up for duration tracker #{self.inspect}"    unless options[:category]
 
-      @categorizer  = options[:category].respond_to?(:call) ? options[:category] : lambda { |request| request[options[:category]] }
-      @durationizer = options[:duration].respond_to?(:call) ? options[:duration] : lambda { |request| request[options[:duration]] }
-      @categories = {}
+      unless options[:multiple]
+        @categorizer  = create_lambda(options[:category])
+        @durationizer = create_lambda(options[:duration])
+      end
+      
+      @categories   = {}
     end
 
     # Get the duration information fron the request and store it in the different categories.
     # <tt>request</tt> The request.
     def update(request)
       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
+        found_categories = request.every(options[:category])
+        found_durations  = request.every(options[:duration])
+        raise "Capture mismatch for multiple values in a request" unless found_categories.length == found_durations.length
+        found_categories.each_with_index { |cat, index| update_statistics(cat, found_durations[index]) }
       else
-        category = @categorizer.call(request)  # options[:category].respond_to?(:call) ? options[:category].call(request) : request[options[:category]]
-        duration = @durationizer.call(request) # options[:duration].respond_to?(:call) ? options[:duration].call(request) : request[options[: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
+        category = @categorizer.call(request)
+        duration = @durationizer.call(request)
+        update_statistics(category, duration) if duration.kind_of?(Numeric) && category
       end
     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 cumulative_duration(cat)
-      categories[cat][:cumulative]
-    end
-
-    # Get the minimal duration of a specific category.
-    # <tt>cat</tt> The category
-    def min_duration(cat)
-      categories[cat][:min]
-    end
-
-    # Get the maximum duration of a specific category.
-    # <tt>cat</tt> The category
-    def max_duration(cat)
-      categories[cat][:max]
-    end
-
-    # Get the average duration of a specific category.
-    # <tt>cat</tt> The category
-    def average_duration(cat)
-      categories[cat][:cumulative] / categories[cat][:hits]  
-    end
-    
-    # Get the average duration of a all categories.
-    def overall_average_duration
-      overall_cumulative_duration / overall_hits
-    end
-    
-    # Get the cumlative duration of a all categories.
-    def overall_cumulative_duration
-      categories.inject(0.0) { |sum, (name, cat)| sum + cat[:cumulative] }  
-    end
-    
-    # Get the total hits of a all categories.
-    def overall_hits
-      categories.inject(0) { |sum, (name, cat)| sum + cat[:hits] }
-    end
 
-    # Return categories sorted by hits.
-    def sorted_by_hits
-      sorted_by(:hits)
-    end
-
-    # Return categories sorted by cumulative duration.
-    def sorted_by_cumulative
-      sorted_by(:cumulative)
-    end
-
-    # Return categories sorted by cumulative duration.
-    def sorted_by_average
-      sorted_by { |cat| cat[:cumulative] / cat[:hits] }
-    end
-          
-    # Return categories sorted by a given key.
-    # <tt>by</tt> The key.
-    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
-    
     # Block function to build a result table using a provided sorting function.
     # <tt>output</tt> The output object.
     # <tt>amount</tt> The number of rows in the report table (default 10).
     # === Options
     #  * </tt>:title</tt> The title of the table
     #  * </tt>:sort</tt> The key to sort on (:hits, :cumulative, :average, :min or :max)
-    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 => '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[:hits], "%0.02fs" % info[:cumulative], "%0.02fs" % (info[:cumulative] / info[:hits]),
-                    "%0.02fs" % info[:min], "%0.02fs" % info[:max]]
-        end        
+    def report_table(output, sort, options = {}, &block)
+      output.puts
+      top_categories = output.slice_results(sorted_by(sort))
+      output.with_style(:top_line => true) do
+        output.table(*statistics_header(:title => options[:title], :highlight => sort)) do |rows|
+          top_categories.each { |(cat, info)| rows << statistics_row(cat) }
+        end
+      end
+    end
+
+    # Display a duration
+    def display_value(time)
+      case time
+      when nil       then '-'
+      when 0...60    then "%0.02fs" % time
+      when 60...3600 then "%dm%02ds" % [time / 60, (time % 60).round]
+      else                "%dh%02dm%02ds" % [time / 3600, (time % 3600) / 60, (time % 60).round]
       end
     end
 
@@ -164,33 +84,20 @@ module RequestLogAnalyzer::Tracker
     # Any options for the report should have been set during initialize.
     # <tt>output</tt> The output object
     def report(output)
-
-      options[:title]  ||= 'Request duration'
-      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", :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", :sort => :hits) { |cat| cat[:hits] }
-        else
-          raise "Unknown duration report specified: #{report}!"
-        end
+      sortings = output.options[:sort] || [:sum, :mean]
+      sortings.each do |sorting|
+        report_table(output, sorting, :title => "#{title} - by #{sorting}")
       end
     end
-    
+
     # Returns the title of this tracker for reports
     def title
       options[:title]  || 'Request duration'
     end
-    
+
     # Returns all the categories and the tracked duration as a hash than can be exported to YAML
     def to_yaml_object
-      return nil if @categories.empty?      
+      return nil if @categories.empty?
       @categories
     end
   end

data/lib/request_log_analyzer/tracker/frequency.rb

@@ -1,10 +1,9 @@
 module RequestLogAnalyzer::Tracker
-  
+
   # Catagorize requests by frequency.
-  # Count and analyze requests for a specific attribute 
+  # Count and analyze requests for a specific attribute
   #
   # === Options
-  # * <tt>:amount</tt> The amount of lines in the report
   # * <tt>:category</tt> Proc that handles the request categorization.
   # * <tt>:if</tt> Proc that has to return !nil for a request to be passed to the tracker.
   # * <tt>:line_type</tt> The line type that contains the duration field (determined by the category proc).
@@ -23,41 +22,42 @@ module RequestLogAnalyzer::Tracker
   #  DELETE |    512 hits (1.1%)  |
   class Frequency < Base
 
-    attr_reader :frequencies
+    attr_reader :categories
 
     # Check if categories are set up
     def prepare
       raise "No categorizer set up for category tracker #{self.inspect}" unless options[:category]
-      @frequencies = {}
-      if options[:all_categories].kind_of?(Enumerable)
-        options[:all_categories].each { |cat| @frequencies[cat] = 0 }
-      end
+      @categorizer = create_lambda(options[:category])
+      
+      # Initialize the categories. Use the list of category names to 
+      @categories = {}
+      options[:all_categories].each { |cat| @categories[cat] = 0 } if options[:all_categories].kind_of?(Enumerable)
     end
-            
-    # Check HTTP method of a request and store that in the frequencies hash.
+
+    # Check HTTP method of a request and store that in the categories hash.
     # <tt>request</tt> The request.
     def update(request)
-      cat = options[:category].respond_to?(:call) ? options[:category].call(request) : request[options[:category]]
-      if !cat.nil? || options[:nils]
-        @frequencies[cat] ||= 0
-        @frequencies[cat] += 1
+      cat = @categorizer.call(request)
+      if cat || options[:nils]
+        @categories[cat] ||= 0
+        @categories[cat] += 1
       end
     end
 
     # Return the amount of times a HTTP method has been encountered
     # <tt>cat</tt> The HTTP method (:get, :put, :post or :delete)
     def frequency(cat)
-      frequencies[cat] || 0
+      categories[cat] || 0
     end
-    
+
     # Return the overall frequency
     def overall_frequency
-      frequencies.inject(0) { |carry, item| carry + item[1] }
+      categories.inject(0) { |carry, item| carry + item[1] }
     end
-    
+
     # Return the methods sorted by frequency
     def sorted_by_frequency
-      @frequencies.sort { |a, b| b[1] <=> a[1] }
+      @categories.sort { |a, b| b[1] <=> a[1] }
     end
 
     # Generate a HTTP method frequency report to the given output object.
@@ -65,29 +65,28 @@ module RequestLogAnalyzer::Tracker
     # <tt>output</tt> The output object
     def report(output)
       output.title(options[:title]) if options[:title]
-    
-      if @frequencies.empty?
-        output << "None found.\n" 
+
+      if @categories.empty?
+        output << "None found.\n"
       else
-        sorted_frequencies = @frequencies.sort { |a, b| b[1] <=> a[1] }
-        total_hits         = sorted_frequencies.inject(0) { |carry, item| carry + item[1] }
-        sorted_frequencies = sorted_frequencies.slice(0...options[:amount]) if options[:amount]
+        sorted_categories = output.slice_results(sorted_by_frequency)
+        total_hits        = overall_frequency
 
-        output.table({:align => :left}, {:align => :right }, {:align => :right}, {:type => :ratio, :width => :rest}) do |rows|        
-          sorted_frequencies.each do |(cat, count)|
+        output.table({:align => :left}, {:align => :right }, {:align => :right}, {:type => :ratio, :width => :rest}) do |rows|
+          sorted_categories.each do |(cat, count)|
             rows << [cat, "#{count} hits", '%0.1f%%' % ((count.to_f / total_hits.to_f) * 100.0), (count.to_f / total_hits.to_f)]
           end
         end
 
       end
     end
-    
-    # Returns a hash with the frequencies of every category that can be exported to YAML
+
+    # Returns a hash with the categories of every category that can be exported to YAML
     def to_yaml_object
-      return nil if @frequencies.empty?
-      @frequencies
+      return nil if @categories.empty?
+      @categories
     end
-    
+
     # Returns the title of this tracker for reports
     def title
       options[:title] || 'Request frequency'