rails_analyzer_tools 1.1.0 → 1.4.0

data/History.txt

@@ -0,0 +1,4 @@
+= 1.4.0
+
+* Moved to seattlerb project.
+

data/Manifest.txt

@@ -1,12 +1,12 @@
+History.txt
 Manifest.txt
+README.txt
 Rakefile
-README
 bin/bench
 bin/crawl
 bin/rails_stat
-lib/io_tail.rb
+lib/analyzer_tools.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
+lib/io_tail.rb

data/{README → README.txt}

@@ -1,12 +1,16 @@
-Rails Analyzer Tools contains Bench, Crawler, RailsStat, IOTail and
-SyslogLogger libraries, and the programs bench, crawl and rails_stat based on
-these libraries.
+= rails_analyzer_tools
 
-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.
+Tools for analyzing the performance of web sites.
 
-rails_stat is useful to see how much traffic your Rails site is doing.
+Rails Analyzer Tools contains Bench, a simple web page benchmarker,
+Crawler, a tool for beating up on web sites, RailsStat, a tool for
+monitoring Rails web sites, and IOTail, a tail(1) method for Ruby IOs.
+
+http://seattlerb.rubyforge.org/rails_analyzer_tools
+
+Bug reports:
+
+http://rubyforge.org/tracker/?func=add&group_id=1513&atid=5921
 
 == Bench
 
@@ -51,11 +55,6 @@ 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

@@ -1,61 +1,17 @@
-require 'rubygems'
-require 'rake'
-require 'rake/testtask'
-require 'rake/rdoctask'
-require 'rake/gempackagetask'
-require 'rake/contrib/sshpublisher'
-
-$VERBOSE = nil
-
-spec = Gem::Specification.new do |s|
-  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'
-task :default => [ :test ]
-
-Rake::TestTask.new('test') do |t|
-  t.libs << 'test'
-  t.libs << 'lib'
-  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'
-  rd.main = 'README'
-  rd.options << '-d' if `which dot` =~ /\/dot/
-end
-
-desc 'Build Gem'
-Rake::GemPackageTask.new spec do |pkg|
-  pkg.need_tar = true
+require 'hoe'
+require './lib/analyzer_tools'
+
+Hoe.new 'rails_analyzer_tools', AnalyzerTools::VERSION do |p|
+  p.rubyforge_name = 'seattlerb'
+  p.author = 'Eric Hodel'
+  p.email = 'drbrain@segment7.net'
+  p.summary = p.paragraphs_of('README.txt', 1).join ' '
+  p.description = p.paragraphs_of('README.txt', 2).join ' '
+  p.url = p.paragraphs_of('README.txt', 3).join ' '
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+
+  p.extra_deps << ['SyslogLogger', '>= 1.4.0']
 end
 
-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
-end
-
-desc 'Clean up'
-task :clean => [ :clobber_rdoc, :clobber_package ]
-
-desc 'Clean up'
-task :clobber => [ :clean ]
-
 # vim: syntax=Ruby
 

data/bin/bench

@@ -14,8 +14,8 @@ OptionParser.accept URI do |u,|
 end
 
 uri = nil
-requests = nil
-concurrency = nil
+requests = 1
+concurrency = 1
 
 opts = OptionParser.new do |opts|
   opts.banner = "Usage: #{$PROGRAM_NAME} [options]"

data/bin/rails_stat

@@ -3,13 +3,10 @@
 require 'io_tail'
 require 'analyzer_tools/rails_stat'
 
-filename = ARGV.shift
-interval = ARGV.shift || 10
-
-if filename.nil? then
-  STDERR.puts "Usage: #{$0} RAILS_LOG [PRINT_INTERVAL]"
+if ARGV.length < 1 then
+  $stderr.puts "Usage: #{$0} RAILS_LOG [...] [PRINT_INTERVAL]"
   exit 1
 end
 
-RailsStat.start filename, interval
+RailsStat.start(*ARGV)
 

data/lib/analyzer_tools.rb

