core.loggingmanager: Refactoring, converted to a module. Now possible to register additional sink types (think syslog) from other modules

1 files changed, 101 insertions, 89 deletions

diff --git a/core/loggingmanager.lua b/core/loggingmanager.lua
index 53ebb99b..36f83861 100644
--- a/core/loggingmanager.lua
+++ b/core/loggingmanager.lua
@@ -1,80 +1,121 @@
 
 local format, rep = string.format, string.rep;
-local io_write = io.write;
 local pcall = pcall;
 local debug = debug;
-local tostring = tostring;
-local math_max = math.max;
+local tostring, setmetatable, rawset, pairs, ipairs, type = 
+	tostring, setmetatable, rawset, pairs, ipairs, type;
+local io_open, io_write = io.open, io.write;
+local math_max, rep = math.max, string.rep;
+local os_getenv = os.getenv;
+local getstyle, getstring = require "util.termcolours".getstyle, require "util.termcolours".getstring;
+
+local config = require "core.configmanager";
 
 local logger = require "util.logger";
 
+module "loggingmanager"
+
+-- The log config used if none specified in the config file
 local default_logging = { { to = "console" } };
 
--- Global log function, because some people are too 
--- lazy to get their own...
-_G.log = logger.init("general");
+-- The actual config loggingmanager is using
+local logging_config = config.get("*", "core", "log") or default_logging;
 
-local log_sink_types = {};
+local apply_sink_rules;
+local log_sink_types = setmetatable({}, { __newindex = function (t, k, v) rawset(t, k, v); apply_sink_rules(k); end; });
 local get_levels;
 local logging_levels = { "debug", "info", "warn", "error", "critical" }
 
---- Main function to read config, create the appropriate sinks and tell logger module
-function setup_logging(log)
-	log = log or config.get("*", "core", "log") or default_logging;
-	-- Set default logger
-	if type(log) == "string" then
-		if not log:match("^%*") then
-		end
-	elseif type(log) == "table" then
-		-- Advanced configuration chosen
-		for i, sink_config in ipairs(log) do
-			local sink_maker = log_sink_types[sink_config.to];
-			if sink_maker then
-				if sink_config.levels and not sink_config.source then
-					-- Create sink
-					local sink = sink_maker(sink_config);
-					
-					-- Set sink for all chosen levels
-					for level in pairs(get_levels(sink_config.levels)) do
-						logger.add_level_sink(level, sink);
-					end
-				elseif sink_config.source and not sink_config.levels then
-					logger.add_name_sink(sink_config.source, sink_maker(sink_config));
-				elseif sink_config.source and sink_config.levels then
-					local levels = get_levels(sink_config.levels);
-					local sink = sink_maker(sink_config);
-					logger.add_name_sink(sink_config.source,
-						function (name, level, ...)
-							if levels[level] then
-								return sink(name, level, ...);
-							end
-						end);
-				else
-					-- All sources
-					-- Create sink
-					local sink = sink_maker(sink_config);
-					
-					-- Set sink for all levels
-					for _, level in pairs(logging_levels) do
-						logger.add_level_sink(level, sink);
+local function add_rule(sink_config)
+	local sink_maker = log_sink_types[sink_config.to];
+	if sink_maker then
+		if sink_config.levels and not sink_config.source then
+			-- Create sink
+			local sink = sink_maker(sink_config);
+			
+			-- Set sink for all chosen levels
+			for level in pairs(get_levels(sink_config.levels)) do
+				logger.add_level_sink(level, sink);
+			end
+		elseif sink_config.source and not sink_config.levels then
+			logger.add_name_sink(sink_config.source, sink_maker(sink_config));
+		elseif sink_config.source and sink_config.levels then
+			local levels = get_levels(sink_config.levels);
+			local sink = sink_maker(sink_config);
+			logger.add_name_sink(sink_config.source,
+				function (name, level, ...)
+					if levels[level] then
+						return sink(name, level, ...);
 					end
-				end
-			else
-				-- No such sink type
+				end);
+		else
+			-- All sources
+			-- Create sink
+			local sink = sink_maker(sink_config);
+			
+			-- Set sink for all levels
+			for _, level in pairs(logging_levels) do
+				logger.add_level_sink(level, sink);
 			end
 		end
+	else
+		-- No such sink type
 	end
 end
 
---- Definition of built-in logging sinks ---
-local math_max, rep = math.max, string.rep;
+-- Search for all rules using a particular sink type,
+-- and apply them
+function apply_sink_rules(sink_type)
+	if type(logging_config) == "table" then
+		for _, sink_config in pairs(logging_config) do
+			if sink_config.to == sink_type then
+				add_rule(sink_config);
+			end
+		end
+	elseif type(logging_config) == "string" and sink_type == "file" then
+		-- User specified simply a filename, and the "file" sink type 
+		-- was just added
+	end
+end
 
--- Column width for "source" (used by stdout and console)
+
+
+--- Helper function to get a set of levels given a "criteria" table
+function get_levels(criteria, set)
+	set = set or {};
+	if type(criteria) == "string" then
+		set[criteria] = true;
+		return set;
+	end
+	local min, max = criteria.min, criteria.max;
+	if min or max then
+		local in_range;
+		for _, level in ipairs(logging_levels) do
+			if min == level then
+				set[level] = true;
+				in_range = true;
+			elseif max == level then
+				set[level] = true;
+				return set;
+			elseif in_range then
+				set[level] = true;
+			end	
+		end
+	end
+	
+	for _, level in ipairs(criteria) do
+		set[level] = true;
+	end
+	return set;
+end
+
+--- Definition of built-in logging sinks ---
 
 function log_sink_types.nowhere()
 	return function () return false; end;
 end
 
+-- Column width for "source" (used by stdout and console)
 local sourcewidth = 20;
 
 function log_sink_types.stdout()
@@ -90,8 +131,7 @@ function log_sink_types.stdout()
 end
 
 do
-	local getstyle, getstring = require "util.termcolours".getstyle, require "util.termcolours".getstring;
-	local do_pretty_printing = not os.getenv("WINDIR");
+	local do_pretty_printing = not os_getenv("WINDIR");
 	
 	local logstyles = {};
 	if do_pretty_printing then
@@ -119,12 +159,12 @@ end
 
 function log_sink_types.file(config)
 	local log = config.filename;
-	local logfile = io.open(log, "a+");
+	local logfile = io_open(log, "a+");
 	if not logfile then
 		return function () end
 	end
 
-	local write, format, flush = logfile.write, string.format, logfile.flush;
+	local write, format, flush = logfile.write, format, logfile.flush;
 	return function (name, level, message, ...)
 		if ... then 
 			write(logfile, name, "\t", level, "\t", format(message, ...), "\n");
@@ -135,38 +175,10 @@ function log_sink_types.file(config)
 	end;
 end
 
-function log_sink_types.syslog()
+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
 
---- Helper function to get a set of levels given a "criteria" table
-function get_levels(criteria, set)
-	set = set or {};
-	if type(criteria) == "string" then
-		set[criteria] = true;
-		return set;
-	end
-	local min, max = criteria.min, criteria.max;
-	if min or max then
-		local in_range;
-		for _, level in ipairs(logging_levels) do
-			if min == level then
-				set[level] = true;
-				in_range = true;
-			elseif max == level then
-				set[level] = true;
-				return set;
-			elseif in_range then
-				set[level] = true;
-			end	
-		end
-	end
-	
-	for _, level in ipairs(criteria) do
-		set[level] = true;
-	end
-	return set;
-end
-
---- Set up logging
-setup_logging();
-
+return _M;