production_log_analyzer 1.3.0 → 1.5.0

data/History.txt

@@ -0,0 +1,34 @@
+= 1.5.0
+
+* Fixed empty log bug.  Patch by Tim Lucas.
+* Fixed bug where sometimes lines would be logged before the
+  Processing line.  Patch by Geoff Grosenbach.
+
+= 1.4.0
+
+* Switched to Hoe
+* Allowed action_errors to suppress routing errors with > 3 occurances
+* action_grep now works correctly with components
+* pl_analyze now works correctly with components
+* Added action_errors to extract error counts from logs
+* Retabbed to match the rest of the world
+
+= 1.3.0
+
+* Added action_grep
+* Added support for newer log format
+
+= 1.2.0
+
+* pl_analyze calculates per-action statistics
+* pl_analyze can send an email with its output
+
+= 1.1.0
+
+* RDoc
+* Other various fixes lost to time.
+
+= 1.0.0
+
+* Birthday!
+

data/{LICENSE → LICENSE.txt}

@@ -1,4 +1,4 @@
-Copyright 2005 Eric Hodel, The Robot Co-op.  All rights reserved.
+Copyright 2005, 2007 Eric Hodel, The Robot Co-op.  All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions

data/Manifest.txt

@@ -1,13 +1,17 @@
-Rakefile
-README
-LICENSE
+History.txt
+LICENSE.txt
 Manifest.txt
+README.txt
+Rakefile
+bin/action_errors
 bin/action_grep
 bin/pl_analyze
 lib/production_log/action_grep.rb
 lib/production_log/analyzer.rb
 lib/production_log/parser.rb
 test/test.syslog.0.14.x.log
+test/test.syslog.1.2.shortname.log
+test/test.syslog.empty.log
 test/test.syslog.log
 test/test_action_grep.rb
 test/test_analyzer.rb

data/{README → README.txt}

@@ -1,63 +1,49 @@
-Production Log Analyzer
+= production_log_analyzer
 
-http://rails-analyzer.rubyforge.org
+production_log_analyzer lets you find out which actions on a Rails
+site are slowing you down.
 
-http://rubyforge.org/projects/rails-analyzer
+http://seattlerb.rubyforge.org/production_log_analyzer
 
-= About
+http://rubyforge.org/projects/seattlerb
 
-The Production Log Analyzer lets you find out which pages on your site are
-dragging you down.  The PL Analyzer requires the use of SyslogLogger from
-rails_analyzer_tools because the default Logger doesn't give any way to
-associate lines logged to a request.
+Bug reports:
 
-The PL Analyzer also includes action_grep which lets you grab lines from a log
-that only match a single action.
-
-  action_grep RssController#uber /var/log/production.log
-
-= Installing
-
-== Download
+http://rubyforge.org/tracker/?func=add&group_id=1513&atid=5921
 
-Grab the gem (or tar.gz) from the RubyForge project:
+== About
 
-http://rubyforge.org/frs/?group_id=586
+production_log_analyzer provides three tools to analyze log files
+created by SyslogLogger.  pl_analyze for getting daily reports,
+action_grep for pulling log lines for a single action and
+action_errors to summarize errors with counts.
 
-== What you need
+The analyzer currently requires the use of SyslogLogger because the
+default Logger doesn't give any way to associate lines logged to a
+request.
 
-Either:
-
-A syslogd that doesn't suck.  This means that syslog.conf(5) shows a
-!program_name specification.  (FreeBSD's syslogd doesn't suck, but OS X's
-syslogd does.)
-
-or:
+The PL Analyzer also includes action_grep which lets you grab lines from a log
+that only match a single action.
 
-Some hacking skills to make Rails log the pid of the process for each line
-logged.  You'll also have to teach LogParser#parse about this.  Feel free to
-submit patches with tests.  (Patches without tests are useless to me.)
+  action_grep RssController#uber /var/log/production.log
 
-== What you need to do
+== Installing
 
-Either:
+  sudo gem install production_log_analyzer
 
-Use SyslogLogger according to directions on the SyslogLogger RDoc page,
-including setting up your non-sucky syslogd as directed.  (SyslogLogger is
-included via the rails_analyzer_tools gem.)
+=== Setup
 
-http://rails-analyzer.rubyforge.org/tools/classes/SyslogLogger.html
+First:
 
