rails_analyzer_tools 1.0.0 → 1.1.0

data/Manifest.txt

@@ -1,6 +1,12 @@
 Manifest.txt
 Rakefile
 README
+bin/bench
+bin/crawl
 bin/rails_stat
 lib/io_tail.rb
-lib/rails_stat.rb
+lib/analyzer_tools/bench.rb
+lib/analyzer_tools/crawl.rb
+lib/analyzer_tools/rails_stat.rb
+lib/analyzer_tools/syslog_logger.rb
+test/test_syslog_logger.rb

data/README

@@ -1,15 +1,61 @@
-Currently, Rails Analyzer Tools contains just one tool, RailsStat, and one
-library extension, IOTail.
+Rails Analyzer Tools contains Bench, Crawler, RailsStat, IOTail and
+SyslogLogger libraries, and the programs bench, crawl and rails_stat based on
+these libraries.
+
+I have used bench and crawl to tune the number of FastCGI processes running on
+43things.com, determine if HyperThreading would give a performance benefit or
+not (it did) and find a fatal threading bug in MySQL.
+
+rails_stat is useful to see how much traffic your Rails site is doing.
+
+== Bench
+
+Bench lets you benchmark the performance of a particular page.  Simply give
+the URL, the number of requests to run and the number of threads to run in
+parallel.
+
+You really, really, really don't want to run bench against a live website.
+
+  $ bench -u http://coop.robotcoop.com/ -r 50 -c 2
+  50....45....40....35....30....25....20....15....10....5....
+  Total time: 10.7073893547058
+  Average time: 0.214147787094116
+
+== Crawler
+
+Crawler lets you exercise a server by crawling it really fast.  It picks URLs
+at random from the returned page and always stays on the same host.  When you
+kill it with a ^C it prints out a summary.
+
+You really, really, really don't want to run crawl against a live website.
+
+  $ crawl -u http://coop.robotcoop.com/ -c 2
+  >>> http://coop.robotcoop.com/
+  GET / HTTP/1.0
+  Host: coop.robotcoop.com
+  User-Agent: RubyCrawl
+
+  ...
+
+  ^C
+  Total time: 0.355171680450439
+  Requests: 3
+  Average time: 0.118390560150146
 
 == RailsStat
 
 RailsStat displays the approximate number of requests, queries, and lines
-logged per second in 10 second intervals.  Simply give it the path to your
-production log for a live Rails site and you're done:
+logged per second in 10 (or whatever) second intervals.  Simply give it the
+path to your production log for a live Rails site and you're done:
 
   $ rails_stat /var/log/production.log
   ~ 2.1 req/sec, 23.0 queries/sec, 32.8 lines/sec
 
+== SyslogLogger
+
+SyslogLogger is a Logger replacement that logs to syslog.  It is almost
+drop-in with a few caveats.
+
 == IOTail
 
 IOTail tails a file like the tail system utility.  This lets you collect data

data/Rakefile

@@ -8,55 +8,54 @@ require 'rake/contrib/sshpublisher'
 $VERBOSE = nil
 
 spec = Gem::Specification.new do |s|
-    s.name = "rails_analyzer_tools"
-    s.version = "1.0.0"
-    s.summary = "Various tools and toys"
-    s.author = "Eric Hodel"
-    s.email = "eric@robotcoop.com"
-
-    s.has_rdoc = true
-    s.files = File.read("Manifest.txt").split($/)
-    s.require_path = 'lib'
-    s.executables = ["rails_stat"]
+  s.name = 'rails_analyzer_tools'
+  s.version = '1.1.0'
+  s.summary = 'Tools for analyzing the performance of web sites.'
+  s.author = 'Eric Hodel'
+  s.email = 'eric@robotcoop.com'
+
+  s.has_rdoc = true
+  s.files = File.read('Manifest.txt').split($/)
+  s.require_path = 'lib'
+  s.executables = %w[rails_stat bench crawl]
 end
 
-desc "Run tests"
+desc 'Run tests'
 task :default => [ :test ]
 
-Rake::TestTask.new("test") do |t|
-    t.libs << "test"
-    t.libs << "lib"
-    t.pattern = "test/test_*.rb"
-    t.verbose = true
+Rake::TestTask.new('test') do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.pattern = 'test/test_*.rb'
+  t.verbose = true
 end
 
-desc "Generate RDoc"
+desc 'Generate RDoc'
 Rake::RDocTask.new :rdoc do |rd|
-    rd.rdoc_dir = "doc"
-    rd.rdoc_files.add "lib", "README"
-    rd.main = "README"
-    rd.options << "-d" if `which dot` =~ /\/dot/
+  rd.rdoc_dir = 'doc'
+  rd.rdoc_files.add 'lib', 'README'
+  rd.main = 'README'
+  rd.options << '-d' if `which dot` =~ /\/dot/
 end
 
