├── History.txt ├── Manifest ├── README.rdoc ├── Rakefile ├── lib ├── analyzer_tools │ └── syslog_logger.rb └── syslog_logger.rb ├── sysloglogger.gemspec └── test └── test_syslog_logger.rb /History.txt: -------------------------------------------------------------------------------- 1 | == 1.4.0 / 2007-05-08 2 | 3 | * Split from rails_analyzer_tools. 4 | * Added eh methods for compatibility with Logger. 5 | * Added syslog-ng instructions. Patch by Tom Lianza. 6 | * Fixed require in documentation. Reported by Gianni Jacklone. 7 | 8 | -------------------------------------------------------------------------------- /Manifest: -------------------------------------------------------------------------------- 1 | History.txt 2 | lib/analyzer_tools/syslog_logger.rb 3 | lib/syslog_logger.rb 4 | Manifest 5 | Rakefile 6 | README.rdoc 7 | sysloglogger.gemspec 8 | test/test_syslog_logger.rb 9 | -------------------------------------------------------------------------------- /README.rdoc: -------------------------------------------------------------------------------- 1 | = SyslogLogger 2 | 3 | http://github.com/cpowell/sysloglogger/tree 4 | 5 | == DESCRIPTION: 6 | 7 | SyslogLogger is a Logger replacement that logs to syslog. It is almost drop-in 8 | with a few caveats. You can add SyslogLogger to your Rails production 9 | environment to aggregate logs between multiple machines. 10 | 11 | NOTE! You can only set the SyslogLogger program name when you initialize 12 | SyslogLogger for the first time. This is a limitation of the way SyslogLogger 13 | uses syslog (and in some ways, a limitation of the way syslog(3) works). 14 | Attempts to change SyslogLogger's program name after the first initialization 15 | will be ignored. 16 | 17 | This particular SyslogLogger improves the original by correctly mapping Rails-side log severities to 18 | the Syslog counterparts. The original can be found here: http://seattlerb.rubyforge.org/SyslogLogger 19 | 20 | == SYNOPSIS: 21 | 22 | === config/environment.rb 23 | 24 | config.gem "cpowell-SyslogLogger", :source=>'http://gems.github.com', :lib=>'syslog_logger' 25 | 26 | === config/environments/production.rb 27 | 28 | (Only this environment, since you probably only want to enable it for Production, and not Test or Development.) 29 | 30 | require 'syslog_logger' 31 | RAILS_DEFAULT_LOGGER = SyslogLogger.new 32 | 33 | By default, SyslogLogger uses the program name 'rails', but this can be 34 | changed via the first argument to SyslogLogger.new: 35 | 36 | RAILS_DEFAULT_LOGGER = SyslogLogger.new(program_name = 'mygreatapp') 37 | 38 | === BSD syslog setup 39 | 40 | ==== /etc/syslog.conf 41 | 42 | Add the following lines: 43 | 44 | !rails 45 | *.* /var/log/production.log 46 | 47 | Then touch /var/log/production.log and signal syslogd with a HUP 48 | (killall -HUP syslogd, on FreeBSD). 49 | 50 | ==== /etc/newsyslog.conf 51 | 52 | Add the following line: 53 | 54 | /var/log/production.log 640 7 * @T00 Z 55 | 56 | This creates a log file that is rotated every day at midnight, gzip'd, then 57 | kept for 7 days. Consult newsyslog.conf(5) for more details. 58 | 59 | === syslog-ng setup 60 | 61 | ==== syslog-ng.conf 62 | 63 | A basic setup: 64 | 65 | destination rails_log { file("/var/log/production.log"); }; 66 | filter f_rails { program("rails.*"); }; 67 | log { source(src); filter(f_rails); destination(rails_log); }; 68 | 69 | A more advanced setup with formatting, etc: 70 | 71 | destination rails { file("/var/log/rails_apps" owner("rails") group("rails") perm(0664) template("$DATE $HOST $PROGRAM [$LEVEL] $MSGONLY\n") template_escape(no) ); }; 72 | 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"); }; 73 | log { source(src); filter(f_rails); destination(rails); }; 74 | 75 | === Starting 76 | 77 | Now restart your Rails app. Your production logs should now be showing up in 78 | /var/log/production.log. If you have mulitple machines, you can log them all 79 | to a central machine with remote syslog logging for analysis. Consult your 80 | syslogd(8) manpage for further details. 81 | 82 | == INSTALL: 83 | 84 | $ gem sources -a http://gems.github.com (you only have to do this once) 85 | $ sudo gem install cpowell-SyslogLogger 86 | 87 | == LICENSE: 88 | 89 | The original code is Copyright (c) Eric Hodel. 90 | 91 | For any additional code... 92 | 93 | Copyright (c) 2008 Christopher Powell 94 | 95 | Permission is hereby granted, free of charge, to any person obtaining 96 | a copy of this software and associated documentation files (the 97 | 'Software'), to deal in the Software without restriction, including 98 | without limitation the rights to use, copy, modify, merge, publish, 99 | distribute, sublicense, and/or sell copies of the Software, and to 100 | permit persons to whom the Software is furnished to do so, subject to 101 | the following conditions: 102 | 103 | The above copyright notice and this permission notice shall be 104 | included in all copies or substantial portions of the Software. 105 | 106 | THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, 107 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 108 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 109 | IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 110 | CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 111 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 112 | SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 113 | 114 | 115 | -------------------------------------------------------------------------------- /Rakefile: -------------------------------------------------------------------------------- 1 | require 'rubygems' 2 | require 'rake' 3 | require 'echoe' 4 | require './lib/syslog_logger.rb' 5 | 6 | Echoe.new('SyslogLogger', SyslogLogger::VERSION) do |p| 7 | p.author = 'Eric Hodel; Chris Powell; Matthew Boeh' 8 | p.email = 'drbrain@segment7.net; cpowell@prylis.com; mboeh@desperance.net' 9 | p.description = "An improved Logger replacement that logs to syslog. It is almost drop-in with a few caveats." 10 | p.url = "http://github.com/mboeh/sysloglogger" 11 | p.ignore_pattern = ["tmp/*", "script/*"] 12 | p.development_dependencies = [] 13 | end 14 | 15 | Dir["#{File.dirname(__FILE__)}/tasks/*.rake"].sort.each { |ext| load ext } 16 | -------------------------------------------------------------------------------- /lib/analyzer_tools/syslog_logger.rb: -------------------------------------------------------------------------------- 1 | require 'syslog_logger' # for compatibility 2 | -------------------------------------------------------------------------------- /lib/syslog_logger.rb: -------------------------------------------------------------------------------- 1 | require 'syslog' 2 | require 'logger' 3 | 4 | class SyslogLogger 5 | 6 | ## 7 | # The version of SyslogLogger you are using. 8 | 9 | VERSION = '1.4.2' 10 | 11 | # From 'man syslog.h': 12 | # LOG_EMERG A panic condition was reported to all processes. 13 | # LOG_ALERT A condition that should be corrected immediately. 14 | # LOG_CRIT A critical condition. 15 | # LOG_ERR An error message. 16 | # LOG_WARNING A warning message. 17 | # LOG_NOTICE A condition requiring special handling. 18 | # LOG_INFO A general information message. 19 | # LOG_DEBUG A message useful for debugging programs. 20 | 21 | # From logger rdoc: 22 | # FATAL: an unhandleable error that results in a program crash 23 | # ERROR: a handleable error condition 24 | # WARN: a warning 25 | # INFO: generic (useful) information about system operation 26 | # DEBUG: low-level information for developers 27 | 28 | ## 29 | # Maps Logger warning types to syslog(3) warning types. 30 | 31 | LOGGER_MAP = { 32 | :unknown => :alert, 33 | :fatal => :alert, 34 | :error => :err, 35 | :warn => :warning, 36 | :info => :info, 37 | :debug => :debug 38 | } 39 | 40 | ## 41 | # Maps Logger log levels to their values so we can silence. 42 | 43 | LOGGER_LEVEL_MAP = {} 44 | 45 | LOGGER_MAP.each_key do |key| 46 | LOGGER_LEVEL_MAP[key] = Logger.const_get key.to_s.upcase 47 | end 48 | 49 | ## 50 | # Maps Logger log level values to syslog log levels. 51 | 52 | LEVEL_LOGGER_MAP = {} 53 | 54 | LOGGER_LEVEL_MAP.invert.each do |level, severity| 55 | LEVEL_LOGGER_MAP[level] = LOGGER_MAP[severity] 56 | end 57 | 58 | ## 59 | # Builds a methods for level +meth+. 60 | 61 | def self.make_methods(meth) 62 | eval <<-EOM, nil, __FILE__, __LINE__ + 1 63 | def #{meth}(message = nil) 64 | return true if #{LOGGER_LEVEL_MAP[meth]} < @level 65 | message ||= yield if block_given? 66 | if message 67 | SYSLOG.#{LOGGER_MAP[meth]} clean(message) 68 | end 69 | return true 70 | end 71 | 72 | def #{meth}? 73 | @level <= Logger::#{meth.to_s.upcase} 74 | end 75 | EOM 76 | end 77 | 78 | LOGGER_MAP.each_key do |level| 79 | make_methods level 80 | end 81 | 82 | ## 83 | # Log level for Logger compatibility. 84 | 85 | attr_accessor :level 86 | 87 | ## 88 | # Fills in variables for Logger compatibility. If this is the first 89 | # instance of SyslogLogger, +program_name+ may be set to change the logged 90 | # program name. 91 | # 92 | # Due to the way syslog works, only one program name may be chosen. 93 | 94 | def initialize(program_name = 'rails') 95 | @level = Logger::DEBUG 96 | 97 | return if defined? SYSLOG 98 | self.class.const_set :SYSLOG, Syslog.open(program_name) 99 | end 100 | 101 | ## 102 | # Almost duplicates Logger#add. +progname+ is ignored. 103 | 104 | def add(severity, message = nil, progname = nil, &block) 105 | severity ||= Logger::UNKNOWN 106 | return true if severity < @level 107 | message = clean(message || block.call) 108 | SYSLOG.send LEVEL_LOGGER_MAP[severity], clean(message) 109 | return true 110 | end 111 | 112 | ## 113 | # Allows messages of a particular log level to be ignored temporarily. 114 | # 115 | # Can you say "Broken Windows"? 116 | 117 | def silence(temporary_level = Logger::ERROR) 118 | old_logger_level = @level 119 | @level = temporary_level 120 | yield 121 | ensure 122 | @level = old_logger_level 123 | end 124 | 125 | private 126 | 127 | ## 128 | # Clean up messages so they're nice and pretty. 129 | 130 | def clean(message) 131 | message = message.to_s.dup 132 | message.strip! 133 | message.gsub!(/%/, '%%') # syslog(3) freaks on % (printf) 134 | message.gsub!(/\e\[[^m]*m/, '') # remove useless ansi color codes 135 | return message 136 | end 137 | 138 | end 139 | 140 | -------------------------------------------------------------------------------- /sysloglogger.gemspec: -------------------------------------------------------------------------------- 1 | # -*- encoding: utf-8 -*- 2 | 3 | Gem::Specification.new do |s| 4 | s.name = %q{SyslogLogger} 5 | s.version = "1.4.2" 6 | 7 | s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version= 8 | s.authors = ["Eric Hodel; Chris Powell; Matthew Boeh"] 9 | s.date = %q{2009-05-28} 10 | s.description = %q{An improved Logger replacement that logs to syslog. It is almost drop-in with a few caveats.} 11 | s.email = %q{drbrain@segment7.net; cpowell@prylis.com; mboeh@desperance.net} 12 | s.extra_rdoc_files = ["README.rdoc", "lib/analyzer_tools/syslog_logger.rb", "lib/syslog_logger.rb"] 13 | s.files = ["Rakefile", "History.txt", "test/test_syslog_logger.rb", "README.rdoc", "lib/analyzer_tools/syslog_logger.rb", "lib/syslog_logger.rb", "sysloglogger.gemspec", "Manifest", "SyslogLogger.gemspec"] 14 | s.has_rdoc = true 15 | s.homepage = %q{http://github.com/mboeh/sysloglogger} 16 | s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "SyslogLogger", "--main", "README.rdoc"] 17 | s.require_paths = ["lib"] 18 | s.rubyforge_project = %q{sysloglogger} 19 | s.rubygems_version = %q{1.3.1} 20 | s.summary = %q{An improved Logger replacement that logs to syslog. It is almost drop-in with a few caveats.} 21 | s.test_files = ["test/test_syslog_logger.rb"] 22 | 23 | if s.respond_to? :specification_version then 24 | current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION 25 | s.specification_version = 2 26 | 27 | if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then 28 | else 29 | end 30 | else 31 | end 32 | end 33 | -------------------------------------------------------------------------------- /test/test_syslog_logger.rb: -------------------------------------------------------------------------------- 1 | require 'test/unit' 2 | require 'tempfile' 3 | require 'syslog_logger' 4 | 5 | module MockSyslog; end 6 | 7 | class << MockSyslog 8 | 9 | @line = nil 10 | 11 | SyslogLogger::LOGGER_MAP.values.uniq.each do |level| 12 | eval <<-EOM 13 | def #{level}(message) 14 | @line = "#{level.to_s.upcase} - \#{message}" 15 | end 16 | EOM 17 | end 18 | 19 | attr_reader :line 20 | attr_reader :program_name 21 | 22 | def open(program_name) 23 | @program_name = program_name 24 | end 25 | 26 | def reset 27 | @line = '' 28 | end 29 | 30 | end 31 | 32 | SyslogLogger.const_set :SYSLOG, MockSyslog 33 | 34 | class TestLogger < Test::Unit::TestCase 35 | 36 | LEVEL_LABEL_MAP = { 37 | Logger::DEBUG => 'DEBUG', 38 | Logger::INFO => 'INFO', 39 | Logger::WARN => 'WARN', 40 | Logger::ERROR => 'ERROR', 41 | Logger::FATAL => 'FATAL', 42 | Logger::UNKNOWN => 'ANY', 43 | } 44 | 45 | def setup 46 | @logger = Logger.new(nil) 47 | end 48 | 49 | class Log 50 | attr_reader :line, :label, :datetime, :pid, :severity, :progname, :msg 51 | def initialize(line) 52 | @line = line 53 | /\A(\w+), \[([^#]*)#(\d+)\]\s+(\w+) -- (\w*): ([\x0-\xff]*)/ =~ @line 54 | @label, @datetime, @pid, @severity, @progname, @msg = $1, $2, $3, $4, $5, $6 55 | end 56 | end 57 | 58 | def log_add(severity, msg, progname = nil, &block) 59 | log(:add, severity, msg, progname, &block) 60 | end 61 | 62 | def log(msg_id, *arg, &block) 63 | Log.new(log_raw(msg_id, *arg, &block)) 64 | end 65 | 66 | def log_raw(msg_id, *arg, &block) 67 | logdev = Tempfile.new(File.basename(__FILE__) + '.log') 68 | @logger.instance_eval { @logdev = Logger::LogDevice.new(logdev) } 69 | assert_equal true, @logger.__send__(msg_id, *arg, &block) 70 | logdev.open 71 | msg = logdev.read 72 | logdev.close 73 | msg 74 | end 75 | 76 | def test_initialize 77 | assert_equal Logger::DEBUG, @logger.level 78 | end 79 | 80 | def test_add 81 | msg = log_add nil, 'unknown level message' # nil == unknown 82 | assert_equal LEVEL_LABEL_MAP[Logger::UNKNOWN], msg.severity 83 | 84 | msg = log_add Logger::FATAL, 'fatal level message' 85 | assert_equal LEVEL_LABEL_MAP[Logger::FATAL], msg.severity 86 | 87 | msg = log_add Logger::ERROR, 'error level message' 88 | assert_equal LEVEL_LABEL_MAP[Logger::ERROR], msg.severity 89 | 90 | msg = log_add Logger::WARN, 'warn level message' 91 | assert_equal LEVEL_LABEL_MAP[Logger::WARN], msg.severity 92 | 93 | msg = log_add Logger::INFO, 'info level message' 94 | assert_equal LEVEL_LABEL_MAP[Logger::INFO], msg.severity 95 | 96 | msg = log_add Logger::DEBUG, 'debug level message' 97 | assert_equal LEVEL_LABEL_MAP[Logger::DEBUG], msg.severity 98 | end 99 | 100 | def test_add_level_unknown 101 | @logger.level = Logger::UNKNOWN 102 | 103 | msg = log_add nil, 'unknown level message' # nil == unknown 104 | assert_equal LEVEL_LABEL_MAP[Logger::UNKNOWN], msg.severity 105 | 106 | msg = log_add Logger::FATAL, 'fatal level message' 107 | assert_equal '', msg.line 108 | 109 | msg = log_add Logger::ERROR, 'error level message' 110 | assert_equal '', msg.line 111 | 112 | msg = log_add Logger::WARN, 'warn level message' 113 | assert_equal '', msg.line 114 | 115 | msg = log_add Logger::INFO, 'info level message' 116 | assert_equal '', msg.line 117 | 118 | msg = log_add Logger::DEBUG, 'debug level message' 119 | assert_equal '', msg.line 120 | end 121 | 122 | def test_add_level_fatal 123 | @logger.level = Logger::FATAL 124 | 125 | msg = log_add nil, 'unknown level message' # nil == unknown 126 | assert_equal LEVEL_LABEL_MAP[Logger::UNKNOWN], msg.severity 127 | 128 | msg = log_add Logger::FATAL, 'fatal level message' 129 | assert_equal LEVEL_LABEL_MAP[Logger::FATAL], msg.severity 130 | 131 | msg = log_add Logger::ERROR, 'error level message' 132 | assert_equal '', msg.line 133 | 134 | msg = log_add Logger::WARN, 'warn level message' 135 | assert_equal '', msg.line 136 | 137 | msg = log_add Logger::INFO, 'info level message' 138 | assert_equal '', msg.line 139 | 140 | msg = log_add Logger::DEBUG, 'debug level message' 141 | assert_equal '', msg.line 142 | end 143 | 144 | def test_add_level_error 145 | @logger.level = Logger::ERROR 146 | 147 | msg = log_add nil, 'unknown level message' # nil == unknown 148 | assert_equal LEVEL_LABEL_MAP[Logger::UNKNOWN], msg.severity 149 | 150 | msg = log_add Logger::FATAL, 'fatal level message' 151 | assert_equal LEVEL_LABEL_MAP[Logger::FATAL], msg.severity 152 | 153 | msg = log_add Logger::ERROR, 'error level message' 154 | assert_equal LEVEL_LABEL_MAP[Logger::ERROR], msg.severity 155 | 156 | msg = log_add Logger::WARN, 'warn level message' 157 | assert_equal '', msg.line 158 | 159 | msg = log_add Logger::INFO, 'info level message' 160 | assert_equal '', msg.line 161 | 162 | msg = log_add Logger::DEBUG, 'debug level message' 163 | assert_equal '', msg.line 164 | end 165 | 166 | def test_add_level_warn 167 | @logger.level = Logger::WARN 168 | 169 | msg = log_add nil, 'unknown level message' # nil == unknown 170 | assert_equal LEVEL_LABEL_MAP[Logger::UNKNOWN], msg.severity 171 | 172 | msg = log_add Logger::FATAL, 'fatal level message' 173 | assert_equal LEVEL_LABEL_MAP[Logger::FATAL], msg.severity 174 | 175 | msg = log_add Logger::ERROR, 'error level message' 176 | assert_equal LEVEL_LABEL_MAP[Logger::ERROR], msg.severity 177 | 178 | msg = log_add Logger::WARN, 'warn level message' 179 | assert_equal LEVEL_LABEL_MAP[Logger::WARN], msg.severity 180 | 181 | msg = log_add Logger::INFO, 'info level message' 182 | assert_equal '', msg.line 183 | 184 | msg = log_add Logger::DEBUG, 'debug level message' 185 | assert_equal '', msg.line 186 | end 187 | 188 | def test_add_level_info 189 | @logger.level = Logger::INFO 190 | 191 | msg = log_add nil, 'unknown level message' # nil == unknown 192 | assert_equal LEVEL_LABEL_MAP[Logger::UNKNOWN], msg.severity 193 | 194 | msg = log_add Logger::FATAL, 'fatal level message' 195 | assert_equal LEVEL_LABEL_MAP[Logger::FATAL], msg.severity 196 | 197 | msg = log_add Logger::ERROR, 'error level message' 198 | assert_equal LEVEL_LABEL_MAP[Logger::ERROR], msg.severity 199 | 200 | msg = log_add Logger::WARN, 'warn level message' 201 | assert_equal LEVEL_LABEL_MAP[Logger::WARN], msg.severity 202 | 203 | msg = log_add Logger::INFO, 'info level message' 204 | assert_equal LEVEL_LABEL_MAP[Logger::INFO], msg.severity 205 | 206 | msg = log_add Logger::DEBUG, 'debug level message' 207 | assert_equal '', msg.line 208 | end 209 | 210 | def test_add_level_debug 211 | @logger.level = Logger::DEBUG 212 | 213 | msg = log_add nil, 'unknown level message' # nil == unknown 214 | assert_equal LEVEL_LABEL_MAP[Logger::UNKNOWN], msg.severity 215 | 216 | msg = log_add Logger::FATAL, 'fatal level message' 217 | assert_equal LEVEL_LABEL_MAP[Logger::FATAL], msg.severity 218 | 219 | msg = log_add Logger::ERROR, 'error level message' 220 | assert_equal LEVEL_LABEL_MAP[Logger::ERROR], msg.severity 221 | 222 | msg = log_add Logger::WARN, 'warn level message' 223 | assert_equal LEVEL_LABEL_MAP[Logger::WARN], msg.severity 224 | 225 | msg = log_add Logger::INFO, 'info level message' 226 | assert_equal LEVEL_LABEL_MAP[Logger::INFO], msg.severity 227 | 228 | msg = log_add Logger::DEBUG, 'debug level message' 229 | assert_equal LEVEL_LABEL_MAP[Logger::DEBUG], msg.severity 230 | end 231 | 232 | def test_unknown 233 | msg = log :unknown, 'unknown level message' 234 | assert_equal LEVEL_LABEL_MAP[Logger::UNKNOWN], msg.severity 235 | 236 | @logger.level = Logger::UNKNOWN 237 | msg = log :unknown, 'unknown level message' 238 | assert_equal LEVEL_LABEL_MAP[Logger::UNKNOWN], msg.severity 239 | 240 | @logger.level = Logger::FATAL 241 | msg = log :unknown, 'unknown level message' 242 | assert_equal LEVEL_LABEL_MAP[Logger::UNKNOWN], msg.severity 243 | 244 | @logger.level = Logger::ERROR 245 | msg = log :unknown, 'unknown level message' 246 | assert_equal LEVEL_LABEL_MAP[Logger::UNKNOWN], msg.severity 247 | 248 | @logger.level = Logger::WARN 249 | msg = log :unknown, 'unknown level message' 250 | assert_equal LEVEL_LABEL_MAP[Logger::UNKNOWN], msg.severity 251 | 252 | @logger.level = Logger::INFO 253 | msg = log :unknown, 'unknown level message' 254 | assert_equal LEVEL_LABEL_MAP[Logger::UNKNOWN], msg.severity 255 | 256 | @logger.level = Logger::DEBUG 257 | msg = log :unknown, 'unknown level message' 258 | assert_equal LEVEL_LABEL_MAP[Logger::UNKNOWN], msg.severity 259 | end 260 | 261 | def test_unknown_eh 262 | @logger.level = Logger::UNKNOWN 263 | assert_equal true, @logger.unknown? 264 | 265 | @logger.level = Logger::UNKNOWN + 1 266 | assert_equal false, @logger.unknown? 267 | end 268 | 269 | def test_fatal 270 | msg = log :fatal, 'fatal level message' 271 | assert_equal LEVEL_LABEL_MAP[Logger::FATAL], msg.severity 272 | 273 | @logger.level = Logger::UNKNOWN 274 | msg = log :fatal, 'fatal level message' 275 | assert_equal '', msg.line 276 | 277 | @logger.level = Logger::FATAL 278 | msg = log :fatal, 'fatal level message' 279 | assert_equal LEVEL_LABEL_MAP[Logger::FATAL], msg.severity 280 | 281 | @logger.level = Logger::ERROR 282 | msg = log :fatal, 'fatal level message' 283 | assert_equal LEVEL_LABEL_MAP[Logger::FATAL], msg.severity 284 | 285 | @logger.level = Logger::WARN 286 | msg = log :fatal, 'fatal level message' 287 | assert_equal LEVEL_LABEL_MAP[Logger::FATAL], msg.severity 288 | 289 | @logger.level = Logger::INFO 290 | msg = log :fatal, 'fatal level message' 291 | assert_equal LEVEL_LABEL_MAP[Logger::FATAL], msg.severity 292 | 293 | @logger.level = Logger::DEBUG 294 | msg = log :fatal, 'fatal level message' 295 | assert_equal LEVEL_LABEL_MAP[Logger::FATAL], msg.severity 296 | end 297 | 298 | def test_fatal_eh 299 | @logger.level = Logger::FATAL 300 | assert_equal true, @logger.fatal? 301 | 302 | @logger.level = Logger::UNKNOWN 303 | assert_equal false, @logger.fatal? 304 | end 305 | 306 | def test_error 307 | msg = log :error, 'error level message' 308 | assert_equal LEVEL_LABEL_MAP[Logger::ERROR], msg.severity 309 | 310 | @logger.level = Logger::UNKNOWN 311 | msg = log :error, 'error level message' 312 | assert_equal '', msg.line 313 | 314 | @logger.level = Logger::FATAL 315 | msg = log :error, 'error level message' 316 | assert_equal '', msg.line 317 | 318 | @logger.level = Logger::ERROR 319 | msg = log :error, 'error level message' 320 | assert_equal LEVEL_LABEL_MAP[Logger::ERROR], msg.severity 321 | 322 | @logger.level = Logger::WARN 323 | msg = log :error, 'error level message' 324 | assert_equal LEVEL_LABEL_MAP[Logger::ERROR], msg.severity 325 | 326 | @logger.level = Logger::INFO 327 | msg = log :error, 'error level message' 328 | assert_equal LEVEL_LABEL_MAP[Logger::ERROR], msg.severity 329 | 330 | @logger.level = Logger::DEBUG 331 | msg = log :error, 'error level message' 332 | assert_equal LEVEL_LABEL_MAP[Logger::ERROR], msg.severity 333 | end 334 | 335 | def test_error_eh 336 | @logger.level = Logger::ERROR 337 | assert_equal true, @logger.error? 338 | 339 | @logger.level = Logger::FATAL 340 | assert_equal false, @logger.error? 341 | end 342 | 343 | def test_warn 344 | msg = log :warn, 'warn level message' 345 | assert_equal LEVEL_LABEL_MAP[Logger::WARN], msg.severity 346 | 347 | @logger.level = Logger::UNKNOWN 348 | msg = log :warn, 'warn level message' 349 | assert_equal '', msg.line 350 | 351 | @logger.level = Logger::FATAL 352 | msg = log :warn, 'warn level message' 353 | assert_equal '', msg.line 354 | 355 | @logger.level = Logger::ERROR 356 | msg = log :warn, 'warn level message' 357 | assert_equal '', msg.line 358 | 359 | @logger.level = Logger::WARN 360 | msg = log :warn, 'warn level message' 361 | assert_equal LEVEL_LABEL_MAP[Logger::WARN], msg.severity 362 | 363 | @logger.level = Logger::INFO 364 | msg = log :warn, 'warn level message' 365 | assert_equal LEVEL_LABEL_MAP[Logger::WARN], msg.severity 366 | 367 | @logger.level = Logger::DEBUG 368 | msg = log :warn, 'warn level message' 369 | assert_equal LEVEL_LABEL_MAP[Logger::WARN], msg.severity 370 | end 371 | 372 | def test_warn_eh 373 | @logger.level = Logger::WARN 374 | assert_equal true, @logger.warn? 375 | 376 | @logger.level = Logger::ERROR 377 | assert_equal false, @logger.warn? 378 | end 379 | 380 | def test_info 381 | msg = log :info, 'info level message' 382 | assert_equal LEVEL_LABEL_MAP[Logger::INFO], msg.severity 383 | 384 | @logger.level = Logger::UNKNOWN 385 | msg = log :info, 'info level message' 386 | assert_equal '', msg.line 387 | 388 | @logger.level = Logger::FATAL 389 | msg = log :info, 'info level message' 390 | assert_equal '', msg.line 391 | 392 | @logger.level = Logger::ERROR 393 | msg = log :info, 'info level message' 394 | assert_equal '', msg.line 395 | 396 | @logger.level = Logger::WARN 397 | msg = log :info, 'info level message' 398 | assert_equal '', msg.line 399 | 400 | @logger.level = Logger::INFO 401 | msg = log :info, 'info level message' 402 | assert_equal LEVEL_LABEL_MAP[Logger::INFO], msg.severity 403 | 404 | @logger.level = Logger::DEBUG 405 | msg = log :info, 'info level message' 406 | assert_equal LEVEL_LABEL_MAP[Logger::INFO], msg.severity 407 | end 408 | 409 | def test_info_eh 410 | @logger.level = Logger::INFO 411 | assert_equal true, @logger.info? 412 | 413 | @logger.level = Logger::WARN 414 | assert_equal false, @logger.info? 415 | end 416 | 417 | def test_debug 418 | msg = log :debug, 'debug level message' 419 | assert_equal LEVEL_LABEL_MAP[Logger::DEBUG], msg.severity 420 | 421 | @logger.level = Logger::UNKNOWN 422 | msg = log :debug, 'debug level message' 423 | assert_equal '', msg.line 424 | 425 | @logger.level = Logger::FATAL 426 | msg = log :debug, 'debug level message' 427 | assert_equal '', msg.line 428 | 429 | @logger.level = Logger::ERROR 430 | msg = log :debug, 'debug level message' 431 | assert_equal '', msg.line 432 | 433 | @logger.level = Logger::WARN 434 | msg = log :debug, 'debug level message' 435 | assert_equal '', msg.line 436 | 437 | @logger.level = Logger::INFO 438 | msg = log :debug, 'debug level message' 439 | assert_equal '', msg.line 440 | 441 | @logger.level = Logger::DEBUG 442 | msg = log :debug, 'debug level message' 443 | assert_equal LEVEL_LABEL_MAP[Logger::DEBUG], msg.severity 444 | end 445 | 446 | def test_debug_eh 447 | @logger.level = Logger::DEBUG 448 | assert_equal true, @logger.debug? 449 | 450 | @logger.level = Logger::INFO 451 | assert_equal false, @logger.debug? 452 | end 453 | 454 | end 455 | 456 | class TestSyslogLogger < TestLogger 457 | 458 | def setup 459 | super 460 | @logger = SyslogLogger.new 461 | end 462 | 463 | class Log 464 | attr_reader :line, :label, :datetime, :pid, :severity, :progname, :msg 465 | def initialize(line) 466 | @line = line 467 | return unless /\A(\w+) - (.*)\Z/ =~ @line 468 | severity, @msg = $1, $2 469 | severity = SyslogLogger::LOGGER_MAP.invert[severity.downcase.intern] 470 | @severity = severity.to_s.upcase 471 | @severity = 'ANY' if @severity == 'UNKNOWN' 472 | end 473 | end 474 | 475 | def log_add(severity, msg, progname = nil, &block) 476 | log(:add, severity, msg, progname, &block) 477 | end 478 | 479 | def log(msg_id, *arg, &block) 480 | Log.new(log_raw(msg_id, *arg, &block)) 481 | end 482 | 483 | def log_raw(msg_id, *arg, &block) 484 | assert_equal true, @logger.__send__(msg_id, *arg, &block) 485 | msg = MockSyslog.line 486 | MockSyslog.reset 487 | return msg 488 | end 489 | 490 | end 491 | 492 | --------------------------------------------------------------------------------