Mirror/FairMQ
1
0
Fork 0
mirror of https://github.com/FairRootGroup/FairMQ.git synced 2025-10-16 18:11:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

Simplify logger filtering options, fix log error double printing issue

Browse Source
This commit is contained in:
winckler
2016-09-16 11:46:51 +02:00
committed by Mohammad Al-Turany
parent 9ceab6099c
commit e0a03242ac
11 changed files with 527 additions and 278 deletions
Download Patch File Download Diff File Expand all files Collapse all files

316
fairmq/logger/logger.cxx
View File

@@ -33,230 +33,150 @@ namespace expr = boost::log::expressions;
namespace sinks = boost::log::sinks;
namespace attrs = boost::log::attributes;
namespace FairMQ
{
namespace Logger
{
std::vector<boost::shared_ptr<sinks::synchronous_sink<sinks::text_ostream_backend>>> sinkList;
}
}
BOOST_LOG_GLOBAL_LOGGER_INIT(global_logger, src::severity_logger_mt)
{
src::severity_logger_mt<custom_severity_level> global_logger;
global_logger.add_attribute("TimeStamp", attrs::local_clock());
init_log_console();
DefaultConsoleInit();
return global_logger;
}
void init_log_console(bool color/* = true*/)
{
FairMQ::Logger::sinkList.clear();
// add a text sink
typedef sinks::synchronous_sink<sinks::text_ostream_backend> text_sink;
logging::core::get()->remove_all_sinks();
// CONSOLE - all severity except error
boost::shared_ptr<text_sink> sink = boost::make_shared<text_sink>();
// add "console" output stream to our sink
sink->locked_backend()->add_stream(boost::shared_ptr<std::ostream>(&std::clog, empty_deleter_t()));
// specify the format of the log message
if (color)
namespace FairMQ{
namespace Logger{
std::vector<boost::shared_ptr< boost::log::sinks::basic_sink_frontend > >sinkList;// global var
}}//end namespace
void RemoveRegisteredSinks()
{
sink->set_formatter(&init_log_formatter<tag_console>);
}
else
{
sink->set_formatter(&init_log_formatter<tag_file>);
if(FairMQ::Logger::sinkList.size() > 0)
{
for(const auto& sink : FairMQ::Logger::sinkList)
logging::core::get()->remove_sink(sink);
FairMQ::Logger::sinkList.clear();
}
}
sink->set_filter(severity != SEVERITY_ERROR && severity < SEVERITY_NOLOG);
// add sink to the core
FairMQ::Logger::sinkList.push_back(sink);
logging::core::get()->add_sink(sink);
// CONSOLE - only severity error
boost::shared_ptr<text_sink> sink_error = boost::make_shared<text_sink>();
sink_error->locked_backend()->add_stream(boost::shared_ptr<std::ostream>(&std::cerr, empty_deleter_t()));
void reinit_logger(bool color, const std::string& filename, custom_severity_level threshold)
{
BOOST_LOG_SEV(global_logger::get(), custom_severity_level::NOLOG) << "";
RemoveRegisteredSinks();
DefaultConsoleInit(color);
if(threshold!=SEVERITY_NOLOG)
{
if(!filename.empty())
{
DefaultAddFileSink(filename,threshold);
}
}
if (color)
{
sink_error->set_formatter(&init_log_formatter<tag_console>);
}
else
{
sink_error->set_formatter(&init_log_formatter<tag_file>);
}
sink_error->set_filter(severity == SEVERITY_ERROR);
FairMQ::Logger::sinkList.push_back(sink_error);
logging::core::get()->add_sink(sink_error);
}
// console sink related functions
void DefaultConsoleInit(bool color/* = true*/)
{
// add a text sink
typedef sinks::synchronous_sink<sinks::text_ostream_backend> text_sink;
void reinit_logger(bool color)
{
LOG(NOLOG) << "";
logging::core::get()->remove_all_sinks();
init_log_console(color);
}
RemoveRegisteredSinks();
void init_log_file(const std::string& filename, custom_severity_level threshold, log_op::operation op, const std::string& id)
{
// add a text sink
std::string formatted_filename(filename);
formatted_filename += id;
formatted_filename += "_%Y-%m-%d_%H-%M-%S.%N.log";
boost::shared_ptr<sinks::text_file_backend> backend = boost::make_shared<sinks::text_file_backend>(
boost::log::keywords::file_name = formatted_filename,
boost::log::keywords::rotation_size = 10 * 1024 * 1024,
// rotate at midnight every day
boost::log::keywords::time_based_rotation = sinks::file::rotation_at_time_point(0, 0, 0),
// log collector,
// -- maximum total size of the stored log files is 1GB.
// -- minimum free space on the drive is 2GB
boost::log::keywords::max_size = 1000 * 1024 * 1024,
boost::log::keywords::min_free_space = 2000 * 1024 * 1024,
boost::log::keywords::auto_flush = true
//keywords::time_based_rotation = &is_it_time_to_rotate
);
typedef sinks::synchronous_sink<sinks::text_file_backend> sink_t;
boost::shared_ptr<sink_t> sink(new sink_t(backend));
// CONSOLE - all severity except error
boost::shared_ptr<text_sink> sink = boost::make_shared<text_sink>();
// add "console" output stream to our sink
sink->locked_backend()->add_stream(boost::shared_ptr<std::ostream>(&std::clog, empty_deleter_t()));
// specify the format of the log message
sink->set_formatter(&init_log_formatter<tag_file>);
// specify the format of the log message
if (color)
{
sink->set_formatter(&InitLogFormatter<tag_console>);
}
else
{
sink->set_formatter(&InitLogFormatter<tag_file>);
}
switch (op)
{
case log_op::operation::EQUAL :
sink->set_filter(severity == threshold);
break;
case log_op::operation::GREATER_THAN :
sink->set_filter(severity > threshold);
break;
case log_op::operation::GREATER_EQ_THAN :
sink->set_filter(severity >= threshold);
break;
case log_op::operation::LESS_THAN :
sink->set_filter(severity < threshold);
break;
case log_op::operation::LESS_EQ_THAN :
sink->set_filter(severity <= threshold);
break;
default:
break;
}
sink->set_filter(severity != SEVERITY_ERROR && severity < SEVERITY_NOLOG);
// add sink to the core
FairMQ::Logger::sinkList.push_back(sink);
logging::core::get()->add_sink(sink);
logging::core::get()->add_sink(sink);
}
// CONSOLE - only severity error
boost::shared_ptr<text_sink> sink_error = boost::make_shared<text_sink>();
sink_error->locked_backend()->add_stream(boost::shared_ptr<std::ostream>(&std::cerr, empty_deleter_t()));
// temporary : to be replaced with c++11 lambda
void set_global_log_level(log_op::operation op, custom_severity_level threshold)
{
switch (threshold)
{
case custom_severity_level::TRACE :
set_global_log_level_operation(op,custom_severity_level::TRACE);
break;
case custom_severity_level::DEBUG :
set_global_log_level_operation(op,custom_severity_level::DEBUG);
break;
case custom_severity_level::RESULTS :
set_global_log_level_operation(op,custom_severity_level::RESULTS);
break;
case custom_severity_level::INFO :
set_global_log_level_operation(op,custom_severity_level::INFO);
break;
case custom_severity_level::WARN :
set_global_log_level_operation(op,custom_severity_level::WARN);
break;
case custom_severity_level::STATE :
set_global_log_level_operation(op,custom_severity_level::STATE);
break;
case custom_severity_level::ERROR :
set_global_log_level_operation(op,custom_severity_level::ERROR);
break;
case custom_severity_level::NOLOG :
set_global_log_level_operation(op,custom_severity_level::NOLOG);
break;
default:
break;
}
}
if (color)
{
sink_error->set_formatter(&InitLogFormatter<tag_console>);
}
else
{
sink_error->set_formatter(&InitLogFormatter<tag_file>);
}
void set_global_log_level_operation(log_op::operation op, custom_severity_level threshold)
{
switch (op)
{
case log_op::operation::EQUAL:
FairMQ::Logger::sinkList.at(0)->set_filter(severity == threshold);
// boost::log::core::get()->set_filter(severity == threshold);
break;
case log_op::operation::GREATER_THAN:
FairMQ::Logger::sinkList.at(0)->set_filter(severity > threshold);
// boost::log::core::get()->set_filter(severity > threshold);
break;
case log_op::operation::GREATER_EQ_THAN:
FairMQ::Logger::sinkList.at(0)->set_filter(severity >= threshold);
// boost::log::core::get()->set_filter(severity >= threshold);
break;
case log_op::operation::LESS_THAN:
FairMQ::Logger::sinkList.at(0)->set_filter(severity < threshold);
// boost::log::core::get()->set_filter(severity < threshold);
break;
case log_op::operation::LESS_EQ_THAN:
FairMQ::Logger::sinkList.at(0)->set_filter(severity <= threshold);
// boost::log::core::get()->set_filter(severity <= threshold);
break;
default:
break;
}
}
sink_error->set_filter(severity == SEVERITY_ERROR);
FairMQ::Logger::sinkList.push_back(sink_error);
logging::core::get()->add_sink(sink_error);
}
void init_new_file(const std::string& filename, custom_severity_level threshold, log_op::operation op)
{
// add a file text sink with filters but without any formatting
std::string formatted_filename(filename);
formatted_filename += ".%N.txt";
boost::shared_ptr<sinks::text_file_backend> backend = boost::make_shared<sinks::text_file_backend>(
boost::log::keywords::file_name = formatted_filename,
boost::log::keywords::rotation_size = 10 * 1024 * 1024,
// rotate at midnight every day
boost::log::keywords::time_based_rotation = sinks::file::rotation_at_time_point(0, 0, 0),
// log collector,
// -- maximum total size of the stored log files is 1GB.
// -- minimum free space on the drive is 2GB
boost::log::keywords::max_size = 1000 * 1024 * 1024,
boost::log::keywords::min_free_space = 2000 * 1024 * 1024,
boost::log::keywords::auto_flush = true
//keywords::time_based_rotation = &is_it_time_to_rotate
);
typedef sinks::synchronous_sink<sinks::text_file_backend> sink_t;
boost::shared_ptr<sink_t> sink(new sink_t(backend));
int DefaultConsoleSetFilter(custom_severity_level threshold)
{
// sink->set_formatter(&init_file_formatter);
if(FairMQ::Logger::sinkList.size()>=2)
{
FairMQ::Logger::sinkList.at(0)->set_filter([threshold](const boost::log::attribute_value_set& attr_set)
{
auto sev = attr_set["Severity"].extract<custom_severity_level>();
auto mainConsoleSinkCondition = (sev != SEVERITY_ERROR) && (sev < SEVERITY_NOLOG);
return mainConsoleSinkCondition && (sev>=threshold);
});
switch (op)
{
case log_op::operation::EQUAL :
sink->set_filter(severity == threshold);
break;
case log_op::operation::GREATER_THAN :
sink->set_filter(severity > threshold);
break;
case log_op::operation::GREATER_EQ_THAN :
sink->set_filter(severity >= threshold);
break;
case log_op::operation::LESS_THAN :
sink->set_filter(severity < threshold);
break;
case log_op::operation::LESS_EQ_THAN :
sink->set_filter(severity <= threshold);
break;
default:
break;
}
FairMQ::Logger::sinkList.at(1)->set_filter([threshold](const boost::log::attribute_value_set& attr_set)
{
auto sev = attr_set["Severity"].extract<custom_severity_level>();
auto errorConsoleSinkCondition = sev == SEVERITY_ERROR;
return errorConsoleSinkCondition && (sev>=threshold);
});
return 0;
}
else
{
return 1;
}
logging::core::get()->add_sink(sink);
}
return 0;
}
// file sink related functions
void DefaultAddFileSink(const std::string& filename, custom_severity_level threshold)
{
// add a text sink
std::string formatted_filename(filename);
formatted_filename += "_%Y-%m-%d_%H-%M-%S.%N.log";
AddFileSink([threshold](const boost::log::attribute_value_set& attr_set)
{
auto sev = attr_set["Severity"].extract<custom_severity_level>();
return (sev >= threshold) && (sev < SEVERITY_NOLOG);
},
boost::log::keywords::file_name = formatted_filename,
boost::log::keywords::rotation_size = 10 * 1024 * 1024,
// rotate at midnight every day
boost::log::keywords::time_based_rotation = boost::log::sinks::file::rotation_at_time_point(0, 0, 0),
// log collector,
// -- maximum total size of the stored log files is 1GB.
// -- minimum free space on the drive is 2GB
boost::log::keywords::max_size = 1000 * 1024 * 1024,
boost::log::keywords::min_free_space = 2000 * 1024 * 1024,
boost::log::keywords::auto_flush = true
//keywords::time_based_rotation = &is_it_time_to_rotate
);
}

138
fairmq/logger/logger.h
View File

@@ -36,6 +36,7 @@
#include <boost/log/sinks/text_file_backend.hpp>
#include <boost/log/sinks/sync_frontend.hpp>
#include <boost/log/sinks/basic_sink_frontend.hpp>
// fairmq
#include "logger_def.h"
@@ -45,35 +46,6 @@
// 3- tag_console
// 4- tag_file
// Note : operation enum temporary : (until we replace it with c++11 lambda expression)
namespace log_op
{
enum operation
{
EQUAL,
GREATER_THAN,
GREATER_EQ_THAN,
LESS_THAN,
LESS_EQ_THAN
};
}
// declaration of the init function for the global logger
void init_log_console(bool color = true);
void reinit_logger(bool color);
void init_log_file(const std::string& filename,
custom_severity_level threshold = SEVERITY_THRESHOLD,
log_op::operation = log_op::GREATER_EQ_THAN,
const std::string& id = ""
);
void init_new_file(const std::string& filename,
custom_severity_level threshold,
log_op::operation op
);
void set_global_log_level(log_op::operation op = log_op::GREATER_EQ_THAN, custom_severity_level threshold = SEVERITY_THRESHOLD);
void set_global_log_level_operation(log_op::operation op = log_op::GREATER_EQ_THAN, custom_severity_level threshold=SEVERITY_THRESHOLD);
#if defined(__GNUC__) || defined(__GNUG__)
#pragma GCC diagnostic push
@@ -90,31 +62,89 @@ BOOST_LOG_ATTRIBUTE_KEYWORD(severity, "Severity", custom_severity_level)
#pragma GCC diagnostic pop
#endif
template<typename T>
void init_log_formatter(const boost::log::record_view &view, boost::log::formatting_ostream &os)
namespace FairMQ
{
os << "[";
namespace Logger
{
// common
extern std::vector<boost::shared_ptr< boost::log::sinks::basic_sink_frontend > >sinkList;// global var
}}
void reinit_logger(bool color, const std::string& filename = "", custom_severity_level threshold = SEVERITY_NOLOG);
void RemoveRegisteredSinks();
if (std::is_same<T,tag_console>::value)
template<typename T>
void InitLogFormatter(const boost::log::record_view &view, boost::log::formatting_ostream &os)
{
os << "\033[01;36m";
os << "[";
if (std::is_same<T,tag_console>::value)
{
os << "\033[01;36m";
}
auto date_time_formatter = boost::log::expressions::stream << boost::log::expressions::format_date_time<boost::posix_time::ptime>("TimeStamp", "%H:%M:%S");
date_time_formatter(view, os);
if (std::is_same<T,tag_console>::value)
{
os << "\033[0m";
}
os << "]"
<< "["
<< view.attribute_values()["Severity"].extract<custom_severity_level, T>()
<< "] "
//<< " - "
<< view.attribute_values()["Message"].extract<std::string>();
}
auto date_time_formatter = boost::log::expressions::stream << boost::log::expressions::format_date_time<boost::posix_time::ptime>("TimeStamp", "%H:%M:%S");
date_time_formatter(view, os);
if (std::is_same<T,tag_console>::value)
template<typename FunT>
int SetSinkFilterImpl(std::size_t index, FunT&& func)
{
os << "\033[0m";
if(index<FairMQ::Logger::sinkList.size())
{
FairMQ::Logger::sinkList.at(index)->set_filter(std::forward<FunT>(func));
}
return 0;
}
os << "]"
<< "["
<< view.attribute_values()["Severity"].extract<custom_severity_level, T>()
<< "] "
//<< " - "
<< view.attribute_values()["Message"].extract<std::string>();
}
// console sink related functions
void DefaultConsoleInit(bool color = true);
int DefaultConsoleSetFilter(custom_severity_level threshold);
// file sink related functions
void DefaultAddFileSink(const std::string& filename, custom_severity_level threshold);
template<typename FunT, typename... Args>
void AddFileSink(FunT&& func, Args&&... args)
{
// add a text sink
typedef boost::log::sinks::text_file_backend sink_backend_t;
typedef boost::log::sinks::synchronous_sink<sink_backend_t> sink_t;
// forward keywords args for setting log file properties
boost::shared_ptr<sink_backend_t> backend = boost::make_shared<sink_backend_t>(std::forward<Args>(args)...);
boost::shared_ptr<sink_t> sink = boost::make_shared<sink_t>(backend);
// specify the format of the log message
sink->set_formatter(&InitLogFormatter<tag_file>);
// forward lambda for setting the filter
sink->set_filter(std::forward<FunT>(func));
// add file sinks to core and list
boost::log::core::get()->add_sink(sink);
FairMQ::Logger::sinkList.push_back(sink);
}
// helper macros
@@ -128,20 +158,8 @@ void init_log_formatter(const boost::log::record_view &view, boost::log::formatt
#define MQLOG(severity) BOOST_LOG_SEV(global_logger::get(),custom_severity_level::severity)
#endif
#define SET_LOG_LEVEL(loglevel) boost::log::core::get()->set_filter(severity >= custom_severity_level::loglevel);
#define SET_LOG_FILTER(op,loglevel) set_global_log_level(log_op::op,custom_severity_level::loglevel)
// local init macros (sinks)
// Notes : when applying a filter to the sink, and then to the core, the resulting filter will
// be the intersection of the two sets defined by the two filters, i.e., core and sinks
// filename : path to file name without extension
#define INIT_LOG_FILE(filename) init_log_file(filename);
#define INIT_LOG_FILE_LVL(filename,loglevel) init_log_file(filename,custom_severity_level::loglevel);
#define INIT_LOG_FILE_FILTER(filename,op,loglevel) init_log_file(filename,custom_severity_level::loglevel,log_op::op);
//INIT_LOG_FILE_FILTER_MP : add id to log filename for multiprocess
#define INIT_LOG_FILE_FILTER_MP(filename,op,loglevel,id) init_log_file(filename,custom_severity_level::loglevel,log_op::GREATER_EQ_THAN,id);
// create new file without formatting
#define INIT_NEW_FILE(filename,op,loglevel) init_new_file(filename,custom_severity_level::loglevel,log_op::op);
#define SET_LOG_CONSOLE_LEVEL(loglevel) DefaultConsoleSetFilter(custom_severity_level::loglevel)
#define ADD_LOG_FILESINK(filename,loglevel) DefaultAddFileSink(filename, custom_severity_level::loglevel)
// Use : SET_LOG_CONSOLE_LEVEL(INFO); ADD_LOG_FILESINK(filename,ERROR);
#endif

68
fairmq/logger/run/testLogger.cxx
View File

@@ -20,7 +20,9 @@
#include "logger.h"
_Pragma("GCC diagnostic pop")
#endif
#include <boost/log/support/date_time.hpp>
void test_logger()
{
LOG(TRACE) << "this is a trace message";
@@ -32,34 +34,34 @@
LOG(STATE) << "this is a state message";
}
void test_set_level()
void test_console_level()
{
std::cout<<"********* test logger : SET_LOG_LEVEL(lvl) *********"<<std::endl;
SET_LOG_LEVEL(TRACE);
std::cout<<"********* test logger : SET_LOG_CONSOLE_LEVEL(lvl) *********"<<std::endl;
SET_LOG_CONSOLE_LEVEL(TRACE);
test_logger();
std::cout << "----------------------------"<<std::endl;
SET_LOG_LEVEL(DEBUG);
SET_LOG_CONSOLE_LEVEL(DEBUG);
test_logger();
std::cout << "----------------------------"<<std::endl;
SET_LOG_LEVEL(RESULTS);
SET_LOG_CONSOLE_LEVEL(RESULTS);
test_logger();
std::cout << "----------------------------"<<std::endl;
SET_LOG_LEVEL(INFO);
SET_LOG_CONSOLE_LEVEL(INFO);
test_logger();
std::cout << "----------------------------"<<std::endl;
SET_LOG_LEVEL(WARN);
SET_LOG_CONSOLE_LEVEL(WARN);
test_logger();
std::cout << "----------------------------"<<std::endl;
SET_LOG_LEVEL(ERROR);
SET_LOG_CONSOLE_LEVEL(ERROR);
test_logger();
std::cout << "----------------------------"<<std::endl;
SET_LOG_LEVEL(STATE);
SET_LOG_CONSOLE_LEVEL(STATE);
test_logger();
std::cout << "----------------------------"<<std::endl;
}
@@ -68,12 +70,48 @@
int main()
{
INIT_LOG_FILE_FILTER("test_log_file",GREATER_EQ_THAN,ERROR);// init and add one sink to the core
test_set_level();
INIT_LOG_FILE_FILTER("test_another_log_file",EQUAL,INFO);// init and add another sink to the core
test_set_level();
test_console_level();
SET_LOG_CONSOLE_LEVEL(INFO);
std::cout << "----------------------------"<<std::endl;
LOG(INFO)<<"open log file 1";
ADD_LOG_FILESINK("test_log1",ERROR);
test_logger();
std::cout << "----------------------------"<<std::endl;
LOG(INFO)<<"open log file 2";
ADD_LOG_FILESINK("test_log2",STATE);
test_logger();
// advanced commands
std::cout << "----------------------------"<<std::endl;
LOG(INFO)<<"open log file 3";// custom file sink setting
AddFileSink([](const boost::log::attribute_value_set& attr_set)
{
auto sev = attr_set["Severity"].extract<custom_severity_level>();
return (sev == fairmq::ERROR);
},
boost::log::keywords::file_name = "test_log3_%5N.log",
boost::log::keywords::rotation_size = 5 * 1024 * 1024,
boost::log::keywords::time_based_rotation = boost::log::sinks::file::rotation_at_time_point(12, 0, 0)
);
test_logger();
std::cout << "----------------------------"<<std::endl;
LOG(INFO)<<"set filter of last sink";// custom file sink setting
// get last added sink and reset filter to WARN and ERROR
FairMQ::Logger::sinkList.back()->set_filter([](const boost::log::attribute_value_set& attr_set)
{
auto sev = attr_set["Severity"].extract<custom_severity_level>();
return (sev == fairmq::WARN) || (sev == fairmq::ERROR);
});
test_logger();
// remove all sinks, and restart console sinks
reinit_logger(false);
test_set_level();
test_logger();
return 0;
}