-or:
+Set up SyslogLogger according to the instructions here:
 
-Use your hacking skills and set up a logger that your hacked LogParser#parse
-can deal with.  (Then send my your patches for integration.)
+http://seattlerb.rubyforge.org/SyslogLogger/
 
 Then:
 
 Set up a cronjob (or something like that) to run log files through pl_analyze.
 
-= Using pl_analyze
+== Using pl_analyze
 
 To run pl_analyze simply give it the name of a log file to analyze.
 
@@ -73,7 +59,7 @@ Or, have pl_analyze email you (which is preferred, because tabs get preserved):
 
 In the future, pl_analyze will be able to read from STDIN.
 
-= Sample output
+== Sample output
 
   Request Times Summary:          Count   Avg     Std Dev Min     Max
   ALL REQUESTS:                   11      0.576   0.508   0.000   1.470
@@ -151,12 +137,11 @@ In the future, pl_analyze will be able to read from STDIN.
           TeamsController#progress took 0.000s
           TeamsController#progress took 0.000s
 
-= What's missing
+== What's missing
 
 * More reports
 * Command line arguments including:
   * Help
   * What type of log file you've got (if somebody sends patches with tests)
 * Read from STDIN
-* Lots more
 

data/Rakefile

@@ -1,63 +1,17 @@
-require 'rubygems'
-require 'rake'
-require 'rake/testtask'
-require 'rake/rdoctask'
-require 'rake/gempackagetask'
-require 'rake/contrib/sshpublisher'
+require 'hoe'
 
-$VERBOSE = nil
+$:.unshift './lib'
+require 'production_log/analyzer'
 
-spec = Gem::Specification.new do |s|
-  s.name = 'production_log_analyzer'
-  s.version = '1.3.0'
-  s.summary = 'Extracts statistics from Rails production logs'
-  s.author = 'Eric Hodel'
-  s.email = 'hodel@robotcoop.com'
+Hoe.new 'production_log_analyzer', '1.5.0' do |p|
+  p.summary = p.paragraphs_of('README.txt', 1).join ' '
+  p.description = p.paragraphs_of('README.txt', 7).join ' '
+  p.author = 'Eric Hodel'
+  p.email = 'drbrain@segment7.net'
+  p.url = p.paragraphs_of('README.txt', 2).join ' '
 
-  s.has_rdoc = true
-  s.files = File.read('Manifest.txt').split($/)
-  s.require_path = 'lib'
-  s.executables = ['pl_analyze', 'action_grep']
-  s.default_executable = 'pl_analyze'
+  p.rubyforge_name = 'seattlerb'
 
-  s.add_dependency 'rails_analyzer_tools', '>= 1.1.0'
+  p.extra_deps << ['rails_analyzer_tools', '>= 1.4.0']
 end
 
-desc 'Run tests'
-task :default => [ :test ]
-
-Rake::TestTask.new('test') do |t|
-  t.libs << 'test'
-  t.pattern = 'test/test_*.rb'
-  t.verbose = true
-end
-
-desc 'Generate RDoc'
-Rake::RDocTask.new :rdoc do |rd|
-  rd.rdoc_dir = 'doc'
-  rd.rdoc_files.add 'lib', 'README', 'LICENSE'
-  rd.main = 'README'
-  rd.options << '-d' if `which dot` =~ /\/dot/
-end
-
-desc 'Build Gem'
-Rake::GemPackageTask.new spec do |pkg|
-  pkg.need_tar = true
-end
-
-desc 'Sends RDoc to RubyForge'
-task :send_rdoc => [ :rerdoc ] do
-  publisher = Rake::SshDirPublisher.new('drbrain@rubyforge.org',
-                                        '/var/www/gforge-projects/rails-analyzer/pl_analyze',
-                                        'doc')
-  publisher.upload
-end
-
-desc 'Clean up'
-task :clean => [ :clobber_rdoc, :clobber_package ]
-
-desc 'Clean up'
-task :clobber => [ :clean ]
-
-# vim: syntax=Ruby
-

data/bin/action_errors

