Class: Logger

Inherits:
Object
  • Object
show all
Includes:
Severity
Defined in:
lib/logger.rb

Defined Under Namespace

Modules: Severity Classes: Application, Error, Formatter, LogDevice, ShiftingError

Constant Summary collapse

VERSION = 
"1.2.8.1"
ProgName = 
"#{File.basename(__FILE__)}/#{VERSION}"

Constants included from Severity

Severity::DEBUG, Severity::ERROR, Severity::FATAL, Severity::INFO, Severity::UNKNOWN, Severity::WARN

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(logdev, shift_age = 0, shift_size = 1048576) ⇒ Logger

Synopsis

Logger.new(name, shift_age = 7, shift_size = 1048576)
Logger.new(name, shift_age = 'weekly')

Args

logdev

The log device. This is a filename (String) or IO object (typically STDOUT, STDERR, or an open file).

shift_age

Number of old log files to keep, or frequency of rotation (daily, weekly or monthly).

shift_size

Maximum logfile size (only applies when shift_age is a number).

Description

Create an instance.



277
278
279
280
281
282
283
284
285
286
287
 
# File 'lib/logger.rb', line 277

def initialize(logdev, shift_age = 0, shift_size = 1048576)
  @progname = nil
  @level = DEBUG
  @default_formatter = Formatter.new
  @formatter = nil
  @logdev = nil
  if logdev
    @logdev = LogDevice.new(logdev, :shift_age => shift_age,
      :shift_size => shift_size)
  end
end

Instance Attribute Details

#formatter ⇒ Object

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.



231
232
233
 
# File 'lib/logger.rb', line 231

def formatter
  @formatter
end

#level ⇒ Object Also known as: sev_threshold

Logging severity threshold (e.g. Logger::INFO).



210
211
212
 
# File 'lib/logger.rb', line 210

def level
  @level
end

#progname ⇒ Object

Logging program name.



213
214
215
 
# File 'lib/logger.rb', line 213

def progname
  @progname
end

Instance Method Details

#<<(msg) ⇒ Object

Dump given message to the log device without any formatting. If no log device exists, return nil.



357
358
359
360
361
 
# File 'lib/logger.rb', line 357

def <<(msg)
  unless @logdev.nil?
    @logdev.write(msg)
  end
end

#add(severity, message = nil, progname = nil, &block) ⇒ Object Also known as: log

Synopsis

Logger#add(severity, message = nil, progname = nil) { ... }

Args

severity

Severity. Constants are defined in Logger namespace: DEBUG, INFO, WARN, ERROR, FATAL, or UNKNOWN.

message

The log message. A String or Exception.

progname

Program name string. Can be omitted. Treated as a message if no message and block are given.

block

Can be omitted. Called to get a message string if message is nil.

Return

true if successful, false otherwise.

When the given severity is not high enough (for this particular logger), log no message, and return true.

Description

Log a message if the given severity is high enough. This is the generic logging method. Users will be more inclined to use #debug, #info, #warn, #error, and #fatal.

Message format: message can be any object, but it has to be converted to a String in order to log it. Generally, inspect is used if the given object is not a String. A special case is an Exception object, which will be printed in detail, including message, class, and backtrace. See #msg2str for the implementation if required.

Bugs

  • Logfile is not locked.

  • Append open does not need to lock file.

  • But on the OS which supports multi I/O, records possibly be mixed.



333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
 
# File 'lib/logger.rb', line 333

def add(severity, message = nil, progname = nil, &block)
  severity ||= UNKNOWN
  if @logdev.nil? or severity < @level
    return true
  end
  progname ||= @progname
  if message.nil?
    if block_given?
      message = yield
    else
      message = progname
      progname = @progname
    end
  end
  @logdev.write(
    format_message(format_severity(severity), Time.now, progname, message))
  true
end

#close ⇒ Object

Close the logging device.



438
439
440
 
# File 'lib/logger.rb', line 438

def close
  @logdev.close if @logdev
end

#datetime_format ⇒ Object

Returns the date format (string passed to strftime) being used (it’s set using datetime_format=)



222
223
224
 
# File 'lib/logger.rb', line 222

def datetime_format
  @default_formatter.datetime_format
end

#datetime_format=(datetime_format) ⇒ Object

Logging date-time format (string passed to strftime).



216
217
218
 
# File 'lib/logger.rb', line 216

def datetime_format=(datetime_format)
  @default_formatter.datetime_format = datetime_format
end

#debug(progname = nil, &block) ⇒ Object

Log a DEBUG message.

See #info for more information.



368
369
370
 
# File 'lib/logger.rb', line 368

def debug(progname = nil, &block)
  add(DEBUG, nil, progname, &block)
end

#debug? ⇒ Boolean

Returns true iff the current severity level allows for the printing of DEBUG messages.

Returns:

  • (Boolean) 


238
 
# File 'lib/logger.rb', line 238

def debug?; @level <= DEBUG; end

#error(progname = nil, &block) ⇒ Object

Log an ERROR message.

See #info for more information.



412
413
414
 
# File 'lib/logger.rb', line 412

def error(progname = nil, &block)
  add(ERROR, nil, progname, &block)
end

#error? ⇒ Boolean

Returns true iff the current severity level allows for the printing of ERROR messages.

Returns:

  • (Boolean) 


250
 
# File 'lib/logger.rb', line 250

def error?; @level <= ERROR; end

#fatal(progname = nil, &block) ⇒ Object

Log a FATAL message.

See #info for more information.



421
422
423
 
# File 'lib/logger.rb', line 421

def fatal(progname = nil, &block)
  add(FATAL, nil, progname, &block)
end

#fatal? ⇒ Boolean

Returns true iff the current severity level allows for the printing of FATAL messages.

Returns:

  • (Boolean) 


254
 
# File 'lib/logger.rb', line 254

def fatal?; @level <= FATAL; end

#info(progname = nil, &block) ⇒ Object

Log an INFO message.

The message can come either from the progname argument or the block. If both are provided, then the block is used as the message, and progname is used as the program name.

Examples

logger.info("MainApp") { "Received connection from #{ip}" }
# ...
logger.info "Waiting for input from user"
# ...
logger.info { "User typed #{input}" }

You’ll probably stick to the second form above, unless you want to provide a program name (which you can do with Logger#progname= as well).

Return

See #add.



394
395
396
 
# File 'lib/logger.rb', line 394

def info(progname = nil, &block)
  add(INFO, nil, progname, &block)
end

#info? ⇒ Boolean

Returns true iff the current severity level allows for the printing of INFO messages.

Returns:

  • (Boolean) 


242
 
# File 'lib/logger.rb', line 242

def info?; @level <= INFO; end

#unknown(progname = nil, &block) ⇒ Object

Log an UNKNOWN message. This will be printed no matter what the logger level.

See #info for more information.



431
432
433
 
# File 'lib/logger.rb', line 431

def unknown(progname = nil, &block)
  add(UNKNOWN, nil, progname, &block)
end

#warn(progname = nil, &block) ⇒ Object

Log a WARN message.

See #info for more information.



403
404
405
 
# File 'lib/logger.rb', line 403

def warn(progname = nil, &block)
  add(WARN, nil, progname, &block)
end

#warn? ⇒ Boolean

Returns true iff the current severity level allows for the printing of WARN messages.

Returns:

  • (Boolean) 


246
 
# File 'lib/logger.rb', line 246

def warn?; @level <= WARN; end