mirror of
https://github.com/FairRootGroup/FairLogger.git
synced 2025-10-13 08:41:12 +00:00
392 lines
11 KiB
C++
392 lines
11 KiB
C++
/********************************************************************************
|
|
* Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH *
|
|
* *
|
|
* This software is distributed under the terms of the *
|
|
* GNU Lesser General Public Licence (LGPL) version 3, *
|
|
* copied verbatim in the file "LICENSE" *
|
|
********************************************************************************/
|
|
#ifndef FAIR_LOGGER_H
|
|
#define FAIR_LOGGER_H
|
|
|
|
#ifdef DEBUG
|
|
#undef DEBUG
|
|
#warning "The symbol 'DEBUG' is used in FairRoot Logger. undefining..."
|
|
#endif
|
|
|
|
#include <sstream>
|
|
#include <fstream>
|
|
#include <string>
|
|
#include <unordered_map>
|
|
#include <functional>
|
|
#include <map>
|
|
#include <chrono>
|
|
#include <mutex>
|
|
#include <utility> // pair
|
|
#include <time.h> // time_t
|
|
#include <array>
|
|
#include <type_traits>
|
|
#include <cassert>
|
|
#include <algorithm>
|
|
|
|
#ifdef FAIRLOGGER_USE_BOOST_PRETTY_FUNCTION
|
|
#include <boost/current_function.hpp>
|
|
#endif
|
|
|
|
namespace fair
|
|
{
|
|
|
|
enum class Severity : int
|
|
{
|
|
nolog,
|
|
fatal,
|
|
error,
|
|
warn,
|
|
state,
|
|
info,
|
|
debug,
|
|
debug1,
|
|
debug2,
|
|
debug3,
|
|
debug4,
|
|
trace,
|
|
// backwards-compatibility:
|
|
NOLOG = nolog,
|
|
FATAL = fatal,
|
|
ERROR = error,
|
|
WARN = warn,
|
|
warning = warn,
|
|
WARNING = warn,
|
|
STATE = state,
|
|
INFO = info,
|
|
DEBUG = debug,
|
|
DEBUG1 = debug1,
|
|
DEBUG2 = debug2,
|
|
DEBUG3 = debug3,
|
|
DEBUG4 = debug4,
|
|
TRACE = trace
|
|
};
|
|
|
|
// verbosity levels:
|
|
// verylow: message
|
|
// low: [severity] message
|
|
// medium: [HH:MM:SS][severity] message
|
|
// high: [process name][HH:MM:SS:µS][severity] message
|
|
// veryhigh: [process name][HH:MM:SS:µS][severity][file:line:function] message
|
|
enum class Verbosity : int
|
|
{
|
|
verylow,
|
|
low,
|
|
medium,
|
|
high,
|
|
veryhigh,
|
|
// backwards-compatibility:
|
|
VERYLOW = verylow,
|
|
LOW = low,
|
|
MEDIUM = medium,
|
|
HIGH = high,
|
|
VERYHIGH = veryhigh,
|
|
// extra slots for user-defined verbosities:
|
|
user1,
|
|
user2,
|
|
user3,
|
|
user4,
|
|
};
|
|
|
|
struct VerbositySpec
|
|
{
|
|
enum class Info : int
|
|
{
|
|
__empty__ = 0, // used to initialize order array
|
|
process_name, // [process name]
|
|
timestamp_s, // [HH:MM:SS]
|
|
timestamp_us, // [HH:MM:SS:µS]
|
|
severity, // [severity]
|
|
file, // [file]
|
|
file_line, // [file:line]
|
|
file_line_function, // [file:line:function]
|
|
__max__ // needs to be last in enum
|
|
};
|
|
|
|
std::array<Info, static_cast<int>(Info::__max__)> fOrder;
|
|
|
|
VerbositySpec() : fOrder({Info::__empty__}) {}
|
|
|
|
template<typename ... Ts>
|
|
static VerbositySpec Make(Ts ... options)
|
|
{
|
|
static_assert(sizeof...(Ts) < static_cast<int>(Info::__max__),
|
|
"Maximum number of VerbositySpec::Info parameters exceeded.");
|
|
|
|
return Make(VerbositySpec(), 0, options...);
|
|
}
|
|
|
|
private:
|
|
template<typename T, typename ... Ts>
|
|
static VerbositySpec Make(VerbositySpec spec, int i, T option, Ts ... options)
|
|
{
|
|
static_assert(std::is_same<T, Info>::value,
|
|
"Only arguments of type VerbositySpec::Info are allowed.");
|
|
|
|
assert(option > Info::__empty__);
|
|
assert(option < Info::__max__);
|
|
|
|
if (std::find(spec.fOrder.begin(), spec.fOrder.end(), option) == spec.fOrder.end()) {
|
|
spec.fOrder[i] = option;
|
|
++i;
|
|
}
|
|
|
|
return Make(spec, i, options ...);
|
|
}
|
|
|
|
static VerbositySpec Make(VerbositySpec spec, int)
|
|
{
|
|
return spec;
|
|
}
|
|
};
|
|
|
|
// non-std exception to avoid undesirable catches - fatal should exit in a way we want.
|
|
class FatalException
|
|
{
|
|
public:
|
|
FatalException()
|
|
: fWhat()
|
|
{}
|
|
|
|
FatalException(std::string what)
|
|
: fWhat(what)
|
|
{}
|
|
|
|
std::string What()
|
|
{
|
|
return fWhat;
|
|
}
|
|
|
|
private:
|
|
std::string fWhat;
|
|
};
|
|
|
|
struct LogMetaData
|
|
{
|
|
std::time_t timestamp;
|
|
std::chrono::microseconds us;
|
|
std::string process_name;
|
|
std::string file;
|
|
std::string line;
|
|
std::string func;
|
|
std::string severity_name;
|
|
fair::Severity severity;
|
|
};
|
|
|
|
class Logger
|
|
{
|
|
public:
|
|
Logger(Severity severity, const std::string& file, const std::string& line, const std::string& func);
|
|
|
|
enum class Color : int
|
|
{
|
|
bold = 1,
|
|
dim = 2,
|
|
underline = 4,
|
|
blink = 5,
|
|
reverse = 7,
|
|
hidden = 8,
|
|
|
|
fgDefault = 39,
|
|
fgBlack = 30,
|
|
fgRed = 31,
|
|
fgGreen = 32,
|
|
fgYellow = 33,
|
|
fgBlue = 34,
|
|
fgMagenta = 35,
|
|
fgCyan = 36,
|
|
fgLightGray = 37,
|
|
fgDarkGray = 90,
|
|
fgLightRed = 91,
|
|
fgLightGreen = 92,
|
|
fgLightYellow = 93,
|
|
fgLightBlue = 94,
|
|
fgLightMagenta = 95,
|
|
fgLightCyan = 96,
|
|
fgWhite = 97,
|
|
|
|
bgDefault = 49,
|
|
bgBlack = 40,
|
|
bgRed = 41,
|
|
bgGreen = 42,
|
|
bgYellow = 43,
|
|
bgBlue = 44,
|
|
bgMagenta = 45,
|
|
bgCyan = 46,
|
|
bgLightGray = 47,
|
|
bgDarkGray = 100,
|
|
bgLightRed = 101,
|
|
bgLightGreen = 102,
|
|
bgLightYellow = 103,
|
|
bgLightBlue = 104,
|
|
bgLightMagenta = 105,
|
|
bgLightCyan = 106,
|
|
bgWhite = 107
|
|
};
|
|
|
|
static std::string startColor(Color color)
|
|
{
|
|
std::ostringstream os;
|
|
os << "\033[01;" << static_cast<int>(color) << "m";
|
|
return os.str();
|
|
}
|
|
|
|
static std::string endColor()
|
|
{
|
|
return "\033[0m";
|
|
}
|
|
|
|
class ColorOut
|
|
{
|
|
public:
|
|
ColorOut(Color color, const std::string& str)
|
|
: fColor(color)
|
|
, fStr(str)
|
|
{}
|
|
|
|
friend std::ostream& operator<<(std::ostream& os, const ColorOut& w)
|
|
{
|
|
return os << "\033[01;" << static_cast<int>(w.fColor) << "m" << w.fStr << "\033[0m";
|
|
}
|
|
|
|
private:
|
|
Color fColor;
|
|
const std::string& fStr;
|
|
};
|
|
|
|
static void SetConsoleSeverity(const Severity severity);
|
|
static void SetConsoleSeverity(const std::string& severityStr);
|
|
static Severity GetConsoleSeverity();
|
|
|
|
static void SetFileSeverity(const Severity severity);
|
|
static void SetFileSeverity(const std::string& severityStr);
|
|
|
|
static void SetCustomSeverity(const std::string& key, const Severity severity);
|
|
static void SetCustomSeverity(const std::string& key, const std::string& severityStr);
|
|
|
|
static void CycleConsoleSeverityUp();
|
|
static void CycleConsoleSeverityDown();
|
|
static void CycleVerbosityUp();
|
|
static void CycleVerbosityDown();
|
|
|
|
static bool Logging(const Severity severity);
|
|
static bool Logging(const std::string& severityStr);
|
|
|
|
static void SetVerbosity(const Verbosity verbosity);
|
|
static void SetVerbosity(const std::string& verbosityStr);
|
|
static Verbosity GetVerbosity();
|
|
static void DefineVerbosity(const Verbosity, VerbositySpec);
|
|
static void DefineVerbosity(const std::string& verbosityStr, VerbositySpec);
|
|
|
|
static void SetConsoleColor(const bool colored = true);
|
|
|
|
static void InitFileSink(const Severity severity, const std::string& filename, bool customizeName = true);
|
|
static void InitFileSink(const std::string& severityStr, const std::string& filename, bool customizeName = true);
|
|
|
|
static void RemoveFileSink();
|
|
|
|
static std::string SeverityName(Severity);
|
|
static std::string VerbosityName(Verbosity);
|
|
|
|
static void OnFatal(std::function<void()> func);
|
|
|
|
static void AddCustomSink(const std::string& key, Severity severity, std::function<void(const std::string& content, const LogMetaData& metadata)> sink);
|
|
static void AddCustomSink(const std::string& key, const std::string& severityStr, std::function<void(const std::string& content, const LogMetaData& metadata)> sink);
|
|
static void RemoveCustomSink(const std::string& key);
|
|
|
|
Logger& Log();
|
|
|
|
template<typename T>
|
|
Logger& operator<<(const T& t)
|
|
{
|
|
fContent << t;
|
|
return *this;
|
|
}
|
|
|
|
// overload for char* to make sure it is not nullptr
|
|
Logger& operator<<(const char* cptr)
|
|
{
|
|
if (cptr != nullptr) {
|
|
fContent << cptr;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
// overload for char* to make sure it is not nullptr
|
|
Logger& operator<<(char* cptr)
|
|
{
|
|
if (cptr != nullptr) {
|
|
fContent << cptr;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
Logger& operator<<(std::ios_base& (*manip) (std::ios_base&));
|
|
Logger& operator<<(std::ostream& (*manip) (std::ostream&));
|
|
|
|
static const std::unordered_map<std::string, Verbosity> fVerbosityMap;
|
|
static const std::unordered_map<std::string, Severity> fSeverityMap;
|
|
static const std::array<std::string, 12> fSeverityNames;
|
|
static const std::array<std::string, 5> fVerbosityNames;
|
|
|
|
virtual ~Logger() noexcept(false);
|
|
|
|
private:
|
|
LogMetaData fMetaData;
|
|
|
|
std::ostringstream fContent;
|
|
std::ostringstream fColorOut;
|
|
std::ostringstream fBWOut;
|
|
static const std::string fProcessName;
|
|
static bool fColored;
|
|
static std::fstream fFileStream;
|
|
|
|
static Severity fConsoleSeverity;
|
|
static Severity fFileSeverity;
|
|
static Severity fMinSeverity;
|
|
|
|
static Verbosity fVerbosity;
|
|
|
|
static std::function<void()> fFatalCallback;
|
|
static std::unordered_map<std::string, std::pair<Severity, std::function<void(const std::string& content, const LogMetaData& metadata)>>> fCustomSinks;
|
|
static std::mutex fMtx;
|
|
|
|
bool LoggingToConsole() const;
|
|
bool LoggingToFile() const;
|
|
bool LoggingCustom(const Severity) const;
|
|
|
|
static void UpdateMinSeverity();
|
|
|
|
static std::map<Verbosity, VerbositySpec> fVerbosities;
|
|
};
|
|
|
|
} // namespace fair
|
|
|
|
#define IMP_CONVERTTOSTRING(s) # s
|
|
#define CONVERTTOSTRING(s) IMP_CONVERTTOSTRING(s)
|
|
|
|
#ifdef FAIRLOGGER_USE_BOOST_PRETTY_FUNCTION
|
|
#define LOG(severity) \
|
|
for (bool fairLOggerunLikelyvariable = false; fair::Logger::Logging(fair::Severity::severity) && !fairLOggerunLikelyvariable; fairLOggerunLikelyvariable = true) \
|
|
fair::Logger(fair::Severity::severity, __FILE__, CONVERTTOSTRING(__LINE__), BOOST_CURRENT_FUNCTION).Log()
|
|
#else
|
|
#define LOG(severity) \
|
|
for (bool fairLOggerunLikelyvariable = false; fair::Logger::Logging(fair::Severity::severity) && !fairLOggerunLikelyvariable; fairLOggerunLikelyvariable = true) \
|
|
fair::Logger(fair::Severity::severity, __FILE__, CONVERTTOSTRING(__LINE__), __FUNCTION__).Log()
|
|
#endif
|
|
|
|
// with custom file, line, function
|
|
#define LOGD(severity, file, line, function) \
|
|
for (bool fairLOggerunLikelyvariable = false; fair::Logger::Logging(severity) && !fairLOggerunLikelyvariable; fairLOggerunLikelyvariable = true) \
|
|
fair::Logger(severity, file, line, function).Log()
|
|
|
|
#define LOG_IF(severity, condition) \
|
|
for (bool fairLOggerunLikelyvariable2 = false; condition && !fairLOggerunLikelyvariable2; fairLOggerunLikelyvariable2 = true) \
|
|
LOG(severity)
|
|
|
|
#endif // FAIR_LOGGER_H
|