Skip to content
Snippets Groups Projects

increased logging arguments

Merged increased logging arguments
devel into main
Merged Joan Vallvé Navarro requested to merge devel into main
Compare
and
1 file
+ 292
− 205
Compare changes
  • Side-by-side
  • Inline
include/core/utils/logging.h
+ 292
− 205
@@ -19,15 +19,27 @@
@@ -19,15 +19,27 @@
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
//
//--------LICENSE_END--------
//--------LICENSE_END--------
/**
// WOLF - Copyright (C) 2020,2021,2022,2023,2024
* \file logging.h
// Institut de Robòtica i Informàtica Industrial, CSIC-UPC.
*
// Authors: Joan Solà Ortega (jsola@iri.upc.edu) and
* Created on: Oct 27, 2016
// Joan Vallvé Navarro (jvallve@iri.upc.edu)
* \author: Jeremie Deray
// All rights reserved.
*/
//
 
// This file is part of WOLF: http://www.iri.upc.edu/wolf
 
// WOLF is free software: you can redistribute it and/or modify
 
// it under the terms of the GNU Lesser General Public License as published by
 
// the Free Software Foundation, either version 3 of the License, or
 
// at your option) any later version.
 
//
 
// This program is distributed in the hope that it will be useful,
 
// but WITHOUT ANY WARRANTY; without even the implied warranty of
 
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 
// GNU Lesser General Public License for more details.
 
//
 
