class Ougai::Formatters::Readable

@attr [Array<String, Symbol>] excluded_fields The fields excluded from all logs
@attr [Boolean] plain Whether log should be plain not colorized.
A human readble formatter with amazing_print

def _call(severity, time, progname, _data) 

def _call(severity, time, progname, _data)
  data = _data.dup
  msg = data.delete(:msg)
  level = @plain ? severity : colored_level(severity)
  dt = format_datetime(time)
  err_str = create_err_str(data)
  @excluded_fields.each { |f| data.delete(f) }
  data_str = create_data_str(data)
  format_log_parts(dt, level, msg, err_str, data_str)
end

def colored_level(severity) 

def colored_level(severity)
  case severity
  when 'TRACE'
    color = '0;34'
  when 'DEBUG'
    color = '0;37'
  when 'INFO'
    color = '0;36'
  when 'WARN'
    color = '0;33'
  when 'ERROR'
    color = '0;31'
  when 'FATAL'
    color = '0;35'
  else
    color = '0;32'
  end
  "\e[#{color}m#{severity}\e[0m"
end

def create_data_str(data) 

def create_data_str(data)
  return nil if data.empty?
  data.ai({ plain: @plain })
end

def create_err_str(data) 

def create_err_str(data)
  return nil unless data.key?(:err)
  err = data.delete(:err)
  err_str = "  #{err[:name]} (#{err[:message]}):"
  err_str += "\n" + (" " * @trace_indent) + err[:stack] if err.key?(:stack)
  err_str
end

def format_log_parts(datetime, level, msg, err, data) 

def format_log_parts(datetime, level, msg, err, data)
  strs = ["[#{datetime}] #{level}: #{msg}"]
  strs.push(err) if err
  strs.push(data) if data
  strs.join("\n") + "\n"
end

def initialize(app_name = nil, hostname = nil, opts = {})

Options Hash: (**opts)
  • :excluded_fields (String) -- the value of excluded_fields attribute
  • :plain (String) -- the value of plain attribute
  • :trace_max_lines (String) -- the value of trace_max_lines attribute
  • :trace_indent (String) -- the value of trace_indent attribute

Parameters:
  • opts (Hash) -- the initial values of attributes
  • hostname (String) -- hostname (hostname if nil)
  • app_name (String) -- application name (execution program name if nil) 
def initialize(app_name = nil, hostname = nil, opts = {})
  aname, hname, opts = Base.parse_new_params([app_name, hostname, opts])
  super(aname, hname, opts)
  @trace_indent = opts.fetch(:trace_indent, 4)
  @plain = opts.fetch(:plain, false)
  @excluded_fields = opts[:excluded_fields] || []
  @serialize_backtrace = true
  load_dependent
end

def load_dependent 

def load_dependent
  require 'amazing_print'
rescue LoadError
  puts 'You must install the amazing_print gem to use this output.'
  raise
end

def serialize_backtrace=(value) 

def serialize_backtrace=(value)
  raise NotImplementedError, 'Not support serialize_backtrace'
end