-desc "Build Gem"
+desc 'Build Gem'
 Rake::GemPackageTask.new spec do |pkg|
-    pkg.need_zip = true
-    pkg.need_tar = true
+  pkg.need_tar = true
 end
 
-desc "Sends RDoc to RubyForge"
+desc 'Sends RDoc to RubyForge'
 task :send_rdoc => [ :rerdoc ] do
-    publisher = Rake::SshDirPublisher.new('drbrain@rubyforge.org',
-                    '/var/www/gforge-projects/rails-analyzer/hacks',
-                    'doc')
-    publisher.upload
+  publisher = Rake::SshDirPublisher.new('drbrain@rubyforge.org',
+                                        '/var/www/gforge-projects/rails-analyzer/hacks',
+                                        'doc')
+  publisher.upload
 end
 
-desc "Clean up"
+desc 'Clean up'
 task :clean => [ :clobber_rdoc, :clobber_package ]
 
-desc "Clean up"
+desc 'Clean up'
 task :clobber => [ :clean ]
 
-# vim: ts=4 sts=4 sw=4 syntax=Ruby
+# vim: syntax=Ruby
 

data/bin/bench

@@ -0,0 +1,53 @@
+#!/usr/local/bin/ruby -w
+
+Thread.abort_on_exception = true
+
+require 'optparse'
+require 'analyzer_tools/bench'
+
+OptionParser.accept URI do |u,|
+  begin
+    URI.parse u if u
+  rescue ArgumentError
+    raise OptionParser::InvalidArgument, u
+  end
+end
+
+uri = nil
+requests = nil
+concurrency = nil
+
+opts = OptionParser.new do |opts|
+  opts.banner = "Usage: #{$PROGRAM_NAME} [options]"
+  opts.separator ""
+
+  opts.on("-u", "--url URL", URI, "URL to access") do |val|
+    uri = val
+  end
+
+  opts.on("-r", "--requests REQUESTS", Integer, "Requests to send") do |val|
+    requests = val
+  end
+
+  opts.separator ""
+
+  opts.on("-c", "--concurrency THREADS", Integer,
+          "Concurrent requests to make") do |val|
+            concurrency = val
+          end
+
+end
+
+opts.parse!
+
+if uri.nil? or requests.nil? then
+  puts opts
+  exit
+end
+
+bench = Bench.new uri, requests, concurrency
+times = bench.run
+
+puts "Total time: #{times.inject(0) { |a,t| a + t }}"
+puts "Average time: #{times.inject(0) { |a,t| a + t } / times.length}"
+

data/bin/crawl

@@ -0,0 +1,57 @@
+#!/usr/local/bin/ruby -w
+
+Thread.abort_on_exception = true
+
+require 'optparse'
+require 'analyzer_tools/crawl'
+
+OptionParser.accept URI do |u,|
+  begin
+    URI.parse u if u
+  rescue ArgumentError
+    raise OptionParser::InvalidArgument, u
+  end
+end
+
+start_url = nil
+concurrency = 1
+
+opts = OptionParser.new do |opts|
+  opts.banner = "Usage: #{$PROGRAM_NAME} -u URL [-c CONCURRENCY]"
+  opts.separator ""
+
+  opts.on("-u", "--url URL", URI, "starting URL") do |val|
+    start_url = val
+    start_url.path = '/' if start_url.path.empty?
+  end
+
+  opts.separator ""
+
+  opts.on("-c", "--concurrency THREADS", Integer,
+          "Concurrent requests to make") do |val|
+    concurrency = val
+  end
+
+end
+
+opts.parse!
+
+if start_url.nil? then
+  STDERR.puts opts
+  exit 1
+end
+
+crawler = Crawler.new start_url, concurrency
+
+trap 'INT' do
+  crawler.stop
+  times = crawler.times
+  puts
+  puts "Total time: #{times.inject(0) { |a,t| a + t }}"
+  puts "Requests: #{times.length}"
+  puts "Average time: #{times.inject(0) { |a,t| a + t } / times.length}"
+  exit
+end
+
+crawler.run
+

data/bin/rails_stat

@@ -1,14 +1,15 @@
 #!/usr/local/bin/ruby -w
 
 require 'io_tail'
-require 'rails_stat'
+require 'analyzer_tools/rails_stat'
 
 filename = ARGV.shift
+interval = ARGV.shift || 10
 
 if filename.nil? then
-  STDERR.puts "Usage: #{$0} RAILS_LOG"
+  STDERR.puts "Usage: #{$0} RAILS_LOG [PRINT_INTERVAL]"
   exit 1
 end
 
-RailsStat.start filename
+RailsStat.start filename, interval
 

