syslog-logger-1.6.8/0000755000175000017500000000000012677253264015061 5ustar kanashirokanashirosyslog-logger-1.6.8/lib/0000755000175000017500000000000012677253264015627 5ustar kanashirokanashirosyslog-logger-1.6.8/lib/syslog-logger.rb0000644000175000017500000001213312677253264020751 0ustar kanashirokanashirorequire 'syslog' require 'logger' require 'syslog-formatter' class Logger::Syslog include Logger::Severity # The version of Logger::Syslog you are using. VERSION = '1.6.8' # 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 => :crit, :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? @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 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 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 SYSLOG.send(LEVEL_LOGGER_MAP[severity], format_message(format_severity(severity), Time.now, progname, clean(message))) 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 = %w(DEBUG INFO WARN ERROR FATAL 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 endsyslog-logger-1.6.8/lib/syslog-formatter.rb0000644000175000017500000000142512677253264021477 0ustar kanashirokanashiro# Adds some default information to syslog messages. # Log format: # [Time.mSec] [SeverityLabel]: message class Logger::SyslogFormatter < Logger::Formatter Format = "[%s] [%5s]: %s\n" attr_accessor :datetime_format def initialize @datetime_format = nil end def call(severity, time, progname, msg) Format % [format_datetime(time), severity, msg2str(msg)] end protected def format_datetime(time) if @datetime_format.nil? time.strftime("%H:%M:%S.") << "%06d " % time.usec else time.strftime(@datetime_format) end end def msg2str(msg) case msg when ::String msg when ::Exception "#{ msg.message } (#{ msg.class })\n" << (msg.backtrace || []).join("\n") else msg.inspect end end endsyslog-logger-1.6.8/README.rdoc0000644000175000017500000001016512677253264016672 0ustar kanashirokanashiro= 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. syslog-logger-1.6.8/test/0000755000175000017500000000000012677253264016040 5ustar kanashirokanashirosyslog-logger-1.6.8/test/test_syslog_logger.rb0000644000175000017500000003332512677253264022311 0ustar kanashirokanashirorequire 'test/unit' require 'tempfile' require 'syslog-logger' module MockSyslog; end class << MockSyslog @line = nil Logger::Syslog::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 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 @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 = Logger::Syslog.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 = Logger::Syslog::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 syslog-logger-1.6.8/metadata.yml0000644000175000017500000000267112677253264017372 0ustar kanashirokanashiro--- !ruby/object:Gem::Specification name: syslog-logger version: !ruby/object:Gem::Version prerelease: false segments: - 1 - 6 - 8 version: 1.6.8 platform: ruby authors: - Eric Hodel; Chris Powell; Matthew Boeh; Ian Lesperance; Dana Danger; Brian Smith; Ashley Martens autorequire: bindir: bin cert_chain: [] date: 2012-02-14 00:00:00 -08:00 default_executable: dependencies: [] description: An improved Logger replacement that logs to syslog. It is almost drop-in with a few caveats. email: teamplatform@ngmoco.com executables: [] extensions: [] extra_rdoc_files: - README.rdoc files: - README.rdoc - lib/syslog-formatter.rb - lib/syslog-logger.rb has_rdoc: true homepage: http://github.com/ngmoco/syslog_logger 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 segments: - 0 version: "0" required_rubygems_version: !ruby/object:Gem::Requirement requirements: - - ">=" - !ruby/object:Gem::Version segments: - 0 version: "0" requirements: [] rubyforge_project: rubygems_version: 1.3.6 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