logger-syslog 1.7.0

data/README.rdoc

@@ -0,0 +1,115 @@
+= SyslogLogger
+
+http://github.com/ngmoco/sysloglogger
+
+== DESCRIPTION:
+
+Logger::Syslog is a Logger replacement that logs to syslog. It is almost drop-in
+with a few caveats. You can add Logger::Syslog to your Rails production
+environment to aggregate logs between multiple machines.
+
+NOTE! You can only set the Logger::Syslog program name and facility when you initialize
+Logger::Syslog for the first time. This is a limitation of the way Logger::Syslog
+uses syslog (and in some ways, a limitation of the way syslog(3) works).
+Attempts to change Logger::Syslog's program name or facility after the first initialization
+will be ignored.
+
+This particular Logger::Syslog 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."
+
+Version 1.6.7 takes a formatter as logger does and uses call to format the message.
+
+== SYNOPSIS:
+
+=== config/environment.rb
+
+  config.gem 'syslog-logger'
+
+=== Gemfile
+
+  gem 'syslog-logger'
+
+=== config/environments/production.rb
+
+(Only this environment, since you probably only want to enable it for Production, and not Test or Development.)
+
+  RAILS_DEFAULT_LOGGER = Logger::Syslog.new 
+
+By default, Logger::Syslog uses the program name 'rails' and the facility 'user', but this can be
+changed via the arguments to Logger::Syslog.new:
+
+  RAILS_DEFAULT_LOGGER = Logger::Syslog.new('mygreatapp', Syslog::LOG_LOCAL7)
+  
+=== BSD syslog setup
+
+==== /etc/syslog.conf
+
+Add the following lines:
+
+  !rails
+  *.*                                             /var/log/production.log
+
+Or, in Mac OS X:
+
+  local7.*                                        /var/log/production.log
+
+Then touch /var/log/production.log and signal syslogd with a HUP
+(killall -HUP syslogd, on FreeBSD and OS X).
+
+==== /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.
+
+== LICENSE:
+
+Copyright (c) 2008, 2009 Eric Hodel, Christopher Powell, Ian Lesperance,
+                         Dana Contreras, Brian Smith, Ashley Martens
+
+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/logger-syslog.rb

