sascha/query
1
0
Fork 0
Code Issues 4 Pull Requests Actions Packages Projects Releases Wiki Activity

stabilized logger classes

Browse Source
This commit is contained in:
Sascha Kühl
2026-02-04 14:45:26 +01:00
parent e7e66f44e2
commit 520b2bab49
10 changed files with 112 additions and 135 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/core/logger/log_domain.cpp
+20 -23
View File
@@ -44,11 +44,13 @@ char* gettimestamp(char* const buffer, const size_t size) {
}
std::map<log_level, std::string> log_domain::level_strings = { /* NOLINT */
{ log_level::LVL_DEBUG, "DEBUG" },
{ log_level::LVL_INFO, "INFO" },
{ log_level::LVL_WARN, "WARN" },
{ log_level::LVL_ERROR, "ERROR" },
{ log_level::LVL_TRACE, "TRACE" }
{ log_level::Fatal, "Fatal" },
{ log_level::Debug, "Debug" },
{ log_level::Info, "Info" },
{ log_level::Warn, "Warn" },
{ log_level::Error, "Error" },
{ log_level::Trace, "Trace" },
{ log_level::All, "All" }
};
log_domain::log_domain(std::string name, const log_level_range log_range)
@@ -61,33 +63,29 @@ std::string log_domain::name() const
return name_;
}
void log_domain::max_log_level(log_level max_level)
{
void log_domain::max_log_level(const log_level max_level) {
log_level_range_.max_level = max_level;
}
log_level log_domain::max_log_level() const
{
log_level log_domain::max_log_level() const {
return log_level_range_.max_level;
}
void log_domain::min_log_level(log_level min_level)
{
void log_domain::min_log_level(const log_level min_level) {
log_level_range_.min_level = min_level;
}
log_level log_domain::min_log_level() const
{
log_level log_domain::min_log_level() const {
return log_level_range_.min_level;
}
void log_domain::add_sink(sink_ptr sink)
{
void log_domain::add_sink(sink_ptr sink) {
std::lock_guard l(mutex_);
sinks.push_back(std::move(sink));
}
void log_domain::log(log_level lvl, const std::string &source, const char *message) const {
if (lvl < log_level_range_.max_level || lvl > log_level_range_.min_level) {
void log_domain::log(const log_level lvl, const std::string &source, const char *message) const {
if (lvl < log_level_range_.min_level || lvl > log_level_range_.max_level) {
return;
}
@@ -97,9 +95,9 @@ void log_domain::log(log_level lvl, const std::string &source, const char *messa
char buffer[1024];
#ifdef _MSC_VER
int ret = sprintf_s(buffer, 1024, "%s [Thread %zu] [%-7s] [%s]: %s\n", timestamp, details::acquire_thread_index(std::this_thread::get_id()), level_strings[lvl].c_str(), source.c_str(), message);
const int ret = sprintf_s(buffer, 1024, "%s [Thread %zu] [%-7s] [%s]: %s\n", timestamp, details::acquire_thread_index(std::this_thread::get_id()), level_strings[lvl].c_str(), source.c_str(), message);
#else
int ret = sprintf(buffer, "%s [Thread %lu] [%-7s] [%s]: %s\n", timestamp, details::acquire_thread_index(std::this_thread::get_id()), level_strings[lvl].c_str(), source.c_str(), message);
const int ret = sprintf(buffer, "%s [Thread %lu] [%-7s] [%s]: %s\n", timestamp, details::acquire_thread_index(std::this_thread::get_id()), level_strings[lvl].c_str(), source.c_str(), message);
#endif
std::lock_guard<std::mutex> l(mutex_);
@@ -108,13 +106,12 @@ void log_domain::log(log_level lvl, const std::string &source, const char *messa
}
}
void log_domain::clear()
{
void log_domain::clear() {
std::lock_guard l(mutex_);
sinks.clear();
}
void log_domain::get_time_stamp(char* const timestamp_buffer) const {
std::lock_guard l(mutex_);
void log_domain::get_time_stamp(char* const timestamp_buffer) {
details::gettimestamp(timestamp_buffer, 80);
}
source/core/logger/log_level.cpp
+7 -7
View File
@@ -7,25 +7,25 @@ namespace matador::logger {
std::ostream& operator<<(std::ostream &os, const log_level lvl)
{
switch (lvl) {
case log_level::LVL_ERROR:
case log_level::Error:
os << "ERROR";
break;
case log_level::LVL_FATAL:
case log_level::Fatal:
os << "FATAL";
break;
case log_level::LVL_DEBUG:
case log_level::Debug:
os << "DEBUG";
break;
case log_level::LVL_INFO:
case log_level::Info:
os << "INFO";
break;
case log_level::LVL_TRACE:
case log_level::Trace:
os << "TRACE";
break;
case log_level::LVL_WARN:
case log_level::Warn:
os << "WARN";
break;
case log_level::LVL_ALL:
case log_level::All:
os << "ALL";
break;
default:
source/core/logger/log_manager.cpp
+26 -31
View File
@@ -5,19 +5,18 @@ namespace matador::logger {
log_level_range log_manager::default_log_level_range_ = {};
logger log_manager::create_logger(std::string source) const {
return logger(std::move(source), default_log_domain_);
return {std::move(source), default_log_domain_};
}
logger log_manager::create_logger(std::string source, const std::string &domain_name) {
return logger(std::move(source), acquire_domain(domain_name));
return {std::move(source), acquire_domain(domain_name)};
}
void log_manager::add_sink(sink_ptr sink) const {
default_log_domain_->add_sink(std::move(sink));
}
void log_manager::add_sink(sink_ptr sink, const std::string &domain_name)
{
void log_manager::add_sink(sink_ptr sink, const std::string &domain_name) {
const auto log_domain = acquire_domain(domain_name);
log_domain->add_sink(std::move(sink));
@@ -27,44 +26,40 @@ void log_manager::clear_all_sinks() const {
default_log_domain_->clear();
}
void log_manager::clear_all_sinks(const std::string &domain_name)
{
void log_manager::clear_all_sinks(const std::string &domain_name) {
std::lock_guard lock(mutex_);
if (const auto it = log_domain_map_.find(domain_name); it != log_domain_map_.end()) {
it->second->clear();
}
}
void log_manager::clear()
{
void log_manager::clear() {
std::lock_guard lock(mutex_);
log_domain_map_.clear();
default_log_domain_->clear();
}
void log_manager::max_default_log_level(log_level max_level)
{
void log_manager::max_default_log_level(const log_level max_level) {
default_log_level_range_.max_level = max_level;
}
log_level log_manager::max_default_log_level()
{
log_level log_manager::max_default_log_level() {
return default_log_level_range_.max_level;
}
void log_manager::min_default_log_level(log_level min_level)
{
void log_manager::min_default_log_level(const log_level min_level) {
default_log_level_range_.min_level = min_level;
}
log_level log_manager::min_default_log_level()
{
log_level log_manager::min_default_log_level() {
return default_log_level_range_.min_level;
}
std::shared_ptr<log_domain> log_manager::acquire_domain(const std::string &name)
{
std::shared_ptr<log_domain> log_manager::acquire_domain(const std::string &name) {
if (name == "default") {
return default_log_domain_;
}
std::lock_guard lock(mutex_);
auto it = log_domain_map_.find(name);
if (it == log_domain_map_.end()) {
it = log_domain_map_.insert(std::make_pair(name, std::make_shared<log_domain>(name, default_log_level_range_))).first;
@@ -72,34 +67,34 @@ std::shared_ptr<log_domain> log_manager::acquire_domain(const std::string &name)
return it->second;
}
std::shared_ptr<log_domain> log_manager::find_domain(const std::string &name)
{
std::shared_ptr<log_domain> log_manager::find_domain(const std::string &name) {
if (name == "default") {
return default_log_domain_;
}
auto it = log_domain_map_.find(name);
if (it != log_domain_map_.end()) {
std::lock_guard lock(mutex_);
if (const auto it = log_domain_map_.find(name); it != log_domain_map_.end()) {
return it->second;
}
return std::shared_ptr<log_domain>();
return {};
}
void log_manager::log_default(const log_level lvl, const std::string &source, const char *message) const {
default_log_domain_->log(lvl, source, message);
}
std::shared_ptr<file_sink> create_file_sink(const std::string &logfile)
{
log_manager::log_manager() {
default_log_domain_ = std::make_shared<log_domain>("default", default_log_level_range_);
}
std::shared_ptr<file_sink> create_file_sink(const std::string &logfile) {
return std::make_shared<file_sink>(logfile);
}
std::shared_ptr<stderr_sink> create_stderr_sink()
{
std::shared_ptr<stderr_sink> create_stderr_sink() {
return std::make_shared<stderr_sink>();
}
std::shared_ptr<stdout_sink> create_stdout_sink()
{
std::shared_ptr<stdout_sink> create_stdout_sink() {
return std::make_shared<stdout_sink>();
}
@@ -128,7 +123,7 @@ void domain_min_log_level(const std::string &name, const log_level min_lvl)
void domain_max_log_level(const std::string &name, const log_level max_lvl)
{
if (const auto domain = log_manager::instance().find_domain(name)) {
domain->min_log_level(max_lvl);
domain->max_log_level(max_lvl);
}
}