@@ -0,0 +1,46 @@
+#!/usr/local/bin/ruby -ws
+
+$h ||= false
+$r ||= false
+$o ||= false
+
+$r = $r ? ($r.to_i rescue false) : false
+
+if $h then
+  $stderr.puts "Usage: #{$0} [-r=N] LOGFILE"
+  $stderr.puts "\t-r=N\tShow routing errors with N or more occurances"
+  $stderr.puts "\t-o\tShow errors with one occurance"
+  exit
+end
+
+errors = {}
+counts = Hash.new 0
+
+ARGF.each_line do |line|
+  line =~ /\]: (.*?)     (.*)/
+  next if $1.nil?
+  msg = $1
+  trace = $2
+  key = msg.gsub(/\d/, '#')
+  counts[key] += 1
+  next if counts[key] > 1
+  trace = trace.split('     ')[0..-2].map { |l| l.strip }.join("\n\t")
+  error = "#{msg}\n\t#{trace}"
+  errors[key] = error
+end
+
+counts.sort_by { |_,c| -c }.each do |key, count|
+  next if count == 1 and not $o
+  error = errors[key]
+
+  if error =~ /^ActionController::RoutingError/ then
+    next unless $r
+    next if $r and count < $r
+  end
+
+  puts "count: #{count}"
+  puts "{{{"
+  puts error
+  puts "}}}"
+end
+

data/lib/production_log/action_grep.rb

@@ -4,31 +4,34 @@ class << ActionGrep
 
   def grep(action_name, file_name)
     unless action_name =~ /\A([A-Z][A-Za-z\d]*)(?:#([A-Za-z]\w*))?\Z/ then
-      raise ArgumentError, "Invalid action name #{action_name} expected something like FooController#uber"
+      raise ArgumentError, "Invalid action name #{action_name} expected something like SomeController#action"
     end
 
     unless File.file? file_name and File.readable? file_name then
       raise ArgumentError, "Unable to read #{file_name}"
     end
 
-    in_component = 0
     buckets = Hash.new { |h,k| h[k] = [] }
+    comp_count = Hash.new 0
+
     File.open file_name do |fp|
       fp.each_line do |line|
-        line =~ / ([^ ]+) ([^ ]+)\[(\d+)\]: /
+        line =~ / ([^ ]+) ([^ ]+)\[(\d+)\]: (.*)/
+        next if $2.nil? or $2 == 'newsyslog'
         bucket = [$1, $2, $3].join '-'
+        data = $4
 
         buckets[bucket] << line
 
-        case line
-        when /\]: Start rendering component / then
-          in_component += 1
-        when /\]: End of component rendering$/ then
-          in_component -= 1
-        when /\]: Completed/ then
-          next unless in_component == 0
+        case data
+        when /^Start rendering component / then
+          comp_count[bucket] += 1
+        when /^End of component rendering$/ then
+          comp_count[bucket] -= 1
+        when /^Completed/ then
+          next unless comp_count[bucket] == 0
           action = buckets.delete bucket