@@ -0,0 +1,177 @@
+require 'syslog'
+require 'logger'
+require 'syslog-formatter'
+
+class Logger::Syslog
+  include Logger::Severity
+
+  # The version of Logger::Syslog you are using.
+  VERSION = '1.7.0'
+
+  # 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 => Syslog::LOG_ALERT,
+    :fatal   => Syslog::LOG_CRIT,
+    :error   => Syslog::LOG_ERR,
+    :warn    => Syslog::LOG_WARNING,
+    :info    => Syslog::LOG_INFO,
+    :debug   => Syslog::LOG_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+.
+  for severity in Logger::Severity.constants
+    class_eval <<-EOT, __FILE__, __LINE__
+      def #{severity.downcase}(progname = nil, &block)  # def debug(progname = nil, &block)
+        add(#{severity}, nil, progname, &block)         #   add(DEBUG, nil, progname, &block)
+      end                                               # end
+                                                        #
+      def #{severity.downcase}?                         # def debug?
+        @level <= #{severity}                           #   @level <= DEBUG
+      end                                               # end
+    EOT
+  end
+
+  # Log level for Logger compatibility.
+  attr_accessor :level
+
+  # Logging program name.
+  attr_accessor :progname
+
+  # Logging date-time format (string passed to +strftime+).
+  def datetime_format=(datetime_format)
+    @default_formatter.datetime_format = datetime_format
+  end
+
+  def datetime_format
+    @default_formatter.datetime_format
+  end
+
+  # Logging formatter.  formatter#call is invoked with 4 arguments; severity,
+  # time, progname and msg for each log.  Bear in mind that time is a Time and
+  # msg is an Object that user passed and it could not be a String.  It is
+  # expected to return a logdev#write-able Object.  Default formatter is used
+  # when no formatter is set.
+  attr_accessor :formatter
+
+  # This is the facility the logger will log to. You can have several loggers
+  # that log to different facilities.
+  attr_accessor :facility
+
+  alias sev_threshold level
+  alias sev_threshold= level=
+
+  # Fills in variables for Logger compatibility.  If this is the first
+  # instance of Logger::Syslog, +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 may be chosen.
+  def initialize(program_name = 'rails', facility = Syslog::LOG_USER, logopts=nil)
+    @default_formatter = Logger::SyslogFormatter.new
+    @formatter         = nil
+    @progname          = nil
+    @level             = Logger::DEBUG
+    @facility          = facility
+
+    return if defined? SYSLOG
+    self.class.const_set :SYSLOG, Syslog.open(program_name, logopts, facility)
+  end
+
+  # Almost duplicates Logger#add.  +progname+ is ignored.
+  def add(severity, message = nil, progname = nil, &block)
+    severity ||= Logger::UNKNOWN
+    if severity < @level
+      return true
+    end
+    if message.nil?
+      if block_given?
+        message = yield
+      else
+        message = progname
+        progname = @progname
+      end
+    end
+
+    # breakup multiple lines into multiple syslog messages
+    message.each_line do | msg |
+      SYSLOG.log(LEVEL_LOGGER_MAP[severity] | @facility, format_message(format_severity(severity), Time.now, progname, clean(msg.chop)))
+    end
+    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
+
+  # In Logger, this dumps the raw message; the closest equivalent
+  # would be Logger::UNKNOWN
+  def <<(message)
+    add(Logger::UNKNOWN, message)
+  end
+
+  private
+
+    # Severity label for logging. (max 5 char)
+    SEV_LABEL = {
+      Logger::DEBUG => "DEBUG",
+      Logger::INFO => "INFO",
+      Logger::WARN => "WARN",
+      Logger::ERROR => "ERROR",
+      Logger::FATAL => "FATAL",
+      Logger::UNKNOWN => "ANY"
+    }
+
+    def format_severity(severity)
+      SEV_LABEL[severity] || 'ANY'
+    end
+
+    def format_message(severity, datetime, progname, msg)
+      (@formatter || @default_formatter).call(severity, datetime, progname, msg)
+    end
+
+    # 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/lib/syslog-formatter.rb

@@ -0,0 +1,32 @@
+# Adds some default information to syslog messages.
+# Log format:
+#   [Time.mSec] [SeverityLabel]: message
+
+class Logger::SyslogFormatter < Logger::Formatter
+  Format = "[%5s] %s\n"
+
+  attr_accessor :datetime_format
+
+  def initialize
+    @datetime_format = nil
+  end
+
+  def call(severity, time, progname, msg)
+    Format % [severity, msg2str(msg)]
+  end
+
+  protected
+
+  def msg2str(msg)
+    case msg
+    when ::String
+      msg
+    when ::Exception
+      "#{ msg.message } (#{ msg.class })\n" <<
+        (msg.backtrace || []).join("\n")
+    else
+      msg.inspect
+    end
+  end
+   
+end

data/test/test_syslog_logger.rb

@@ -0,0 +1,524 @@
+require 'test/unit'
+require 'tempfile'
+require 'logger-syslog'
+
+module MockSyslog; end
+
+class << MockSyslog
+
+  @line = nil
+
+  attr_reader :line
+  attr_reader :program_name
+
+  def open(program_name)
+    @program_name = program_name
+  end
+
+  def log(priority, message)
+    @line = message
+  end
+
+  def reset
+    @line = ''
+  end
+
+end
+
+Logger::Syslog.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
+
+    assert_raise(ArgumentError) do
+      log :unknown, 'unknown level message', :dummy_progname
+    end
+
+    @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
+
+    assert_raise(ArgumentError) do
+      log :fatal, 'fatal level message', :dummy_progname
+    end
+
+    @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
+
+    assert_raise(ArgumentError) do
+      log :error, 'error level message', :dummy_progname
+    end
+
+    @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
+
+    assert_raise(ArgumentError) do
+      log :warn, 'warn level message', :dummy_progname
+    end
+
+    @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
+
+    assert_raise(ArgumentError) do
+      log :info, 'info level message', :dummy_progname
+    end
+
+    @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
+
+    assert_raise(ArgumentError) do
+      log :debug, 'debug level message', :dummy_progname
+    end
+
+    @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
+
+  [:unknown, :fatal, :error, :warn, :info, :debug].each do |severity|
+    class_eval <<-EOS, __FILE__, __LINE__
+      def test_#{severity}_block
+        msg = log :#{severity}, '#{severity} level message'
+        msg_blk = log(:#{severity}){ '#{severity} level message' }
+        [:severity, :msg].each do |attr|
+          assert_equal msg.send(attr), msg_blk.send(attr)
+        end
+
+        msg_blk = log(:#{severity}, :dummy_progname){ '#{severity} level message' }
+        [:severity, :msg].each do |attr|
+          assert_equal msg.send(attr), msg_blk.send(attr)
+        end
+      end
+    EOS
+  end
+end
+
+class TestSyslogLogger < TestLogger
+
+  def setup
+    super
+    @logger = Logger::Syslog.new
+  end
+
+  class Log
+    attr_reader :line, :label, :datetime, :pid, :severity, :progname, :msg
+    def initialize(line)
+      @line = line
+      return unless /\A\[\s*([^\]]+)\] ([\x0-\xff]*)/ =~ @line
+      @severity, @msg = $1, $2
+    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,90 @@
+--- !ruby/object:Gem::Specification 
+name: logger-syslog
+version: !ruby/object:Gem::Version 
+  hash: 11
+  prerelease: 
+  segments: 
+  - 1
+  - 7
+  - 0
+  version: 1.7.0
+platform: ruby
+authors: 
+- Sergio Cambra; Eric Hodel; Chris Powell; Matthew Boeh; Ian Lesperance; Dana Danger; Brian Smith; Ashley Martens
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-10-17 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 1
+        - 1
+        - 0
+        version: 1.1.0
+  type: :development
+  version_requirements: *id001
+description: An improved Logger replacement that logs to syslog. It is almost drop-in with a few caveats.
+email: 
+- sergio@programatica.es
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/syslog-formatter.rb
+- lib/logger-syslog.rb
+- README.rdoc
+- test/test_syslog_logger.rb
+homepage: https://github.com/scambra/logger-syslog
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 59
+      segments: 
+      - 1
+      - 8
+      - 6
+      version: 1.8.6
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: An improved Logger replacement that logs to syslog. It is almost drop-in with a few caveats.
+test_files: 
+- test/test_syslog_logger.rb