@@ -0,0 +1,9 @@
+module AnalyzerTools
+
+  ##
+  # The version of AnalyzerTools you have installed.
+
+  VERSION = '1.4.0'
+
+end
+

data/lib/analyzer_tools/bench.rb

@@ -44,7 +44,7 @@ class Bench
             end
             @num_requests -= 1
           end
-          STDOUT.flush
+          $stdout.flush
           times << time_request
         end
       end

data/lib/analyzer_tools/crawl.rb

@@ -64,7 +64,7 @@ class Crawler
   def do_request(url)
     req = []
     req << "GET #{url.request_uri} HTTP/1.0"
-    req << "Host: #{url.host}" 
+    req << "Host: #{url.host}"
     req << "User-Agent: RubyCrawl"
     req << ""
     req << ""

data/lib/analyzer_tools/rails_stat.rb

@@ -1,72 +1,133 @@
 require 'thread'
+require 'curses' rescue nil
 
 ##
-# RailsStat displays a the current requests, queries and lines logged per
-# second.  Default interval is 10 seconds.
+# RailsStat displays a the current requests and lines logged per second.
+# Default interval is 10 seconds.
 
 class RailsStat
-  
+
+  class << self
+    attr_reader :lines
+  end
+
   ##
-  # Starts a new RailsStat for +filename+ that prints every +interval+ seconds.
+  #   RailsStat.start 'online-43things.log', 'online-43people.log', 10
+  #
+  # Starts a new RailsStat for +filenames+ that prints every +interval+
+  # seconds.
+  #
+  # Stats for multiple log files requires curses.
+
+  def self.start(*args)
+    interval = 10
+    interval = Float(args.pop) if Float(args.last) rescue nil
+
+    stats = []
+
+    if args.length > 1 and not defined? Curses then
+      $stderr.puts "Multiple logfile support requires curses"
+      exit 1
+    end
+
+    if defined? Curses then
+      Curses.init_screen
+      Curses.clear
+      Curses.addstr "Collecting data...\n"
+      Curses.refresh
+      @lines = []
+    end
 
-  def self.start(filename, interval = 10)
-    File.open filename do |fp|
-      self.new(fp).start(interval)
+    args.each_with_index do |filename, offset|
+      stat = self.new File.open(filename), interval, offset
+      stat.start
+      stats << stat
     end
+
+    stats.each { |stat| stat.thread.join }
   end
 
   ##
-  # Creates a new RailsStat that will listen on +io+.
+  # The log reading thread
+
+  attr_reader :thread
+
+  ##
+  # Current status line
 
-  def initialize(io)
+  attr_reader :status
+
+  ##
+  # Creates a new RailsStat that will listen on +io+ and print every
+  # +interval+ seconds.  +offset+ is only used for multi-file support.
+
+  def initialize(io, interval, offset = 0)
     @io = io
+    @io_path = File.basename io.path rescue 'unknown'
+    @interval = interval.to_f
+    @offset = offset
+
     @mutex = Mutex.new
+    @status = ''
+    @last_len = 0
     @lines = 0
     @count = 0
-    @queries = 0
+    @thread = nil
   end
 
   ##
   # Starts the RailsStat running.  This method never returns.
 
-  def start(interval)
-    trap('INT') { exit }
-    start_printer interval
+  def start
+    trap 'INT' do
+      Curses.close_screen if defined? Curses
+      exit
+    end
+    start_printer
     read_log
   end
 
+  def print
+    if defined? Curses then
+      Curses.setpos @offset, 0
+      Curses.addstr ' ' * @last_len
+      Curses.setpos @offset, 0
+      Curses.addstr "#{@io_path}\t#{@status}"
+      Curses.refresh
+    else
+      print "\r"
+      print ' ' * @last_len
+      print "\r"
+      print @status
+      $stdout.flush
+    end
+  end
+
   private
 
   ##
   # Starts a thread that prints log information every +interval+ seconds.
 
