You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 

247 lines
8.4 KiB

require_relative 'ansi_wrapper'
require_relative 'ansi_colors'
require_relative 'ansi_dimensions'
require 'io/console'
require 'amazing_print'
require 'json'
module Semantic
# wraps meanwhile takes care of ansi colors
class AnsiFormatter < SemanticLogger::Formatters::Color
include AnsiColors
CENTER_SIZE = 20
FOREMAN_PREFIX_LENGTH = 18
FAILOVER_WRAP = 80
CHAR_FATAL = '⯶'.freeze
TERMINUS_STRING = '╙─╜'.freeze
RENDERED_VIEW_DURATION = 100
TOTAL_RENDERED_VIEW_DURATION = RENDERED_VIEW_DURATION * 5
def initialize
super(color_map:
ColorMap.new(
debug: CLEAR + TEXT_GRAY_400,
info: CLEAR + TEXT_GRAY_100,
warn: CLEAR + BG_YELLOW + TEXT_BLACK,
error: CLEAR + BG_RED + TEXT_WHITE,
fatal: CLEAR + BG_MAGENTA + BOLD + TEXT_WHITE
))
@memory = nil
end
def call(log, logger)
log = alter(log)
self.log = log
self.logger = logger
self.color = color_map[log.level]
wrap_level(compute_useful_length, message, payload, exception)
end
def reject(log)
return true if log.name == 'ActionView::Base' && log.message&.starts_with?(' Rendering')
true if log.name == 'Rails' && log.message&.starts_with?('Loaded')
end
private
def build_regex_redirected
dev_port = Rails.application.routes.default_url_options[:port]
dev_hosts = ['127.0.0.1', 'localhost', Rails.application.routes.default_url_options[:host]].uniq.join('|')
dev_from = "http://(?:#{dev_hosts}):#{dev_port}"
regex_s = "^(Redirected to )#{dev_from}(.*)"
Regexp.new(regex_s)
end
def ansi_trace(trace, symbol)
match = trace.match(/(↳ )?(.*:\d+)(:in `)?(.*'?)/) # only m2(=file) and m4(=optional function) are useful
return trace unless match
_, m2, _, m4 = match.captures
"#{symbol} #{m2} #{BOLD}#{m4.chop}#{CLEAR}"
end
def two_captures_last_as_bold(message, regex)
match = message.match(regex)
return "unmatched: #{message}" unless match
m1, m2 = match.captures
"#{m1}#{BOLD}#{m2}#{CLEAR}"
end
def alter(log)
if log.name == 'Rails'
if log.message
log.message.lstrip!
log.message.chomp!('')
if log.message.starts_with?('Started')
rails = '╓─╖'
before = 1
if @memory
rails = "#{@memory}"
before = 0
end
log.dimensions = AnsiDimensions.new(rails:, before:)
@memory = nil
log.message = two_captures_last_as_bold(log.message, /(^Started \w* )"(.*?)"/)
elsif log.message.starts_with?('Parameters')
parameters = log.message.match(/Parameters: ({.*}$)/).match(1)
parameters = JSON.parse(parameters.gsub('=>', ':'), symbolize_names: true)
parameters = parameters.ai(ruby19_syntax: true, plain: true, multiline: false)
parameters = parameters.gsub(/\w*:/) { |key| "#{TEXT_GRAY_200}#{key.chop}#{color_map[:debug]}:" }
parameters = parameters.gsub(/: ".*?"/) do |value|
": \"#{TEXT_YELLOW}#{value[3..-2]}#{color_map[:debug]}\""
end
log.message = "Parameters: #{parameters}"
log.level = :debug
elsif log.message.starts_with?('Completed')
m1, m2, m3, m4 = log.message.match(/^Completed (\d+) (.*) in (\d+\.?\d*)ms (.*)$/).captures
http_code = m1.to_i
duration = m3.to_f
duration = duration > TOTAL_RENDERED_VIEW_DURATION ? " in #{m3}ms #{m4}" : ''
log.message = "Completed #{BOLD}#{http_code}#{CLEAR} #{m2}#{duration}"
if http_code / 100 == 2
log.dimensions = AnsiDimensions.new(rails: TERMINUS_STRING, after: 1)
elsif http_code / 100 == 3
@memory = '║'
log.dimensions = AnsiDimensions.new(rails: "#{@memory}")
elsif http_code / 100 == 4
log.dimensions = AnsiDimensions.new(rails: '╙╨╜')
elsif http_code / 100 == 5
log.dimensions = AnsiDimensions.new(rails: "#{draw_fatal}")
end
elsif log.message =~ /^(Processing|Parameters)/
log.level = :debug
if log.message =~ /^Processing/
log.message = two_captures_last_as_bold(log.message, /(^Processing by \w*#\w* as )(.*)/)
end
elsif log.message =~ /Redirected/
log.level = :debug
@regex_redirected ||= build_regex_redirected # lazy building
log.message = two_captures_last_as_bold(log.message, @regex_redirected)
end
elsif log.exception
log.dimensions = AnsiDimensions.new(
rails: "#{draw_fatal(log.level.to_s.chr.upcase)}",
after: 1,
terminus: true
)
end
elsif log.name =~ /^(ActionView|ActiveRecord)::Base/
log.level = :debug
log.message.lstrip!
if log.name == 'ActiveRecord::Base'
unbold!(log.message)
if log.message.starts_with?('↳ ')
log.message = ansi_trace(log.message, '⇄')
else
sql_match = log.message.match(/\s+\[\[.*\]\]$/)
if sql_match
sql_command = sql_match.pre_match
sql_type, sql_entry = sql_command.split("\e[0m")
sql_color_entry = sql_entry.match(ANSI_REGEX).to_s
sql_args = JSON.parse(sql_match.to_s).map(&:last)
sql_args.each_with_index do |val, index|
sql_arg = val.inspect
sql_arg = "'#{val.gsub("'", "''")}'" if val.is_a?(String)
sql_entry.gsub!("$#{index + 1}", colorize(sql_arg, BOLD) + sql_color_entry)
end
log.message = [sql_type, sql_entry].join(CLEAR)
end
end
elsif log.name == 'ActionView::Base'
match = log.message.match(/^Rendered( layout| collection of|) (.*?\.erb)(.*)(\(Duration:.*\))/)
if match
m1, m2, m3, m4 = match.captures
duration = m4.match(/Duration: (\d+\.?\d*)ms/).match(1).to_f
duration = duration < RENDERED_VIEW_DURATION ? '' : m4.to_s
log.message = "⇤ Rendered#{m1} app/views/#{m2}#{m3}#{duration}"
end
end
end
log
end
def draw_fatal(char = CHAR_FATAL)
BG_MAGENTA + BOLD + TEXT_WHITE + char + CLEAR
end
def origin = colorize(centerize(log.name), TEXT_CYAN)
def build_prefix(char) = "#{origin}#{colorize(char)}"
def build_terminus = "#{origin} #{TERMINUS_STRING} "
def centerize(text) = text.truncate(CENTER_SIZE).center(CENTER_SIZE)
def colorize(text, tint = color) = "#{tint}#{text}#{CLEAR}"
def stackisize(items)
return '' if items.empty?
traces = items.map { |item| ansi_trace(item, '➟') }
"\n#{traces.join("\n")}"
end
def build_dimensions(dimensions)
"#{origin} #{dimensions.rails} "
end
def compute_useful_length
IO.console.winsize[1] - FOREMAN_PREFIX_LENGTH
rescue StandardError
FAILOVER_WRAP
end
def unbold!(text) = text.gsub!(BOLD, '')
def message
colorize(log.message) if log.message
end
def payload
return unless log.payload
log.payload.ai(indent: 2, object_id: false)
end
def exception
return unless log.exception
exc = log.exception
clazz = colorize("#{exc.class}\n", color_map[:fatal])
message = colorize(exc.message.chomp(''), color_map[:error])
backtrace = stackisize(Rails.backtrace_cleaner.clean(exc.backtrace))
"#{clazz}#{message}#{backtrace}"
end
def level_char
case log.level
when :info, :debug then ' '
else log.level.to_s.chr.upcase
end
end
def wrap_level(length, *items)
prefix = log.dimensions ? build_dimensions(log.dimensions) : build_prefix(level_char)
continuation = build_prefix('┆')
result = items.map do |item|
AnsiWrapper.wrap(item, length, prefix, continuation)
end
if log.dimensions&.terminus
terminus = AnsiWrapper.wrap(' ', length, build_terminus)
result << terminus
end
log.dimensions&.before&.times { result.unshift('') }
log.dimensions&.after&.times { result << '' }
result.compact.join("\n")
end
end
end