ashleym1972-SyslogLogger 1.6.0

data/Manifest

@@ -0,0 +1,7 @@
+lib/syslog_logger.rb
+lib/syslog_logger_env_formatting.rb
+Manifest
+Rakefile
+README.rdoc
+sysloglogger.gemspec
+test/test_syslog_logger.rb

data/README.rdoc

@@ -0,0 +1,111 @@
+= SyslogLogger
+
+http://github.com/ashleym1972/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 or facility 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 "ashleym1972-SyslogLogger", :source=>'http://gems.github.com', :lib=>'syslog_logger'
+
+=== 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 the facility 'user', but this can be
+changed via the arguments to SyslogLogger.new:
+
+  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 ashleym1972-SyslogLogger
+
+== 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/Rakefile

@@ -0,0 +1,23 @@
+require "rake/gempackagetask"
+
+$dir = File.dirname(__FILE__)
+
+task :default => :package
+
+desc "Run all tests"
+
+task :test do
+  $: << "#{$dir}/lib"
+  Dir.glob("#{$dir}/test/*.rb").each do |test_rb|
+    require test_rb
+  end
+end
+
+spec = eval(IO.read("#{$dir}/syslog_logger.gemspec"))
+gem_pkg_task = Rake::GemPackageTask.new(spec) {|pkg|}
+
+desc "Install the gem with sudo"
+task :install => :package do
+  system("sudo", "gem", "install",
+    "#{$dir}/#{gem_pkg_task.package_dir}/#{gem_pkg_task.gem_file}")
+end

data/lib/syslog_logger.rb

@@ -0,0 +1,115 @@
+require 'syslog'
+require 'logger'
+
+class SyslogLogger
+  include Logger::Severity
+
+  # The version of SyslogLogger you are using.
+  VERSION = '1.6.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 => :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+.
+  for severity in Logger::Severity.constants
+    class_eval <<-EOT, __FILE__, __LINE__
+      def #{severity.downcase}(message = nil, progname = nil, &block)  # def debug(message = nil, progname = nil, &block)
+        add(#{severity}, message, progname, &block)                    #   add(DEBUG, message, progname, &block)
+      end                                                              # end
+                                                                       #
+      def #{severity.downcase}?                                        # def debug?
+        #{severity} >= @level                                          #   DEBUG >= @level
+      end                                                              # end
+    EOT
+  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 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
+
+  # In Logger, this dumps the raw message; the closest equivalent
+  # would be Logger::UNKNOWN
+  def <<(message)
+    add(Logger::UNKNOWN, message)
+  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/lib/syslog_logger_env_formatting.rb

@@ -0,0 +1,38 @@
+# Adds some default information to syslog messages.
+# If you pass a User or Device object as the first parameter, it will log that user/device's id
+# If you pass a block from a controller, it will automatically log the current user id
+# If you pass a block, the class name of the block's context will be added
+# 
+# Examples
+# logger.debug "O'Doyle Rules!" 
+#     #=> [development] [DEBUG: 2008-01-25 14:16:12.12345] O'Doyle Rules!
+# 
+# #from within a controller...
+# logger.error {"Something is messed up!"}
+#     #=> [development] [ERROR: 2008-01-25 14:16:12.12345] [123] [ClassName] Something is messed up!
+
+class SyslogLogger
+
+    # short names for "DEBUG", "INFO", ...
+    # must be ordered to correspond to severity constants defined in 
+    # ActiveSupport::BufferedLogger::Severity 
+    #@@log_level_names = %w( D I W E F U )
+    #LOG_NAME_FIELD_WIDTH = 1
+
+    @@log_level_names = %w( DEBUG INFO WARN ERROR FATAL UNKNOWN )
+    LOG_NAME_FIELD_WIDTH = 7
+    
+    def add_with_formatting(severity, message = nil, progname = nil, &block)
+      severity ||= Logger::UNKNOWN
+      message = "[#{RAILS_ENV}] [#{@@log_level_names[severity].ljust(LOG_NAME_FIELD_WIDTH)}: #{time.strftime("%Y-%m-%d %H:%M:%S")}.#{time.usec.to_s.rjust(6, '0')}] #{message}"
+
+      if(block)
+        add_without_formatting(severity, message, progname,
+          &Proc.new{g_log_formatter(severity, nil, user, &block)})
+      else
+        add_without_formatting(severity, message, progname)
+      end
+    end
+    alias_method_chain :add, :formatting
+    
+end

data/syslog_logger.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{SyslogLogger}
+  s.version = "1.6.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Eric Hodel; Chris Powell; Matthew Boeh; Dana Contreras; Brian Smith; Ashley Martens"]
+  s.date = %q{2009-08-06}
+  s.description = s.summary = %q{An improved Logger replacement that logs to syslog. It is almost drop-in with a few caveats.}
+  s.email = %q{drbrain@segment7.net; cpowell@prylis.com; mboeh@desperance.net}
+  s.extra_rdoc_files = ["README.rdoc", "lib/syslog_logger.rb", "lib/syslog_logger_env_formatting.rb"]
+  s.files = ["Rakefile", "test/test_syslog_logger.rb", "README.rdoc", "lib/syslog_logger.rb", "lib/syslog_logger_env_formatting.rb", "syslog_logger.gemspec", "Manifest"]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/ashleym1972/sysloglogger}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "SyslogLogger", "--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{sysloglogger}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{An improved Logger replacement that logs to syslog. It is almost drop-in with a few caveats.}
+  s.test_files = ["test/test_syslog_logger.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/test/test_syslog_logger.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,67 @@
+--- !ruby/object:Gem::Specification 
+name: ashleym1972-SyslogLogger
+version: !ruby/object:Gem::Version 
+  version: 1.6.0
+platform: ruby
+authors: 
+- Eric Hodel; Chris Powell; Matthew Boeh; Dana Contreras; Brian Smith; Ashley Martens
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-06 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: drbrain@segment7.net; cpowell@prylis.com; mboeh@desperance.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- lib/syslog_logger.rb
+- lib/syslog_logger_env_formatting.rb
+files: 
+- Rakefile
+- test/test_syslog_logger.rb
+- README.rdoc
+- lib/syslog_logger.rb
+- lib/syslog_logger_env_formatting.rb
+- syslog_logger.gemspec
+- Manifest
+has_rdoc: true
+homepage: http://github.com/ashleym1972/sysloglogger
+licenses: 
+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: "1.2"
+  version: 
+requirements: []
+
+rubyforge_project: sysloglogger
+rubygems_version: 1.3.5
+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/test_syslog_logger.rb