DanaDanger-syslog_logger 1.5

data/README.rdoc

@@ -0,0 +1,113 @@
+= SyslogLogger
+
+http://github.com/DanaDanger/sysloglogger/tree
+
+== DESCRIPTION:
+
+SyslogLogger is a Logger replacement that logs to syslog. It is almost drop-in
+with a few caveats. You can add SyslogLogger to your Rails production
+environment to aggregate logs between multiple machines.
+
+NOTE! You can only set the SyslogLogger program name and facility when you
+initialize SyslogLogger for the first time. This is a limitation of the way
+SyslogLogger uses syslog (and in some ways, a limitation of the way syslog(3)
+works). Attempts to change SyslogLogger's program name after the first
+initialization will be ignored.
+
+This particular SyslogLogger improves the original by correctly mapping Rails
+log severities to the syslog counterparts. It also adds the ability to select
+a syslog facility other than "user."
+
+== SYNOPSIS:
+
+=== config/environment.rb
+
+  config.gem "DanaDanger-syslog_logger",
+    :lib    => "syslog_logger",
+    :source => "http://gems.github.com"
+
+=== config/environments/production.rb
+
+(Only this environment, since you probably only want to enable it for
+production, and not test or development.)
+
+  require "syslog_logger"
+  RAILS_DEFAULT_LOGGER = SyslogLogger.new 
+
+By default, SyslogLogger uses the program name "rails" and facility "user", but
+these can be changed the first time you instantiate a SyslogLogger:
+
+  RAILS_DEFAULT_LOGGER = SyslogLogger.new("mygreatapp", Syslog::LOG_LOCAL7)
+  
+=== BSD syslog setup
+
+==== /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.
+
+=== syslog-ng setup
+
+==== syslog-ng.conf
+
+A basic setup:
+
+  destination rails_log { file("/var/log/production.log"); };
+  filter f_rails { program("rails.*"); };
+  log { source(src); filter(f_rails); destination(rails_log); };
+
+A more advanced setup with formatting, etc:
+
+  destination rails { file("/var/log/rails_apps" owner("rails") group("rails") perm(0664) template("$DATE $HOST $PROGRAM [$LEVEL] $MSGONLY\n") template_escape(no) ); };
+  filter f_rails    { (program("railsappone") or program("railsapptwo")) and not match("SQL ") and not match("SELECT") and not match("INSERT INTO") and not match("UPDATE"); };
+  log { source(src); filter(f_rails); destination(rails); };
+
+=== Starting
+
+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.
+
+== INSTALL:
+
+  $ gem sources -a http://gems.github.com (you only have to do this once)
+  $ sudo gem install DanaDanger-syslog_logger
+
+== LICENSE:
+
+Copyright (c) 2008-2009 Eric Hodel, Christopher Powell, Ian Lesperance,
+and Dana Contreras
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/syslog_logger.rb

@@ -0,0 +1,112 @@
+require "syslog"
+require "logger"
+
+class SyslogLogger
+  # The version of SyslogLogger you are using.
+  VERSION = "1.5"
+  
+  # From "man syslog.h":
+  # LOG_EMERG   A panic condition was reported to all processes.
+  # LOG_ALERT   A condition that should be corrected immediately.
+  # LOG_CRIT    A critical condition.
+  # LOG_ERR     An error message.
+  # LOG_WARNING A warning message.
+  # LOG_NOTICE  A condition requiring special handling.
+  # LOG_INFO    A general information message.
+  # LOG_DEBUG   A message useful for debugging programs.
+  
+  # From logger rdoc:
+  # FATAL:  an unhandleable error that results in a program crash
+  # ERROR:  a handleable error condition
+  # WARN:   a warning
+  # INFO:   generic (useful) information about system operation
+  # DEBUG:  low-level information for developers
+  
+  # Maps Logger warning types to syslog(3) warning types.
+  LOGGER_MAP = {
+    :unknown => :alert,
+    :fatal   => :alert,
+    :error   => :err,
+    :warn    => :warning,
+    :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 methods for level +meth+.
+  def self.make_methods(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
+
+      def #{meth}?
+        @level <= Logger::#{meth.to_s.upcase}
+      end
+    EOM
+  end
+  
+  LOGGER_MAP.each_key do |level|
+    make_methods 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 and +facility+ may be set to specify a custom facility
+  # with your syslog daemon.
+  #
+  # Due to the way syslog works, only one program name and facility may be chosen.
+  def initialize(program_name = "rails", facility = Syslog::LOG_USER)
+    @level = Logger::DEBUG
+
+    return if defined? SYSLOG
+    self.class.const_set :SYSLOG, Syslog.open(program_name, nil, facility)
+  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.
+  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

data/test/syslog_logger_test.rb

@@ -0,0 +1,491 @@
+require 'test/unit'
+require 'tempfile'
+require '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_unknown_eh
+    @logger.level = Logger::UNKNOWN
+    assert_equal true, @logger.unknown?
+
+    @logger.level = Logger::UNKNOWN + 1
+    assert_equal false, @logger.unknown?
+  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_fatal_eh
+    @logger.level = Logger::FATAL
+    assert_equal true, @logger.fatal?
+
+    @logger.level = Logger::UNKNOWN
+    assert_equal false, @logger.fatal?
+  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_error_eh
+    @logger.level = Logger::ERROR
+    assert_equal true, @logger.error?
+
+    @logger.level = Logger::FATAL
+    assert_equal false, @logger.error?
+  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_warn_eh
+    @logger.level = Logger::WARN
+    assert_equal true, @logger.warn?
+
+    @logger.level = Logger::ERROR
+    assert_equal false, @logger.warn?
+  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_info_eh
+    @logger.level = Logger::INFO
+    assert_equal true, @logger.info?
+
+    @logger.level = Logger::WARN
+    assert_equal false, @logger.info?
+  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
+
+  def test_debug_eh
+    @logger.level = Logger::DEBUG
+    assert_equal true, @logger.debug?
+
+    @logger.level = Logger::INFO
+    assert_equal false, @logger.debug?
+  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

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification 
+name: DanaDanger-syslog_logger
+version: !ruby/object:Gem::Version 
+  version: "1.5"
+platform: ruby
+authors: 
+- Eric Hodel; Chris Powell; Ian Lesperance; Dana Danger
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-08 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: An improved Logger replacement that logs to syslog. It is almost drop-in with a few caveats.
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- lib/syslog_logger.rb
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/DanaDanger/syslog_logger
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- SyslogLogger
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: An improved Logger replacement that logs to syslog. It is almost drop-in with a few caveats.
+test_files: 
+- test/syslog_logger_test.rb