class Loggability::Logger
A subclass of Logger that provides additional API for configuring outputters, formatters, etc.
Constants
- DEFAULT_DEVICE
Default log 'device'
- DEFAULT_SHIFT_AGE
Default 'shift age'
- DEFAULT_SHIFT_SIZE
Default 'shift size'
Attributes
The line that caused this logger to be created.
Public Class Methods
Return an equivalent Loggability::Logger object
for the given logger
.
# File lib/loggability/logger.rb, line 129 def self::from_std_logger( logger ) device = logger.instance_variable_get( :@logdev ) or raise ArgumentError, "%p doesn't appear to be a Logger (no @logdev)" % [ logger ] newlogger = self.new( device.dev ) newlogger.level = logger.level newlogger.formatter = logger.formatter return newlogger end
Create a new Logger wrapper that will output to
the specified logdev
.
# File lib/loggability/logger.rb, line 147 def initialize( logdev=DEFAULT_DEVICE, *args ) super( nil ) self.level = if $DEBUG then :debug else :warn end self.output_to( logdev, *args ) @created_from = caller( 3 ).first @default_formatter = Loggability::Formatter.create( :default ) end
Public Instance Methods
Append operator – Override Logger's append so log messages always have formatting, and are always appended at :debug level.
# File lib/loggability/logger.rb, line 187 def <<( message ) unless self.logdev.nil? self.add( Logger::DEBUG, message ) end end
Return a human-readable representation of the object suitable for debugging.
# File lib/loggability/logger.rb, line 168 def inspect dev = if self.logdev.respond_to?( :dev ) self.logdev.dev.class else self.logdev end return "#<%p:%#x severity: %s, formatter: %s, outputting to: %p>" % [ self.class, self.object_id * 2, self.level, self.formatter.class.name.sub( /.*::/, '' ).downcase, dev, ] end
Restore the level, logdev, and formatter from the given
settings
.
# File lib/loggability/logger.rb, line 214 def restore_settings( settings ) self.level = settings[:level] if settings[ :level ] self.output_to( settings[:logdev] ) if settings[ :logdev ] self.format_with( settings[:formatter] ) if settings[ :formatter ] end
Return a Hash that contains its settings suitable for restoration via restore_settings later.
# File lib/loggability/logger.rb, line 204 def settings return { level: self.level, logdev: self.logdev, formatter: self.formatter, } end
Rack::CommonLogger compatibility method – append a message
at
'info' level.
# File lib/loggability/logger.rb, line 195 def write( message ) unless self.logdev.nil? self.add( Logger::INFO, message ) end end
Output Device
↑ topAttributes
The raw log device
Public Instance Methods
Change the log device to log to target
instead of what it was
before. Any additional args
are passed to the LogDevice's
constructor. In addition to Logger's support for logging to IO objects
and files (given a filename in a String), this method can also set up
logging to any object that responds to <<.
# File lib/loggability/logger.rb, line 253 def output_to( target, *args ) if target.is_a?( Logger::LogDevice ) || target.is_a?( Loggability::Logger::AppendingLogDevice ) self.logdev = target elsif target.respond_to?( :write ) || target.is_a?( String ) opts = { :shift_age => args.shift || 0, :shift_size => args.shift || 1048576 } self.logdev = Logger::LogDevice.new( target, opts ) elsif target.respond_to?( :<< ) self.logdev = AppendingLogDevice.new( target ) else raise ArgumentError, "don't know how to output to %p (a %p)" % [ target, target.class ] end end
Output Formatting API
↑ topPublic Instance Methods
Format a log message using the current formatter and return it.
# File lib/loggability/logger.rb, line 280 def format_message( severity, datetime, progname, msg ) self.formatter.call(severity, datetime, progname, msg) end
Set a new formatter
for the logger. If formatter
is nil
or :default
, this causes the logger to
fall back to its default formatter. If it's a Symbol other than
:default
, it looks for a similarly-named formatter under
loggability/formatter/ and uses that. If formatter
is an
object that responds to call (e.g., a Proc or a Method object), that object
is used directly.
Procs and methods should have the method signature: (severity, datetime, progname, msg).
# Load and use the HTML formatter MyProject.logger.format_with( :html ) # Call self.format_logmsg(...) to format messages MyProject.logger.format_with( self.method(:format_logmsg) ) # Reset to the default MyProject.logger.format_with( :default )
# File lib/loggability/logger.rb, line 301 def format_with( formatter=nil, &block ) # :yield: severity, datetime, progname, msg formatter ||= block if formatter.nil? || formatter == :default @formatter = nil elsif formatter.respond_to?( :call ) @formatter = formatter elsif formatter.respond_to?( :to_sym ) @formatter = Loggability::Formatter.create( formatter ) else raise ArgumentError, "don't know what to do with a %p formatter (%p)" % [ formatter.class, formatter ] end end
Return the current formatter used to format log messages.
# File lib/loggability/logger.rb, line 274 def formatter return ( @formatter || @default_formatter ) end
Progname Proxy
↑ topPublic Instance Methods
Create a logging proxy for object
that will include its name
as the 'progname' of each message.
# File lib/loggability/logger.rb, line 332 def proxy_for( object ) return ObjectNameProxy.new( self, object ) end
Severity Level
↑ topPublic Instance Methods
Return the logger's level as a Symbol.
# File lib/loggability/logger.rb, line 226 def level numeric_level = super return LOG_LEVEL_NAMES[ numeric_level ] end
Set the logger level to newlevel
, which can be a numeric level
(e.g., Logger::DEBUG, etc.), or a symbolic level (e.g., :debug, :info,
etc.)
# File lib/loggability/logger.rb, line 234 def level=( newlevel ) newlevel = LOG_LEVELS[ newlevel.to_sym ] if newlevel.respond_to?( :to_sym ) && LOG_LEVELS.key?( newlevel.to_sym ) super( newlevel ) end