data/lib/analyzer_tools/bench.rb

@@ -0,0 +1,97 @@
+require 'socket'
+require 'thread'
+require 'uri'
+
+##
+# Bench measures load time for a particular page.  You can run it
+# multi-threaded to test web server performance, or single threaded to test
+# the performance of a single page.
+
+class Bench
+
+  ##
+  # Creates a new Bench instance that will +requests+ fetches of +uri+ using
+  # +thread+ concurrent threads.
+
+  def initialize(uri, requests, threads = 1)
+    raise ArgumentError, "Thread count must be more than 0" if threads < 1
+    @uri = uri
+    @total_requests = requests
+    @tenths = @total_requests > 10 ? @total_requests / 10 : 1
+    @hundredths = @total_requests > 100 ? @total_requests / 100 : 1
+    @num_requests = requests
+    @threads = threads
+  end
+
+  ##
+  # Starts the benchmark.  Returns an Array of request times in seconds.
+
+  def run
+    done = false
+    times = []
+    threads = ThreadGroup.new
+    count_m = Mutex.new
+
+    @threads.times do
+      Thread.start do
+        threads.add Thread.current
+        until @num_requests <= 0 do
+          count_m.synchronize do
+            if @num_requests % @tenths == 0 then
+              print @num_requests
+            elsif @num_requests % @hundredths == 0 then
+              print '.'
+            end
+            @num_requests -= 1
+          end
+          STDOUT.flush
+          times << time_request
+        end
+      end
+      Thread.pass
+    end
+
+    threads.enclose
+
+    threads.list.each { |t| t.join }
+    puts
+
+    return times
+  end
+
+  ##
+  # Performs a request.
+
+  def do_request
+    s = TCPSocket.new @uri.host, @uri.port
+    s.puts "GET #{@uri.request_uri} HTTP/1.0\r\n"
+    s.puts "Host: #{@uri.host}\r\n"
+    s.puts "User-Agent: RubyBench\r\n"
+    s.puts "\r\n"
+    s.flush
+    response = s.read
+  ensure
+    s.close unless s.nil?
+  end
+
+  ##
+  # Returns the amount of time taken to execute the given block.
+
+  def time
+    start_time = Time.now.to_f
+    yield
+    end_time = Time.now.to_f
+    return end_time - start_time
+  end
+
+  ##
+  # Returns the time taken to perform a request.
+
+  def time_request
+    time do
+      do_request
+    end
+  end
+
+end
+

data/lib/analyzer_tools/crawl.rb

@@ -0,0 +1,142 @@
+require 'socket'
+require 'thread'
+require 'uri'
+
+##
+# A fast web crawler that stays on the site it started from.  Crawler
+# randomly picks a URL from the page retrieved and follows it.  If
+# can't find a URL for the next page, Crawler starts over from the
+# beginning.
+#
+# Crawler is multi-threaded and can run as many threads as you
+# choose.
+
+class Crawler
+
+  ##
+  # Array of response times in seconds.
+
+  attr_reader :times
+
+  ##
+  # Creates a new Crawler that will start at +start_url+ and run +threads+
+  # concurrent threads.
+
+  def initialize(start_url, threads = 1)
+    raise ArgumentError, "Thread count must be more than 0" if threads < 1
+    @start_url = start_url
+    @thread_count = threads
+    @threads = ThreadGroup.new
+    @times = []
+  end
+
+  ##
+  # Begins crawling.
+
+  def run
+    url = @start_url
+
+    @thread_count.times do
+      Thread.start do
+        @threads.add Thread.current
+        loop do
+          puts ">>> #{url}"
+          body = timed_request url
+          url = extract_url_from body, url
+        end
+      end
+      Thread.pass
+    end
+
+    @threads.list.first.join until @threads.list.empty?
+  end
+
+  ##
+  # Stops crawling.
+
+  def stop
+    @threads.list.first.kill until @threads.list.empty?
+  end
+
+  ##
+  # Performs a request of +url+ and returns the request body.
+
+  def do_request(url)
+    req = []
+    req << "GET #{url.request_uri} HTTP/1.0"
+    req << "Host: #{url.host}" 
+    req << "User-Agent: RubyCrawl"
+    req << ""
+    req << ""
+    req = req.join "\r\n"
+    puts req
+
+    begin
+      s = TCPSocket.new url.host, url.port
+      s.write req
+      s.flush
+      response = s.read
+    ensure
+      s.close unless s.nil?
+    end
+
+    headers, body = response.split(/\r\n\r\n/)
+
+    headers = headers.split(/\r\n/)
+    status = headers.shift
+    headers = Hash[*headers.map { |h| h.split ': ', 2 }.flatten]
+
+    puts status
+
+    case status
+    when / 302 / then
+      body = "href=\"#{headers['Location']}\""
+    when / 500 / then
+      body = "href=\"#{@start_url}\""
+    end
+
+    return body
+  end
+
+  ##
+  # Returns the amount of time taken to execute the given block.
+
+  def time
+    start_time = Time.now.to_f
+    yield
+    end_time = Time.now.to_f
+    return end_time - start_time
+  end
+
+  ##
+  # Performs a request of +url+ and records the time taken into times.
+  # Returns the body of the request.
+
+  def timed_request(url)
+    body = nil
+    @times << time { body = do_request(url) }
+    return body
+  end
+
+  ##
+  # Returns a random URL on the same site as +original_url+ from +body+ using
+  # +original_url+ to resolve relative paths.  If no URL valid is found then
+  # the start URL is returned.
+
+  def extract_url_from(body, original_url)
+    urls = body.scan(/href="(.+?)"/)
+    until urls.empty? do
+      begin
+        rand_url = urls.delete_at(rand(urls.length)).first
+        new_url = original_url + rand_url
+        return new_url if new_url.host == original_url.host
+      rescue URI::InvalidURIError
+        retry
+      end
+    end
+
+    return @start_url
+  end
+
+end
+