-  def start_printer(interval)
-    interval = interval.to_f
+  def start_printer
     Thread.start do
-      last_len = 0
       lines_sec = 0
       count_sec = 0
-      queries_sec = 0
 
       loop do
-        sleep interval
+        sleep @interval
 
         @mutex.synchronize do
-          lines_sec = @lines / interval
-          count_sec = @count / interval
-          queries_sec = @queries / interval
+          lines_sec = @lines / @interval
+          count_sec = @count / @interval
           @lines = 0
           @count = 0
-          @queries = 0
         end
 
-        status = sprintf("~ %0.1f req/sec, %0.1f queries/sec, %0.1f lines/sec",
-                         count_sec, queries_sec, lines_sec)
+        @status = "%5.1f req/sec, %6.1f lines/sec" % [count_sec, lines_sec]
 
-        print "\r#{' ' * last_len}\r#{status}"
-        STDOUT.flush
+        print
 
-        last_len = status.length
+        @last_len = status.length
       end
     end
   end
@@ -76,10 +137,11 @@ class RailsStat
   # goes.
 
   def read_log
-    @io.tail_lines do |line|
-      @mutex.synchronize { @lines += 1 }
-      @mutex.synchronize { @count += 1 } if line =~ /Completed in /
-      @mutex.synchronize { @queries += 1 } if line =~ / (?:Update|Load|SQL|Count) /
+    @thread = Thread.start do
+      @io.tail_lines do |line|
+        @mutex.synchronize { @lines += 1 }
+        @mutex.synchronize { @count += 1 } if line =~ /Completed in /
+      end
     end
   end
 

metadata

@@ -1,53 +1,76 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.11
+rubygems_version: 0.9.2
 specification_version: 1
 name: rails_analyzer_tools
 version: !ruby/object:Gem::Version 
-  version: 1.1.0
-date: 2005-09-22 00:00:00 -07:00
+  version: 1.4.0
+date: 2007-05-15 00:00:00 -07:00
 summary: Tools for analyzing the performance of web sites.
 require_paths: 
-  - lib
-email: eric@robotcoop.com
-homepage: 
-rubyforge_project: 
-description: 
+- lib
+email: drbrain@segment7.net
+homepage: http://seattlerb.rubyforge.org/rails_analyzer_tools
+rubyforge_project: seattlerb
+description: Rails Analyzer Tools contains Bench, a simple web page benchmarker, Crawler, a tool for beating up on web sites, RailsStat, a tool for monitoring Rails web sites, and IOTail, a tail(1) method for Ruby IOs.
 autorequire: 
 default_executable: 
 bindir: bin
 has_rdoc: true
 required_ruby_version: !ruby/object:Gem::Version::Requirement 
   requirements: 
-    - 
-      - ">"
-      - !ruby/object:Gem::Version 
-        version: 0.0.0
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
   version: 
 platform: ruby
 signing_key: 
 cert_chain: 
+post_install_message: 
 authors: 
-  - Eric Hodel
+- Eric Hodel
 files: 
-  - Manifest.txt
-  - Rakefile
-  - README
-  - bin/bench
-  - bin/crawl
-  - bin/rails_stat
-  - lib/io_tail.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
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/bench
+- bin/crawl
+- bin/rails_stat
+- lib/analyzer_tools.rb
+- lib/analyzer_tools/bench.rb
+- lib/analyzer_tools/crawl.rb
+- lib/analyzer_tools/rails_stat.rb
+- lib/io_tail.rb
 test_files: []
+
 rdoc_options: []
+
 extra_rdoc_files: []
+
 executables: 
-  - rails_stat
-  - bench
-  - crawl
+- bench
+- crawl
+- rails_stat
 extensions: []
+
 requirements: []
-dependencies: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: SyslogLogger
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.4.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.0
+    version: 

data/lib/analyzer_tools/syslog_logger.rb

@@ -1,171 +0,0 @@
-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/test/test_syslog_logger.rb

@@ -1,443 +0,0 @@
-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
-