lib/yell/formatter.rb
require 'time'
# TODO: Register custom formats
#
# @example The Yell default fomat
# Yell::Formatter.register(:default)
#
# @example The Ruby standard logger format
# Yell::Formatter.register(:stdlogger, "%l, [%d #%p] %5L -- : %m", "%Y-%m-%dT%H:%M:%S.%6N")
#
module Yell #:nodoc:
# No format on the log message
#
# @example
# logger = Yell.new STDOUT, format: false
# logger.info "Hello World!"
# #=> "Hello World!"
NoFormat = "%m"
# Default Format
#
# @example
# logger = Yell.new STDOUT, format: Yell::DefaultFormat
# logger.info "Hello World!"
# #=> "2012-02-29T09:30:00+01:00 [ INFO] 65784 : Hello World!"
# # ^ ^ ^ ^
# # ISO8601 Timestamp Level Pid Message
DefaultFormat = "%d [%5L] %p : %m"
# Basic Format
#
# @example
# logger = Yell.new STDOUT, format: Yell::BasicFormat
# logger.info "Hello World!"
# #=> "I, 2012-02-29T09:30:00+01:00 : Hello World!"
# # ^ ^ ^
# # ^ ISO8601 Timestamp Message
# # Level (short)
BasicFormat = "%l, %d : %m"
# Extended Format
#
# @example
# logger = Yell.new STDOUT, format: Yell::ExtendedFormat
# logger.info "Hello World!"
# #=> "2012-02-29T09:30:00+01:00 [ INFO] 65784 localhost : Hello World!"
# # ^ ^ ^ ^ ^
# # ISO8601 Timestamp Level Pid Hostname Message
ExtendedFormat = "%d [%5L] %p %h : %m"
# The +Formatter+ provides a handle to configure your log message style.
class Formatter
Table = {
"m" => "message(event.messages)", # Message
"l" => "level(event.level, 1)", # Level (short), e.g.'I', 'W'
"L" => "level(event.level)", # Level, e.g. 'INFO', 'WARN'
"d" => "date(event.time)", # ISO8601 Timestamp
"h" => "event.hostname", # Hostname
"p" => "event.pid", # PID
"P" => "event.progname", # Progname
"t" => "event.thread_id", # Thread ID
"F" => "event.file", # Path with filename where the logger was called
"f" => "File.basename(event.file)", # Filename where the loger was called
"M" => "event.method", # Method name where the logger was called
"n" => "event.line", # Line where the logger was called
"N" => "event.name" # Name of the logger
}
# For standard formatted backwards compatibility
LegacyTable = Hash[ Table.keys.map { |k| [k, 'noop'] } ].merge(
'm' => 'message(msg)',
'l' => 'level(event, 1)',
'L' => 'level(event)',
'd' => 'date(time)',
"p" => "$$",
'P' => 'progname'
)
PatternMatcher = /([^%]*)(%\d*)?(#{Table.keys.join('|')})?(.*)/m
attr_reader :pattern, :date_pattern
# Initializes a new +Yell::Formatter+.
#
# Upon initialization it defines a format method. `format` takes
# a {Yell::Event} instance as agument in order to apply for desired log
# message formatting.
#
# @example Blank formatter
# Formatter.new
#
# @example Formatter with a message pattern
# Formatter.new("%d [%5L] %p : %m")
#
# @example Formatter with a message and date pattern
# Formatter.new("%d [%5L] %p : %m", "%D %H:%M:%S.%L")
#
# @example Formatter with a message modifier
# Formatter.new do |f|
# f.modify(Hash) { |h| "Hash: #{h.inspect}" }
# end
def initialize( *args, &block )
builder = Builder.new(*args, &block)
@pattern = builder.pattern
@date_pattern = builder.date_pattern
@modifier = builder.modifier
define_date_method!
define_call_method!
end
# Get a pretty string
def inspect
"#<#{self.class.name} pattern: #{@pattern.inspect}, date_pattern: #{@date_pattern.inspect}>"
end
private
# Message modifier class to allow different modifiers for different requirements.
class Modifier
def initialize
@repository = {}
end
def set( key, &block )
@repository.merge!(key => block)
end
def call( message )
case
when mod = @repository[message.class] || @repository[message.class.to_s]
mod.call(message)
when message.is_a?(Array)
message.map { |m| call(m) }.join(" ")
when message.is_a?(Hash)
message.map { |k, v| "#{k}: #{v}" }.join(", ")
when message.is_a?(Exception)
backtrace = message.backtrace ? "\n\t#{message.backtrace.join("\n\t")}" : ""
sprintf("%s: %s%s", message.class, message.message, backtrace)
else
message
end
end
end
# Builder class to allow setters that won't be accessible once
# transferred to the Formatter
class Builder
attr_accessor :pattern, :date_pattern
attr_reader :modifier
def initialize( pattern = nil, date_pattern = nil, &block )
@modifier = Modifier.new
@pattern = case pattern
when false then Yell::NoFormat
when nil then Yell::DefaultFormat
else pattern
end.dup
@pattern << "\n" unless @pattern[-1] == ?\n # add newline if not present
@date_pattern = date_pattern || :iso8601
block.call(self) if block
end
def modify( key, &block )
modifier.set(key, &block)
end
end
def define_date_method!
buf = case @date_pattern
when String then "t.strftime(@date_pattern)"
when Symbol then respond_to?(@date_pattern, true) ? "#{@date_pattern}(t)" : "t.#{@date_pattern}"
else t.iso8601
end
# define the method
instance_eval <<-METHOD, __FILE__, __LINE__
def date(t = Time.now)
#{buf}
end
METHOD
end
# define a standard +Logger+ backwards compatible #call method for the formatter
def define_call_method!
instance_eval <<-METHOD, __FILE__, __LINE__
def call(event, time = nil, progname = nil, msg = nil)
event.is_a?(Yell::Event) ? #{to_sprintf(Table)} : #{to_sprintf(LegacyTable)}
end
METHOD
end
def to_sprintf( table )
buff, args, _pattern = "", [], @pattern.dup
while true
match = PatternMatcher.match(_pattern)
buff << match[1] unless match[1].empty?
break if match[2].nil?
buff << match[2] + 's'
args << table[ match[3] ]
_pattern = match[4]
end
%Q{sprintf("#{buff.gsub(/"/, '\"')}", #{args.join(', ')})}
end
def level( sev, length = nil )
severity = case sev
when Integer then Yell::Severities[sev] || 'ANY'
else sev
end
length.nil? ? severity : severity[0, length]
end
def message( messages )
@modifier.call(messages.is_a?(Array) && messages.size == 1 ? messages.first : messages)
end
# do nothing
def noop
''
end
end
end