data/lib/{rails_stat.rb → analyzer_tools/rails_stat.rb}

@@ -2,16 +2,16 @@ require 'thread'
 
 ##
 # RailsStat displays a the current requests, queries and lines logged per
-# second in 10 second intervals.
+# second.  Default interval is 10 seconds.
 
 class RailsStat
   
   ##
-  # Starts a new RailsStat for +filename+.
+  # Starts a new RailsStat for +filename+ that prints every +interval+ seconds.
 
-  def self.start(filename)
+  def self.start(filename, interval = 10)
     File.open filename do |fp|
-      self.new(fp).start
+      self.new(fp).start(interval)
     end
   end
 
@@ -27,20 +27,21 @@ class RailsStat
   end
 
   ##
-  # Starts the RailsStat running.
+  # Starts the RailsStat running.  This method never returns.
 
-  def start
+  def start(interval)
     trap('INT') { exit }
-    start_printer
+    start_printer interval
     read_log
   end
 
   private
 
   ##
-  # Starts a thread that prints log information every 10 seconds.
+  # Starts a thread that prints log information every +interval+ seconds.
 
-  def start_printer
+  def start_printer(interval)
+    interval = interval.to_f
     Thread.start do
       last_len = 0
       lines_sec = 0
@@ -48,12 +49,12 @@ class RailsStat
       queries_sec = 0
 
       loop do
-        sleep 10
+        sleep interval
 
         @mutex.synchronize do
-          lines_sec = @lines / 10.0
-          count_sec = @count / 10.0
-          queries_sec = @queries / 10.0
+          lines_sec = @lines / interval
+          count_sec = @count / interval
+          queries_sec = @queries / interval
           @lines = 0
           @count = 0
           @queries = 0

data/lib/analyzer_tools/syslog_logger.rb