-          next unless action.first =~ /#{action_name}/
+          next unless action.any? { |l| l =~ /: Processing #{action_name}/ }
           puts action.join
         end
       end

data/lib/production_log/analyzer.rb

@@ -4,41 +4,41 @@ require 'production_log/parser'
 
 module Enumerable
 
-    ##
-    # Sum of all the elements of the Enumerable
-
-    def sum
-        return self.inject(0) { |acc, i| acc + i }
-    end
-
-    ##
-    # Average of all the elements of the Enumerable
-    #
-    # The Enumerable must respond to #length
-
-    def average
-        return self.sum / self.length.to_f
-    end
-
-    ##
-    # Sample variance of all the elements of the Enumerable
-    #
-    # The Enumerable must respond to #length
-
-    def sample_variance
-        avg = self.average
-        sum = self.inject(0) { |acc, i| acc + (i - avg) ** 2 }
-        return (1 / self.length.to_f * sum)
-    end
-
-    ##
-    # Standard deviation of all the elements of the Enumerable
-    #
-    # The Enumerable must respond to #length
-
-    def standard_deviation
-        return Math.sqrt(self.sample_variance)
-    end
+  ##
+  # Sum of all the elements of the Enumerable
+
+  def sum
+    return self.inject(0) { |acc, i| acc + i }
+  end
+
+  ##
+  # Average of all the elements of the Enumerable
+  #
+  # The Enumerable must respond to #length
+
+  def average
+    return self.sum / self.length.to_f
+  end
+
+  ##
+  # Sample variance of all the elements of the Enumerable
+  #
+  # The Enumerable must respond to #length
+
+  def sample_variance
+    avg = self.average
+    sum = self.inject(0) { |acc, i| acc + (i - avg) ** 2 }
+    return (1 / self.length.to_f * sum)
+  end
+
+  ##
+  # Standard deviation of all the elements of the Enumerable
+  #
+  # The Enumerable must respond to #length
+
+  def standard_deviation
+    return Math.sqrt(self.sample_variance)
+  end
 
 end
 
@@ -47,27 +47,27 @@ end
 
 class SizedList < Array
 
-    ##
-    # Creates a new SizedList that can hold up to +limit+ items.  Whenever
-    # adding a new item to the SizedList would make the list larger than
-    # +limit+, +delete_block+ is called.
-    #
-    # +delete_block+ is passed the list and the item being added.
-    # +delete_block+ must take action to remove an item and return true or
-    # return false if the item should not be added to the list.
-
-    def initialize(limit, &delete_block)
-        @limit = limit
-        @delete_block = delete_block
-    end
+  ##
+  # Creates a new SizedList that can hold up to +limit+ items.  Whenever
+  # adding a new item to the SizedList would make the list larger than
+  # +limit+, +delete_block+ is called.
+  #
+  # +delete_block+ is passed the list and the item being added.
+  # +delete_block+ must take action to remove an item and return true or
+  # return false if the item should not be added to the list.
 
-    ##
-    # Attempts to add +obj+ to the list.
+  def initialize(limit, &delete_block)
+    @limit = limit
+    @delete_block = delete_block
+  end
 
-    def <<(obj)
-        return super if self.length < @limit
-        return super if @delete_block.call self, obj
-    end
+  ##
+  # Attempts to add +obj+ to the list.
+
+  def <<(obj)
+    return super if self.length < @limit
+    return super if @delete_block.call self, obj
+  end
 
 end
 
@@ -89,20 +89,21 @@ end
 
 class SlowestTimes < SizedList
 
-    ##
-    # Creates a new SlowestTimes SizedList that holds only +limit+ time/object
-    # pairs.
-    def initialize(limit)
-        super limit do |arr, new_item|
-            fastest_time = arr.sort_by { |time, name| time }.first
-            if fastest_time.first < new_item.first then
-                arr.delete_at index(fastest_time)
-                true
-            else
-                false
-            end
-        end
+  ##
+  # Creates a new SlowestTimes SizedList that holds only +limit+ time/object
+  # pairs.
+
+  def initialize(limit)
+    super limit do |arr, new_item|
+      fastest_time = arr.sort_by { |time, name| time }.first
+      if fastest_time.first < new_item.first then
+        arr.delete_at index(fastest_time)
+        true
+      else
+        false
+      end
     end
+  end
 
 end
 
@@ -111,277 +112,285 @@ end
 
 class Analyzer
 
-    ##
-    # The logfile being read by the Analyzer.
+  ##
+  # The version of the production log analyzer you are using.
 
-    attr_reader :logfile_name
+  VERSION = '1.5.0'
 
-    ##
-    # An Array of all the request total times for the log file.
+  ##
+  # The logfile being read by the Analyzer.
 
-    attr_reader :request_times
+  attr_reader :logfile_name
 
-    ##
-    # An Array of all the request database times for the log file.
+  ##
+  # An Array of all the request total times for the log file.
 
-    attr_reader :db_times
+  attr_reader :request_times
 
-    ##
-    # An Array of all the request render times for the log file.
+  ##
+  # An Array of all the request database times for the log file.
 
-    attr_reader :render_times
+  attr_reader :db_times
 
-    ##
-    # Generates and sends an email report with lots of fun stuff in it.  This
-    # way, Mail.app will behave when given tabs.
+  ##
+  # An Array of all the request render times for the log file.
 
-    def self.email(file_name, recipient, subject, count = 10)
-        analyzer = self.new file_name
-        analyzer.process
-        body = analyzer.report count
+  attr_reader :render_times
 
-        email = self.envelope(recipient, subject)
-        email << nil
-        email << "<pre>#{body}</pre>"
-        email = email.join($/) << $/
+  ##
+  # Generates and sends an email report with lots of fun stuff in it.  This
+  # way, Mail.app will behave when given tabs.
 
-        return email if $TESTING
+  def self.email(file_name, recipient, subject, count = 10)
+    analyzer = self.new file_name
+    analyzer.process
+    body = analyzer.report count
 
-        IO.popen("/usr/sbin/sendmail -i -t", "w+") do |sm|
-            sm.print email
-            sm.flush
-        end
-    end
+    email = self.envelope(recipient, subject)
+    email << nil
+    email << "<pre>#{body}</pre>"
+    email = email.join($/) << $/
 
-    def self.envelope(recipient, subject = nil) # :nodoc:
-        envelope = {}
-        envelope['To'] = recipient
-        envelope['Subject'] = subject || "pl_analyze"
-        envelope['Content-Type'] = "text/html"
+    return email if $TESTING
 
-        return envelope.map { |(k,v)| "#{k}: #{v}" }
+    IO.popen("/usr/sbin/sendmail -i -t", "w+") do |sm|
+      sm.print email
+      sm.flush
     end
+  end
+
+  def self.envelope(recipient, subject = nil) # :nodoc:
+    envelope = {}
+    envelope['To'] = recipient
+    envelope['Subject'] = subject || "pl_analyze"
+    envelope['Content-Type'] = "text/html"
+
+    return envelope.map { |(k,v)| "#{k}: #{v}" }
+  end
+
+  ##
+  # Creates a new Analyzer that will read data from +logfile_name+.
+
+  def initialize(logfile_name)
+    @logfile_name  = logfile_name
+    @request_times = Hash.new { |h,k| h[k] = [] }
+    @db_times      = Hash.new { |h,k| h[k] = [] }
+    @render_times  = Hash.new { |h,k| h[k] = [] }
+  end
+
+  ##
+  # Processes the log file collecting statistics from each found LogEntry.
+
+  def process
+    File.open @logfile_name do |fp|
+      LogParser.parse fp do |entry|
+        entry_page = entry.page
+        next if entry_page.nil?
+        @request_times[entry_page] << entry.request_time
+        @db_times[entry_page] << entry.db_time
+        @render_times[entry_page] << entry.render_time
+      end
+    end
+  end
 
-    ##
-    # Creates a new Analyzer that will read data from +logfile_name+.
+  ##
+  # The average total request time for all requests.
 
-    def initialize(logfile_name)
-        @logfile_name  = logfile_name
-        @request_times = Hash.new { |h,k| h[k] = [] }
-        @db_times      = Hash.new { |h,k| h[k] = [] }
-        @render_times  = Hash.new { |h,k| h[k] = [] }
-#        @query_times   = Hash.new { |h,k| h[k] = [] }
-    end
+  def average_request_time
+    return time_average(@request_times)
+  end
 
-    ##
-    # Processes the log file collecting statistics from each found LogEntry.
-
-    def process
-        File.open @logfile_name do |fp|
-            LogParser.parse fp do |entry|
-                entry_page = entry.page
-                @request_times[entry_page] << entry.request_time
-                @db_times[entry_page] << entry.db_time
-                @render_times[entry_page] << entry.render_time
-            end
-        end
-    end
+  ##
+  # The standard deviation of the total request time for all requests.
 
-    ##
-    # The average total request time for all requests.
+  def request_time_std_dev
+    return time_std_dev(@request_times)
+  end
 
-    def average_request_time
-        return time_average(@request_times)
-    end
+  ##
+  # The +limit+ slowest total request times.
 
-    ##
-    # The standard deviation of the total request time for all requests.
+  def slowest_request_times(limit = 10)
+    return slowest_times(@request_times, limit)
+  end
 
-    def request_time_std_dev
-        return time_std_dev(@request_times)
-    end
+  ##
+  # The average total database time for all requests.
 
-    ##
-    # The +limit+ slowest total request times.
+  def average_db_time
+    return time_average(@db_times)
+  end
 
-    def slowest_request_times(limit = 10)
-        return slowest_times(@request_times, limit)
-    end
+  ##
+  # The standard deviation of the total database time for all requests.
 
-    ##
-    # The average total database time for all requests.
+  def db_time_std_dev
+    return time_std_dev(@db_times)
+  end
 
-    def average_db_time
-        return time_average(@db_times)
-    end
+  ##
+  # The +limit+ slowest total database times.
 
-    ##
-    # The standard deviation of the total database time for all requests.
+  def slowest_db_times(limit = 10)
+    return slowest_times(@db_times, limit)
+  end
 
-    def db_time_std_dev
-        return time_std_dev(@db_times)
-    end
+  ##
+  # The average total render time for all requests.
 
-    ##
-    # The +limit+ slowest total database times.
+  def average_render_time
+    return time_average(@render_times)
+  end
 
-    def slowest_db_times(limit = 10)
-        return slowest_times(@db_times, limit)
-    end
+  ##
+  # The standard deviation of the total render time for all requests.
 
-    ##
-    # The average total render time for all requests.
+  def render_time_std_dev
+    return time_std_dev(@render_times)
+  end
 
-    def average_render_time
-        return time_average(@render_times)
-    end
+  ##
+  # The +limit+ slowest total render times for all requests.
 
-    ##
-    # The standard deviation of the total render time for all requests.
+  def slowest_render_times(limit = 10)
+    return slowest_times(@render_times, limit)
+  end
 
-    def render_time_std_dev
-        return time_std_dev(@render_times)
-    end
+  ##
+  # A list of count/min/max/avg/std dev for request times.
 
-    ##
-    # The +limit+ slowest total render times for all requests.
+  def request_times_summary
+    return summarize("Request Times", @request_times)
+  end
 
-    def slowest_render_times(limit = 10)
-        return slowest_times(@render_times, limit)
-    end
+  ##
+  # A list of count/min/max/avg/std dev for database times.
 
-    ##
-    # A list of count/min/max/avg/std dev for request times.
+  def db_times_summary
+    return summarize("DB Times", @db_times)
+  end
 
-    def request_times_summary
-        return summarize("Request Times", @request_times)
-    end
+  ##
+  # A list of count/min/max/avg/std dev for request times.
 
-    ##
-    # A list of count/min/max/avg/std dev for database times.
+  def render_times_summary
+    return summarize("Render Times", @render_times)
+  end
 
-    def db_times_summary
-        return summarize("DB Times", @db_times)
-    end
+  ##
+  # Builds a report containing +count+ slow items.
 
-    ##
-    # A list of count/min/max/avg/std dev for request times.
+  def report(count)
+    return "No requests to analyze" if request_times.empty?
 
-    def render_times_summary
-        return summarize("Render Times", @render_times)
-    end
+    text = []
 
-    ##
-    # Builds a report containing +count+ slow items.
-
-    def report(count)
-        text = []
-
-        text << request_times_summary
-        text << nil
-        text << "Slowest Request Times:"
-        slowest_request_times(count).each do |time, name|
-            text << "\t#{name} took #{'%0.3f' % time}s"
-        end
-        text << nil
-        text << "-" * 72
-        text << nil
-
-        text << db_times_summary
-        text << nil
-        text << "Slowest Total DB Times:"
-        slowest_db_times(count).each do |time, name|
-            text << "\t#{name} took #{'%0.3f' % time}s"
-        end
-        text << nil
-        text << "-" * 72
-        text << nil
-
-        text << render_times_summary
-        text << nil
-        text << "Slowest Total Render Times:"
-        slowest_render_times(count).each do |time, name|
-            text << "\t#{name} took #{'%0.3f' % time}s"
-        end
-        text << nil
-
-        return text.join($/)
+    text << request_times_summary
+    text << nil
+    text << "Slowest Request Times:"
+    slowest_request_times(count).each do |time, name|
+      text << "\t#{name} took #{'%0.3f' % time}s"
     end
+    text << nil
+    text << "-" * 72
+    text << nil
+
+    text << db_times_summary
+    text << nil
+    text << "Slowest Total DB Times:"
+    slowest_db_times(count).each do |time, name|
+      text << "\t#{name} took #{'%0.3f' % time}s"
+    end
+    text << nil
+    text << "-" * 72
+    text << nil
+
+    text << render_times_summary
+    text << nil
+    text << "Slowest Total Render Times:"
+    slowest_render_times(count).each do |time, name|
+      text << "\t#{name} took #{'%0.3f' % time}s"
+    end
+    text << nil
 
-    private unless $TESTING
+    return text.join($/)
+  end
 
-    def summarize(title, records) # :nodoc:
-        record = nil
-        list = []
+  private unless $TESTING
 
-        # header
-        record = [pad_request_name("#{title} Summary"), 'Count', 'Avg',
-                  'Std Dev', 'Min', 'Max']
-        list << record.join("\t")
+  def summarize(title, records) # :nodoc:
+    record = nil
+    list = []
 
-        # all requests
-        times = records.values.flatten
-        record = [times.average, times.standard_deviation, times.min, times.max]
-        record.map! { |v| "%0.3f" % v }
-        record.unshift [pad_request_name('ALL REQUESTS'), times.size]
-        list << record.join("\t")
+    # header
+    record = [pad_request_name("#{title} Summary"), 'Count', 'Avg', 'Std Dev',
+              'Min', 'Max']
+    list << record.join("\t")
 
-        # spacer
-        list << nil
+    # all requests
+    times = records.values.flatten
+    record = [times.average, times.standard_deviation, times.min, times.max]
+    record.map! { |v| "%0.3f" % v }
+    record.unshift [pad_request_name('ALL REQUESTS'), times.size]
+    list << record.join("\t")
 
-        records.sort_by { |k,v| v.size}.reverse_each do |req, times|
-            record = [times.average, times.standard_deviation,
-                      times.min, times.max]
-            record.map! { |v| "%0.3f" % v }
-            record.unshift ["#{pad_request_name req}", times.size]
-            list << record.join("\t")
-        end
+    # spacer
+    list << nil
 
-        return list.join("\n")
+    records.sort_by { |k,v| v.size}.reverse_each do |req, times|
+      record = [times.average, times.standard_deviation, times.min, times.max]
+      record.map! { |v| "%0.3f" % v }
+      record.unshift ["#{pad_request_name req}", times.size]
+      list << record.join("\t")
     end
 
-    def slowest_times(records, limit) # :nodoc:
-        slowest_times = SlowestTimes.new limit
+    return list.join("\n")
+  end
 
-        records.each do |name, times|
-            times.each do |time|
-                slowest_times << [time, name]
-            end
-        end
+  def slowest_times(records, limit) # :nodoc:
+    slowest_times = SlowestTimes.new limit
 
-        return slowest_times.sort_by { |time, name| time }.reverse
+    records.each do |name, times|
+      times.each do |time|
+        slowest_times << [time, name]
+      end
     end
 
-    def time_average(records) # :nodoc:
-        times = records.values.flatten
-        times.delete 0
-        return times.average
-    end
-
-    def time_std_dev(records) # :nodoc:
-        times = records.values.flatten
-        times.delete 0
-        return times.standard_deviation
-    end
+    return slowest_times.sort_by { |time, name| time }.reverse
+  end
 
-    def longest_request_name # :nodoc:
-        return @longest_req if defined? @longest_req
+  def time_average(records) # :nodoc:
+    times = records.values.flatten
+    times.delete 0
+    return times.average
+  end
 
-        names = @request_times.keys.map do |name|
-            (name||'Unknown').length + 1 # + : - HACK where does nil come from?
-        end
+  def time_std_dev(records) # :nodoc:
+    times = records.values.flatten
+    times.delete 0
+    return times.standard_deviation
+  end
 
-        @longest_req = names.max
+  def longest_request_name # :nodoc:
+    return @longest_req if defined? @longest_req
 
-        return @longest_req
+    names = @request_times.keys.map do |name|
+      (name||'Unknown').length + 1 # + : - HACK where does nil come from?
     end
 
-    def pad_request_name(name) # :nodoc:
-        name = (name||'Unknown') + ':' # HACK where does nil come from?
-        name += (' ' * (longest_request_name - name.length))
-    end
+    @longest_req = names.max
 
-end
+    @longest_req = 'Unknown'.length + 1 if @longest_req.nil?
+
+    return @longest_req
+  end
 
-# vim: ts=4 sts=4 sw=4
+  def pad_request_name(name) # :nodoc:
+    name = (name||'Unknown') + ':' # HACK where does nil come from?
+    padding_width = longest_request_name - name.length
+    padding_width = 0 if padding_width < 0
+    name += (' ' * padding_width)
+  end
+
+end