// You should have received a copy of the GNU Lesser General Public License
 
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#ifndef WOLF_LOGGING_H_
#pragma once
#define WOLF_LOGGING_H_
// third_party include
// third_party include
#include <map>
#include <map>
@@ -42,234 +54,256 @@
@@ -42,234 +54,256 @@
// Wolf includes
// Wolf includes
#include "core/utils/singleton.h"
#include "core/utils/singleton.h"
namespace wolf {
namespace wolf
namespace internal {
{
namespace do_not_enter_where_the_wolf_lives {
namespace internal
{
 
namespace do_not_enter_where_the_wolf_lives
 
{
#define __INTERNAL_WOLF_MAIN_LOGGER_NAME_ "wolf_main_console"
#define __INTERNAL_WOLF_MAIN_LOGGER_NAME_ "wolf_main_console"
static const auto repeated_brace = std::make_tuple("{}",
static const auto repeated_brace = std::make_tuple(
"{}{}",
"{}",
"{}{}{}",
"{}{}",
"{}{}{}{}",
"{}{}{}",
"{}{}{}{}{}",
"{}{}{}{}",
"{}{}{}{}{}{}",
"{}{}{}{}{}",
"{}{}{}{}{}{}{}",
"{}{}{}{}{}{}",
"{}{}{}{}{}{}{}{}",
"{}{}{}{}{}{}{}",
"{}{}{}{}{}{}{}{}{}",
"{}{}{}{}{}{}{}{}",
"{}{}{}{}{}{}{}{}{}{}",
"{}{}{}{}{}{}{}{}{}",
"{}{}{}{}{}{}{}{}{}{}{}",
"{}{}{}{}{}{}{}{}{}{}",
"{}{}{}{}{}{}{}{}{}{}{}{}",
"{}{}{}{}{}{}{}{}{}{}{}",
"{}{}{}{}{}{}{}{}{}{}{}{}{}",
"{}{}{}{}{}{}{}{}{}{}{}{}",
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
"{}{}{}{}{}{}{}{}{}{}{}{}{}",
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}"); // up to 25 args. Should be fine
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
 
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
 
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
 
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
 
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
 
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
 
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
 
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
 
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
 
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
 
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
 
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
 
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
 
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
 
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
 
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
 
"{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}"); // up to 40 args. should be
 
// enough
class Logger
class Logger
{
{
public:
public:
 
Logger(const std::string& name);
Logger(const std::string& name);
Logger(std::string&& name);
Logger(std::string&& name);
~Logger();
~Logger();
// Not copyable/movable
 
Logger(Logger&) = delete;
 
void operator=(Logger&) = delete;
 
Logger(Logger&&) = delete;
 
void operator=(Logger&&) = delete;
// Not copyable/movable
template <typename... Args>
Logger(Logger&) = delete;
void info(Args&&... args) const;
void operator=(Logger&) = delete;
Logger(Logger&&) = delete;
void operator=(Logger&&) = delete;
template<typename... Args>
template <typename... Args>
void info(Args&&... args) const;
void warn(Args&&... args) const;
template<typename... Args>
template <typename... Args>
void warn(Args&&... args) const;
void error(Args&&... args) const;
template<typename... Args>
template <typename... Args>
void error(Args&&... args) const;
void debug(Args&&... args) const;
template<typename... Args>
template <typename... Args>
void debug(Args&&... args) const;
void trace(Args&&... args) const;
template<typename... Args>
bool set_async_queue(const std::size_t q_size);
void trace(Args&&... args) const;
bool set_async_queue(const std::size_t q_size);
void set_pattern(const std::string& p);
void set_pattern(const std::string& p);
protected:
 
const std::string log_name_;
protected:
std::shared_ptr<spdlog::logger> console_;
const std::string log_name_;
std::shared_ptr<spdlog::logger> console_;
};
};
inline Logger::Logger(const std::string& name) :
inline Logger::Logger(const std::string& name) : log_name_(name)
log_name_(name)
{
{
// Create main logger
// Create main logger
console_ = spdlog::stdout_color_mt(log_name_);
console_ = spdlog::stdout_color_mt(log_name_);
#ifdef _WOLF_TRACE
#ifdef _WOLF_TRACE
console_->set_level(spdlog::level::trace);
console_->set_level(spdlog::level::trace);
#endif
#endif
// Enable asynchronous logging
// Enable asynchronous logging
// Queue size must be a power of 2
// Queue size must be a power of 2
spdlog::init_thread_pool(4096, 1);
spdlog::init_thread_pool(4096, 1);
if (log_name_ == __INTERNAL_WOLF_MAIN_LOGGER_NAME_)
if (log_name_ == __INTERNAL_WOLF_MAIN_LOGGER_NAME_)
// Logging pattern is :
// [thread num][hour:minutes:seconds.nanoseconds][log type] #log-content
// [thread num][hour:minutes:seconds.nanoseconds][log type] #log-content
// set_pattern("[%t][%H:%M:%S.%F][%l] %v");
//set_pattern("[%t][%H:%M:%S.%F][%l] %v");
// [log type][MM/DD/YY - hour:minutes:seconds.nanoseconds] #log-content
// [log type][MM/DD/YY - hour:minutes:seconds.nanoseconds] #log-content
// set_pattern("[%l][%x - %H:%M:%S.%F] %v");
// set_pattern("[%l][%x - %H:%M:%S.%F] %v");
set_pattern("%^[%l][%H:%M:%S] %v%$");
else
// [log type][hour:minutes:seconds] #log-content
// Logging pattern is :
// set_pattern("%^[%l][%H:%M:%S] %v%$");
// [logger name][thread num][hour:minutes:seconds.nanoseconds][log type] #log-content
//set_pattern("[" + log_name_ + "]" +"[%t][%H:%M:%S.%F][%l] %v");
// [log type]#log-content
// [log type][MM/DD/YY - hour:minutes:seconds.nanoseconds][logger name] #log-content
set_pattern("%^[%l]%v%$");
set_pattern("%^[%l][%x - %H:%M:%S.%F][" + log_name_ + "] %v%$");
else
 
// [logger name][thread num][hour:minutes:seconds.nanoseconds][log type] #log-content
 
// set_pattern("[" + log_name_ + "]" +"[%t][%H:%M:%S.%F][%l] %v");
 
 
// [log type][MM/DD/YY - hour:minutes:seconds.nanoseconds][logger name] #log-content
 
set_pattern("%^[%l][%x - %H:%M:%S.%F][" + log_name_ + "] %v%$");
}
}
inline Logger::Logger(std::string&& name) :
inline Logger::Logger(std::string&& name) : log_name_(std::forward<std::string>(name))
log_name_(std::forward<std::string>(name))
{
{
// Create main logger
// Create main logger
console_ = spdlog::stdout_color_mt(log_name_);
console_ = spdlog::stdout_color_mt(log_name_);
#ifdef _WOLF_TRACE
#ifdef _WOLF_TRACE
console_->set_level(spdlog::level::trace);
console_->set_level(spdlog::level::trace);
#endif
#endif
// Enable asynchronous logging
// Enable asynchronous logging
// Queue size must be a power of 2
// Queue size must be a power of 2
spdlog::init_thread_pool(4096, 1);
spdlog::init_thread_pool(4096, 1);
if (log_name_ == __INTERNAL_WOLF_MAIN_LOGGER_NAME_)
if (log_name_ == __INTERNAL_WOLF_MAIN_LOGGER_NAME_)
// Logging pattern is :
// [thread num][hour:minutes:seconds.nanoseconds][log type] #log-content
// [thread num][hour:minutes:seconds.nanoseconds][log type] #log-content
// set_pattern("[%t][%H:%M:%S.%F][%l] %v");
//set_pattern("[%t][%H:%M:%S.%F][%l] %v");
// [log type][MM/DD/YY - hour:minutes:seconds.nanoseconds] #log-content
// [log type][MM/DD/YY - hour:minutes:seconds.nanoseconds] #log-content
// set_pattern("[%l][%x - %H:%M:%S.%F] %v");
// set_pattern("[%l][%x - %H:%M:%S.%F] %v");
set_pattern("%^[%l][%H:%M:%S] %v%$");
else
// [log type][hour:minutes:seconds] #log-content
// Logging pattern is :
// set_pattern("%^[%l][%H:%M:%S] %v%$");
// [logger name][thread num][hour:minutes:seconds.nanoseconds][log type] #log-content
//set_pattern("[" + log_name_ + "]" +"[%t][%H:%M:%S.%F][%l] %v");
// [log type][source_file line][function] #log-content
// [log type][MM/DD/YY - hour:minutes:seconds.nanoseconds][logger name] #log-content
set_pattern("%^[%l]%v%$");
set_pattern("%^[%l][%x - %H:%M:%S.%F][" + log_name_ + "] %v%$");
else
 
// [logger name][thread num][hour:minutes:seconds.nanoseconds][log type] #log-content
 
// set_pattern("[" + log_name_ + "]" +"[%t][%H:%M:%S.%F][%l] %v");
 
 
// [log type][MM/DD/YY - hour:minutes:seconds.nanoseconds][logger name] #log-content
 
set_pattern("%^[%l][%x - %H:%M:%S.%F][" + log_name_ + "] %v%$");
}
}
inline Logger::~Logger()
inline Logger::~Logger()
{
{
spdlog::drop(log_name_);
spdlog::drop(log_name_);
}
}
template<typename... Args>
template <typename... Args>
void Logger::info(Args&&... args) const
void Logger::info(Args&&... args) const
{
{
console_->info(std::get<sizeof...(args)-1>(repeated_brace), std::forward<Args>(args)...);
console_->info(std::get<sizeof...(args) - 1>(repeated_brace), std::forward<Args>(args)...);
}
}
template<typename... Args>
template <typename... Args>
void Logger::warn(Args&&... args) const
void Logger::warn(Args&&... args) const
{
{
console_->warn(std::get<sizeof...(args)-1>(repeated_brace), std::forward<Args>(args)...);
console_->warn(std::get<sizeof...(args) - 1>(repeated_brace), std::forward<Args>(args)...);
}
}
template<typename... Args>
template <typename... Args>
void Logger::error(Args&&... args) const
void Logger::error(Args&&... args) const
{
{
console_->error(std::get<sizeof...(args)-1>(repeated_brace), std::forward<Args>(args)...);
console_->error(std::get<sizeof...(args) - 1>(repeated_brace), std::forward<Args>(args)...);
}
}
template<typename... Args>
template <typename... Args>
void Logger::debug(Args&&... args) const
void Logger::debug(Args&&... args) const
{
{
console_->debug(std::get<sizeof...(args)-1>(repeated_brace), std::forward<Args>(args)...);
console_->debug(std::get<sizeof...(args) - 1>(repeated_brace), std::forward<Args>(args)...);
}
}
template<typename... Args>
template <typename... Args>
void Logger::trace(Args&&... args) const
void Logger::trace(Args&&... args) const
{
{
console_->trace(std::get<sizeof...(args)-1>(repeated_brace), std::forward<Args>(args)...);
console_->trace(std::get<sizeof...(args) - 1>(repeated_brace), std::forward<Args>(args)...);
}
}
inline bool Logger::set_async_queue(const std::size_t q_size)
inline bool Logger::set_async_queue(const std::size_t q_size)
{
{
bool p2 = q_size%2 == 0;
bool p2 = q_size % 2 == 0;
if (p2) spdlog::init_thread_pool(q_size, 1);
return q_size;
if (p2) spdlog::init_thread_pool(q_size, 1);
 
 
return q_size;
}
}
inline void Logger::set_pattern(const std::string& p)
inline void Logger::set_pattern(const std::string& p)
{
{
console_->set_pattern(p);
console_->set_pattern(p);
}
}
using LoggerPtr = std::unique_ptr<Logger>;
using LoggerPtr = std::unique_ptr<Logger>;
class LoggerManager
class LoggerManager
{
{
public:
public:
LoggerManager() = default;
LoggerManager() = default;
~LoggerManager() = default;
~LoggerManager() = default;
bool exists(const std::string& name) const
bool exists(const std::string& name) const
{
{
std::lock_guard<std::mutex> lock(mut_);
std::lock_guard<std::mutex> lock(mut_);
return existsImpl(name);
return existsImpl(name);
}
}
const Logger& getLogger(const std::string& name) /*const*/
const Logger& getLogger(const std::string& name) /*const*/
{
{
std::lock_guard<std::mutex> lock(mut_);
std::lock_guard<std::mutex> lock(mut_);
if (!existsImpl(name)) addLogger(name);
if (!existsImpl(name)) addLogger(name);
return *(logger_map_.at(name));
return *(logger_map_.at(name));
}
}
protected:
protected:
mutable std::mutex mut_;
mutable std::mutex mut_;
std::map<const std::string, const LoggerPtr> logger_map_;
std::map<const std::string, const LoggerPtr> logger_map_;
bool addLogger(const std::string& name)
{
bool addLogger(const std::string& name)
/// @note would be easier with cpp17 map.try_emplace...
{
const bool created =
/// @note would be easier with cpp17 map.try_emplace...
existsImpl(name) ? false : logger_map_.emplace(name, std::make_unique<Logger>(name)).second;
const bool created = existsImpl(name) ?
return created;
false :
}
logger_map_.emplace(name, std::make_unique<Logger>(name)).second;
return created;
bool existsImpl(const std::string& name) const
}
{
return (logger_map_.find(name) != logger_map_.end());
bool existsImpl(const std::string& name) const
}
{
return (logger_map_.find(name) != logger_map_.end());
//return (spdlog::get(name) != nullptr);
}
};
};
} /* namespace do_not_enter_where_the_wolf_lives */
} /* namespace do_not_enter_where_the_wolf_lives */
using WolfLogger = Singleton<do_not_enter_where_the_wolf_lives::Logger>;
using WolfLogger = Singleton<do_not_enter_where_the_wolf_lives::Logger>;
using WolfLoggerManager = Singleton<do_not_enter_where_the_wolf_lives::LoggerManager>;
using WolfLoggerManager = Singleton<do_not_enter_where_the_wolf_lives::LoggerManager>;
} /* namespace internal */
} /* namespace internal */
@@ -280,66 +314,119 @@ using WolfLoggerManager = Singleton<do_not_enter_where_the_wolf_lives::LoggerMan
@@ -280,66 +314,119 @@ using WolfLoggerManager = Singleton<do_not_enter_where_the_wolf_lives::LoggerMan
/// @brief NAMED LOGGING
/// @brief NAMED LOGGING
#define WOLF_ASYNC_QUEUE_LOG_NAMED(name, ...) wolf::internal::WolfLoggerManager::get().getLogger(name).set_async_queue(x);
#define WOLF_ASYNC_QUEUE_LOG_NAMED(name, ...) \
wolf::internal::WolfLoggerManager::get().getLogger(name).set_async_queue(x);
#define WOLF_INFO_NAMED(name, ...) wolf::internal::WolfLoggerManager::get().getLogger(name).info(__VA_ARGS__);
#define WOLF_INFO_NAMED_COND(name, cond, ...) if (cond) WOLF_INFO_NAMED(name, __VA_ARGS__);
#define WOLF_INFO_NAMED(name, ...) \
{ \
#define WOLF_WARN_NAMED(name, ...) wolf::internal::WolfLoggerManager::get().getLogger(name).warn(__VA_ARGS__);
char this_file[] = __FILE__; \
#define WOLF_WARN_NAMED_COND(name, cond, ...) if (cond) WOLF_WARN_NAMED(name, __VA_ARGS__);
wolf::internal::WolfLoggerManager::get().getLogger(name).info( \
"[", basename(this_file), " L", __LINE__, "] ", __FUNCTION__, ": ", __VA_ARGS__); \
#define WOLF_ERROR_NAMED(name, ...) wolf::internal::WolfLoggerManager::get().getLogger(name).error(__VA_ARGS__);
}
#define WOLF_ERROR_NAMED_COND(name, cond, ...) if (cond) WOLF_ERROR_NAMED(name, __VA_ARGS__);
#define WOLF_INFO_NAMED_COND(name, cond, ...) \
 
if (cond) WOLF_INFO_NAMED(name, __VA_ARGS__);
 
 
#define WOLF_WARN_NAMED(name, ...) \
 
{ \
 
char this_file[] = __FILE__; \
 
wolf::internal::WolfLoggerManager::get().getLogger(name).warn( \
 
"[", basename(this_file), " L", __LINE__, "] ", __FUNCTION__, ": ", __VA_ARGS__); \
 
}
 
#define WOLF_WARN_NAMED_COND(name, cond, ...) \
 
if (cond) WOLF_WARN_NAMED(name, __VA_ARGS__);
 
 
#define WOLF_ERROR_NAMED(name, ...) \
 
{ \
 
char this_file[] = __FILE__; \
 
wolf::internal::WolfLoggerManager::get().getLogger(name).error( \
 
"[", basename(this_file), " L", __LINE__, "] ", __FUNCTION__, ": ", __VA_ARGS__); \
 
}
 
#define WOLF_ERROR_NAMED_COND(name, cond, ...) \
 
if (cond) WOLF_ERROR_NAMED(name, __VA_ARGS__);
#ifdef _WOLF_DEBUG
#ifdef _WOLF_DEBUG
#define WOLF_DEBUG_NAMED(name, ...) wolf::internal::WolfLoggerManager::get().getLogger(name).debug(__VA_ARGS__);
#define WOLF_DEBUG_NAMED(name, ...) \
#define WOLF_DEBUG_NAMED_COND(name, cond, ...) if (cond) WOLF_DEBUG_NAMED(name, __VA_ARGS__);
{ \
 
char this_file[] = __FILE__; \
 
wolf::internal::WolfLoggerManager::get().getLogger(name).debug( \
 
"[", basename(this_file), " L", __LINE__, "] ", __FUNCTION__, ": ", __VA_ARGS__); \
 
}
 
#define WOLF_DEBUG_NAMED_COND(name, cond, ...) \
 
if (cond) WOLF_DEBUG_NAMED(name, __VA_ARGS__);
#else
#else
#define WOLF_DEBUG_NAMED(name, ...)
#define WOLF_DEBUG_NAMED(name, ...)
#define WOLF_DEBUG_NAMED_COND(cond, name, ...)
#define WOLF_DEBUG_NAMED_COND(cond, name, ...)
#endif
#endif
#ifdef _WOLF_TRACE
#ifdef _WOLF_TRACE
#define WOLF_TRACE_NAMED(name, ...) \
#define WOLF_TRACE_NAMED(name, ...) \
{char this_file[] = __FILE__;\
{ \
wolf::internal::WolfLoggerManager::get().getLogger(name).trace("[", basename(this_file), " L", __LINE__, \
char this_file[] = __FILE__; \
" : ", __FUNCTION__, "] ", __VA_ARGS__);}
wolf::internal::WolfLoggerManager::get().getLogger(name).trace( \
#define WOLF_TRACE_NAMED_COND(name, cond, ...) if (cond) WOLF_TRACE_NAMED_COND(name, __VA_ARGS__);
"[", basename(this_file), " L", __LINE__, "] ", __FUNCTION__, ": ", __VA_ARGS__); \
 
}
 
#define WOLF_TRACE_NAMED_COND(name, cond, ...) \
 
if (cond) WOLF_TRACE_NAMED_COND(name, __VA_ARGS__);
#else
#else
#define WOLF_TRACE_NAMED(...)
#define WOLF_TRACE_NAMED(...)
#define WOLF_TRACE_NAMED_cond(name, cond, ...)
#define WOLF_TRACE_NAMED_cond(name, cond, ...)
#endif
#endif
/// @brief MAIN LOGGING
/// @brief MAIN LOGGING
#define WOLF_ASYNC_QUEUE_LOG(x) wolf::internal::WolfLogger::get(__INTERNAL_WOLF_MAIN_LOGGER_NAME_).set_async_queue(x);
#define WOLF_ASYNC_QUEUE_LOG(x) wolf::internal::WolfLogger::get(__INTERNAL_WOLF_MAIN_LOGGER_NAME_).set_async_queue(x);
#define WOLF_INFO(...) wolf::internal::WolfLogger::get(__INTERNAL_WOLF_MAIN_LOGGER_NAME_).info(__VA_ARGS__);
#define WOLF_INFO(...) \
#define WOLF_INFO_COND(cond, ...) if (cond) WOLF_INFO(__VA_ARGS__);
{ \
char this_file[] = __FILE__; \
#define WOLF_WARN(...) wolf::internal::WolfLogger::get(__INTERNAL_WOLF_MAIN_LOGGER_NAME_).warn(__VA_ARGS__);
wolf::internal::WolfLogger::get(__INTERNAL_WOLF_MAIN_LOGGER_NAME_) \
#define WOLF_WARN_COND(cond, ...) if (cond) WOLF_WARN(__VA_ARGS__);
.info("[", basename(this_file), " L", __LINE__, "] ", __FUNCTION__, ": ", __VA_ARGS__); \
}
#define WOLF_ERROR(...) wolf::internal::WolfLogger::get(__INTERNAL_WOLF_MAIN_LOGGER_NAME_).error(__VA_ARGS__);
#define WOLF_INFO_COND(cond, ...) \
#define WOLF_ERROR_COND(cond, ...) if (cond) WOLF_ERROR(__VA_ARGS__);
if (cond) WOLF_INFO(__VA_ARGS__);
 
 
#define WOLF_WARN(...) \
 
{ \
 
char this_file[] = __FILE__; \
 
wolf::internal::WolfLogger::get(__INTERNAL_WOLF_MAIN_LOGGER_NAME_) \
 
.warn("[", basename(this_file), " L", __LINE__, "] ", __FUNCTION__, ": ", __VA_ARGS__); \
 
}
 
#define WOLF_WARN_COND(cond, ...) \
 
if (cond) WOLF_WARN(__VA_ARGS__);
 
 
#define WOLF_ERROR(...) \
 
{ \
 
char this_file[] = __FILE__; \
 
wolf::internal::WolfLogger::get(__INTERNAL_WOLF_MAIN_LOGGER_NAME_) \
 
.error("[", basename(this_file), " L", __LINE__, "] ", __FUNCTION__, ": ", __VA_ARGS__); \
 
}
 
#define WOLF_ERROR_COND(cond, ...) \
 
if (cond) WOLF_ERROR(__VA_ARGS__);
#ifdef _WOLF_DEBUG
#ifdef _WOLF_DEBUG
#define WOLF_DEBUG(...) wolf::internal::WolfLogger::get(__INTERNAL_WOLF_MAIN_LOGGER_NAME_).debug(__VA_ARGS__);
#define WOLF_DEBUG(...) \
#define WOLF_DEBUG_COND(cond, ...) if (cond) WOLF_DEBUG(__VA_ARGS__);
{ \
 
char this_file[] = __FILE__; \
 
wolf::internal::WolfLogger::get(__INTERNAL_WOLF_MAIN_LOGGER_NAME_) \
 
.debug("[", basename(this_file), " L", __LINE__, "] ", __FUNCTION__, ": ", __VA_ARGS__); \
 
}
 
#define WOLF_DEBUG_COND(cond, ...) \
 
if (cond) WOLF_DEBUG(__VA_ARGS__);
#else
#else
#define WOLF_DEBUG(...)
#define WOLF_DEBUG(...)
#define WOLF_DEBUG_COND(cond, ...)
#define WOLF_DEBUG_COND(cond, ...)
#endif
#endif
#ifdef _WOLF_TRACE
#ifdef _WOLF_TRACE
#define WOLF_TRACE(...) \
#define WOLF_TRACE(...) \
{char this_file[] = __FILE__;\
{ \
wolf::internal::WolfLogger::get(__INTERNAL_WOLF_MAIN_LOGGER_NAME_).trace("[", basename(this_file), " L", __LINE__, \
char this_file[] = __FILE__; \
" : ", __FUNCTION__, "] ", __VA_ARGS__);}
wolf::internal::WolfLogger::get(__INTERNAL_WOLF_MAIN_LOGGER_NAME_) \
#define WOLF_TRACE_COND(cond, ...) if (cond) WOLF_TRACE(__VA_ARGS__);
.trace("[", basename(this_file), " L", __LINE__, "] ", __FUNCTION__, ": ", __VA_ARGS__); \
 
}
 
#define WOLF_TRACE_COND(cond, ...) \
 
if (cond) WOLF_TRACE(__VA_ARGS__);
#else
#else
#define WOLF_TRACE(...)
#define WOLF_TRACE(...)
#define WOLF_TRACE_COND(cond, ...)
#define WOLF_TRACE_COND(cond, ...)
#endif
#endif
#endif /* WOLF_LOGGING_H_ */