I am a member of a university team that designs a nanosatellite.
We decided to implement our own (lighter) logging library to use, instead of, for example, that of Google. glog, spdlog, plog and Boost::Log.
- The concept of different levels of logging is introduced, allowing log messages to be divided into subcategories based on their severity and eventuality.
- In addition, a "global log level" can be defined.
Anything less serious than the severity defined as global journal level do not to be connected.
Due to obvious restrictions, it is imperative that log calls below the global log level be optimized at compile time.
The first attempt looked like this (single header file):
log levels:
// We can set the global log level by defining one of these
#if defined LOGLEVEL_TRACE
#define LOGLEVEL Logger::trace
#elif defined LOGLEVEL_DEBUG
#define LOGLEVEL Logger::debug
#elif defined LOGLEVEL_INFO
(...)
#else
#define LOGLEVEL Logger::disabled
#endif
the levels themselves are enum members:
enum LogLevel {
trace = 32, // Very detailed information, useful for tracking the individual steps of an operation
debug = 64, // General debugging information
info = 96, // Noteworthy or periodical events
(...)
};
A operator<< overload for better readability:
template
Logger::LogEntry& operator<<(Logger::LogEntry& entry, const T value) {
etl::to_string(value, entry.message, entry.format, true);
return entry;
}
And the macroconstexpr ritual to make the compiler do what we want:
#define LOG(level)
if (Logger::isLogged(level))
if (Logger::LogEntry entry(level); true)
entry
// (...)
static constexpr bool isLogged(LogLevelType level) {
return static_cast(LOGLEVEL) <= level;
}
There were a lot of problems with this code (see MR discussion for more).
- An operator of call
enum LogLevelhas been added to return a newstatic LogEntry. - It is
inlineto forceconstspread to-O1. - Two
LogEntryenumshas been created. - The second is a
nopwith allinline. if constexprthe syntax has been added.
and more (see here and below for justification.)
It's the (hashed) state of the code currently:
#include
#include
#define LOGLEVEL_EMERGENCY
#if defined LOGLEVEL_TRACE
#define LOGLEVEL Logger::trace
#elif defined LOGLEVEL_DEBUG
#define LOGLEVEL Logger::debug
#elif defined LOGLEVEL_INFO
#define LOGLEVEL Logger::info
#elif defined LOGLEVEL_NOTICE
#define LOGLEVEL Logger::notice
#elif defined LOGLEVEL_WARNING
#define LOGLEVEL Logger::warning
#elif defined LOGLEVEL_ERROR
#define LOGLEVEL Logger::error
#elif defined LOGLEVEL_EMERGENCY
#define LOGLEVEL Logger::emergency
#else
#define LOGLEVEL Logger::disabled
#endif
#define LOG_TRACE (LOG())
#define LOG_DEBUG (LOG())
#define LOG_INFO (LOG())
#define LOG_NOTICE (LOG())
#define LOG_WARNING (LOG())
#define LOG_ERROR (LOG())
#define LOG_EMERGENCY (LOG())
class Logger {
public:
Logger() = delete;
typedef uint8_t LogLevelType;
enum LogLevel : LogLevelType {
trace = 32,
debug = 64,
info = 96,
notice = 128,
warning = 160,
error = 192,
emergency = 254,
disabled = 255,
};
enum class NoLogEntry {};
struct LogEntry {
std::string message = "";
LogLevel level;
explicit LogEntry(LogLevel level);
~LogEntry();
LogEntry(LogEntry const&) = delete;
template
Logger::LogEntry& operator<<(const T value) noexcept {
message.append(value);
return *this;
}
Logger::LogEntry& operator<<(const std::string& value);
};
static constexpr bool isLogged(LogLevelType level) {
return static_cast(LOGLEVEL) <= level;
}
static void log(LogLevel level, std::string & message);
};
template
constexpr inline auto LOG() {
if constexpr (Logger::isLogged(level)) {
return Logger::LogEntry(level);
} else {
return Logger::NoLogEntry();
}
};
template
((maybe_unused)) constexpr Logger::NoLogEntry operator<<(const Logger::NoLogEntry noLogEntry, T value) {
return noLogEntry;
}
int main() {
LOG_NOTICE << "I am getting optimized away!";
LOG_EMERGENCY << "I am not getting optimized away, and rightfully so";
return 0;
}
As you can see in the compiler explorer, for example, LOG_NOTICE becomes optimized far from -O1.
Do you have any suggestions?
