X-Git-Url: https://git.enpas.org/?a=blobdiff_plain;f=core%2Floggingmanager.lua;h=e3a83817b5d239c2009bc0261b674ad71ef98b7b;hb=2518a9b0cd8e43f84c98e26580b931c510d2944b;hp=c63611468ba2fa2343567759ffb779e5d9220831;hpb=ac8c3154923599cf1226ae4d7ea5a6ab0d473ea5;p=prosody.git diff --git a/core/loggingmanager.lua b/core/loggingmanager.lua index c6361146..e3a83817 100644 --- a/core/loggingmanager.lua +++ b/core/loggingmanager.lua @@ -10,29 +10,28 @@ local format = string.format; local setmetatable, rawset, pairs, ipairs, type = setmetatable, rawset, pairs, ipairs, type; -local io_open, io_write = io.open, io.write; +local stdout = io.stdout; +local io_open = io.open; local math_max, rep = math.max, string.rep; local os_date = os.date; -local getstyle, setstyle = require "util.termcolours".getstyle, require "util.termcolours".setstyle; - -if os.getenv("__FLUSH_LOG") then - local io_flush = io.flush; - local _io_write = io_write; - io_write = function(...) _io_write(...); io_flush(); end -end +local getstyle, getstring = require "util.termcolours".getstyle, require "util.termcolours".getstring; +local tostring = tostring; +local select = select; +local unpack = table.unpack or unpack; --luacheck: ignore 113 local config = require "core.configmanager"; local logger = require "util.logger"; local prosody = prosody; _G.log = logger.init("general"); +prosody.log = logger.init("general"); -module "loggingmanager" +local _ENV = nil; -- The log config used if none specified in the config file (see reload_logging for initialization) local default_logging; local default_file_logging; -local default_timestamp = "%b %d %H:%M:%S"; +local default_timestamp = "%b %d %H:%M:%S "; -- The actual config loggingmanager is using local logging_config; @@ -45,16 +44,16 @@ local logging_levels = { "debug", "info", "warn", "error" } -- This function is called automatically when a new sink type is added [see apply_sink_rules()] local function add_rule(sink_config) local sink_maker = log_sink_types[sink_config.to]; - if sink_maker then - -- Create sink - local sink = sink_maker(sink_config); + if not sink_maker then + return; -- No such sink type + end - -- Set sink for all chosen levels - for level in pairs(get_levels(sink_config.levels or logging_levels)) do - logger.add_level_sink(level, sink); - end - else - -- No such sink type + -- Create sink + local sink = sink_maker(sink_config); + + -- Set sink for all chosen levels + for level in pairs(get_levels(sink_config.levels or logging_levels)) do + logger.add_level_sink(level, sink); end end @@ -136,7 +135,7 @@ function get_levels(criteria, set) end -- Initialize config, etc. -- -function reload_logging() +local function reload_logging() local old_sink_types = {}; for name, sink_maker in pairs(log_sink_types) do @@ -152,11 +151,9 @@ function reload_logging() default_file_logging = { { to = "file", levels = { min = (debug_mode and "debug") or "info" }, timestamps = true } }; - default_timestamp = "%b %d %H:%M:%S"; logging_config = config.get("*", "log") or default_logging; - for name, sink_maker in pairs(old_sink_types) do log_sink_types[name] = sink_maker; end @@ -170,107 +167,98 @@ prosody.events.add_handler("config-reloaded", reload_logging); --- Definition of built-in logging sinks --- -- Null sink, must enter log_sink_types *first* -function log_sink_types.nowhere() +local function log_to_nowhere() return function () return false; end; end +log_sink_types.nowhere = log_to_nowhere; --- Column width for "source" (used by stdout and console) -local sourcewidth = 20; +local function log_to_file(sink_config, logfile) + logfile = logfile or io_open(sink_config.filename, "a+"); + if not logfile then + return log_to_nowhere(sink_config); + end + local write = logfile.write; -function log_sink_types.stdout(config) - local timestamps = config.timestamps; + local timestamps = sink_config.timestamps; if timestamps == true then timestamps = default_timestamp; -- Default format + elseif timestamps then + timestamps = timestamps .. " "; end - return function (name, level, message, ...) - sourcewidth = math_max(#name+2, sourcewidth); - local namelen = #name; - if timestamps then - io_write(os_date(timestamps), " "); - end - if ... then - io_write(name, rep(" ", sourcewidth-namelen), level, "\t", format(message, ...), "\n"); - else - io_write(name, rep(" ", sourcewidth-namelen), level, "\t", message, "\n"); - end - end -end - -do - local do_pretty_printing = true; - - local logstyles = {}; - if do_pretty_printing then - logstyles["info"] = getstyle("bold"); - logstyles["warn"] = getstyle("bold", "yellow"); - logstyles["error"] = getstyle("bold", "red"); + if sink_config.buffer_mode ~= false then + logfile:setvbuf(sink_config.buffer_mode or "line"); end - function log_sink_types.console(config) - -- Really if we don't want pretty colours then just use plain stdout - if not do_pretty_printing then - return log_sink_types.stdout(config); - end - local timestamps = config.timestamps; + -- Column width for "source" (used by stdout and console) + local sourcewidth = sink_config.source_width; - if timestamps == true then - timestamps = default_timestamp; -- Default format + return function (name, level, message, ...) + local n = select('#', ...); + if n ~= 0 then + local arg = { ... }; + for i = 1, n do + arg[i] = tostring(arg[i]); + end + message = format(message, unpack(arg, 1, n)); end - return function (name, level, message, ...) + if sourcewidth then sourcewidth = math_max(#name+2, sourcewidth); - local namelen = #name; - - if timestamps then - io_write(os_date(timestamps), " "); - end - io_write(name, rep(" ", sourcewidth-namelen)); - setstyle(logstyles[level]); - io_write(level); - setstyle(); - if ... then - io_write("\t", format(message, ...), "\n"); - else - io_write("\t", message, "\n"); - end + name = name .. rep(" ", sourcewidth-#name); + else + name = name .. "\t"; end + write(logfile, timestamps and os_date(timestamps) or "", name, level, "\t", message, "\n"); end end +log_sink_types.file = log_to_file; -local empty_function = function () end; -function log_sink_types.file(config) - local log = config.filename; - local logfile = io_open(log, "a+"); - if not logfile then - return empty_function; +local function log_to_stdout(sink_config) + if not sink_config.timestamps then + sink_config.timestamps = false; + end + if sink_config.source_width == nil then + sink_config.source_width = 20; end - local write, flush = logfile.write, logfile.flush; + return log_to_file(sink_config, stdout); +end +log_sink_types.stdout = log_to_stdout; - local timestamps = config.timestamps; +local do_pretty_printing = true; - if timestamps == nil or timestamps == true then - timestamps = default_timestamp; -- Default format - end +local logstyles; +if do_pretty_printing then + logstyles = {}; + logstyles["info"] = getstyle("bold"); + logstyles["warn"] = getstyle("bold", "yellow"); + logstyles["error"] = getstyle("bold", "red"); +end +local function log_to_console(sink_config) + -- Really if we don't want pretty colours then just use plain stdout + local logstdout = log_to_stdout(sink_config); + if not do_pretty_printing then + return logstdout; + end return function (name, level, message, ...) - if timestamps then - write(logfile, os_date(timestamps), " "); - end - if ... then - write(logfile, name, "\t", level, "\t", format(message, ...), "\n"); - else - write(logfile, name, "\t" , level, "\t", message, "\n"); + local logstyle = logstyles[level]; + if logstyle then + level = getstring(logstyle, level); end - flush(logfile); - end; + return logstdout(name, level, message, ...); + end end +log_sink_types.console = log_to_console; -function register_sink_type(name, sink_maker) +local function register_sink_type(name, sink_maker) local old_sink_maker = log_sink_types[name]; log_sink_types[name] = sink_maker; return old_sink_maker; end -return _M; +return { + reload_logging = reload_logging; + register_sink_type = register_sink_type; +}