@@ -0,0 +1,171 @@
+require 'syslog'
+require 'logger'
+
+##
+# SyslogLogger is a Logger work-alike that logs via syslog instead of to a
+# file.  You can add SyslogLogger to your Rails production environment to
+# aggregate logs between multiple machines.
+#
+# By default, SyslogLogger uses the program name 'rails', but this can be
+# changed via the first argument to SyslogLogger.new.
+#
+# NOTE! You can only set the SyslogLogger program name when you initialize
+# SyslogLogger for the first time.  This is a limitation of the way
+# SyslogLogger uses syslog (and in some ways, a the way syslog(3) works).
+# Attempts to change SyslogLogger's program name after the first
+# initialization will be ignored.
+#
+# = Sample usage with Rails
+# 
+# == config/environment/production.rb
+#
+# Add the following lines:
+# 
+#   require 'production_log/syslog_logger'
+#   RAILS_DEFAULT_LOGGER = SyslogLogger.new
+#
+# == config/environment.rb
+#
+# In 0.10.0, change this line:
+# 
+#   RAILS_DEFAULT_LOGGER = Logger.new("#{RAILS_ROOT}/log/#{RAILS_ENV}.log")
+#
+# to:
+#
+#   RAILS_DEFAULT_LOGGER ||= Logger.new("#{RAILS_ROOT}/log/#{RAILS_ENV}.log")
+#
+# Other versions of Rails should have a similar change.
+#
+# == /etc/syslog.conf
+#
+# Add the following lines:
+# 
+#  !rails
+#  *.*                                             /var/log/production.log
+#
+# Then touch /var/log/production.log and signal syslogd with a HUP
+# (killall -HUP syslogd, on FreeBSD).
+#
+# == /etc/newsyslog.conf
+#
+# Add the following line:
+# 
+#   /var/log/production.log                 640  7     *    @T00  Z
+# 
+# This creates a log file that is rotated every day at midnight, gzip'd, then
+# kept for 7 days.  Consult newsyslog.conf(5) for more details.
+#
+# Now restart your Rails app.  Your production logs should now be showing up
+# in /var/log/production.log.  If you have mulitple machines, you can log them
+# all to a central machine with remote syslog logging for analysis.  Consult
+# your syslogd(8) manpage for further details.
+
+class SyslogLogger
+
+    ##
+    # Maps Logger warning types to syslog(3) warning types.
+
+    LOGGER_MAP = {
+        :unknown => :alert,
+        :fatal   => :err,
+        :error   => :warning,
+        :warn    => :notice,
+        :info    => :info,
+        :debug   => :debug,
+    }
+
+    ##
+    # Maps Logger log levels to their values so we can silence.
+
+    LOGGER_LEVEL_MAP = {}
+
+    LOGGER_MAP.each_key do |key|
+        LOGGER_LEVEL_MAP[key] = Logger.const_get key.to_s.upcase
+    end
+
+    ##
+    # Maps Logger log level values to syslog log levels.
+
+    LEVEL_LOGGER_MAP = {}
+
+    LOGGER_LEVEL_MAP.invert.each do |level, severity|
+        LEVEL_LOGGER_MAP[level] = LOGGER_MAP[severity]
+    end
+
+    ##
+    # Builds a logging method for level +meth+.
+
+    def self.log_method(meth)
+        eval <<-EOM, nil, __FILE__, __LINE__ + 1
+            def #{meth}(message = nil)
+                return true if #{LOGGER_LEVEL_MAP[meth]} < @level
+                SYSLOG.#{LOGGER_MAP[meth]} clean(message || yield)
+                return true
+            end
+        EOM
+    end
+
+    LOGGER_MAP.each_key do |level|
+        log_method level
+    end
+
+    ##
+    # Log level for Logger compatibility.
+
+    attr_accessor :level
+
+    ##
+    # Fills in variables for Logger compatibility.  If this is the first
+    # instance of SyslogLogger, +program_name+ may be set to change the logged
+    # program name.
+    #
+    # Due to the way syslog works, only one program name may be chosen.
+
+    def initialize(program_name = 'rails')
+        @level = Logger::DEBUG
+
+        return if defined? SYSLOG
+        self.class.const_set :SYSLOG, Syslog.open(program_name)
+    end
+
+    ##
+    # Almost duplicates Logger#add.  +progname+ is ignored.
+
+    def add(severity, message = nil, progname = nil, &block)
+        severity ||= Logger::UNKNOWN
+        return true if severity < @level
+        message = clean(message || block.call)
+        SYSLOG.send LEVEL_LOGGER_MAP[severity], clean(message)
+        return true
+    end
+
+    ##
+    # Allows messages of a particular log level to be ignored temporarily.
+    #
+    # Can you say "Broken Windows"?
+
+    def silence(temporary_level = Logger::ERROR)
+        old_logger_level = @level
+        @level = temporary_level 
+        yield
+    ensure
+        @level = old_logger_level
+    end
+
+    private
+
+    ##
+    # Clean up messages so they're nice and pretty.
+
+    def clean(message)
+        message = message.to_s.dup
+        message.strip!
+        message.gsub!(/%/, '%%') # syslog(3) freaks on % (printf)
+        message.gsub!(/\e\[[^m]*m/, '') # remove useless ansi color codes
+        return message
+    end
+
+end
+
+# vim: ts=4 sts=4 sw=4
+

data/lib/io_tail.rb

@@ -14,7 +14,7 @@ module IOTail
     self.gets
 
     loop do
-      self.each_line &block
+      self.each_line(&block)
 
       if self.eof? then
         sleep 0.25

data/test/test_syslog_logger.rb

@@ -0,0 +1,443 @@
+require 'test/unit'
+require 'tempfile'
+require 'analyzer_tools/syslog_logger'
+
+module MockSyslog; end
+
+class << MockSyslog
+
+  @line = nil
+
+  SyslogLogger::LOGGER_MAP.values.uniq.each do |level|
+    eval <<-EOM
+      def #{level}(message)
+        @line = "#{level.to_s.upcase} - \#{message}"
+      end
+    EOM
+  end
+
+  attr_reader :line
+  attr_reader :program_name
+
+  def open(program_name)
+    @program_name = program_name
+  end
+
+  def reset
+    @line = ''
+  end
+
+end
+
+SyslogLogger.const_set :SYSLOG, MockSyslog
+
+class TestLogger < Test::Unit::TestCase
+
+  LEVEL_LABEL_MAP = {
+    Logger::DEBUG => 'DEBUG',
+    Logger::INFO => 'INFO',
+    Logger::WARN => 'WARN',
+    Logger::ERROR => 'ERROR',
+    Logger::FATAL => 'FATAL',
+    Logger::UNKNOWN => 'ANY',
+  }
+
+  def setup
+    @logger = Logger.new(nil)
+  end
+
+  class Log
+    attr_reader :line, :label, :datetime, :pid, :severity, :progname, :msg
+    def initialize(line)
+      @line = line
+      /\A(\w+), \[([^#]*)#(\d+)\]\s+(\w+) -- (\w*): ([\x0-\xff]*)/ =~ @line
+      @label, @datetime, @pid, @severity, @progname, @msg = $1, $2, $3, $4, $5, $6
+    end
+  end
+
+  def log_add(severity, msg, progname = nil, &block)
+    log(:add, severity, msg, progname, &block)
+  end
+
+  def log(msg_id, *arg, &block)
+    Log.new(log_raw(msg_id, *arg, &block))
+  end
+
+  def log_raw(msg_id, *arg, &block)
+    logdev = Tempfile.new(File.basename(__FILE__) + '.log')
+    @logger.instance_eval { @logdev = Logger::LogDevice.new(logdev) }
+    assert_equal true, @logger.__send__(msg_id, *arg, &block)
+    logdev.open
+    msg = logdev.read
+    logdev.close
+    msg
+  end
+
+  def test_initialize
+    assert_equal Logger::DEBUG, @logger.level
+  end
+
+  def test_add
+    msg = log_add nil,           'unknown level message' # nil == unknown
+    assert_equal LEVEL_LABEL_MAP[Logger::UNKNOWN], msg.severity
+
+    msg = log_add Logger::FATAL, 'fatal level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::FATAL],   msg.severity
+
+    msg = log_add Logger::ERROR, 'error level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::ERROR],   msg.severity
+
+    msg = log_add Logger::WARN,  'warn level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::WARN],    msg.severity
+
+    msg = log_add Logger::INFO,  'info level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::INFO],    msg.severity
+
+    msg = log_add Logger::DEBUG, 'debug level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::DEBUG],   msg.severity
+  end
+
+  def test_add_level_unknown
+    @logger.level = Logger::UNKNOWN
+
+    msg = log_add nil,           'unknown level message' # nil == unknown
+    assert_equal LEVEL_LABEL_MAP[Logger::UNKNOWN], msg.severity
+
+    msg = log_add Logger::FATAL, 'fatal level message'
+    assert_equal '', msg.line
+
+    msg = log_add Logger::ERROR, 'error level message'
+    assert_equal '', msg.line
+
+    msg = log_add Logger::WARN,  'warn level message'
+    assert_equal '', msg.line
+
+    msg = log_add Logger::INFO,  'info level message'
+    assert_equal '', msg.line
+
+    msg = log_add Logger::DEBUG, 'debug level message'
+    assert_equal '', msg.line
+  end
+
+  def test_add_level_fatal
+    @logger.level = Logger::FATAL
+
+    msg = log_add nil,           'unknown level message' # nil == unknown
+    assert_equal LEVEL_LABEL_MAP[Logger::UNKNOWN], msg.severity
+
+    msg = log_add Logger::FATAL, 'fatal level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::FATAL],   msg.severity
+
+    msg = log_add Logger::ERROR, 'error level message'
+    assert_equal '', msg.line
+
+    msg = log_add Logger::WARN,  'warn level message'
+    assert_equal '', msg.line
+
+    msg = log_add Logger::INFO,  'info level message'
+    assert_equal '', msg.line
+
+    msg = log_add Logger::DEBUG, 'debug level message'
+    assert_equal '', msg.line
+  end
+
+  def test_add_level_error
+    @logger.level = Logger::ERROR
+
+    msg = log_add nil,           'unknown level message' # nil == unknown
+    assert_equal LEVEL_LABEL_MAP[Logger::UNKNOWN], msg.severity
+
+    msg = log_add Logger::FATAL, 'fatal level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::FATAL],   msg.severity
+
+    msg = log_add Logger::ERROR, 'error level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::ERROR],   msg.severity
+
+    msg = log_add Logger::WARN,  'warn level message'
+    assert_equal '', msg.line
+
+    msg = log_add Logger::INFO,  'info level message'
+    assert_equal '', msg.line
+
+    msg = log_add Logger::DEBUG, 'debug level message'
+    assert_equal '', msg.line
+  end
+
+  def test_add_level_warn
+    @logger.level = Logger::WARN
+
+    msg = log_add nil,           'unknown level message' # nil == unknown
+    assert_equal LEVEL_LABEL_MAP[Logger::UNKNOWN], msg.severity
+
+    msg = log_add Logger::FATAL, 'fatal level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::FATAL],   msg.severity
+
+    msg = log_add Logger::ERROR, 'error level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::ERROR],   msg.severity
+
+    msg = log_add Logger::WARN,  'warn level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::WARN],   msg.severity
+
+    msg = log_add Logger::INFO,  'info level message'
+    assert_equal '', msg.line
+
+    msg = log_add Logger::DEBUG, 'debug level message'
+    assert_equal '', msg.line
+  end
+
+  def test_add_level_info
+    @logger.level = Logger::INFO
+
+    msg = log_add nil,           'unknown level message' # nil == unknown
+    assert_equal LEVEL_LABEL_MAP[Logger::UNKNOWN], msg.severity
+
+    msg = log_add Logger::FATAL, 'fatal level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::FATAL],   msg.severity
+
+    msg = log_add Logger::ERROR, 'error level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::ERROR],   msg.severity
+
+    msg = log_add Logger::WARN,  'warn level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::WARN],    msg.severity
+
+    msg = log_add Logger::INFO,  'info level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::INFO],    msg.severity
+
+    msg = log_add Logger::DEBUG, 'debug level message'
+    assert_equal '', msg.line
+  end
+
+  def test_add_level_debug
+    @logger.level = Logger::DEBUG
+
+    msg = log_add nil,           'unknown level message' # nil == unknown
+    assert_equal LEVEL_LABEL_MAP[Logger::UNKNOWN], msg.severity
+
+    msg = log_add Logger::FATAL, 'fatal level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::FATAL],   msg.severity
+
+    msg = log_add Logger::ERROR, 'error level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::ERROR],   msg.severity
+
+    msg = log_add Logger::WARN,  'warn level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::WARN],    msg.severity
+
+    msg = log_add Logger::INFO,  'info level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::INFO],    msg.severity
+
+    msg = log_add Logger::DEBUG, 'debug level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::DEBUG],   msg.severity
+  end
+
+  def test_unknown
+    msg = log :unknown, 'unknown level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::UNKNOWN], msg.severity
+
+    @logger.level = Logger::UNKNOWN
+    msg = log :unknown, 'unknown level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::UNKNOWN], msg.severity
+
+    @logger.level = Logger::FATAL
+    msg = log :unknown, 'unknown level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::UNKNOWN], msg.severity
+
+    @logger.level = Logger::ERROR
+    msg = log :unknown, 'unknown level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::UNKNOWN], msg.severity
+
+    @logger.level = Logger::WARN
+    msg = log :unknown, 'unknown level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::UNKNOWN], msg.severity
+
+    @logger.level = Logger::INFO
+    msg = log :unknown, 'unknown level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::UNKNOWN], msg.severity
+
+    @logger.level = Logger::DEBUG
+    msg = log :unknown, 'unknown level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::UNKNOWN], msg.severity
+  end
+
+  def test_fatal
+    msg = log :fatal, 'fatal level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::FATAL], msg.severity
+
+    @logger.level = Logger::UNKNOWN
+    msg = log :fatal, 'fatal level message'
+    assert_equal '', msg.line
+
+    @logger.level = Logger::FATAL
+    msg = log :fatal, 'fatal level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::FATAL], msg.severity
+
+    @logger.level = Logger::ERROR
+    msg = log :fatal, 'fatal level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::FATAL], msg.severity
+
+    @logger.level = Logger::WARN
+    msg = log :fatal, 'fatal level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::FATAL], msg.severity
+
+    @logger.level = Logger::INFO
+    msg = log :fatal, 'fatal level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::FATAL], msg.severity
+
+    @logger.level = Logger::DEBUG
+    msg = log :fatal, 'fatal level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::FATAL], msg.severity
+  end
+
+  def test_error
+    msg = log :error, 'error level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::ERROR], msg.severity
+
+    @logger.level = Logger::UNKNOWN
+    msg = log :error, 'error level message'
+    assert_equal '', msg.line
+
+    @logger.level = Logger::FATAL
+    msg = log :error, 'error level message'
+    assert_equal '', msg.line
+
+    @logger.level = Logger::ERROR
+    msg = log :error, 'error level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::ERROR], msg.severity
+
+    @logger.level = Logger::WARN
+    msg = log :error, 'error level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::ERROR], msg.severity
+
+    @logger.level = Logger::INFO
+    msg = log :error, 'error level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::ERROR], msg.severity
+
+    @logger.level = Logger::DEBUG
+    msg = log :error, 'error level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::ERROR], msg.severity
+  end
+
+  def test_warn
+    msg = log :warn, 'warn level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::WARN], msg.severity
+
+    @logger.level = Logger::UNKNOWN
+    msg = log :warn, 'warn level message'
+    assert_equal '', msg.line
+
+    @logger.level = Logger::FATAL
+    msg = log :warn, 'warn level message'
+    assert_equal '', msg.line
+
+    @logger.level = Logger::ERROR
+    msg = log :warn, 'warn level message'
+    assert_equal '', msg.line
+
+    @logger.level = Logger::WARN
+    msg = log :warn, 'warn level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::WARN], msg.severity
+
+    @logger.level = Logger::INFO
+    msg = log :warn, 'warn level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::WARN], msg.severity
+
+    @logger.level = Logger::DEBUG
+    msg = log :warn, 'warn level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::WARN], msg.severity
+  end
+
+  def test_info
+    msg = log :info, 'info level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::INFO], msg.severity
+
+    @logger.level = Logger::UNKNOWN
+    msg = log :info, 'info level message'
+    assert_equal '', msg.line
+
+    @logger.level = Logger::FATAL
+    msg = log :info, 'info level message'
+    assert_equal '', msg.line
+
+    @logger.level = Logger::ERROR
+    msg = log :info, 'info level message'
+    assert_equal '', msg.line
+
+    @logger.level = Logger::WARN
+    msg = log :info, 'info level message'
+    assert_equal '', msg.line
+
+    @logger.level = Logger::INFO
+    msg = log :info, 'info level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::INFO], msg.severity
+
+    @logger.level = Logger::DEBUG
+    msg = log :info, 'info level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::INFO], msg.severity
+  end
+
+  def test_debug
+    msg = log :debug, 'debug level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::DEBUG], msg.severity
+
+    @logger.level = Logger::UNKNOWN
+    msg = log :debug, 'debug level message'
+    assert_equal '', msg.line
+
+    @logger.level = Logger::FATAL
+    msg = log :debug, 'debug level message'
+    assert_equal '', msg.line
+
+    @logger.level = Logger::ERROR
+    msg = log :debug, 'debug level message'
+    assert_equal '', msg.line
+
+    @logger.level = Logger::WARN
+    msg = log :debug, 'debug level message'
+    assert_equal '', msg.line
+
+    @logger.level = Logger::INFO
+    msg = log :debug, 'debug level message'
+    assert_equal '', msg.line
+
+    @logger.level = Logger::DEBUG
+    msg = log :debug, 'debug level message'
+    assert_equal LEVEL_LABEL_MAP[Logger::DEBUG], msg.severity
+  end
+
+end
+
+class TestSyslogLogger < TestLogger
+
+  def setup
+    super
+    @logger = SyslogLogger.new
+  end
+
+  class Log
+    attr_reader :line, :label, :datetime, :pid, :severity, :progname, :msg
+    def initialize(line)
+      @line = line
+      return unless /\A(\w+) - (.*)\Z/ =~ @line
+      severity, @msg = $1, $2
+      severity = SyslogLogger::LOGGER_MAP.invert[severity.downcase.intern]
+      @severity = severity.to_s.upcase
+      @severity = 'ANY' if @severity == 'UNKNOWN'
+    end
+  end
+
+  def log_add(severity, msg, progname = nil, &block)
+    log(:add, severity, msg, progname, &block)
+  end
+
+  def log(msg_id, *arg, &block)
+    Log.new(log_raw(msg_id, *arg, &block))
+  end
+
+  def log_raw(msg_id, *arg, &block)
+    assert_equal true, @logger.__send__(msg_id, *arg, &block)
+    msg = MockSyslog.line
+    MockSyslog.reset
+    return msg
+  end
+
+end
+

metadata

@@ -1,11 +1,11 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.10
+rubygems_version: 0.8.11
 specification_version: 1
 name: rails_analyzer_tools
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
-date: 2005-06-04
-summary: Various tools and toys
+  version: 1.1.0
+date: 2005-09-22 00:00:00 -07:00
+summary: Tools for analyzing the performance of web sites.
 require_paths: 
   - lib
 email: eric@robotcoop.com
@@ -24,20 +24,30 @@ required_ruby_version: !ruby/object:Gem::Version::Requirement
         version: 0.0.0
   version: 
 platform: ruby
+signing_key: 
+cert_chain: 
 authors: 
   - Eric Hodel
 files: 
   - Manifest.txt
   - Rakefile
   - README
+  - bin/bench
+  - bin/crawl
   - bin/rails_stat
   - lib/io_tail.rb
-  - lib/rails_stat.rb
+  - lib/analyzer_tools/bench.rb
+  - lib/analyzer_tools/crawl.rb
+  - lib/analyzer_tools/rails_stat.rb
+  - lib/analyzer_tools/syslog_logger.rb
+  - test/test_syslog_logger.rb
 test_files: []
 rdoc_options: []
 extra_rdoc_files: []
 executables: 
   - rails_stat
+  - bench
+  - crawl
 extensions: []
 requirements: []
 dependencies: []