diff options
| author | Stefan Boberg <[email protected]> | 2026-03-09 10:50:47 +0100 |
|---|---|---|
| committer | GitHub Enterprise <[email protected]> | 2026-03-09 10:50:47 +0100 |
| commit | 19a117889c2db6b817af9458c04c04f324162e75 (patch) | |
| tree | fbbd0d01c5bf40be90cec88e1d02c6a3c529a2f5 | |
| parent | zenstore bug-fixes from static analysis pass (#815) (diff) | |
| download | zen-19a117889c2db6b817af9458c04c04f324162e75.tar.xz zen-19a117889c2db6b817af9458c04c04f324162e75.zip | |
Eliminate spdlog dependency (#773)
Removes the vendored spdlog library (~12,000 lines) and replaces it with a purpose-built logging system in zencore (~1,800 lines). The new implementation provides the same functionality with fewer abstractions, no shared_ptr overhead, and full control over the logging pipeline.
### What changed
**New logging core in zencore/logging/:**
- LogMessage, Formatter, Sink, Logger, Registry - core abstractions matching spdlog's model but simplified
- AnsiColorStdoutSink - ANSI color console output (replaces spdlog stdout_color_sink)
- MsvcSink - OutputDebugString on Windows (replaces spdlog msvc_sink)
- AsyncSink - async logging via BlockingQueue worker thread (replaces spdlog async_logger)
- NullSink, MessageOnlyFormatter - utility types
- Thread-safe timestamp caching in formatters using RwLock
**Moved to zenutil/logging/:**
- FullFormatter - full log formatting with timestamp, logger name, level, source location, multiline alignment
- JsonFormatter - structured JSON log output
- RotatingFileSink - rotating file sink with atomic size tracking
**API changes:**
- Log levels are now an enum (LogLevel) instead of int, eliminating the zen::logging::level namespace
- LoggerRef no longer wraps shared_ptr - it holds a raw pointer with the registry owning lifetime
- Logger error handler is wired through Registry and propagated to all loggers on registration
- Logger::Log() now populates ThreadId on every message
**Cleanup:**
- Deleted thirdparty/spdlog/ entirely (110+ files)
- Deleted full_test_formatter (was ~80% duplicate of FullFormatter)
- Renamed snake_case classes to PascalCase (full_formatter -> FullFormatter, json_formatter -> JsonFormatter, sentry_sink -> SentrySink)
- Removed spdlog from xmake dependency graph
### Build / test impact
- zencore no longer depends on spdlog
- zenutil and zenvfs xmake.lua updated to drop spdlog dep
- zentelemetry xmake.lua updated to drop spdlog dep
- All existing tests pass, no test changes required beyond formatter class renames
172 files changed, 2297 insertions, 13965 deletions
diff --git a/src/zen/cmds/builds_cmd.cpp b/src/zen/cmds/builds_cmd.cpp index 0722e9714..e5cbafbea 100644 --- a/src/zen/cmds/builds_cmd.cpp +++ b/src/zen/cmds/builds_cmd.cpp @@ -269,10 +269,10 @@ namespace builds_impl { static ProgressBar::Mode ProgressMode = ProgressBar::Mode::Pretty; #undef ZEN_CONSOLE_VERBOSE -#define ZEN_CONSOLE_VERBOSE(fmtstr, ...) \ - if (IsVerbose) \ - { \ - ZEN_CONSOLE_LOG(zen::logging::level::Info, fmtstr, ##__VA_ARGS__); \ +#define ZEN_CONSOLE_VERBOSE(fmtstr, ...) \ + if (IsVerbose) \ + { \ + ZEN_CONSOLE_LOG(zen::logging::Info, fmtstr, ##__VA_ARGS__); \ } const std::string DefaultAccessTokenEnvVariableName( diff --git a/src/zen/cmds/wipe_cmd.cpp b/src/zen/cmds/wipe_cmd.cpp index fd9e28a80..10f5ad8e1 100644 --- a/src/zen/cmds/wipe_cmd.cpp +++ b/src/zen/cmds/wipe_cmd.cpp @@ -50,10 +50,10 @@ namespace wipe_impl { } #undef ZEN_CONSOLE_VERBOSE -#define ZEN_CONSOLE_VERBOSE(fmtstr, ...) \ - if (IsVerbose) \ - { \ - ZEN_CONSOLE_LOG(zen::logging::level::Info, fmtstr, ##__VA_ARGS__); \ +#define ZEN_CONSOLE_VERBOSE(fmtstr, ...) \ + if (IsVerbose) \ + { \ + ZEN_CONSOLE_LOG(zen::logging::Info, fmtstr, ##__VA_ARGS__); \ } static void SignalCallbackHandler(int SigNum) diff --git a/src/zen/progressbar.cpp b/src/zen/progressbar.cpp index 9467ed60d..b758c061b 100644 --- a/src/zen/progressbar.cpp +++ b/src/zen/progressbar.cpp @@ -390,19 +390,19 @@ class ConsoleOpLogOutput : public OperationLogOutput { public: ConsoleOpLogOutput(zen::ProgressBar::Mode InMode) : m_Mode(InMode) {} - virtual void EmitLogMessage(int LogLevel, std::string_view Format, fmt::format_args Args) + virtual void EmitLogMessage(const logging::LogPoint& Point, fmt::format_args Args) override { - logging::EmitConsoleLogMessage(LogLevel, Format, Args); + logging::EmitConsoleLogMessage(Point, Args); } - virtual void SetLogOperationName(std::string_view Name) { zen::ProgressBar::SetLogOperationName(m_Mode, Name); } - virtual void SetLogOperationProgress(uint32_t StepIndex, uint32_t StepCount) + virtual void SetLogOperationName(std::string_view Name) override { zen::ProgressBar::SetLogOperationName(m_Mode, Name); } + virtual void SetLogOperationProgress(uint32_t StepIndex, uint32_t StepCount) override { zen::ProgressBar::SetLogOperationProgress(m_Mode, StepIndex, StepCount); } - virtual uint32_t GetProgressUpdateDelayMS() { return GetUpdateDelayMS(m_Mode); } + virtual uint32_t GetProgressUpdateDelayMS() override { return GetUpdateDelayMS(m_Mode); } - virtual ProgressBar* CreateProgressBar(std::string_view InSubTask) { return new ConsoleOpLogProgressBar(m_Mode, InSubTask); } + virtual ProgressBar* CreateProgressBar(std::string_view InSubTask) override { return new ConsoleOpLogProgressBar(m_Mode, InSubTask); } private: zen::ProgressBar::Mode m_Mode; diff --git a/src/zen/zen.cpp b/src/zen/zen.cpp index ba8a76bc3..7f7afa322 100644 --- a/src/zen/zen.cpp +++ b/src/zen/zen.cpp @@ -689,7 +689,6 @@ main(int argc, char** argv) const LoggingOptions LogOptions = {.IsDebug = GlobalOptions.IsDebug, .IsVerbose = GlobalOptions.IsVerbose, .IsTest = false, - .AllowAsync = false, .NoConsoleOutput = GlobalOptions.LoggingConfig.NoConsoleOutput, .QuietConsole = GlobalOptions.LoggingConfig.QuietConsole, .AbsLogFile = GlobalOptions.LoggingConfig.AbsLogFile, diff --git a/src/zencore/include/zencore/blockingqueue.h b/src/zencore/include/zencore/blockingqueue.h index e91fdc659..b6c93e937 100644 --- a/src/zencore/include/zencore/blockingqueue.h +++ b/src/zencore/include/zencore/blockingqueue.h @@ -2,6 +2,8 @@ #pragma once +#include <zencore/zencore.h> // For ZEN_ASSERT + #include <atomic> #include <condition_variable> #include <deque> diff --git a/src/zencore/include/zencore/logbase.h b/src/zencore/include/zencore/logbase.h index 00af68b0a..ece17a85e 100644 --- a/src/zencore/include/zencore/logbase.h +++ b/src/zencore/include/zencore/logbase.h @@ -4,96 +4,85 @@ #include <string_view> -#define ZEN_LOG_LEVEL_TRACE 0 -#define ZEN_LOG_LEVEL_DEBUG 1 -#define ZEN_LOG_LEVEL_INFO 2 -#define ZEN_LOG_LEVEL_WARN 3 -#define ZEN_LOG_LEVEL_ERROR 4 -#define ZEN_LOG_LEVEL_CRITICAL 5 -#define ZEN_LOG_LEVEL_OFF 6 - -#define ZEN_LEVEL_NAME_TRACE std::string_view("trace", 5) -#define ZEN_LEVEL_NAME_DEBUG std::string_view("debug", 5) -#define ZEN_LEVEL_NAME_INFO std::string_view("info", 4) -#define ZEN_LEVEL_NAME_WARNING std::string_view("warning", 7) -#define ZEN_LEVEL_NAME_ERROR std::string_view("error", 5) -#define ZEN_LEVEL_NAME_CRITICAL std::string_view("critical", 8) -#define ZEN_LEVEL_NAME_OFF std::string_view("off", 3) - -namespace zen::logging::level { +namespace zen::logging { enum LogLevel : int { - Trace = ZEN_LOG_LEVEL_TRACE, - Debug = ZEN_LOG_LEVEL_DEBUG, - Info = ZEN_LOG_LEVEL_INFO, - Warn = ZEN_LOG_LEVEL_WARN, - Err = ZEN_LOG_LEVEL_ERROR, - Critical = ZEN_LOG_LEVEL_CRITICAL, - Off = ZEN_LOG_LEVEL_OFF, + Trace, + Debug, + Info, + Warn, + Err, + Critical, + Off, LogLevelCount }; LogLevel ParseLogLevelString(std::string_view String); std::string_view ToStringView(LogLevel Level); -} // namespace zen::logging::level - -namespace zen::logging { - -void SetLogLevel(level::LogLevel NewLogLevel); -level::LogLevel GetLogLevel(); +void SetLogLevel(LogLevel NewLogLevel); +LogLevel GetLogLevel(); -} // namespace zen::logging +struct SourceLocation +{ + constexpr SourceLocation() = default; + constexpr SourceLocation(const char* InFilename, int InLine) : Filename(InFilename), Line(InLine) {} -namespace spdlog { -class logger; -} + constexpr operator bool() const noexcept { return Line != 0; } -namespace zen::logging { + const char* Filename{nullptr}; + int Line{0}; +}; -struct SourceLocation +/** This encodes the constant parts of a log message which can be emitted once + * and then referred to by log events. + * + * It's *critical* that instances of this struct are permanent and never + * destroyed, as log messages will refer to them by pointer. The easiest way + * to ensure this is to create them as function-local statics. + * + * The logging macros already do this for you so this should not be something + * you normally would need to worry about. + */ +struct LogPoint { - constexpr SourceLocation() = default; - constexpr SourceLocation(const char* filename_in, int line_in, const char* funcname_in) - : filename(filename_in) - , line(line_in) - , funcname(funcname_in) - { - } - - constexpr bool empty() const noexcept { return line == 0; } - - // IMPORTANT NOTE: the layout of this class must match the spdlog::source_loc class - // since we currently pass a pointer to it into spdlog after casting it to - // spdlog::source_loc* - // - // This is intended to be an intermediate state, before we (probably) transition off - // spdlog entirely - - const char* filename{nullptr}; - int line{0}; - const char* funcname{nullptr}; + SourceLocation Location; + LogLevel Level; + std::string_view FormatString; }; +class Logger; + } // namespace zen::logging namespace zen { +// Lightweight non-owning handle to a Logger. Loggers are owned by the Registry +// via Ref<Logger>; LoggerRef exists as a cheap (raw pointer) handle that can be +// stored in members and passed through logging macros without requiring the +// complete Logger type or incurring refcount overhead on every log call. struct LoggerRef { LoggerRef() = default; - LoggerRef(spdlog::logger& InLogger) : SpdLogger(&InLogger) {} + LoggerRef(logging::Logger& InLogger) : m_Logger(&InLogger) {} + // This exists so that logging macros can pass LoggerRef or LogCategory + // to ZEN_LOG without needing to know which one it is LoggerRef Logger() { return *this; } - bool ShouldLog(int Level) const; - inline operator bool() const { return SpdLogger != nullptr; } + bool ShouldLog(logging::LogLevel Level) const; + inline operator bool() const { return m_Logger != nullptr; } + + inline logging::Logger* operator->() const { return m_Logger; } + inline logging::Logger& operator*() const { return *m_Logger; } - void SetLogLevel(logging::level::LogLevel NewLogLevel); - logging::level::LogLevel GetLogLevel(); + void SetLogLevel(logging::LogLevel NewLogLevel); + logging::LogLevel GetLogLevel(); + void Flush(); - spdlog::logger* SpdLogger = nullptr; +private: + logging::Logger* m_Logger = nullptr; }; } // namespace zen diff --git a/src/zencore/include/zencore/logging.h b/src/zencore/include/zencore/logging.h index 74a44d028..4b593c19e 100644 --- a/src/zencore/include/zencore/logging.h +++ b/src/zencore/include/zencore/logging.h @@ -9,16 +9,9 @@ #if ZEN_PLATFORM_WINDOWS # define ZEN_LOG_SECTION(Id) ZEN_DATA_SECTION(Id) -# pragma section(".zlog$f", read) # pragma section(".zlog$l", read) -# pragma section(".zlog$m", read) -# pragma section(".zlog$s", read) -# define ZEN_DECLARE_FUNCTION static constinit ZEN_LOG_SECTION(".zlog$f") char FuncName[] = __FUNCTION__; -# define ZEN_LOG_FUNCNAME FuncName #else # define ZEN_LOG_SECTION(Id) -# define ZEN_DECLARE_FUNCTION -# define ZEN_LOG_FUNCNAME static_cast<const char*>(__func__) #endif namespace zen::logging { @@ -37,34 +30,29 @@ LoggerRef ErrorLog(); void SetErrorLog(std::string_view LoggerId); LoggerRef Get(std::string_view Name); -void ConfigureLogLevels(level::LogLevel Level, std::string_view Loggers); +void ConfigureLogLevels(LogLevel Level, std::string_view Loggers); void RefreshLogLevels(); -void RefreshLogLevels(level::LogLevel DefaultLevel); - +void RefreshLogLevels(LogLevel DefaultLevel); + +/** LogCategory allows for the creation of log categories that can be used with + * the logging macros just like a logger reference. The main purpose of this is + * to allow for static log categories in global scope where we can't actually + * go ahead and instantiate a logger immediately because the logging system may + * not be initialized yet. + */ struct LogCategory { - inline LogCategory(std::string_view InCategory) : CategoryName(InCategory) {} - - inline zen::LoggerRef Logger() - { - if (LoggerRef) - { - return LoggerRef; - } + inline LogCategory(std::string_view InCategory) : m_CategoryName(InCategory) {} - LoggerRef = zen::logging::Get(CategoryName); - return LoggerRef; - } + LoggerRef Logger(); - std::string CategoryName; - zen::LoggerRef LoggerRef; +private: + std::string m_CategoryName; + LoggerRef m_LoggerRef; }; -void EmitConsoleLogMessage(int LogLevel, std::string_view Format, fmt::format_args Args); -void EmitLogMessage(LoggerRef& Logger, int LogLevel, std::string_view Message); -void EmitLogMessage(LoggerRef& Logger, const SourceLocation& Location, int LogLevel, std::string_view Message); -void EmitLogMessage(LoggerRef& Logger, int LogLevel, std::string_view Format, fmt::format_args Args); -void EmitLogMessage(LoggerRef& Logger, const SourceLocation& Location, int LogLevel, std::string_view Format, fmt::format_args Args); +void EmitConsoleLogMessage(const LogPoint& Lp, fmt::format_args Args); +void EmitLogMessage(LoggerRef& Logger, const LogPoint& Lp, fmt::format_args Args); template<typename... T> auto @@ -79,15 +67,14 @@ namespace zen { extern LoggerRef TheDefaultLogger; -inline LoggerRef -Log() -{ - if (TheDefaultLogger) - { - return TheDefaultLogger; - } - return zen::logging::ConsoleLog(); -} +/** + * This is the default logger, which any ZEN_INFO et al will get if there's + * no Log() function declared in the current scope. + * + * Typically, classes which want to log to its own channel will declare a Log() + * member function which returns a LoggerRef created at construction time. + */ +LoggerRef Log(); using logging::ConsoleLog; using logging::ErrorLog; @@ -98,12 +85,6 @@ using zen::ConsoleLog; using zen::ErrorLog; using zen::Log; -inline consteval bool -LogIsErrorLevel(int LogLevel) -{ - return (LogLevel == zen::logging::level::Err || LogLevel == zen::logging::level::Critical); -}; - #if ZEN_BUILD_DEBUG # define ZEN_CHECK_FORMAT_STRING(fmtstr, ...) \ while (false) \ @@ -117,75 +98,66 @@ LogIsErrorLevel(int LogLevel) } #endif -#define ZEN_LOG_WITH_LOCATION(InLogger, InLevel, fmtstr, ...) \ - do \ - { \ - using namespace std::literals; \ - ZEN_DECLARE_FUNCTION \ - static constinit ZEN_LOG_SECTION(".zlog$s") char FileName[] = __FILE__; \ - static constinit ZEN_LOG_SECTION(".zlog$m") char FormatString[] = fmtstr; \ - static constinit ZEN_LOG_SECTION(".zlog$l") zen::logging::SourceLocation Location{FileName, __LINE__, ZEN_LOG_FUNCNAME}; \ - zen::LoggerRef Logger = InLogger; \ - ZEN_CHECK_FORMAT_STRING(fmtstr##sv, ##__VA_ARGS__); \ - if (Logger.ShouldLog(InLevel)) \ - { \ - zen::logging::EmitLogMessage(Logger, \ - Location, \ - InLevel, \ - std::string_view(FormatString, sizeof FormatString - 1), \ - zen::logging::LogCaptureArguments(__VA_ARGS__)); \ - } \ +#define ZEN_LOG_WITH_LOCATION(InLogger, InLevel, fmtstr, ...) \ + do \ + { \ + using namespace std::literals; \ + static constinit ZEN_LOG_SECTION(".zlog$l") \ + zen::logging::LogPoint LogPoint{zen::logging::SourceLocation{__FILE__, __LINE__}, InLevel, std::string_view(fmtstr)}; \ + zen::LoggerRef Logger = InLogger; \ + ZEN_CHECK_FORMAT_STRING(fmtstr##sv, ##__VA_ARGS__); \ + if (Logger.ShouldLog(InLevel)) \ + { \ + zen::logging::EmitLogMessage(Logger, LogPoint, zen::logging::LogCaptureArguments(__VA_ARGS__)); \ + } \ } while (false); -#define ZEN_LOG(InLogger, InLevel, fmtstr, ...) \ - do \ - { \ - using namespace std::literals; \ - static constinit ZEN_LOG_SECTION(".zlog$m") char FormatString[] = fmtstr; \ - zen::LoggerRef Logger = InLogger; \ - ZEN_CHECK_FORMAT_STRING(fmtstr##sv, ##__VA_ARGS__); \ - if (Logger.ShouldLog(InLevel)) \ - { \ - zen::logging::EmitLogMessage(Logger, \ - InLevel, \ - std::string_view(FormatString, sizeof FormatString - 1), \ - zen::logging::LogCaptureArguments(__VA_ARGS__)); \ - } \ +#define ZEN_LOG(InLogger, InLevel, fmtstr, ...) \ + do \ + { \ + using namespace std::literals; \ + static constinit ZEN_LOG_SECTION(".zlog$l") zen::logging::LogPoint LogPoint{{}, InLevel, std::string_view(fmtstr)}; \ + zen::LoggerRef Logger = InLogger; \ + ZEN_CHECK_FORMAT_STRING(fmtstr##sv, ##__VA_ARGS__); \ + if (Logger.ShouldLog(InLevel)) \ + { \ + zen::logging::EmitLogMessage(Logger, LogPoint, zen::logging::LogCaptureArguments(__VA_ARGS__)); \ + } \ } while (false); #define ZEN_DEFINE_LOG_CATEGORY_STATIC(Category, Name) \ static zen::logging::LogCategory Category { Name } -#define ZEN_LOG_TRACE(Category, fmtstr, ...) ZEN_LOG(Category.Logger(), zen::logging::level::Trace, fmtstr, ##__VA_ARGS__) -#define ZEN_LOG_DEBUG(Category, fmtstr, ...) ZEN_LOG(Category.Logger(), zen::logging::level::Debug, fmtstr, ##__VA_ARGS__) -#define ZEN_LOG_INFO(Category, fmtstr, ...) ZEN_LOG(Category.Logger(), zen::logging::level::Info, fmtstr, ##__VA_ARGS__) -#define ZEN_LOG_WARN(Category, fmtstr, ...) ZEN_LOG(Category.Logger(), zen::logging::level::Warn, fmtstr, ##__VA_ARGS__) -#define ZEN_LOG_ERROR(Category, fmtstr, ...) ZEN_LOG_WITH_LOCATION(Category.Logger(), zen::logging::level::Err, fmtstr, ##__VA_ARGS__) -#define ZEN_LOG_CRITICAL(Category, fmtstr, ...) \ - ZEN_LOG_WITH_LOCATION(Category.Logger(), zen::logging::level::Critical, fmtstr, ##__VA_ARGS__) - -#define ZEN_TRACE(fmtstr, ...) ZEN_LOG(Log(), zen::logging::level::Trace, fmtstr, ##__VA_ARGS__) -#define ZEN_DEBUG(fmtstr, ...) ZEN_LOG(Log(), zen::logging::level::Debug, fmtstr, ##__VA_ARGS__) -#define ZEN_INFO(fmtstr, ...) ZEN_LOG(Log(), zen::logging::level::Info, fmtstr, ##__VA_ARGS__) -#define ZEN_WARN(fmtstr, ...) ZEN_LOG(Log(), zen::logging::level::Warn, fmtstr, ##__VA_ARGS__) -#define ZEN_ERROR(fmtstr, ...) ZEN_LOG_WITH_LOCATION(Log(), zen::logging::level::Err, fmtstr, ##__VA_ARGS__) -#define ZEN_CRITICAL(fmtstr, ...) ZEN_LOG_WITH_LOCATION(Log(), zen::logging::level::Critical, fmtstr, ##__VA_ARGS__) - -#define ZEN_CONSOLE_LOG(InLevel, fmtstr, ...) \ - do \ - { \ - using namespace std::literals; \ - ZEN_CHECK_FORMAT_STRING(fmtstr##sv, ##__VA_ARGS__); \ - zen::logging::EmitConsoleLogMessage(InLevel, fmtstr, zen::logging::LogCaptureArguments(__VA_ARGS__)); \ +#define ZEN_LOG_TRACE(Category, fmtstr, ...) ZEN_LOG(Category.Logger(), zen::logging::Trace, fmtstr, ##__VA_ARGS__) +#define ZEN_LOG_DEBUG(Category, fmtstr, ...) ZEN_LOG(Category.Logger(), zen::logging::Debug, fmtstr, ##__VA_ARGS__) +#define ZEN_LOG_INFO(Category, fmtstr, ...) ZEN_LOG(Category.Logger(), zen::logging::Info, fmtstr, ##__VA_ARGS__) +#define ZEN_LOG_WARN(Category, fmtstr, ...) ZEN_LOG(Category.Logger(), zen::logging::Warn, fmtstr, ##__VA_ARGS__) +#define ZEN_LOG_ERROR(Category, fmtstr, ...) ZEN_LOG_WITH_LOCATION(Category.Logger(), zen::logging::Err, fmtstr, ##__VA_ARGS__) +#define ZEN_LOG_CRITICAL(Category, fmtstr, ...) ZEN_LOG_WITH_LOCATION(Category.Logger(), zen::logging::Critical, fmtstr, ##__VA_ARGS__) + +#define ZEN_TRACE(fmtstr, ...) ZEN_LOG(Log(), zen::logging::Trace, fmtstr, ##__VA_ARGS__) +#define ZEN_DEBUG(fmtstr, ...) ZEN_LOG(Log(), zen::logging::Debug, fmtstr, ##__VA_ARGS__) +#define ZEN_INFO(fmtstr, ...) ZEN_LOG(Log(), zen::logging::Info, fmtstr, ##__VA_ARGS__) +#define ZEN_WARN(fmtstr, ...) ZEN_LOG(Log(), zen::logging::Warn, fmtstr, ##__VA_ARGS__) +#define ZEN_ERROR(fmtstr, ...) ZEN_LOG_WITH_LOCATION(Log(), zen::logging::Err, fmtstr, ##__VA_ARGS__) +#define ZEN_CRITICAL(fmtstr, ...) ZEN_LOG_WITH_LOCATION(Log(), zen::logging::Critical, fmtstr, ##__VA_ARGS__) + +#define ZEN_CONSOLE_LOG(InLevel, fmtstr, ...) \ + do \ + { \ + using namespace std::literals; \ + static constinit ZEN_LOG_SECTION(".zlog$l") zen::logging::LogPoint LogPoint{{}, InLevel, std::string_view(fmtstr)}; \ + ZEN_CHECK_FORMAT_STRING(fmtstr##sv, ##__VA_ARGS__); \ + zen::logging::EmitConsoleLogMessage(LogPoint, zen::logging::LogCaptureArguments(__VA_ARGS__)); \ } while (false) -#define ZEN_CONSOLE(fmtstr, ...) ZEN_CONSOLE_LOG(zen::logging::level::Info, fmtstr, ##__VA_ARGS__) -#define ZEN_CONSOLE_TRACE(fmtstr, ...) ZEN_CONSOLE_LOG(zen::logging::level::Trace, fmtstr, ##__VA_ARGS__) -#define ZEN_CONSOLE_DEBUG(fmtstr, ...) ZEN_CONSOLE_LOG(zen::logging::level::Debug, fmtstr, ##__VA_ARGS__) -#define ZEN_CONSOLE_INFO(fmtstr, ...) ZEN_CONSOLE_LOG(zen::logging::level::Info, fmtstr, ##__VA_ARGS__) -#define ZEN_CONSOLE_WARN(fmtstr, ...) ZEN_CONSOLE_LOG(zen::logging::level::Warn, fmtstr, ##__VA_ARGS__) -#define ZEN_CONSOLE_ERROR(fmtstr, ...) ZEN_CONSOLE_LOG(zen::logging::level::Err, fmtstr, ##__VA_ARGS__) -#define ZEN_CONSOLE_CRITICAL(fmtstr, ...) ZEN_CONSOLE_LOG(zen::logging::level::Critical, fmtstr, ##__VA_ARGS__) +#define ZEN_CONSOLE(fmtstr, ...) ZEN_CONSOLE_LOG(zen::logging::Info, fmtstr, ##__VA_ARGS__) +#define ZEN_CONSOLE_TRACE(fmtstr, ...) ZEN_CONSOLE_LOG(zen::logging::Trace, fmtstr, ##__VA_ARGS__) +#define ZEN_CONSOLE_DEBUG(fmtstr, ...) ZEN_CONSOLE_LOG(zen::logging::Debug, fmtstr, ##__VA_ARGS__) +#define ZEN_CONSOLE_INFO(fmtstr, ...) ZEN_CONSOLE_LOG(zen::logging::Info, fmtstr, ##__VA_ARGS__) +#define ZEN_CONSOLE_WARN(fmtstr, ...) ZEN_CONSOLE_LOG(zen::logging::Warn, fmtstr, ##__VA_ARGS__) +#define ZEN_CONSOLE_ERROR(fmtstr, ...) ZEN_CONSOLE_LOG(zen::logging::Err, fmtstr, ##__VA_ARGS__) +#define ZEN_CONSOLE_CRITICAL(fmtstr, ...) ZEN_CONSOLE_LOG(zen::logging::Critical, fmtstr, ##__VA_ARGS__) ////////////////////////////////////////////////////////////////////////// @@ -240,28 +212,28 @@ std::string_view EmitActivitiesForLogging(StringBuilderBase& OutString); #define ZEN_LOG_SCOPE(...) ScopedLazyActivity $Activity##__LINE__([&](StringBuilderBase& Out) { Out << fmt::format(__VA_ARGS__); }) -#define ZEN_SCOPED_WARN(fmtstr, ...) \ - do \ - { \ - ExtendableStringBuilder<256> ScopeString; \ - const std::string_view Scopes = EmitActivitiesForLogging(ScopeString); \ - ZEN_LOG(Log(), zen::logging::level::Warn, fmtstr "{}", ##__VA_ARGS__, Scopes); \ +#define ZEN_SCOPED_WARN(fmtstr, ...) \ + do \ + { \ + ExtendableStringBuilder<256> ScopeString; \ + const std::string_view Scopes = EmitActivitiesForLogging(ScopeString); \ + ZEN_LOG(Log(), zen::logging::Warn, fmtstr "{}", ##__VA_ARGS__, Scopes); \ } while (false) -#define ZEN_SCOPED_ERROR(fmtstr, ...) \ - do \ - { \ - ExtendableStringBuilder<256> ScopeString; \ - const std::string_view Scopes = EmitActivitiesForLogging(ScopeString); \ - ZEN_LOG_WITH_LOCATION(Log(), zen::logging::level::Err, fmtstr "{}", ##__VA_ARGS__, Scopes); \ +#define ZEN_SCOPED_ERROR(fmtstr, ...) \ + do \ + { \ + ExtendableStringBuilder<256> ScopeString; \ + const std::string_view Scopes = EmitActivitiesForLogging(ScopeString); \ + ZEN_LOG_WITH_LOCATION(Log(), zen::logging::Err, fmtstr "{}", ##__VA_ARGS__, Scopes); \ } while (false) -#define ZEN_SCOPED_CRITICAL(fmtstr, ...) \ - do \ - { \ - ExtendableStringBuilder<256> ScopeString; \ - const std::string_view Scopes = EmitActivitiesForLogging(ScopeString); \ - ZEN_LOG_WITH_LOCATION(Log(), zen::logging::level::Critical, fmtstr "{}", ##__VA_ARGS__, Scopes); \ +#define ZEN_SCOPED_CRITICAL(fmtstr, ...) \ + do \ + { \ + ExtendableStringBuilder<256> ScopeString; \ + const std::string_view Scopes = EmitActivitiesForLogging(ScopeString); \ + ZEN_LOG_WITH_LOCATION(Log(), zen::logging::Critical, fmtstr "{}", ##__VA_ARGS__, Scopes); \ } while (false) ScopedActivityBase* GetThreadActivity(); diff --git a/src/zencore/include/zencore/logging/ansicolorsink.h b/src/zencore/include/zencore/logging/ansicolorsink.h new file mode 100644 index 000000000..9f859e8d7 --- /dev/null +++ b/src/zencore/include/zencore/logging/ansicolorsink.h @@ -0,0 +1,26 @@ +// Copyright Epic Games, Inc. All Rights Reserved. + +#pragma once + +#include <zencore/logging/sink.h> + +#include <memory> + +namespace zen::logging { + +class AnsiColorStdoutSink : public Sink +{ +public: + AnsiColorStdoutSink(); + ~AnsiColorStdoutSink() override; + + void Log(const LogMessage& Msg) override; + void Flush() override; + void SetFormatter(std::unique_ptr<Formatter> InFormatter) override; + +private: + struct Impl; + std::unique_ptr<Impl> m_Impl; +}; + +} // namespace zen::logging diff --git a/src/zencore/include/zencore/logging/asyncsink.h b/src/zencore/include/zencore/logging/asyncsink.h new file mode 100644 index 000000000..c49a1ccce --- /dev/null +++ b/src/zencore/include/zencore/logging/asyncsink.h @@ -0,0 +1,30 @@ +// Copyright Epic Games, Inc. All Rights Reserved. + +#pragma once + +#include <zencore/logging/sink.h> + +#include <memory> +#include <vector> + +namespace zen::logging { + +class AsyncSink : public Sink +{ +public: + explicit AsyncSink(std::vector<SinkPtr> InSinks); + ~AsyncSink() override; + + AsyncSink(const AsyncSink&) = delete; + AsyncSink& operator=(const AsyncSink&) = delete; + + void Log(const LogMessage& Msg) override; + void Flush() override; + void SetFormatter(std::unique_ptr<Formatter> InFormatter) override; + +private: + struct Impl; + std::unique_ptr<Impl> m_Impl; +}; + +} // namespace zen::logging diff --git a/src/zencore/include/zencore/logging/formatter.h b/src/zencore/include/zencore/logging/formatter.h new file mode 100644 index 000000000..11904d71d --- /dev/null +++ b/src/zencore/include/zencore/logging/formatter.h @@ -0,0 +1,20 @@ +// Copyright Epic Games, Inc. All Rights Reserved. + +#pragma once + +#include <zencore/logging/logmsg.h> +#include <zencore/logging/memorybuffer.h> + +#include <memory> + +namespace zen::logging { + +class Formatter +{ +public: + virtual ~Formatter() = default; + virtual void Format(const LogMessage& Msg, MemoryBuffer& Dest) = 0; + virtual std::unique_ptr<Formatter> Clone() const = 0; +}; + +} // namespace zen::logging diff --git a/src/zencore/include/zencore/logging/helpers.h b/src/zencore/include/zencore/logging/helpers.h new file mode 100644 index 000000000..ce021e1a5 --- /dev/null +++ b/src/zencore/include/zencore/logging/helpers.h @@ -0,0 +1,122 @@ +// Copyright Epic Games, Inc. All Rights Reserved. + +#pragma once + +#include <zencore/logbase.h> +#include <zencore/logging/memorybuffer.h> + +#include <chrono> +#include <ctime> +#include <string_view> + +namespace zen::logging::helpers { + +inline void +AppendStringView(std::string_view Sv, MemoryBuffer& Dest) +{ + Dest.append(Sv.data(), Sv.data() + Sv.size()); +} + +inline void +AppendInt(int N, MemoryBuffer& Dest) +{ + fmt::format_int Formatted(N); + Dest.append(Formatted.data(), Formatted.data() + Formatted.size()); +} + +inline void +Pad2(int N, MemoryBuffer& Dest) +{ + if (N >= 0 && N < 100) + { + Dest.push_back(static_cast<char>('0' + N / 10)); + Dest.push_back(static_cast<char>('0' + N % 10)); + } + else + { + fmt::format_int Formatted(N); + Dest.append(Formatted.data(), Formatted.data() + Formatted.size()); + } +} + +inline void +Pad3(uint32_t N, MemoryBuffer& Dest) +{ + if (N < 1000) + { + Dest.push_back(static_cast<char>('0' + N / 100)); + Dest.push_back(static_cast<char>('0' + (N / 10) % 10)); + Dest.push_back(static_cast<char>('0' + N % 10)); + } + else + { + AppendInt(static_cast<int>(N), Dest); + } +} + +inline void +PadUint(size_t N, unsigned int Width, MemoryBuffer& Dest) +{ + fmt::format_int Formatted(N); + auto StrLen = static_cast<unsigned int>(Formatted.size()); + if (Width > StrLen) + { + for (unsigned int Pad = 0; Pad < Width - StrLen; ++Pad) + { + Dest.push_back('0'); + } + } + Dest.append(Formatted.data(), Formatted.data() + Formatted.size()); +} + +template<typename ToDuration> +inline ToDuration +TimeFraction(std::chrono::system_clock::time_point Tp) +{ + using std::chrono::duration_cast; + using std::chrono::seconds; + auto Duration = Tp.time_since_epoch(); + auto Secs = duration_cast<seconds>(Duration); + return duration_cast<ToDuration>(Duration) - duration_cast<ToDuration>(Secs); +} + +inline std::tm +SafeLocaltime(std::time_t Time) +{ + std::tm Result{}; +#if defined(_WIN32) + localtime_s(&Result, &Time); +#else + localtime_r(&Time, &Result); +#endif + return Result; +} + +inline const char* +ShortFilename(const char* Path) +{ + if (Path == nullptr) + { + return Path; + } + + const char* It = Path; + const char* LastSep = Path; + while (*It) + { + if (*It == '/' || *It == '\\') + { + LastSep = It + 1; + } + ++It; + } + return LastSep; +} + +inline std::string_view +LevelToShortString(LogLevel Level) +{ + return ToStringView(Level); +} + +} // namespace zen::logging::helpers diff --git a/src/zencore/include/zencore/logging/logger.h b/src/zencore/include/zencore/logging/logger.h new file mode 100644 index 000000000..39d1139a5 --- /dev/null +++ b/src/zencore/include/zencore/logging/logger.h @@ -0,0 +1,63 @@ +// Copyright Epic Games, Inc. All Rights Reserved. + +#pragma once + +#include <zencore/logging/sink.h> + +#include <atomic> +#include <memory> +#include <string_view> + +namespace zen::logging { + +class ErrorHandler +{ +public: + virtual ~ErrorHandler() = default; + virtual void HandleError(const std::string_view& Msg) = 0; +}; + +class Logger : public RefCounted +{ +public: + Logger(std::string_view InName, SinkPtr InSink); + Logger(std::string_view InName, std::span<const SinkPtr> InSinks); + ~Logger(); + + Logger(const Logger&) = delete; + Logger& operator=(const Logger&) = delete; + + void Log(const LogPoint& Point, fmt::format_args Args); + + bool ShouldLog(LogLevel InLevel) const { return InLevel >= m_Level.load(std::memory_order_relaxed); } + + void SetLevel(LogLevel InLevel) { m_Level.store(InLevel, std::memory_order_relaxed); } + LogLevel GetLevel() const { return m_Level.load(std::memory_order_relaxed); } + + void SetFlushLevel(LogLevel InLevel) { m_FlushLevel.store(InLevel, std::memory_order_relaxed); } + LogLevel GetFlushLevel() const { return m_FlushLevel.load(std::memory_order_relaxed); } + + std::string_view Name() const; + + void SetSinks(std::vector<SinkPtr> InSinks); + void AddSink(SinkPtr InSink); + + void SetFormatter(std::unique_ptr<Formatter> InFormatter); + + void SetErrorHandler(ErrorHandler* Handler); + + void Flush(); + + Ref<Logger> Clone(std::string_view NewName) const; + +private: + void SinkIt(const LogMessage& Msg); + void FlushIfNeeded(LogLevel InLevel); + + struct Impl; + std::unique_ptr<Impl> m_Impl; + std::atomic<LogLevel> m_Level{Info}; + std::atomic<LogLevel> m_FlushLevel{Off}; +}; + +} // namespace zen::logging diff --git a/src/zencore/include/zencore/logging/logmsg.h b/src/zencore/include/zencore/logging/logmsg.h new file mode 100644 index 000000000..1d8b6b1b7 --- /dev/null +++ b/src/zencore/include/zencore/logging/logmsg.h @@ -0,0 +1,66 @@ +// Copyright Epic Games, Inc. All Rights Reserved. + +#pragma once + +#include <zencore/logbase.h> + +#include <chrono> +#include <string_view> + +namespace zen::logging { + +using LogClock = std::chrono::system_clock; + +struct LogMessage +{ + LogMessage() = default; + + LogMessage(const LogPoint& InPoint, std::string_view InLoggerName, std::string_view InPayload) + : m_LoggerName(InLoggerName) + , m_Level(InPoint.Level) + , m_Time(LogClock::now()) + , m_Source(InPoint.Location) + , m_Payload(InPayload) + , m_Point(&InPoint) + { + } + + std::string_view GetPayload() const { return m_Payload; } + int GetThreadId() const { return m_ThreadId; } + LogClock::time_point GetTime() const { return m_Time; } + LogLevel GetLevel() const { return m_Level; } + std::string_view GetLoggerName() const { return m_LoggerName; } + const SourceLocation& GetSource() const { return m_Source; } + const LogPoint& GetLogPoint() const { return *m_Point; } + + void SetThreadId(int InThreadId) { m_ThreadId = InThreadId; } + void SetPayload(std::string_view InPayload) { m_Payload = InPayload; } + void SetLoggerName(std::string_view InName) { m_LoggerName = InName; } + void SetLevel(LogLevel InLevel) { m_Level = InLevel; } + void SetTime(LogClock::time_point InTime) { m_Time = InTime; } + void SetSource(const SourceLocation& InSource) { m_Source = InSource; } + + mutable size_t ColorRangeStart = 0; + mutable size_t ColorRangeEnd = 0; + +private: + static constexpr LogPoint s_DefaultPoints[LogLevelCount] = { + {{}, Trace, {}}, + {{}, Debug, {}}, + {{}, Info, {}}, + {{}, Warn, {}}, + {{}, Err, {}}, + {{}, Critical, {}}, + {{}, Off, {}}, + }; + + std::string_view m_LoggerName; + LogLevel m_Level = Off; + std::chrono::system_clock::time_point m_Time; + SourceLocation m_Source; + std::string_view m_Payload; + const LogPoint* m_Point = &s_DefaultPoints[Off]; + int m_ThreadId = 0; +}; + +} // namespace zen::logging diff --git a/src/zencore/include/zencore/logging/memorybuffer.h b/src/zencore/include/zencore/logging/memorybuffer.h new file mode 100644 index 000000000..cd0ff324f --- /dev/null +++ b/src/zencore/include/zencore/logging/memorybuffer.h @@ -0,0 +1,11 @@ +// Copyright Epic Games, Inc. All Rights Reserved. + +#pragma once + +#include <fmt/format.h> + +namespace zen::logging { + +using MemoryBuffer = fmt::basic_memory_buffer<char, 250>; + +} // namespace zen::logging diff --git a/src/zencore/include/zencore/logging/messageonlyformatter.h b/src/zencore/include/zencore/logging/messageonlyformatter.h new file mode 100644 index 000000000..ce25fe9a6 --- /dev/null +++ b/src/zencore/include/zencore/logging/messageonlyformatter.h @@ -0,0 +1,22 @@ +// Copyright Epic Games, Inc. All Rights Reserved. + +#pragma once + +#include <zencore/logging/formatter.h> +#include <zencore/logging/helpers.h> + +namespace zen::logging { + +class MessageOnlyFormatter : public Formatter +{ +public: + void Format(const LogMessage& Msg, MemoryBuffer& Dest) override + { + helpers::AppendStringView(Msg.GetPayload(), Dest); + Dest.push_back('\n'); + } + + std::unique_ptr<Formatter> Clone() const override { return std::make_unique<MessageOnlyFormatter>(); } +}; + +} // namespace zen::logging diff --git a/src/zencore/include/zencore/logging/msvcsink.h b/src/zencore/include/zencore/logging/msvcsink.h new file mode 100644 index 000000000..48ea1b915 --- /dev/null +++ b/src/zencore/include/zencore/logging/msvcsink.h @@ -0,0 +1,30 @@ +// Copyright Epic Games, Inc. All Rights Reserved. + +#pragma once + +#include <zencore/logging/sink.h> + +#if ZEN_PLATFORM_WINDOWS + +# include <mutex> + +namespace zen::logging { + +class MsvcSink : public Sink +{ +public: + MsvcSink(); + ~MsvcSink() override = default; + + void Log(const LogMessage& Msg) override; + void Flush() override; + void SetFormatter(std::unique_ptr<Formatter> InFormatter) override; + +private: + std::mutex m_Mutex; + std::unique_ptr<Formatter> m_Formatter; +}; + +} // namespace zen::logging + +#endif // ZEN_PLATFORM_WINDOWS diff --git a/src/zencore/include/zencore/logging/nullsink.h b/src/zencore/include/zencore/logging/nullsink.h new file mode 100644 index 000000000..7ac5677c6 --- /dev/null +++ b/src/zencore/include/zencore/logging/nullsink.h @@ -0,0 +1,17 @@ +// Copyright Epic Games, Inc. All Rights Reserved. + +#pragma once + +#include <zencore/logging/sink.h> + +namespace zen::logging { + +class NullSink : public Sink +{ +public: + void Log(const LogMessage& /*Msg*/) override {} + void Flush() override {} + void SetFormatter(std::unique_ptr<Formatter> /*InFormatter*/) override {} +}; + +} // namespace zen::logging diff --git a/src/zencore/include/zencore/logging/registry.h b/src/zencore/include/zencore/logging/registry.h new file mode 100644 index 000000000..a4d3692d2 --- /dev/null +++ b/src/zencore/include/zencore/logging/registry.h @@ -0,0 +1,70 @@ +// Copyright Epic Games, Inc. All Rights Reserved. + +#pragma once + +#include <zencore/logging/logger.h> + +#include <chrono> +#include <memory> +#include <span> +#include <string> +#include <type_traits> +#include <utility> + +namespace zen::logging { + +class Registry +{ +public: + using LogLevels = std::span<const std::pair<std::string, LogLevel>>; + + static Registry& Instance(); + void Shutdown(); + + void Register(Ref<Logger> InLogger); + void Drop(const std::string& Name); + Ref<Logger> Get(const std::string& Name); + + void SetDefaultLogger(Ref<Logger> InLogger); + Logger* DefaultLoggerRaw(); + Ref<Logger> DefaultLogger(); + + void SetGlobalLevel(LogLevel Level); + LogLevel GetGlobalLevel() const; + void SetLevels(LogLevels Levels, LogLevel* DefaultLevel); + + void FlushAll(); + void FlushOn(LogLevel Level); + void FlushEvery(std::chrono::seconds Interval); + + // Change formatter on all registered loggers + void SetFormatter(std::unique_ptr<Formatter> InFormatter); + + // Apply function to all registered loggers. Note that the function will + // be called while the registry mutex is held, so it should be fast and + // not attempt to call back into the registry. + template<typename Func> + void ApplyAll(Func&& F) + { + ApplyAllImpl([](void* Ctx, Ref<Logger> L) { (*static_cast<std::decay_t<Func>*>(Ctx))(std::move(L)); }, &F); + } + + // Set error handler for all loggers in the registry. The handler is called + // if any logger encounters an error during logging or flushing. + // The caller must ensure the handler outlives the registry. + void SetErrorHandler(ErrorHandler* Handler); + +private: + void ApplyAllImpl(void (*Func)(void*, Ref<Logger>), void* Context); + + Registry(); + ~Registry(); + + Registry(const Registry&) = delete; + Registry& operator=(const Registry&) = delete; + + struct Impl; + std::unique_ptr<Impl> m_Impl; +}; + +} // namespace zen::logging diff --git a/src/zencore/include/zencore/logging/sink.h b/src/zencore/include/zencore/logging/sink.h new file mode 100644 index 000000000..172176a4e --- /dev/null +++ b/src/zencore/include/zencore/logging/sink.h @@ -0,0 +1,34 @@ +// Copyright Epic Games, Inc. All Rights Reserved. + +#pragma once + +#include <zenbase/refcount.h> +#include <zencore/logging/formatter.h> +#include <zencore/logging/logmsg.h> + +#include <atomic> +#include <memory> + +namespace zen::logging { + +class Sink : public RefCounted +{ +public: + virtual ~Sink() = default; + + virtual void Log(const LogMessage& Msg) = 0; + virtual void Flush() = 0; + + virtual void SetFormatter(std::unique_ptr<Formatter> InFormatter) = 0; + + bool ShouldLog(LogLevel InLevel) const { return InLevel >= m_Level.load(std::memory_order_relaxed); } + void SetLevel(LogLevel InLevel) { m_Level.store(InLevel, std::memory_order_relaxed); } + LogLevel GetLevel() const { return m_Level.load(std::memory_order_relaxed); } + +protected: + std::atomic<LogLevel> m_Level{Trace}; +}; + +using SinkPtr = Ref<Sink>; + +} // namespace zen::logging diff --git a/src/zencore/include/zencore/logging/tracesink.h b/src/zencore/include/zencore/logging/tracesink.h new file mode 100644 index 000000000..e63d838b4 --- /dev/null +++ b/src/zencore/include/zencore/logging/tracesink.h @@ -0,0 +1,23 @@ +// Copyright Epic Games, Inc. All Rights Reserved. + +#pragma once + +#include <zencore/logging/sink.h> + +namespace zen::logging { + +/** + * A logging sink that forwards log messages to the trace system. + * + * Work-in-progress, not fully implemented. + */ + +class TraceSink : public Sink +{ +public: + void Log(const LogMessage& Msg) override; + void Flush() override; + void SetFormatter(std::unique_ptr<Formatter> InFormatter) override; +}; + +} // namespace zen::logging diff --git a/src/zencore/include/zencore/sentryintegration.h b/src/zencore/include/zencore/sentryintegration.h index faf1238b7..a4e33d69e 100644 --- a/src/zencore/include/zencore/sentryintegration.h +++ b/src/zencore/include/zencore/sentryintegration.h @@ -11,11 +11,9 @@ #if ZEN_USE_SENTRY -# include <memory> +# include <zencore/logging/logger.h> -ZEN_THIRD_PARTY_INCLUDES_START -# include <spdlog/logger.h> -ZEN_THIRD_PARTY_INCLUDES_END +# include <memory> namespace sentry { @@ -53,7 +51,7 @@ private: std::string m_SentryUserName; std::string m_SentryHostName; std::string m_SentryId; - std::shared_ptr<spdlog::logger> m_SentryLogger; + Ref<logging::Logger> m_SentryLogger; }; } // namespace zen diff --git a/src/zencore/logging.cpp b/src/zencore/logging.cpp index ebd68de09..099518637 100644 --- a/src/zencore/logging.cpp +++ b/src/zencore/logging.cpp @@ -2,208 +2,128 @@ #include "zencore/logging.h" +#include <zencore/logging/ansicolorsink.h> +#include <zencore/logging/logger.h> +#include <zencore/logging/messageonlyformatter.h> +#include <zencore/logging/nullsink.h> +#include <zencore/logging/registry.h> #include <zencore/string.h> #include <zencore/testing.h> #include <zencore/thread.h> #include <zencore/memory/llm.h> -ZEN_THIRD_PARTY_INCLUDES_START -#include <spdlog/details/registry.h> -#include <spdlog/sinks/null_sink.h> -#include <spdlog/sinks/stdout_color_sinks.h> -#include <spdlog/spdlog.h> -ZEN_THIRD_PARTY_INCLUDES_END +#include <mutex> #if ZEN_PLATFORM_WINDOWS # pragma section(".zlog$a", read) -# pragma section(".zlog$f", read) -# pragma section(".zlog$m", read) -# pragma section(".zlog$s", read) +# pragma section(".zlog$l", read) # pragma section(".zlog$z", read) #endif namespace zen { -// We shadow the underlying spdlog default logger, in order to avoid a bunch of overhead LoggerRef TheDefaultLogger; +LoggerRef +Log() +{ + if (TheDefaultLogger) + { + return TheDefaultLogger; + } + return zen::logging::ConsoleLog(); +} + } // namespace zen namespace zen::logging { -using MemoryBuffer_t = fmt::basic_memory_buffer<char, 250>; - -struct LoggingContext -{ - inline LoggingContext(); - inline ~LoggingContext(); - - zen::logging::MemoryBuffer_t MessageBuffer; - - inline std::string_view Message() const { return std::string_view(MessageBuffer.data(), MessageBuffer.size()); } -}; +////////////////////////////////////////////////////////////////////////// -LoggingContext::LoggingContext() +LoggerRef +LogCategory::Logger() { -} + // This should be thread safe since zen::logging::Get() will return + // the same logger instance for the same category name. Also the + // LoggerRef is simply a pointer. + if (!m_LoggerRef) + { + m_LoggerRef = zen::logging::Get(m_CategoryName); + } -LoggingContext::~LoggingContext() -{ + return m_LoggerRef; } -////////////////////////////////////////////////////////////////////////// - static inline bool -IsErrorLevel(int LogLevel) +IsErrorLevel(LogLevel InLevel) { - return (LogLevel == zen::logging::level::Err || LogLevel == zen::logging::level::Critical); + return (InLevel == Err || InLevel == Critical); }; -static_assert(sizeof(spdlog::source_loc) == sizeof(SourceLocation)); -static_assert(offsetof(spdlog::source_loc, filename) == offsetof(SourceLocation, filename)); -static_assert(offsetof(spdlog::source_loc, line) == offsetof(SourceLocation, line)); -static_assert(offsetof(spdlog::source_loc, funcname) == offsetof(SourceLocation, funcname)); - void -EmitLogMessage(LoggerRef& Logger, int LogLevel, const std::string_view Message) +EmitLogMessage(LoggerRef& Logger, const LogPoint& Lp, fmt::format_args Args) { ZEN_MEMSCOPE(ELLMTag::Logging); - const spdlog::level::level_enum InLevel = (spdlog::level::level_enum)LogLevel; - Logger.SpdLogger->log(InLevel, Message); - if (IsErrorLevel(LogLevel)) - { - if (LoggerRef ErrLogger = zen::logging::ErrorLog()) - { - ErrLogger.SpdLogger->log(InLevel, Message); - } - } -} -void -EmitLogMessage(LoggerRef& Logger, int LogLevel, std::string_view Format, fmt::format_args Args) -{ - ZEN_MEMSCOPE(ELLMTag::Logging); - zen::logging::LoggingContext LogCtx; - fmt::vformat_to(fmt::appender(LogCtx.MessageBuffer), Format, Args); - zen::logging::EmitLogMessage(Logger, LogLevel, LogCtx.Message()); -} + Logger->Log(Lp, Args); -void -EmitLogMessage(LoggerRef& Logger, const SourceLocation& InLocation, int LogLevel, const std::string_view Message) -{ - ZEN_MEMSCOPE(ELLMTag::Logging); - const spdlog::source_loc& Location = *reinterpret_cast<const spdlog::source_loc*>(&InLocation); - const spdlog::level::level_enum InLevel = (spdlog::level::level_enum)LogLevel; - Logger.SpdLogger->log(Location, InLevel, Message); - if (IsErrorLevel(LogLevel)) + if (IsErrorLevel(Lp.Level)) { if (LoggerRef ErrLogger = zen::logging::ErrorLog()) { - ErrLogger.SpdLogger->log(Location, InLevel, Message); + ErrLogger->Log(Lp, Args); } } } void -EmitLogMessage(LoggerRef& Logger, const SourceLocation& InLocation, int LogLevel, std::string_view Format, fmt::format_args Args) -{ - ZEN_MEMSCOPE(ELLMTag::Logging); - zen::logging::LoggingContext LogCtx; - fmt::vformat_to(fmt::appender(LogCtx.MessageBuffer), Format, Args); - zen::logging::EmitLogMessage(Logger, InLocation, LogLevel, LogCtx.Message()); -} - -void -EmitConsoleLogMessage(int LogLevel, const std::string_view Message) -{ - ZEN_MEMSCOPE(ELLMTag::Logging); - const spdlog::level::level_enum InLevel = (spdlog::level::level_enum)LogLevel; - ConsoleLog().SpdLogger->log(InLevel, Message); -} - -#define ZEN_COLOR_YELLOW "\033[0;33m" -#define ZEN_COLOR_RED "\033[0;31m" -#define ZEN_BRIGHT_COLOR_RED "\033[1;31m" -#define ZEN_COLOR_RESET "\033[0m" - -void -EmitConsoleLogMessage(int LogLevel, std::string_view Format, fmt::format_args Args) +EmitConsoleLogMessage(const LogPoint& Lp, fmt::format_args Args) { ZEN_MEMSCOPE(ELLMTag::Logging); - zen::logging::LoggingContext LogCtx; - - // We are not using a format option for console which include log level since it would interfere with normal console output - - const spdlog::level::level_enum InLevel = (spdlog::level::level_enum)LogLevel; - switch (InLevel) - { - case spdlog::level::level_enum::warn: - fmt::format_to(fmt::appender(LogCtx.MessageBuffer), ZEN_COLOR_YELLOW "Warning: " ZEN_COLOR_RESET); - break; - case spdlog::level::level_enum::err: - fmt::format_to(fmt::appender(LogCtx.MessageBuffer), ZEN_BRIGHT_COLOR_RED "Error: " ZEN_COLOR_RESET); - break; - case spdlog::level::level_enum::critical: - fmt::format_to(fmt::appender(LogCtx.MessageBuffer), ZEN_COLOR_RED "Critical: " ZEN_COLOR_RESET); - break; - default: - break; - } - fmt::vformat_to(fmt::appender(LogCtx.MessageBuffer), Format, Args); - zen::logging::EmitConsoleLogMessage(LogLevel, LogCtx.Message()); + ConsoleLog()->Log(Lp, Args); } } // namespace zen::logging -namespace zen::logging::level { +namespace zen::logging { -spdlog::level::level_enum -to_spdlog_level(LogLevel NewLogLevel) -{ - return static_cast<spdlog::level::level_enum>((int)NewLogLevel); -} +constinit std::string_view LevelNames[] = {std::string_view("trace", 5), + std::string_view("debug", 5), + std::string_view("info", 4), + std::string_view("warning", 7), + std::string_view("error", 5), + std::string_view("critical", 8), + std::string_view("off", 3)}; LogLevel -to_logging_level(spdlog::level::level_enum NewLogLevel) -{ - return static_cast<LogLevel>((int)NewLogLevel); -} - -constinit std::string_view LevelNames[] = {ZEN_LEVEL_NAME_TRACE, - ZEN_LEVEL_NAME_DEBUG, - ZEN_LEVEL_NAME_INFO, - ZEN_LEVEL_NAME_WARNING, - ZEN_LEVEL_NAME_ERROR, - ZEN_LEVEL_NAME_CRITICAL, - ZEN_LEVEL_NAME_OFF}; - -level::LogLevel ParseLogLevelString(std::string_view Name) { - for (int Level = 0; Level < level::LogLevelCount; ++Level) + for (int Level = 0; Level < LogLevelCount; ++Level) { if (LevelNames[Level] == Name) - return static_cast<level::LogLevel>(Level); + { + return static_cast<LogLevel>(Level); + } } if (Name == "warn") { - return level::Warn; + return Warn; } if (Name == "err") { - return level::Err; + return Err; } - return level::Off; + return Off; } std::string_view -ToStringView(level::LogLevel Level) +ToStringView(LogLevel Level) { - if (int(Level) < level::LogLevelCount) + if (int(Level) < LogLevelCount) { return LevelNames[int(Level)]; } @@ -211,17 +131,17 @@ ToStringView(level::LogLevel Level) return "None"; } -} // namespace zen::logging::level +} // namespace zen::logging ////////////////////////////////////////////////////////////////////////// namespace zen::logging { RwLock LogLevelsLock; -std::string LogLevels[level::LogLevelCount]; +std::string LogLevels[LogLevelCount]; void -ConfigureLogLevels(level::LogLevel Level, std::string_view Loggers) +ConfigureLogLevels(LogLevel Level, std::string_view Loggers) { ZEN_MEMSCOPE(ELLMTag::Logging); @@ -230,18 +150,18 @@ ConfigureLogLevels(level::LogLevel Level, std::string_view Loggers) } void -RefreshLogLevels(level::LogLevel* DefaultLevel) +RefreshLogLevels(LogLevel* DefaultLevel) { ZEN_MEMSCOPE(ELLMTag::Logging); - spdlog::details::registry::log_levels Levels; + std::vector<std::pair<std::string, LogLevel>> Levels; { RwLock::SharedLockScope _(LogLevelsLock); - for (int i = 0; i < level::LogLevelCount; ++i) + for (int i = 0; i < LogLevelCount; ++i) { - level::LogLevel CurrentLevel{i}; + LogLevel CurrentLevel{i}; std::string_view Spec = LogLevels[i]; @@ -260,24 +180,16 @@ RefreshLogLevels(level::LogLevel* DefaultLevel) Spec = {}; } - Levels[LoggerName] = to_spdlog_level(CurrentLevel); + Levels.emplace_back(std::move(LoggerName), CurrentLevel); } } } - if (DefaultLevel) - { - spdlog::level::level_enum SpdDefaultLevel = to_spdlog_level(*DefaultLevel); - spdlog::details::registry::instance().set_levels(Levels, &SpdDefaultLevel); - } - else - { - spdlog::details::registry::instance().set_levels(Levels, nullptr); - } + Registry::Instance().SetLevels(Levels, DefaultLevel); } void -RefreshLogLevels(level::LogLevel DefaultLevel) +RefreshLogLevels(LogLevel DefaultLevel) { RefreshLogLevels(&DefaultLevel); } @@ -289,15 +201,15 @@ RefreshLogLevels() } void -SetLogLevel(level::LogLevel NewLogLevel) +SetLogLevel(LogLevel NewLogLevel) { - spdlog::set_level(to_spdlog_level(NewLogLevel)); + Registry::Instance().SetGlobalLevel(NewLogLevel); } -level::LogLevel +LogLevel GetLogLevel() { - return level::to_logging_level(spdlog::get_level()); + return Registry::Instance().GetGlobalLevel(); } LoggerRef @@ -312,10 +224,10 @@ SetDefault(std::string_view NewDefaultLoggerId) { ZEN_MEMSCOPE(ELLMTag::Logging); - auto NewDefaultLogger = spdlog::get(std::string(NewDefaultLoggerId)); + Ref<Logger> NewDefaultLogger = Registry::Instance().Get(std::string(NewDefaultLoggerId)); ZEN_ASSERT(NewDefaultLogger); - spdlog::set_default_logger(NewDefaultLogger); + Registry::Instance().SetDefaultLogger(NewDefaultLogger); TheDefaultLogger = LoggerRef(*NewDefaultLogger); } @@ -338,11 +250,11 @@ SetErrorLog(std::string_view NewErrorLoggerId) } else { - auto NewErrorLogger = spdlog::get(std::string(NewErrorLoggerId)); + Ref<Logger> NewErrorLogger = Registry::Instance().Get(std::string(NewErrorLoggerId)); ZEN_ASSERT(NewErrorLogger); - TheErrorLogger = LoggerRef(*NewErrorLogger.get()); + TheErrorLogger = LoggerRef(*NewErrorLogger.Get()); } } @@ -353,39 +265,75 @@ Get(std::string_view Name) { ZEN_MEMSCOPE(ELLMTag::Logging); - std::shared_ptr<spdlog::logger> Logger = spdlog::get(std::string(Name)); + Ref<Logger> FoundLogger = Registry::Instance().Get(std::string(Name)); - if (!Logger) + if (!FoundLogger) { g_LoggerMutex.WithExclusiveLock([&] { - Logger = spdlog::get(std::string(Name)); + FoundLogger = Registry::Instance().Get(std::string(Name)); - if (!Logger) + if (!FoundLogger) { - Logger = Default().SpdLogger->clone(std::string(Name)); - spdlog::apply_logger_env_levels(Logger); - spdlog::register_logger(Logger); + FoundLogger = Default()->Clone(std::string(Name)); + Registry::Instance().Register(FoundLogger); } }); } - return *Logger; + return *FoundLogger; } -std::once_flag ConsoleInitFlag; -std::shared_ptr<spdlog::logger> ConLogger; +std::once_flag ConsoleInitFlag; +Ref<Logger> ConLogger; void SuppressConsoleLog() { + ZEN_MEMSCOPE(ELLMTag::Logging); + if (ConLogger) { - spdlog::drop("console"); + Registry::Instance().Drop("console"); ConLogger = {}; } - ConLogger = spdlog::null_logger_mt("console"); + + SinkPtr NullSinkPtr(new NullSink()); + ConLogger = Ref<Logger>(new Logger("console", std::vector<SinkPtr>{NullSinkPtr})); + Registry::Instance().Register(ConLogger); } +#define ZEN_COLOR_YELLOW "\033[0;33m" +#define ZEN_COLOR_RED "\033[0;31m" +#define ZEN_BRIGHT_COLOR_RED "\033[1;31m" +#define ZEN_COLOR_RESET "\033[0m" + +class ConsoleFormatter : public Formatter +{ +public: + void Format(const LogMessage& Msg, MemoryBuffer& Dest) override + { + switch (Msg.GetLevel()) + { + case Warn: + fmt::format_to(fmt::appender(Dest), ZEN_COLOR_YELLOW "Warning: " ZEN_COLOR_RESET); + break; + case Err: + fmt::format_to(fmt::appender(Dest), ZEN_BRIGHT_COLOR_RED "Error: " ZEN_COLOR_RESET); + break; + case Critical: + fmt::format_to(fmt::appender(Dest), ZEN_COLOR_RED "Critical: " ZEN_COLOR_RESET); + break; + default: + break; + } + + helpers::AppendStringView(Msg.GetPayload(), Dest); + Dest.push_back('\n'); + } + + std::unique_ptr<Formatter> Clone() const override { return std::make_unique<ConsoleFormatter>(); } +}; + LoggerRef ConsoleLog() { @@ -394,10 +342,10 @@ ConsoleLog() std::call_once(ConsoleInitFlag, [&] { if (!ConLogger) { - ConLogger = spdlog::stdout_color_mt("console"); - spdlog::apply_logger_env_levels(ConLogger); - - ConLogger->set_pattern("%v"); + SinkPtr ConsoleSink(new AnsiColorStdoutSink()); + ConsoleSink->SetFormatter(std::make_unique<ConsoleFormatter>()); + ConLogger = Ref<Logger>(new Logger("console", std::vector<SinkPtr>{ConsoleSink})); + Registry::Instance().Register(ConLogger); } }); @@ -407,9 +355,11 @@ ConsoleLog() void ResetConsoleLog() { + ZEN_MEMSCOPE(ELLMTag::Logging); + LoggerRef ConLog = ConsoleLog(); - ConLog.SpdLogger->set_pattern("%v"); + ConLog->SetFormatter(std::make_unique<ConsoleFormatter>()); } void @@ -417,13 +367,15 @@ InitializeLogging() { ZEN_MEMSCOPE(ELLMTag::Logging); - TheDefaultLogger = *spdlog::default_logger_raw(); + TheDefaultLogger = *Registry::Instance().DefaultLoggerRaw(); } void ShutdownLogging() { - spdlog::shutdown(); + ZEN_MEMSCOPE(ELLMTag::Logging); + + Registry::Instance().Shutdown(); TheDefaultLogger = {}; } @@ -457,7 +409,7 @@ EnableVTMode() void FlushLogging() { - spdlog::details::registry::instance().flush_all(); + Registry::Instance().FlushAll(); } } // namespace zen::logging @@ -465,21 +417,27 @@ FlushLogging() namespace zen { bool -LoggerRef::ShouldLog(int Level) const +LoggerRef::ShouldLog(logging::LogLevel Level) const { - return SpdLogger->should_log(static_cast<spdlog::level::level_enum>(Level)); + return m_Logger->ShouldLog(Level); } void -LoggerRef::SetLogLevel(logging::level::LogLevel NewLogLevel) +LoggerRef::SetLogLevel(logging::LogLevel NewLogLevel) { - SpdLogger->set_level(to_spdlog_level(NewLogLevel)); + m_Logger->SetLevel(NewLogLevel); } -logging::level::LogLevel +logging::LogLevel LoggerRef::GetLogLevel() { - return logging::level::to_logging_level(SpdLogger->level()); + return m_Logger->GetLevel(); +} + +void +LoggerRef::Flush() +{ + m_Logger->Flush(); } thread_local ScopedActivityBase* t_ScopeStack = nullptr; diff --git a/src/zencore/logging/ansicolorsink.cpp b/src/zencore/logging/ansicolorsink.cpp new file mode 100644 index 000000000..9b9959862 --- /dev/null +++ b/src/zencore/logging/ansicolorsink.cpp @@ -0,0 +1,178 @@ +// Copyright Epic Games, Inc. All Rights Reserved. + +#include <zencore/logging/ansicolorsink.h> +#include <zencore/logging/helpers.h> +#include <zencore/logging/messageonlyformatter.h> + +#include <cstdio> +#include <mutex> + +namespace zen::logging { + +// Default formatter replicating spdlog's %+ pattern: +// [YYYY-MM-DD HH:MM:SS.mmm] [logger_name] [level] message\n +class DefaultConsoleFormatter : public Formatter +{ +public: + void Format(const LogMessage& Msg, MemoryBuffer& Dest) override + { + // timestamp + auto Secs = std::chrono::duration_cast<std::chrono::seconds>(Msg.GetTime().time_since_epoch()); + if (Secs != m_LastLogSecs) + { + m_LastLogSecs = Secs; + m_CachedLocalTm = helpers::SafeLocaltime(LogClock::to_time_t(Msg.GetTime())); + } + + Dest.push_back('['); + helpers::AppendInt(m_CachedLocalTm.tm_year + 1900, Dest); + Dest.push_back('-'); + helpers::Pad2(m_CachedLocalTm.tm_mon + 1, Dest); + Dest.push_back('-'); + helpers::Pad2(m_CachedLocalTm.tm_mday, Dest); + Dest.push_back(' '); + helpers::Pad2(m_CachedLocalTm.tm_hour, Dest); + Dest.push_back(':'); + helpers::Pad2(m_CachedLocalTm.tm_min, Dest); + Dest.push_back(':'); + helpers::Pad2(m_CachedLocalTm.tm_sec, Dest); + Dest.push_back('.'); + auto Millis = helpers::TimeFraction<std::chrono::milliseconds>(Msg.GetTime()); + helpers::Pad3(static_cast<uint32_t>(Millis.count()), Dest); + Dest.push_back(']'); + Dest.push_back(' '); + + // logger name + if (Msg.GetLoggerName().size() > 0) + { + Dest.push_back('['); + helpers::AppendStringView(Msg.GetLoggerName(), Dest); + Dest.push_back(']'); + Dest.push_back(' '); + } + + // level (colored range) + Dest.push_back('['); + Msg.ColorRangeStart = Dest.size(); + helpers::AppendStringView(helpers::LevelToShortString(Msg.GetLevel()), Dest); + Msg.ColorRangeEnd = Dest.size(); + Dest.push_back(']'); + Dest.push_back(' '); + + // message + helpers::AppendStringView(Msg.GetPayload(), Dest); + Dest.push_back('\n'); + } + + std::unique_ptr<Formatter> Clone() const override { return std::make_unique<DefaultConsoleFormatter>(); } + +private: + std::chrono::seconds m_LastLogSecs{0}; + std::tm m_CachedLocalTm{}; +}; + +static constexpr std::string_view s_Reset = "\033[m"; + +static std::string_view +GetColorForLevel(LogLevel InLevel) +{ + using namespace std::string_view_literals; + switch (InLevel) + { + case Trace: + return "\033[37m"sv; // white + case Debug: + return "\033[36m"sv; // cyan + case Info: + return "\033[32m"sv; // green + case Warn: + return "\033[33m\033[1m"sv; // bold yellow + case Err: + return "\033[31m\033[1m"sv; // bold red + case Critical: + return "\033[1m\033[41m"sv; // bold on red background + default: + return s_Reset; + } +} + +struct AnsiColorStdoutSink::Impl +{ + Impl() : m_Formatter(std::make_unique<DefaultConsoleFormatter>()) {} + + void Log(const LogMessage& Msg) + { + std::lock_guard<std::mutex> Lock(m_Mutex); + + MemoryBuffer Formatted; + m_Formatter->Format(Msg, Formatted); + + if (Msg.ColorRangeEnd > Msg.ColorRangeStart) + { + // Print pre-color range + fwrite(Formatted.data(), 1, Msg.ColorRangeStart, m_File); + + // Print color + std::string_view Color = GetColorForLevel(Msg.GetLevel()); + fwrite(Color.data(), 1, Color.size(), m_File); + + // Print colored range + fwrite(Formatted.data() + Msg.ColorRangeStart, 1, Msg.ColorRangeEnd - Msg.ColorRangeStart, m_File); + + // Reset color + fwrite(s_Reset.data(), 1, s_Reset.size(), m_File); + + // Print remainder + fwrite(Formatted.data() + Msg.ColorRangeEnd, 1, Formatted.size() - Msg.ColorRangeEnd, m_File); + } + else + { + fwrite(Formatted.data(), 1, Formatted.size(), m_File); + } + + fflush(m_File); + } + + void Flush() + { + std::lock_guard<std::mutex> Lock(m_Mutex); + fflush(m_File); + } + + void SetFormatter(std::unique_ptr<Formatter> InFormatter) + { + std::lock_guard<std::mutex> Lock(m_Mutex); + m_Formatter = std::move(InFormatter); + } + +private: + std::mutex m_Mutex; + std::unique_ptr<Formatter> m_Formatter; + FILE* m_File = stdout; +}; + +AnsiColorStdoutSink::AnsiColorStdoutSink() : m_Impl(std::make_unique<Impl>()) +{ +} + +AnsiColorStdoutSink::~AnsiColorStdoutSink() = default; + +void +AnsiColorStdoutSink::Log(const LogMessage& Msg) +{ + m_Impl->Log(Msg); +} + +void +AnsiColorStdoutSink::Flush() +{ + m_Impl->Flush(); +} + +void +AnsiColorStdoutSink::SetFormatter(std::unique_ptr<Formatter> InFormatter) +{ + m_Impl->SetFormatter(std::move(InFormatter)); +} + +} // namespace zen::logging diff --git a/src/zencore/logging/asyncsink.cpp b/src/zencore/logging/asyncsink.cpp new file mode 100644 index 000000000..02bf9f3ba --- /dev/null +++ b/src/zencore/logging/asyncsink.cpp @@ -0,0 +1,212 @@ +// Copyright Epic Games, Inc. All Rights Reserved. + +#include <zencore/logging/asyncsink.h> + +#include <zencore/blockingqueue.h> +#include <zencore/logging/logmsg.h> +#include <zencore/thread.h> + +#include <future> +#include <string> +#include <thread> + +namespace zen::logging { + +struct AsyncLogMessage +{ + enum class Type : uint8_t + { + Log, + Flush, + Shutdown + }; + + Type MsgType = Type::Log; + + // Points to the LogPoint from upstream logging code. LogMessage guarantees + // this is always valid (either a static LogPoint from ZEN_LOG macros or one + // of the per-level default LogPoints). + const LogPoint* Point = nullptr; + + int ThreadId = 0; + std::string OwnedPayload; + std::string OwnedLoggerName; + std::chrono::system_clock::time_point Time; + + std::shared_ptr<std::promise<void>> FlushPromise; +}; + +struct AsyncSink::Impl +{ + explicit Impl(std::vector<SinkPtr> InSinks) : m_Sinks(std::move(InSinks)) + { + m_WorkerThread = std::thread([this]() { + zen::SetCurrentThreadName("AsyncLog"); + WorkerLoop(); + }); + } + + ~Impl() + { + AsyncLogMessage ShutdownMsg; + ShutdownMsg.MsgType = AsyncLogMessage::Type::Shutdown; + m_Queue.Enqueue(std::move(ShutdownMsg)); + + if (m_WorkerThread.joinable()) + { + m_WorkerThread.join(); + } + } + + void Log(const LogMessage& Msg) + { + AsyncLogMessage AsyncMsg; + AsyncMsg.OwnedPayload = std::string(Msg.GetPayload()); + AsyncMsg.OwnedLoggerName = std::string(Msg.GetLoggerName()); + AsyncMsg.ThreadId = Msg.GetThreadId(); + AsyncMsg.Time = Msg.GetTime(); + AsyncMsg.Point = &Msg.GetLogPoint(); + AsyncMsg.MsgType = AsyncLogMessage::Type::Log; + + m_Queue.Enqueue(std::move(AsyncMsg)); + } + + void Flush() + { + auto Promise = std::make_shared<std::promise<void>>(); + auto Future = Promise->get_future(); + + AsyncLogMessage FlushMsg; + FlushMsg.MsgType = AsyncLogMessage::Type::Flush; + FlushMsg.FlushPromise = std::move(Promise); + + m_Queue.Enqueue(std::move(FlushMsg)); + + Future.get(); + } + + void SetFormatter(std::unique_ptr<Formatter> InFormatter) + { + for (auto& CurrentSink : m_Sinks) + { + CurrentSink->SetFormatter(InFormatter->Clone()); + } + } + +private: + void ForwardLogToSinks(const AsyncLogMessage& AsyncMsg) + { + LogMessage Reconstructed(*AsyncMsg.Point, AsyncMsg.OwnedLoggerName, AsyncMsg.OwnedPayload); + Reconstructed.SetTime(AsyncMsg.Time); + Reconstructed.SetThreadId(AsyncMsg.ThreadId); + + for (auto& CurrentSink : m_Sinks) + { + if (CurrentSink->ShouldLog(Reconstructed.GetLevel())) + { + try + { + CurrentSink->Log(Reconstructed); + } + catch (const std::exception&) + { + } + } + } + } + + void FlushSinks() + { + for (auto& CurrentSink : m_Sinks) + { + try + { + CurrentSink->Flush(); + } + catch (const std::exception&) + { + } + } + } + + void WorkerLoop() + { + AsyncLogMessage Msg; + while (m_Queue.WaitAndDequeue(Msg)) + { + switch (Msg.MsgType) + { + case AsyncLogMessage::Type::Log: + { + ForwardLogToSinks(Msg); + break; + } + + case AsyncLogMessage::Type::Flush: + { + FlushSinks(); + if (Msg.FlushPromise) + { + Msg.FlushPromise->set_value(); + } + break; + } + + case AsyncLogMessage::Type::Shutdown: + { + m_Queue.CompleteAdding(); + + AsyncLogMessage Remaining; + while (m_Queue.WaitAndDequeue(Remaining)) + { + if (Remaining.MsgType == AsyncLogMessage::Type::Log) + { + ForwardLogToSinks(Remaining); + } + else if (Remaining.MsgType == AsyncLogMessage::Type::Flush) + { + FlushSinks(); + if (Remaining.FlushPromise) + { + Remaining.FlushPromise->set_value(); + } + } + } + + FlushSinks(); + return; + } + } + } + } + + std::vector<SinkPtr> m_Sinks; + BlockingQueue<AsyncLogMessage> m_Queue; + std::thread m_WorkerThread; +}; + +AsyncSink::AsyncSink(std::vector<SinkPtr> InSinks) : m_Impl(std::make_unique<Impl>(std::move(InSinks))) +{ +} + +AsyncSink::~AsyncSink() = default; + +void +AsyncSink::Log(const LogMessage& Msg) +{ + m_Impl->Log(Msg); +} + +void +AsyncSink::Flush() +{ + m_Impl->Flush(); +} + +void +AsyncSink::SetFormatter(std::unique_ptr<Formatter> InFormatter) +{ + m_Impl->SetFormatter(std::move(InFormatter)); +} + +} // namespace zen::logging diff --git a/src/zencore/logging/logger.cpp b/src/zencore/logging/logger.cpp new file mode 100644 index 000000000..dd1675bb1 --- /dev/null +++ b/src/zencore/logging/logger.cpp @@ -0,0 +1,142 @@ +// Copyright Epic Games, Inc. All Rights Reserved. + +#include <zencore/logging/logger.h> +#include <zencore/thread.h> + +#include <string> +#include <vector> + +namespace zen::logging { + +struct Logger::Impl +{ + std::string m_Name; + std::vector<SinkPtr> m_Sinks; + ErrorHandler* m_ErrorHandler = nullptr; +}; + +Logger::Logger(std::string_view InName, SinkPtr InSink) : m_Impl(std::make_unique<Impl>()) +{ + m_Impl->m_Name = InName; + m_Impl->m_Sinks.push_back(std::move(InSink)); +} + +Logger::Logger(std::string_view InName, std::span<const SinkPtr> InSinks) : m_Impl(std::make_unique<Impl>()) +{ + m_Impl->m_Name = InName; + m_Impl->m_Sinks.assign(InSinks.begin(), InSinks.end()); +} + +Logger::~Logger() = default; + +void +Logger::Log(const LogPoint& Point, fmt::format_args Args) +{ + if (!ShouldLog(Point.Level)) + { + return; + } + + fmt::basic_memory_buffer<char, 250> Buffer; + fmt::vformat_to(fmt::appender(Buffer), Point.FormatString, Args); + + LogMessage LogMsg(Point, m_Impl->m_Name, std::string_view(Buffer.data(), Buffer.size())); + LogMsg.SetThreadId(GetCurrentThreadId()); + SinkIt(LogMsg); + FlushIfNeeded(Point.Level); +} + +void +Logger::SinkIt(const LogMessage& Msg) +{ + for (auto& CurrentSink : m_Impl->m_Sinks) + { + if (CurrentSink->ShouldLog(Msg.GetLevel())) + { + try + { + CurrentSink->Log(Msg); + } + catch (const std::exception& Ex) + { + if (m_Impl->m_ErrorHandler) + { + m_Impl->m_ErrorHandler->HandleError(Ex.what()); + } + } + } + } +} + +void +Logger::FlushIfNeeded(LogLevel InLevel) +{ + if (InLevel >= m_FlushLevel.load(std::memory_order_relaxed)) + { + Flush(); + } +} + +void +Logger::Flush() +{ + for (auto& CurrentSink : m_Impl->m_Sinks) + { + try + { + CurrentSink->Flush(); + } + catch (const std::exception& Ex) + { + if (m_Impl->m_ErrorHandler) + { + m_Impl->m_ErrorHandler->HandleError(Ex.what()); + } + } + } +} + +void +Logger::SetSinks(std::vector<SinkPtr> InSinks) +{ + m_Impl->m_Sinks = std::move(InSinks); +} + +void +Logger::AddSink(SinkPtr InSink) +{ + m_Impl->m_Sinks.push_back(std::move(InSink)); +} + +void +Logger::SetErrorHandler(ErrorHandler* Handler) +{ + m_Impl->m_ErrorHandler = Handler; +} + +void +Logger::SetFormatter(std::unique_ptr<Formatter> InFormatter) +{ + for (auto& CurrentSink : m_Impl->m_Sinks) + { + CurrentSink->SetFormatter(InFormatter->Clone()); + } +} + +std::string_view +Logger::Name() const +{ + return m_Impl->m_Name; +} + +Ref<Logger> +Logger::Clone(std::string_view NewName) const +{ + Ref<Logger> Cloned(new Logger(NewName, m_Impl->m_Sinks)); + Cloned->SetLevel(m_Level.load(std::memory_order_relaxed)); + Cloned->SetFlushLevel(m_FlushLevel.load(std::memory_order_relaxed)); + Cloned->SetErrorHandler(m_Impl->m_ErrorHandler); + return Cloned; +} + +} // namespace zen::logging diff --git a/src/zencore/logging/msvcsink.cpp b/src/zencore/logging/msvcsink.cpp new file mode 100644 index 000000000..457a4d6e1 --- /dev/null +++ b/src/zencore/logging/msvcsink.cpp @@ -0,0 +1,80 @@ +// Copyright Epic Games, Inc. All Rights Reserved. + +#include <zencore/zencore.h> + +#if ZEN_PLATFORM_WINDOWS + +# include <zencore/logging/helpers.h> +# include <zencore/logging/messageonlyformatter.h> +# include <zencore/logging/msvcsink.h> + +ZEN_THIRD_PARTY_INCLUDES_START +# include <Windows.h> +ZEN_THIRD_PARTY_INCLUDES_END + +namespace zen::logging { + +// Default formatter for MSVC debug output: [level] message\n +// For error/critical messages with source info, prepends file(line): so that +// the message is clickable in the Visual Studio Output window. +class DefaultMsvcFormatter : public Formatter +{ +public: + void Format(const LogMessage& Msg, MemoryBuffer& Dest) override + { + const auto& Source = Msg.GetSource(); + if (Msg.GetLevel() >= LogLevel::Err && Source) + { + helpers::AppendStringView(Source.Filename, Dest); + Dest.push_back('('); + helpers::AppendInt(Source.Line, Dest); + Dest.push_back(')'); + Dest.push_back(':'); + Dest.push_back(' '); + } + + Dest.push_back('['); + helpers::AppendStringView(helpers::LevelToShortString(Msg.GetLevel()), Dest); + Dest.push_back(']'); + Dest.push_back(' '); + helpers::AppendStringView(Msg.GetPayload(), Dest); + Dest.push_back('\n'); + } + + std::unique_ptr<Formatter> Clone() const override { return std::make_unique<DefaultMsvcFormatter>(); } +}; + +MsvcSink::MsvcSink() : m_Formatter(std::make_unique<DefaultMsvcFormatter>()) +{ +} + +void +MsvcSink::Log(const LogMessage& Msg) +{ + std::lock_guard<std::mutex> Lock(m_Mutex); + + MemoryBuffer Formatted; + m_Formatter->Format(Msg, Formatted); + + // Null-terminate for OutputDebugStringA + Formatted.push_back('\0'); + + OutputDebugStringA(Formatted.data()); +} + +void +MsvcSink::Flush() +{ + // Nothing to flush for OutputDebugString +} + +void +MsvcSink::SetFormatter(std::unique_ptr<Formatter> InFormatter) +{ + std::lock_guard<std::mutex> Lock(m_Mutex); + m_Formatter = std::move(InFormatter); +} + +} // namespace zen::logging + +#endif // ZEN_PLATFORM_WINDOWS diff --git a/src/zencore/logging/registry.cpp b/src/zencore/logging/registry.cpp new file mode 100644 index 000000000..3ed1fb0df --- /dev/null +++ b/src/zencore/logging/registry.cpp @@ -0,0 +1,330 @@ +// Copyright Epic Games, Inc. All Rights Reserved. + +#include <zencore/logging/registry.h> + +#include <zencore/logging/ansicolorsink.h> +#include <zencore/logging/messageonlyformatter.h> + +#include <atomic> +#include <condition_variable> +#include <mutex> +#include <thread> +#include <unordered_map> + +namespace zen::logging { + +struct Registry::Impl +{ + Impl() + { + // Create default logger with a stdout color sink + SinkPtr DefaultSink(new AnsiColorStdoutSink()); + m_DefaultLogger = Ref<Logger>(new Logger("", DefaultSink)); + m_Loggers[""] = m_DefaultLogger; + } + + ~Impl() { StopPeriodicFlush(); } + + void Register(Ref<Logger> InLogger) + { + std::lock_guard<std::mutex> Lock(m_Mutex); + if (m_ErrorHandler) + { + InLogger->SetErrorHandler(m_ErrorHandler); + } + m_Loggers[std::string(InLogger->Name())] = std::move(InLogger); + } + + void Drop(const std::string& Name) + { + std::lock_guard<std::mutex> Lock(m_Mutex); + m_Loggers.erase(Name); + } + + Ref<Logger> Get(const std::string& Name) + { + std::lock_guard<std::mutex> Lock(m_Mutex); + auto It = m_Loggers.find(Name); + if (It != m_Loggers.end()) + { + return It->second; + } + return {}; + } + + void SetDefaultLogger(Ref<Logger> InLogger) + { + std::lock_guard<std::mutex> Lock(m_Mutex); + if (InLogger) + { + m_Loggers[std::string(InLogger->Name())] = InLogger; + } + m_DefaultLogger = std::move(InLogger); + } + + Logger* DefaultLoggerRaw() { return m_DefaultLogger.Get(); } + + Ref<Logger> DefaultLogger() + { + std::lock_guard<std::mutex> Lock(m_Mutex); + return m_DefaultLogger; + } + + void SetGlobalLevel(LogLevel Level) + { + m_GlobalLevel.store(Level, std::memory_order_relaxed); + std::lock_guard<std::mutex> Lock(m_Mutex); + for (auto& [Name, CurLogger] : m_Loggers) + { + CurLogger->SetLevel(Level); + } + } + + LogLevel GetGlobalLevel() const { return m_GlobalLevel.load(std::memory_order_relaxed); } + + void SetLevels(Registry::LogLevels Levels, LogLevel* DefaultLevel) + { + std::lock_guard<std::mutex> Lock(m_Mutex); + + if (DefaultLevel) + { + m_GlobalLevel.store(*DefaultLevel, std::memory_order_relaxed); + for (auto& [Name, CurLogger] : m_Loggers) + { + CurLogger->SetLevel(*DefaultLevel); + } + } + + for (auto& [LoggerName, Level] : Levels) + { + auto It = m_Loggers.find(LoggerName); + if (It != m_Loggers.end()) + { + It->second->SetLevel(Level); + } + } + } + + void FlushAll() + { + std::lock_guard<std::mutex> Lock(m_Mutex); + for (auto& [Name, CurLogger] : m_Loggers) + { + try + { + CurLogger->Flush(); + } + catch (const std::exception&) + { + } + } + } + + void FlushOn(LogLevel Level) + { + std::lock_guard<std::mutex> Lock(m_Mutex); + m_FlushLevel = Level; + for (auto& [Name, CurLogger] : m_Loggers) + { + CurLogger->SetFlushLevel(Level); + } + } + + void FlushEvery(std::chrono::seconds Interval) + { + StopPeriodicFlush(); + + m_PeriodicFlushRunning.store(true, std::memory_order_relaxed); + + m_FlushThread = std::thread([this, Interval] { + while (m_PeriodicFlushRunning.load(std::memory_order_relaxed)) + { + { + std::unique_lock<std::mutex> Lock(m_PeriodicFlushMutex); + m_PeriodicFlushCv.wait_for(Lock, Interval, [this] { return !m_PeriodicFlushRunning.load(std::memory_order_relaxed); }); + } + + if (m_PeriodicFlushRunning.load(std::memory_order_relaxed)) + { + FlushAll(); + } + } + }); + } + + void SetFormatter(std::unique_ptr<Formatter> InFormatter) + { + std::lock_guard<std::mutex> Lock(m_Mutex); + for (auto& [Name, CurLogger] : m_Loggers) + { + CurLogger->SetFormatter(InFormatter->Clone()); + } + } + + void ApplyAll(void (*Func)(void*, Ref<Logger>), void* Context) + { + std::lock_guard<std::mutex> Lock(m_Mutex); + for (auto& [Name, CurLogger] : m_Loggers) + { + Func(Context, CurLogger); + } + } + + void SetErrorHandler(ErrorHandler* Handler) + { + std::lock_guard<std::mutex> Lock(m_Mutex); + m_ErrorHandler = Handler; + for (auto& [Name, CurLogger] : m_Loggers) + { + CurLogger->SetErrorHandler(Handler); + } + } + + void Shutdown() + { + StopPeriodicFlush(); + FlushAll(); + + std::lock_guard<std::mutex> Lock(m_Mutex); + m_Loggers.clear(); + m_DefaultLogger = nullptr; + } + +private: + void StopPeriodicFlush() + { + if (m_FlushThread.joinable()) + { + m_PeriodicFlushRunning.store(false, std::memory_order_relaxed); + { + std::lock_guard<std::mutex> Lock(m_PeriodicFlushMutex); + m_PeriodicFlushCv.notify_one(); + } + m_FlushThread.join(); + } + } + + std::mutex m_Mutex; + std::unordered_map<std::string, Ref<Logger>> m_Loggers; + Ref<Logger> m_DefaultLogger; + std::atomic<LogLevel> m_GlobalLevel{Trace}; + LogLevel m_FlushLevel{Off}; + ErrorHandler* m_ErrorHandler = nullptr; + + // Periodic flush + std::atomic<bool> m_PeriodicFlushRunning{false}; + std::mutex m_PeriodicFlushMutex; + std::condition_variable m_PeriodicFlushCv; + std::thread m_FlushThread; +}; + +Registry& +Registry::Instance() +{ + static Registry s_Instance; + return s_Instance; +} + +Registry::Registry() : m_Impl(std::make_unique<Impl>()) +{ +} + +Registry::~Registry() = default; + +void +Registry::Register(Ref<Logger> InLogger) +{ + m_Impl->Register(std::move(InLogger)); +} + +void +Registry::Drop(const std::string& Name) +{ + m_Impl->Drop(Name); +} + +Ref<Logger> +Registry::Get(const std::string& Name) +{ + return m_Impl->Get(Name); +} + +void +Registry::SetDefaultLogger(Ref<Logger> InLogger) +{ + m_Impl->SetDefaultLogger(std::move(InLogger)); +} + +Logger* +Registry::DefaultLoggerRaw() +{ + return m_Impl->DefaultLoggerRaw(); +} + +Ref<Logger> +Registry::DefaultLogger() +{ + return m_Impl->DefaultLogger(); +} + +void +Registry::SetGlobalLevel(LogLevel Level) +{ + m_Impl->SetGlobalLevel(Level); +} + +LogLevel +Registry::GetGlobalLevel() const +{ + return m_Impl->GetGlobalLevel(); +} + +void +Registry::SetLevels(LogLevels Levels, LogLevel* DefaultLevel) +{ + m_Impl->SetLevels(Levels, DefaultLevel); +} + +void +Registry::FlushAll() +{ + m_Impl->FlushAll(); +} + +void +Registry::FlushOn(LogLevel Level) +{ + m_Impl->FlushOn(Level); +} + +void +Registry::FlushEvery(std::chrono::seconds Interval) +{ + m_Impl->FlushEvery(Interval); +} + +void +Registry::SetFormatter(std::unique_ptr<Formatter> InFormatter) +{ + m_Impl->SetFormatter(std::move(InFormatter)); +} + +void +Registry::ApplyAllImpl(void (*Func)(void*, Ref<Logger>), void* Context) +{ + m_Impl->ApplyAll(Func, Context); +} + +void +Registry::SetErrorHandler(ErrorHandler* Handler) +{ + m_Impl->SetErrorHandler(Handler); +} + +void +Registry::Shutdown() +{ + m_Impl->Shutdown(); +} + +} // namespace zen::logging diff --git a/src/zencore/logging/tracesink.cpp b/src/zencore/logging/tracesink.cpp new file mode 100644 index 000000000..e3533327b --- /dev/null +++ b/src/zencore/logging/tracesink.cpp @@ -0,0 +1,88 @@ + +// Copyright Epic Games, Inc. All Rights Reserved. + +#include <zencore/logbase.h> +#include <zencore/logging/tracesink.h> +#include <zencore/string.h> +#include <zencore/timer.h> +#include <zencore/trace.h> + +namespace zen::logging { + +UE_TRACE_CHANNEL_DEFINE(LogChannel) + +UE_TRACE_EVENT_BEGIN(Logging, LogCategory, NoSync | Important) + UE_TRACE_EVENT_FIELD(const void*, CategoryPointer) + UE_TRACE_EVENT_FIELD(uint8_t, DefaultVerbosity) + UE_TRACE_EVENT_FIELD(UE::Trace::AnsiString, Name) +UE_TRACE_EVENT_END() + +UE_TRACE_EVENT_BEGIN(Logging, LogMessageSpec, NoSync | Important) + UE_TRACE_EVENT_FIELD(const void*, LogPoint) + UE_TRACE_EVENT_FIELD(const void*, CategoryPointer) + UE_TRACE_EVENT_FIELD(int32_t, Line) + UE_TRACE_EVENT_FIELD(uint8_t, Verbosity) + UE_TRACE_EVENT_FIELD(UE::Trace::AnsiString, FileName) + UE_TRACE_EVENT_FIELD(UE::Trace::AnsiString, FormatString) +UE_TRACE_EVENT_END() + +UE_TRACE_EVENT_BEGIN(Logging, LogMessage, NoSync) + UE_TRACE_EVENT_FIELD(const void*, LogPoint) + UE_TRACE_EVENT_FIELD(uint64_t, Cycle) + UE_TRACE_EVENT_FIELD(uint8_t[], FormatArgs) +UE_TRACE_EVENT_END() + +void +TraceLogCategory(const logging::Logger* Category, const char* Name, logging::LogLevel DefaultVerbosity) +{ + uint16_t NameLen = uint16_t(strlen(Name)); + UE_TRACE_LOG(Logging, LogCategory, LogChannel, NameLen * sizeof(ANSICHAR)) + << LogCategory.CategoryPointer(Category) << LogCategory.DefaultVerbosity(uint8_t(DefaultVerbosity)) + << LogCategory.Name(Name, NameLen); +} + +void +TraceLogMessageSpec(const void* LogPoint, + const logging::Logger* Category, + logging::LogLevel Verbosity, + const std::string_view File, + int32_t Line, + const std::string_view Format) +{ + uint16_t FileNameLen = uint16_t(File.size()); + uint16_t FormatStringLen = uint16_t(Format.size()); + uint32_t DataSize = (FileNameLen * sizeof(ANSICHAR)) + (FormatStringLen * sizeof(ANSICHAR)); + UE_TRACE_LOG(Logging, LogMessageSpec, LogChannel, DataSize) + << LogMessageSpec.LogPoint(LogPoint) << LogMessageSpec.CategoryPointer(Category) << LogMessageSpec.Line(Line) + << LogMessageSpec.Verbosity(uint8_t(Verbosity)) << LogMessageSpec.FileName(File.data(), FileNameLen) + << LogMessageSpec.FormatString(Format.data(), FormatStringLen); +} + +void +TraceLogMessageInternal(const void* LogPoint, int32_t EncodedFormatArgsSize, const uint8_t* EncodedFormatArgs) +{ + UE_TRACE_LOG(Logging, LogMessage, LogChannel) << LogMessage.LogPoint(LogPoint) << LogMessage.Cycle(GetHifreqTimerValue()) + << LogMessage.FormatArgs(EncodedFormatArgs, EncodedFormatArgsSize); +} + +////////////////////////////////////////////////////////////////////////// + +void +TraceSink::Log(const LogMessage& Msg) +{ + ZEN_UNUSED(Msg); +} + +void +TraceSink::Flush() +{ +} + +void +TraceSink::SetFormatter(std::unique_ptr<Formatter> /*InFormatter*/) +{ + // This sink doesn't use a formatter since it just forwards the raw format + // args to the trace system +} + +} // namespace zen::logging diff --git a/src/zencore/sentryintegration.cpp b/src/zencore/sentryintegration.cpp index bfff114c3..e39b8438d 100644 --- a/src/zencore/sentryintegration.cpp +++ b/src/zencore/sentryintegration.cpp @@ -4,29 +4,23 @@ #include <zencore/config.h> #include <zencore/logging.h> +#include <zencore/logging/registry.h> +#include <zencore/logging/sink.h> #include <zencore/session.h> #include <zencore/uid.h> #include <stdarg.h> #include <stdio.h> -#if ZEN_PLATFORM_LINUX +#if ZEN_PLATFORM_LINUX || ZEN_PLATFORM_MAC # include <pwd.h> +# include <unistd.h> #endif -#if ZEN_PLATFORM_MAC -# include <pwd.h> -#endif - -ZEN_THIRD_PARTY_INCLUDES_START -#include <spdlog/spdlog.h> -ZEN_THIRD_PARTY_INCLUDES_END - #if ZEN_USE_SENTRY # define SENTRY_BUILD_STATIC 1 ZEN_THIRD_PARTY_INCLUDES_START # include <sentry.h> -# include <spdlog/sinks/base_sink.h> ZEN_THIRD_PARTY_INCLUDES_END namespace sentry { @@ -44,76 +38,58 @@ struct SentryAssertImpl : zen::AssertImpl const zen::CallstackFrames* Callstack) override; }; -class sentry_sink final : public spdlog::sinks::base_sink<spdlog::details::null_mutex> +static constexpr sentry_level_t MapToSentryLevel[zen::logging::LogLevelCount] = {SENTRY_LEVEL_DEBUG, + SENTRY_LEVEL_DEBUG, + SENTRY_LEVEL_INFO, + SENTRY_LEVEL_WARNING, + SENTRY_LEVEL_ERROR, + SENTRY_LEVEL_FATAL, + SENTRY_LEVEL_DEBUG}; + +class SentrySink final : public zen::logging::Sink { public: - sentry_sink(); - ~sentry_sink(); + SentrySink() = default; + ~SentrySink() = default; + + void Log(const zen::logging::LogMessage& Msg) override + { + if (Msg.GetLevel() != zen::logging::Err && Msg.GetLevel() != zen::logging::Critical) + { + return; + } + try + { + std::string Message = fmt::format("{}\n{}({})", Msg.GetPayload(), Msg.GetSource().Filename, Msg.GetSource().Line); + sentry_value_t Event = sentry_value_new_message_event( + /* level */ MapToSentryLevel[Msg.GetLevel()], + /* logger */ nullptr, + /* message */ Message.c_str()); + sentry_event_value_add_stacktrace(Event, NULL, 0); + sentry_capture_event(Event); + } + catch (const std::exception&) + { + // If our logging with Message formatting fails we do a non-allocating version and just post the payload raw + char TmpBuffer[256]; + size_t MaxCopy = zen::Min<size_t>(Msg.GetPayload().size(), size_t(255)); + memcpy(TmpBuffer, Msg.GetPayload().data(), MaxCopy); + TmpBuffer[MaxCopy] = '\0'; + sentry_value_t Event = sentry_value_new_message_event( + /* level */ SENTRY_LEVEL_ERROR, + /* logger */ nullptr, + /* message */ TmpBuffer); + sentry_event_value_add_stacktrace(Event, NULL, 0); + sentry_capture_event(Event); + } + } -protected: - void sink_it_(const spdlog::details::log_msg& msg) override; - void flush_() override; + void Flush() override {} + void SetFormatter(std::unique_ptr<zen::logging::Formatter>) override {} }; ////////////////////////////////////////////////////////////////////////// -static constexpr sentry_level_t MapToSentryLevel[spdlog::level::level_enum::n_levels] = {SENTRY_LEVEL_DEBUG, - SENTRY_LEVEL_DEBUG, - SENTRY_LEVEL_INFO, - SENTRY_LEVEL_WARNING, - SENTRY_LEVEL_ERROR, - SENTRY_LEVEL_FATAL, - SENTRY_LEVEL_DEBUG}; - -sentry_sink::sentry_sink() -{ -} -sentry_sink::~sentry_sink() -{ -} - -void -sentry_sink::sink_it_(const spdlog::details::log_msg& msg) -{ - if (msg.level != spdlog::level::err && msg.level != spdlog::level::critical) - { - return; - } - try - { - auto MaybeNullString = [](const char* Ptr) { return Ptr ? Ptr : "<null>"; }; - std::string Message = fmt::format("{}\n{}({}) [{}]", - msg.payload, - MaybeNullString(msg.source.filename), - msg.source.line, - MaybeNullString(msg.source.funcname)); - sentry_value_t event = sentry_value_new_message_event( - /* level */ MapToSentryLevel[msg.level], - /* logger */ nullptr, - /* message */ Message.c_str()); - sentry_event_value_add_stacktrace(event, NULL, 0); - sentry_capture_event(event); - } - catch (const std::exception&) - { - // If our logging with Message formatting fails we do a non-allocating version and just post the msg.payload raw - char TmpBuffer[256]; - size_t MaxCopy = zen::Min<size_t>(msg.payload.size(), size_t(255)); - memcpy(TmpBuffer, msg.payload.data(), MaxCopy); - TmpBuffer[MaxCopy] = '\0'; - sentry_value_t event = sentry_value_new_message_event( - /* level */ SENTRY_LEVEL_ERROR, - /* logger */ nullptr, - /* message */ TmpBuffer); - sentry_event_value_add_stacktrace(event, NULL, 0); - sentry_capture_event(event); - } -} -void -sentry_sink::flush_() -{ -} - void SentryAssertImpl::OnAssert(const char* Filename, int LineNumber, @@ -340,7 +316,9 @@ SentryIntegration::Initialize(const Config& Conf, const std::string& CommandLine sentry_set_user(SentryUserObject); - m_SentryLogger = spdlog::create<sentry::sentry_sink>("sentry"); + logging::SinkPtr SentrySink(new sentry::SentrySink()); + m_SentryLogger = Ref<logging::Logger>(new logging::Logger("sentry", std::vector<logging::SinkPtr>{SentrySink})); + logging::Registry::Instance().Register(m_SentryLogger); logging::SetErrorLog("sentry"); m_SentryAssert = std::make_unique<sentry::SentryAssertImpl>(); @@ -354,7 +332,7 @@ SentryIntegration::LogStartupInformation() { // Initialize the sentry-sdk log category at Warn level to reduce startup noise. // The level can be overridden via --log-debug=sentry-sdk or --log-info=sentry-sdk - LogSentry.Logger().SetLogLevel(logging::level::Warn); + LogSentry.Logger().SetLogLevel(logging::Warn); if (m_IsInitialized) { diff --git a/src/zencore/testing.cpp b/src/zencore/testing.cpp index 0bae139bd..089e376bb 100644 --- a/src/zencore/testing.cpp +++ b/src/zencore/testing.cpp @@ -143,11 +143,11 @@ TestRunner::ApplyCommandLine(int Argc, char const* const* Argv) { if (Argv[i] == "--debug"sv) { - zen::logging::SetLogLevel(zen::logging::level::Debug); + zen::logging::SetLogLevel(zen::logging::Debug); } else if (Argv[i] == "--verbose"sv) { - zen::logging::SetLogLevel(zen::logging::level::Trace); + zen::logging::SetLogLevel(zen::logging::Trace); } } diff --git a/src/zencore/xmake.lua b/src/zencore/xmake.lua index 2f81b7ec8..171f4c533 100644 --- a/src/zencore/xmake.lua +++ b/src/zencore/xmake.lua @@ -26,7 +26,6 @@ target('zencore') end add_deps("zenbase") - add_deps("spdlog") add_deps("utfcpp") add_deps("oodle") add_deps("blake3") diff --git a/src/zencore/zencore.cpp b/src/zencore/zencore.cpp index d82474705..8c29a8962 100644 --- a/src/zencore/zencore.cpp +++ b/src/zencore/zencore.cpp @@ -147,7 +147,7 @@ AssertImpl::OnAssert(const char* Filename, int LineNumber, const char* FunctionN Message.push_back('\0'); // We use direct ZEN_LOG here instead of ZEN_ERROR as we don't care about *this* code location in the log - ZEN_LOG(Log(), zen::logging::level::Err, "{}", Message.data()); + ZEN_LOG(Log(), zen::logging::Err, "{}", Message.data()); zen::logging::FlushLogging(); } diff --git a/src/zenhttp/servers/httpasio.cpp b/src/zenhttp/servers/httpasio.cpp index 33f182df9..2cf051d14 100644 --- a/src/zenhttp/servers/httpasio.cpp +++ b/src/zenhttp/servers/httpasio.cpp @@ -150,7 +150,7 @@ inline LoggerRef InitLogger() { LoggerRef Logger = logging::Get("asio"); - // Logger.SetLogLevel(logging::level::Trace); + // Logger.SetLogLevel(logging::Trace); return Logger; } @@ -1256,7 +1256,7 @@ HttpServerConnection::HandleRequest() const HttpVerb RequestVerb = Request.RequestVerb(); const std::string_view Uri = Request.RelativeUri(); - if (m_Server.m_RequestLog.ShouldLog(logging::level::Trace)) + if (m_Server.m_RequestLog.ShouldLog(logging::Trace)) { ZEN_LOG_TRACE(m_Server.m_RequestLog, "connection #{} Handling Request: {} {} ({} bytes ({}), accept: {})", diff --git a/src/zenhttp/servers/httpplugin.cpp b/src/zenhttp/servers/httpplugin.cpp index 850dafdca..021b941bd 100644 --- a/src/zenhttp/servers/httpplugin.cpp +++ b/src/zenhttp/servers/httpplugin.cpp @@ -383,7 +383,7 @@ HttpPluginConnectionHandler::HandleRequest() const HttpVerb RequestVerb = Request.RequestVerb(); const std::string_view Uri = Request.RelativeUri(); - if (m_Server->m_RequestLog.ShouldLog(logging::level::Trace)) + if (m_Server->m_RequestLog.ShouldLog(logging::Trace)) { ZEN_LOG_TRACE(m_Server->m_RequestLog, "connection #{} Handling Request: {} {} ({} bytes ({}), accept: {})", @@ -480,7 +480,7 @@ HttpPluginConnectionHandler::HandleRequest() const std::vector<IoBuffer>& ResponseBuffers = Response->ResponseBuffers(); - if (m_Server->m_RequestLog.ShouldLog(logging::level::Trace)) + if (m_Server->m_RequestLog.ShouldLog(logging::Trace)) { m_Server->m_RequestTracer.WriteDebugPayload(fmt::format("response_{}_{}.bin", m_ConnectionId, RequestNumber), ResponseBuffers); diff --git a/src/zenhttp/transports/dlltransport.cpp b/src/zenhttp/transports/dlltransport.cpp index 9135d5425..489324aba 100644 --- a/src/zenhttp/transports/dlltransport.cpp +++ b/src/zenhttp/transports/dlltransport.cpp @@ -72,20 +72,36 @@ DllTransportLogger::DllTransportLogger(std::string_view PluginName) : m_PluginNa void DllTransportLogger::LogMessage(LogLevel PluginLogLevel, const char* Message) { - logging::level::LogLevel Level; - // clang-format off switch (PluginLogLevel) { - case LogLevel::Trace: Level = logging::level::Trace; break; - case LogLevel::Debug: Level = logging::level::Debug; break; - case LogLevel::Info: Level = logging::level::Info; break; - case LogLevel::Warn: Level = logging::level::Warn; break; - case LogLevel::Err: Level = logging::level::Err; break; - case LogLevel::Critical: Level = logging::level::Critical; break; - default: Level = logging::level::Off; break; + case LogLevel::Trace: + ZEN_TRACE("[{}] {}", m_PluginName, Message); + return; + + case LogLevel::Debug: + ZEN_DEBUG("[{}] {}", m_PluginName, Message); + return; + + case LogLevel::Info: + ZEN_INFO("[{}] {}", m_PluginName, Message); + return; + + case LogLevel::Warn: + ZEN_WARN("[{}] {}", m_PluginName, Message); + return; + + case LogLevel::Err: + ZEN_ERROR("[{}] {}", m_PluginName, Message); + return; + + case LogLevel::Critical: + ZEN_CRITICAL("[{}] {}", m_PluginName, Message); + return; + + default: + ZEN_UNUSED(Message); + break; } - // clang-format on - ZEN_LOG(Log(), Level, "[{}] {}", m_PluginName, Message) } uint32_t diff --git a/src/zenremotestore/include/zenremotestore/operationlogoutput.h b/src/zenremotestore/include/zenremotestore/operationlogoutput.h index 6f10ab156..32b95f50f 100644 --- a/src/zenremotestore/include/zenremotestore/operationlogoutput.h +++ b/src/zenremotestore/include/zenremotestore/operationlogoutput.h @@ -11,7 +11,7 @@ class OperationLogOutput { public: virtual ~OperationLogOutput() {} - virtual void EmitLogMessage(int LogLevel, std::string_view Format, fmt::format_args Args) = 0; + virtual void EmitLogMessage(const logging::LogPoint& Point, fmt::format_args Args) = 0; virtual void SetLogOperationName(std::string_view Name) = 0; virtual void SetLogOperationProgress(uint32_t StepIndex, uint32_t StepCount) = 0; @@ -60,19 +60,17 @@ public: OperationLogOutput* CreateStandardLogOutput(LoggerRef Log); -#define ZEN_OPERATION_LOG(OutputTarget, InLevel, fmtstr, ...) \ - do \ - { \ - using namespace std::literals; \ - ZEN_CHECK_FORMAT_STRING(fmtstr##sv, ##__VA_ARGS__); \ - OutputTarget.EmitLogMessage(InLevel, fmtstr, zen::logging::LogCaptureArguments(__VA_ARGS__)); \ +#define ZEN_OPERATION_LOG(OutputTarget, InLevel, fmtstr, ...) \ + do \ + { \ + using namespace std::literals; \ + static constinit zen::logging::LogPoint LogPoint{{}, InLevel, std::string_view(fmtstr)}; \ + ZEN_CHECK_FORMAT_STRING(fmtstr##sv, ##__VA_ARGS__); \ + (OutputTarget).EmitLogMessage(LogPoint, zen::logging::LogCaptureArguments(__VA_ARGS__)); \ } while (false) -#define ZEN_OPERATION_LOG_INFO(OutputTarget, fmtstr, ...) \ - ZEN_OPERATION_LOG((OutputTarget), zen::logging::level::Info, fmtstr, ##__VA_ARGS__) -#define ZEN_OPERATION_LOG_DEBUG(OutputTarget, fmtstr, ...) \ - ZEN_OPERATION_LOG((OutputTarget), zen::logging::level::Debug, fmtstr, ##__VA_ARGS__) -#define ZEN_OPERATION_LOG_WARN(OutputTarget, fmtstr, ...) \ - ZEN_OPERATION_LOG((OutputTarget), zen::logging::level::Warn, fmtstr, ##__VA_ARGS__) +#define ZEN_OPERATION_LOG_INFO(OutputTarget, fmtstr, ...) ZEN_OPERATION_LOG(OutputTarget, zen::logging::Info, fmtstr, ##__VA_ARGS__) +#define ZEN_OPERATION_LOG_DEBUG(OutputTarget, fmtstr, ...) ZEN_OPERATION_LOG(OutputTarget, zen::logging::Debug, fmtstr, ##__VA_ARGS__) +#define ZEN_OPERATION_LOG_WARN(OutputTarget, fmtstr, ...) ZEN_OPERATION_LOG(OutputTarget, zen::logging::Warn, fmtstr, ##__VA_ARGS__) } // namespace zen diff --git a/src/zenremotestore/operationlogoutput.cpp b/src/zenremotestore/operationlogoutput.cpp index 7ed93c947..5ed844c9d 100644 --- a/src/zenremotestore/operationlogoutput.cpp +++ b/src/zenremotestore/operationlogoutput.cpp @@ -3,6 +3,7 @@ #include <zenremotestore/operationlogoutput.h> #include <zencore/logging.h> +#include <zencore/logging/logger.h> ZEN_THIRD_PARTY_INCLUDES_START #include <gsl/gsl-lite.hpp> @@ -30,13 +31,11 @@ class StandardLogOutput : public OperationLogOutput { public: StandardLogOutput(LoggerRef& Log) : m_Log(Log) {} - virtual void EmitLogMessage(int LogLevel, std::string_view Format, fmt::format_args Args) override + virtual void EmitLogMessage(const logging::LogPoint& Point, fmt::format_args Args) override { - if (m_Log.ShouldLog(LogLevel)) + if (m_Log.ShouldLog(Point.Level)) { - fmt::basic_memory_buffer<char, 250> MessageBuffer; - fmt::vformat_to(fmt::appender(MessageBuffer), Format, Args); - ZEN_LOG(m_Log, LogLevel, "{}", std::string_view(MessageBuffer.data(), MessageBuffer.size())); + m_Log->Log(Point, Args); } } @@ -47,7 +46,7 @@ public: } virtual void SetLogOperationProgress(uint32_t StepIndex, uint32_t StepCount) override { - const size_t PercentDone = StepCount > 0u ? gsl::narrow<uint8_t>((100 * StepIndex) / StepCount) : 0u; + [[maybe_unused]] const size_t PercentDone = StepCount > 0u ? gsl::narrow<uint8_t>((100 * StepIndex) / StepCount) : 0u; ZEN_OPERATION_LOG_INFO(*this, "{}: {}%", m_LogOperationName, PercentDone); } virtual uint32_t GetProgressUpdateDelayMS() override { return 2000; } @@ -59,13 +58,14 @@ public: private: LoggerRef m_Log; std::string m_LogOperationName; + LoggerRef Log() { return m_Log; } }; void StandardLogOutputProgressBar::UpdateState(const State& NewState, bool DoLinebreak) { ZEN_UNUSED(DoLinebreak); - const size_t PercentDone = + [[maybe_unused]] const size_t PercentDone = NewState.TotalCount > 0u ? gsl::narrow<uint8_t>((100 * (NewState.TotalCount - NewState.RemainingCount)) / NewState.TotalCount) : 0u; std::string Task = NewState.Task; switch (NewState.Status) diff --git a/src/zenremotestore/projectstore/remoteprojectstore.cpp b/src/zenremotestore/projectstore/remoteprojectstore.cpp index 78f6014df..c8c5f201d 100644 --- a/src/zenremotestore/projectstore/remoteprojectstore.cpp +++ b/src/zenremotestore/projectstore/remoteprojectstore.cpp @@ -246,13 +246,12 @@ namespace remotestore_impl { { public: JobContextLogOutput(JobContext* OptionalContext) : m_OptionalContext(OptionalContext) {} - virtual void EmitLogMessage(int LogLevel, std::string_view Format, fmt::format_args Args) override + virtual void EmitLogMessage(const logging::LogPoint& Point, fmt::format_args Args) override { - ZEN_UNUSED(LogLevel); if (m_OptionalContext) { fmt::basic_memory_buffer<char, 250> MessageBuffer; - fmt::vformat_to(fmt::appender(MessageBuffer), Format, Args); + fmt::vformat_to(fmt::appender(MessageBuffer), Point.FormatString, Args); remotestore_impl::ReportMessage(m_OptionalContext, std::string_view(MessageBuffer.data(), MessageBuffer.size())); } } diff --git a/src/zenserver-test/logging-tests.cpp b/src/zenserver-test/logging-tests.cpp index f284f0371..2e530ff92 100644 --- a/src/zenserver-test/logging-tests.cpp +++ b/src/zenserver-test/logging-tests.cpp @@ -71,7 +71,7 @@ TEST_CASE("logging.file.default") // entry written by the default logger's console sink must therefore not appear // in captured stdout. (The "console" named logger — used by ZEN_CONSOLE_* // macros — may still emit plain-text messages without a level marker, so we -// check for the absence of the full_formatter "[info]" prefix rather than the +// check for the absence of the FullFormatter "[info]" prefix rather than the // message text itself.) TEST_CASE("logging.console.quiet") { diff --git a/src/zenserver-test/zenserver-test.cpp b/src/zenserver-test/zenserver-test.cpp index bd36d731f..8d5400294 100644 --- a/src/zenserver-test/zenserver-test.cpp +++ b/src/zenserver-test/zenserver-test.cpp @@ -9,6 +9,7 @@ # include <zencore/except.h> # include <zencore/fmtutils.h> # include <zencore/logging.h> +# include <zencore/logging/registry.h> # include <zencore/stream.h> # include <zencore/string.h> # include <zencore/testutils.h> @@ -17,7 +18,7 @@ # include <zenhttp/httpclient.h> # include <zenhttp/packageformat.h> # include <zenutil/config/commandlineoptions.h> -# include <zenutil/logging/testformatter.h> +# include <zenutil/logging/fullformatter.h> # include <zenutil/zenserverprocess.h> # include <atomic> @@ -85,8 +86,9 @@ main(int argc, char** argv) zen::logging::InitializeLogging(); - zen::logging::SetLogLevel(zen::logging::level::Debug); - spdlog::set_formatter(std::make_unique<zen::logging::full_test_formatter>("test", std::chrono::system_clock::now())); + zen::logging::SetLogLevel(zen::logging::Debug); + zen::logging::Registry::Instance().SetFormatter( + std::make_unique<zen::logging::FullFormatter>("test", std::chrono::system_clock::now())); std::filesystem::path ProgramBaseDir = GetRunningExecutablePath().parent_path(); std::filesystem::path TestBaseDir = std::filesystem::current_path() / ".test"; diff --git a/src/zenserver/diag/diagsvcs.cpp b/src/zenserver/diag/diagsvcs.cpp index d8d53b0e3..5fa81ff9f 100644 --- a/src/zenserver/diag/diagsvcs.cpp +++ b/src/zenserver/diag/diagsvcs.cpp @@ -12,9 +12,7 @@ #include <fstream> #include <sstream> -ZEN_THIRD_PARTY_INCLUDES_START -#include <spdlog/logger.h> -ZEN_THIRD_PARTY_INCLUDES_END +#include <zencore/logging/logger.h> namespace zen { @@ -64,7 +62,7 @@ HttpHealthService::HttpHealthService() [this](HttpRouterRequest& RoutedReq) { HttpServerRequest& HttpReq = RoutedReq.ServerRequest(); - zen::Log().SpdLogger->flush(); + zen::Log().Flush(); std::filesystem::path Path = [&] { RwLock::SharedLockScope _(m_InfoLock); diff --git a/src/zenserver/diag/logging.cpp b/src/zenserver/diag/logging.cpp index 75a8efc09..178c3d3b5 100644 --- a/src/zenserver/diag/logging.cpp +++ b/src/zenserver/diag/logging.cpp @@ -6,6 +6,8 @@ #include <zencore/filesystem.h> #include <zencore/fmtutils.h> +#include <zencore/logging/logger.h> +#include <zencore/logging/registry.h> #include <zencore/memory/llm.h> #include <zencore/session.h> #include <zencore/string.h> @@ -14,10 +16,6 @@ #include "otlphttp.h" -ZEN_THIRD_PARTY_INCLUDES_START -#include <spdlog/spdlog.h> -ZEN_THIRD_PARTY_INCLUDES_END - namespace zen { void @@ -43,13 +41,12 @@ InitializeServerLogging(const ZenServerConfig& InOptions, bool WithCacheService) std::filesystem::path HttpLogPath = InOptions.DataDir / "logs" / "http.log"; zen::CreateDirectories(HttpLogPath.parent_path()); - auto HttpSink = std::make_shared<zen::logging::RotatingFileSink>(HttpLogPath, - /* max size */ 128 * 1024 * 1024, - /* max files */ 16, - /* rotate on open */ true); - auto HttpLogger = std::make_shared<spdlog::logger>("http_requests", HttpSink); - spdlog::apply_logger_env_levels(HttpLogger); - spdlog::register_logger(HttpLogger); + logging::SinkPtr HttpSink(new zen::logging::RotatingFileSink(HttpLogPath, + /* max size */ 128 * 1024 * 1024, + /* max files */ 16, + /* rotate on open */ true)); + Ref<logging::Logger> HttpLogger(new logging::Logger("http_requests", std::vector<logging::SinkPtr>{HttpSink})); + logging::Registry::Instance().Register(HttpLogger); if (WithCacheService) { @@ -57,33 +54,30 @@ InitializeServerLogging(const ZenServerConfig& InOptions, bool WithCacheService) std::filesystem::path CacheLogPath = InOptions.DataDir / "logs" / "z$.log"; zen::CreateDirectories(CacheLogPath.parent_path()); - auto CacheSink = std::make_shared<zen::logging::RotatingFileSink>(CacheLogPath, - /* max size */ 128 * 1024 * 1024, - /* max files */ 16, - /* rotate on open */ false); - auto CacheLogger = std::make_shared<spdlog::logger>("z$", CacheSink); - spdlog::apply_logger_env_levels(CacheLogger); - spdlog::register_logger(CacheLogger); + logging::SinkPtr CacheSink(new zen::logging::RotatingFileSink(CacheLogPath, + /* max size */ 128 * 1024 * 1024, + /* max files */ 16, + /* rotate on open */ false)); + Ref<logging::Logger> CacheLogger(new logging::Logger("z$", std::vector<logging::SinkPtr>{CacheSink})); + logging::Registry::Instance().Register(CacheLogger); // Jupiter - only log upstream HTTP traffic to file - auto JupiterLogger = std::make_shared<spdlog::logger>("jupiter", FileSink); - spdlog::apply_logger_env_levels(JupiterLogger); - spdlog::register_logger(JupiterLogger); + Ref<logging::Logger> JupiterLogger(new logging::Logger("jupiter", std::vector<logging::SinkPtr>{FileSink})); + logging::Registry::Instance().Register(JupiterLogger); // Zen - only log upstream HTTP traffic to file - auto ZenClientLogger = std::make_shared<spdlog::logger>("zenclient", FileSink); - spdlog::apply_logger_env_levels(ZenClientLogger); - spdlog::register_logger(ZenClientLogger); + Ref<logging::Logger> ZenClientLogger(new logging::Logger("zenclient", std::vector<logging::SinkPtr>{FileSink})); + logging::Registry::Instance().Register(ZenClientLogger); } #if ZEN_WITH_OTEL if (!InOptions.LoggingConfig.OtelEndpointUri.empty()) { // TODO: Should sanity check that endpoint is reachable? Also, a valid URI? - auto OtelSink = std::make_shared<zen::logging::OtelHttpProtobufSink>(InOptions.LoggingConfig.OtelEndpointUri); - zen::logging::Default().SpdLogger->sinks().push_back(std::move(OtelSink)); + logging::SinkPtr OtelSink(new zen::logging::OtelHttpProtobufSink(InOptions.LoggingConfig.OtelEndpointUri)); + zen::logging::Default()->AddSink(std::move(OtelSink)); } #endif @@ -91,9 +85,10 @@ InitializeServerLogging(const ZenServerConfig& InOptions, bool WithCacheService) const zen::Oid ServerSessionId = zen::GetSessionId(); - spdlog::apply_all([&](auto Logger) { + static constinit logging::LogPoint SessionIdPoint{{}, logging::Info, "server session id: {}"}; + logging::Registry::Instance().ApplyAll([&](auto Logger) { ZEN_MEMSCOPE(ELLMTag::Logging); - Logger->info("server session id: {}", ServerSessionId); + Logger->Log(SessionIdPoint, fmt::make_format_args(ServerSessionId)); }); } diff --git a/src/zenserver/diag/otlphttp.cpp b/src/zenserver/diag/otlphttp.cpp index d62ccccb6..1434c9331 100644 --- a/src/zenserver/diag/otlphttp.cpp +++ b/src/zenserver/diag/otlphttp.cpp @@ -53,7 +53,7 @@ OtelHttpProtobufSink::TraceRecorder::RecordSpans(zen::otel::TraceId Trace, std:: } void -OtelHttpProtobufSink::log(const spdlog::details::log_msg& Msg) +OtelHttpProtobufSink::Log(const LogMessage& Msg) { { std::string Data = m_Encoder.FormatOtelProtobuf(Msg); @@ -74,7 +74,7 @@ OtelHttpProtobufSink::log(const spdlog::details::log_msg& Msg) } } void -OtelHttpProtobufSink::flush() +OtelHttpProtobufSink::Flush() { } diff --git a/src/zenserver/diag/otlphttp.h b/src/zenserver/diag/otlphttp.h index 2281bdcc0..8254af04d 100644 --- a/src/zenserver/diag/otlphttp.h +++ b/src/zenserver/diag/otlphttp.h @@ -3,7 +3,7 @@ #pragma once -#include <spdlog/sinks/sink.h> +#include <zencore/logging/sink.h> #include <zencore/zencore.h> #include <zenhttp/httpclient.h> #include <zentelemetry/otlpencoder.h> @@ -14,12 +14,12 @@ namespace zen::logging { /** - * OTLP/HTTP sink for spdlog + * OTLP/HTTP sink for logging * * Sends log messages and traces to an OpenTelemetry collector via OTLP over HTTP */ -class OtelHttpProtobufSink : public spdlog::sinks::sink +class OtelHttpProtobufSink : public Sink { public: // Note that this URI should be the base URI of the OTLP HTTP endpoint, e.g. @@ -31,10 +31,9 @@ public: OtelHttpProtobufSink& operator=(const OtelHttpProtobufSink&) = delete; private: - virtual void log(const spdlog::details::log_msg& Msg) override; - virtual void flush() override; - virtual void set_pattern(const std::string& pattern) override { ZEN_UNUSED(pattern); } - virtual void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override { ZEN_UNUSED(sink_formatter); } + virtual void Log(const LogMessage& Msg) override; + virtual void Flush() override; + virtual void SetFormatter(std::unique_ptr<Formatter>) override {} void RecordSpans(zen::otel::TraceId Trace, std::span<const zen::otel::Span*> Spans); @@ -61,4 +60,4 @@ private: } // namespace zen::logging -#endif
\ No newline at end of file +#endif diff --git a/src/zenserver/main.cpp b/src/zenserver/main.cpp index c764cbde6..09ecc48e5 100644 --- a/src/zenserver/main.cpp +++ b/src/zenserver/main.cpp @@ -246,7 +246,7 @@ test_main(int argc, char** argv) # endif // ZEN_PLATFORM_WINDOWS zen::logging::InitializeLogging(); - zen::logging::SetLogLevel(zen::logging::level::Debug); + zen::logging::SetLogLevel(zen::logging::Debug); zen::MaximizeOpenFileCount(); diff --git a/src/zenserver/storage/admin/admin.cpp b/src/zenserver/storage/admin/admin.cpp index 19155e02b..c9f999c69 100644 --- a/src/zenserver/storage/admin/admin.cpp +++ b/src/zenserver/storage/admin/admin.cpp @@ -716,7 +716,7 @@ HttpAdminService::HttpAdminService(GcScheduler& Scheduler, "logs", [this](HttpRouterRequest& Req) { CbObjectWriter Obj; - auto LogLevel = logging::level::ToStringView(logging::GetLogLevel()); + auto LogLevel = logging::ToStringView(logging::GetLogLevel()); Obj.AddString("loglevel", std::string_view(LogLevel.data(), LogLevel.size())); Obj.AddString("Logfile", PathToUtf8(m_LogPaths.AbsLogPath)); Obj.BeginObject("cache"); @@ -767,8 +767,8 @@ HttpAdminService::HttpAdminService(GcScheduler& Scheduler, } if (std::string Param(Params.GetValue("loglevel")); Param.empty() == false) { - logging::level::LogLevel NewLevel = logging::level::ParseLogLevelString(Param); - std::string_view LogLevel = logging::level::ToStringView(NewLevel); + logging::LogLevel NewLevel = logging::ParseLogLevelString(Param); + std::string_view LogLevel = logging::ToStringView(NewLevel); if (LogLevel != Param) { return Req.ServerRequest().WriteResponse(HttpResponseCode::BadRequest, diff --git a/src/zenstore/projectstore.cpp b/src/zenstore/projectstore.cpp index 3f705d12c..1706c9105 100644 --- a/src/zenstore/projectstore.cpp +++ b/src/zenstore/projectstore.cpp @@ -4360,7 +4360,7 @@ ProjectStore::ProjectStore(CidStore& Store, std::filesystem::path BasePath, GcMa , m_DiskWriteBlocker(Gc.GetDiskWriteBlocker()) { ZEN_INFO("initializing project store at '{}'", m_ProjectBasePath); - // m_Log.set_level(spdlog::level::debug); + // m_Log.SetLogLevel(zen::logging::Debug); m_Gc.AddGcStorage(this); m_Gc.AddGcReferencer(*this); m_Gc.AddGcReferenceLocker(*this); diff --git a/src/zentelemetry/include/zentelemetry/otlpencoder.h b/src/zentelemetry/include/zentelemetry/otlpencoder.h index ed6665781..f280aa9ec 100644 --- a/src/zentelemetry/include/zentelemetry/otlpencoder.h +++ b/src/zentelemetry/include/zentelemetry/otlpencoder.h @@ -13,9 +13,9 @@ # include <protozero/pbf_builder.hpp> # include <protozero/types.hpp> -namespace spdlog { namespace details { - struct log_msg; -}} // namespace spdlog::details +namespace zen::logging { +struct LogMessage; +} // namespace zen::logging namespace zen::otel { enum class Resource : protozero::pbf_tag_type; @@ -46,7 +46,7 @@ public: void AddResourceAttribute(const std::string_view& Key, const std::string_view& Value); void AddResourceAttribute(const std::string_view& Key, int64_t Value); - std::string FormatOtelProtobuf(const spdlog::details::log_msg& Msg) const; + std::string FormatOtelProtobuf(const logging::LogMessage& Msg) const; std::string FormatOtelMetrics() const; std::string FormatOtelTrace(zen::otel::TraceId Trace, std::span<const zen::otel::Span*> Spans) const; diff --git a/src/zentelemetry/otlpencoder.cpp b/src/zentelemetry/otlpencoder.cpp index 677545066..5477c5381 100644 --- a/src/zentelemetry/otlpencoder.cpp +++ b/src/zentelemetry/otlpencoder.cpp @@ -3,9 +3,9 @@ #include "zentelemetry/otlpencoder.h" #include <zenbase/zenbase.h> +#include <zencore/logging/logmsg.h> #include <zentelemetry/otlptrace.h> -#include <spdlog/sinks/sink.h> #include <zencore/testing.h> #include <protozero/buffer_string.hpp> @@ -29,49 +29,49 @@ OtlpEncoder::~OtlpEncoder() } static int -MapSeverity(const spdlog::level::level_enum Level) +MapSeverity(const logging::LogLevel Level) { switch (Level) { - case spdlog::level::critical: + case logging::Critical: return otel::SEVERITY_NUMBER_FATAL; - case spdlog::level::err: + case logging::Err: return otel::SEVERITY_NUMBER_ERROR; - case spdlog::level::warn: + case logging::Warn: return otel::SEVERITY_NUMBER_WARN; - case spdlog::level::info: + case logging::Info: return otel::SEVERITY_NUMBER_INFO; - case spdlog::level::debug: + case logging::Debug: return otel::SEVERITY_NUMBER_DEBUG; default: - case spdlog::level::trace: + case logging::Trace: return otel::SEVERITY_NUMBER_TRACE; } } static const char* -MapSeverityText(const spdlog::level::level_enum Level) +MapSeverityText(const logging::LogLevel Level) { switch (Level) { - case spdlog::level::critical: + case logging::Critical: return "fatal"; - case spdlog::level::err: + case logging::Err: return "error"; - case spdlog::level::warn: + case logging::Warn: return "warn"; - case spdlog::level::info: + case logging::Info: return "info"; - case spdlog::level::debug: + case logging::Debug: return "debug"; default: - case spdlog::level::trace: + case logging::Trace: return "trace"; } } std::string -OtlpEncoder::FormatOtelProtobuf(const spdlog::details::log_msg& Msg) const +OtlpEncoder::FormatOtelProtobuf(const logging::LogMessage& Msg) const { std::string Data; @@ -98,7 +98,7 @@ OtlpEncoder::FormatOtelProtobuf(const spdlog::details::log_msg& Msg) const protozero::pbf_builder<otel::InstrumentationScope> IsBuilder{SlBuilder, otel::ScopeLogs::required_InstrumentationScope_scope}; - IsBuilder.add_string(otel::InstrumentationScope::string_name, Msg.logger_name.data(), Msg.logger_name.size()); + IsBuilder.add_string(otel::InstrumentationScope::string_name, Msg.GetLoggerName().data(), Msg.GetLoggerName().size()); } // LogRecord log_records @@ -106,13 +106,13 @@ OtlpEncoder::FormatOtelProtobuf(const spdlog::details::log_msg& Msg) const protozero::pbf_builder<otel::LogRecord> LrBuilder{SlBuilder, otel::ScopeLogs::required_repeated_LogRecord_log_records}; LrBuilder.add_fixed64(otel::LogRecord::required_fixed64_time_unix_nano, - std::chrono::duration_cast<std::chrono::nanoseconds>(Msg.time.time_since_epoch()).count()); + std::chrono::duration_cast<std::chrono::nanoseconds>(Msg.GetTime().time_since_epoch()).count()); - const int Severity = MapSeverity(Msg.level); + const int Severity = MapSeverity(Msg.GetLevel()); LrBuilder.add_enum(otel::LogRecord::optional_SeverityNumber_severity_number, Severity); - LrBuilder.add_string(otel::LogRecord::optional_string_severity_text, MapSeverityText(Msg.level)); + LrBuilder.add_string(otel::LogRecord::optional_string_severity_text, MapSeverityText(Msg.GetLevel())); otel::TraceId TraceId; const otel::SpanId SpanId = otel::Span::GetCurrentSpanId(TraceId); @@ -127,7 +127,7 @@ OtlpEncoder::FormatOtelProtobuf(const spdlog::details::log_msg& Msg) const { protozero::pbf_builder<otel::AnyValue> BodyBuilder{LrBuilder, otel::LogRecord::optional_anyvalue_body}; - BodyBuilder.add_string(otel::AnyValue::string_string_value, Msg.payload.data(), Msg.payload.size()); + BodyBuilder.add_string(otel::AnyValue::string_string_value, Msg.GetPayload().data(), Msg.GetPayload().size()); } // attributes @@ -139,7 +139,7 @@ OtlpEncoder::FormatOtelProtobuf(const spdlog::details::log_msg& Msg) const { protozero::pbf_builder<otel::AnyValue> AvBuilder{KvBuilder, otel::KeyValue::AnyValue_value}; - AvBuilder.add_int64(otel::AnyValue::int64_int_value, Msg.thread_id); + AvBuilder.add_int64(otel::AnyValue::int64_int_value, Msg.GetThreadId()); } } } diff --git a/src/zentelemetry/xmake.lua b/src/zentelemetry/xmake.lua index 7739c0a08..cd9a18ec4 100644 --- a/src/zentelemetry/xmake.lua +++ b/src/zentelemetry/xmake.lua @@ -6,5 +6,5 @@ target('zentelemetry') add_headerfiles("**.h") add_files("**.cpp") add_includedirs("include", {public=true}) - add_deps("zencore", "protozero", "spdlog") + add_deps("zencore", "protozero") add_deps("robin-map") diff --git a/src/zenutil/config/commandlineoptions.cpp b/src/zenutil/config/commandlineoptions.cpp index 2344354b3..25f5522d8 100644 --- a/src/zenutil/config/commandlineoptions.cpp +++ b/src/zenutil/config/commandlineoptions.cpp @@ -2,6 +2,7 @@ #include <zenutil/config/commandlineoptions.h> +#include <zencore/filesystem.h> #include <zencore/string.h> #include <filesystem> diff --git a/src/zenutil/config/loggingconfig.cpp b/src/zenutil/config/loggingconfig.cpp index 9ec816b1b..5092c60aa 100644 --- a/src/zenutil/config/loggingconfig.cpp +++ b/src/zenutil/config/loggingconfig.cpp @@ -21,13 +21,13 @@ ZenLoggingCmdLineOptions::AddCliOptions(cxxopts::Options& options, ZenLoggingCon ("log-id", "Specify id for adding context to log output", cxxopts::value<std::string>(LoggingConfig.LogId)) ("quiet", "Configure console logger output to level WARN", cxxopts::value<bool>(LoggingConfig.QuietConsole)->default_value("false")) ("noconsole", "Disable console logging", cxxopts::value<bool>(LoggingConfig.NoConsoleOutput)->default_value("false")) - ("log-trace", "Change selected loggers to level TRACE", cxxopts::value<std::string>(LoggingConfig.Loggers[logging::level::Trace])) - ("log-debug", "Change selected loggers to level DEBUG", cxxopts::value<std::string>(LoggingConfig.Loggers[logging::level::Debug])) - ("log-info", "Change selected loggers to level INFO", cxxopts::value<std::string>(LoggingConfig.Loggers[logging::level::Info])) - ("log-warn", "Change selected loggers to level WARN", cxxopts::value<std::string>(LoggingConfig.Loggers[logging::level::Warn])) - ("log-error", "Change selected loggers to level ERROR", cxxopts::value<std::string>(LoggingConfig.Loggers[logging::level::Err])) - ("log-critical", "Change selected loggers to level CRITICAL", cxxopts::value<std::string>(LoggingConfig.Loggers[logging::level::Critical])) - ("log-off", "Change selected loggers to level OFF", cxxopts::value<std::string>(LoggingConfig.Loggers[logging::level::Off])) + ("log-trace", "Change selected loggers to level TRACE", cxxopts::value<std::string>(LoggingConfig.Loggers[logging::Trace])) + ("log-debug", "Change selected loggers to level DEBUG", cxxopts::value<std::string>(LoggingConfig.Loggers[logging::Debug])) + ("log-info", "Change selected loggers to level INFO", cxxopts::value<std::string>(LoggingConfig.Loggers[logging::Info])) + ("log-warn", "Change selected loggers to level WARN", cxxopts::value<std::string>(LoggingConfig.Loggers[logging::Warn])) + ("log-error", "Change selected loggers to level ERROR", cxxopts::value<std::string>(LoggingConfig.Loggers[logging::Err])) + ("log-critical", "Change selected loggers to level CRITICAL", cxxopts::value<std::string>(LoggingConfig.Loggers[logging::Critical])) + ("log-off", "Change selected loggers to level OFF", cxxopts::value<std::string>(LoggingConfig.Loggers[logging::Off])) ("otlp-endpoint", "OpenTelemetry endpoint URI (e.g http://localhost:4318)", cxxopts::value<std::string>(LoggingConfig.OtelEndpointUri)) ; // clang-format on @@ -47,7 +47,7 @@ ApplyLoggingOptions(cxxopts::Options& options, ZenLoggingConfig& LoggingConfig) if (LoggingConfig.QuietConsole) { bool HasExplicitConsoleLevel = false; - for (int i = 0; i < logging::level::LogLevelCount; ++i) + for (int i = 0; i < logging::LogLevelCount; ++i) { if (LoggingConfig.Loggers[i].find("console") != std::string::npos) { @@ -58,7 +58,7 @@ ApplyLoggingOptions(cxxopts::Options& options, ZenLoggingConfig& LoggingConfig) if (!HasExplicitConsoleLevel) { - std::string& WarnLoggers = LoggingConfig.Loggers[logging::level::Warn]; + std::string& WarnLoggers = LoggingConfig.Loggers[logging::Warn]; if (!WarnLoggers.empty()) { WarnLoggers += ","; @@ -67,9 +67,9 @@ ApplyLoggingOptions(cxxopts::Options& options, ZenLoggingConfig& LoggingConfig) } } - for (int i = 0; i < logging::level::LogLevelCount; ++i) + for (int i = 0; i < logging::LogLevelCount; ++i) { - logging::ConfigureLogLevels(logging::level::LogLevel(i), LoggingConfig.Loggers[i]); + logging::ConfigureLogLevels(logging::LogLevel(i), LoggingConfig.Loggers[i]); } logging::RefreshLogLevels(); } diff --git a/src/zenutil/include/zenutil/config/loggingconfig.h b/src/zenutil/include/zenutil/config/loggingconfig.h index 6d6f64b30..b55b2d9f7 100644 --- a/src/zenutil/include/zenutil/config/loggingconfig.h +++ b/src/zenutil/include/zenutil/config/loggingconfig.h @@ -17,7 +17,7 @@ struct ZenLoggingConfig bool NoConsoleOutput = false; // Control default use of stdout for diagnostics bool QuietConsole = false; // Configure console logger output to level WARN std::filesystem::path AbsLogFile; // Absolute path to main log file - std::string Loggers[logging::level::LogLevelCount]; + std::string Loggers[logging::LogLevelCount]; std::string LogId; // Id for tagging log output std::string OtelEndpointUri; // OpenTelemetry endpoint URI }; diff --git a/src/zenutil/include/zenutil/logging.h b/src/zenutil/include/zenutil/logging.h index 85ddc86cd..95419c274 100644 --- a/src/zenutil/include/zenutil/logging.h +++ b/src/zenutil/include/zenutil/logging.h @@ -3,19 +3,12 @@ #pragma once #include <zencore/logging.h> +#include <zencore/logging/sink.h> #include <filesystem> #include <memory> #include <string> -namespace spdlog::sinks { -class sink; -} - -namespace spdlog { -using sink_ptr = std::shared_ptr<sinks::sink>; -} - ////////////////////////////////////////////////////////////////////////// // // Logging utilities @@ -45,6 +38,6 @@ void FinishInitializeLogging(const LoggingOptions& LoggingOptions); void InitializeLogging(const LoggingOptions& LoggingOptions); void ShutdownLogging(); -spdlog::sink_ptr GetFileSink(); +logging::SinkPtr GetFileSink(); } // namespace zen diff --git a/src/zenutil/include/zenutil/logging/fullformatter.h b/src/zenutil/include/zenutil/logging/fullformatter.h index 9f245becd..33cb94dae 100644 --- a/src/zenutil/include/zenutil/logging/fullformatter.h +++ b/src/zenutil/include/zenutil/logging/fullformatter.h @@ -2,21 +2,19 @@ #pragma once +#include <zencore/logging/formatter.h> +#include <zencore/logging/helpers.h> #include <zencore/memory/llm.h> #include <zencore/zencore.h> #include <string_view> -ZEN_THIRD_PARTY_INCLUDES_START -#include <spdlog/formatter.h> -ZEN_THIRD_PARTY_INCLUDES_END - namespace zen::logging { -class full_formatter final : public spdlog::formatter +class FullFormatter final : public Formatter { public: - full_formatter(std::string_view LogId, std::chrono::time_point<std::chrono::system_clock> Epoch) + FullFormatter(std::string_view LogId, std::chrono::time_point<std::chrono::system_clock> Epoch) : m_Epoch(Epoch) , m_LogId(LogId) , m_LinePrefix(128, ' ') @@ -24,16 +22,19 @@ public: { } - full_formatter(std::string_view LogId) : m_LogId(LogId), m_LinePrefix(128, ' '), m_UseFullDate(true) {} + FullFormatter(std::string_view LogId) : m_LogId(LogId), m_LinePrefix(128, ' '), m_UseFullDate(true) {} - virtual std::unique_ptr<formatter> clone() const override + virtual std::unique_ptr<Formatter> Clone() const override { ZEN_MEMSCOPE(ELLMTag::Logging); - // Note: this does not properly clone m_UseFullDate - return std::make_unique<full_formatter>(m_LogId, m_Epoch); + if (m_UseFullDate) + { + return std::make_unique<FullFormatter>(m_LogId); + } + return std::make_unique<FullFormatter>(m_LogId, m_Epoch); } - virtual void format(const spdlog::details::log_msg& msg, spdlog::memory_buf_t& OutBuffer) override + virtual void Format(const LogMessage& Msg, MemoryBuffer& OutBuffer) override { ZEN_MEMSCOPE(ELLMTag::Logging); @@ -44,38 +45,38 @@ public: std::chrono::seconds TimestampSeconds; - std::chrono::milliseconds millis; + std::chrono::milliseconds Millis; if (m_UseFullDate) { - TimestampSeconds = std::chrono::duration_cast<std::chrono::seconds>(msg.time.time_since_epoch()); + TimestampSeconds = std::chrono::duration_cast<std::chrono::seconds>(Msg.GetTime().time_since_epoch()); if (TimestampSeconds != m_LastLogSecs) { RwLock::ExclusiveLockScope _(m_TimestampLock); m_LastLogSecs = TimestampSeconds; - m_CachedLocalTm = spdlog::details::os::localtime(spdlog::log_clock::to_time_t(msg.time)); + m_CachedLocalTm = helpers::SafeLocaltime(LogClock::to_time_t(Msg.GetTime())); m_CachedDatetime.clear(); m_CachedDatetime.push_back('['); - spdlog::details::fmt_helper::pad2(m_CachedLocalTm.tm_year % 100, m_CachedDatetime); + helpers::Pad2(m_CachedLocalTm.tm_year % 100, m_CachedDatetime); m_CachedDatetime.push_back('-'); - spdlog::details::fmt_helper::pad2(m_CachedLocalTm.tm_mon + 1, m_CachedDatetime); + helpers::Pad2(m_CachedLocalTm.tm_mon + 1, m_CachedDatetime); m_CachedDatetime.push_back('-'); - spdlog::details::fmt_helper::pad2(m_CachedLocalTm.tm_mday, m_CachedDatetime); + helpers::Pad2(m_CachedLocalTm.tm_mday, m_CachedDatetime); m_CachedDatetime.push_back(' '); - spdlog::details::fmt_helper::pad2(m_CachedLocalTm.tm_hour, m_CachedDatetime); + helpers::Pad2(m_CachedLocalTm.tm_hour, m_CachedDatetime); m_CachedDatetime.push_back(':'); - spdlog::details::fmt_helper::pad2(m_CachedLocalTm.tm_min, m_CachedDatetime); + helpers::Pad2(m_CachedLocalTm.tm_min, m_CachedDatetime); m_CachedDatetime.push_back(':'); - spdlog::details::fmt_helper::pad2(m_CachedLocalTm.tm_sec, m_CachedDatetime); + helpers::Pad2(m_CachedLocalTm.tm_sec, m_CachedDatetime); m_CachedDatetime.push_back('.'); } - millis = spdlog::details::fmt_helper::time_fraction<std::chrono::milliseconds>(msg.time); + Millis = helpers::TimeFraction<std::chrono::milliseconds>(Msg.GetTime()); } else { - auto ElapsedTime = msg.time - m_Epoch; + auto ElapsedTime = Msg.GetTime() - m_Epoch; TimestampSeconds = std::chrono::duration_cast<std::chrono::seconds>(ElapsedTime); if (m_CacheTimestamp.load() != TimestampSeconds) @@ -93,15 +94,15 @@ public: m_CachedDatetime.clear(); m_CachedDatetime.push_back('['); - spdlog::details::fmt_helper::pad2(LogHours, m_CachedDatetime); + helpers::Pad2(LogHours, m_CachedDatetime); m_CachedDatetime.push_back(':'); - spdlog::details::fmt_helper::pad2(LogMins, m_CachedDatetime); + helpers::Pad2(LogMins, m_CachedDatetime); m_CachedDatetime.push_back(':'); - spdlog::details::fmt_helper::pad2(LogSecs, m_CachedDatetime); + helpers::Pad2(LogSecs, m_CachedDatetime); m_CachedDatetime.push_back('.'); } - millis = std::chrono::duration_cast<std::chrono::milliseconds>(ElapsedTime - TimestampSeconds); + Millis = std::chrono::duration_cast<std::chrono::milliseconds>(ElapsedTime - TimestampSeconds); } { @@ -109,44 +110,43 @@ public: OutBuffer.append(m_CachedDatetime.begin(), m_CachedDatetime.end()); } - spdlog::details::fmt_helper::pad3(static_cast<uint32_t>(millis.count()), OutBuffer); + helpers::Pad3(static_cast<uint32_t>(Millis.count()), OutBuffer); OutBuffer.push_back(']'); OutBuffer.push_back(' '); if (!m_LogId.empty()) { OutBuffer.push_back('['); - spdlog::details::fmt_helper::append_string_view(m_LogId, OutBuffer); + helpers::AppendStringView(m_LogId, OutBuffer); OutBuffer.push_back(']'); OutBuffer.push_back(' '); } // append logger name if exists - if (msg.logger_name.size() > 0) + if (Msg.GetLoggerName().size() > 0) { OutBuffer.push_back('['); - spdlog::details::fmt_helper::append_string_view(msg.logger_name, OutBuffer); + helpers::AppendStringView(Msg.GetLoggerName(), OutBuffer); OutBuffer.push_back(']'); OutBuffer.push_back(' '); } OutBuffer.push_back('['); // wrap the level name with color - msg.color_range_start = OutBuffer.size(); - spdlog::details::fmt_helper::append_string_view(spdlog::level::to_string_view(msg.level), OutBuffer); - msg.color_range_end = OutBuffer.size(); + Msg.ColorRangeStart = OutBuffer.size(); + helpers::AppendStringView(helpers::LevelToShortString(Msg.GetLevel()), OutBuffer); + Msg.ColorRangeEnd = OutBuffer.size(); OutBuffer.push_back(']'); OutBuffer.push_back(' '); // add source location if present - if (!msg.source.empty()) + if (Msg.GetSource()) { OutBuffer.push_back('['); - const char* filename = - spdlog::details::short_filename_formatter<spdlog::details::null_scoped_padder>::basename(msg.source.filename); - spdlog::details::fmt_helper::append_string_view(filename, OutBuffer); + const char* Filename = helpers::ShortFilename(Msg.GetSource().Filename); + helpers::AppendStringView(Filename, OutBuffer); OutBuffer.push_back(':'); - spdlog::details::fmt_helper::append_int(msg.source.line, OutBuffer); + helpers::AppendInt(Msg.GetSource().Line, OutBuffer); OutBuffer.push_back(']'); OutBuffer.push_back(' '); } @@ -156,8 +156,9 @@ public: const size_t LinePrefixCount = Min<size_t>(OutBuffer.size(), m_LinePrefix.size()); - auto ItLineBegin = msg.payload.begin(); - auto ItMessageEnd = msg.payload.end(); + auto MsgPayload = Msg.GetPayload(); + auto ItLineBegin = MsgPayload.begin(); + auto ItMessageEnd = MsgPayload.end(); bool IsFirstline = true; { @@ -170,9 +171,9 @@ public: } else { - spdlog::details::fmt_helper::append_string_view(std::string_view(m_LinePrefix.data(), LinePrefixCount), OutBuffer); + helpers::AppendStringView(std::string_view(m_LinePrefix.data(), LinePrefixCount), OutBuffer); } - spdlog::details::fmt_helper::append_string_view(spdlog::string_view_t(&*ItLineBegin, ItLineEnd - ItLineBegin), OutBuffer); + helpers::AppendStringView(std::string_view(&*ItLineBegin, ItLineEnd - ItLineBegin), OutBuffer); }; while (ItLineEnd != ItMessageEnd) @@ -187,7 +188,7 @@ public: if (ItLineBegin != ItMessageEnd) { EmitLine(); - spdlog::details::fmt_helper::append_string_view("\n"sv, OutBuffer); + helpers::AppendStringView("\n"sv, OutBuffer); } } } @@ -197,7 +198,7 @@ private: std::tm m_CachedLocalTm; std::chrono::seconds m_LastLogSecs{std::chrono::seconds(87654321)}; std::atomic<std::chrono::seconds> m_CacheTimestamp{std::chrono::seconds(87654321)}; - spdlog::memory_buf_t m_CachedDatetime; + MemoryBuffer m_CachedDatetime; std::string m_LogId; std::string m_LinePrefix; bool m_UseFullDate = true; diff --git a/src/zenutil/include/zenutil/logging/jsonformatter.h b/src/zenutil/include/zenutil/logging/jsonformatter.h index 3f660e421..216b1b5e5 100644 --- a/src/zenutil/include/zenutil/logging/jsonformatter.h +++ b/src/zenutil/include/zenutil/logging/jsonformatter.h @@ -2,27 +2,26 @@ #pragma once +#include <zencore/logging/formatter.h> +#include <zencore/logging/helpers.h> #include <zencore/memory/llm.h> #include <zencore/zencore.h> #include <string_view> - -ZEN_THIRD_PARTY_INCLUDES_START -#include <spdlog/formatter.h> -ZEN_THIRD_PARTY_INCLUDES_END +#include <unordered_map> namespace zen::logging { using namespace std::literals; -class json_formatter final : public spdlog::formatter +class JsonFormatter final : public Formatter { public: - json_formatter(std::string_view LogId) : m_LogId(LogId) {} + JsonFormatter(std::string_view LogId) : m_LogId(LogId) {} - virtual std::unique_ptr<formatter> clone() const override { return std::make_unique<json_formatter>(m_LogId); } + virtual std::unique_ptr<Formatter> Clone() const override { return std::make_unique<JsonFormatter>(m_LogId); } - virtual void format(const spdlog::details::log_msg& msg, spdlog::memory_buf_t& dest) override + virtual void Format(const LogMessage& Msg, MemoryBuffer& Dest) override { ZEN_MEMSCOPE(ELLMTag::Logging); @@ -30,141 +29,132 @@ public: using std::chrono::milliseconds; using std::chrono::seconds; - auto secs = std::chrono::duration_cast<seconds>(msg.time.time_since_epoch()); - if (secs != m_LastLogSecs) + auto Secs = std::chrono::duration_cast<seconds>(Msg.GetTime().time_since_epoch()); + if (Secs != m_LastLogSecs) { - m_CachedTm = spdlog::details::os::localtime(spdlog::log_clock::to_time_t(msg.time)); - m_LastLogSecs = secs; - } - - const auto& tm_time = m_CachedTm; + RwLock::ExclusiveLockScope _(m_TimestampLock); + m_CachedTm = helpers::SafeLocaltime(LogClock::to_time_t(Msg.GetTime())); + m_LastLogSecs = Secs; - // cache the date/time part for the next second. - - if (m_CacheTimestamp != secs || m_CachedDatetime.size() == 0) - { + // cache the date/time part for the next second. m_CachedDatetime.clear(); - spdlog::details::fmt_helper::append_int(tm_time.tm_year + 1900, m_CachedDatetime); + helpers::AppendInt(m_CachedTm.tm_year + 1900, m_CachedDatetime); m_CachedDatetime.push_back('-'); - spdlog::details::fmt_helper::pad2(tm_time.tm_mon + 1, m_CachedDatetime); + helpers::Pad2(m_CachedTm.tm_mon + 1, m_CachedDatetime); m_CachedDatetime.push_back('-'); - spdlog::details::fmt_helper::pad2(tm_time.tm_mday, m_CachedDatetime); + helpers::Pad2(m_CachedTm.tm_mday, m_CachedDatetime); m_CachedDatetime.push_back(' '); - spdlog::details::fmt_helper::pad2(tm_time.tm_hour, m_CachedDatetime); + helpers::Pad2(m_CachedTm.tm_hour, m_CachedDatetime); m_CachedDatetime.push_back(':'); - spdlog::details::fmt_helper::pad2(tm_time.tm_min, m_CachedDatetime); + helpers::Pad2(m_CachedTm.tm_min, m_CachedDatetime); m_CachedDatetime.push_back(':'); - spdlog::details::fmt_helper::pad2(tm_time.tm_sec, m_CachedDatetime); + helpers::Pad2(m_CachedTm.tm_sec, m_CachedDatetime); m_CachedDatetime.push_back('.'); - - m_CacheTimestamp = secs; } - dest.append("{"sv); - dest.append("\"time\": \""sv); - dest.append(m_CachedDatetime.begin(), m_CachedDatetime.end()); - auto millis = spdlog::details::fmt_helper::time_fraction<milliseconds>(msg.time); - spdlog::details::fmt_helper::pad3(static_cast<uint32_t>(millis.count()), dest); - dest.append("\", "sv); + helpers::AppendStringView("{"sv, Dest); + helpers::AppendStringView("\"time\": \""sv, Dest); + { + RwLock::SharedLockScope _(m_TimestampLock); + Dest.append(m_CachedDatetime.begin(), m_CachedDatetime.end()); + } + auto Millis = helpers::TimeFraction<milliseconds>(Msg.GetTime()); + helpers::Pad3(static_cast<uint32_t>(Millis.count()), Dest); + helpers::AppendStringView("\", "sv, Dest); - dest.append("\"status\": \""sv); - dest.append(spdlog::level::to_string_view(msg.level)); - dest.append("\", "sv); + helpers::AppendStringView("\"status\": \""sv, Dest); + helpers::AppendStringView(helpers::LevelToShortString(Msg.GetLevel()), Dest); + helpers::AppendStringView("\", "sv, Dest); - dest.append("\"source\": \""sv); - dest.append("zenserver"sv); - dest.append("\", "sv); + helpers::AppendStringView("\"source\": \""sv, Dest); + helpers::AppendStringView("zenserver"sv, Dest); + helpers::AppendStringView("\", "sv, Dest); - dest.append("\"service\": \""sv); - dest.append("zencache"sv); - dest.append("\", "sv); + helpers::AppendStringView("\"service\": \""sv, Dest); + helpers::AppendStringView("zencache"sv, Dest); + helpers::AppendStringView("\", "sv, Dest); if (!m_LogId.empty()) { - dest.append("\"id\": \""sv); - dest.append(m_LogId); - dest.append("\", "sv); + helpers::AppendStringView("\"id\": \""sv, Dest); + helpers::AppendStringView(m_LogId, Dest); + helpers::AppendStringView("\", "sv, Dest); } - if (msg.logger_name.size() > 0) + if (Msg.GetLoggerName().size() > 0) { - dest.append("\"logger.name\": \""sv); - dest.append(msg.logger_name); - dest.append("\", "sv); + helpers::AppendStringView("\"logger.name\": \""sv, Dest); + helpers::AppendStringView(Msg.GetLoggerName(), Dest); + helpers::AppendStringView("\", "sv, Dest); } - if (msg.thread_id != 0) + if (Msg.GetThreadId() != 0) { - dest.append("\"logger.thread_name\": \""sv); - spdlog::details::fmt_helper::pad_uint(msg.thread_id, 0, dest); - dest.append("\", "sv); + helpers::AppendStringView("\"logger.thread_name\": \""sv, Dest); + helpers::PadUint(Msg.GetThreadId(), 0, Dest); + helpers::AppendStringView("\", "sv, Dest); } - if (!msg.source.empty()) + if (Msg.GetSource()) { - dest.append("\"file\": \""sv); - WriteEscapedString( - dest, - spdlog::details::short_filename_formatter<spdlog::details::null_scoped_padder>::basename(msg.source.filename)); - dest.append("\","sv); - - dest.append("\"line\": \""sv); - dest.append(fmt::format("{}", msg.source.line)); - dest.append("\","sv); - - dest.append("\"logger.method_name\": \""sv); - WriteEscapedString(dest, msg.source.funcname); - dest.append("\", "sv); + helpers::AppendStringView("\"file\": \""sv, Dest); + WriteEscapedString(Dest, helpers::ShortFilename(Msg.GetSource().Filename)); + helpers::AppendStringView("\","sv, Dest); + + helpers::AppendStringView("\"line\": \""sv, Dest); + helpers::AppendInt(Msg.GetSource().Line, Dest); + helpers::AppendStringView("\","sv, Dest); } - dest.append("\"message\": \""sv); - WriteEscapedString(dest, msg.payload); - dest.append("\""sv); + helpers::AppendStringView("\"message\": \""sv, Dest); + WriteEscapedString(Dest, Msg.GetPayload()); + helpers::AppendStringView("\""sv, Dest); - dest.append("}\n"sv); + helpers::AppendStringView("}\n"sv, Dest); } private: - static inline const std::unordered_map<char, std::string_view> SpecialCharacterMap{{'\b', "\\b"sv}, - {'\f', "\\f"sv}, - {'\n', "\\n"sv}, - {'\r', "\\r"sv}, - {'\t', "\\t"sv}, - {'"', "\\\""sv}, - {'\\', "\\\\"sv}}; - - static void WriteEscapedString(spdlog::memory_buf_t& dest, const spdlog::string_view_t& payload) + static inline const std::unordered_map<char, std::string_view> s_SpecialCharacterMap{{'\b', "\\b"sv}, + {'\f', "\\f"sv}, + {'\n', "\\n"sv}, + {'\r', "\\r"sv}, + {'\t', "\\t"sv}, + {'"', "\\\""sv}, + {'\\', "\\\\"sv}}; + + static void WriteEscapedString(MemoryBuffer& Dest, const std::string_view& Text) { - const char* RangeStart = payload.begin(); - for (const char* It = RangeStart; It != payload.end(); ++It) + const char* RangeStart = Text.data(); + const char* End = Text.data() + Text.size(); + for (const char* It = RangeStart; It != End; ++It) { - if (auto SpecialIt = SpecialCharacterMap.find(*It); SpecialIt != SpecialCharacterMap.end()) + if (auto SpecialIt = s_SpecialCharacterMap.find(*It); SpecialIt != s_SpecialCharacterMap.end()) { if (RangeStart != It) { - dest.append(RangeStart, It); + Dest.append(RangeStart, It); } - dest.append(SpecialIt->second); + helpers::AppendStringView(SpecialIt->second, Dest); RangeStart = It + 1; } } - if (RangeStart != payload.end()) + if (RangeStart != End) { - dest.append(RangeStart, payload.end()); + Dest.append(RangeStart, End); } }; std::tm m_CachedTm{0, 0, 0, 0, 0, 0, 0, 0, 0}; std::chrono::seconds m_LastLogSecs{0}; - std::chrono::seconds m_CacheTimestamp{0}; - spdlog::memory_buf_t m_CachedDatetime; + MemoryBuffer m_CachedDatetime; std::string m_LogId; + RwLock m_TimestampLock; }; } // namespace zen::logging diff --git a/src/zenutil/include/zenutil/logging/rotatingfilesink.h b/src/zenutil/include/zenutil/logging/rotatingfilesink.h index 8901b7779..cebc5b110 100644 --- a/src/zenutil/include/zenutil/logging/rotatingfilesink.h +++ b/src/zenutil/include/zenutil/logging/rotatingfilesink.h @@ -3,14 +3,11 @@ #pragma once #include <zencore/basicfile.h> +#include <zencore/logging/formatter.h> +#include <zencore/logging/messageonlyformatter.h> +#include <zencore/logging/sink.h> #include <zencore/memory/llm.h> -ZEN_THIRD_PARTY_INCLUDES_START -#include <spdlog/details/log_msg.h> -#include <spdlog/pattern_formatter.h> -#include <spdlog/sinks/sink.h> -ZEN_THIRD_PARTY_INCLUDES_END - #include <atomic> #include <filesystem> @@ -19,13 +16,14 @@ namespace zen::logging { // Basically the same functionality as spdlog::sinks::rotating_file_sink with the biggest difference // being that it just ignores any errors when writing/rotating files and keeps chugging on. // It will keep trying to log, and if it starts to work it will continue to log. -class RotatingFileSink : public spdlog::sinks::sink +class RotatingFileSink : public Sink { public: RotatingFileSink(const std::filesystem::path& BaseFilename, std::size_t MaxSize, std::size_t MaxFiles, bool RotateOnOpen = false) : m_BaseFilename(BaseFilename) , m_MaxSize(MaxSize) , m_MaxFiles(MaxFiles) + , m_Formatter(std::make_unique<MessageOnlyFormatter>()) { ZEN_MEMSCOPE(ELLMTag::Logging); @@ -76,18 +74,21 @@ public: RotatingFileSink& operator=(const RotatingFileSink&) = delete; RotatingFileSink& operator=(RotatingFileSink&&) = delete; - virtual void log(const spdlog::details::log_msg& msg) override + virtual void Log(const LogMessage& Msg) override { ZEN_MEMSCOPE(ELLMTag::Logging); try { - spdlog::memory_buf_t Formatted; - if (TrySinkIt(msg, Formatted)) + MemoryBuffer Formatted; + if (TrySinkIt(Msg, Formatted)) { return; } - while (true) + + // This intentionally has no limit on the number of retries, see + // comment above. + for (;;) { { RwLock::ExclusiveLockScope RotateLock(m_Lock); @@ -113,7 +114,7 @@ public: // Silently eat errors } } - virtual void flush() override + virtual void Flush() override { if (!m_NeedFlush) { @@ -138,28 +139,14 @@ public: m_NeedFlush = false; } - virtual void set_pattern(const std::string& pattern) override + virtual void SetFormatter(std::unique_ptr<Formatter> InFormatter) override { ZEN_MEMSCOPE(ELLMTag::Logging); try { RwLock::ExclusiveLockScope _(m_Lock); - m_Formatter = spdlog::details::make_unique<spdlog::pattern_formatter>(pattern); - } - catch (const std::exception&) - { - // Silently eat errors - } - } - virtual void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override - { - ZEN_MEMSCOPE(ELLMTag::Logging); - - try - { - RwLock::ExclusiveLockScope _(m_Lock); - m_Formatter = std::move(sink_formatter); + m_Formatter = std::move(InFormatter); } catch (const std::exception&) { @@ -186,11 +173,17 @@ private: return; } - // If we fail to rotate, try extending the current log file m_CurrentSize = m_CurrentFile.FileSize(OutEc); + if (OutEc) + { + // FileSize failed but we have an open file — reset to 0 + // so we can at least attempt writes from the start + m_CurrentSize = 0; + OutEc.clear(); + } } - bool TrySinkIt(const spdlog::details::log_msg& msg, spdlog::memory_buf_t& OutFormatted) + bool TrySinkIt(const LogMessage& Msg, MemoryBuffer& OutFormatted) { ZEN_MEMSCOPE(ELLMTag::Logging); @@ -199,15 +192,15 @@ private: { return false; } - m_Formatter->format(msg, OutFormatted); - size_t add_size = OutFormatted.size(); - size_t write_pos = m_CurrentSize.fetch_add(add_size); - if (write_pos + add_size > m_MaxSize) + m_Formatter->Format(Msg, OutFormatted); + size_t AddSize = OutFormatted.size(); + size_t WritePos = m_CurrentSize.fetch_add(AddSize); + if (WritePos + AddSize > m_MaxSize) { return false; } std::error_code Ec; - m_CurrentFile.Write(OutFormatted.data(), OutFormatted.size(), write_pos, Ec); + m_CurrentFile.Write(OutFormatted.data(), OutFormatted.size(), WritePos, Ec); if (Ec) { return false; @@ -216,7 +209,7 @@ private: return true; } - bool TrySinkIt(const spdlog::memory_buf_t& Formatted) + bool TrySinkIt(const MemoryBuffer& Formatted) { ZEN_MEMSCOPE(ELLMTag::Logging); @@ -225,15 +218,15 @@ private: { return false; } - size_t add_size = Formatted.size(); - size_t write_pos = m_CurrentSize.fetch_add(add_size); - if (write_pos + add_size > m_MaxSize) + size_t AddSize = Formatted.size(); + size_t WritePos = m_CurrentSize.fetch_add(AddSize); + if (WritePos + AddSize > m_MaxSize) { return false; } std::error_code Ec; - m_CurrentFile.Write(Formatted.data(), Formatted.size(), write_pos, Ec); + m_CurrentFile.Write(Formatted.data(), Formatted.size(), WritePos, Ec); if (Ec) { return false; @@ -242,14 +235,14 @@ private: return true; } - RwLock m_Lock; - const std::filesystem::path m_BaseFilename; - std::unique_ptr<spdlog::formatter> m_Formatter; - std::atomic_size_t m_CurrentSize; - const std::size_t m_MaxSize; - const std::size_t m_MaxFiles; - BasicFile m_CurrentFile; - std::atomic<bool> m_NeedFlush = false; + RwLock m_Lock; + const std::filesystem::path m_BaseFilename; + const std::size_t m_MaxSize; + const std::size_t m_MaxFiles; + std::unique_ptr<Formatter> m_Formatter; + std::atomic_size_t m_CurrentSize; + BasicFile m_CurrentFile; + std::atomic<bool> m_NeedFlush = false; }; } // namespace zen::logging diff --git a/src/zenutil/include/zenutil/logging/testformatter.h b/src/zenutil/include/zenutil/logging/testformatter.h deleted file mode 100644 index 0b0c191fb..000000000 --- a/src/zenutil/include/zenutil/logging/testformatter.h +++ /dev/null @@ -1,160 +0,0 @@ -// Copyright Epic Games, Inc. All Rights Reserved. - -#pragma once - -#include <zencore/memory/llm.h> - -#include <spdlog/spdlog.h> - -namespace zen::logging { - -class full_test_formatter final : public spdlog::formatter -{ -public: - full_test_formatter(std::string_view LogId, std::chrono::time_point<std::chrono::system_clock> Epoch) : m_Epoch(Epoch), m_LogId(LogId) - { - } - - virtual std::unique_ptr<formatter> clone() const override - { - ZEN_MEMSCOPE(ELLMTag::Logging); - return std::make_unique<full_test_formatter>(m_LogId, m_Epoch); - } - - static constexpr bool UseDate = false; - - virtual void format(const spdlog::details::log_msg& msg, spdlog::memory_buf_t& dest) override - { - ZEN_MEMSCOPE(ELLMTag::Logging); - - using namespace std::literals; - - if constexpr (UseDate) - { - auto secs = std::chrono::duration_cast<std::chrono::seconds>(msg.time.time_since_epoch()); - if (secs != m_LastLogSecs) - { - m_CachedTm = spdlog::details::os::localtime(spdlog::log_clock::to_time_t(msg.time)); - m_LastLogSecs = secs; - } - } - - const auto& tm_time = m_CachedTm; - - // cache the date/time part for the next second. - auto duration = msg.time - m_Epoch; - auto secs = std::chrono::duration_cast<std::chrono::seconds>(duration); - - if (m_CacheTimestamp != secs) - { - RwLock::ExclusiveLockScope _(m_TimestampLock); - - m_CachedDatetime.clear(); - m_CachedDatetime.push_back('['); - - if constexpr (UseDate) - { - spdlog::details::fmt_helper::append_int(tm_time.tm_year + 1900, m_CachedDatetime); - m_CachedDatetime.push_back('-'); - - spdlog::details::fmt_helper::pad2(tm_time.tm_mon + 1, m_CachedDatetime); - m_CachedDatetime.push_back('-'); - - spdlog::details::fmt_helper::pad2(tm_time.tm_mday, m_CachedDatetime); - m_CachedDatetime.push_back(' '); - - spdlog::details::fmt_helper::pad2(tm_time.tm_hour, m_CachedDatetime); - m_CachedDatetime.push_back(':'); - - spdlog::details::fmt_helper::pad2(tm_time.tm_min, m_CachedDatetime); - m_CachedDatetime.push_back(':'); - - spdlog::details::fmt_helper::pad2(tm_time.tm_sec, m_CachedDatetime); - } - else - { - int Count = int(secs.count()); - - const int LogSecs = Count % 60; - Count /= 60; - - const int LogMins = Count % 60; - Count /= 60; - - const int LogHours = Count; - - spdlog::details::fmt_helper::pad2(LogHours, m_CachedDatetime); - m_CachedDatetime.push_back(':'); - spdlog::details::fmt_helper::pad2(LogMins, m_CachedDatetime); - m_CachedDatetime.push_back(':'); - spdlog::details::fmt_helper::pad2(LogSecs, m_CachedDatetime); - } - - m_CachedDatetime.push_back('.'); - - m_CacheTimestamp = secs; - } - - { - RwLock::SharedLockScope _(m_TimestampLock); - dest.append(m_CachedDatetime.begin(), m_CachedDatetime.end()); - } - - auto millis = spdlog::details::fmt_helper::time_fraction<std::chrono::milliseconds>(msg.time); - spdlog::details::fmt_helper::pad3(static_cast<uint32_t>(millis.count()), dest); - dest.push_back(']'); - dest.push_back(' '); - - if (!m_LogId.empty()) - { - dest.push_back('['); - spdlog::details::fmt_helper::append_string_view(m_LogId, dest); - dest.push_back(']'); - dest.push_back(' '); - } - - // append logger name if exists - if (msg.logger_name.size() > 0) - { - dest.push_back('['); - spdlog::details::fmt_helper::append_string_view(msg.logger_name, dest); - dest.push_back(']'); - dest.push_back(' '); - } - - dest.push_back('['); - // wrap the level name with color - msg.color_range_start = dest.size(); - spdlog::details::fmt_helper::append_string_view(spdlog::level::to_string_view(msg.level), dest); - msg.color_range_end = dest.size(); - dest.push_back(']'); - dest.push_back(' '); - - // add source location if present - if (!msg.source.empty()) - { - dest.push_back('['); - const char* filename = - spdlog::details::short_filename_formatter<spdlog::details::null_scoped_padder>::basename(msg.source.filename); - spdlog::details::fmt_helper::append_string_view(filename, dest); - dest.push_back(':'); - spdlog::details::fmt_helper::append_int(msg.source.line, dest); - dest.push_back(']'); - dest.push_back(' '); - } - - spdlog::details::fmt_helper::append_string_view(msg.payload, dest); - spdlog::details::fmt_helper::append_string_view("\n"sv, dest); - } - -private: - std::chrono::time_point<std::chrono::system_clock> m_Epoch; - std::tm m_CachedTm; - std::chrono::seconds m_LastLogSecs{std::chrono::seconds(87654321)}; - std::chrono::seconds m_CacheTimestamp{std::chrono::seconds(87654321)}; - spdlog::memory_buf_t m_CachedDatetime; - std::string m_LogId; - RwLock m_TimestampLock; -}; - -} // namespace zen::logging diff --git a/src/zenutil/logging.cpp b/src/zenutil/logging.cpp index 54ac30c5d..1258ca155 100644 --- a/src/zenutil/logging.cpp +++ b/src/zenutil/logging.cpp @@ -2,18 +2,15 @@ #include "zenutil/logging.h" -ZEN_THIRD_PARTY_INCLUDES_START -#include <spdlog/async.h> -#include <spdlog/async_logger.h> -#include <spdlog/sinks/ansicolor_sink.h> -#include <spdlog/sinks/msvc_sink.h> -#include <spdlog/spdlog.h> -ZEN_THIRD_PARTY_INCLUDES_END - #include <zencore/callstack.h> #include <zencore/compactbinary.h> #include <zencore/filesystem.h> #include <zencore/logging.h> +#include <zencore/logging/ansicolorsink.h> +#include <zencore/logging/asyncsink.h> +#include <zencore/logging/logger.h> +#include <zencore/logging/msvcsink.h> +#include <zencore/logging/registry.h> #include <zencore/memory/llm.h> #include <zencore/string.h> #include <zencore/timer.h> @@ -27,9 +24,9 @@ ZEN_THIRD_PARTY_INCLUDES_END namespace zen { static bool g_IsLoggingInitialized; -spdlog::sink_ptr g_FileSink; +logging::SinkPtr g_FileSink; -spdlog::sink_ptr +logging::SinkPtr GetFileSink() { return g_FileSink; @@ -52,33 +49,9 @@ BeginInitializeLogging(const LoggingOptions& LogOptions) zen::logging::InitializeLogging(); zen::logging::EnableVTMode(); - bool IsAsync = LogOptions.AllowAsync; - - if (LogOptions.IsDebug) - { - IsAsync = false; - } - - if (LogOptions.IsTest) - { - IsAsync = false; - } - - if (IsAsync) - { - const int QueueSize = 8192; - const int ThreadCount = 1; - spdlog::init_thread_pool(QueueSize, ThreadCount, [&] { SetCurrentThreadName("spdlog_async"); }); - - auto AsyncSink = spdlog::create_async<spdlog::sinks::ansicolor_stdout_sink_mt>("main"); - zen::logging::SetDefault("main"); - } - // Sinks - spdlog::sink_ptr FileSink; - - // spdlog can't create directories that starts with `\\?\` so we make sure the folder exists before creating the logger instance + logging::SinkPtr FileSink; if (!LogOptions.AbsLogFile.empty()) { @@ -87,17 +60,17 @@ BeginInitializeLogging(const LoggingOptions& LogOptions) zen::CreateDirectories(LogOptions.AbsLogFile.parent_path()); } - FileSink = std::make_shared<zen::logging::RotatingFileSink>(LogOptions.AbsLogFile, - /* max size */ 128 * 1024 * 1024, - /* max files */ 16, - /* rotate on open */ true); + FileSink = logging::SinkPtr(new zen::logging::RotatingFileSink(LogOptions.AbsLogFile, + /* max size */ 128 * 1024 * 1024, + /* max files */ 16, + /* rotate on open */ true)); if (LogOptions.AbsLogFile.extension() == ".json") { - FileSink->set_formatter(std::make_unique<logging::json_formatter>(LogOptions.LogId)); + FileSink->SetFormatter(std::make_unique<logging::JsonFormatter>(LogOptions.LogId)); } else { - FileSink->set_formatter(std::make_unique<logging::full_formatter>(LogOptions.LogId)); // this will have a date prefix + FileSink->SetFormatter(std::make_unique<logging::FullFormatter>(LogOptions.LogId)); // this will have a date prefix } } @@ -127,7 +100,7 @@ BeginInitializeLogging(const LoggingOptions& LogOptions) Message.push_back('\0'); // We use direct ZEN_LOG here instead of ZEN_ERROR as we don't care about *this* code location in the log - ZEN_LOG(Log(), zen::logging::level::Critical, "{}", Message.data()); + ZEN_LOG(Log(), zen::logging::Critical, "{}", Message.data()); zen::logging::FlushLogging(); } catch (const std::exception&) @@ -143,9 +116,9 @@ BeginInitializeLogging(const LoggingOptions& LogOptions) // Default LoggerRef DefaultLogger = zen::logging::Default(); - auto& Sinks = DefaultLogger.SpdLogger->sinks(); - Sinks.clear(); + // Collect sinks into a local vector first so we can optionally wrap them + std::vector<logging::SinkPtr> Sinks; if (LogOptions.NoConsoleOutput) { @@ -153,10 +126,10 @@ BeginInitializeLogging(const LoggingOptions& LogOptions) } else { - auto ConsoleSink = std::make_shared<spdlog::sinks::ansicolor_stdout_sink_mt>(); + logging::SinkPtr ConsoleSink(new logging::AnsiColorStdoutSink()); if (LogOptions.QuietConsole) { - ConsoleSink->set_level(spdlog::level::warn); + ConsoleSink->SetLevel(logging::Warn); } Sinks.push_back(ConsoleSink); } @@ -169,40 +142,54 @@ BeginInitializeLogging(const LoggingOptions& LogOptions) #if ZEN_PLATFORM_WINDOWS if (zen::IsDebuggerPresent() && LogOptions.IsDebug) { - auto DebugSink = std::make_shared<spdlog::sinks::msvc_sink_mt>(); - DebugSink->set_level(spdlog::level::debug); + logging::SinkPtr DebugSink(new logging::MsvcSink()); + DebugSink->SetLevel(logging::Debug); Sinks.push_back(DebugSink); } #endif - spdlog::set_error_handler([](const std::string& msg) { - if (msg == std::bad_alloc().what()) - { - // Don't report out of memory in spdlog as we usually log in response to errors which will cause another OOM crashing the - // program - return; - } - // Bypass zen logging wrapping to reduce potential other error sources - if (auto ErrLogger = zen::logging::ErrorLog()) + bool IsAsync = LogOptions.AllowAsync && !LogOptions.IsDebug && !LogOptions.IsTest; + + if (IsAsync) + { + std::vector<logging::SinkPtr> AsyncSinks; + AsyncSinks.emplace_back(new logging::AsyncSink(std::move(Sinks))); + DefaultLogger->SetSinks(std::move(AsyncSinks)); + } + else + { + DefaultLogger->SetSinks(std::move(Sinks)); + } + + static struct : logging::ErrorHandler + { + void HandleError(const std::string_view& ErrorMsg) override { + if (ErrorMsg == std::bad_alloc().what()) + { + return; + } + static constinit logging::LogPoint ErrorPoint{{}, logging::Err, "{}"}; + if (auto ErrLogger = zen::logging::ErrorLog()) + { + try + { + ErrLogger->Log(ErrorPoint, fmt::make_format_args(ErrorMsg)); + } + catch (const std::exception&) + { + } + } try { - ErrLogger.SpdLogger->log(spdlog::level::err, msg); + Log()->Log(ErrorPoint, fmt::make_format_args(ErrorMsg)); } catch (const std::exception&) { - // Just ignore any errors when in error handler } } - try - { - Log().SpdLogger->error(msg); - } - catch (const std::exception&) - { - // Just ignore any errors when in error handler - } - }); + } s_ErrorHandler; + logging::Registry::Instance().SetErrorHandler(&s_ErrorHandler); g_FileSink = std::move(FileSink); } @@ -212,24 +199,24 @@ FinishInitializeLogging(const LoggingOptions& LogOptions) { ZEN_MEMSCOPE(ELLMTag::Logging); - logging::level::LogLevel LogLevel = logging::level::Info; + logging::LogLevel LogLevel = logging::Info; if (LogOptions.IsDebug) { - LogLevel = logging::level::Debug; + LogLevel = logging::Debug; } if (LogOptions.IsTest || LogOptions.IsVerbose) { - LogLevel = logging::level::Trace; + LogLevel = logging::Trace; } // Configure all registered loggers according to settings logging::RefreshLogLevels(LogLevel); - spdlog::flush_on(spdlog::level::err); - spdlog::flush_every(std::chrono::seconds{2}); - spdlog::set_formatter(std::make_unique<logging::full_formatter>( + logging::Registry::Instance().FlushOn(logging::Err); + logging::Registry::Instance().FlushEvery(std::chrono::seconds{2}); + logging::Registry::Instance().SetFormatter(std::make_unique<logging::FullFormatter>( LogOptions.LogId, std::chrono::system_clock::now() - std::chrono::milliseconds(GetTimeSinceProcessStart()))); // default to duration prefix @@ -242,16 +229,17 @@ FinishInitializeLogging(const LoggingOptions& LogOptions) { if (LogOptions.AbsLogFile.extension() == ".json") { - g_FileSink->set_formatter(std::make_unique<logging::json_formatter>(LogOptions.LogId)); + g_FileSink->SetFormatter(std::make_unique<logging::JsonFormatter>(LogOptions.LogId)); } else { - g_FileSink->set_formatter(std::make_unique<logging::full_formatter>(LogOptions.LogId)); // this will have a date prefix + g_FileSink->SetFormatter(std::make_unique<logging::FullFormatter>(LogOptions.LogId)); // this will have a date prefix } const std::string StartLogTime = zen::DateTime::Now().ToIso8601(); - spdlog::apply_all([&](auto Logger) { Logger->info("log starting at {}", StartLogTime); }); + static constinit logging::LogPoint LogStartPoint{{}, logging::Info, "log starting at {}"}; + logging::Registry::Instance().ApplyAll([&](auto Logger) { Logger->Log(LogStartPoint, fmt::make_format_args(StartLogTime)); }); } g_IsLoggingInitialized = true; @@ -268,7 +256,7 @@ ShutdownLogging() zen::logging::ShutdownLogging(); - g_FileSink.reset(); + g_FileSink = nullptr; } } // namespace zen diff --git a/src/zenutil/xmake.lua b/src/zenutil/xmake.lua index bc33adf9e..1d5be5977 100644 --- a/src/zenutil/xmake.lua +++ b/src/zenutil/xmake.lua @@ -6,7 +6,7 @@ target('zenutil') add_headerfiles("**.h") add_files("**.cpp") add_includedirs("include", {public=true}) - add_deps("zencore", "zenhttp", "spdlog") + add_deps("zencore", "zenhttp") add_deps("cxxopts") add_deps("robin-map") diff --git a/src/zenvfs/xmake.lua b/src/zenvfs/xmake.lua index 7f790c2d4..47665a5d5 100644 --- a/src/zenvfs/xmake.lua +++ b/src/zenvfs/xmake.lua @@ -6,5 +6,5 @@ target('zenvfs') add_headerfiles("**.h") add_files("**.cpp") add_includedirs("include", {public=true}) - add_deps("zencore", "spdlog") + add_deps("zencore") diff --git a/thirdparty/spdlog/.clang-format b/thirdparty/spdlog/.clang-format deleted file mode 100644 index c8c345f6f..000000000 --- a/thirdparty/spdlog/.clang-format +++ /dev/null @@ -1,19 +0,0 @@ ---- -Language: Cpp -BasedOnStyle: Google -AccessModifierOffset: -4 -Standard: c++17 -IndentWidth: 4 -TabWidth: 4 -UseTab: Never -ColumnLimit: 100 -AlignAfterOpenBracket: Align -BinPackParameters: false -AlignEscapedNewlines: Left -AlwaysBreakTemplateDeclarations: Yes -PackConstructorInitializers: Never -BreakConstructorInitializersBeforeComma: false -IndentPPDirectives: BeforeHash -SortIncludes: Never -... - diff --git a/thirdparty/spdlog/.clang-tidy b/thirdparty/spdlog/.clang-tidy deleted file mode 100644 index bc50ee791..000000000 --- a/thirdparty/spdlog/.clang-tidy +++ /dev/null @@ -1,53 +0,0 @@ -Checks: 'cppcoreguidelines-*, -performance-*, -modernize-*, -google-*, -misc-* -cert-*, -readability-*, -clang-analyzer-*, --performance-unnecessary-value-param, --modernize-use-trailing-return-type, --google-runtime-references, --misc-non-private-member-variables-in-classes, --readability-braces-around-statements, --google-readability-braces-around-statements, --cppcoreguidelines-avoid-magic-numbers, --readability-magic-numbers, --readability-magic-numbers, --cppcoreguidelines-pro-type-vararg, --cppcoreguidelines-pro-bounds-pointer-arithmetic, --cppcoreguidelines-avoid-c-arrays, --modernize-avoid-c-arrays, --cppcoreguidelines-pro-bounds-array-to-pointer-decay, --readability-named-parameter, --cert-env33-c -' - - -WarningsAsErrors: '' -HeaderFilterRegex: '*spdlog/[^f].*' -FormatStyle: none - -CheckOptions: - - key: google-readability-braces-around-statements.ShortStatementLines - value: '1' - - key: google-readability-function-size.StatementThreshold - value: '800' - - key: google-readability-namespace-comments.ShortNamespaceLines - value: '10' - - key: google-readability-namespace-comments.SpacesBeforeComments - value: '2' - - key: modernize-loop-convert.MaxCopySize - value: '16' - - key: modernize-loop-convert.MinConfidence - value: reasonable - - key: modernize-loop-convert.NamingStyle - value: CamelCase - - key: modernize-pass-by-value.IncludeStyle - value: llvm - - key: modernize-replace-auto-ptr.IncludeStyle - value: llvm - - key: modernize-use-nullptr.NullMacros - value: 'NULL' - diff --git a/thirdparty/spdlog/.gitattributes b/thirdparty/spdlog/.gitattributes deleted file mode 100644 index fe505b275..000000000 --- a/thirdparty/spdlog/.gitattributes +++ /dev/null @@ -1 +0,0 @@ -* text=false diff --git a/thirdparty/spdlog/.gitignore b/thirdparty/spdlog/.gitignore deleted file mode 100644 index 487fc3847..000000000 --- a/thirdparty/spdlog/.gitignore +++ /dev/null @@ -1,98 +0,0 @@ -# Auto generated files -[Dd]ebug/ -[Rr]elease/ -build/* -*.slo -*.lo -*.o -*.obj -*.suo -*.tlog -*.ilk -*.log -*.pdb -*.idb -*.iobj -*.ipdb -*.opensdf -*.sdf - -# Compiled Dynamic libraries -*.so -*.dylib -*.dll - -# Compiled Static libraries -*.lai -*.la -*.a -*.lib - -# Executables -*.exe -*.out -*.app - -# Codelite -.codelite - -# KDevelop -*.kdev4 - -# .orig files -*.orig - -# example files -example/* -!example/example.cpp -!example/bench.cpp -!example/utils.h -!example/Makefile* -!example/example.sln -!example/example.vcxproj -!example/CMakeLists.txt -!example/meson.build -!example/multisink.cpp -!example/jni - -# generated files -generated -version.rc - -# Cmake -CMakeCache.txt -CMakeFiles -CMakeScripts -Makefile -cmake_install.cmake -install_manifest.txt -/tests/tests.VC.VC.opendb -/tests/tests.VC.db -/tests/tests -/tests/logs/* -spdlogConfig.cmake -spdlogConfigVersion.cmake -compile_commands.json - -# idea -.idea/ -.cache/ -.vscode/ -cmake-build-*/ -*.db -*.ipch -*.filters -*.db-wal -*.opendb -*.db-shm -*.vcxproj -*.tcl -*.user -*.sln - -# macos -*.DS_store -*.xcodeproj/ -/.vs -/out/build -/CMakeSettings.json diff --git a/thirdparty/spdlog/LICENSE b/thirdparty/spdlog/LICENSE deleted file mode 100644 index 6546da0b9..000000000 --- a/thirdparty/spdlog/LICENSE +++ /dev/null @@ -1,26 +0,0 @@ -The MIT License (MIT) - -Copyright (c) 2016 Gabi Melman. - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in -all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -THE SOFTWARE. - --- NOTE: Third party dependency used by this software -- -This software depends on the fmt lib (MIT License), -and users must comply to its license: https://raw.githubusercontent.com/fmtlib/fmt/master/LICENSE - diff --git a/thirdparty/spdlog/README.md b/thirdparty/spdlog/README.md deleted file mode 100644 index 262f867e5..000000000 --- a/thirdparty/spdlog/README.md +++ /dev/null @@ -1,553 +0,0 @@ -# spdlog - - -[](https://github.com/gabime/spdlog/actions/workflows/linux.yml) -[](https://github.com/gabime/spdlog/actions/workflows/windows.yml) -[](https://github.com/gabime/spdlog/actions/workflows/macos.yml) -[](https://ci.appveyor.com/project/gabime/spdlog) [](https://github.com/gabime/spdlog/releases/latest) - -Fast C++ logging library - - -## Install -#### Header-only version -Copy the include [folder](include/spdlog) to your build tree and use a C++11 compiler. - -#### Compiled version (recommended - much faster compile times) -```console -$ git clone https://github.com/gabime/spdlog.git -$ cd spdlog && mkdir build && cd build -$ cmake .. && cmake --build . -``` -see example [CMakeLists.txt](example/CMakeLists.txt) on how to use. - -## Platforms -* Linux, FreeBSD, OpenBSD, Solaris, AIX -* Windows (msvc 2013+, cygwin) -* macOS (clang 3.5+) -* Android - -## Package managers: -* Debian: `sudo apt install libspdlog-dev` -* Homebrew: `brew install spdlog` -* MacPorts: `sudo port install spdlog` -* FreeBSD: `pkg install spdlog` -* Fedora: `dnf install spdlog` -* Gentoo: `emerge dev-libs/spdlog` -* Arch Linux: `pacman -S spdlog` -* openSUSE: `sudo zypper in spdlog-devel` -* ALT Linux: `apt-get install libspdlog-devel` -* vcpkg: `vcpkg install spdlog` -* conan: `conan install --requires=spdlog/[*]` -* conda: `conda install -c conda-forge spdlog` -* build2: ```depends: spdlog ^1.8.2``` - - -## Features -* Very fast (see [benchmarks](#benchmarks) below). -* Headers only or compiled -* Feature-rich formatting, using the excellent [fmt](https://github.com/fmtlib/fmt) library. -* Asynchronous mode (optional) -* [Custom](https://github.com/gabime/spdlog/wiki/Custom-formatting) formatting. -* Multi/Single threaded loggers. -* Various log targets: - * Rotating log files. - * Daily log files. - * Console logging (colors supported). - * syslog. - * Windows event log. - * Windows debugger (```OutputDebugString(..)```). - * Log to Qt widgets ([example](#log-to-qt-with-nice-colors)). - * Easily [extendable](https://github.com/gabime/spdlog/wiki/Sinks#implementing-your-own-sink) with custom log targets. -* Log filtering - log levels can be modified at runtime as well as compile time. -* Support for loading log levels from argv or environment var. -* [Backtrace](#backtrace-support) support - store debug messages in a ring buffer and display them later on demand. - -## Usage samples - -#### Basic usage -```c++ -#include "spdlog/spdlog.h" - -int main() -{ - spdlog::info("Welcome to spdlog!"); - spdlog::error("Some error message with arg: {}", 1); - - spdlog::warn("Easy padding in numbers like {:08d}", 12); - spdlog::critical("Support for int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}", 42); - spdlog::info("Support for floats {:03.2f}", 1.23456); - spdlog::info("Positional args are {1} {0}..", "too", "supported"); - spdlog::info("{:<30}", "left aligned"); - - spdlog::set_level(spdlog::level::debug); // Set *global* log level to debug - spdlog::debug("This message should be displayed.."); - - // change log pattern - spdlog::set_pattern("[%H:%M:%S %z] [%n] [%^---%L---%$] [thread %t] %v"); - - // Compile time log levels - // Note that this does not change the current log level, it will only - // remove (depending on SPDLOG_ACTIVE_LEVEL) the call on the release code. - SPDLOG_TRACE("Some trace message with param {}", 42); - SPDLOG_DEBUG("Some debug message"); -} - -``` ---- -#### Create stdout/stderr logger object -```c++ -#include "spdlog/spdlog.h" -#include "spdlog/sinks/stdout_color_sinks.h" -void stdout_example() -{ - // create a color multi-threaded logger - auto console = spdlog::stdout_color_mt("console"); - auto err_logger = spdlog::stderr_color_mt("stderr"); - spdlog::get("console")->info("loggers can be retrieved from a global registry using the spdlog::get(logger_name)"); -} -``` - ---- -#### Basic file logger -```c++ -#include "spdlog/sinks/basic_file_sink.h" -void basic_logfile_example() -{ - try - { - auto logger = spdlog::basic_logger_mt("basic_logger", "logs/basic-log.txt"); - } - catch (const spdlog::spdlog_ex &ex) - { - std::cout << "Log init failed: " << ex.what() << std::endl; - } -} -``` ---- -#### Rotating files -```c++ -#include "spdlog/sinks/rotating_file_sink.h" -void rotating_example() -{ - // Create a file rotating logger with 5 MB size max and 3 rotated files - auto max_size = 1048576 * 5; - auto max_files = 3; - auto logger = spdlog::rotating_logger_mt("some_logger_name", "logs/rotating.txt", max_size, max_files); -} -``` - ---- -#### Daily files -```c++ - -#include "spdlog/sinks/daily_file_sink.h" -void daily_example() -{ - // Create a daily logger - a new file is created every day at 2:30 am - auto logger = spdlog::daily_logger_mt("daily_logger", "logs/daily.txt", 2, 30); -} - -``` - ---- -#### Backtrace support -```c++ -// Debug messages can be stored in a ring buffer instead of being logged immediately. -// This is useful to display debug logs only when needed (e.g. when an error happens). -// When needed, call dump_backtrace() to dump them to your log. - -spdlog::enable_backtrace(32); // Store the latest 32 messages in a buffer. -// or my_logger->enable_backtrace(32).. -for(int i = 0; i < 100; i++) -{ - spdlog::debug("Backtrace message {}", i); // not logged yet.. -} -// e.g. if some error happened: -spdlog::dump_backtrace(); // log them now! show the last 32 messages -// or my_logger->dump_backtrace(32).. -``` - ---- -#### Periodic flush -```c++ -// periodically flush all *registered* loggers every 3 seconds: -// warning: only use if all your loggers are thread-safe ("_mt" loggers) -spdlog::flush_every(std::chrono::seconds(3)); - -``` - ---- -#### Stopwatch -```c++ -// Stopwatch support for spdlog -#include "spdlog/stopwatch.h" -void stopwatch_example() -{ - spdlog::stopwatch sw; - spdlog::debug("Elapsed {}", sw); - spdlog::debug("Elapsed {:.3}", sw); -} - -``` - ---- -#### Log binary data in hex -```c++ -// many types of std::container<char> types can be used. -// ranges are supported too. -// format flags: -// {:X} - print in uppercase. -// {:s} - don't separate each byte with space. -// {:p} - don't print the position on each line start. -// {:n} - don't split the output into lines. -// {:a} - show ASCII if :n is not set. - -#include "spdlog/fmt/bin_to_hex.h" - -void binary_example() -{ - auto console = spdlog::get("console"); - std::array<char, 80> buf; - console->info("Binary example: {}", spdlog::to_hex(buf)); - console->info("Another binary example:{:n}", spdlog::to_hex(std::begin(buf), std::begin(buf) + 10)); - // more examples: - // logger->info("uppercase: {:X}", spdlog::to_hex(buf)); - // logger->info("uppercase, no delimiters: {:Xs}", spdlog::to_hex(buf)); - // logger->info("uppercase, no delimiters, no position info: {:Xsp}", spdlog::to_hex(buf)); -} - -``` - ---- -#### Logger with multi sinks - each with a different format and log level -```c++ - -// create a logger with 2 targets, with different log levels and formats. -// The console will show only warnings or errors, while the file will log all. -void multi_sink_example() -{ - auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>(); - console_sink->set_level(spdlog::level::warn); - console_sink->set_pattern("[multi_sink_example] [%^%l%$] %v"); - - auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>("logs/multisink.txt", true); - file_sink->set_level(spdlog::level::trace); - - spdlog::logger logger("multi_sink", {console_sink, file_sink}); - logger.set_level(spdlog::level::debug); - logger.warn("this should appear in both console and file"); - logger.info("this message should not appear in the console, only in the file"); -} -``` - ---- -#### Register several loggers - change global level -```c++ - -// Creation of loggers. Set levels to all registered loggers. -void set_level_example() -{ - auto logger1 = spdlog::basic_logger_mt("logger1", "logs/logger1.txt"); - auto logger2 = spdlog::basic_logger_mt("logger2", "logs/logger2.txt"); - - spdlog::set_default_logger(logger2); - spdlog::default_logger()->set_level(spdlog::level::trace); // set level for the default logger (logger2) to trace - - spdlog::trace("trace message to the logger2 (specified as default)"); - - spdlog::set_level(spdlog::level::off) // (sic!) set level for *all* registered loggers to off (disable) - - logger1.warn("warn message will not appear because the level set to off"); - logger2.warn("warn message will not appear because the level set to off"); - spdlog::warn("warn message will not appear because the level set to off"); -} -``` - ---- -#### User-defined callbacks about log events -```c++ - -// create a logger with a lambda function callback, the callback will be called -// each time something is logged to the logger -void callback_example() -{ - auto callback_sink = std::make_shared<spdlog::sinks::callback_sink_mt>([](const spdlog::details::log_msg &msg) { - // for example you can be notified by sending an email to yourself - }); - callback_sink->set_level(spdlog::level::err); - - auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>(); - spdlog::logger logger("custom_callback_logger", {console_sink, callback_sink}); - - logger.info("some info log"); - logger.error("critical issue"); // will notify you -} -``` - ---- -#### Asynchronous logging -```c++ -#include "spdlog/async.h" -#include "spdlog/sinks/basic_file_sink.h" -void async_example() -{ - // default thread pool settings can be modified *before* creating the async logger: - // spdlog::init_thread_pool(8192, 1); // queue with 8k items and 1 backing thread. - auto async_file = spdlog::basic_logger_mt<spdlog::async_factory>("async_file_logger", "logs/async_log.txt"); - // alternatively: - // auto async_file = spdlog::create_async<spdlog::sinks::basic_file_sink_mt>("async_file_logger", "logs/async_log.txt"); -} - -``` - ---- -#### Asynchronous logger with multi sinks -```c++ -#include "spdlog/async.h" -#include "spdlog/sinks/stdout_color_sinks.h" -#include "spdlog/sinks/rotating_file_sink.h" - -void multi_sink_example2() -{ - spdlog::init_thread_pool(8192, 1); - auto stdout_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt >(); - auto rotating_sink = std::make_shared<spdlog::sinks::rotating_file_sink_mt>("mylog.txt", 1024*1024*10, 3); - std::vector<spdlog::sink_ptr> sinks {stdout_sink, rotating_sink}; - auto logger = std::make_shared<spdlog::async_logger>("loggername", sinks.begin(), sinks.end(), spdlog::thread_pool(), spdlog::async_overflow_policy::block); - spdlog::register_logger(logger); -} -``` - ---- -#### User-defined types -```c++ -template<> -struct fmt::formatter<my_type> : fmt::formatter<std::string> -{ - auto format(my_type my, format_context &ctx) const -> decltype(ctx.out()) - { - return fmt::format_to(ctx.out(), "[my_type i={}]", my.i); - } -}; - -void user_defined_example() -{ - spdlog::info("user defined type: {}", my_type(14)); -} - -``` - ---- -#### User-defined flags in the log pattern -```c++ -// Log patterns can contain custom flags. -// the following example will add new flag '%*' - which will be bound to a <my_formatter_flag> instance. -#include "spdlog/pattern_formatter.h" -class my_formatter_flag : public spdlog::custom_flag_formatter -{ -public: - void format(const spdlog::details::log_msg &, const std::tm &, spdlog::memory_buf_t &dest) override - { - std::string some_txt = "custom-flag"; - dest.append(some_txt.data(), some_txt.data() + some_txt.size()); - } - - std::unique_ptr<custom_flag_formatter> clone() const override - { - return spdlog::details::make_unique<my_formatter_flag>(); - } -}; - -void custom_flags_example() -{ - auto formatter = std::make_unique<spdlog::pattern_formatter>(); - formatter->add_flag<my_formatter_flag>('*').set_pattern("[%n] [%*] [%^%l%$] %v"); - spdlog::set_formatter(std::move(formatter)); -} - -``` - ---- -#### Custom error handler -```c++ -void err_handler_example() -{ - // can be set globally or per logger(logger->set_error_handler(..)) - spdlog::set_error_handler([](const std::string &msg) { spdlog::get("console")->error("*** LOGGER ERROR ***: {}", msg); }); - spdlog::get("console")->info("some invalid message to trigger an error {}{}{}{}", 3); -} - -``` - ---- -#### syslog -```c++ -#include "spdlog/sinks/syslog_sink.h" -void syslog_example() -{ - std::string ident = "spdlog-example"; - auto syslog_logger = spdlog::syslog_logger_mt("syslog", ident, LOG_PID); - syslog_logger->warn("This is warning that will end up in syslog."); -} -``` ---- -#### Android example -```c++ -#include "spdlog/sinks/android_sink.h" -void android_example() -{ - std::string tag = "spdlog-android"; - auto android_logger = spdlog::android_logger_mt("android", tag); - android_logger->critical("Use \"adb shell logcat\" to view this message."); -} -``` - ---- -#### Load log levels from the env variable or argv - -```c++ -#include "spdlog/cfg/env.h" -int main (int argc, char *argv[]) -{ - spdlog::cfg::load_env_levels(); - // or specify the env variable name: - // MYAPP_LEVEL=info,mylogger=trace && ./example - // spdlog::cfg::load_env_levels("MYAPP_LEVEL"); - // or from the command line: - // ./example SPDLOG_LEVEL=info,mylogger=trace - // #include "spdlog/cfg/argv.h" // for loading levels from argv - // spdlog::cfg::load_argv_levels(argc, argv); -} -``` -So then you can: - -```console -$ export SPDLOG_LEVEL=info,mylogger=trace -$ ./example -``` - - ---- -#### Log file open/close event handlers -```c++ -// You can get callbacks from spdlog before/after a log file has been opened or closed. -// This is useful for cleanup procedures or for adding something to the start/end of the log file. -void file_events_example() -{ - // pass the spdlog::file_event_handlers to file sinks for open/close log file notifications - spdlog::file_event_handlers handlers; - handlers.before_open = [](spdlog::filename_t filename) { spdlog::info("Before opening {}", filename); }; - handlers.after_open = [](spdlog::filename_t filename, std::FILE *fstream) { fputs("After opening\n", fstream); }; - handlers.before_close = [](spdlog::filename_t filename, std::FILE *fstream) { fputs("Before closing\n", fstream); }; - handlers.after_close = [](spdlog::filename_t filename) { spdlog::info("After closing {}", filename); }; - auto my_logger = spdlog::basic_logger_st("some_logger", "logs/events-sample.txt", true, handlers); -} -``` - ---- -#### Replace the Default Logger -```c++ -void replace_default_logger_example() -{ - auto new_logger = spdlog::basic_logger_mt("new_default_logger", "logs/new-default-log.txt", true); - spdlog::set_default_logger(new_logger); - spdlog::info("new logger log message"); -} -``` - ---- -#### Log to Qt with nice colors -```c++ -#include "spdlog/spdlog.h" -#include "spdlog/sinks/qt_sinks.h" -MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent) -{ - setMinimumSize(640, 480); - auto log_widget = new QTextEdit(this); - setCentralWidget(log_widget); - int max_lines = 500; // keep the text widget to max 500 lines. remove old lines if needed. - auto logger = spdlog::qt_color_logger_mt("qt_logger", log_widget, max_lines); - logger->info("Some info message"); -} -``` ---- - -#### Mapped Diagnostic Context -```c++ -// Mapped Diagnostic Context (MDC) is a map that stores key-value pairs (string values) in thread local storage. -// Each thread maintains its own MDC, which loggers use to append diagnostic information to log outputs. -// Note: it is not supported in asynchronous mode due to its reliance on thread-local storage. -#include "spdlog/mdc.h" -void mdc_example() -{ - spdlog::mdc::put("key1", "value1"); - spdlog::mdc::put("key2", "value2"); - // if not using the default format, use the %& formatter to print mdc data - // spdlog::set_pattern("[%H:%M:%S %z] [%^%L%$] [%&] %v"); -} -``` ---- -## Benchmarks - -Below are some [benchmarks](bench/bench.cpp) done in Ubuntu 64 bit, Intel i7-4770 CPU @ 3.40GHz - -#### Synchronous mode -``` -[info] ************************************************************** -[info] Single thread, 1,000,000 iterations -[info] ************************************************************** -[info] basic_st Elapsed: 0.17 secs 5,777,626/sec -[info] rotating_st Elapsed: 0.18 secs 5,475,894/sec -[info] daily_st Elapsed: 0.20 secs 5,062,659/sec -[info] empty_logger Elapsed: 0.07 secs 14,127,300/sec -[info] ************************************************************** -[info] C-string (400 bytes). Single thread, 1,000,000 iterations -[info] ************************************************************** -[info] basic_st Elapsed: 0.41 secs 2,412,483/sec -[info] rotating_st Elapsed: 0.72 secs 1,389,196/sec -[info] daily_st Elapsed: 0.42 secs 2,393,298/sec -[info] null_st Elapsed: 0.04 secs 27,446,957/sec -[info] ************************************************************** -[info] 10 threads, competing over the same logger object, 1,000,000 iterations -[info] ************************************************************** -[info] basic_mt Elapsed: 0.60 secs 1,659,613/sec -[info] rotating_mt Elapsed: 0.62 secs 1,612,493/sec -[info] daily_mt Elapsed: 0.61 secs 1,638,305/sec -[info] null_mt Elapsed: 0.16 secs 6,272,758/sec -``` -#### Asynchronous mode -``` -[info] ------------------------------------------------- -[info] Messages : 1,000,000 -[info] Threads : 10 -[info] Queue : 8,192 slots -[info] Queue memory : 8,192 x 272 = 2,176 KB -[info] ------------------------------------------------- -[info] -[info] ********************************* -[info] Queue Overflow Policy: block -[info] ********************************* -[info] Elapsed: 1.70784 secs 585,535/sec -[info] Elapsed: 1.69805 secs 588,910/sec -[info] Elapsed: 1.7026 secs 587,337/sec -[info] -[info] ********************************* -[info] Queue Overflow Policy: overrun -[info] ********************************* -[info] Elapsed: 0.372816 secs 2,682,285/sec -[info] Elapsed: 0.379758 secs 2,633,255/sec -[info] Elapsed: 0.373532 secs 2,677,147/sec - -``` - -## Documentation - -Documentation can be found in the [wiki](https://github.com/gabime/spdlog/wiki) pages. - ---- - -### Powered by -<a href="https://jb.gg/OpenSource"> - <img src="https://resources.jetbrains.com/storage/products/company/brand/logos/jetbrains.svg" alt="JetBrains logo" width="200"> -</a> diff --git a/thirdparty/spdlog/include/spdlog/async.h b/thirdparty/spdlog/include/spdlog/async.h deleted file mode 100644 index 92fcd9a7d..000000000 --- a/thirdparty/spdlog/include/spdlog/async.h +++ /dev/null @@ -1,99 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -// -// Async logging using global thread pool -// All loggers created here share same global thread pool. -// Each log message is pushed to a queue along with a shared pointer to the -// logger. -// If a logger deleted while having pending messages in the queue, it's actual -// destruction will defer -// until all its messages are processed by the thread pool. -// This is because each message in the queue holds a shared_ptr to the -// originating logger. - -#include <spdlog/async_logger.h> -#include <spdlog/details/registry.h> -#include <spdlog/details/thread_pool.h> - -#include <functional> -#include <memory> -#include <mutex> - -namespace spdlog { - -namespace details { -static const size_t default_async_q_size = 8192; -} - -// async logger factory - creates async loggers backed with thread pool. -// if a global thread pool doesn't already exist, create it with default queue -// size of 8192 items and single thread. -template <async_overflow_policy OverflowPolicy = async_overflow_policy::block> -struct async_factory_impl { - template <typename Sink, typename... SinkArgs> - static std::shared_ptr<async_logger> create(std::string logger_name, SinkArgs &&...args) { - auto ®istry_inst = details::registry::instance(); - - // create global thread pool if not already exists.. - - auto &mutex = registry_inst.tp_mutex(); - std::lock_guard<std::recursive_mutex> tp_lock(mutex); - auto tp = registry_inst.get_tp(); - if (tp == nullptr) { - tp = std::make_shared<details::thread_pool>(details::default_async_q_size, 1U); - registry_inst.set_tp(tp); - } - - auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...); - auto new_logger = std::make_shared<async_logger>(std::move(logger_name), std::move(sink), - std::move(tp), OverflowPolicy); - registry_inst.initialize_logger(new_logger); - return new_logger; - } -}; - -using async_factory = async_factory_impl<async_overflow_policy::block>; -using async_factory_nonblock = async_factory_impl<async_overflow_policy::overrun_oldest>; - -template <typename Sink, typename... SinkArgs> -inline std::shared_ptr<spdlog::logger> create_async(std::string logger_name, - SinkArgs &&...sink_args) { - return async_factory::create<Sink>(std::move(logger_name), - std::forward<SinkArgs>(sink_args)...); -} - -template <typename Sink, typename... SinkArgs> -inline std::shared_ptr<spdlog::logger> create_async_nb(std::string logger_name, - SinkArgs &&...sink_args) { - return async_factory_nonblock::create<Sink>(std::move(logger_name), - std::forward<SinkArgs>(sink_args)...); -} - -// set global thread pool. -inline void init_thread_pool(size_t q_size, - size_t thread_count, - std::function<void()> on_thread_start, - std::function<void()> on_thread_stop) { - auto tp = std::make_shared<details::thread_pool>(q_size, thread_count, on_thread_start, - on_thread_stop); - details::registry::instance().set_tp(std::move(tp)); -} - -inline void init_thread_pool(size_t q_size, - size_t thread_count, - std::function<void()> on_thread_start) { - init_thread_pool(q_size, thread_count, on_thread_start, [] {}); -} - -inline void init_thread_pool(size_t q_size, size_t thread_count) { - init_thread_pool(q_size, thread_count, [] {}, [] {}); -} - -// get the global thread pool. -inline std::shared_ptr<spdlog::details::thread_pool> thread_pool() { - return details::registry::instance().get_tp(); -} -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/async_logger-inl.h b/thirdparty/spdlog/include/spdlog/async_logger-inl.h deleted file mode 100644 index a681d97c6..000000000 --- a/thirdparty/spdlog/include/spdlog/async_logger-inl.h +++ /dev/null @@ -1,84 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#ifndef SPDLOG_HEADER_ONLY - #include <spdlog/async_logger.h> -#endif - -#include <spdlog/details/thread_pool.h> -#include <spdlog/sinks/sink.h> - -#include <memory> -#include <string> - -SPDLOG_INLINE spdlog::async_logger::async_logger(std::string logger_name, - sinks_init_list sinks_list, - std::weak_ptr<details::thread_pool> tp, - async_overflow_policy overflow_policy) - : async_logger(std::move(logger_name), - sinks_list.begin(), - sinks_list.end(), - std::move(tp), - overflow_policy) {} - -SPDLOG_INLINE spdlog::async_logger::async_logger(std::string logger_name, - sink_ptr single_sink, - std::weak_ptr<details::thread_pool> tp, - async_overflow_policy overflow_policy) - : async_logger( - std::move(logger_name), {std::move(single_sink)}, std::move(tp), overflow_policy) {} - -// send the log message to the thread pool -SPDLOG_INLINE void spdlog::async_logger::sink_it_(const details::log_msg &msg){ - SPDLOG_TRY{if (auto pool_ptr = thread_pool_.lock()){ - pool_ptr -> post_log(shared_from_this(), msg, overflow_policy_); -} -else { - throw_spdlog_ex("async log: thread pool doesn't exist anymore"); -} -} -SPDLOG_LOGGER_CATCH(msg.source) -} - -// send flush request to the thread pool -SPDLOG_INLINE void spdlog::async_logger::flush_(){ - SPDLOG_TRY{if (auto pool_ptr = thread_pool_.lock()){ - pool_ptr -> post_flush(shared_from_this(), overflow_policy_); -} -else { - throw_spdlog_ex("async flush: thread pool doesn't exist anymore"); -} -} -SPDLOG_LOGGER_CATCH(source_loc()) -} - -// -// backend functions - called from the thread pool to do the actual job -// -SPDLOG_INLINE void spdlog::async_logger::backend_sink_it_(const details::log_msg &msg) { - for (auto &sink : sinks_) { - if (sink->should_log(msg.level)) { - SPDLOG_TRY { sink->log(msg); } - SPDLOG_LOGGER_CATCH(msg.source) - } - } - - if (should_flush_(msg)) { - backend_flush_(); - } -} - -SPDLOG_INLINE void spdlog::async_logger::backend_flush_() { - for (auto &sink : sinks_) { - SPDLOG_TRY { sink->flush(); } - SPDLOG_LOGGER_CATCH(source_loc()) - } -} - -SPDLOG_INLINE std::shared_ptr<spdlog::logger> spdlog::async_logger::clone(std::string new_name) { - auto cloned = std::make_shared<spdlog::async_logger>(*this); - cloned->name_ = std::move(new_name); - return cloned; -} diff --git a/thirdparty/spdlog/include/spdlog/async_logger.h b/thirdparty/spdlog/include/spdlog/async_logger.h deleted file mode 100644 index 846c4c6f0..000000000 --- a/thirdparty/spdlog/include/spdlog/async_logger.h +++ /dev/null @@ -1,74 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -// Fast asynchronous logger. -// Uses pre allocated queue. -// Creates a single back thread to pop messages from the queue and log them. -// -// Upon each log write the logger: -// 1. Checks if its log level is enough to log the message -// 2. Push a new copy of the message to a queue (or block the caller until -// space is available in the queue) -// Upon destruction, logs all remaining messages in the queue before -// destructing.. - -#include <spdlog/logger.h> - -namespace spdlog { - -// Async overflow policy - block by default. -enum class async_overflow_policy { - block, // Block until message can be enqueued - overrun_oldest, // Discard oldest message in the queue if full when trying to - // add new item. - discard_new // Discard new message if the queue is full when trying to add new item. -}; - -namespace details { -class thread_pool; -} - -class SPDLOG_API async_logger final : public std::enable_shared_from_this<async_logger>, - public logger { - friend class details::thread_pool; - -public: - template <typename It> - async_logger(std::string logger_name, - It begin, - It end, - std::weak_ptr<details::thread_pool> tp, - async_overflow_policy overflow_policy = async_overflow_policy::block) - : logger(std::move(logger_name), begin, end), - thread_pool_(std::move(tp)), - overflow_policy_(overflow_policy) {} - - async_logger(std::string logger_name, - sinks_init_list sinks_list, - std::weak_ptr<details::thread_pool> tp, - async_overflow_policy overflow_policy = async_overflow_policy::block); - - async_logger(std::string logger_name, - sink_ptr single_sink, - std::weak_ptr<details::thread_pool> tp, - async_overflow_policy overflow_policy = async_overflow_policy::block); - - std::shared_ptr<logger> clone(std::string new_name) override; - -protected: - void sink_it_(const details::log_msg &msg) override; - void flush_() override; - void backend_sink_it_(const details::log_msg &incoming_log_msg); - void backend_flush_(); - -private: - std::weak_ptr<details::thread_pool> thread_pool_; - async_overflow_policy overflow_policy_; -}; -} // namespace spdlog - -#ifdef SPDLOG_HEADER_ONLY - #include "async_logger-inl.h" -#endif diff --git a/thirdparty/spdlog/include/spdlog/cfg/argv.h b/thirdparty/spdlog/include/spdlog/cfg/argv.h deleted file mode 100644 index 7de2f83e7..000000000 --- a/thirdparty/spdlog/include/spdlog/cfg/argv.h +++ /dev/null @@ -1,40 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once -#include <spdlog/cfg/helpers.h> -#include <spdlog/details/registry.h> - -// -// Init log levels using each argv entry that starts with "SPDLOG_LEVEL=" -// -// set all loggers to debug level: -// example.exe "SPDLOG_LEVEL=debug" - -// set logger1 to trace level -// example.exe "SPDLOG_LEVEL=logger1=trace" - -// turn off all logging except for logger1 and logger2: -// example.exe "SPDLOG_LEVEL=off,logger1=debug,logger2=info" - -namespace spdlog { -namespace cfg { - -// search for SPDLOG_LEVEL= in the args and use it to init the levels -inline void load_argv_levels(int argc, const char **argv) { - const std::string spdlog_level_prefix = "SPDLOG_LEVEL="; - for (int i = 1; i < argc; i++) { - std::string arg = argv[i]; - if (arg.find(spdlog_level_prefix) == 0) { - auto levels_string = arg.substr(spdlog_level_prefix.size()); - helpers::load_levels(levels_string); - } - } -} - -inline void load_argv_levels(int argc, char **argv) { - load_argv_levels(argc, const_cast<const char **>(argv)); -} - -} // namespace cfg -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/cfg/env.h b/thirdparty/spdlog/include/spdlog/cfg/env.h deleted file mode 100644 index 47bf61c72..000000000 --- a/thirdparty/spdlog/include/spdlog/cfg/env.h +++ /dev/null @@ -1,36 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once -#include <spdlog/cfg/helpers.h> -#include <spdlog/details/os.h> -#include <spdlog/details/registry.h> - -// -// Init levels and patterns from env variables SPDLOG_LEVEL -// Inspired from Rust's "env_logger" crate (https://crates.io/crates/env_logger). -// Note - fallback to "info" level on unrecognized levels -// -// Examples: -// -// set global level to debug: -// export SPDLOG_LEVEL=debug -// -// turn off all logging except for logger1: -// export SPDLOG_LEVEL="*=off,logger1=debug" -// - -// turn off all logging except for logger1 and logger2: -// export SPDLOG_LEVEL="off,logger1=debug,logger2=info" - -namespace spdlog { -namespace cfg { -inline void load_env_levels(const char* var = "SPDLOG_LEVEL") { - auto env_val = details::os::getenv(var); - if (!env_val.empty()) { - helpers::load_levels(env_val); - } -} - -} // namespace cfg -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/cfg/helpers-inl.h b/thirdparty/spdlog/include/spdlog/cfg/helpers-inl.h deleted file mode 100644 index 61b9b9f64..000000000 --- a/thirdparty/spdlog/include/spdlog/cfg/helpers-inl.h +++ /dev/null @@ -1,106 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#ifndef SPDLOG_HEADER_ONLY - #include <spdlog/cfg/helpers.h> -#endif - -#include <spdlog/details/os.h> -#include <spdlog/details/registry.h> - -#include <algorithm> -#include <sstream> -#include <string> -#include <utility> - -namespace spdlog { -namespace cfg { -namespace helpers { - -// inplace convert to lowercase -inline std::string &to_lower_(std::string &str) { - std::transform(str.begin(), str.end(), str.begin(), [](char ch) { - return static_cast<char>((ch >= 'A' && ch <= 'Z') ? ch + ('a' - 'A') : ch); - }); - return str; -} - -// inplace trim spaces -inline std::string &trim_(std::string &str) { - const char *spaces = " \n\r\t"; - str.erase(str.find_last_not_of(spaces) + 1); - str.erase(0, str.find_first_not_of(spaces)); - return str; -} - -// return (name,value) trimmed pair from the given "name = value" string. -// return empty string on missing parts -// "key=val" => ("key", "val") -// " key = val " => ("key", "val") -// "key=" => ("key", "") -// "val" => ("", "val") - -inline std::pair<std::string, std::string> extract_kv_(char sep, const std::string &str) { - auto n = str.find(sep); - std::string k, v; - if (n == std::string::npos) { - v = str; - } else { - k = str.substr(0, n); - v = str.substr(n + 1); - } - return std::make_pair(trim_(k), trim_(v)); -} - -// return vector of key/value pairs from a sequence of "K1=V1,K2=V2,.." -// "a=AAA,b=BBB,c=CCC,.." => {("a","AAA"),("b","BBB"),("c", "CCC"),...} -inline std::unordered_map<std::string, std::string> extract_key_vals_(const std::string &str) { - std::string token; - std::istringstream token_stream(str); - std::unordered_map<std::string, std::string> rv{}; - while (std::getline(token_stream, token, ',')) { - if (token.empty()) { - continue; - } - auto kv = extract_kv_('=', token); - rv[kv.first] = kv.second; - } - return rv; -} - -SPDLOG_INLINE void load_levels(const std::string &input) { - if (input.empty() || input.size() >= 32768) { - return; - } - - auto key_vals = extract_key_vals_(input); - std::unordered_map<std::string, level::level_enum> levels; - level::level_enum global_level = level::info; - bool global_level_found = false; - - for (auto &name_level : key_vals) { - const auto &logger_name = name_level.first; - const auto &level_name = to_lower_(name_level.second); - auto level = level::from_str(level_name); - // ignore unrecognized level names - if (level == level::off && level_name != "off") { - continue; - } - if (logger_name.empty()) // no logger name indicates global level - { - global_level_found = true; - global_level = level; - } else { - levels[logger_name] = level; - } - } - - details::registry::instance().set_levels(std::move(levels), - global_level_found ? &global_level : nullptr); -} - -} // namespace helpers -} // namespace cfg -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/cfg/helpers.h b/thirdparty/spdlog/include/spdlog/cfg/helpers.h deleted file mode 100644 index c02381891..000000000 --- a/thirdparty/spdlog/include/spdlog/cfg/helpers.h +++ /dev/null @@ -1,29 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#include <spdlog/common.h> -#include <unordered_map> - -namespace spdlog { -namespace cfg { -namespace helpers { -// -// Init levels from given string -// -// Examples: -// -// set global level to debug: "debug" -// turn off all logging except for logger1: "off,logger1=debug" -// turn off all logging except for logger1 and logger2: "off,logger1=debug,logger2=info" -// -SPDLOG_API void load_levels(const std::string &txt); -} // namespace helpers - -} // namespace cfg -} // namespace spdlog - -#ifdef SPDLOG_HEADER_ONLY - #include "helpers-inl.h" -#endif // SPDLOG_HEADER_ONLY diff --git a/thirdparty/spdlog/include/spdlog/common-inl.h b/thirdparty/spdlog/include/spdlog/common-inl.h deleted file mode 100644 index a8a0453c1..000000000 --- a/thirdparty/spdlog/include/spdlog/common-inl.h +++ /dev/null @@ -1,68 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#ifndef SPDLOG_HEADER_ONLY - #include <spdlog/common.h> -#endif - -#include <algorithm> -#include <iterator> - -namespace spdlog { -namespace level { - -#if __cplusplus >= 201703L -constexpr -#endif - static string_view_t level_string_views[] SPDLOG_LEVEL_NAMES; - -static const char *short_level_names[] SPDLOG_SHORT_LEVEL_NAMES; - -SPDLOG_INLINE const string_view_t &to_string_view(spdlog::level::level_enum l) SPDLOG_NOEXCEPT { - return level_string_views[l]; -} - -SPDLOG_INLINE const char *to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOEXCEPT { - return short_level_names[l]; -} - -SPDLOG_INLINE spdlog::level::level_enum from_str(const std::string &name) SPDLOG_NOEXCEPT { - auto it = std::find(std::begin(level_string_views), std::end(level_string_views), name); - if (it != std::end(level_string_views)) - return static_cast<level::level_enum>(std::distance(std::begin(level_string_views), it)); - - // check also for "warn" and "err" before giving up.. - if (name == "warn") { - return level::warn; - } - if (name == "err") { - return level::err; - } - return level::off; -} -} // namespace level - -SPDLOG_INLINE spdlog_ex::spdlog_ex(std::string msg) - : msg_(std::move(msg)) {} - -SPDLOG_INLINE spdlog_ex::spdlog_ex(const std::string &msg, int last_errno) { -#ifdef SPDLOG_USE_STD_FORMAT - msg_ = std::system_error(std::error_code(last_errno, std::generic_category()), msg).what(); -#else - memory_buf_t outbuf; - fmt::format_system_error(outbuf, last_errno, msg.c_str()); - msg_ = fmt::to_string(outbuf); -#endif -} - -SPDLOG_INLINE const char *spdlog_ex::what() const SPDLOG_NOEXCEPT { return msg_.c_str(); } - -SPDLOG_INLINE void throw_spdlog_ex(const std::string &msg, int last_errno) { - SPDLOG_THROW(spdlog_ex(msg, last_errno)); -} - -SPDLOG_INLINE void throw_spdlog_ex(std::string msg) { SPDLOG_THROW(spdlog_ex(std::move(msg))); } - -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/common.h b/thirdparty/spdlog/include/spdlog/common.h deleted file mode 100644 index ba9a2e75f..000000000 --- a/thirdparty/spdlog/include/spdlog/common.h +++ /dev/null @@ -1,406 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#include <spdlog/details/null_mutex.h> -#include <spdlog/tweakme.h> - -#include <atomic> -#include <chrono> -#include <cstdio> -#include <exception> -#include <functional> -#include <initializer_list> -#include <memory> -#include <string> -#include <type_traits> - -#ifdef SPDLOG_USE_STD_FORMAT - #include <version> - #if __cpp_lib_format >= 202207L - #include <format> - #else - #include <string_view> - #endif -#endif - -#ifdef SPDLOG_COMPILED_LIB - #undef SPDLOG_HEADER_ONLY - #if defined(SPDLOG_SHARED_LIB) - #if defined(_WIN32) - #ifdef spdlog_EXPORTS - #define SPDLOG_API __declspec(dllexport) - #else // !spdlog_EXPORTS - #define SPDLOG_API __declspec(dllimport) - #endif - #else // !defined(_WIN32) - #define SPDLOG_API __attribute__((visibility("default"))) - #endif - #else // !defined(SPDLOG_SHARED_LIB) - #define SPDLOG_API - #endif - #define SPDLOG_INLINE -#else // !defined(SPDLOG_COMPILED_LIB) - #define SPDLOG_API - #define SPDLOG_HEADER_ONLY - #define SPDLOG_INLINE inline -#endif // #ifdef SPDLOG_COMPILED_LIB - -#include <spdlog/fmt/fmt.h> - -#if !defined(SPDLOG_USE_STD_FORMAT) && \ - FMT_VERSION >= 80000 // backward compatibility with fmt versions older than 8 - #define SPDLOG_FMT_RUNTIME(format_string) fmt::runtime(format_string) - #define SPDLOG_FMT_STRING(format_string) FMT_STRING(format_string) - #if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) - #include <spdlog/fmt/xchar.h> - #endif -#else - #define SPDLOG_FMT_RUNTIME(format_string) format_string - #define SPDLOG_FMT_STRING(format_string) format_string -#endif - -// visual studio up to 2013 does not support noexcept nor constexpr -#if defined(_MSC_VER) && (_MSC_VER < 1900) - #define SPDLOG_NOEXCEPT _NOEXCEPT - #define SPDLOG_CONSTEXPR -#else - #define SPDLOG_NOEXCEPT noexcept - #define SPDLOG_CONSTEXPR constexpr -#endif - -// If building with std::format, can just use constexpr, otherwise if building with fmt -// SPDLOG_CONSTEXPR_FUNC needs to be set the same as FMT_CONSTEXPR to avoid situations where -// a constexpr function in spdlog could end up calling a non-constexpr function in fmt -// depending on the compiler -// If fmt determines it can't use constexpr, we should inline the function instead -#ifdef SPDLOG_USE_STD_FORMAT - #define SPDLOG_CONSTEXPR_FUNC constexpr -#else // Being built with fmt - #if FMT_USE_CONSTEXPR - #define SPDLOG_CONSTEXPR_FUNC FMT_CONSTEXPR - #else - #define SPDLOG_CONSTEXPR_FUNC inline - #endif -#endif - -#if defined(__GNUC__) || defined(__clang__) - #define SPDLOG_DEPRECATED __attribute__((deprecated)) -#elif defined(_MSC_VER) - #define SPDLOG_DEPRECATED __declspec(deprecated) -#else - #define SPDLOG_DEPRECATED -#endif - -// disable thread local on msvc 2013 -#ifndef SPDLOG_NO_TLS - #if (defined(_MSC_VER) && (_MSC_VER < 1900)) || defined(__cplusplus_winrt) - #define SPDLOG_NO_TLS 1 - #endif -#endif - -#ifndef SPDLOG_FUNCTION - #define SPDLOG_FUNCTION static_cast<const char *>(__FUNCTION__) -#endif - -#ifdef SPDLOG_NO_EXCEPTIONS - #define SPDLOG_TRY - #define SPDLOG_THROW(ex) \ - do { \ - printf("spdlog fatal error: %s\n", ex.what()); \ - std::abort(); \ - } while (0) - #define SPDLOG_CATCH_STD -#else - #define SPDLOG_TRY try - #define SPDLOG_THROW(ex) throw(ex) - #define SPDLOG_CATCH_STD \ - catch (const std::exception &) { \ - } -#endif - -namespace spdlog { - -class formatter; - -namespace sinks { -class sink; -} - -#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) -using filename_t = std::wstring; - // allow macro expansion to occur in SPDLOG_FILENAME_T - #define SPDLOG_FILENAME_T_INNER(s) L##s - #define SPDLOG_FILENAME_T(s) SPDLOG_FILENAME_T_INNER(s) -#else -using filename_t = std::string; - #define SPDLOG_FILENAME_T(s) s -#endif - -using log_clock = std::chrono::system_clock; -using sink_ptr = std::shared_ptr<sinks::sink>; -using sinks_init_list = std::initializer_list<sink_ptr>; -using err_handler = std::function<void(const std::string &err_msg)>; -#ifdef SPDLOG_USE_STD_FORMAT -namespace fmt_lib = std; - -using string_view_t = std::string_view; -using memory_buf_t = std::string; - -template <typename... Args> - #if __cpp_lib_format >= 202207L -using format_string_t = std::format_string<Args...>; - #else -using format_string_t = std::string_view; - #endif - -template <class T, class Char = char> -struct is_convertible_to_basic_format_string - : std::integral_constant<bool, std::is_convertible<T, std::basic_string_view<Char>>::value> {}; - - #if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) -using wstring_view_t = std::wstring_view; -using wmemory_buf_t = std::wstring; - -template <typename... Args> - #if __cpp_lib_format >= 202207L -using wformat_string_t = std::wformat_string<Args...>; - #else -using wformat_string_t = std::wstring_view; - #endif - #endif - #define SPDLOG_BUF_TO_STRING(x) x -#else // use fmt lib instead of std::format -namespace fmt_lib = fmt; - -using string_view_t = fmt::basic_string_view<char>; -using memory_buf_t = fmt::basic_memory_buffer<char, 250>; - -template <typename... Args> -using format_string_t = fmt::format_string<Args...>; - -template <class T> -using remove_cvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type; - -template <typename Char> - #if FMT_VERSION >= 90101 -using fmt_runtime_string = fmt::runtime_format_string<Char>; - #else -using fmt_runtime_string = fmt::basic_runtime<Char>; - #endif - -// clang doesn't like SFINAE disabled constructor in std::is_convertible<> so have to repeat the -// condition from basic_format_string here, in addition, fmt::basic_runtime<Char> is only -// convertible to basic_format_string<Char> but not basic_string_view<Char> -template <class T, class Char = char> -struct is_convertible_to_basic_format_string - : std::integral_constant<bool, - std::is_convertible<T, fmt::basic_string_view<Char>>::value || - std::is_same<remove_cvref_t<T>, fmt_runtime_string<Char>>::value> { -}; - - #if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) -using wstring_view_t = fmt::basic_string_view<wchar_t>; -using wmemory_buf_t = fmt::basic_memory_buffer<wchar_t, 250>; - -template <typename... Args> -using wformat_string_t = fmt::wformat_string<Args...>; - #endif - #define SPDLOG_BUF_TO_STRING(x) fmt::to_string(x) -#endif - -#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT - #ifndef _WIN32 - #error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows - #endif // _WIN32 -#endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT - -template <class T> -struct is_convertible_to_any_format_string - : std::integral_constant<bool, - is_convertible_to_basic_format_string<T, char>::value || - is_convertible_to_basic_format_string<T, wchar_t>::value> {}; - -#if defined(SPDLOG_NO_ATOMIC_LEVELS) -using level_t = details::null_atomic_int; -#else -using level_t = std::atomic<int>; -#endif - -#define SPDLOG_LEVEL_TRACE 0 -#define SPDLOG_LEVEL_DEBUG 1 -#define SPDLOG_LEVEL_INFO 2 -#define SPDLOG_LEVEL_WARN 3 -#define SPDLOG_LEVEL_ERROR 4 -#define SPDLOG_LEVEL_CRITICAL 5 -#define SPDLOG_LEVEL_OFF 6 - -#if !defined(SPDLOG_ACTIVE_LEVEL) - #define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_INFO -#endif - -// Log level enum -namespace level { -enum level_enum : int { - trace = SPDLOG_LEVEL_TRACE, - debug = SPDLOG_LEVEL_DEBUG, - info = SPDLOG_LEVEL_INFO, - warn = SPDLOG_LEVEL_WARN, - err = SPDLOG_LEVEL_ERROR, - critical = SPDLOG_LEVEL_CRITICAL, - off = SPDLOG_LEVEL_OFF, - n_levels -}; - -#define SPDLOG_LEVEL_NAME_TRACE spdlog::string_view_t("trace", 5) -#define SPDLOG_LEVEL_NAME_DEBUG spdlog::string_view_t("debug", 5) -#define SPDLOG_LEVEL_NAME_INFO spdlog::string_view_t("info", 4) -#define SPDLOG_LEVEL_NAME_WARNING spdlog::string_view_t("warning", 7) -#define SPDLOG_LEVEL_NAME_ERROR spdlog::string_view_t("error", 5) -#define SPDLOG_LEVEL_NAME_CRITICAL spdlog::string_view_t("critical", 8) -#define SPDLOG_LEVEL_NAME_OFF spdlog::string_view_t("off", 3) - -#if !defined(SPDLOG_LEVEL_NAMES) - #define SPDLOG_LEVEL_NAMES \ - { \ - SPDLOG_LEVEL_NAME_TRACE, SPDLOG_LEVEL_NAME_DEBUG, SPDLOG_LEVEL_NAME_INFO, \ - SPDLOG_LEVEL_NAME_WARNING, SPDLOG_LEVEL_NAME_ERROR, SPDLOG_LEVEL_NAME_CRITICAL, \ - SPDLOG_LEVEL_NAME_OFF \ - } -#endif - -#if !defined(SPDLOG_SHORT_LEVEL_NAMES) - - #define SPDLOG_SHORT_LEVEL_NAMES \ - { "T", "D", "I", "W", "E", "C", "O" } -#endif - -SPDLOG_API const string_view_t &to_string_view(spdlog::level::level_enum l) SPDLOG_NOEXCEPT; -SPDLOG_API const char *to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOEXCEPT; -SPDLOG_API spdlog::level::level_enum from_str(const std::string &name) SPDLOG_NOEXCEPT; - -} // namespace level - -// -// Color mode used by sinks with color support. -// -enum class color_mode { always, automatic, never }; - -// -// Pattern time - specific time getting to use for pattern_formatter. -// local time by default -// -enum class pattern_time_type { - local, // log localtime - utc // log utc -}; - -// -// Log exception -// -class SPDLOG_API spdlog_ex : public std::exception { -public: - explicit spdlog_ex(std::string msg); - spdlog_ex(const std::string &msg, int last_errno); - const char *what() const SPDLOG_NOEXCEPT override; - -private: - std::string msg_; -}; - -[[noreturn]] SPDLOG_API void throw_spdlog_ex(const std::string &msg, int last_errno); -[[noreturn]] SPDLOG_API void throw_spdlog_ex(std::string msg); - -struct source_loc { - SPDLOG_CONSTEXPR source_loc() = default; - SPDLOG_CONSTEXPR source_loc(const char *filename_in, int line_in, const char *funcname_in) - : filename{filename_in}, - line{line_in}, - funcname{funcname_in} {} - - SPDLOG_CONSTEXPR bool empty() const SPDLOG_NOEXCEPT { return line <= 0; } - const char *filename{nullptr}; - int line{0}; - const char *funcname{nullptr}; -}; - -struct file_event_handlers { - file_event_handlers() - : before_open(nullptr), - after_open(nullptr), - before_close(nullptr), - after_close(nullptr) {} - - std::function<void(const filename_t &filename)> before_open; - std::function<void(const filename_t &filename, std::FILE *file_stream)> after_open; - std::function<void(const filename_t &filename, std::FILE *file_stream)> before_close; - std::function<void(const filename_t &filename)> after_close; -}; - -namespace details { - -// to_string_view - -SPDLOG_CONSTEXPR_FUNC spdlog::string_view_t to_string_view(const memory_buf_t &buf) - SPDLOG_NOEXCEPT { - return spdlog::string_view_t{buf.data(), buf.size()}; -} - -SPDLOG_CONSTEXPR_FUNC spdlog::string_view_t to_string_view(spdlog::string_view_t str) - SPDLOG_NOEXCEPT { - return str; -} - -#if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) -SPDLOG_CONSTEXPR_FUNC spdlog::wstring_view_t to_string_view(const wmemory_buf_t &buf) - SPDLOG_NOEXCEPT { - return spdlog::wstring_view_t{buf.data(), buf.size()}; -} - -SPDLOG_CONSTEXPR_FUNC spdlog::wstring_view_t to_string_view(spdlog::wstring_view_t str) - SPDLOG_NOEXCEPT { - return str; -} -#endif - -#if defined(SPDLOG_USE_STD_FORMAT) && __cpp_lib_format >= 202207L -template <typename T, typename... Args> -SPDLOG_CONSTEXPR_FUNC std::basic_string_view<T> to_string_view( - std::basic_format_string<T, Args...> fmt) SPDLOG_NOEXCEPT { - return fmt.get(); -} -#endif - -// make_unique support for pre c++14 -#if __cplusplus >= 201402L // C++14 and beyond -using std::enable_if_t; -using std::make_unique; -#else -template <bool B, class T = void> -using enable_if_t = typename std::enable_if<B, T>::type; - -template <typename T, typename... Args> -std::unique_ptr<T> make_unique(Args &&...args) { - static_assert(!std::is_array<T>::value, "arrays not supported"); - return std::unique_ptr<T>(new T(std::forward<Args>(args)...)); -} -#endif - -// to avoid useless casts (see https://github.com/nlohmann/json/issues/2893#issuecomment-889152324) -template <typename T, typename U, enable_if_t<!std::is_same<T, U>::value, int> = 0> -constexpr T conditional_static_cast(U value) { - return static_cast<T>(value); -} - -template <typename T, typename U, enable_if_t<std::is_same<T, U>::value, int> = 0> -constexpr T conditional_static_cast(U value) { - return value; -} - -} // namespace details -} // namespace spdlog - -#ifdef SPDLOG_HEADER_ONLY - #include "common-inl.h" -#endif diff --git a/thirdparty/spdlog/include/spdlog/details/backtracer-inl.h b/thirdparty/spdlog/include/spdlog/details/backtracer-inl.h deleted file mode 100644 index 43d100247..000000000 --- a/thirdparty/spdlog/include/spdlog/details/backtracer-inl.h +++ /dev/null @@ -1,63 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#ifndef SPDLOG_HEADER_ONLY - #include <spdlog/details/backtracer.h> -#endif -namespace spdlog { -namespace details { -SPDLOG_INLINE backtracer::backtracer(const backtracer &other) { - std::lock_guard<std::mutex> lock(other.mutex_); - enabled_ = other.enabled(); - messages_ = other.messages_; -} - -SPDLOG_INLINE backtracer::backtracer(backtracer &&other) SPDLOG_NOEXCEPT { - std::lock_guard<std::mutex> lock(other.mutex_); - enabled_ = other.enabled(); - messages_ = std::move(other.messages_); -} - -SPDLOG_INLINE backtracer &backtracer::operator=(backtracer other) { - std::lock_guard<std::mutex> lock(mutex_); - enabled_ = other.enabled(); - messages_ = std::move(other.messages_); - return *this; -} - -SPDLOG_INLINE void backtracer::enable(size_t size) { - std::lock_guard<std::mutex> lock{mutex_}; - enabled_.store(true, std::memory_order_relaxed); - messages_ = circular_q<log_msg_buffer>{size}; -} - -SPDLOG_INLINE void backtracer::disable() { - std::lock_guard<std::mutex> lock{mutex_}; - enabled_.store(false, std::memory_order_relaxed); -} - -SPDLOG_INLINE bool backtracer::enabled() const { return enabled_.load(std::memory_order_relaxed); } - -SPDLOG_INLINE void backtracer::push_back(const log_msg &msg) { - std::lock_guard<std::mutex> lock{mutex_}; - messages_.push_back(log_msg_buffer{msg}); -} - -SPDLOG_INLINE bool backtracer::empty() const { - std::lock_guard<std::mutex> lock{mutex_}; - return messages_.empty(); -} - -// pop all items in the q and apply the given fun on each of them. -SPDLOG_INLINE void backtracer::foreach_pop(std::function<void(const details::log_msg &)> fun) { - std::lock_guard<std::mutex> lock{mutex_}; - while (!messages_.empty()) { - auto &front_msg = messages_.front(); - fun(front_msg); - messages_.pop_front(); - } -} -} // namespace details -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/details/backtracer.h b/thirdparty/spdlog/include/spdlog/details/backtracer.h deleted file mode 100644 index 541339cdc..000000000 --- a/thirdparty/spdlog/include/spdlog/details/backtracer.h +++ /dev/null @@ -1,45 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#include <spdlog/details/circular_q.h> -#include <spdlog/details/log_msg_buffer.h> - -#include <atomic> -#include <functional> -#include <mutex> - -// Store log messages in circular buffer. -// Useful for storing debug data in case of error/warning happens. - -namespace spdlog { -namespace details { -class SPDLOG_API backtracer { - mutable std::mutex mutex_; - std::atomic<bool> enabled_{false}; - circular_q<log_msg_buffer> messages_; - -public: - backtracer() = default; - backtracer(const backtracer &other); - - backtracer(backtracer &&other) SPDLOG_NOEXCEPT; - backtracer &operator=(backtracer other); - - void enable(size_t size); - void disable(); - bool enabled() const; - void push_back(const log_msg &msg); - bool empty() const; - - // pop all items in the q and apply the given fun on each of them. - void foreach_pop(std::function<void(const details::log_msg &)> fun); -}; - -} // namespace details -} // namespace spdlog - -#ifdef SPDLOG_HEADER_ONLY - #include "backtracer-inl.h" -#endif diff --git a/thirdparty/spdlog/include/spdlog/details/circular_q.h b/thirdparty/spdlog/include/spdlog/details/circular_q.h deleted file mode 100644 index 29e9d255f..000000000 --- a/thirdparty/spdlog/include/spdlog/details/circular_q.h +++ /dev/null @@ -1,115 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -// circular q view of std::vector. -#pragma once - -#include <cassert> -#include <vector> - -#include "spdlog/common.h" - -namespace spdlog { -namespace details { -template <typename T> -class circular_q { - size_t max_items_ = 0; - typename std::vector<T>::size_type head_ = 0; - typename std::vector<T>::size_type tail_ = 0; - size_t overrun_counter_ = 0; - std::vector<T> v_; - -public: - using value_type = T; - - // empty ctor - create a disabled queue with no elements allocated at all - circular_q() = default; - - explicit circular_q(size_t max_items) - : max_items_(max_items + 1) // one item is reserved as marker for full q - , - v_(max_items_) {} - - circular_q(const circular_q &) = default; - circular_q &operator=(const circular_q &) = default; - - // move cannot be default, - // since we need to reset head_, tail_, etc to zero in the moved object - circular_q(circular_q &&other) SPDLOG_NOEXCEPT { copy_moveable(std::move(other)); } - - circular_q &operator=(circular_q &&other) SPDLOG_NOEXCEPT { - copy_moveable(std::move(other)); - return *this; - } - - // push back, overrun (oldest) item if no room left - void push_back(T &&item) { - if (max_items_ > 0) { - v_[tail_] = std::move(item); - tail_ = (tail_ + 1) % max_items_; - - if (tail_ == head_) // overrun last item if full - { - head_ = (head_ + 1) % max_items_; - ++overrun_counter_; - } - } - } - - // Return reference to the front item. - // If there are no elements in the container, the behavior is undefined. - const T &front() const { return v_[head_]; } - - T &front() { return v_[head_]; } - - // Return number of elements actually stored - size_t size() const { - if (tail_ >= head_) { - return tail_ - head_; - } else { - return max_items_ - (head_ - tail_); - } - } - - // Return const reference to item by index. - // If index is out of range 0…size()-1, the behavior is undefined. - const T &at(size_t i) const { - assert(i < size()); - return v_[(head_ + i) % max_items_]; - } - - // Pop item from front. - // If there are no elements in the container, the behavior is undefined. - void pop_front() { head_ = (head_ + 1) % max_items_; } - - bool empty() const { return tail_ == head_; } - - bool full() const { - // head is ahead of the tail by 1 - if (max_items_ > 0) { - return ((tail_ + 1) % max_items_) == head_; - } - return false; - } - - size_t overrun_counter() const { return overrun_counter_; } - - void reset_overrun_counter() { overrun_counter_ = 0; } - -private: - // copy from other&& and reset it to disabled state - void copy_moveable(circular_q &&other) SPDLOG_NOEXCEPT { - max_items_ = other.max_items_; - head_ = other.head_; - tail_ = other.tail_; - overrun_counter_ = other.overrun_counter_; - v_ = std::move(other.v_); - - // put &&other in disabled, but valid state - other.max_items_ = 0; - other.head_ = other.tail_ = 0; - other.overrun_counter_ = 0; - } -}; -} // namespace details -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/details/console_globals.h b/thirdparty/spdlog/include/spdlog/details/console_globals.h deleted file mode 100644 index 9c552106a..000000000 --- a/thirdparty/spdlog/include/spdlog/details/console_globals.h +++ /dev/null @@ -1,28 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#include <mutex> -#include <spdlog/details/null_mutex.h> - -namespace spdlog { -namespace details { - -struct console_mutex { - using mutex_t = std::mutex; - static mutex_t &mutex() { - static mutex_t s_mutex; - return s_mutex; - } -}; - -struct console_nullmutex { - using mutex_t = null_mutex; - static mutex_t &mutex() { - static mutex_t s_mutex; - return s_mutex; - } -}; -} // namespace details -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/details/file_helper-inl.h b/thirdparty/spdlog/include/spdlog/details/file_helper-inl.h deleted file mode 100644 index 0c514ef2a..000000000 --- a/thirdparty/spdlog/include/spdlog/details/file_helper-inl.h +++ /dev/null @@ -1,151 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#ifndef SPDLOG_HEADER_ONLY - #include <spdlog/details/file_helper.h> -#endif - -#include <spdlog/common.h> -#include <spdlog/details/os.h> - -#include <cerrno> -#include <cstdio> -#include <string> -#include <tuple> - -namespace spdlog { -namespace details { - -SPDLOG_INLINE file_helper::file_helper(const file_event_handlers &event_handlers) - : event_handlers_(event_handlers) {} - -SPDLOG_INLINE file_helper::~file_helper() { close(); } - -SPDLOG_INLINE void file_helper::open(const filename_t &fname, bool truncate) { - close(); - filename_ = fname; - - auto *mode = SPDLOG_FILENAME_T("ab"); - auto *trunc_mode = SPDLOG_FILENAME_T("wb"); - - if (event_handlers_.before_open) { - event_handlers_.before_open(filename_); - } - for (int tries = 0; tries < open_tries_; ++tries) { - // create containing folder if not exists already. - os::create_dir(os::dir_name(fname)); - if (truncate) { - // Truncate by opening-and-closing a tmp file in "wb" mode, always - // opening the actual log-we-write-to in "ab" mode, since that - // interacts more politely with eternal processes that might - // rotate/truncate the file underneath us. - std::FILE *tmp; - if (os::fopen_s(&tmp, fname, trunc_mode)) { - continue; - } - std::fclose(tmp); - } - if (!os::fopen_s(&fd_, fname, mode)) { - if (event_handlers_.after_open) { - event_handlers_.after_open(filename_, fd_); - } - return; - } - - details::os::sleep_for_millis(open_interval_); - } - - throw_spdlog_ex("Failed opening file " + os::filename_to_str(filename_) + " for writing", - errno); -} - -SPDLOG_INLINE void file_helper::reopen(bool truncate) { - if (filename_.empty()) { - throw_spdlog_ex("Failed re opening file - was not opened before"); - } - this->open(filename_, truncate); -} - -SPDLOG_INLINE void file_helper::flush() { - if (std::fflush(fd_) != 0) { - throw_spdlog_ex("Failed flush to file " + os::filename_to_str(filename_), errno); - } -} - -SPDLOG_INLINE void file_helper::sync() { - if (!os::fsync(fd_)) { - throw_spdlog_ex("Failed to fsync file " + os::filename_to_str(filename_), errno); - } -} - -SPDLOG_INLINE void file_helper::close() { - if (fd_ != nullptr) { - if (event_handlers_.before_close) { - event_handlers_.before_close(filename_, fd_); - } - - std::fclose(fd_); - fd_ = nullptr; - - if (event_handlers_.after_close) { - event_handlers_.after_close(filename_); - } - } -} - -SPDLOG_INLINE void file_helper::write(const memory_buf_t &buf) { - if (fd_ == nullptr) return; - size_t msg_size = buf.size(); - auto data = buf.data(); - - if (!details::os::fwrite_bytes(data, msg_size, fd_)) { - throw_spdlog_ex("Failed writing to file " + os::filename_to_str(filename_), errno); - } -} - -SPDLOG_INLINE size_t file_helper::size() const { - if (fd_ == nullptr) { - throw_spdlog_ex("Cannot use size() on closed file " + os::filename_to_str(filename_)); - } - return os::filesize(fd_); -} - -SPDLOG_INLINE const filename_t &file_helper::filename() const { return filename_; } - -// -// return file path and its extension: -// -// "mylog.txt" => ("mylog", ".txt") -// "mylog" => ("mylog", "") -// "mylog." => ("mylog.", "") -// "/dir1/dir2/mylog.txt" => ("/dir1/dir2/mylog", ".txt") -// -// the starting dot in filenames is ignored (hidden files): -// -// ".mylog" => (".mylog". "") -// "my_folder/.mylog" => ("my_folder/.mylog", "") -// "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt") -SPDLOG_INLINE std::tuple<filename_t, filename_t> file_helper::split_by_extension( - const filename_t &fname) { - auto ext_index = fname.rfind('.'); - - // no valid extension found - return whole path and empty string as - // extension - if (ext_index == filename_t::npos || ext_index == 0 || ext_index == fname.size() - 1) { - return std::make_tuple(fname, filename_t()); - } - - // treat cases like "/etc/rc.d/somelogfile or "/abc/.hiddenfile" - auto folder_index = fname.find_last_of(details::os::folder_seps_filename); - if (folder_index != filename_t::npos && folder_index >= ext_index - 1) { - return std::make_tuple(fname, filename_t()); - } - - // finally - return a valid base and extension tuple - return std::make_tuple(fname.substr(0, ext_index), fname.substr(ext_index)); -} - -} // namespace details -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/details/file_helper.h b/thirdparty/spdlog/include/spdlog/details/file_helper.h deleted file mode 100644 index f0e5d180e..000000000 --- a/thirdparty/spdlog/include/spdlog/details/file_helper.h +++ /dev/null @@ -1,61 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#include <spdlog/common.h> -#include <tuple> - -namespace spdlog { -namespace details { - -// Helper class for file sinks. -// When failing to open a file, retry several times(5) with a delay interval(10 ms). -// Throw spdlog_ex exception on errors. - -class SPDLOG_API file_helper { -public: - file_helper() = default; - explicit file_helper(const file_event_handlers &event_handlers); - - file_helper(const file_helper &) = delete; - file_helper &operator=(const file_helper &) = delete; - ~file_helper(); - - void open(const filename_t &fname, bool truncate = false); - void reopen(bool truncate); - void flush(); - void sync(); - void close(); - void write(const memory_buf_t &buf); - size_t size() const; - const filename_t &filename() const; - - // - // return file path and its extension: - // - // "mylog.txt" => ("mylog", ".txt") - // "mylog" => ("mylog", "") - // "mylog." => ("mylog.", "") - // "/dir1/dir2/mylog.txt" => ("/dir1/dir2/mylog", ".txt") - // - // the starting dot in filenames is ignored (hidden files): - // - // ".mylog" => (".mylog". "") - // "my_folder/.mylog" => ("my_folder/.mylog", "") - // "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt") - static std::tuple<filename_t, filename_t> split_by_extension(const filename_t &fname); - -private: - const int open_tries_ = 5; - const unsigned int open_interval_ = 10; - std::FILE *fd_{nullptr}; - filename_t filename_; - file_event_handlers event_handlers_; -}; -} // namespace details -} // namespace spdlog - -#ifdef SPDLOG_HEADER_ONLY - #include "file_helper-inl.h" -#endif diff --git a/thirdparty/spdlog/include/spdlog/details/fmt_helper.h b/thirdparty/spdlog/include/spdlog/details/fmt_helper.h deleted file mode 100644 index 61306003b..000000000 --- a/thirdparty/spdlog/include/spdlog/details/fmt_helper.h +++ /dev/null @@ -1,141 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -#pragma once - -#include <chrono> -#include <iterator> -#include <spdlog/common.h> -#include <spdlog/fmt/fmt.h> -#include <type_traits> - -#ifdef SPDLOG_USE_STD_FORMAT - #include <charconv> - #include <limits> -#endif - -// Some fmt helpers to efficiently format and pad ints and strings -namespace spdlog { -namespace details { -namespace fmt_helper { - -inline void append_string_view(spdlog::string_view_t view, memory_buf_t &dest) { - auto *buf_ptr = view.data(); - dest.append(buf_ptr, buf_ptr + view.size()); -} - -#ifdef SPDLOG_USE_STD_FORMAT -template <typename T> -inline void append_int(T n, memory_buf_t &dest) { - // Buffer should be large enough to hold all digits (digits10 + 1) and a sign - SPDLOG_CONSTEXPR const auto BUF_SIZE = std::numeric_limits<T>::digits10 + 2; - char buf[BUF_SIZE]; - - auto [ptr, ec] = std::to_chars(buf, buf + BUF_SIZE, n, 10); - if (ec == std::errc()) { - dest.append(buf, ptr); - } else { - throw_spdlog_ex("Failed to format int", static_cast<int>(ec)); - } -} -#else -template <typename T> -inline void append_int(T n, memory_buf_t &dest) { - fmt::format_int i(n); - dest.append(i.data(), i.data() + i.size()); -} -#endif - -template <typename T> -SPDLOG_CONSTEXPR_FUNC unsigned int count_digits_fallback(T n) { - // taken from fmt: https://github.com/fmtlib/fmt/blob/8.0.1/include/fmt/format.h#L899-L912 - unsigned int count = 1; - for (;;) { - // Integer division is slow so do it for a group of four digits instead - // of for every digit. The idea comes from the talk by Alexandrescu - // "Three Optimization Tips for C++". See speed-test for a comparison. - if (n < 10) return count; - if (n < 100) return count + 1; - if (n < 1000) return count + 2; - if (n < 10000) return count + 3; - n /= 10000u; - count += 4; - } -} - -template <typename T> -inline unsigned int count_digits(T n) { - using count_type = - typename std::conditional<(sizeof(T) > sizeof(uint32_t)), uint64_t, uint32_t>::type; -#ifdef SPDLOG_USE_STD_FORMAT - return count_digits_fallback(static_cast<count_type>(n)); -#else - return static_cast<unsigned int>(fmt:: - // fmt 7.0.0 renamed the internal namespace to detail. - // See: https://github.com/fmtlib/fmt/issues/1538 - #if FMT_VERSION < 70000 - internal - #else - detail - #endif - ::count_digits(static_cast<count_type>(n))); -#endif -} - -inline void pad2(int n, memory_buf_t &dest) { - if (n >= 0 && n < 100) // 0-99 - { - dest.push_back(static_cast<char>('0' + n / 10)); - dest.push_back(static_cast<char>('0' + n % 10)); - } else // unlikely, but just in case, let fmt deal with it - { - fmt_lib::format_to(std::back_inserter(dest), SPDLOG_FMT_STRING("{:02}"), n); - } -} - -template <typename T> -inline void pad_uint(T n, unsigned int width, memory_buf_t &dest) { - static_assert(std::is_unsigned<T>::value, "pad_uint must get unsigned T"); - for (auto digits = count_digits(n); digits < width; digits++) { - dest.push_back('0'); - } - append_int(n, dest); -} - -template <typename T> -inline void pad3(T n, memory_buf_t &dest) { - static_assert(std::is_unsigned<T>::value, "pad3 must get unsigned T"); - if (n < 1000) { - dest.push_back(static_cast<char>(n / 100 + '0')); - n = n % 100; - dest.push_back(static_cast<char>((n / 10) + '0')); - dest.push_back(static_cast<char>((n % 10) + '0')); - } else { - append_int(n, dest); - } -} - -template <typename T> -inline void pad6(T n, memory_buf_t &dest) { - pad_uint(n, 6, dest); -} - -template <typename T> -inline void pad9(T n, memory_buf_t &dest) { - pad_uint(n, 9, dest); -} - -// return fraction of a second of the given time_point. -// e.g. -// fraction<std::milliseconds>(tp) -> will return the millis part of the second -template <typename ToDuration> -inline ToDuration time_fraction(log_clock::time_point tp) { - using std::chrono::duration_cast; - using std::chrono::seconds; - auto duration = tp.time_since_epoch(); - auto secs = duration_cast<seconds>(duration); - return duration_cast<ToDuration>(duration) - duration_cast<ToDuration>(secs); -} - -} // namespace fmt_helper -} // namespace details -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/details/log_msg-inl.h b/thirdparty/spdlog/include/spdlog/details/log_msg-inl.h deleted file mode 100644 index aa3a95768..000000000 --- a/thirdparty/spdlog/include/spdlog/details/log_msg-inl.h +++ /dev/null @@ -1,44 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#ifndef SPDLOG_HEADER_ONLY - #include <spdlog/details/log_msg.h> -#endif - -#include <spdlog/details/os.h> - -namespace spdlog { -namespace details { - -SPDLOG_INLINE log_msg::log_msg(spdlog::log_clock::time_point log_time, - spdlog::source_loc loc, - string_view_t a_logger_name, - spdlog::level::level_enum lvl, - spdlog::string_view_t msg) - : logger_name(a_logger_name), - level(lvl), - time(log_time) -#ifndef SPDLOG_NO_THREAD_ID - , - thread_id(os::thread_id()) -#endif - , - source(loc), - payload(msg) { -} - -SPDLOG_INLINE log_msg::log_msg(spdlog::source_loc loc, - string_view_t a_logger_name, - spdlog::level::level_enum lvl, - spdlog::string_view_t msg) - : log_msg(os::now(), loc, a_logger_name, lvl, msg) {} - -SPDLOG_INLINE log_msg::log_msg(string_view_t a_logger_name, - spdlog::level::level_enum lvl, - spdlog::string_view_t msg) - : log_msg(os::now(), source_loc{}, a_logger_name, lvl, msg) {} - -} // namespace details -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/details/log_msg.h b/thirdparty/spdlog/include/spdlog/details/log_msg.h deleted file mode 100644 index 87df1e833..000000000 --- a/thirdparty/spdlog/include/spdlog/details/log_msg.h +++ /dev/null @@ -1,40 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#include <spdlog/common.h> -#include <string> - -namespace spdlog { -namespace details { -struct SPDLOG_API log_msg { - log_msg() = default; - log_msg(log_clock::time_point log_time, - source_loc loc, - string_view_t logger_name, - level::level_enum lvl, - string_view_t msg); - log_msg(source_loc loc, string_view_t logger_name, level::level_enum lvl, string_view_t msg); - log_msg(string_view_t logger_name, level::level_enum lvl, string_view_t msg); - log_msg(const log_msg &other) = default; - log_msg &operator=(const log_msg &other) = default; - - string_view_t logger_name; - level::level_enum level{level::off}; - log_clock::time_point time; - size_t thread_id{0}; - - // wrapping the formatted text with color (updated by pattern_formatter). - mutable size_t color_range_start{0}; - mutable size_t color_range_end{0}; - - source_loc source; - string_view_t payload; -}; -} // namespace details -} // namespace spdlog - -#ifdef SPDLOG_HEADER_ONLY - #include "log_msg-inl.h" -#endif diff --git a/thirdparty/spdlog/include/spdlog/details/log_msg_buffer-inl.h b/thirdparty/spdlog/include/spdlog/details/log_msg_buffer-inl.h deleted file mode 100644 index 2eb242859..000000000 --- a/thirdparty/spdlog/include/spdlog/details/log_msg_buffer-inl.h +++ /dev/null @@ -1,54 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#ifndef SPDLOG_HEADER_ONLY - #include <spdlog/details/log_msg_buffer.h> -#endif - -namespace spdlog { -namespace details { - -SPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg &orig_msg) - : log_msg{orig_msg} { - buffer.append(logger_name.begin(), logger_name.end()); - buffer.append(payload.begin(), payload.end()); - update_string_views(); -} - -SPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg_buffer &other) - : log_msg{other} { - buffer.append(logger_name.begin(), logger_name.end()); - buffer.append(payload.begin(), payload.end()); - update_string_views(); -} - -SPDLOG_INLINE log_msg_buffer::log_msg_buffer(log_msg_buffer &&other) SPDLOG_NOEXCEPT - : log_msg{other}, - buffer{std::move(other.buffer)} { - update_string_views(); -} - -SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(const log_msg_buffer &other) { - log_msg::operator=(other); - buffer.clear(); - buffer.append(other.buffer.data(), other.buffer.data() + other.buffer.size()); - update_string_views(); - return *this; -} - -SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(log_msg_buffer &&other) SPDLOG_NOEXCEPT { - log_msg::operator=(other); - buffer = std::move(other.buffer); - update_string_views(); - return *this; -} - -SPDLOG_INLINE void log_msg_buffer::update_string_views() { - logger_name = string_view_t{buffer.data(), logger_name.size()}; - payload = string_view_t{buffer.data() + logger_name.size(), payload.size()}; -} - -} // namespace details -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/details/log_msg_buffer.h b/thirdparty/spdlog/include/spdlog/details/log_msg_buffer.h deleted file mode 100644 index 1143b3ba4..000000000 --- a/thirdparty/spdlog/include/spdlog/details/log_msg_buffer.h +++ /dev/null @@ -1,32 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#include <spdlog/details/log_msg.h> - -namespace spdlog { -namespace details { - -// Extend log_msg with internal buffer to store its payload. -// This is needed since log_msg holds string_views that points to stack data. - -class SPDLOG_API log_msg_buffer : public log_msg { - memory_buf_t buffer; - void update_string_views(); - -public: - log_msg_buffer() = default; - explicit log_msg_buffer(const log_msg &orig_msg); - log_msg_buffer(const log_msg_buffer &other); - log_msg_buffer(log_msg_buffer &&other) SPDLOG_NOEXCEPT; - log_msg_buffer &operator=(const log_msg_buffer &other); - log_msg_buffer &operator=(log_msg_buffer &&other) SPDLOG_NOEXCEPT; -}; - -} // namespace details -} // namespace spdlog - -#ifdef SPDLOG_HEADER_ONLY - #include "log_msg_buffer-inl.h" -#endif diff --git a/thirdparty/spdlog/include/spdlog/details/mpmc_blocking_q.h b/thirdparty/spdlog/include/spdlog/details/mpmc_blocking_q.h deleted file mode 100644 index 5848cca83..000000000 --- a/thirdparty/spdlog/include/spdlog/details/mpmc_blocking_q.h +++ /dev/null @@ -1,177 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -// multi producer-multi consumer blocking queue. -// enqueue(..) - will block until room found to put the new message. -// enqueue_nowait(..) - will return immediately with false if no room left in -// the queue. -// dequeue_for(..) - will block until the queue is not empty or timeout have -// passed. - -#include <spdlog/details/circular_q.h> - -#include <atomic> -#include <condition_variable> -#include <mutex> - -namespace spdlog { -namespace details { - -template <typename T> -class mpmc_blocking_queue { -public: - using item_type = T; - explicit mpmc_blocking_queue(size_t max_items) - : q_(max_items) {} - -#ifndef __MINGW32__ - // try to enqueue and block if no room left - void enqueue(T &&item) { - { - std::unique_lock<std::mutex> lock(queue_mutex_); - pop_cv_.wait(lock, [this] { return !this->q_.full(); }); - q_.push_back(std::move(item)); - } - push_cv_.notify_one(); - } - - // enqueue immediately. overrun oldest message in the queue if no room left. - void enqueue_nowait(T &&item) { - { - std::unique_lock<std::mutex> lock(queue_mutex_); - q_.push_back(std::move(item)); - } - push_cv_.notify_one(); - } - - void enqueue_if_have_room(T &&item) { - bool pushed = false; - { - std::unique_lock<std::mutex> lock(queue_mutex_); - if (!q_.full()) { - q_.push_back(std::move(item)); - pushed = true; - } - } - - if (pushed) { - push_cv_.notify_one(); - } else { - ++discard_counter_; - } - } - - // dequeue with a timeout. - // Return true, if succeeded dequeue item, false otherwise - bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration) { - { - std::unique_lock<std::mutex> lock(queue_mutex_); - if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); })) { - return false; - } - popped_item = std::move(q_.front()); - q_.pop_front(); - } - pop_cv_.notify_one(); - return true; - } - - // blocking dequeue without a timeout. - void dequeue(T &popped_item) { - { - std::unique_lock<std::mutex> lock(queue_mutex_); - push_cv_.wait(lock, [this] { return !this->q_.empty(); }); - popped_item = std::move(q_.front()); - q_.pop_front(); - } - pop_cv_.notify_one(); - } - -#else - // apparently mingw deadlocks if the mutex is released before cv.notify_one(), - // so release the mutex at the very end each function. - - // try to enqueue and block if no room left - void enqueue(T &&item) { - std::unique_lock<std::mutex> lock(queue_mutex_); - pop_cv_.wait(lock, [this] { return !this->q_.full(); }); - q_.push_back(std::move(item)); - push_cv_.notify_one(); - } - - // enqueue immediately. overrun oldest message in the queue if no room left. - void enqueue_nowait(T &&item) { - std::unique_lock<std::mutex> lock(queue_mutex_); - q_.push_back(std::move(item)); - push_cv_.notify_one(); - } - - void enqueue_if_have_room(T &&item) { - bool pushed = false; - std::unique_lock<std::mutex> lock(queue_mutex_); - if (!q_.full()) { - q_.push_back(std::move(item)); - pushed = true; - } - - if (pushed) { - push_cv_.notify_one(); - } else { - ++discard_counter_; - } - } - - // dequeue with a timeout. - // Return true, if succeeded dequeue item, false otherwise - bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration) { - std::unique_lock<std::mutex> lock(queue_mutex_); - if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); })) { - return false; - } - popped_item = std::move(q_.front()); - q_.pop_front(); - pop_cv_.notify_one(); - return true; - } - - // blocking dequeue without a timeout. - void dequeue(T &popped_item) { - std::unique_lock<std::mutex> lock(queue_mutex_); - push_cv_.wait(lock, [this] { return !this->q_.empty(); }); - popped_item = std::move(q_.front()); - q_.pop_front(); - pop_cv_.notify_one(); - } - -#endif - - size_t overrun_counter() { - std::lock_guard<std::mutex> lock(queue_mutex_); - return q_.overrun_counter(); - } - - size_t discard_counter() { return discard_counter_.load(std::memory_order_relaxed); } - - size_t size() { - std::lock_guard<std::mutex> lock(queue_mutex_); - return q_.size(); - } - - void reset_overrun_counter() { - std::lock_guard<std::mutex> lock(queue_mutex_); - q_.reset_overrun_counter(); - } - - void reset_discard_counter() { discard_counter_.store(0, std::memory_order_relaxed); } - -private: - std::mutex queue_mutex_; - std::condition_variable push_cv_; - std::condition_variable pop_cv_; - spdlog::details::circular_q<T> q_; - std::atomic<size_t> discard_counter_{0}; -}; -} // namespace details -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/details/null_mutex.h b/thirdparty/spdlog/include/spdlog/details/null_mutex.h deleted file mode 100644 index e3b322041..000000000 --- a/thirdparty/spdlog/include/spdlog/details/null_mutex.h +++ /dev/null @@ -1,35 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#include <atomic> -#include <utility> -// null, no cost dummy "mutex" and dummy "atomic" int - -namespace spdlog { -namespace details { -struct null_mutex { - void lock() const {} - void unlock() const {} -}; - -struct null_atomic_int { - int value; - null_atomic_int() = default; - - explicit null_atomic_int(int new_value) - : value(new_value) {} - - int load(std::memory_order = std::memory_order_relaxed) const { return value; } - - void store(int new_value, std::memory_order = std::memory_order_relaxed) { value = new_value; } - - int exchange(int new_value, std::memory_order = std::memory_order_relaxed) { - std::swap(new_value, value); - return new_value; // return value before the call - } -}; - -} // namespace details -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/details/os-inl.h b/thirdparty/spdlog/include/spdlog/details/os-inl.h deleted file mode 100644 index edbbd5c25..000000000 --- a/thirdparty/spdlog/include/spdlog/details/os-inl.h +++ /dev/null @@ -1,605 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#ifndef SPDLOG_HEADER_ONLY - #include <spdlog/details/os.h> -#endif - -#include <spdlog/common.h> - -#include <algorithm> -#include <array> -#include <chrono> -#include <cstdio> -#include <cstdlib> -#include <cstring> -#include <ctime> -#include <string> -#include <sys/stat.h> -#include <sys/types.h> -#include <thread> - -#ifdef _WIN32 - #include <spdlog/details/windows_include.h> - #include <io.h> // for _get_osfhandle, _isatty, _fileno - #include <process.h> // for _get_pid - - #ifdef __MINGW32__ - #include <share.h> - #endif - - #if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES) - #include <cassert> - #include <limits> - #endif - - #include <direct.h> // for _mkdir/_wmkdir - -#else // unix - - #include <fcntl.h> - #include <unistd.h> - - #ifdef __linux__ - #include <sys/syscall.h> //Use gettid() syscall under linux to get thread id - - #elif defined(_AIX) - #include <pthread.h> // for pthread_getthrds_np - - #elif defined(__DragonFly__) || defined(__FreeBSD__) - #include <pthread_np.h> // for pthread_getthreadid_np - - #elif defined(__NetBSD__) - #include <lwp.h> // for _lwp_self - - #elif defined(__sun) - #include <thread.h> // for thr_self - #endif - -#endif // unix - -#if defined __APPLE__ - #include <AvailabilityMacros.h> -#endif - -#ifndef __has_feature // Clang - feature checking macros. - #define __has_feature(x) 0 // Compatibility with non-clang compilers. -#endif - -namespace spdlog { -namespace details { -namespace os { - -SPDLOG_INLINE spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT { -#if defined __linux__ && defined SPDLOG_CLOCK_COARSE - timespec ts; - ::clock_gettime(CLOCK_REALTIME_COARSE, &ts); - return std::chrono::time_point<log_clock, typename log_clock::duration>( - std::chrono::duration_cast<typename log_clock::duration>( - std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec))); - -#else - return log_clock::now(); -#endif -} -SPDLOG_INLINE std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT { -#ifdef _WIN32 - std::tm tm; - ::localtime_s(&tm, &time_tt); -#else - std::tm tm; - ::localtime_r(&time_tt, &tm); -#endif - return tm; -} - -SPDLOG_INLINE std::tm localtime() SPDLOG_NOEXCEPT { - std::time_t now_t = ::time(nullptr); - return localtime(now_t); -} - -SPDLOG_INLINE std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT { -#ifdef _WIN32 - std::tm tm; - ::gmtime_s(&tm, &time_tt); -#else - std::tm tm; - ::gmtime_r(&time_tt, &tm); -#endif - return tm; -} - -SPDLOG_INLINE std::tm gmtime() SPDLOG_NOEXCEPT { - std::time_t now_t = ::time(nullptr); - return gmtime(now_t); -} - -// fopen_s on non windows for writing -SPDLOG_INLINE bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode) { -#ifdef _WIN32 - #ifdef SPDLOG_WCHAR_FILENAMES - *fp = ::_wfsopen((filename.c_str()), mode.c_str(), _SH_DENYNO); - #else - *fp = ::_fsopen((filename.c_str()), mode.c_str(), _SH_DENYNO); - #endif - #if defined(SPDLOG_PREVENT_CHILD_FD) - if (*fp != nullptr) { - auto file_handle = reinterpret_cast<HANDLE>(_get_osfhandle(::_fileno(*fp))); - if (!::SetHandleInformation(file_handle, HANDLE_FLAG_INHERIT, 0)) { - ::fclose(*fp); - *fp = nullptr; - } - } - #endif -#else // unix - #if defined(SPDLOG_PREVENT_CHILD_FD) - const int mode_flag = mode == SPDLOG_FILENAME_T("ab") ? O_APPEND : O_TRUNC; - const int fd = - ::open((filename.c_str()), O_CREAT | O_WRONLY | O_CLOEXEC | mode_flag, mode_t(0644)); - if (fd == -1) { - return true; - } - *fp = ::fdopen(fd, mode.c_str()); - if (*fp == nullptr) { - ::close(fd); - } - #else - *fp = ::fopen((filename.c_str()), mode.c_str()); - #endif -#endif - - return *fp == nullptr; -} - -SPDLOG_INLINE int remove(const filename_t &filename) SPDLOG_NOEXCEPT { -#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) - return ::_wremove(filename.c_str()); -#else - return std::remove(filename.c_str()); -#endif -} - -SPDLOG_INLINE int remove_if_exists(const filename_t &filename) SPDLOG_NOEXCEPT { - return path_exists(filename) ? remove(filename) : 0; -} - -SPDLOG_INLINE int rename(const filename_t &filename1, const filename_t &filename2) SPDLOG_NOEXCEPT { -#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) - return ::_wrename(filename1.c_str(), filename2.c_str()); -#else - return std::rename(filename1.c_str(), filename2.c_str()); -#endif -} - -// Return true if path exists (file or directory) -SPDLOG_INLINE bool path_exists(const filename_t &filename) SPDLOG_NOEXCEPT { -#ifdef _WIN32 - struct _stat buffer; - #ifdef SPDLOG_WCHAR_FILENAMES - return (::_wstat(filename.c_str(), &buffer) == 0); - #else - return (::_stat(filename.c_str(), &buffer) == 0); - #endif -#else // common linux/unix all have the stat system call - struct stat buffer; - return (::stat(filename.c_str(), &buffer) == 0); -#endif -} - -#ifdef _MSC_VER - // avoid warning about unreachable statement at the end of filesize() - #pragma warning(push) - #pragma warning(disable : 4702) -#endif - -// Return file size according to open FILE* object -SPDLOG_INLINE size_t filesize(FILE *f) { - if (f == nullptr) { - throw_spdlog_ex("Failed getting file size. fd is null"); - } -#if defined(_WIN32) && !defined(__CYGWIN__) - int fd = ::_fileno(f); - #if defined(_WIN64) // 64 bits - __int64 ret = ::_filelengthi64(fd); - if (ret >= 0) { - return static_cast<size_t>(ret); - } - - #else // windows 32 bits - long ret = ::_filelength(fd); - if (ret >= 0) { - return static_cast<size_t>(ret); - } - #endif - -#else // unix - // OpenBSD and AIX doesn't compile with :: before the fileno(..) - #if defined(__OpenBSD__) || defined(_AIX) - int fd = fileno(f); - #else - int fd = ::fileno(f); - #endif - // 64 bits(but not in osx, linux/musl or cygwin, where fstat64 is deprecated) - #if ((defined(__linux__) && defined(__GLIBC__)) || defined(__sun) || defined(_AIX)) && \ - (defined(__LP64__) || defined(_LP64)) - struct stat64 st; - if (::fstat64(fd, &st) == 0) { - return static_cast<size_t>(st.st_size); - } - #else // other unix or linux 32 bits or cygwin - struct stat st; - if (::fstat(fd, &st) == 0) { - return static_cast<size_t>(st.st_size); - } - #endif -#endif - throw_spdlog_ex("Failed getting file size from fd", errno); - return 0; // will not be reached. -} - -#ifdef _MSC_VER - #pragma warning(pop) -#endif - -// Return utc offset in minutes or throw spdlog_ex on failure -SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm) { -#ifdef _WIN32 - #if _WIN32_WINNT < _WIN32_WINNT_WS08 - TIME_ZONE_INFORMATION tzinfo; - auto rv = ::GetTimeZoneInformation(&tzinfo); - #else - DYNAMIC_TIME_ZONE_INFORMATION tzinfo; - auto rv = ::GetDynamicTimeZoneInformation(&tzinfo); - #endif - if (rv == TIME_ZONE_ID_INVALID) throw_spdlog_ex("Failed getting timezone info. ", errno); - - int offset = -tzinfo.Bias; - if (tm.tm_isdst) { - offset -= tzinfo.DaylightBias; - } else { - offset -= tzinfo.StandardBias; - } - return offset; -#else - - #if defined(sun) || defined(__sun) || defined(_AIX) || \ - (defined(__NEWLIB__) && !defined(__TM_GMTOFF)) || \ - (!defined(__APPLE__) && !defined(_BSD_SOURCE) && !defined(_GNU_SOURCE) && \ - (!defined(_POSIX_VERSION) || (_POSIX_VERSION < 202405L))) - // 'tm_gmtoff' field is BSD extension and it's missing on SunOS/Solaris - struct helper { - static long int calculate_gmt_offset(const std::tm &localtm = details::os::localtime(), - const std::tm &gmtm = details::os::gmtime()) { - int local_year = localtm.tm_year + (1900 - 1); - int gmt_year = gmtm.tm_year + (1900 - 1); - - long int days = ( - // difference in day of year - localtm.tm_yday - - gmtm.tm_yday - - // + intervening leap days - + ((local_year >> 2) - (gmt_year >> 2)) - (local_year / 100 - gmt_year / 100) + - ((local_year / 100 >> 2) - (gmt_year / 100 >> 2)) - - // + difference in years * 365 */ - + static_cast<long int>(local_year - gmt_year) * 365); - - long int hours = (24 * days) + (localtm.tm_hour - gmtm.tm_hour); - long int mins = (60 * hours) + (localtm.tm_min - gmtm.tm_min); - long int secs = (60 * mins) + (localtm.tm_sec - gmtm.tm_sec); - - return secs; - } - }; - - auto offset_seconds = helper::calculate_gmt_offset(tm); - #else - auto offset_seconds = tm.tm_gmtoff; - #endif - - return static_cast<int>(offset_seconds / 60); -#endif -} - -// Return current thread id as size_t -// It exists because the std::this_thread::get_id() is much slower(especially -// under VS 2013) -SPDLOG_INLINE size_t _thread_id() SPDLOG_NOEXCEPT { -#ifdef _WIN32 - return static_cast<size_t>(::GetCurrentThreadId()); -#elif defined(__linux__) - #if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21) - #define SYS_gettid __NR_gettid - #endif - return static_cast<size_t>(::syscall(SYS_gettid)); -#elif defined(_AIX) - struct __pthrdsinfo buf; - int reg_size = 0; - pthread_t pt = pthread_self(); - int retval = pthread_getthrds_np(&pt, PTHRDSINFO_QUERY_TID, &buf, sizeof(buf), NULL, ®_size); - int tid = (!retval) ? buf.__pi_tid : 0; - return static_cast<size_t>(tid); -#elif defined(__DragonFly__) || defined(__FreeBSD__) - return static_cast<size_t>(::pthread_getthreadid_np()); -#elif defined(__NetBSD__) - return static_cast<size_t>(::_lwp_self()); -#elif defined(__OpenBSD__) - return static_cast<size_t>(::getthrid()); -#elif defined(__sun) - return static_cast<size_t>(::thr_self()); -#elif __APPLE__ - uint64_t tid; - // There is no pthread_threadid_np prior to Mac OS X 10.6, and it is not supported on any PPC, - // including 10.6.8 Rosetta. __POWERPC__ is Apple-specific define encompassing ppc and ppc64. - #ifdef MAC_OS_X_VERSION_MAX_ALLOWED - { - #if (MAC_OS_X_VERSION_MAX_ALLOWED < 1060) || defined(__POWERPC__) - tid = pthread_mach_thread_np(pthread_self()); - #elif MAC_OS_X_VERSION_MIN_REQUIRED < 1060 - if (&pthread_threadid_np) { - pthread_threadid_np(nullptr, &tid); - } else { - tid = pthread_mach_thread_np(pthread_self()); - } - #else - pthread_threadid_np(nullptr, &tid); - #endif - } - #else - pthread_threadid_np(nullptr, &tid); - #endif - return static_cast<size_t>(tid); -#else // Default to standard C++11 (other Unix) - return static_cast<size_t>(std::hash<std::thread::id>()(std::this_thread::get_id())); -#endif -} - -// Return current thread id as size_t (from thread local storage) -SPDLOG_INLINE size_t thread_id() SPDLOG_NOEXCEPT { -#if defined(SPDLOG_NO_TLS) - return _thread_id(); -#else // cache thread id in tls - static thread_local const size_t tid = _thread_id(); - return tid; -#endif -} - -// This is avoid msvc issue in sleep_for that happens if the clock changes. -// See https://github.com/gabime/spdlog/issues/609 -SPDLOG_INLINE void sleep_for_millis(unsigned int milliseconds) SPDLOG_NOEXCEPT { -#if defined(_WIN32) - ::Sleep(milliseconds); -#else - std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds)); -#endif -} - -// wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined) -#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) -SPDLOG_INLINE std::string filename_to_str(const filename_t &filename) { - memory_buf_t buf; - wstr_to_utf8buf(filename, buf); - return SPDLOG_BUF_TO_STRING(buf); -} -#else -SPDLOG_INLINE std::string filename_to_str(const filename_t &filename) { return filename; } -#endif - -SPDLOG_INLINE int pid() SPDLOG_NOEXCEPT { -#ifdef _WIN32 - return conditional_static_cast<int>(::GetCurrentProcessId()); -#else - return conditional_static_cast<int>(::getpid()); -#endif -} - -// Determine if the terminal supports colors -// Based on: https://github.com/agauniyal/rang/ -SPDLOG_INLINE bool is_color_terminal() SPDLOG_NOEXCEPT { -#ifdef _WIN32 - return true; -#else - - static const bool result = []() { - const char *env_colorterm_p = std::getenv("COLORTERM"); - if (env_colorterm_p != nullptr) { - return true; - } - - static constexpr std::array<const char *, 16> terms = { - {"ansi", "color", "console", "cygwin", "gnome", "konsole", "kterm", "linux", "msys", - "putty", "rxvt", "screen", "vt100", "xterm", "alacritty", "vt102"}}; - - const char *env_term_p = std::getenv("TERM"); - if (env_term_p == nullptr) { - return false; - } - - return std::any_of(terms.begin(), terms.end(), [&](const char *term) { - return std::strstr(env_term_p, term) != nullptr; - }); - }(); - - return result; -#endif -} - -// Determine if the terminal attached -// Source: https://github.com/agauniyal/rang/ -SPDLOG_INLINE bool in_terminal(FILE *file) SPDLOG_NOEXCEPT { -#ifdef _WIN32 - return ::_isatty(_fileno(file)) != 0; -#else - return ::isatty(fileno(file)) != 0; -#endif -} - -#if (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32) -SPDLOG_INLINE void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target) { - if (wstr.size() > static_cast<size_t>((std::numeric_limits<int>::max)()) / 4 - 1) { - throw_spdlog_ex("UTF-16 string is too big to be converted to UTF-8"); - } - - int wstr_size = static_cast<int>(wstr.size()); - if (wstr_size == 0) { - target.resize(0); - return; - } - - int result_size = static_cast<int>(target.capacity()); - if ((wstr_size + 1) * 4 > result_size) { - result_size = - ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, NULL, 0, NULL, NULL); - } - - if (result_size > 0) { - target.resize(result_size); - result_size = ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, target.data(), - result_size, NULL, NULL); - - if (result_size > 0) { - target.resize(result_size); - return; - } - } - - throw_spdlog_ex( - fmt_lib::format("WideCharToMultiByte failed. Last error: {}", ::GetLastError())); -} - -SPDLOG_INLINE void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target) { - if (str.size() > static_cast<size_t>((std::numeric_limits<int>::max)()) - 1) { - throw_spdlog_ex("UTF-8 string is too big to be converted to UTF-16"); - } - - int str_size = static_cast<int>(str.size()); - if (str_size == 0) { - target.resize(0); - return; - } - - // find the size to allocate for the result buffer - int result_size = ::MultiByteToWideChar(CP_UTF8, 0, str.data(), str_size, NULL, 0); - - if (result_size > 0) { - target.resize(result_size); - result_size = - ::MultiByteToWideChar(CP_UTF8, 0, str.data(), str_size, target.data(), result_size); - if (result_size > 0) { - assert(result_size == target.size()); - return; - } - } - - throw_spdlog_ex( - fmt_lib::format("MultiByteToWideChar failed. Last error: {}", ::GetLastError())); -} -#endif // (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && - // defined(_WIN32) - -// return true on success -static SPDLOG_INLINE bool mkdir_(const filename_t &path) { -#ifdef _WIN32 - #ifdef SPDLOG_WCHAR_FILENAMES - return ::_wmkdir(path.c_str()) == 0; - #else - return ::_mkdir(path.c_str()) == 0; - #endif -#else - return ::mkdir(path.c_str(), mode_t(0755)) == 0; -#endif -} - -// create the given directory - and all directories leading to it -// return true on success or if the directory already exists -SPDLOG_INLINE bool create_dir(const filename_t &path) { - if (path_exists(path)) { - return true; - } - - if (path.empty()) { - return false; - } - - size_t search_offset = 0; - do { - auto token_pos = path.find_first_of(folder_seps_filename, search_offset); - // treat the entire path as a folder if no folder separator not found - if (token_pos == filename_t::npos) { - token_pos = path.size(); - } - - auto subdir = path.substr(0, token_pos); -#ifdef _WIN32 - // if subdir is just a drive letter, add a slash e.g. "c:"=>"c:\", - // otherwise path_exists(subdir) returns false (issue #3079) - const bool is_drive = subdir.length() == 2 && subdir[1] == ':'; - if (is_drive) { - subdir += '\\'; - token_pos++; - } -#endif - - if (!subdir.empty() && !path_exists(subdir) && !mkdir_(subdir)) { - return false; // return error if failed creating dir - } - search_offset = token_pos + 1; - } while (search_offset < path.size()); - - return true; -} - -// Return directory name from given path or empty string -// "abc/file" => "abc" -// "abc/" => "abc" -// "abc" => "" -// "abc///" => "abc//" -SPDLOG_INLINE filename_t dir_name(const filename_t &path) { - auto pos = path.find_last_of(folder_seps_filename); - return pos != filename_t::npos ? path.substr(0, pos) : filename_t{}; -} - -#ifdef _MSC_VER - #pragma warning(push) - #pragma warning(disable : 4996) -#endif // _MSC_VER -std::string SPDLOG_INLINE getenv(const char *field) { -#if defined(_MSC_VER) && defined(__cplusplus_winrt) - return std::string{}; // not supported under uwp -#else - char *buf = std::getenv(field); - return buf ? buf : std::string{}; -#endif -} -#ifdef _MSC_VER - #pragma warning(pop) -#endif // _MSC_VER - -// Do fsync by FILE handlerpointer -// Return true on success -SPDLOG_INLINE bool fsync(FILE *fp) { -#ifdef _WIN32 - return FlushFileBuffers(reinterpret_cast<HANDLE>(_get_osfhandle(_fileno(fp)))) != 0; -#else - return ::fsync(fileno(fp)) == 0; -#endif -} - -// Do non-locking fwrite if possible by the os or use the regular locking fwrite -// Return true on success. -SPDLOG_INLINE bool fwrite_bytes(const void *ptr, const size_t n_bytes, FILE *fp) { -#if defined(_WIN32) && defined(SPDLOG_FWRITE_UNLOCKED) - return _fwrite_nolock(ptr, 1, n_bytes, fp) == n_bytes; -#elif defined(SPDLOG_FWRITE_UNLOCKED) - return ::fwrite_unlocked(ptr, 1, n_bytes, fp) == n_bytes; -#else - return std::fwrite(ptr, 1, n_bytes, fp) == n_bytes; -#endif -} - -} // namespace os -} // namespace details -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/details/os.h b/thirdparty/spdlog/include/spdlog/details/os.h deleted file mode 100644 index 5fd12bac1..000000000 --- a/thirdparty/spdlog/include/spdlog/details/os.h +++ /dev/null @@ -1,127 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#include <ctime> // std::time_t -#include <spdlog/common.h> - -namespace spdlog { -namespace details { -namespace os { - -SPDLOG_API spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT; - -SPDLOG_API std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT; - -SPDLOG_API std::tm localtime() SPDLOG_NOEXCEPT; - -SPDLOG_API std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT; - -SPDLOG_API std::tm gmtime() SPDLOG_NOEXCEPT; - -// eol definition -#if !defined(SPDLOG_EOL) - #ifdef _WIN32 - #define SPDLOG_EOL "\r\n" - #else - #define SPDLOG_EOL "\n" - #endif -#endif - -SPDLOG_CONSTEXPR static const char *default_eol = SPDLOG_EOL; - -// folder separator -#if !defined(SPDLOG_FOLDER_SEPS) - #ifdef _WIN32 - #define SPDLOG_FOLDER_SEPS "\\/" - #else - #define SPDLOG_FOLDER_SEPS "/" - #endif -#endif - -SPDLOG_CONSTEXPR static const char folder_seps[] = SPDLOG_FOLDER_SEPS; -SPDLOG_CONSTEXPR static const filename_t::value_type folder_seps_filename[] = - SPDLOG_FILENAME_T(SPDLOG_FOLDER_SEPS); - -// fopen_s on non windows for writing -SPDLOG_API bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode); - -// Remove filename. return 0 on success -SPDLOG_API int remove(const filename_t &filename) SPDLOG_NOEXCEPT; - -// Remove file if exists. return 0 on success -// Note: Non atomic (might return failure to delete if concurrently deleted by other process/thread) -SPDLOG_API int remove_if_exists(const filename_t &filename) SPDLOG_NOEXCEPT; - -SPDLOG_API int rename(const filename_t &filename1, const filename_t &filename2) SPDLOG_NOEXCEPT; - -// Return if file exists. -SPDLOG_API bool path_exists(const filename_t &filename) SPDLOG_NOEXCEPT; - -// Return file size according to open FILE* object -SPDLOG_API size_t filesize(FILE *f); - -// Return utc offset in minutes or throw spdlog_ex on failure -SPDLOG_API int utc_minutes_offset(const std::tm &tm = details::os::localtime()); - -// Return current thread id as size_t -// It exists because the std::this_thread::get_id() is much slower(especially -// under VS 2013) -SPDLOG_API size_t _thread_id() SPDLOG_NOEXCEPT; - -// Return current thread id as size_t (from thread local storage) -SPDLOG_API size_t thread_id() SPDLOG_NOEXCEPT; - -// This is avoid msvc issue in sleep_for that happens if the clock changes. -// See https://github.com/gabime/spdlog/issues/609 -SPDLOG_API void sleep_for_millis(unsigned int milliseconds) SPDLOG_NOEXCEPT; - -SPDLOG_API std::string filename_to_str(const filename_t &filename); - -SPDLOG_API int pid() SPDLOG_NOEXCEPT; - -// Determine if the terminal supports colors -// Source: https://github.com/agauniyal/rang/ -SPDLOG_API bool is_color_terminal() SPDLOG_NOEXCEPT; - -// Determine if the terminal attached -// Source: https://github.com/agauniyal/rang/ -SPDLOG_API bool in_terminal(FILE *file) SPDLOG_NOEXCEPT; - -#if (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32) -SPDLOG_API void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target); - -SPDLOG_API void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target); -#endif - -// Return directory name from given path or empty string -// "abc/file" => "abc" -// "abc/" => "abc" -// "abc" => "" -// "abc///" => "abc//" -SPDLOG_API filename_t dir_name(const filename_t &path); - -// Create a dir from the given path. -// Return true if succeeded or if this dir already exists. -SPDLOG_API bool create_dir(const filename_t &path); - -// non thread safe, cross platform getenv/getenv_s -// return empty string if field not found -SPDLOG_API std::string getenv(const char *field); - -// Do fsync by FILE objectpointer. -// Return true on success. -SPDLOG_API bool fsync(FILE *fp); - -// Do non-locking fwrite if possible by the os or use the regular locking fwrite -// Return true on success. -SPDLOG_API bool fwrite_bytes(const void *ptr, const size_t n_bytes, FILE *fp); - -} // namespace os -} // namespace details -} // namespace spdlog - -#ifdef SPDLOG_HEADER_ONLY - #include "os-inl.h" -#endif diff --git a/thirdparty/spdlog/include/spdlog/details/periodic_worker-inl.h b/thirdparty/spdlog/include/spdlog/details/periodic_worker-inl.h deleted file mode 100644 index 18f11fbec..000000000 --- a/thirdparty/spdlog/include/spdlog/details/periodic_worker-inl.h +++ /dev/null @@ -1,26 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#ifndef SPDLOG_HEADER_ONLY - #include <spdlog/details/periodic_worker.h> -#endif - -namespace spdlog { -namespace details { - -// stop the worker thread and join it -SPDLOG_INLINE periodic_worker::~periodic_worker() { - if (worker_thread_.joinable()) { - { - std::lock_guard<std::mutex> lock(mutex_); - active_ = false; - } - cv_.notify_one(); - worker_thread_.join(); - } -} - -} // namespace details -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/details/periodic_worker.h b/thirdparty/spdlog/include/spdlog/details/periodic_worker.h deleted file mode 100644 index d647b66ee..000000000 --- a/thirdparty/spdlog/include/spdlog/details/periodic_worker.h +++ /dev/null @@ -1,58 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -// periodic worker thread - periodically executes the given callback function. -// -// RAII over the owned thread: -// creates the thread on construction. -// stops and joins the thread on destruction (if the thread is executing a callback, wait for it -// to finish first). - -#include <chrono> -#include <condition_variable> -#include <functional> -#include <mutex> -#include <thread> -namespace spdlog { -namespace details { - -class SPDLOG_API periodic_worker { -public: - template <typename Rep, typename Period> - periodic_worker(const std::function<void()> &callback_fun, - std::chrono::duration<Rep, Period> interval) { - active_ = (interval > std::chrono::duration<Rep, Period>::zero()); - if (!active_) { - return; - } - - worker_thread_ = std::thread([this, callback_fun, interval]() { - for (;;) { - std::unique_lock<std::mutex> lock(this->mutex_); - if (this->cv_.wait_for(lock, interval, [this] { return !this->active_; })) { - return; // active_ == false, so exit this thread - } - callback_fun(); - } - }); - } - std::thread &get_thread() { return worker_thread_; } - periodic_worker(const periodic_worker &) = delete; - periodic_worker &operator=(const periodic_worker &) = delete; - // stop the worker thread and join it - ~periodic_worker(); - -private: - bool active_; - std::thread worker_thread_; - std::mutex mutex_; - std::condition_variable cv_; -}; -} // namespace details -} // namespace spdlog - -#ifdef SPDLOG_HEADER_ONLY - #include "periodic_worker-inl.h" -#endif diff --git a/thirdparty/spdlog/include/spdlog/details/registry-inl.h b/thirdparty/spdlog/include/spdlog/details/registry-inl.h deleted file mode 100644 index 272bebbd3..000000000 --- a/thirdparty/spdlog/include/spdlog/details/registry-inl.h +++ /dev/null @@ -1,270 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#ifndef SPDLOG_HEADER_ONLY - #include <spdlog/details/registry.h> -#endif - -#include <spdlog/common.h> -#include <spdlog/details/periodic_worker.h> -#include <spdlog/logger.h> -#include <spdlog/pattern_formatter.h> - -#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER - // support for the default stdout color logger - #ifdef _WIN32 - #include <spdlog/sinks/wincolor_sink.h> - #else - #include <spdlog/sinks/ansicolor_sink.h> - #endif -#endif // SPDLOG_DISABLE_DEFAULT_LOGGER - -#include <chrono> -#include <functional> -#include <memory> -#include <string> -#include <unordered_map> - -namespace spdlog { -namespace details { - -SPDLOG_INLINE registry::registry() - : formatter_(new pattern_formatter()) { -#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER - // create default logger (ansicolor_stdout_sink_mt or wincolor_stdout_sink_mt in windows). - #ifdef _WIN32 - auto color_sink = std::make_shared<sinks::wincolor_stdout_sink_mt>(); - #else - auto color_sink = std::make_shared<sinks::ansicolor_stdout_sink_mt>(); - #endif - - const char *default_logger_name = ""; - default_logger_ = std::make_shared<spdlog::logger>(default_logger_name, std::move(color_sink)); - loggers_[default_logger_name] = default_logger_; - -#endif // SPDLOG_DISABLE_DEFAULT_LOGGER -} - -SPDLOG_INLINE registry::~registry() = default; - -SPDLOG_INLINE void registry::register_logger(std::shared_ptr<logger> new_logger) { - std::lock_guard<std::mutex> lock(logger_map_mutex_); - register_logger_(std::move(new_logger)); -} - -SPDLOG_INLINE void registry::register_or_replace(std::shared_ptr<logger> new_logger) { - std::lock_guard<std::mutex> lock(logger_map_mutex_); - register_or_replace_(std::move(new_logger)); -} - -SPDLOG_INLINE void registry::initialize_logger(std::shared_ptr<logger> new_logger) { - std::lock_guard<std::mutex> lock(logger_map_mutex_); - new_logger->set_formatter(formatter_->clone()); - - if (err_handler_) { - new_logger->set_error_handler(err_handler_); - } - - // set new level according to previously configured level or default level - auto it = log_levels_.find(new_logger->name()); - auto new_level = it != log_levels_.end() ? it->second : global_log_level_; - new_logger->set_level(new_level); - - new_logger->flush_on(flush_level_); - - if (backtrace_n_messages_ > 0) { - new_logger->enable_backtrace(backtrace_n_messages_); - } - - if (automatic_registration_) { - register_logger_(std::move(new_logger)); - } -} - -SPDLOG_INLINE std::shared_ptr<logger> registry::get(const std::string &logger_name) { - std::lock_guard<std::mutex> lock(logger_map_mutex_); - auto found = loggers_.find(logger_name); - return found == loggers_.end() ? nullptr : found->second; -} - -SPDLOG_INLINE std::shared_ptr<logger> registry::default_logger() { - std::lock_guard<std::mutex> lock(logger_map_mutex_); - return default_logger_; -} - -// Return raw ptr to the default logger. -// To be used directly by the spdlog default api (e.g. spdlog::info) -// This make the default API faster, but cannot be used concurrently with set_default_logger(). -// e.g do not call set_default_logger() from one thread while calling spdlog::info() from another. -SPDLOG_INLINE logger *registry::get_default_raw() { return default_logger_.get(); } - -// set default logger. -// the default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map. -SPDLOG_INLINE void registry::set_default_logger(std::shared_ptr<logger> new_default_logger) { - std::lock_guard<std::mutex> lock(logger_map_mutex_); - if (new_default_logger != nullptr) { - loggers_[new_default_logger->name()] = new_default_logger; - } - default_logger_ = std::move(new_default_logger); -} - -SPDLOG_INLINE void registry::set_tp(std::shared_ptr<thread_pool> tp) { - std::lock_guard<std::recursive_mutex> lock(tp_mutex_); - tp_ = std::move(tp); -} - -SPDLOG_INLINE std::shared_ptr<thread_pool> registry::get_tp() { - std::lock_guard<std::recursive_mutex> lock(tp_mutex_); - return tp_; -} - -// Set global formatter. Each sink in each logger will get a clone of this object -SPDLOG_INLINE void registry::set_formatter(std::unique_ptr<formatter> formatter) { - std::lock_guard<std::mutex> lock(logger_map_mutex_); - formatter_ = std::move(formatter); - for (auto &l : loggers_) { - l.second->set_formatter(formatter_->clone()); - } -} - -SPDLOG_INLINE void registry::enable_backtrace(size_t n_messages) { - std::lock_guard<std::mutex> lock(logger_map_mutex_); - backtrace_n_messages_ = n_messages; - - for (auto &l : loggers_) { - l.second->enable_backtrace(n_messages); - } -} - -SPDLOG_INLINE void registry::disable_backtrace() { - std::lock_guard<std::mutex> lock(logger_map_mutex_); - backtrace_n_messages_ = 0; - for (auto &l : loggers_) { - l.second->disable_backtrace(); - } -} - -SPDLOG_INLINE void registry::set_level(level::level_enum log_level) { - std::lock_guard<std::mutex> lock(logger_map_mutex_); - for (auto &l : loggers_) { - l.second->set_level(log_level); - } - global_log_level_ = log_level; -} - -SPDLOG_INLINE void registry::flush_on(level::level_enum log_level) { - std::lock_guard<std::mutex> lock(logger_map_mutex_); - for (auto &l : loggers_) { - l.second->flush_on(log_level); - } - flush_level_ = log_level; -} - -SPDLOG_INLINE void registry::set_error_handler(err_handler handler) { - std::lock_guard<std::mutex> lock(logger_map_mutex_); - for (auto &l : loggers_) { - l.second->set_error_handler(handler); - } - err_handler_ = std::move(handler); -} - -SPDLOG_INLINE void registry::apply_all( - const std::function<void(const std::shared_ptr<logger>)> &fun) { - std::lock_guard<std::mutex> lock(logger_map_mutex_); - for (auto &l : loggers_) { - fun(l.second); - } -} - -SPDLOG_INLINE void registry::flush_all() { - std::lock_guard<std::mutex> lock(logger_map_mutex_); - for (auto &l : loggers_) { - l.second->flush(); - } -} - -SPDLOG_INLINE void registry::drop(const std::string &logger_name) { - std::lock_guard<std::mutex> lock(logger_map_mutex_); - auto is_default_logger = default_logger_ && default_logger_->name() == logger_name; - loggers_.erase(logger_name); - if (is_default_logger) { - default_logger_.reset(); - } -} - -SPDLOG_INLINE void registry::drop_all() { - std::lock_guard<std::mutex> lock(logger_map_mutex_); - loggers_.clear(); - default_logger_.reset(); -} - -// clean all resources and threads started by the registry -SPDLOG_INLINE void registry::shutdown() { - { - std::lock_guard<std::mutex> lock(flusher_mutex_); - periodic_flusher_.reset(); - } - - drop_all(); - - { - std::lock_guard<std::recursive_mutex> lock(tp_mutex_); - tp_.reset(); - } -} - -SPDLOG_INLINE std::recursive_mutex ®istry::tp_mutex() { return tp_mutex_; } - -SPDLOG_INLINE void registry::set_automatic_registration(bool automatic_registration) { - std::lock_guard<std::mutex> lock(logger_map_mutex_); - automatic_registration_ = automatic_registration; -} - -SPDLOG_INLINE void registry::set_levels(log_levels levels, level::level_enum *global_level) { - std::lock_guard<std::mutex> lock(logger_map_mutex_); - log_levels_ = std::move(levels); - auto global_level_requested = global_level != nullptr; - global_log_level_ = global_level_requested ? *global_level : global_log_level_; - - for (auto &logger : loggers_) { - auto logger_entry = log_levels_.find(logger.first); - if (logger_entry != log_levels_.end()) { - logger.second->set_level(logger_entry->second); - } else if (global_level_requested) { - logger.second->set_level(*global_level); - } - } -} - -SPDLOG_INLINE registry ®istry::instance() { - static registry s_instance; - return s_instance; -} - -SPDLOG_INLINE void registry::apply_logger_env_levels(std::shared_ptr<logger> new_logger) { - std::lock_guard<std::mutex> lock(logger_map_mutex_); - auto it = log_levels_.find(new_logger->name()); - auto new_level = it != log_levels_.end() ? it->second : global_log_level_; - new_logger->set_level(new_level); -} - -SPDLOG_INLINE void registry::throw_if_exists_(const std::string &logger_name) { - if (loggers_.find(logger_name) != loggers_.end()) { - throw_spdlog_ex("logger with name '" + logger_name + "' already exists"); - } -} - -SPDLOG_INLINE void registry::register_logger_(std::shared_ptr<logger> new_logger) { - auto &logger_name = new_logger->name(); - throw_if_exists_(logger_name); - loggers_[logger_name] = std::move(new_logger); -} - -SPDLOG_INLINE void registry::register_or_replace_(std::shared_ptr<logger> new_logger) { - loggers_[new_logger->name()] = std::move(new_logger); -} - -} // namespace details -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/details/registry.h b/thirdparty/spdlog/include/spdlog/details/registry.h deleted file mode 100644 index 72c70b82b..000000000 --- a/thirdparty/spdlog/include/spdlog/details/registry.h +++ /dev/null @@ -1,131 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -// Loggers registry of unique name->logger pointer -// An attempt to create a logger with an already existing name will result with spdlog_ex exception. -// If user requests a non existing logger, nullptr will be returned -// This class is thread safe - -#include <spdlog/common.h> -#include <spdlog/details/periodic_worker.h> - -#include <chrono> -#include <functional> -#include <memory> -#include <mutex> -#include <string> -#include <unordered_map> - -namespace spdlog { -class logger; - -namespace details { -class thread_pool; - -class SPDLOG_API registry { -public: - using log_levels = std::unordered_map<std::string, level::level_enum>; - registry(const registry &) = delete; - registry &operator=(const registry &) = delete; - - void register_logger(std::shared_ptr<logger> new_logger); - void register_or_replace(std::shared_ptr<logger> new_logger); - void initialize_logger(std::shared_ptr<logger> new_logger); - std::shared_ptr<logger> get(const std::string &logger_name); - std::shared_ptr<logger> default_logger(); - - // Return raw ptr to the default logger. - // To be used directly by the spdlog default api (e.g. spdlog::info) - // This make the default API faster, but cannot be used concurrently with set_default_logger(). - // e.g do not call set_default_logger() from one thread while calling spdlog::info() from - // another. - logger *get_default_raw(); - - // set default logger and add it to the registry if not registered already. - // default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map. - // Note: Make sure to unregister it when no longer needed or before calling again with a new - // logger. - void set_default_logger(std::shared_ptr<logger> new_default_logger); - - void set_tp(std::shared_ptr<thread_pool> tp); - - std::shared_ptr<thread_pool> get_tp(); - - // Set global formatter. Each sink in each logger will get a clone of this object - void set_formatter(std::unique_ptr<formatter> formatter); - - void enable_backtrace(size_t n_messages); - - void disable_backtrace(); - - void set_level(level::level_enum log_level); - - void flush_on(level::level_enum log_level); - - template <typename Rep, typename Period> - void flush_every(std::chrono::duration<Rep, Period> interval) { - std::lock_guard<std::mutex> lock(flusher_mutex_); - auto clbk = [this]() { this->flush_all(); }; - periodic_flusher_ = details::make_unique<periodic_worker>(clbk, interval); - } - - std::unique_ptr<periodic_worker> &get_flusher() { - std::lock_guard<std::mutex> lock(flusher_mutex_); - return periodic_flusher_; - } - - void set_error_handler(err_handler handler); - - void apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun); - - void flush_all(); - - void drop(const std::string &logger_name); - - void drop_all(); - - // clean all resources and threads started by the registry - void shutdown(); - - std::recursive_mutex &tp_mutex(); - - void set_automatic_registration(bool automatic_registration); - - // set levels for all existing/future loggers. global_level can be null if should not set. - void set_levels(log_levels levels, level::level_enum *global_level); - - static registry &instance(); - - void apply_logger_env_levels(std::shared_ptr<logger> new_logger); - -private: - registry(); - ~registry(); - - void throw_if_exists_(const std::string &logger_name); - void register_logger_(std::shared_ptr<logger> new_logger); - void register_or_replace_(std::shared_ptr<logger> new_logger); - bool set_level_from_cfg_(logger *logger); - std::mutex logger_map_mutex_, flusher_mutex_; - std::recursive_mutex tp_mutex_; - std::unordered_map<std::string, std::shared_ptr<logger>> loggers_; - log_levels log_levels_; - std::unique_ptr<formatter> formatter_; - spdlog::level::level_enum global_log_level_ = level::info; - level::level_enum flush_level_ = level::off; - err_handler err_handler_; - std::shared_ptr<thread_pool> tp_; - std::unique_ptr<periodic_worker> periodic_flusher_; - std::shared_ptr<logger> default_logger_; - bool automatic_registration_ = true; - size_t backtrace_n_messages_ = 0; -}; - -} // namespace details -} // namespace spdlog - -#ifdef SPDLOG_HEADER_ONLY - #include "registry-inl.h" -#endif diff --git a/thirdparty/spdlog/include/spdlog/details/synchronous_factory.h b/thirdparty/spdlog/include/spdlog/details/synchronous_factory.h deleted file mode 100644 index 4bd5a51c8..000000000 --- a/thirdparty/spdlog/include/spdlog/details/synchronous_factory.h +++ /dev/null @@ -1,22 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#include "registry.h" - -namespace spdlog { - -// Default logger factory- creates synchronous loggers -class logger; - -struct synchronous_factory { - template <typename Sink, typename... SinkArgs> - static std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&...args) { - auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...); - auto new_logger = std::make_shared<spdlog::logger>(std::move(logger_name), std::move(sink)); - details::registry::instance().initialize_logger(new_logger); - return new_logger; - } -}; -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/details/thread_pool-inl.h b/thirdparty/spdlog/include/spdlog/details/thread_pool-inl.h deleted file mode 100644 index b172b2801..000000000 --- a/thirdparty/spdlog/include/spdlog/details/thread_pool-inl.h +++ /dev/null @@ -1,125 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#ifndef SPDLOG_HEADER_ONLY - #include <spdlog/details/thread_pool.h> -#endif - -#include <cassert> -#include <spdlog/common.h> - -namespace spdlog { -namespace details { - -SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, - size_t threads_n, - std::function<void()> on_thread_start, - std::function<void()> on_thread_stop) - : q_(q_max_items) { - if (threads_n == 0 || threads_n > 1000) { - throw_spdlog_ex( - "spdlog::thread_pool(): invalid threads_n param (valid " - "range is 1-1000)"); - } - for (size_t i = 0; i < threads_n; i++) { - threads_.emplace_back([this, on_thread_start, on_thread_stop] { - on_thread_start(); - this->thread_pool::worker_loop_(); - on_thread_stop(); - }); - } -} - -SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, - size_t threads_n, - std::function<void()> on_thread_start) - : thread_pool(q_max_items, threads_n, std::move(on_thread_start), [] {}) {} - -SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n) - : thread_pool(q_max_items, threads_n, [] {}, [] {}) {} - -// message all threads to terminate gracefully join them -SPDLOG_INLINE thread_pool::~thread_pool() { - SPDLOG_TRY { - for (size_t i = 0; i < threads_.size(); i++) { - post_async_msg_(async_msg(async_msg_type::terminate), async_overflow_policy::block); - } - - for (auto &t : threads_) { - t.join(); - } - } - SPDLOG_CATCH_STD -} - -void SPDLOG_INLINE thread_pool::post_log(async_logger_ptr &&worker_ptr, - const details::log_msg &msg, - async_overflow_policy overflow_policy) { - async_msg async_m(std::move(worker_ptr), async_msg_type::log, msg); - post_async_msg_(std::move(async_m), overflow_policy); -} - -void SPDLOG_INLINE thread_pool::post_flush(async_logger_ptr &&worker_ptr, - async_overflow_policy overflow_policy) { - post_async_msg_(async_msg(std::move(worker_ptr), async_msg_type::flush), overflow_policy); -} - -size_t SPDLOG_INLINE thread_pool::overrun_counter() { return q_.overrun_counter(); } - -void SPDLOG_INLINE thread_pool::reset_overrun_counter() { q_.reset_overrun_counter(); } - -size_t SPDLOG_INLINE thread_pool::discard_counter() { return q_.discard_counter(); } - -void SPDLOG_INLINE thread_pool::reset_discard_counter() { q_.reset_discard_counter(); } - -size_t SPDLOG_INLINE thread_pool::queue_size() { return q_.size(); } - -void SPDLOG_INLINE thread_pool::post_async_msg_(async_msg &&new_msg, - async_overflow_policy overflow_policy) { - if (overflow_policy == async_overflow_policy::block) { - q_.enqueue(std::move(new_msg)); - } else if (overflow_policy == async_overflow_policy::overrun_oldest) { - q_.enqueue_nowait(std::move(new_msg)); - } else { - assert(overflow_policy == async_overflow_policy::discard_new); - q_.enqueue_if_have_room(std::move(new_msg)); - } -} - -void SPDLOG_INLINE thread_pool::worker_loop_() { - while (process_next_msg_()) { - } -} - -// process next message in the queue -// returns true if this thread should still be active (while no terminated msg was received) -bool SPDLOG_INLINE thread_pool::process_next_msg_() { - async_msg incoming_async_msg; - q_.dequeue(incoming_async_msg); - - switch (incoming_async_msg.msg_type) { - case async_msg_type::log: { - incoming_async_msg.worker_ptr->backend_sink_it_(incoming_async_msg); - return true; - } - case async_msg_type::flush: { - incoming_async_msg.worker_ptr->backend_flush_(); - return true; - } - - case async_msg_type::terminate: { - return false; - } - - default: { - assert(false); - } - } - - return true; -} - -} // namespace details -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/details/thread_pool.h b/thirdparty/spdlog/include/spdlog/details/thread_pool.h deleted file mode 100644 index f22b07821..000000000 --- a/thirdparty/spdlog/include/spdlog/details/thread_pool.h +++ /dev/null @@ -1,117 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#include <spdlog/details/log_msg_buffer.h> -#include <spdlog/details/mpmc_blocking_q.h> -#include <spdlog/details/os.h> - -#include <chrono> -#include <functional> -#include <memory> -#include <thread> -#include <vector> - -namespace spdlog { -class async_logger; - -namespace details { - -using async_logger_ptr = std::shared_ptr<spdlog::async_logger>; - -enum class async_msg_type { log, flush, terminate }; - -// Async msg to move to/from the queue -// Movable only. should never be copied -struct async_msg : log_msg_buffer { - async_msg_type msg_type{async_msg_type::log}; - async_logger_ptr worker_ptr; - - async_msg() = default; - ~async_msg() = default; - - // should only be moved in or out of the queue.. - async_msg(const async_msg &) = delete; - -// support for vs2013 move -#if defined(_MSC_VER) && _MSC_VER <= 1800 - async_msg(async_msg &&other) - : log_msg_buffer(std::move(other)), - msg_type(other.msg_type), - worker_ptr(std::move(other.worker_ptr)) {} - - async_msg &operator=(async_msg &&other) { - *static_cast<log_msg_buffer *>(this) = std::move(other); - msg_type = other.msg_type; - worker_ptr = std::move(other.worker_ptr); - return *this; - } -#else // (_MSC_VER) && _MSC_VER <= 1800 - async_msg(async_msg &&) = default; - async_msg &operator=(async_msg &&) = default; -#endif - - // construct from log_msg with given type - async_msg(async_logger_ptr &&worker, async_msg_type the_type, const details::log_msg &m) - : log_msg_buffer{m}, - msg_type{the_type}, - worker_ptr{std::move(worker)} {} - - async_msg(async_logger_ptr &&worker, async_msg_type the_type) - : log_msg_buffer{}, - msg_type{the_type}, - worker_ptr{std::move(worker)} {} - - explicit async_msg(async_msg_type the_type) - : async_msg{nullptr, the_type} {} -}; - -class SPDLOG_API thread_pool { -public: - using item_type = async_msg; - using q_type = details::mpmc_blocking_queue<item_type>; - - thread_pool(size_t q_max_items, - size_t threads_n, - std::function<void()> on_thread_start, - std::function<void()> on_thread_stop); - thread_pool(size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start); - thread_pool(size_t q_max_items, size_t threads_n); - - // message all threads to terminate gracefully and join them - ~thread_pool(); - - thread_pool(const thread_pool &) = delete; - thread_pool &operator=(thread_pool &&) = delete; - - void post_log(async_logger_ptr &&worker_ptr, - const details::log_msg &msg, - async_overflow_policy overflow_policy); - void post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy); - size_t overrun_counter(); - void reset_overrun_counter(); - size_t discard_counter(); - void reset_discard_counter(); - size_t queue_size(); - -private: - q_type q_; - - std::vector<std::thread> threads_; - - void post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy); - void worker_loop_(); - - // process next message in the queue - // return true if this thread should still be active (while no terminate msg - // was received) - bool process_next_msg_(); -}; - -} // namespace details -} // namespace spdlog - -#ifdef SPDLOG_HEADER_ONLY - #include "thread_pool-inl.h" -#endif diff --git a/thirdparty/spdlog/include/spdlog/details/windows_include.h b/thirdparty/spdlog/include/spdlog/details/windows_include.h deleted file mode 100644 index bbab59b1c..000000000 --- a/thirdparty/spdlog/include/spdlog/details/windows_include.h +++ /dev/null @@ -1,11 +0,0 @@ -#pragma once - -#ifndef NOMINMAX - #define NOMINMAX // prevent windows redefining min/max -#endif - -#ifndef WIN32_LEAN_AND_MEAN - #define WIN32_LEAN_AND_MEAN -#endif - -#include <windows.h> diff --git a/thirdparty/spdlog/include/spdlog/fmt/bin_to_hex.h b/thirdparty/spdlog/include/spdlog/fmt/bin_to_hex.h deleted file mode 100644 index 6ed68e427..000000000 --- a/thirdparty/spdlog/include/spdlog/fmt/bin_to_hex.h +++ /dev/null @@ -1,224 +0,0 @@ -// -// Copyright(c) 2015 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -#pragma once - -#include <cctype> -#include <spdlog/common.h> - -#if defined(__has_include) - #if __has_include(<version>) - #include <version> - #endif -#endif - -#if __cpp_lib_span >= 202002L - #include <span> -#endif - -// -// Support for logging binary data as hex -// format flags, any combination of the following: -// {:X} - print in uppercase. -// {:s} - don't separate each byte with space. -// {:p} - don't print the position on each line start. -// {:n} - don't split the output to lines. -// {:a} - show ASCII if :n is not set - -// -// Examples: -// -// std::vector<char> v(200, 0x0b); -// logger->info("Some buffer {}", spdlog::to_hex(v)); -// char buf[128]; -// logger->info("Some buffer {:X}", spdlog::to_hex(std::begin(buf), std::end(buf))); -// logger->info("Some buffer {:X}", spdlog::to_hex(std::begin(buf), std::end(buf), 16)); - -namespace spdlog { -namespace details { - -template <typename It> -class dump_info { -public: - dump_info(It range_begin, It range_end, size_t size_per_line) - : begin_(range_begin), - end_(range_end), - size_per_line_(size_per_line) {} - - // do not use begin() and end() to avoid collision with fmt/ranges - It get_begin() const { return begin_; } - It get_end() const { return end_; } - size_t size_per_line() const { return size_per_line_; } - -private: - It begin_, end_; - size_t size_per_line_; -}; -} // namespace details - -// create a dump_info that wraps the given container -template <typename Container> -inline details::dump_info<typename Container::const_iterator> to_hex(const Container &container, - size_t size_per_line = 32) { - static_assert(sizeof(typename Container::value_type) == 1, - "sizeof(Container::value_type) != 1"); - using Iter = typename Container::const_iterator; - return details::dump_info<Iter>(std::begin(container), std::end(container), size_per_line); -} - -#if __cpp_lib_span >= 202002L - -template <typename Value, size_t Extent> -inline details::dump_info<typename std::span<Value, Extent>::iterator> to_hex( - const std::span<Value, Extent> &container, size_t size_per_line = 32) { - using Container = std::span<Value, Extent>; - static_assert(sizeof(typename Container::value_type) == 1, - "sizeof(Container::value_type) != 1"); - using Iter = typename Container::iterator; - return details::dump_info<Iter>(std::begin(container), std::end(container), size_per_line); -} - -#endif - -// create dump_info from ranges -template <typename It> -inline details::dump_info<It> to_hex(const It range_begin, - const It range_end, - size_t size_per_line = 32) { - return details::dump_info<It>(range_begin, range_end, size_per_line); -} - -} // namespace spdlog - -namespace -#ifdef SPDLOG_USE_STD_FORMAT - std -#else - fmt -#endif -{ - -template <typename T> -struct formatter<spdlog::details::dump_info<T>, char> { - char delimiter = ' '; - bool put_newlines = true; - bool put_delimiters = true; - bool use_uppercase = false; - bool put_positions = true; // position on start of each line - bool show_ascii = false; - - // parse the format string flags - template <typename ParseContext> - SPDLOG_CONSTEXPR_FUNC auto parse(ParseContext &ctx) -> decltype(ctx.begin()) { - auto it = ctx.begin(); - while (it != ctx.end() && *it != '}') { - switch (*it) { - case 'X': - use_uppercase = true; - break; - case 's': - put_delimiters = false; - break; - case 'p': - put_positions = false; - break; - case 'n': - put_newlines = false; - show_ascii = false; - break; - case 'a': - if (put_newlines) { - show_ascii = true; - } - break; - } - - ++it; - } - return it; - } - - // format the given bytes range as hex - template <typename FormatContext, typename Container> - auto format(const spdlog::details::dump_info<Container> &the_range, - FormatContext &ctx) const -> decltype(ctx.out()) { - SPDLOG_CONSTEXPR const char *hex_upper = "0123456789ABCDEF"; - SPDLOG_CONSTEXPR const char *hex_lower = "0123456789abcdef"; - const char *hex_chars = use_uppercase ? hex_upper : hex_lower; - -#if !defined(SPDLOG_USE_STD_FORMAT) && FMT_VERSION < 60000 - auto inserter = ctx.begin(); -#else - auto inserter = ctx.out(); -#endif - - int size_per_line = static_cast<int>(the_range.size_per_line()); - auto start_of_line = the_range.get_begin(); - for (auto i = the_range.get_begin(); i != the_range.get_end(); i++) { - auto ch = static_cast<unsigned char>(*i); - - if (put_newlines && - (i == the_range.get_begin() || i - start_of_line >= size_per_line)) { - if (show_ascii && i != the_range.get_begin()) { - *inserter++ = delimiter; - *inserter++ = delimiter; - for (auto j = start_of_line; j < i; j++) { - auto pc = static_cast<unsigned char>(*j); - *inserter++ = std::isprint(pc) ? static_cast<char>(*j) : '.'; - } - } - - put_newline(inserter, static_cast<size_t>(i - the_range.get_begin())); - - // put first byte without delimiter in front of it - *inserter++ = hex_chars[(ch >> 4) & 0x0f]; - *inserter++ = hex_chars[ch & 0x0f]; - start_of_line = i; - continue; - } - - if (put_delimiters && i != the_range.get_begin()) { - *inserter++ = delimiter; - } - - *inserter++ = hex_chars[(ch >> 4) & 0x0f]; - *inserter++ = hex_chars[ch & 0x0f]; - } - if (show_ascii) // add ascii to last line - { - if (the_range.get_end() - the_range.get_begin() > size_per_line) { - auto blank_num = size_per_line - (the_range.get_end() - start_of_line); - while (blank_num-- > 0) { - *inserter++ = delimiter; - *inserter++ = delimiter; - if (put_delimiters) { - *inserter++ = delimiter; - } - } - } - *inserter++ = delimiter; - *inserter++ = delimiter; - for (auto j = start_of_line; j != the_range.get_end(); j++) { - auto pc = static_cast<unsigned char>(*j); - *inserter++ = std::isprint(pc) ? static_cast<char>(*j) : '.'; - } - } - return inserter; - } - - // put newline(and position header) - template <typename It> - void put_newline(It inserter, std::size_t pos) const { -#ifdef _WIN32 - *inserter++ = '\r'; -#endif - *inserter++ = '\n'; - - if (put_positions) { - spdlog::fmt_lib::format_to(inserter, SPDLOG_FMT_STRING("{:04X}: "), pos); - } - } -}; -} // namespace std diff --git a/thirdparty/spdlog/include/spdlog/fmt/chrono.h b/thirdparty/spdlog/include/spdlog/fmt/chrono.h deleted file mode 100644 index a72a5bd64..000000000 --- a/thirdparty/spdlog/include/spdlog/fmt/chrono.h +++ /dev/null @@ -1,23 +0,0 @@ -// -// Copyright(c) 2016 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -#pragma once -// -// include bundled or external copy of fmtlib's chrono support -// -#include <spdlog/tweakme.h> - -#if !defined(SPDLOG_USE_STD_FORMAT) - #if !defined(SPDLOG_FMT_EXTERNAL) - #ifdef SPDLOG_HEADER_ONLY - #ifndef FMT_HEADER_ONLY - #define FMT_HEADER_ONLY - #endif - #endif - #include <spdlog/fmt/bundled/chrono.h> - #else - #include <fmt/chrono.h> - #endif -#endif diff --git a/thirdparty/spdlog/include/spdlog/fmt/compile.h b/thirdparty/spdlog/include/spdlog/fmt/compile.h deleted file mode 100644 index 3c9c25d8b..000000000 --- a/thirdparty/spdlog/include/spdlog/fmt/compile.h +++ /dev/null @@ -1,23 +0,0 @@ -// -// Copyright(c) 2016 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -#pragma once -// -// include bundled or external copy of fmtlib's compile-time support -// -#include <spdlog/tweakme.h> - -#if !defined(SPDLOG_USE_STD_FORMAT) - #if !defined(SPDLOG_FMT_EXTERNAL) - #ifdef SPDLOG_HEADER_ONLY - #ifndef FMT_HEADER_ONLY - #define FMT_HEADER_ONLY - #endif - #endif - #include <spdlog/fmt/bundled/compile.h> - #else - #include <fmt/compile.h> - #endif -#endif diff --git a/thirdparty/spdlog/include/spdlog/fmt/fmt.h b/thirdparty/spdlog/include/spdlog/fmt/fmt.h deleted file mode 100644 index ba94a0c5f..000000000 --- a/thirdparty/spdlog/include/spdlog/fmt/fmt.h +++ /dev/null @@ -1,26 +0,0 @@ -// -// Copyright(c) 2016-2018 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -#pragma once - -// -// Include a bundled header-only copy of fmtlib or an external one. -// By default spdlog include its own copy. -// -#include <spdlog/tweakme.h> - -#if defined(SPDLOG_USE_STD_FORMAT) // SPDLOG_USE_STD_FORMAT is defined - use std::format - #include <format> -#elif !defined(SPDLOG_FMT_EXTERNAL) - #if !defined(SPDLOG_COMPILED_LIB) && !defined(FMT_HEADER_ONLY) - #define FMT_HEADER_ONLY - #endif - #ifndef FMT_USE_WINDOWS_H - #define FMT_USE_WINDOWS_H 0 - #endif - #include <spdlog/fmt/bundled/format.h> -#else // SPDLOG_FMT_EXTERNAL is defined - use external fmtlib - #include <fmt/format.h> -#endif diff --git a/thirdparty/spdlog/include/spdlog/fmt/ostr.h b/thirdparty/spdlog/include/spdlog/fmt/ostr.h deleted file mode 100644 index 2b901055f..000000000 --- a/thirdparty/spdlog/include/spdlog/fmt/ostr.h +++ /dev/null @@ -1,23 +0,0 @@ -// -// Copyright(c) 2016 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -#pragma once -// -// include bundled or external copy of fmtlib's ostream support -// -#include <spdlog/tweakme.h> - -#if !defined(SPDLOG_USE_STD_FORMAT) - #if !defined(SPDLOG_FMT_EXTERNAL) - #ifdef SPDLOG_HEADER_ONLY - #ifndef FMT_HEADER_ONLY - #define FMT_HEADER_ONLY - #endif - #endif - #include <spdlog/fmt/bundled/ostream.h> - #else - #include <fmt/ostream.h> - #endif -#endif diff --git a/thirdparty/spdlog/include/spdlog/fmt/ranges.h b/thirdparty/spdlog/include/spdlog/fmt/ranges.h deleted file mode 100644 index 5bb91e9ac..000000000 --- a/thirdparty/spdlog/include/spdlog/fmt/ranges.h +++ /dev/null @@ -1,23 +0,0 @@ -// -// Copyright(c) 2016 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -#pragma once -// -// include bundled or external copy of fmtlib's ranges support -// -#include <spdlog/tweakme.h> - -#if !defined(SPDLOG_USE_STD_FORMAT) - #if !defined(SPDLOG_FMT_EXTERNAL) - #ifdef SPDLOG_HEADER_ONLY - #ifndef FMT_HEADER_ONLY - #define FMT_HEADER_ONLY - #endif - #endif - #include <spdlog/fmt/bundled/ranges.h> - #else - #include <fmt/ranges.h> - #endif -#endif diff --git a/thirdparty/spdlog/include/spdlog/fmt/std.h b/thirdparty/spdlog/include/spdlog/fmt/std.h deleted file mode 100644 index dabe6f69d..000000000 --- a/thirdparty/spdlog/include/spdlog/fmt/std.h +++ /dev/null @@ -1,24 +0,0 @@ -// -// Copyright(c) 2016 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -#pragma once -// -// include bundled or external copy of fmtlib's std support (for formatting e.g. -// std::filesystem::path, std::thread::id, std::monostate, std::variant, ...) -// -#include <spdlog/tweakme.h> - -#if !defined(SPDLOG_USE_STD_FORMAT) - #if !defined(SPDLOG_FMT_EXTERNAL) - #ifdef SPDLOG_HEADER_ONLY - #ifndef FMT_HEADER_ONLY - #define FMT_HEADER_ONLY - #endif - #endif - #include <spdlog/fmt/bundled/std.h> - #else - #include <fmt/std.h> - #endif -#endif diff --git a/thirdparty/spdlog/include/spdlog/fmt/xchar.h b/thirdparty/spdlog/include/spdlog/fmt/xchar.h deleted file mode 100644 index 2525f0586..000000000 --- a/thirdparty/spdlog/include/spdlog/fmt/xchar.h +++ /dev/null @@ -1,23 +0,0 @@ -// -// Copyright(c) 2016 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -#pragma once -// -// include bundled or external copy of fmtlib's xchar support -// -#include <spdlog/tweakme.h> - -#if !defined(SPDLOG_USE_STD_FORMAT) - #if !defined(SPDLOG_FMT_EXTERNAL) - #ifdef SPDLOG_HEADER_ONLY - #ifndef FMT_HEADER_ONLY - #define FMT_HEADER_ONLY - #endif - #endif - #include <spdlog/fmt/bundled/xchar.h> - #else - #include <fmt/xchar.h> - #endif -#endif diff --git a/thirdparty/spdlog/include/spdlog/formatter.h b/thirdparty/spdlog/include/spdlog/formatter.h deleted file mode 100644 index 4d482f827..000000000 --- a/thirdparty/spdlog/include/spdlog/formatter.h +++ /dev/null @@ -1,17 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#include <spdlog/details/log_msg.h> -#include <spdlog/fmt/fmt.h> - -namespace spdlog { - -class formatter { -public: - virtual ~formatter() = default; - virtual void format(const details::log_msg &msg, memory_buf_t &dest) = 0; - virtual std::unique_ptr<formatter> clone() const = 0; -}; -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/fwd.h b/thirdparty/spdlog/include/spdlog/fwd.h deleted file mode 100644 index 647b16bf0..000000000 --- a/thirdparty/spdlog/include/spdlog/fwd.h +++ /dev/null @@ -1,18 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -namespace spdlog { -class logger; -class formatter; - -namespace sinks { -class sink; -} - -namespace level { -enum level_enum : int; -} - -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/logger-inl.h b/thirdparty/spdlog/include/spdlog/logger-inl.h deleted file mode 100644 index 6879273c3..000000000 --- a/thirdparty/spdlog/include/spdlog/logger-inl.h +++ /dev/null @@ -1,198 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#ifndef SPDLOG_HEADER_ONLY - #include <spdlog/logger.h> -#endif - -#include <spdlog/details/backtracer.h> -#include <spdlog/pattern_formatter.h> -#include <spdlog/sinks/sink.h> - -#include <cstdio> - -namespace spdlog { - -// public methods -SPDLOG_INLINE logger::logger(const logger &other) - : name_(other.name_), - sinks_(other.sinks_), - level_(other.level_.load(std::memory_order_relaxed)), - flush_level_(other.flush_level_.load(std::memory_order_relaxed)), - custom_err_handler_(other.custom_err_handler_), - tracer_(other.tracer_) {} - -SPDLOG_INLINE logger::logger(logger &&other) SPDLOG_NOEXCEPT - : name_(std::move(other.name_)), - sinks_(std::move(other.sinks_)), - level_(other.level_.load(std::memory_order_relaxed)), - flush_level_(other.flush_level_.load(std::memory_order_relaxed)), - custom_err_handler_(std::move(other.custom_err_handler_)), - tracer_(std::move(other.tracer_)) - -{} - -SPDLOG_INLINE logger &logger::operator=(logger other) SPDLOG_NOEXCEPT { - this->swap(other); - return *this; -} - -SPDLOG_INLINE void logger::swap(spdlog::logger &other) SPDLOG_NOEXCEPT { - name_.swap(other.name_); - sinks_.swap(other.sinks_); - - // swap level_ - auto other_level = other.level_.load(); - auto my_level = level_.exchange(other_level); - other.level_.store(my_level); - - // swap flush level_ - other_level = other.flush_level_.load(); - my_level = flush_level_.exchange(other_level); - other.flush_level_.store(my_level); - - custom_err_handler_.swap(other.custom_err_handler_); - std::swap(tracer_, other.tracer_); -} - -SPDLOG_INLINE void swap(logger &a, logger &b) noexcept { a.swap(b); } - -SPDLOG_INLINE void logger::set_level(level::level_enum log_level) { level_.store(log_level); } - -SPDLOG_INLINE level::level_enum logger::level() const { - return static_cast<level::level_enum>(level_.load(std::memory_order_relaxed)); -} - -SPDLOG_INLINE const std::string &logger::name() const { return name_; } - -// set formatting for the sinks in this logger. -// each sink will get a separate instance of the formatter object. -SPDLOG_INLINE void logger::set_formatter(std::unique_ptr<formatter> f) { - for (auto it = sinks_.begin(); it != sinks_.end(); ++it) { - if (std::next(it) == sinks_.end()) { - // last element - we can be move it. - (*it)->set_formatter(std::move(f)); - break; // to prevent clang-tidy warning - } else { - (*it)->set_formatter(f->clone()); - } - } -} - -SPDLOG_INLINE void logger::set_pattern(std::string pattern, pattern_time_type time_type) { - auto new_formatter = details::make_unique<pattern_formatter>(std::move(pattern), time_type); - set_formatter(std::move(new_formatter)); -} - -// create new backtrace sink and move to it all our child sinks -SPDLOG_INLINE void logger::enable_backtrace(size_t n_messages) { tracer_.enable(n_messages); } - -// restore orig sinks and level and delete the backtrace sink -SPDLOG_INLINE void logger::disable_backtrace() { tracer_.disable(); } - -SPDLOG_INLINE void logger::dump_backtrace() { dump_backtrace_(); } - -// flush functions -SPDLOG_INLINE void logger::flush() { flush_(); } - -SPDLOG_INLINE void logger::flush_on(level::level_enum log_level) { flush_level_.store(log_level); } - -SPDLOG_INLINE level::level_enum logger::flush_level() const { - return static_cast<level::level_enum>(flush_level_.load(std::memory_order_relaxed)); -} - -// sinks -SPDLOG_INLINE const std::vector<sink_ptr> &logger::sinks() const { return sinks_; } - -SPDLOG_INLINE std::vector<sink_ptr> &logger::sinks() { return sinks_; } - -// error handler -SPDLOG_INLINE void logger::set_error_handler(err_handler handler) { - custom_err_handler_ = std::move(handler); -} - -// create new logger with same sinks and configuration. -SPDLOG_INLINE std::shared_ptr<logger> logger::clone(std::string logger_name) { - auto cloned = std::make_shared<logger>(*this); - cloned->name_ = std::move(logger_name); - return cloned; -} - -// protected methods -SPDLOG_INLINE void logger::log_it_(const spdlog::details::log_msg &log_msg, - bool log_enabled, - bool traceback_enabled) { - if (log_enabled) { - sink_it_(log_msg); - } - if (traceback_enabled) { - tracer_.push_back(log_msg); - } -} - -SPDLOG_INLINE void logger::sink_it_(const details::log_msg &msg) { - for (auto &sink : sinks_) { - if (sink->should_log(msg.level)) { - SPDLOG_TRY { sink->log(msg); } - SPDLOG_LOGGER_CATCH(msg.source) - } - } - - if (should_flush_(msg)) { - flush_(); - } -} - -SPDLOG_INLINE void logger::flush_() { - for (auto &sink : sinks_) { - SPDLOG_TRY { sink->flush(); } - SPDLOG_LOGGER_CATCH(source_loc()) - } -} - -SPDLOG_INLINE void logger::dump_backtrace_() { - using details::log_msg; - if (tracer_.enabled() && !tracer_.empty()) { - sink_it_( - log_msg{name(), level::info, "****************** Backtrace Start ******************"}); - tracer_.foreach_pop([this](const log_msg &msg) { this->sink_it_(msg); }); - sink_it_( - log_msg{name(), level::info, "****************** Backtrace End ********************"}); - } -} - -SPDLOG_INLINE bool logger::should_flush_(const details::log_msg &msg) const { - auto flush_level = flush_level_.load(std::memory_order_relaxed); - return (msg.level >= flush_level) && (msg.level != level::off); -} - -SPDLOG_INLINE void logger::err_handler_(const std::string &msg) const { - if (custom_err_handler_) { - custom_err_handler_(msg); - } else { - using std::chrono::system_clock; - static std::mutex mutex; - static std::chrono::system_clock::time_point last_report_time; - static size_t err_counter = 0; - std::lock_guard<std::mutex> lk{mutex}; - auto now = system_clock::now(); - err_counter++; - if (now - last_report_time < std::chrono::seconds(1)) { - return; - } - last_report_time = now; - auto tm_time = details::os::localtime(system_clock::to_time_t(now)); - char date_buf[64]; - std::strftime(date_buf, sizeof(date_buf), "%Y-%m-%d %H:%M:%S", &tm_time); -#if defined(USING_R) && defined(R_R_H) // if in R environment - REprintf("[*** LOG ERROR #%04zu ***] [%s] [%s] %s\n", err_counter, date_buf, name().c_str(), - msg.c_str()); -#else - std::fprintf(stderr, "[*** LOG ERROR #%04zu ***] [%s] [%s] %s\n", err_counter, date_buf, - name().c_str(), msg.c_str()); -#endif - } -} -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/logger.h b/thirdparty/spdlog/include/spdlog/logger.h deleted file mode 100644 index 8c3cd91f5..000000000 --- a/thirdparty/spdlog/include/spdlog/logger.h +++ /dev/null @@ -1,379 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -// Thread safe logger (except for set_error_handler()) -// Has name, log level, vector of std::shared sink pointers and formatter -// Upon each log write the logger: -// 1. Checks if its log level is enough to log the message and if yes: -// 2. Call the underlying sinks to do the job. -// 3. Each sink use its own private copy of a formatter to format the message -// and send to its destination. -// -// The use of private formatter per sink provides the opportunity to cache some -// formatted data, and support for different format per sink. - -#include <spdlog/common.h> -#include <spdlog/details/backtracer.h> -#include <spdlog/details/log_msg.h> - -#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT - #ifndef _WIN32 - #error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows - #endif - #include <spdlog/details/os.h> -#endif - -#include <vector> - -#ifndef SPDLOG_NO_EXCEPTIONS - #define SPDLOG_LOGGER_CATCH(location) \ - catch (const std::exception &ex) { \ - if (location.filename) { \ - err_handler_(fmt_lib::format(SPDLOG_FMT_STRING("{} [{}({})]"), ex.what(), \ - location.filename, location.line)); \ - } else { \ - err_handler_(ex.what()); \ - } \ - } \ - catch (...) { \ - err_handler_("Rethrowing unknown exception in logger"); \ - throw; \ - } -#else - #define SPDLOG_LOGGER_CATCH(location) -#endif - -namespace spdlog { - -class SPDLOG_API logger { -public: - // Empty logger - explicit logger(std::string name) - : name_(std::move(name)), - sinks_() {} - - // Logger with range on sinks - template <typename It> - logger(std::string name, It begin, It end) - : name_(std::move(name)), - sinks_(begin, end) {} - - // Logger with single sink - logger(std::string name, sink_ptr single_sink) - : logger(std::move(name), {std::move(single_sink)}) {} - - // Logger with sinks init list - logger(std::string name, sinks_init_list sinks) - : logger(std::move(name), sinks.begin(), sinks.end()) {} - - virtual ~logger() = default; - - logger(const logger &other); - logger(logger &&other) SPDLOG_NOEXCEPT; - logger &operator=(logger other) SPDLOG_NOEXCEPT; - void swap(spdlog::logger &other) SPDLOG_NOEXCEPT; - - template <typename... Args> - void log(source_loc loc, level::level_enum lvl, format_string_t<Args...> fmt, Args &&...args) { - log_(loc, lvl, details::to_string_view(fmt), std::forward<Args>(args)...); - } - - template <typename... Args> - void log(level::level_enum lvl, format_string_t<Args...> fmt, Args &&...args) { - log(source_loc{}, lvl, fmt, std::forward<Args>(args)...); - } - - template <typename T> - void log(level::level_enum lvl, const T &msg) { - log(source_loc{}, lvl, msg); - } - - // T cannot be statically converted to format string (including string_view/wstring_view) - template <class T, - typename std::enable_if<!is_convertible_to_any_format_string<const T &>::value, - int>::type = 0> - void log(source_loc loc, level::level_enum lvl, const T &msg) { - log(loc, lvl, "{}", msg); - } - - void log(log_clock::time_point log_time, - source_loc loc, - level::level_enum lvl, - string_view_t msg) { - bool log_enabled = should_log(lvl); - bool traceback_enabled = tracer_.enabled(); - if (!log_enabled && !traceback_enabled) { - return; - } - - details::log_msg log_msg(log_time, loc, name_, lvl, msg); - log_it_(log_msg, log_enabled, traceback_enabled); - } - - void log(source_loc loc, level::level_enum lvl, string_view_t msg) { - bool log_enabled = should_log(lvl); - bool traceback_enabled = tracer_.enabled(); - if (!log_enabled && !traceback_enabled) { - return; - } - - details::log_msg log_msg(loc, name_, lvl, msg); - log_it_(log_msg, log_enabled, traceback_enabled); - } - - void log(level::level_enum lvl, string_view_t msg) { log(source_loc{}, lvl, msg); } - - template <typename... Args> - void trace(format_string_t<Args...> fmt, Args &&...args) { - log(level::trace, fmt, std::forward<Args>(args)...); - } - - template <typename... Args> - void debug(format_string_t<Args...> fmt, Args &&...args) { - log(level::debug, fmt, std::forward<Args>(args)...); - } - - template <typename... Args> - void info(format_string_t<Args...> fmt, Args &&...args) { - log(level::info, fmt, std::forward<Args>(args)...); - } - - template <typename... Args> - void warn(format_string_t<Args...> fmt, Args &&...args) { - log(level::warn, fmt, std::forward<Args>(args)...); - } - - template <typename... Args> - void error(format_string_t<Args...> fmt, Args &&...args) { - log(level::err, fmt, std::forward<Args>(args)...); - } - - template <typename... Args> - void critical(format_string_t<Args...> fmt, Args &&...args) { - log(level::critical, fmt, std::forward<Args>(args)...); - } - -#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT - template <typename... Args> - void log(source_loc loc, level::level_enum lvl, wformat_string_t<Args...> fmt, Args &&...args) { - log_(loc, lvl, details::to_string_view(fmt), std::forward<Args>(args)...); - } - - template <typename... Args> - void log(level::level_enum lvl, wformat_string_t<Args...> fmt, Args &&...args) { - log(source_loc{}, lvl, fmt, std::forward<Args>(args)...); - } - - void log(log_clock::time_point log_time, - source_loc loc, - level::level_enum lvl, - wstring_view_t msg) { - bool log_enabled = should_log(lvl); - bool traceback_enabled = tracer_.enabled(); - if (!log_enabled && !traceback_enabled) { - return; - } - - memory_buf_t buf; - details::os::wstr_to_utf8buf(wstring_view_t(msg.data(), msg.size()), buf); - details::log_msg log_msg(log_time, loc, name_, lvl, string_view_t(buf.data(), buf.size())); - log_it_(log_msg, log_enabled, traceback_enabled); - } - - void log(source_loc loc, level::level_enum lvl, wstring_view_t msg) { - bool log_enabled = should_log(lvl); - bool traceback_enabled = tracer_.enabled(); - if (!log_enabled && !traceback_enabled) { - return; - } - - memory_buf_t buf; - details::os::wstr_to_utf8buf(wstring_view_t(msg.data(), msg.size()), buf); - details::log_msg log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size())); - log_it_(log_msg, log_enabled, traceback_enabled); - } - - void log(level::level_enum lvl, wstring_view_t msg) { log(source_loc{}, lvl, msg); } - - template <typename... Args> - void trace(wformat_string_t<Args...> fmt, Args &&...args) { - log(level::trace, fmt, std::forward<Args>(args)...); - } - - template <typename... Args> - void debug(wformat_string_t<Args...> fmt, Args &&...args) { - log(level::debug, fmt, std::forward<Args>(args)...); - } - - template <typename... Args> - void info(wformat_string_t<Args...> fmt, Args &&...args) { - log(level::info, fmt, std::forward<Args>(args)...); - } - - template <typename... Args> - void warn(wformat_string_t<Args...> fmt, Args &&...args) { - log(level::warn, fmt, std::forward<Args>(args)...); - } - - template <typename... Args> - void error(wformat_string_t<Args...> fmt, Args &&...args) { - log(level::err, fmt, std::forward<Args>(args)...); - } - - template <typename... Args> - void critical(wformat_string_t<Args...> fmt, Args &&...args) { - log(level::critical, fmt, std::forward<Args>(args)...); - } -#endif - - template <typename T> - void trace(const T &msg) { - log(level::trace, msg); - } - - template <typename T> - void debug(const T &msg) { - log(level::debug, msg); - } - - template <typename T> - void info(const T &msg) { - log(level::info, msg); - } - - template <typename T> - void warn(const T &msg) { - log(level::warn, msg); - } - - template <typename T> - void error(const T &msg) { - log(level::err, msg); - } - - template <typename T> - void critical(const T &msg) { - log(level::critical, msg); - } - - // return true logging is enabled for the given level. - bool should_log(level::level_enum msg_level) const { - return msg_level >= level_.load(std::memory_order_relaxed); - } - - // return true if backtrace logging is enabled. - bool should_backtrace() const { return tracer_.enabled(); } - - void set_level(level::level_enum log_level); - - level::level_enum level() const; - - const std::string &name() const; - - // set formatting for the sinks in this logger. - // each sink will get a separate instance of the formatter object. - void set_formatter(std::unique_ptr<formatter> f); - - // set formatting for the sinks in this logger. - // equivalent to - // set_formatter(make_unique<pattern_formatter>(pattern, time_type)) - // Note: each sink will get a new instance of a formatter object, replacing the old one. - void set_pattern(std::string pattern, pattern_time_type time_type = pattern_time_type::local); - - // backtrace support. - // efficiently store all debug/trace messages in a circular buffer until needed for debugging. - void enable_backtrace(size_t n_messages); - void disable_backtrace(); - void dump_backtrace(); - - // flush functions - void flush(); - void flush_on(level::level_enum log_level); - level::level_enum flush_level() const; - - // sinks - const std::vector<sink_ptr> &sinks() const; - - std::vector<sink_ptr> &sinks(); - - // error handler - void set_error_handler(err_handler); - - // create new logger with same sinks and configuration. - virtual std::shared_ptr<logger> clone(std::string logger_name); - -protected: - std::string name_; - std::vector<sink_ptr> sinks_; - spdlog::level_t level_{level::info}; - spdlog::level_t flush_level_{level::off}; - err_handler custom_err_handler_{nullptr}; - details::backtracer tracer_; - - // common implementation for after templated public api has been resolved - template <typename... Args> - void log_(source_loc loc, level::level_enum lvl, string_view_t fmt, Args &&...args) { - bool log_enabled = should_log(lvl); - bool traceback_enabled = tracer_.enabled(); - if (!log_enabled && !traceback_enabled) { - return; - } - SPDLOG_TRY { - memory_buf_t buf; -#ifdef SPDLOG_USE_STD_FORMAT - fmt_lib::vformat_to(std::back_inserter(buf), fmt, fmt_lib::make_format_args(args...)); -#else - fmt::vformat_to(fmt::appender(buf), fmt, fmt::make_format_args(args...)); -#endif - - details::log_msg log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size())); - log_it_(log_msg, log_enabled, traceback_enabled); - } - SPDLOG_LOGGER_CATCH(loc) - } - -#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT - template <typename... Args> - void log_(source_loc loc, level::level_enum lvl, wstring_view_t fmt, Args &&...args) { - bool log_enabled = should_log(lvl); - bool traceback_enabled = tracer_.enabled(); - if (!log_enabled && !traceback_enabled) { - return; - } - SPDLOG_TRY { - // format to wmemory_buffer and convert to utf8 - wmemory_buf_t wbuf; - fmt_lib::vformat_to(std::back_inserter(wbuf), fmt, - fmt_lib::make_format_args<fmt_lib::wformat_context>(args...)); - - memory_buf_t buf; - details::os::wstr_to_utf8buf(wstring_view_t(wbuf.data(), wbuf.size()), buf); - details::log_msg log_msg(loc, name_, lvl, string_view_t(buf.data(), buf.size())); - log_it_(log_msg, log_enabled, traceback_enabled); - } - SPDLOG_LOGGER_CATCH(loc) - } -#endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT - - // log the given message (if the given log level is high enough), - // and save backtrace (if backtrace is enabled). - void log_it_(const details::log_msg &log_msg, bool log_enabled, bool traceback_enabled); - virtual void sink_it_(const details::log_msg &msg); - virtual void flush_(); - void dump_backtrace_(); - bool should_flush_(const details::log_msg &msg) const; - - // handle errors during logging. - // default handler prints the error to stderr at max rate of 1 message/sec. - void err_handler_(const std::string &msg) const; -}; - -void swap(logger &a, logger &b) noexcept; - -} // namespace spdlog - -#ifdef SPDLOG_HEADER_ONLY - #include "logger-inl.h" -#endif diff --git a/thirdparty/spdlog/include/spdlog/mdc.h b/thirdparty/spdlog/include/spdlog/mdc.h deleted file mode 100644 index bc131746e..000000000 --- a/thirdparty/spdlog/include/spdlog/mdc.h +++ /dev/null @@ -1,52 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#if defined(SPDLOG_NO_TLS) - #error "This header requires thread local storage support, but SPDLOG_NO_TLS is defined." -#endif - -#include <map> -#include <string> - -#include <spdlog/common.h> - -// MDC is a simple map of key->string values stored in thread local storage whose content will be -// printed by the loggers. Note: Not supported in async mode (thread local storage - so the async -// thread pool have different copy). -// -// Usage example: -// spdlog::mdc::put("mdc_key_1", "mdc_value_1"); -// spdlog::info("Hello, {}", "World!"); // => [2024-04-26 02:08:05.040] [info] -// [mdc_key_1:mdc_value_1] Hello, World! - -namespace spdlog { -class SPDLOG_API mdc { -public: - using mdc_map_t = std::map<std::string, std::string>; - - static void put(const std::string &key, const std::string &value) { - get_context()[key] = value; - } - - static std::string get(const std::string &key) { - auto &context = get_context(); - auto it = context.find(key); - if (it != context.end()) { - return it->second; - } - return ""; - } - - static void remove(const std::string &key) { get_context().erase(key); } - - static void clear() { get_context().clear(); } - - static mdc_map_t &get_context() { - static thread_local mdc_map_t context; - return context; - } -}; - -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/pattern_formatter-inl.h b/thirdparty/spdlog/include/spdlog/pattern_formatter-inl.h deleted file mode 100644 index fd408ed52..000000000 --- a/thirdparty/spdlog/include/spdlog/pattern_formatter-inl.h +++ /dev/null @@ -1,1340 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#ifndef SPDLOG_HEADER_ONLY - #include <spdlog/pattern_formatter.h> -#endif - -#include <spdlog/details/fmt_helper.h> -#include <spdlog/details/log_msg.h> -#include <spdlog/details/os.h> - -#ifndef SPDLOG_NO_TLS - #include <spdlog/mdc.h> -#endif - -#include <spdlog/fmt/fmt.h> -#include <spdlog/formatter.h> - -#include <algorithm> -#include <array> -#include <cctype> -#include <chrono> -#include <cstring> -#include <ctime> -#include <iterator> -#include <memory> -#include <mutex> -#include <string> -#include <thread> -#include <utility> -#include <vector> - -namespace spdlog { -namespace details { - -/////////////////////////////////////////////////////////////////////// -// name & level pattern appender -/////////////////////////////////////////////////////////////////////// - -class scoped_padder { -public: - scoped_padder(size_t wrapped_size, const padding_info &padinfo, memory_buf_t &dest) - : padinfo_(padinfo), - dest_(dest) { - remaining_pad_ = static_cast<long>(padinfo.width_) - static_cast<long>(wrapped_size); - if (remaining_pad_ <= 0) { - return; - } - - if (padinfo_.side_ == padding_info::pad_side::left) { - pad_it(remaining_pad_); - remaining_pad_ = 0; - } else if (padinfo_.side_ == padding_info::pad_side::center) { - auto half_pad = remaining_pad_ / 2; - auto reminder = remaining_pad_ & 1; - pad_it(half_pad); - remaining_pad_ = half_pad + reminder; // for the right side - } - } - - template <typename T> - static unsigned int count_digits(T n) { - return fmt_helper::count_digits(n); - } - - ~scoped_padder() { - if (remaining_pad_ >= 0) { - pad_it(remaining_pad_); - } else if (padinfo_.truncate_) { - long new_size = static_cast<long>(dest_.size()) + remaining_pad_; - if (new_size < 0) { - new_size = 0; - } - dest_.resize(static_cast<size_t>(new_size)); - } - } - -private: - void pad_it(long count) { - fmt_helper::append_string_view(string_view_t(spaces_.data(), static_cast<size_t>(count)), - dest_); - } - - const padding_info &padinfo_; - memory_buf_t &dest_; - long remaining_pad_; - string_view_t spaces_{" ", 64}; -}; - -struct null_scoped_padder { - null_scoped_padder(size_t /*wrapped_size*/, - const padding_info & /*padinfo*/, - memory_buf_t & /*dest*/) {} - - template <typename T> - static unsigned int count_digits(T /* number */) { - return 0; - } -}; - -template <typename ScopedPadder> -class name_formatter final : public flag_formatter { -public: - explicit name_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { - ScopedPadder p(msg.logger_name.size(), padinfo_, dest); - fmt_helper::append_string_view(msg.logger_name, dest); - } -}; - -// log level appender -template <typename ScopedPadder> -class level_formatter final : public flag_formatter { -public: - explicit level_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { - const string_view_t &level_name = level::to_string_view(msg.level); - ScopedPadder p(level_name.size(), padinfo_, dest); - fmt_helper::append_string_view(level_name, dest); - } -}; - -// short log level appender -template <typename ScopedPadder> -class short_level_formatter final : public flag_formatter { -public: - explicit short_level_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { - string_view_t level_name{level::to_short_c_str(msg.level)}; - ScopedPadder p(level_name.size(), padinfo_, dest); - fmt_helper::append_string_view(level_name, dest); - } -}; - -/////////////////////////////////////////////////////////////////////// -// Date time pattern appenders -/////////////////////////////////////////////////////////////////////// - -static const char *ampm(const tm &t) { return t.tm_hour >= 12 ? "PM" : "AM"; } - -static int to12h(const tm &t) { return t.tm_hour > 12 ? t.tm_hour - 12 : t.tm_hour; } - -// Abbreviated weekday name -static std::array<const char *, 7> days{{"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}}; - -template <typename ScopedPadder> -class a_formatter final : public flag_formatter { -public: - explicit a_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { - string_view_t field_value{days[static_cast<size_t>(tm_time.tm_wday)]}; - ScopedPadder p(field_value.size(), padinfo_, dest); - fmt_helper::append_string_view(field_value, dest); - } -}; - -// Full weekday name -static std::array<const char *, 7> full_days{ - {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}}; - -template <typename ScopedPadder> -class A_formatter : public flag_formatter { -public: - explicit A_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { - string_view_t field_value{full_days[static_cast<size_t>(tm_time.tm_wday)]}; - ScopedPadder p(field_value.size(), padinfo_, dest); - fmt_helper::append_string_view(field_value, dest); - } -}; - -// Abbreviated month -static const std::array<const char *, 12> months{ - {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}}; - -template <typename ScopedPadder> -class b_formatter final : public flag_formatter { -public: - explicit b_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { - string_view_t field_value{months[static_cast<size_t>(tm_time.tm_mon)]}; - ScopedPadder p(field_value.size(), padinfo_, dest); - fmt_helper::append_string_view(field_value, dest); - } -}; - -// Full month name -static const std::array<const char *, 12> full_months{{"January", "February", "March", "April", - "May", "June", "July", "August", "September", - "October", "November", "December"}}; - -template <typename ScopedPadder> -class B_formatter final : public flag_formatter { -public: - explicit B_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { - string_view_t field_value{full_months[static_cast<size_t>(tm_time.tm_mon)]}; - ScopedPadder p(field_value.size(), padinfo_, dest); - fmt_helper::append_string_view(field_value, dest); - } -}; - -// Date and time representation (Thu Aug 23 15:35:46 2014) -template <typename ScopedPadder> -class c_formatter final : public flag_formatter { -public: - explicit c_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { - const size_t field_size = 24; - ScopedPadder p(field_size, padinfo_, dest); - - fmt_helper::append_string_view(days[static_cast<size_t>(tm_time.tm_wday)], dest); - dest.push_back(' '); - fmt_helper::append_string_view(months[static_cast<size_t>(tm_time.tm_mon)], dest); - dest.push_back(' '); - fmt_helper::append_int(tm_time.tm_mday, dest); - dest.push_back(' '); - // time - - fmt_helper::pad2(tm_time.tm_hour, dest); - dest.push_back(':'); - fmt_helper::pad2(tm_time.tm_min, dest); - dest.push_back(':'); - fmt_helper::pad2(tm_time.tm_sec, dest); - dest.push_back(' '); - fmt_helper::append_int(tm_time.tm_year + 1900, dest); - } -}; - -// year - 2 digit -template <typename ScopedPadder> -class C_formatter final : public flag_formatter { -public: - explicit C_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { - const size_t field_size = 2; - ScopedPadder p(field_size, padinfo_, dest); - fmt_helper::pad2(tm_time.tm_year % 100, dest); - } -}; - -// Short MM/DD/YY date, equivalent to %m/%d/%y 08/23/01 -template <typename ScopedPadder> -class D_formatter final : public flag_formatter { -public: - explicit D_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { - const size_t field_size = 8; - ScopedPadder p(field_size, padinfo_, dest); - - fmt_helper::pad2(tm_time.tm_mon + 1, dest); - dest.push_back('/'); - fmt_helper::pad2(tm_time.tm_mday, dest); - dest.push_back('/'); - fmt_helper::pad2(tm_time.tm_year % 100, dest); - } -}; - -// year - 4 digit -template <typename ScopedPadder> -class Y_formatter final : public flag_formatter { -public: - explicit Y_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { - const size_t field_size = 4; - ScopedPadder p(field_size, padinfo_, dest); - fmt_helper::append_int(tm_time.tm_year + 1900, dest); - } -}; - -// month 1-12 -template <typename ScopedPadder> -class m_formatter final : public flag_formatter { -public: - explicit m_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { - const size_t field_size = 2; - ScopedPadder p(field_size, padinfo_, dest); - fmt_helper::pad2(tm_time.tm_mon + 1, dest); - } -}; - -// day of month 1-31 -template <typename ScopedPadder> -class d_formatter final : public flag_formatter { -public: - explicit d_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { - const size_t field_size = 2; - ScopedPadder p(field_size, padinfo_, dest); - fmt_helper::pad2(tm_time.tm_mday, dest); - } -}; - -// hours in 24 format 0-23 -template <typename ScopedPadder> -class H_formatter final : public flag_formatter { -public: - explicit H_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { - const size_t field_size = 2; - ScopedPadder p(field_size, padinfo_, dest); - fmt_helper::pad2(tm_time.tm_hour, dest); - } -}; - -// hours in 12 format 1-12 -template <typename ScopedPadder> -class I_formatter final : public flag_formatter { -public: - explicit I_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { - const size_t field_size = 2; - ScopedPadder p(field_size, padinfo_, dest); - fmt_helper::pad2(to12h(tm_time), dest); - } -}; - -// minutes 0-59 -template <typename ScopedPadder> -class M_formatter final : public flag_formatter { -public: - explicit M_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { - const size_t field_size = 2; - ScopedPadder p(field_size, padinfo_, dest); - fmt_helper::pad2(tm_time.tm_min, dest); - } -}; - -// seconds 0-59 -template <typename ScopedPadder> -class S_formatter final : public flag_formatter { -public: - explicit S_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { - const size_t field_size = 2; - ScopedPadder p(field_size, padinfo_, dest); - fmt_helper::pad2(tm_time.tm_sec, dest); - } -}; - -// milliseconds -template <typename ScopedPadder> -class e_formatter final : public flag_formatter { -public: - explicit e_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { - auto millis = fmt_helper::time_fraction<std::chrono::milliseconds>(msg.time); - const size_t field_size = 3; - ScopedPadder p(field_size, padinfo_, dest); - fmt_helper::pad3(static_cast<uint32_t>(millis.count()), dest); - } -}; - -// microseconds -template <typename ScopedPadder> -class f_formatter final : public flag_formatter { -public: - explicit f_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { - auto micros = fmt_helper::time_fraction<std::chrono::microseconds>(msg.time); - - const size_t field_size = 6; - ScopedPadder p(field_size, padinfo_, dest); - fmt_helper::pad6(static_cast<size_t>(micros.count()), dest); - } -}; - -// nanoseconds -template <typename ScopedPadder> -class F_formatter final : public flag_formatter { -public: - explicit F_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { - auto ns = fmt_helper::time_fraction<std::chrono::nanoseconds>(msg.time); - const size_t field_size = 9; - ScopedPadder p(field_size, padinfo_, dest); - fmt_helper::pad9(static_cast<size_t>(ns.count()), dest); - } -}; - -// seconds since epoch -template <typename ScopedPadder> -class E_formatter final : public flag_formatter { -public: - explicit E_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { - const size_t field_size = 10; - ScopedPadder p(field_size, padinfo_, dest); - auto duration = msg.time.time_since_epoch(); - auto seconds = std::chrono::duration_cast<std::chrono::seconds>(duration).count(); - fmt_helper::append_int(seconds, dest); - } -}; - -// AM/PM -template <typename ScopedPadder> -class p_formatter final : public flag_formatter { -public: - explicit p_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { - const size_t field_size = 2; - ScopedPadder p(field_size, padinfo_, dest); - fmt_helper::append_string_view(ampm(tm_time), dest); - } -}; - -// 12 hour clock 02:55:02 pm -template <typename ScopedPadder> -class r_formatter final : public flag_formatter { -public: - explicit r_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { - const size_t field_size = 11; - ScopedPadder p(field_size, padinfo_, dest); - - fmt_helper::pad2(to12h(tm_time), dest); - dest.push_back(':'); - fmt_helper::pad2(tm_time.tm_min, dest); - dest.push_back(':'); - fmt_helper::pad2(tm_time.tm_sec, dest); - dest.push_back(' '); - fmt_helper::append_string_view(ampm(tm_time), dest); - } -}; - -// 24-hour HH:MM time, equivalent to %H:%M -template <typename ScopedPadder> -class R_formatter final : public flag_formatter { -public: - explicit R_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { - const size_t field_size = 5; - ScopedPadder p(field_size, padinfo_, dest); - - fmt_helper::pad2(tm_time.tm_hour, dest); - dest.push_back(':'); - fmt_helper::pad2(tm_time.tm_min, dest); - } -}; - -// ISO 8601 time format (HH:MM:SS), equivalent to %H:%M:%S -template <typename ScopedPadder> -class T_formatter final : public flag_formatter { -public: - explicit T_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override { - const size_t field_size = 8; - ScopedPadder p(field_size, padinfo_, dest); - - fmt_helper::pad2(tm_time.tm_hour, dest); - dest.push_back(':'); - fmt_helper::pad2(tm_time.tm_min, dest); - dest.push_back(':'); - fmt_helper::pad2(tm_time.tm_sec, dest); - } -}; - -// ISO 8601 offset from UTC in timezone (+-HH:MM) -template <typename ScopedPadder> -class z_formatter final : public flag_formatter { -public: - explicit z_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - z_formatter() = default; - z_formatter(const z_formatter &) = delete; - z_formatter &operator=(const z_formatter &) = delete; - - void format(const details::log_msg &msg, const std::tm &tm_time, memory_buf_t &dest) override { - const size_t field_size = 6; - ScopedPadder p(field_size, padinfo_, dest); - - auto total_minutes = get_cached_offset(msg, tm_time); - bool is_negative = total_minutes < 0; - if (is_negative) { - total_minutes = -total_minutes; - dest.push_back('-'); - } else { - dest.push_back('+'); - } - - fmt_helper::pad2(total_minutes / 60, dest); // hours - dest.push_back(':'); - fmt_helper::pad2(total_minutes % 60, dest); // minutes - } - -private: - log_clock::time_point last_update_{std::chrono::seconds(0)}; - int offset_minutes_{0}; - - int get_cached_offset(const log_msg &msg, const std::tm &tm_time) { - // refresh every 10 seconds - if (msg.time - last_update_ >= std::chrono::seconds(10)) { - offset_minutes_ = os::utc_minutes_offset(tm_time); - last_update_ = msg.time; - } - return offset_minutes_; - } -}; - -// Thread id -template <typename ScopedPadder> -class t_formatter final : public flag_formatter { -public: - explicit t_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { - const auto field_size = ScopedPadder::count_digits(msg.thread_id); - ScopedPadder p(field_size, padinfo_, dest); - fmt_helper::append_int(msg.thread_id, dest); - } -}; - -// Current pid -template <typename ScopedPadder> -class pid_formatter final : public flag_formatter { -public: - explicit pid_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - void format(const details::log_msg &, const std::tm &, memory_buf_t &dest) override { - const auto pid = static_cast<uint32_t>(details::os::pid()); - auto field_size = ScopedPadder::count_digits(pid); - ScopedPadder p(field_size, padinfo_, dest); - fmt_helper::append_int(pid, dest); - } -}; - -template <typename ScopedPadder> -class v_formatter final : public flag_formatter { -public: - explicit v_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { - ScopedPadder p(msg.payload.size(), padinfo_, dest); - fmt_helper::append_string_view(msg.payload, dest); - } -}; - -class ch_formatter final : public flag_formatter { -public: - explicit ch_formatter(char ch) - : ch_(ch) {} - - void format(const details::log_msg &, const std::tm &, memory_buf_t &dest) override { - dest.push_back(ch_); - } - -private: - char ch_; -}; - -// aggregate user chars to display as is -class aggregate_formatter final : public flag_formatter { -public: - aggregate_formatter() = default; - - void add_ch(char ch) { str_ += ch; } - void format(const details::log_msg &, const std::tm &, memory_buf_t &dest) override { - fmt_helper::append_string_view(str_, dest); - } - -private: - std::string str_; -}; - -// mark the color range. expect it to be in the form of "%^colored text%$" -class color_start_formatter final : public flag_formatter { -public: - explicit color_start_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { - msg.color_range_start = dest.size(); - } -}; - -class color_stop_formatter final : public flag_formatter { -public: - explicit color_stop_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { - msg.color_range_end = dest.size(); - } -}; - -// print source location -template <typename ScopedPadder> -class source_location_formatter final : public flag_formatter { -public: - explicit source_location_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { - if (msg.source.empty()) { - ScopedPadder p(0, padinfo_, dest); - return; - } - - size_t text_size; - if (padinfo_.enabled()) { - // calc text size for padding based on "filename:line" - text_size = std::char_traits<char>::length(msg.source.filename) + - ScopedPadder::count_digits(msg.source.line) + 1; - } else { - text_size = 0; - } - - ScopedPadder p(text_size, padinfo_, dest); - fmt_helper::append_string_view(msg.source.filename, dest); - dest.push_back(':'); - fmt_helper::append_int(msg.source.line, dest); - } -}; - -// print source filename -template <typename ScopedPadder> -class source_filename_formatter final : public flag_formatter { -public: - explicit source_filename_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { - if (msg.source.empty()) { - ScopedPadder p(0, padinfo_, dest); - return; - } - size_t text_size = - padinfo_.enabled() ? std::char_traits<char>::length(msg.source.filename) : 0; - ScopedPadder p(text_size, padinfo_, dest); - fmt_helper::append_string_view(msg.source.filename, dest); - } -}; - -template <typename ScopedPadder> -class short_filename_formatter final : public flag_formatter { -public: - explicit short_filename_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - -#ifdef _MSC_VER - #pragma warning(push) - #pragma warning(disable : 4127) // consider using 'if constexpr' instead -#endif // _MSC_VER - static const char *basename(const char *filename) { - // if the size is 2 (1 character + null terminator) we can use the more efficient strrchr - // the branch will be elided by optimizations - if (sizeof(os::folder_seps) == 2) { - const char *rv = std::strrchr(filename, os::folder_seps[0]); - return rv != nullptr ? rv + 1 : filename; - } else { - const std::reverse_iterator<const char *> begin(filename + std::strlen(filename)); - const std::reverse_iterator<const char *> end(filename); - - const auto it = std::find_first_of(begin, end, std::begin(os::folder_seps), - std::end(os::folder_seps) - 1); - return it != end ? it.base() : filename; - } - } -#ifdef _MSC_VER - #pragma warning(pop) -#endif // _MSC_VER - - void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { - if (msg.source.empty()) { - ScopedPadder p(0, padinfo_, dest); - return; - } - auto filename = basename(msg.source.filename); - size_t text_size = padinfo_.enabled() ? std::char_traits<char>::length(filename) : 0; - ScopedPadder p(text_size, padinfo_, dest); - fmt_helper::append_string_view(filename, dest); - } -}; - -template <typename ScopedPadder> -class source_linenum_formatter final : public flag_formatter { -public: - explicit source_linenum_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { - if (msg.source.empty()) { - ScopedPadder p(0, padinfo_, dest); - return; - } - - auto field_size = ScopedPadder::count_digits(msg.source.line); - ScopedPadder p(field_size, padinfo_, dest); - fmt_helper::append_int(msg.source.line, dest); - } -}; - -// print source funcname -template <typename ScopedPadder> -class source_funcname_formatter final : public flag_formatter { -public: - explicit source_funcname_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { - if (msg.source.empty()) { - ScopedPadder p(0, padinfo_, dest); - return; - } - size_t text_size = - padinfo_.enabled() ? std::char_traits<char>::length(msg.source.funcname) : 0; - ScopedPadder p(text_size, padinfo_, dest); - fmt_helper::append_string_view(msg.source.funcname, dest); - } -}; - -// print elapsed time since last message -template <typename ScopedPadder, typename Units> -class elapsed_formatter final : public flag_formatter { -public: - using DurationUnits = Units; - - explicit elapsed_formatter(padding_info padinfo) - : flag_formatter(padinfo), - last_message_time_(log_clock::now()) {} - - void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override { - auto delta = (std::max)(msg.time - last_message_time_, log_clock::duration::zero()); - auto delta_units = std::chrono::duration_cast<DurationUnits>(delta); - last_message_time_ = msg.time; - auto delta_count = static_cast<size_t>(delta_units.count()); - auto n_digits = static_cast<size_t>(ScopedPadder::count_digits(delta_count)); - ScopedPadder p(n_digits, padinfo_, dest); - fmt_helper::append_int(delta_count, dest); - } - -private: - log_clock::time_point last_message_time_; -}; - -// Class for formatting Mapped Diagnostic Context (MDC) in log messages. -// Example: [logger-name] [info] [mdc_key_1:mdc_value_1 mdc_key_2:mdc_value_2] some message -#ifndef SPDLOG_NO_TLS -template <typename ScopedPadder> -class mdc_formatter : public flag_formatter { -public: - explicit mdc_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - void format(const details::log_msg &, const std::tm &, memory_buf_t &dest) override { - auto &mdc_map = mdc::get_context(); - if (mdc_map.empty()) { - ScopedPadder p(0, padinfo_, dest); - return; - } else { - format_mdc(mdc_map, dest); - } - } - - void format_mdc(const mdc::mdc_map_t &mdc_map, memory_buf_t &dest) { - auto last_element = --mdc_map.end(); - for (auto it = mdc_map.begin(); it != mdc_map.end(); ++it) { - auto &pair = *it; - const auto &key = pair.first; - const auto &value = pair.second; - size_t content_size = key.size() + value.size() + 1; // 1 for ':' - - if (it != last_element) { - content_size++; // 1 for ' ' - } - - ScopedPadder p(content_size, padinfo_, dest); - fmt_helper::append_string_view(key, dest); - fmt_helper::append_string_view(":", dest); - fmt_helper::append_string_view(value, dest); - if (it != last_element) { - fmt_helper::append_string_view(" ", dest); - } - } - } -}; -#endif - -// Full info formatter -// pattern: [%Y-%m-%d %H:%M:%S.%e] [%n] [%l] [%s:%#] %v -class full_formatter final : public flag_formatter { -public: - explicit full_formatter(padding_info padinfo) - : flag_formatter(padinfo) {} - - void format(const details::log_msg &msg, const std::tm &tm_time, memory_buf_t &dest) override { - using std::chrono::duration_cast; - using std::chrono::milliseconds; - using std::chrono::seconds; - - // cache the date/time part for the next second. - auto duration = msg.time.time_since_epoch(); - auto secs = duration_cast<seconds>(duration); - - if (cache_timestamp_ != secs || cached_datetime_.size() == 0) { - cached_datetime_.clear(); - cached_datetime_.push_back('['); - fmt_helper::append_int(tm_time.tm_year + 1900, cached_datetime_); - cached_datetime_.push_back('-'); - - fmt_helper::pad2(tm_time.tm_mon + 1, cached_datetime_); - cached_datetime_.push_back('-'); - - fmt_helper::pad2(tm_time.tm_mday, cached_datetime_); - cached_datetime_.push_back(' '); - - fmt_helper::pad2(tm_time.tm_hour, cached_datetime_); - cached_datetime_.push_back(':'); - - fmt_helper::pad2(tm_time.tm_min, cached_datetime_); - cached_datetime_.push_back(':'); - - fmt_helper::pad2(tm_time.tm_sec, cached_datetime_); - cached_datetime_.push_back('.'); - - cache_timestamp_ = secs; - } - dest.append(cached_datetime_.begin(), cached_datetime_.end()); - - auto millis = fmt_helper::time_fraction<milliseconds>(msg.time); - fmt_helper::pad3(static_cast<uint32_t>(millis.count()), dest); - dest.push_back(']'); - dest.push_back(' '); - - // append logger name if exists - if (msg.logger_name.size() > 0) { - dest.push_back('['); - fmt_helper::append_string_view(msg.logger_name, dest); - dest.push_back(']'); - dest.push_back(' '); - } - - dest.push_back('['); - // wrap the level name with color - msg.color_range_start = dest.size(); - // fmt_helper::append_string_view(level::to_c_str(msg.level), dest); - fmt_helper::append_string_view(level::to_string_view(msg.level), dest); - msg.color_range_end = dest.size(); - dest.push_back(']'); - dest.push_back(' '); - - // add source location if present - if (!msg.source.empty()) { - dest.push_back('['); - const char *filename = - details::short_filename_formatter<details::null_scoped_padder>::basename( - msg.source.filename); - fmt_helper::append_string_view(filename, dest); - dest.push_back(':'); - fmt_helper::append_int(msg.source.line, dest); - dest.push_back(']'); - dest.push_back(' '); - } - -#ifndef SPDLOG_NO_TLS - // add mdc if present - auto &mdc_map = mdc::get_context(); - if (!mdc_map.empty()) { - dest.push_back('['); - mdc_formatter_.format_mdc(mdc_map, dest); - dest.push_back(']'); - dest.push_back(' '); - } -#endif - // fmt_helper::append_string_view(msg.msg(), dest); - fmt_helper::append_string_view(msg.payload, dest); - } - -private: - std::chrono::seconds cache_timestamp_{0}; - memory_buf_t cached_datetime_; - -#ifndef SPDLOG_NO_TLS - mdc_formatter<null_scoped_padder> mdc_formatter_{padding_info {}}; -#endif -}; - -} // namespace details - -SPDLOG_INLINE pattern_formatter::pattern_formatter(std::string pattern, - pattern_time_type time_type, - std::string eol, - custom_flags custom_user_flags) - : pattern_(std::move(pattern)), - eol_(std::move(eol)), - pattern_time_type_(time_type), - need_localtime_(false), - last_log_secs_(0), - custom_handlers_(std::move(custom_user_flags)) { - std::memset(&cached_tm_, 0, sizeof(cached_tm_)); - compile_pattern_(pattern_); -} - -// use by default full formatter for if pattern is not given -SPDLOG_INLINE pattern_formatter::pattern_formatter(pattern_time_type time_type, std::string eol) - : pattern_("%+"), - eol_(std::move(eol)), - pattern_time_type_(time_type), - need_localtime_(true), - last_log_secs_(0) { - std::memset(&cached_tm_, 0, sizeof(cached_tm_)); - formatters_.push_back(details::make_unique<details::full_formatter>(details::padding_info{})); -} - -SPDLOG_INLINE std::unique_ptr<formatter> pattern_formatter::clone() const { - custom_flags cloned_custom_formatters; - for (auto &it : custom_handlers_) { - cloned_custom_formatters[it.first] = it.second->clone(); - } - auto cloned = details::make_unique<pattern_formatter>(pattern_, pattern_time_type_, eol_, - std::move(cloned_custom_formatters)); - cloned->need_localtime(need_localtime_); -#if defined(__GNUC__) && __GNUC__ < 5 - return std::move(cloned); -#else - return cloned; -#endif -} - -SPDLOG_INLINE void pattern_formatter::format(const details::log_msg &msg, memory_buf_t &dest) { - if (need_localtime_) { - const auto secs = - std::chrono::duration_cast<std::chrono::seconds>(msg.time.time_since_epoch()); - if (secs != last_log_secs_) { - cached_tm_ = get_time_(msg); - last_log_secs_ = secs; - } - } - - for (auto &f : formatters_) { - f->format(msg, cached_tm_, dest); - } - // write eol - details::fmt_helper::append_string_view(eol_, dest); -} - -SPDLOG_INLINE void pattern_formatter::set_pattern(std::string pattern) { - pattern_ = std::move(pattern); - need_localtime_ = false; - compile_pattern_(pattern_); -} - -SPDLOG_INLINE void pattern_formatter::need_localtime(bool need) { need_localtime_ = need; } - -SPDLOG_INLINE std::tm pattern_formatter::get_time_(const details::log_msg &msg) { - if (pattern_time_type_ == pattern_time_type::local) { - return details::os::localtime(log_clock::to_time_t(msg.time)); - } - return details::os::gmtime(log_clock::to_time_t(msg.time)); -} - -template <typename Padder> -SPDLOG_INLINE void pattern_formatter::handle_flag_(char flag, details::padding_info padding) { - // process custom flags - auto it = custom_handlers_.find(flag); - if (it != custom_handlers_.end()) { - auto custom_handler = it->second->clone(); - custom_handler->set_padding_info(padding); - formatters_.push_back(std::move(custom_handler)); - return; - } - - // process built-in flags - switch (flag) { - case ('+'): // default formatter - formatters_.push_back(details::make_unique<details::full_formatter>(padding)); - need_localtime_ = true; - break; - - case 'n': // logger name - formatters_.push_back(details::make_unique<details::name_formatter<Padder>>(padding)); - break; - - case 'l': // level - formatters_.push_back(details::make_unique<details::level_formatter<Padder>>(padding)); - break; - - case 'L': // short level - formatters_.push_back( - details::make_unique<details::short_level_formatter<Padder>>(padding)); - break; - - case ('t'): // thread id - formatters_.push_back(details::make_unique<details::t_formatter<Padder>>(padding)); - break; - - case ('v'): // the message text - formatters_.push_back(details::make_unique<details::v_formatter<Padder>>(padding)); - break; - - case ('a'): // weekday - formatters_.push_back(details::make_unique<details::a_formatter<Padder>>(padding)); - need_localtime_ = true; - break; - - case ('A'): // short weekday - formatters_.push_back(details::make_unique<details::A_formatter<Padder>>(padding)); - need_localtime_ = true; - break; - - case ('b'): - case ('h'): // month - formatters_.push_back(details::make_unique<details::b_formatter<Padder>>(padding)); - need_localtime_ = true; - break; - - case ('B'): // short month - formatters_.push_back(details::make_unique<details::B_formatter<Padder>>(padding)); - need_localtime_ = true; - break; - - case ('c'): // datetime - formatters_.push_back(details::make_unique<details::c_formatter<Padder>>(padding)); - need_localtime_ = true; - break; - - case ('C'): // year 2 digits - formatters_.push_back(details::make_unique<details::C_formatter<Padder>>(padding)); - need_localtime_ = true; - break; - - case ('Y'): // year 4 digits - formatters_.push_back(details::make_unique<details::Y_formatter<Padder>>(padding)); - need_localtime_ = true; - break; - - case ('D'): - case ('x'): // datetime MM/DD/YY - formatters_.push_back(details::make_unique<details::D_formatter<Padder>>(padding)); - need_localtime_ = true; - break; - - case ('m'): // month 1-12 - formatters_.push_back(details::make_unique<details::m_formatter<Padder>>(padding)); - need_localtime_ = true; - break; - - case ('d'): // day of month 1-31 - formatters_.push_back(details::make_unique<details::d_formatter<Padder>>(padding)); - need_localtime_ = true; - break; - - case ('H'): // hours 24 - formatters_.push_back(details::make_unique<details::H_formatter<Padder>>(padding)); - need_localtime_ = true; - break; - - case ('I'): // hours 12 - formatters_.push_back(details::make_unique<details::I_formatter<Padder>>(padding)); - need_localtime_ = true; - break; - - case ('M'): // minutes - formatters_.push_back(details::make_unique<details::M_formatter<Padder>>(padding)); - need_localtime_ = true; - break; - - case ('S'): // seconds - formatters_.push_back(details::make_unique<details::S_formatter<Padder>>(padding)); - need_localtime_ = true; - break; - - case ('e'): // milliseconds - formatters_.push_back(details::make_unique<details::e_formatter<Padder>>(padding)); - break; - - case ('f'): // microseconds - formatters_.push_back(details::make_unique<details::f_formatter<Padder>>(padding)); - break; - - case ('F'): // nanoseconds - formatters_.push_back(details::make_unique<details::F_formatter<Padder>>(padding)); - break; - - case ('E'): // seconds since epoch - formatters_.push_back(details::make_unique<details::E_formatter<Padder>>(padding)); - break; - - case ('p'): // am/pm - formatters_.push_back(details::make_unique<details::p_formatter<Padder>>(padding)); - need_localtime_ = true; - break; - - case ('r'): // 12 hour clock 02:55:02 pm - formatters_.push_back(details::make_unique<details::r_formatter<Padder>>(padding)); - need_localtime_ = true; - break; - - case ('R'): // 24-hour HH:MM time - formatters_.push_back(details::make_unique<details::R_formatter<Padder>>(padding)); - need_localtime_ = true; - break; - - case ('T'): - case ('X'): // ISO 8601 time format (HH:MM:SS) - formatters_.push_back(details::make_unique<details::T_formatter<Padder>>(padding)); - need_localtime_ = true; - break; - - case ('z'): // timezone - formatters_.push_back(details::make_unique<details::z_formatter<Padder>>(padding)); - need_localtime_ = true; - break; - - case ('P'): // pid - formatters_.push_back(details::make_unique<details::pid_formatter<Padder>>(padding)); - break; - - case ('^'): // color range start - formatters_.push_back(details::make_unique<details::color_start_formatter>(padding)); - break; - - case ('$'): // color range end - formatters_.push_back(details::make_unique<details::color_stop_formatter>(padding)); - break; - - case ('@'): // source location (filename:filenumber) - formatters_.push_back( - details::make_unique<details::source_location_formatter<Padder>>(padding)); - break; - - case ('s'): // short source filename - without directory name - formatters_.push_back( - details::make_unique<details::short_filename_formatter<Padder>>(padding)); - break; - - case ('g'): // full source filename - formatters_.push_back( - details::make_unique<details::source_filename_formatter<Padder>>(padding)); - break; - - case ('#'): // source line number - formatters_.push_back( - details::make_unique<details::source_linenum_formatter<Padder>>(padding)); - break; - - case ('!'): // source funcname - formatters_.push_back( - details::make_unique<details::source_funcname_formatter<Padder>>(padding)); - break; - - case ('%'): // % char - formatters_.push_back(details::make_unique<details::ch_formatter>('%')); - break; - - case ('u'): // elapsed time since last log message in nanos - formatters_.push_back( - details::make_unique<details::elapsed_formatter<Padder, std::chrono::nanoseconds>>( - padding)); - break; - - case ('i'): // elapsed time since last log message in micros - formatters_.push_back( - details::make_unique<details::elapsed_formatter<Padder, std::chrono::microseconds>>( - padding)); - break; - - case ('o'): // elapsed time since last log message in millis - formatters_.push_back( - details::make_unique<details::elapsed_formatter<Padder, std::chrono::milliseconds>>( - padding)); - break; - - case ('O'): // elapsed time since last log message in seconds - formatters_.push_back( - details::make_unique<details::elapsed_formatter<Padder, std::chrono::seconds>>( - padding)); - break; - -#ifndef SPDLOG_NO_TLS // mdc formatter requires TLS support - case ('&'): - formatters_.push_back(details::make_unique<details::mdc_formatter<Padder>>(padding)); - break; -#endif - - default: // Unknown flag appears as is - auto unknown_flag = details::make_unique<details::aggregate_formatter>(); - - if (!padding.truncate_) { - unknown_flag->add_ch('%'); - unknown_flag->add_ch(flag); - formatters_.push_back((std::move(unknown_flag))); - } - // fix issue #1617 (prev char was '!' and should have been treated as funcname flag - // instead of truncating flag) spdlog::set_pattern("[%10!] %v") => "[ main] some - // message" spdlog::set_pattern("[%3!!] %v") => "[mai] some message" - else { - padding.truncate_ = false; - formatters_.push_back( - details::make_unique<details::source_funcname_formatter<Padder>>(padding)); - unknown_flag->add_ch(flag); - formatters_.push_back((std::move(unknown_flag))); - } - - break; - } -} - -// Extract given pad spec (e.g. %8X, %=8X, %-8!X, %8!X, %=8!X, %-8!X, %+8!X) -// Advance the given it pass the end of the padding spec found (if any) -// Return padding. -SPDLOG_INLINE details::padding_info pattern_formatter::handle_padspec_( - std::string::const_iterator &it, std::string::const_iterator end) { - using details::padding_info; - using details::scoped_padder; - const size_t max_width = 64; - if (it == end) { - return padding_info{}; - } - - padding_info::pad_side side; - switch (*it) { - case '-': - side = padding_info::pad_side::right; - ++it; - break; - case '=': - side = padding_info::pad_side::center; - ++it; - break; - default: - side = details::padding_info::pad_side::left; - break; - } - - if (it == end || !std::isdigit(static_cast<unsigned char>(*it))) { - return padding_info{}; // no padding if no digit found here - } - - auto width = static_cast<size_t>(*it) - '0'; - for (++it; it != end && std::isdigit(static_cast<unsigned char>(*it)); ++it) { - auto digit = static_cast<size_t>(*it) - '0'; - width = width * 10 + digit; - } - - // search for the optional truncate marker '!' - bool truncate; - if (it != end && *it == '!') { - truncate = true; - ++it; - } else { - truncate = false; - } - return details::padding_info{std::min<size_t>(width, max_width), side, truncate}; -} - -SPDLOG_INLINE void pattern_formatter::compile_pattern_(const std::string &pattern) { - auto end = pattern.end(); - std::unique_ptr<details::aggregate_formatter> user_chars; - formatters_.clear(); - for (auto it = pattern.begin(); it != end; ++it) { - if (*it == '%') { - if (user_chars) // append user chars found so far - { - formatters_.push_back(std::move(user_chars)); - } - - auto padding = handle_padspec_(++it, end); - - if (it != end) { - if (padding.enabled()) { - handle_flag_<details::scoped_padder>(*it, padding); - } else { - handle_flag_<details::null_scoped_padder>(*it, padding); - } - } else { - break; - } - } else // chars not following the % sign should be displayed as is - { - if (!user_chars) { - user_chars = details::make_unique<details::aggregate_formatter>(); - } - user_chars->add_ch(*it); - } - } - if (user_chars) // append raw chars found so far - { - formatters_.push_back(std::move(user_chars)); - } -} -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/pattern_formatter.h b/thirdparty/spdlog/include/spdlog/pattern_formatter.h deleted file mode 100644 index ececd6732..000000000 --- a/thirdparty/spdlog/include/spdlog/pattern_formatter.h +++ /dev/null @@ -1,118 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#include <spdlog/common.h> -#include <spdlog/details/log_msg.h> -#include <spdlog/details/os.h> -#include <spdlog/formatter.h> - -#include <chrono> -#include <ctime> -#include <memory> - -#include <string> -#include <unordered_map> -#include <vector> - -namespace spdlog { -namespace details { - -// padding information. -struct padding_info { - enum class pad_side { left, right, center }; - - padding_info() = default; - padding_info(size_t width, padding_info::pad_side side, bool truncate) - : width_(width), - side_(side), - truncate_(truncate), - enabled_(true) {} - - bool enabled() const { return enabled_; } - size_t width_ = 0; - pad_side side_ = pad_side::left; - bool truncate_ = false; - bool enabled_ = false; -}; - -class SPDLOG_API flag_formatter { -public: - explicit flag_formatter(padding_info padinfo) - : padinfo_(padinfo) {} - flag_formatter() = default; - virtual ~flag_formatter() = default; - virtual void format(const details::log_msg &msg, - const std::tm &tm_time, - memory_buf_t &dest) = 0; - -protected: - padding_info padinfo_; -}; - -} // namespace details - -class SPDLOG_API custom_flag_formatter : public details::flag_formatter { -public: - virtual std::unique_ptr<custom_flag_formatter> clone() const = 0; - - void set_padding_info(const details::padding_info &padding) { - flag_formatter::padinfo_ = padding; - } -}; - -class SPDLOG_API pattern_formatter final : public formatter { -public: - using custom_flags = std::unordered_map<char, std::unique_ptr<custom_flag_formatter>>; - - explicit pattern_formatter(std::string pattern, - pattern_time_type time_type = pattern_time_type::local, - std::string eol = spdlog::details::os::default_eol, - custom_flags custom_user_flags = custom_flags()); - - // use default pattern is not given - explicit pattern_formatter(pattern_time_type time_type = pattern_time_type::local, - std::string eol = spdlog::details::os::default_eol); - - pattern_formatter(const pattern_formatter &other) = delete; - pattern_formatter &operator=(const pattern_formatter &other) = delete; - - std::unique_ptr<formatter> clone() const override; - void format(const details::log_msg &msg, memory_buf_t &dest) override; - - template <typename T, typename... Args> - pattern_formatter &add_flag(char flag, Args &&...args) { - custom_handlers_[flag] = details::make_unique<T>(std::forward<Args>(args)...); - return *this; - } - void set_pattern(std::string pattern); - void need_localtime(bool need = true); - -private: - std::string pattern_; - std::string eol_; - pattern_time_type pattern_time_type_; - bool need_localtime_; - std::tm cached_tm_; - std::chrono::seconds last_log_secs_; - std::vector<std::unique_ptr<details::flag_formatter>> formatters_; - custom_flags custom_handlers_; - - std::tm get_time_(const details::log_msg &msg); - template <typename Padder> - void handle_flag_(char flag, details::padding_info padding); - - // Extract given pad spec (e.g. %8X) - // Advance the given it pass the end of the padding spec found (if any) - // Return padding. - static details::padding_info handle_padspec_(std::string::const_iterator &it, - std::string::const_iterator end); - - void compile_pattern_(const std::string &pattern); -}; -} // namespace spdlog - -#ifdef SPDLOG_HEADER_ONLY - #include "pattern_formatter-inl.h" -#endif diff --git a/thirdparty/spdlog/include/spdlog/sinks/ansicolor_sink-inl.h b/thirdparty/spdlog/include/spdlog/sinks/ansicolor_sink-inl.h deleted file mode 100644 index 6a23f6c70..000000000 --- a/thirdparty/spdlog/include/spdlog/sinks/ansicolor_sink-inl.h +++ /dev/null @@ -1,142 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#ifndef SPDLOG_HEADER_ONLY - #include <spdlog/sinks/ansicolor_sink.h> -#endif - -#include <spdlog/details/os.h> -#include <spdlog/pattern_formatter.h> - -namespace spdlog { -namespace sinks { - -template <typename ConsoleMutex> -SPDLOG_INLINE ansicolor_sink<ConsoleMutex>::ansicolor_sink(FILE *target_file, color_mode mode) - : target_file_(target_file), - mutex_(ConsoleMutex::mutex()), - formatter_(details::make_unique<spdlog::pattern_formatter>()) - -{ - set_color_mode_(mode); - colors_.at(level::trace) = to_string_(white); - colors_.at(level::debug) = to_string_(cyan); - colors_.at(level::info) = to_string_(green); - colors_.at(level::warn) = to_string_(yellow_bold); - colors_.at(level::err) = to_string_(red_bold); - colors_.at(level::critical) = to_string_(bold_on_red); - colors_.at(level::off) = to_string_(reset); -} - -template <typename ConsoleMutex> -SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color(level::level_enum color_level, - string_view_t color) { - std::lock_guard<mutex_t> lock(mutex_); - colors_.at(static_cast<size_t>(color_level)) = to_string_(color); -} - -template <typename ConsoleMutex> -SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::log(const details::log_msg &msg) { - // Wrap the originally formatted message in color codes. - // If color is not supported in the terminal, log as is instead. - std::lock_guard<mutex_t> lock(mutex_); - msg.color_range_start = 0; - msg.color_range_end = 0; - memory_buf_t formatted; - formatter_->format(msg, formatted); - if (should_do_colors_ && msg.color_range_end > msg.color_range_start) { - // before color range - print_range_(formatted, 0, msg.color_range_start); - // in color range - print_ccode_(colors_.at(static_cast<size_t>(msg.level))); - print_range_(formatted, msg.color_range_start, msg.color_range_end); - print_ccode_(reset); - // after color range - print_range_(formatted, msg.color_range_end, formatted.size()); - } else // no color - { - print_range_(formatted, 0, formatted.size()); - } - fflush(target_file_); -} - -template <typename ConsoleMutex> -SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::flush() { - std::lock_guard<mutex_t> lock(mutex_); - fflush(target_file_); -} - -template <typename ConsoleMutex> -SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_pattern(const std::string &pattern) { - std::lock_guard<mutex_t> lock(mutex_); - formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern)); -} - -template <typename ConsoleMutex> -SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_formatter( - std::unique_ptr<spdlog::formatter> sink_formatter) { - std::lock_guard<mutex_t> lock(mutex_); - formatter_ = std::move(sink_formatter); -} - -template <typename ConsoleMutex> -SPDLOG_INLINE bool ansicolor_sink<ConsoleMutex>::should_color() const { - return should_do_colors_; -} - -template <typename ConsoleMutex> -SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color_mode(color_mode mode) { - std::lock_guard<mutex_t> lock(mutex_); - set_color_mode_(mode); -} - -template <typename ConsoleMutex> -SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color_mode_(color_mode mode) { - switch (mode) { - case color_mode::always: - should_do_colors_ = true; - return; - case color_mode::automatic: - should_do_colors_ = - details::os::in_terminal(target_file_) && details::os::is_color_terminal(); - return; - case color_mode::never: - should_do_colors_ = false; - return; - default: - should_do_colors_ = false; - } -} - -template <typename ConsoleMutex> -SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::print_ccode_( - const string_view_t &color_code) const { - details::os::fwrite_bytes(color_code.data(), color_code.size(), target_file_); -} - -template <typename ConsoleMutex> -SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::print_range_(const memory_buf_t &formatted, - size_t start, - size_t end) const { - details::os::fwrite_bytes(formatted.data() + start, end - start, target_file_); -} - -template <typename ConsoleMutex> -SPDLOG_INLINE std::string ansicolor_sink<ConsoleMutex>::to_string_(const string_view_t &sv) { - return std::string(sv.data(), sv.size()); -} - -// ansicolor_stdout_sink -template <typename ConsoleMutex> -SPDLOG_INLINE ansicolor_stdout_sink<ConsoleMutex>::ansicolor_stdout_sink(color_mode mode) - : ansicolor_sink<ConsoleMutex>(stdout, mode) {} - -// ansicolor_stderr_sink -template <typename ConsoleMutex> -SPDLOG_INLINE ansicolor_stderr_sink<ConsoleMutex>::ansicolor_stderr_sink(color_mode mode) - : ansicolor_sink<ConsoleMutex>(stderr, mode) {} - -} // namespace sinks -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/sinks/ansicolor_sink.h b/thirdparty/spdlog/include/spdlog/sinks/ansicolor_sink.h deleted file mode 100644 index 47cea9154..000000000 --- a/thirdparty/spdlog/include/spdlog/sinks/ansicolor_sink.h +++ /dev/null @@ -1,116 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#include <array> -#include <memory> -#include <mutex> -#include <spdlog/details/console_globals.h> -#include <spdlog/details/null_mutex.h> -#include <spdlog/sinks/sink.h> -#include <string> - -namespace spdlog { -namespace sinks { - -/** - * This sink prefixes the output with an ANSI escape sequence color code - * depending on the severity - * of the message. - * If no color terminal detected, omit the escape codes. - */ - -template <typename ConsoleMutex> -class ansicolor_sink : public sink { -public: - using mutex_t = typename ConsoleMutex::mutex_t; - ansicolor_sink(FILE *target_file, color_mode mode); - ~ansicolor_sink() override = default; - - ansicolor_sink(const ansicolor_sink &other) = delete; - ansicolor_sink(ansicolor_sink &&other) = delete; - - ansicolor_sink &operator=(const ansicolor_sink &other) = delete; - ansicolor_sink &operator=(ansicolor_sink &&other) = delete; - - void set_color(level::level_enum color_level, string_view_t color); - void set_color_mode(color_mode mode); - bool should_color() const; - - void log(const details::log_msg &msg) override; - void flush() override; - void set_pattern(const std::string &pattern) override; - void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override; - - // Formatting codes - const string_view_t reset = "\033[m"; - const string_view_t bold = "\033[1m"; - const string_view_t dark = "\033[2m"; - const string_view_t underline = "\033[4m"; - const string_view_t blink = "\033[5m"; - const string_view_t reverse = "\033[7m"; - const string_view_t concealed = "\033[8m"; - const string_view_t clear_line = "\033[K"; - - // Foreground colors - const string_view_t black = "\033[30m"; - const string_view_t red = "\033[31m"; - const string_view_t green = "\033[32m"; - const string_view_t yellow = "\033[33m"; - const string_view_t blue = "\033[34m"; - const string_view_t magenta = "\033[35m"; - const string_view_t cyan = "\033[36m"; - const string_view_t white = "\033[37m"; - - /// Background colors - const string_view_t on_black = "\033[40m"; - const string_view_t on_red = "\033[41m"; - const string_view_t on_green = "\033[42m"; - const string_view_t on_yellow = "\033[43m"; - const string_view_t on_blue = "\033[44m"; - const string_view_t on_magenta = "\033[45m"; - const string_view_t on_cyan = "\033[46m"; - const string_view_t on_white = "\033[47m"; - - /// Bold colors - const string_view_t yellow_bold = "\033[33m\033[1m"; - const string_view_t red_bold = "\033[31m\033[1m"; - const string_view_t bold_on_red = "\033[1m\033[41m"; - -private: - FILE *target_file_; - mutex_t &mutex_; - bool should_do_colors_; - std::unique_ptr<spdlog::formatter> formatter_; - std::array<std::string, level::n_levels> colors_; - void set_color_mode_(color_mode mode); - void print_ccode_(const string_view_t &color_code) const; - void print_range_(const memory_buf_t &formatted, size_t start, size_t end) const; - static std::string to_string_(const string_view_t &sv); -}; - -template <typename ConsoleMutex> -class ansicolor_stdout_sink : public ansicolor_sink<ConsoleMutex> { -public: - explicit ansicolor_stdout_sink(color_mode mode = color_mode::automatic); -}; - -template <typename ConsoleMutex> -class ansicolor_stderr_sink : public ansicolor_sink<ConsoleMutex> { -public: - explicit ansicolor_stderr_sink(color_mode mode = color_mode::automatic); -}; - -using ansicolor_stdout_sink_mt = ansicolor_stdout_sink<details::console_mutex>; -using ansicolor_stdout_sink_st = ansicolor_stdout_sink<details::console_nullmutex>; - -using ansicolor_stderr_sink_mt = ansicolor_stderr_sink<details::console_mutex>; -using ansicolor_stderr_sink_st = ansicolor_stderr_sink<details::console_nullmutex>; - -} // namespace sinks -} // namespace spdlog - -#ifdef SPDLOG_HEADER_ONLY - #include "ansicolor_sink-inl.h" -#endif diff --git a/thirdparty/spdlog/include/spdlog/sinks/base_sink-inl.h b/thirdparty/spdlog/include/spdlog/sinks/base_sink-inl.h deleted file mode 100644 index ada161bcc..000000000 --- a/thirdparty/spdlog/include/spdlog/sinks/base_sink-inl.h +++ /dev/null @@ -1,59 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#ifndef SPDLOG_HEADER_ONLY - #include <spdlog/sinks/base_sink.h> -#endif - -#include <spdlog/common.h> -#include <spdlog/pattern_formatter.h> - -#include <memory> -#include <mutex> - -template <typename Mutex> -SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::base_sink() - : formatter_{details::make_unique<spdlog::pattern_formatter>()} {} - -template <typename Mutex> -SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::base_sink( - std::unique_ptr<spdlog::formatter> formatter) - : formatter_{std::move(formatter)} {} - -template <typename Mutex> -void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::log(const details::log_msg &msg) { - std::lock_guard<Mutex> lock(mutex_); - sink_it_(msg); -} - -template <typename Mutex> -void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::flush() { - std::lock_guard<Mutex> lock(mutex_); - flush_(); -} - -template <typename Mutex> -void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_pattern(const std::string &pattern) { - std::lock_guard<Mutex> lock(mutex_); - set_pattern_(pattern); -} - -template <typename Mutex> -void SPDLOG_INLINE -spdlog::sinks::base_sink<Mutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) { - std::lock_guard<Mutex> lock(mutex_); - set_formatter_(std::move(sink_formatter)); -} - -template <typename Mutex> -void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_pattern_(const std::string &pattern) { - set_formatter_(details::make_unique<spdlog::pattern_formatter>(pattern)); -} - -template <typename Mutex> -void SPDLOG_INLINE -spdlog::sinks::base_sink<Mutex>::set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter) { - formatter_ = std::move(sink_formatter); -} diff --git a/thirdparty/spdlog/include/spdlog/sinks/base_sink.h b/thirdparty/spdlog/include/spdlog/sinks/base_sink.h deleted file mode 100644 index 1b4bb0689..000000000 --- a/thirdparty/spdlog/include/spdlog/sinks/base_sink.h +++ /dev/null @@ -1,51 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once -// -// base sink templated over a mutex (either dummy or real) -// concrete implementation should override the sink_it_() and flush_() methods. -// locking is taken care of in this class - no locking needed by the -// implementers.. -// - -#include <spdlog/common.h> -#include <spdlog/details/log_msg.h> -#include <spdlog/sinks/sink.h> - -namespace spdlog { -namespace sinks { -template <typename Mutex> -class SPDLOG_API base_sink : public sink { -public: - base_sink(); - explicit base_sink(std::unique_ptr<spdlog::formatter> formatter); - ~base_sink() override = default; - - base_sink(const base_sink &) = delete; - base_sink(base_sink &&) = delete; - - base_sink &operator=(const base_sink &) = delete; - base_sink &operator=(base_sink &&) = delete; - - void log(const details::log_msg &msg) final override; - void flush() final override; - void set_pattern(const std::string &pattern) final override; - void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) final override; - -protected: - // sink formatter - std::unique_ptr<spdlog::formatter> formatter_; - Mutex mutex_; - - virtual void sink_it_(const details::log_msg &msg) = 0; - virtual void flush_() = 0; - virtual void set_pattern_(const std::string &pattern); - virtual void set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter); -}; -} // namespace sinks -} // namespace spdlog - -#ifdef SPDLOG_HEADER_ONLY - #include "base_sink-inl.h" -#endif diff --git a/thirdparty/spdlog/include/spdlog/sinks/basic_file_sink-inl.h b/thirdparty/spdlog/include/spdlog/sinks/basic_file_sink-inl.h deleted file mode 100644 index ce0ddad00..000000000 --- a/thirdparty/spdlog/include/spdlog/sinks/basic_file_sink-inl.h +++ /dev/null @@ -1,48 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#ifndef SPDLOG_HEADER_ONLY - #include <spdlog/sinks/basic_file_sink.h> -#endif - -#include <spdlog/common.h> -#include <spdlog/details/os.h> - -namespace spdlog { -namespace sinks { - -template <typename Mutex> -SPDLOG_INLINE basic_file_sink<Mutex>::basic_file_sink(const filename_t &filename, - bool truncate, - const file_event_handlers &event_handlers) - : file_helper_{event_handlers} { - file_helper_.open(filename, truncate); -} - -template <typename Mutex> -SPDLOG_INLINE const filename_t &basic_file_sink<Mutex>::filename() const { - return file_helper_.filename(); -} - -template <typename Mutex> -SPDLOG_INLINE void basic_file_sink<Mutex>::truncate() { - std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_); - file_helper_.reopen(true); -} - -template <typename Mutex> -SPDLOG_INLINE void basic_file_sink<Mutex>::sink_it_(const details::log_msg &msg) { - memory_buf_t formatted; - base_sink<Mutex>::formatter_->format(msg, formatted); - file_helper_.write(formatted); -} - -template <typename Mutex> -SPDLOG_INLINE void basic_file_sink<Mutex>::flush_() { - file_helper_.flush(); -} - -} // namespace sinks -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/sinks/basic_file_sink.h b/thirdparty/spdlog/include/spdlog/sinks/basic_file_sink.h deleted file mode 100644 index 48c07671a..000000000 --- a/thirdparty/spdlog/include/spdlog/sinks/basic_file_sink.h +++ /dev/null @@ -1,66 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#include <spdlog/details/file_helper.h> -#include <spdlog/details/null_mutex.h> -#include <spdlog/details/synchronous_factory.h> -#include <spdlog/sinks/base_sink.h> - -#include <mutex> -#include <string> - -namespace spdlog { -namespace sinks { -/* - * Trivial file sink with single file as target - */ -template <typename Mutex> -class basic_file_sink final : public base_sink<Mutex> { -public: - explicit basic_file_sink(const filename_t &filename, - bool truncate = false, - const file_event_handlers &event_handlers = {}); - const filename_t &filename() const; - void truncate(); - -protected: - void sink_it_(const details::log_msg &msg) override; - void flush_() override; - -private: - details::file_helper file_helper_; -}; - -using basic_file_sink_mt = basic_file_sink<std::mutex>; -using basic_file_sink_st = basic_file_sink<details::null_mutex>; - -} // namespace sinks - -// -// factory functions -// -template <typename Factory = spdlog::synchronous_factory> -inline std::shared_ptr<logger> basic_logger_mt(const std::string &logger_name, - const filename_t &filename, - bool truncate = false, - const file_event_handlers &event_handlers = {}) { - return Factory::template create<sinks::basic_file_sink_mt>(logger_name, filename, truncate, - event_handlers); -} - -template <typename Factory = spdlog::synchronous_factory> -inline std::shared_ptr<logger> basic_logger_st(const std::string &logger_name, - const filename_t &filename, - bool truncate = false, - const file_event_handlers &event_handlers = {}) { - return Factory::template create<sinks::basic_file_sink_st>(logger_name, filename, truncate, - event_handlers); -} - -} // namespace spdlog - -#ifdef SPDLOG_HEADER_ONLY - #include "basic_file_sink-inl.h" -#endif diff --git a/thirdparty/spdlog/include/spdlog/sinks/callback_sink.h b/thirdparty/spdlog/include/spdlog/sinks/callback_sink.h deleted file mode 100644 index 8f0c8d411..000000000 --- a/thirdparty/spdlog/include/spdlog/sinks/callback_sink.h +++ /dev/null @@ -1,56 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#include <spdlog/details/null_mutex.h> -#include <spdlog/details/synchronous_factory.h> -#include <spdlog/sinks/base_sink.h> - -#include <mutex> -#include <string> - -namespace spdlog { - -// callbacks type -typedef std::function<void(const details::log_msg &msg)> custom_log_callback; - -namespace sinks { -/* - * Trivial callback sink, gets a callback function and calls it on each log - */ -template <typename Mutex> -class callback_sink final : public base_sink<Mutex> { -public: - explicit callback_sink(const custom_log_callback &callback) - : callback_{callback} {} - -protected: - void sink_it_(const details::log_msg &msg) override { callback_(msg); } - void flush_() override {} - -private: - custom_log_callback callback_; -}; - -using callback_sink_mt = callback_sink<std::mutex>; -using callback_sink_st = callback_sink<details::null_mutex>; - -} // namespace sinks - -// -// factory functions -// -template <typename Factory = spdlog::synchronous_factory> -inline std::shared_ptr<logger> callback_logger_mt(const std::string &logger_name, - const custom_log_callback &callback) { - return Factory::template create<sinks::callback_sink_mt>(logger_name, callback); -} - -template <typename Factory = spdlog::synchronous_factory> -inline std::shared_ptr<logger> callback_logger_st(const std::string &logger_name, - const custom_log_callback &callback) { - return Factory::template create<sinks::callback_sink_st>(logger_name, callback); -} - -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/sinks/daily_file_sink.h b/thirdparty/spdlog/include/spdlog/sinks/daily_file_sink.h deleted file mode 100644 index 615c9f7be..000000000 --- a/thirdparty/spdlog/include/spdlog/sinks/daily_file_sink.h +++ /dev/null @@ -1,254 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#include <spdlog/common.h> -#include <spdlog/details/circular_q.h> -#include <spdlog/details/file_helper.h> -#include <spdlog/details/null_mutex.h> -#include <spdlog/details/os.h> -#include <spdlog/details/synchronous_factory.h> -#include <spdlog/fmt/chrono.h> -#include <spdlog/fmt/fmt.h> -#include <spdlog/sinks/base_sink.h> - -#include <chrono> -#include <cstdio> -#include <iomanip> -#include <mutex> -#include <sstream> -#include <string> - -namespace spdlog { -namespace sinks { - -/* - * Generator of daily log file names in format basename.YYYY-MM-DD.ext - */ -struct daily_filename_calculator { - // Create filename for the form basename.YYYY-MM-DD - static filename_t calc_filename(const filename_t &filename, const tm &now_tm) { - filename_t basename, ext; - std::tie(basename, ext) = details::file_helper::split_by_extension(filename); - return fmt_lib::format(SPDLOG_FMT_STRING(SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}{}")), - basename, now_tm.tm_year + 1900, now_tm.tm_mon + 1, now_tm.tm_mday, - ext); - } -}; - -/* - * Generator of daily log file names with strftime format. - * Usages: - * auto sink = - * std::make_shared<spdlog::sinks::daily_file_format_sink_mt>("myapp-%Y-%m-%d:%H:%M:%S.log", hour, - * minute);" auto logger = spdlog::daily_logger_format_mt("loggername, "myapp-%Y-%m-%d:%X.log", - * hour, minute)" - * - */ -struct daily_filename_format_calculator { - static filename_t calc_filename(const filename_t &file_path, const tm &now_tm) { -#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) - std::wstringstream stream; -#else - std::stringstream stream; -#endif - stream << std::put_time(&now_tm, file_path.c_str()); - return stream.str(); - } -}; - -/* - * Rotating file sink based on date. - * If truncate != false , the created file will be truncated. - * If max_files > 0, retain only the last max_files and delete previous. - * Note that old log files from previous executions will not be deleted by this class, - * rotation and deletion is only applied while the program is running. - */ -template <typename Mutex, typename FileNameCalc = daily_filename_calculator> -class daily_file_sink final : public base_sink<Mutex> { -public: - // create daily file sink which rotates on given time - daily_file_sink(filename_t base_filename, - int rotation_hour, - int rotation_minute, - bool truncate = false, - uint16_t max_files = 0, - const file_event_handlers &event_handlers = {}) - : base_filename_(std::move(base_filename)), - rotation_h_(rotation_hour), - rotation_m_(rotation_minute), - file_helper_{event_handlers}, - truncate_(truncate), - max_files_(max_files), - filenames_q_() { - if (rotation_hour < 0 || rotation_hour > 23 || rotation_minute < 0 || - rotation_minute > 59) { - throw_spdlog_ex("daily_file_sink: Invalid rotation time in ctor"); - } - - auto now = log_clock::now(); - auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now)); - file_helper_.open(filename, truncate_); - rotation_tp_ = next_rotation_tp_(); - - if (max_files_ > 0) { - init_filenames_q_(); - } - } - - filename_t filename() { - std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_); - return file_helper_.filename(); - } - -protected: - void sink_it_(const details::log_msg &msg) override { - auto time = msg.time; - bool should_rotate = time >= rotation_tp_; - if (should_rotate) { - auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(time)); - file_helper_.open(filename, truncate_); - rotation_tp_ = next_rotation_tp_(); - } - memory_buf_t formatted; - base_sink<Mutex>::formatter_->format(msg, formatted); - file_helper_.write(formatted); - - // Do the cleaning only at the end because it might throw on failure. - if (should_rotate && max_files_ > 0) { - delete_old_(); - } - } - - void flush_() override { file_helper_.flush(); } - -private: - void init_filenames_q_() { - using details::os::path_exists; - - filenames_q_ = details::circular_q<filename_t>(static_cast<size_t>(max_files_)); - std::vector<filename_t> filenames; - auto now = log_clock::now(); - while (filenames.size() < max_files_) { - auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now)); - if (!path_exists(filename)) { - break; - } - filenames.emplace_back(filename); - now -= std::chrono::hours(24); - } - for (auto iter = filenames.rbegin(); iter != filenames.rend(); ++iter) { - filenames_q_.push_back(std::move(*iter)); - } - } - - tm now_tm(log_clock::time_point tp) { - time_t tnow = log_clock::to_time_t(tp); - return spdlog::details::os::localtime(tnow); - } - - log_clock::time_point next_rotation_tp_() { - auto now = log_clock::now(); - tm date = now_tm(now); - date.tm_hour = rotation_h_; - date.tm_min = rotation_m_; - date.tm_sec = 0; - auto rotation_time = log_clock::from_time_t(std::mktime(&date)); - if (rotation_time > now) { - return rotation_time; - } - return {rotation_time + std::chrono::hours(24)}; - } - - // Delete the file N rotations ago. - // Throw spdlog_ex on failure to delete the old file. - void delete_old_() { - using details::os::filename_to_str; - using details::os::remove_if_exists; - - filename_t current_file = file_helper_.filename(); - if (filenames_q_.full()) { - auto old_filename = std::move(filenames_q_.front()); - filenames_q_.pop_front(); - bool ok = remove_if_exists(old_filename) == 0; - if (!ok) { - filenames_q_.push_back(std::move(current_file)); - throw_spdlog_ex("Failed removing daily file " + filename_to_str(old_filename), - errno); - } - } - filenames_q_.push_back(std::move(current_file)); - } - - filename_t base_filename_; - int rotation_h_; - int rotation_m_; - log_clock::time_point rotation_tp_; - details::file_helper file_helper_; - bool truncate_; - uint16_t max_files_; - details::circular_q<filename_t> filenames_q_; -}; - -using daily_file_sink_mt = daily_file_sink<std::mutex>; -using daily_file_sink_st = daily_file_sink<details::null_mutex>; -using daily_file_format_sink_mt = daily_file_sink<std::mutex, daily_filename_format_calculator>; -using daily_file_format_sink_st = - daily_file_sink<details::null_mutex, daily_filename_format_calculator>; - -} // namespace sinks - -// -// factory functions -// -template <typename Factory = spdlog::synchronous_factory> -inline std::shared_ptr<logger> daily_logger_mt(const std::string &logger_name, - const filename_t &filename, - int hour = 0, - int minute = 0, - bool truncate = false, - uint16_t max_files = 0, - const file_event_handlers &event_handlers = {}) { - return Factory::template create<sinks::daily_file_sink_mt>(logger_name, filename, hour, minute, - truncate, max_files, event_handlers); -} - -template <typename Factory = spdlog::synchronous_factory> -inline std::shared_ptr<logger> daily_logger_format_mt( - const std::string &logger_name, - const filename_t &filename, - int hour = 0, - int minute = 0, - bool truncate = false, - uint16_t max_files = 0, - const file_event_handlers &event_handlers = {}) { - return Factory::template create<sinks::daily_file_format_sink_mt>( - logger_name, filename, hour, minute, truncate, max_files, event_handlers); -} - -template <typename Factory = spdlog::synchronous_factory> -inline std::shared_ptr<logger> daily_logger_st(const std::string &logger_name, - const filename_t &filename, - int hour = 0, - int minute = 0, - bool truncate = false, - uint16_t max_files = 0, - const file_event_handlers &event_handlers = {}) { - return Factory::template create<sinks::daily_file_sink_st>(logger_name, filename, hour, minute, - truncate, max_files, event_handlers); -} - -template <typename Factory = spdlog::synchronous_factory> -inline std::shared_ptr<logger> daily_logger_format_st( - const std::string &logger_name, - const filename_t &filename, - int hour = 0, - int minute = 0, - bool truncate = false, - uint16_t max_files = 0, - const file_event_handlers &event_handlers = {}) { - return Factory::template create<sinks::daily_file_format_sink_st>( - logger_name, filename, hour, minute, truncate, max_files, event_handlers); -} -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/sinks/dist_sink.h b/thirdparty/spdlog/include/spdlog/sinks/dist_sink.h deleted file mode 100644 index 69c4971c9..000000000 --- a/thirdparty/spdlog/include/spdlog/sinks/dist_sink.h +++ /dev/null @@ -1,81 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#include "base_sink.h" -#include <spdlog/details/log_msg.h> -#include <spdlog/details/null_mutex.h> -#include <spdlog/pattern_formatter.h> - -#include <algorithm> -#include <memory> -#include <mutex> -#include <vector> - -// Distribution sink (mux). Stores a vector of sinks which get called when log -// is called - -namespace spdlog { -namespace sinks { - -template <typename Mutex> -class dist_sink : public base_sink<Mutex> { -public: - dist_sink() = default; - explicit dist_sink(std::vector<std::shared_ptr<sink>> sinks) - : sinks_(sinks) {} - - dist_sink(const dist_sink &) = delete; - dist_sink &operator=(const dist_sink &) = delete; - - void add_sink(std::shared_ptr<sink> sub_sink) { - std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_); - sinks_.push_back(sub_sink); - } - - void remove_sink(std::shared_ptr<sink> sub_sink) { - std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_); - sinks_.erase(std::remove(sinks_.begin(), sinks_.end(), sub_sink), sinks_.end()); - } - - void set_sinks(std::vector<std::shared_ptr<sink>> sinks) { - std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_); - sinks_ = std::move(sinks); - } - - std::vector<std::shared_ptr<sink>> &sinks() { return sinks_; } - -protected: - void sink_it_(const details::log_msg &msg) override { - for (auto &sub_sink : sinks_) { - if (sub_sink->should_log(msg.level)) { - sub_sink->log(msg); - } - } - } - - void flush_() override { - for (auto &sub_sink : sinks_) { - sub_sink->flush(); - } - } - - void set_pattern_(const std::string &pattern) override { - set_formatter_(details::make_unique<spdlog::pattern_formatter>(pattern)); - } - - void set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter) override { - base_sink<Mutex>::formatter_ = std::move(sink_formatter); - for (auto &sub_sink : sinks_) { - sub_sink->set_formatter(base_sink<Mutex>::formatter_->clone()); - } - } - std::vector<std::shared_ptr<sink>> sinks_; -}; - -using dist_sink_mt = dist_sink<std::mutex>; -using dist_sink_st = dist_sink<details::null_mutex>; - -} // namespace sinks -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/sinks/hourly_file_sink.h b/thirdparty/spdlog/include/spdlog/sinks/hourly_file_sink.h deleted file mode 100644 index 3e618725b..000000000 --- a/thirdparty/spdlog/include/spdlog/sinks/hourly_file_sink.h +++ /dev/null @@ -1,193 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#include <spdlog/common.h> -#include <spdlog/details/circular_q.h> -#include <spdlog/details/file_helper.h> -#include <spdlog/details/null_mutex.h> -#include <spdlog/details/os.h> -#include <spdlog/details/synchronous_factory.h> -#include <spdlog/fmt/fmt.h> -#include <spdlog/sinks/base_sink.h> - -#include <chrono> -#include <cstdio> -#include <ctime> -#include <mutex> -#include <string> - -namespace spdlog { -namespace sinks { - -/* - * Generator of Hourly log file names in format basename.YYYY-MM-DD-HH.ext - */ -struct hourly_filename_calculator { - // Create filename for the form basename.YYYY-MM-DD-H - static filename_t calc_filename(const filename_t &filename, const tm &now_tm) { - filename_t basename, ext; - std::tie(basename, ext) = details::file_helper::split_by_extension(filename); - return fmt_lib::format(SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}_{:02d}{}"), basename, - now_tm.tm_year + 1900, now_tm.tm_mon + 1, now_tm.tm_mday, - now_tm.tm_hour, ext); - } -}; - -/* - * Rotating file sink based on time. - * If truncate != false , the created file will be truncated. - * If max_files > 0, retain only the last max_files and delete previous. - * Note that old log files from previous executions will not be deleted by this class, - * rotation and deletion is only applied while the program is running. - */ -template <typename Mutex, typename FileNameCalc = hourly_filename_calculator> -class hourly_file_sink final : public base_sink<Mutex> { -public: - // create hourly file sink which rotates on given time - hourly_file_sink(filename_t base_filename, - bool truncate = false, - uint16_t max_files = 0, - const file_event_handlers &event_handlers = {}) - : base_filename_(std::move(base_filename)), - file_helper_{event_handlers}, - truncate_(truncate), - max_files_(max_files), - filenames_q_() { - auto now = log_clock::now(); - auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now)); - file_helper_.open(filename, truncate_); - remove_init_file_ = file_helper_.size() == 0; - rotation_tp_ = next_rotation_tp_(); - - if (max_files_ > 0) { - init_filenames_q_(); - } - } - - filename_t filename() { - std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_); - return file_helper_.filename(); - } - -protected: - void sink_it_(const details::log_msg &msg) override { - auto time = msg.time; - bool should_rotate = time >= rotation_tp_; - if (should_rotate) { - if (remove_init_file_) { - file_helper_.close(); - details::os::remove(file_helper_.filename()); - } - auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(time)); - file_helper_.open(filename, truncate_); - rotation_tp_ = next_rotation_tp_(); - } - remove_init_file_ = false; - memory_buf_t formatted; - base_sink<Mutex>::formatter_->format(msg, formatted); - file_helper_.write(formatted); - - // Do the cleaning only at the end because it might throw on failure. - if (should_rotate && max_files_ > 0) { - delete_old_(); - } - } - - void flush_() override { file_helper_.flush(); } - -private: - void init_filenames_q_() { - using details::os::path_exists; - - filenames_q_ = details::circular_q<filename_t>(static_cast<size_t>(max_files_)); - std::vector<filename_t> filenames; - auto now = log_clock::now(); - while (filenames.size() < max_files_) { - auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now)); - if (!path_exists(filename)) { - break; - } - filenames.emplace_back(filename); - now -= std::chrono::hours(1); - } - for (auto iter = filenames.rbegin(); iter != filenames.rend(); ++iter) { - filenames_q_.push_back(std::move(*iter)); - } - } - - tm now_tm(log_clock::time_point tp) { - time_t tnow = log_clock::to_time_t(tp); - return spdlog::details::os::localtime(tnow); - } - - log_clock::time_point next_rotation_tp_() { - auto now = log_clock::now(); - tm date = now_tm(now); - date.tm_min = 0; - date.tm_sec = 0; - auto rotation_time = log_clock::from_time_t(std::mktime(&date)); - if (rotation_time > now) { - return rotation_time; - } - return {rotation_time + std::chrono::hours(1)}; - } - - // Delete the file N rotations ago. - // Throw spdlog_ex on failure to delete the old file. - void delete_old_() { - using details::os::filename_to_str; - using details::os::remove_if_exists; - - filename_t current_file = file_helper_.filename(); - if (filenames_q_.full()) { - auto old_filename = std::move(filenames_q_.front()); - filenames_q_.pop_front(); - bool ok = remove_if_exists(old_filename) == 0; - if (!ok) { - filenames_q_.push_back(std::move(current_file)); - SPDLOG_THROW(spdlog_ex( - "Failed removing hourly file " + filename_to_str(old_filename), errno)); - } - } - filenames_q_.push_back(std::move(current_file)); - } - - filename_t base_filename_; - log_clock::time_point rotation_tp_; - details::file_helper file_helper_; - bool truncate_; - uint16_t max_files_; - details::circular_q<filename_t> filenames_q_; - bool remove_init_file_; -}; - -using hourly_file_sink_mt = hourly_file_sink<std::mutex>; -using hourly_file_sink_st = hourly_file_sink<details::null_mutex>; - -} // namespace sinks - -// -// factory functions -// -template <typename Factory = spdlog::synchronous_factory> -inline std::shared_ptr<logger> hourly_logger_mt(const std::string &logger_name, - const filename_t &filename, - bool truncate = false, - uint16_t max_files = 0, - const file_event_handlers &event_handlers = {}) { - return Factory::template create<sinks::hourly_file_sink_mt>(logger_name, filename, truncate, - max_files, event_handlers); -} - -template <typename Factory = spdlog::synchronous_factory> -inline std::shared_ptr<logger> hourly_logger_st(const std::string &logger_name, - const filename_t &filename, - bool truncate = false, - uint16_t max_files = 0, - const file_event_handlers &event_handlers = {}) { - return Factory::template create<sinks::hourly_file_sink_st>(logger_name, filename, truncate, - max_files, event_handlers); -} -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/sinks/msvc_sink.h b/thirdparty/spdlog/include/spdlog/sinks/msvc_sink.h deleted file mode 100644 index c28d6ebd7..000000000 --- a/thirdparty/spdlog/include/spdlog/sinks/msvc_sink.h +++ /dev/null @@ -1,68 +0,0 @@ -// Copyright(c) 2016 Alexander Dalshov & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#if defined(_WIN32) - - #include <spdlog/details/null_mutex.h> - #if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) - #include <spdlog/details/os.h> - #endif - #include <spdlog/sinks/base_sink.h> - - #include <mutex> - #include <string> - - // Avoid including windows.h (https://stackoverflow.com/a/30741042) - #if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) -extern "C" __declspec(dllimport) void __stdcall OutputDebugStringW(const wchar_t *lpOutputString); - #else -extern "C" __declspec(dllimport) void __stdcall OutputDebugStringA(const char *lpOutputString); - #endif -extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent(); - -namespace spdlog { -namespace sinks { -/* - * MSVC sink (logging using OutputDebugStringA) - */ -template <typename Mutex> -class msvc_sink : public base_sink<Mutex> { -public: - msvc_sink() = default; - msvc_sink(bool check_debugger_present) - : check_debugger_present_{check_debugger_present} {} - -protected: - void sink_it_(const details::log_msg &msg) override { - if (check_debugger_present_ && !IsDebuggerPresent()) { - return; - } - memory_buf_t formatted; - base_sink<Mutex>::formatter_->format(msg, formatted); - formatted.push_back('\0'); // add a null terminator for OutputDebugString - #if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) - wmemory_buf_t wformatted; - details::os::utf8_to_wstrbuf(string_view_t(formatted.data(), formatted.size()), wformatted); - OutputDebugStringW(wformatted.data()); - #else - OutputDebugStringA(formatted.data()); - #endif - } - - void flush_() override {} - - bool check_debugger_present_ = true; -}; - -using msvc_sink_mt = msvc_sink<std::mutex>; -using msvc_sink_st = msvc_sink<details::null_mutex>; - -using windebug_sink_mt = msvc_sink_mt; -using windebug_sink_st = msvc_sink_st; - -} // namespace sinks -} // namespace spdlog - -#endif diff --git a/thirdparty/spdlog/include/spdlog/sinks/null_sink.h b/thirdparty/spdlog/include/spdlog/sinks/null_sink.h deleted file mode 100644 index 74530b5b1..000000000 --- a/thirdparty/spdlog/include/spdlog/sinks/null_sink.h +++ /dev/null @@ -1,41 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#include <spdlog/details/null_mutex.h> -#include <spdlog/details/synchronous_factory.h> -#include <spdlog/sinks/base_sink.h> - -#include <mutex> - -namespace spdlog { -namespace sinks { - -template <typename Mutex> -class null_sink final : public base_sink<Mutex> { -protected: - void sink_it_(const details::log_msg &) override {} - void flush_() override {} -}; - -using null_sink_mt = null_sink<details::null_mutex>; -using null_sink_st = null_sink<details::null_mutex>; - -} // namespace sinks - -template <typename Factory = spdlog::synchronous_factory> -inline std::shared_ptr<logger> null_logger_mt(const std::string &logger_name) { - auto null_logger = Factory::template create<sinks::null_sink_mt>(logger_name); - null_logger->set_level(level::off); - return null_logger; -} - -template <typename Factory = spdlog::synchronous_factory> -inline std::shared_ptr<logger> null_logger_st(const std::string &logger_name) { - auto null_logger = Factory::template create<sinks::null_sink_st>(logger_name); - null_logger->set_level(level::off); - return null_logger; -} - -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/sinks/sink-inl.h b/thirdparty/spdlog/include/spdlog/sinks/sink-inl.h deleted file mode 100644 index e4b271404..000000000 --- a/thirdparty/spdlog/include/spdlog/sinks/sink-inl.h +++ /dev/null @@ -1,22 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#ifndef SPDLOG_HEADER_ONLY - #include <spdlog/sinks/sink.h> -#endif - -#include <spdlog/common.h> - -SPDLOG_INLINE bool spdlog::sinks::sink::should_log(spdlog::level::level_enum msg_level) const { - return msg_level >= level_.load(std::memory_order_relaxed); -} - -SPDLOG_INLINE void spdlog::sinks::sink::set_level(level::level_enum log_level) { - level_.store(log_level, std::memory_order_relaxed); -} - -SPDLOG_INLINE spdlog::level::level_enum spdlog::sinks::sink::level() const { - return static_cast<spdlog::level::level_enum>(level_.load(std::memory_order_relaxed)); -} diff --git a/thirdparty/spdlog/include/spdlog/sinks/sink.h b/thirdparty/spdlog/include/spdlog/sinks/sink.h deleted file mode 100644 index 585068536..000000000 --- a/thirdparty/spdlog/include/spdlog/sinks/sink.h +++ /dev/null @@ -1,34 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#include <spdlog/details/log_msg.h> -#include <spdlog/formatter.h> - -namespace spdlog { - -namespace sinks { -class SPDLOG_API sink { -public: - virtual ~sink() = default; - virtual void log(const details::log_msg &msg) = 0; - virtual void flush() = 0; - virtual void set_pattern(const std::string &pattern) = 0; - virtual void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) = 0; - - void set_level(level::level_enum log_level); - level::level_enum level() const; - bool should_log(level::level_enum msg_level) const; - -protected: - // sink log level - default is all - level_t level_{level::trace}; -}; - -} // namespace sinks -} // namespace spdlog - -#ifdef SPDLOG_HEADER_ONLY - #include "sink-inl.h" -#endif diff --git a/thirdparty/spdlog/include/spdlog/sinks/stdout_color_sinks-inl.h b/thirdparty/spdlog/include/spdlog/sinks/stdout_color_sinks-inl.h deleted file mode 100644 index 166e38614..000000000 --- a/thirdparty/spdlog/include/spdlog/sinks/stdout_color_sinks-inl.h +++ /dev/null @@ -1,38 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#ifndef SPDLOG_HEADER_ONLY - #include <spdlog/sinks/stdout_color_sinks.h> -#endif - -#include <spdlog/common.h> -#include <spdlog/logger.h> - -namespace spdlog { - -template <typename Factory> -SPDLOG_INLINE std::shared_ptr<logger> stdout_color_mt(const std::string &logger_name, - color_mode mode) { - return Factory::template create<sinks::stdout_color_sink_mt>(logger_name, mode); -} - -template <typename Factory> -SPDLOG_INLINE std::shared_ptr<logger> stdout_color_st(const std::string &logger_name, - color_mode mode) { - return Factory::template create<sinks::stdout_color_sink_st>(logger_name, mode); -} - -template <typename Factory> -SPDLOG_INLINE std::shared_ptr<logger> stderr_color_mt(const std::string &logger_name, - color_mode mode) { - return Factory::template create<sinks::stderr_color_sink_mt>(logger_name, mode); -} - -template <typename Factory> -SPDLOG_INLINE std::shared_ptr<logger> stderr_color_st(const std::string &logger_name, - color_mode mode) { - return Factory::template create<sinks::stderr_color_sink_st>(logger_name, mode); -} -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/sinks/stdout_color_sinks.h b/thirdparty/spdlog/include/spdlog/sinks/stdout_color_sinks.h deleted file mode 100644 index 72991fe0e..000000000 --- a/thirdparty/spdlog/include/spdlog/sinks/stdout_color_sinks.h +++ /dev/null @@ -1,49 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#ifdef _WIN32 - #include <spdlog/sinks/wincolor_sink.h> -#else - #include <spdlog/sinks/ansicolor_sink.h> -#endif - -#include <spdlog/details/synchronous_factory.h> - -namespace spdlog { -namespace sinks { -#ifdef _WIN32 -using stdout_color_sink_mt = wincolor_stdout_sink_mt; -using stdout_color_sink_st = wincolor_stdout_sink_st; -using stderr_color_sink_mt = wincolor_stderr_sink_mt; -using stderr_color_sink_st = wincolor_stderr_sink_st; -#else -using stdout_color_sink_mt = ansicolor_stdout_sink_mt; -using stdout_color_sink_st = ansicolor_stdout_sink_st; -using stderr_color_sink_mt = ansicolor_stderr_sink_mt; -using stderr_color_sink_st = ansicolor_stderr_sink_st; -#endif -} // namespace sinks - -template <typename Factory = spdlog::synchronous_factory> -std::shared_ptr<logger> stdout_color_mt(const std::string &logger_name, - color_mode mode = color_mode::automatic); - -template <typename Factory = spdlog::synchronous_factory> -std::shared_ptr<logger> stdout_color_st(const std::string &logger_name, - color_mode mode = color_mode::automatic); - -template <typename Factory = spdlog::synchronous_factory> -std::shared_ptr<logger> stderr_color_mt(const std::string &logger_name, - color_mode mode = color_mode::automatic); - -template <typename Factory = spdlog::synchronous_factory> -std::shared_ptr<logger> stderr_color_st(const std::string &logger_name, - color_mode mode = color_mode::automatic); - -} // namespace spdlog - -#ifdef SPDLOG_HEADER_ONLY - #include "stdout_color_sinks-inl.h" -#endif diff --git a/thirdparty/spdlog/include/spdlog/sinks/stdout_sinks-inl.h b/thirdparty/spdlog/include/spdlog/sinks/stdout_sinks-inl.h deleted file mode 100644 index dcb21d84a..000000000 --- a/thirdparty/spdlog/include/spdlog/sinks/stdout_sinks-inl.h +++ /dev/null @@ -1,127 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#ifndef SPDLOG_HEADER_ONLY - #include <spdlog/sinks/stdout_sinks.h> -#endif - -#include <memory> -#include <spdlog/details/console_globals.h> -#include <spdlog/pattern_formatter.h> -#include <spdlog/details/os.h> - -#ifdef _WIN32 - // under windows using fwrite to non-binary stream results in \r\r\n (see issue #1675) - // so instead we use ::FileWrite - #include <spdlog/details/windows_include.h> - - #ifndef _USING_V110_SDK71_ // fileapi.h doesn't exist in winxp - #include <fileapi.h> // WriteFile (..) - #endif - - #include <io.h> // _get_osfhandle(..) - #include <stdio.h> // _fileno(..) -#endif // _WIN32 - -namespace spdlog { - -namespace sinks { - -template <typename ConsoleMutex> -SPDLOG_INLINE stdout_sink_base<ConsoleMutex>::stdout_sink_base(FILE *file) - : mutex_(ConsoleMutex::mutex()), - file_(file), - formatter_(details::make_unique<spdlog::pattern_formatter>()) { -#ifdef _WIN32 - // get windows handle from the FILE* object - - handle_ = reinterpret_cast<HANDLE>(::_get_osfhandle(::_fileno(file_))); - - // don't throw to support cases where no console is attached, - // and let the log method to do nothing if (handle_ == INVALID_HANDLE_VALUE). - // throw only if non stdout/stderr target is requested (probably regular file and not console). - if (handle_ == INVALID_HANDLE_VALUE && file != stdout && file != stderr) { - throw_spdlog_ex("spdlog::stdout_sink_base: _get_osfhandle() failed", errno); - } -#endif // _WIN32 -} - -template <typename ConsoleMutex> -SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::log(const details::log_msg &msg) { -#ifdef _WIN32 - if (handle_ == INVALID_HANDLE_VALUE) { - return; - } - std::lock_guard<mutex_t> lock(mutex_); - memory_buf_t formatted; - formatter_->format(msg, formatted); - auto size = static_cast<DWORD>(formatted.size()); - DWORD bytes_written = 0; - bool ok = ::WriteFile(handle_, formatted.data(), size, &bytes_written, nullptr) != 0; - if (!ok) { - throw_spdlog_ex("stdout_sink_base: WriteFile() failed. GetLastError(): " + - std::to_string(::GetLastError())); - } -#else - std::lock_guard<mutex_t> lock(mutex_); - memory_buf_t formatted; - formatter_->format(msg, formatted); - details::os::fwrite_bytes(formatted.data(), formatted.size(), file_); -#endif // _WIN32 - ::fflush(file_); // flush every line to terminal -} - -template <typename ConsoleMutex> -SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::flush() { - std::lock_guard<mutex_t> lock(mutex_); - fflush(file_); -} - -template <typename ConsoleMutex> -SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::set_pattern(const std::string &pattern) { - std::lock_guard<mutex_t> lock(mutex_); - formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern)); -} - -template <typename ConsoleMutex> -SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::set_formatter( - std::unique_ptr<spdlog::formatter> sink_formatter) { - std::lock_guard<mutex_t> lock(mutex_); - formatter_ = std::move(sink_formatter); -} - -// stdout sink -template <typename ConsoleMutex> -SPDLOG_INLINE stdout_sink<ConsoleMutex>::stdout_sink() - : stdout_sink_base<ConsoleMutex>(stdout) {} - -// stderr sink -template <typename ConsoleMutex> -SPDLOG_INLINE stderr_sink<ConsoleMutex>::stderr_sink() - : stdout_sink_base<ConsoleMutex>(stderr) {} - -} // namespace sinks - -// factory methods -template <typename Factory> -SPDLOG_INLINE std::shared_ptr<logger> stdout_logger_mt(const std::string &logger_name) { - return Factory::template create<sinks::stdout_sink_mt>(logger_name); -} - -template <typename Factory> -SPDLOG_INLINE std::shared_ptr<logger> stdout_logger_st(const std::string &logger_name) { - return Factory::template create<sinks::stdout_sink_st>(logger_name); -} - -template <typename Factory> -SPDLOG_INLINE std::shared_ptr<logger> stderr_logger_mt(const std::string &logger_name) { - return Factory::template create<sinks::stderr_sink_mt>(logger_name); -} - -template <typename Factory> -SPDLOG_INLINE std::shared_ptr<logger> stderr_logger_st(const std::string &logger_name) { - return Factory::template create<sinks::stderr_sink_st>(logger_name); -} -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/sinks/stdout_sinks.h b/thirdparty/spdlog/include/spdlog/sinks/stdout_sinks.h deleted file mode 100644 index 6ef09968a..000000000 --- a/thirdparty/spdlog/include/spdlog/sinks/stdout_sinks.h +++ /dev/null @@ -1,84 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#include <cstdio> -#include <spdlog/details/console_globals.h> -#include <spdlog/details/synchronous_factory.h> -#include <spdlog/sinks/sink.h> - -#ifdef _WIN32 - #include <spdlog/details/windows_include.h> -#endif - -namespace spdlog { - -namespace sinks { - -template <typename ConsoleMutex> -class stdout_sink_base : public sink { -public: - using mutex_t = typename ConsoleMutex::mutex_t; - explicit stdout_sink_base(FILE *file); - ~stdout_sink_base() override = default; - - stdout_sink_base(const stdout_sink_base &other) = delete; - stdout_sink_base(stdout_sink_base &&other) = delete; - - stdout_sink_base &operator=(const stdout_sink_base &other) = delete; - stdout_sink_base &operator=(stdout_sink_base &&other) = delete; - - void log(const details::log_msg &msg) override; - void flush() override; - void set_pattern(const std::string &pattern) override; - - void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override; - -protected: - mutex_t &mutex_; - FILE *file_; - std::unique_ptr<spdlog::formatter> formatter_; -#ifdef _WIN32 - HANDLE handle_; -#endif // WIN32 -}; - -template <typename ConsoleMutex> -class stdout_sink : public stdout_sink_base<ConsoleMutex> { -public: - stdout_sink(); -}; - -template <typename ConsoleMutex> -class stderr_sink : public stdout_sink_base<ConsoleMutex> { -public: - stderr_sink(); -}; - -using stdout_sink_mt = stdout_sink<details::console_mutex>; -using stdout_sink_st = stdout_sink<details::console_nullmutex>; - -using stderr_sink_mt = stderr_sink<details::console_mutex>; -using stderr_sink_st = stderr_sink<details::console_nullmutex>; - -} // namespace sinks - -// factory methods -template <typename Factory = spdlog::synchronous_factory> -std::shared_ptr<logger> stdout_logger_mt(const std::string &logger_name); - -template <typename Factory = spdlog::synchronous_factory> -std::shared_ptr<logger> stdout_logger_st(const std::string &logger_name); - -template <typename Factory = spdlog::synchronous_factory> -std::shared_ptr<logger> stderr_logger_mt(const std::string &logger_name); - -template <typename Factory = spdlog::synchronous_factory> -std::shared_ptr<logger> stderr_logger_st(const std::string &logger_name); - -} // namespace spdlog - -#ifdef SPDLOG_HEADER_ONLY - #include "stdout_sinks-inl.h" -#endif diff --git a/thirdparty/spdlog/include/spdlog/sinks/syslog_sink.h b/thirdparty/spdlog/include/spdlog/sinks/syslog_sink.h deleted file mode 100644 index 913d41be6..000000000 --- a/thirdparty/spdlog/include/spdlog/sinks/syslog_sink.h +++ /dev/null @@ -1,104 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#include <spdlog/details/null_mutex.h> -#include <spdlog/details/synchronous_factory.h> -#include <spdlog/sinks/base_sink.h> - -#include <array> -#include <string> -#include <syslog.h> - -namespace spdlog { -namespace sinks { -/** - * Sink that write to syslog using the `syscall()` library call. - */ -template <typename Mutex> -class syslog_sink : public base_sink<Mutex> { -public: - syslog_sink(std::string ident, int syslog_option, int syslog_facility, bool enable_formatting) - : enable_formatting_{enable_formatting}, - syslog_levels_{{/* spdlog::level::trace */ LOG_DEBUG, - /* spdlog::level::debug */ LOG_DEBUG, - /* spdlog::level::info */ LOG_INFO, - /* spdlog::level::warn */ LOG_WARNING, - /* spdlog::level::err */ LOG_ERR, - /* spdlog::level::critical */ LOG_CRIT, - /* spdlog::level::off */ LOG_INFO}}, - ident_{std::move(ident)} { - // set ident to be program name if empty - ::openlog(ident_.empty() ? nullptr : ident_.c_str(), syslog_option, syslog_facility); - } - - ~syslog_sink() override { ::closelog(); } - - syslog_sink(const syslog_sink &) = delete; - syslog_sink &operator=(const syslog_sink &) = delete; - -protected: - void sink_it_(const details::log_msg &msg) override { - string_view_t payload; - memory_buf_t formatted; - if (enable_formatting_) { - base_sink<Mutex>::formatter_->format(msg, formatted); - payload = string_view_t(formatted.data(), formatted.size()); - } else { - payload = msg.payload; - } - - size_t length = payload.size(); - // limit to max int - if (length > static_cast<size_t>(std::numeric_limits<int>::max())) { - length = static_cast<size_t>(std::numeric_limits<int>::max()); - } - - ::syslog(syslog_prio_from_level(msg), "%.*s", static_cast<int>(length), payload.data()); - } - - void flush_() override {} - bool enable_formatting_ = false; - - // - // Simply maps spdlog's log level to syslog priority level. - // - virtual int syslog_prio_from_level(const details::log_msg &msg) const { - return syslog_levels_.at(static_cast<levels_array::size_type>(msg.level)); - } - - using levels_array = std::array<int, 7>; - levels_array syslog_levels_; - -private: - // must store the ident because the man says openlog might use the pointer as - // is and not a string copy - const std::string ident_; -}; - -using syslog_sink_mt = syslog_sink<std::mutex>; -using syslog_sink_st = syslog_sink<details::null_mutex>; -} // namespace sinks - -// Create and register a syslog logger -template <typename Factory = spdlog::synchronous_factory> -inline std::shared_ptr<logger> syslog_logger_mt(const std::string &logger_name, - const std::string &syslog_ident = "", - int syslog_option = 0, - int syslog_facility = LOG_USER, - bool enable_formatting = false) { - return Factory::template create<sinks::syslog_sink_mt>(logger_name, syslog_ident, syslog_option, - syslog_facility, enable_formatting); -} - -template <typename Factory = spdlog::synchronous_factory> -inline std::shared_ptr<logger> syslog_logger_st(const std::string &logger_name, - const std::string &syslog_ident = "", - int syslog_option = 0, - int syslog_facility = LOG_USER, - bool enable_formatting = false) { - return Factory::template create<sinks::syslog_sink_st>(logger_name, syslog_ident, syslog_option, - syslog_facility, enable_formatting); -} -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/sinks/systemd_sink.h b/thirdparty/spdlog/include/spdlog/sinks/systemd_sink.h deleted file mode 100644 index d2cd55f2e..000000000 --- a/thirdparty/spdlog/include/spdlog/sinks/systemd_sink.h +++ /dev/null @@ -1,121 +0,0 @@ -// Copyright(c) 2019 [email protected] -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#include <spdlog/details/null_mutex.h> -#include <spdlog/details/os.h> -#include <spdlog/details/synchronous_factory.h> -#include <spdlog/sinks/base_sink.h> - -#include <array> -#ifndef SD_JOURNAL_SUPPRESS_LOCATION - #define SD_JOURNAL_SUPPRESS_LOCATION -#endif -#include <systemd/sd-journal.h> - -namespace spdlog { -namespace sinks { - -/** - * Sink that write to systemd journal using the `sd_journal_send()` library call. - */ -template <typename Mutex> -class systemd_sink : public base_sink<Mutex> { -public: - systemd_sink(std::string ident = "", bool enable_formatting = false) - : ident_{std::move(ident)}, - enable_formatting_{enable_formatting}, - syslog_levels_{{/* spdlog::level::trace */ LOG_DEBUG, - /* spdlog::level::debug */ LOG_DEBUG, - /* spdlog::level::info */ LOG_INFO, - /* spdlog::level::warn */ LOG_WARNING, - /* spdlog::level::err */ LOG_ERR, - /* spdlog::level::critical */ LOG_CRIT, - /* spdlog::level::off */ LOG_INFO}} {} - - ~systemd_sink() override {} - - systemd_sink(const systemd_sink &) = delete; - systemd_sink &operator=(const systemd_sink &) = delete; - -protected: - const std::string ident_; - bool enable_formatting_ = false; - using levels_array = std::array<int, 7>; - levels_array syslog_levels_; - - void sink_it_(const details::log_msg &msg) override { - int err; - string_view_t payload; - memory_buf_t formatted; - if (enable_formatting_) { - base_sink<Mutex>::formatter_->format(msg, formatted); - payload = string_view_t(formatted.data(), formatted.size()); - } else { - payload = msg.payload; - } - - size_t length = payload.size(); - // limit to max int - if (length > static_cast<size_t>(std::numeric_limits<int>::max())) { - length = static_cast<size_t>(std::numeric_limits<int>::max()); - } - - const string_view_t syslog_identifier = ident_.empty() ? msg.logger_name : ident_; - - // Do not send source location if not available - if (msg.source.empty()) { - // Note: function call inside '()' to avoid macro expansion - err = (sd_journal_send)("MESSAGE=%.*s", static_cast<int>(length), payload.data(), - "PRIORITY=%d", syslog_level(msg.level), -#ifndef SPDLOG_NO_THREAD_ID - "TID=%zu", msg.thread_id, -#endif - "SYSLOG_IDENTIFIER=%.*s", - static_cast<int>(syslog_identifier.size()), - syslog_identifier.data(), nullptr); - } else { - err = (sd_journal_send)("MESSAGE=%.*s", static_cast<int>(length), payload.data(), - "PRIORITY=%d", syslog_level(msg.level), -#ifndef SPDLOG_NO_THREAD_ID - "TID=%zu", msg.thread_id, -#endif - "SYSLOG_IDENTIFIER=%.*s", - static_cast<int>(syslog_identifier.size()), - syslog_identifier.data(), "CODE_FILE=%s", msg.source.filename, - "CODE_LINE=%d", msg.source.line, "CODE_FUNC=%s", - msg.source.funcname, nullptr); - } - - if (err) { - throw_spdlog_ex("Failed writing to systemd", errno); - } - } - - int syslog_level(level::level_enum l) { - return syslog_levels_.at(static_cast<levels_array::size_type>(l)); - } - - void flush_() override {} -}; - -using systemd_sink_mt = systemd_sink<std::mutex>; -using systemd_sink_st = systemd_sink<details::null_mutex>; -} // namespace sinks - -// Create and register a syslog logger -template <typename Factory = spdlog::synchronous_factory> -inline std::shared_ptr<logger> systemd_logger_mt(const std::string &logger_name, - const std::string &ident = "", - bool enable_formatting = false) { - return Factory::template create<sinks::systemd_sink_mt>(logger_name, ident, enable_formatting); -} - -template <typename Factory = spdlog::synchronous_factory> -inline std::shared_ptr<logger> systemd_logger_st(const std::string &logger_name, - const std::string &ident = "", - bool enable_formatting = false) { - return Factory::template create<sinks::systemd_sink_st>(logger_name, ident, enable_formatting); -} -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/sinks/win_eventlog_sink.h b/thirdparty/spdlog/include/spdlog/sinks/win_eventlog_sink.h deleted file mode 100644 index 2c9b582d3..000000000 --- a/thirdparty/spdlog/include/spdlog/sinks/win_eventlog_sink.h +++ /dev/null @@ -1,260 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -// Writing to Windows Event Log requires the registry entries below to be present, with the -// following modifications: -// 1. <log_name> should be replaced with your log name (e.g. your application name) -// 2. <source_name> should be replaced with the specific source name and the key should be -// duplicated for -// each source used in the application -// -// Since typically modifications of this kind require elevation, it's better to do it as a part of -// setup procedure. The snippet below uses mscoree.dll as the message file as it exists on most of -// the Windows systems anyway and happens to contain the needed resource. -// -// You can also specify a custom message file if needed. -// Please refer to Event Log functions descriptions in MSDN for more details on custom message -// files. - -/*--------------------------------------------------------------------------------------- - -Windows Registry Editor Version 5.00 - -[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\EventLog\<log_name>] - -[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\EventLog\<log_name>\<source_name>] -"TypesSupported"=dword:00000007 -"EventMessageFile"=hex(2):25,00,73,00,79,00,73,00,74,00,65,00,6d,00,72,00,6f,\ - 00,6f,00,74,00,25,00,5c,00,53,00,79,00,73,00,74,00,65,00,6d,00,33,00,32,00,\ - 5c,00,6d,00,73,00,63,00,6f,00,72,00,65,00,65,00,2e,00,64,00,6c,00,6c,00,00,\ - 00 - ------------------------------------------------------------------------------------------*/ - -#pragma once - -#include <spdlog/details/null_mutex.h> -#include <spdlog/sinks/base_sink.h> - -#include <spdlog/details/windows_include.h> -#include <winbase.h> - -#include <mutex> -#include <string> -#include <vector> - -namespace spdlog { -namespace sinks { - -namespace win_eventlog { - -namespace internal { - -struct local_alloc_t { - HLOCAL hlocal_; - - SPDLOG_CONSTEXPR local_alloc_t() SPDLOG_NOEXCEPT : hlocal_(nullptr) {} - - local_alloc_t(local_alloc_t const &) = delete; - local_alloc_t &operator=(local_alloc_t const &) = delete; - - ~local_alloc_t() SPDLOG_NOEXCEPT { - if (hlocal_) { - LocalFree(hlocal_); - } - } -}; - -/** Windows error */ -struct win32_error : public spdlog_ex { - /** Formats an error report line: "user-message: error-code (system message)" */ - static std::string format(std::string const &user_message, DWORD error_code = GetLastError()) { - std::string system_message; - - local_alloc_t format_message_result{}; - auto format_message_succeeded = - ::FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | - FORMAT_MESSAGE_IGNORE_INSERTS, - nullptr, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), - (LPSTR)&format_message_result.hlocal_, 0, nullptr); - - if (format_message_succeeded && format_message_result.hlocal_) { - system_message = fmt_lib::format(" ({})", (LPSTR)format_message_result.hlocal_); - } - - return fmt_lib::format("{}: {}{}", user_message, error_code, system_message); - } - - explicit win32_error(std::string const &func_name, DWORD error = GetLastError()) - : spdlog_ex(format(func_name, error)) {} -}; - -/** Wrapper for security identifiers (SID) on Windows */ -struct sid_t { - std::vector<char> buffer_; - -public: - sid_t() {} - - /** creates a wrapped SID copy */ - static sid_t duplicate_sid(PSID psid) { - if (!::IsValidSid(psid)) { - throw_spdlog_ex("sid_t::sid_t(): invalid SID received"); - } - - auto const sid_length{::GetLengthSid(psid)}; - - sid_t result; - result.buffer_.resize(sid_length); - if (!::CopySid(sid_length, (PSID)result.as_sid(), psid)) { - SPDLOG_THROW(win32_error("CopySid")); - } - - return result; - } - - /** Retrieves pointer to the internal buffer contents as SID* */ - SID *as_sid() const { return buffer_.empty() ? nullptr : (SID *)buffer_.data(); } - - /** Get SID for the current user */ - static sid_t get_current_user_sid() { - /* create and init RAII holder for process token */ - struct process_token_t { - HANDLE token_handle_ = INVALID_HANDLE_VALUE; - explicit process_token_t(HANDLE process) { - if (!::OpenProcessToken(process, TOKEN_QUERY, &token_handle_)) { - SPDLOG_THROW(win32_error("OpenProcessToken")); - } - } - - ~process_token_t() { ::CloseHandle(token_handle_); } - - } current_process_token( - ::GetCurrentProcess()); // GetCurrentProcess returns pseudohandle, no leak here! - - // Get the required size, this is expected to fail with ERROR_INSUFFICIENT_BUFFER and return - // the token size - DWORD tusize = 0; - if (::GetTokenInformation(current_process_token.token_handle_, TokenUser, NULL, 0, - &tusize)) { - SPDLOG_THROW(win32_error("GetTokenInformation should fail")); - } - - // get user token - std::vector<unsigned char> buffer(static_cast<size_t>(tusize)); - if (!::GetTokenInformation(current_process_token.token_handle_, TokenUser, - (LPVOID)buffer.data(), tusize, &tusize)) { - SPDLOG_THROW(win32_error("GetTokenInformation")); - } - - // create a wrapper of the SID data as stored in the user token - return sid_t::duplicate_sid(((TOKEN_USER *)buffer.data())->User.Sid); - } -}; - -struct eventlog { - static WORD get_event_type(details::log_msg const &msg) { - switch (msg.level) { - case level::trace: - case level::debug: - return EVENTLOG_SUCCESS; - - case level::info: - return EVENTLOG_INFORMATION_TYPE; - - case level::warn: - return EVENTLOG_WARNING_TYPE; - - case level::err: - case level::critical: - case level::off: - return EVENTLOG_ERROR_TYPE; - - default: - return EVENTLOG_INFORMATION_TYPE; - } - } - - static WORD get_event_category(details::log_msg const &msg) { return (WORD)msg.level; } -}; - -} // namespace internal - -/* - * Windows Event Log sink - */ -template <typename Mutex> -class win_eventlog_sink : public base_sink<Mutex> { -private: - HANDLE hEventLog_{NULL}; - internal::sid_t current_user_sid_; - std::string source_; - DWORD event_id_; - - HANDLE event_log_handle() { - if (!hEventLog_) { - hEventLog_ = ::RegisterEventSourceA(nullptr, source_.c_str()); - if (!hEventLog_ || hEventLog_ == (HANDLE)ERROR_ACCESS_DENIED) { - SPDLOG_THROW(internal::win32_error("RegisterEventSource")); - } - } - - return hEventLog_; - } - -protected: - void sink_it_(const details::log_msg &msg) override { - using namespace internal; - - bool succeeded; - memory_buf_t formatted; - base_sink<Mutex>::formatter_->format(msg, formatted); - formatted.push_back('\0'); - -#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT - wmemory_buf_t buf; - details::os::utf8_to_wstrbuf(string_view_t(formatted.data(), formatted.size()), buf); - - LPCWSTR lp_wstr = buf.data(); - succeeded = static_cast<bool>(::ReportEventW( - event_log_handle(), eventlog::get_event_type(msg), eventlog::get_event_category(msg), - event_id_, current_user_sid_.as_sid(), 1, 0, &lp_wstr, nullptr)); -#else - LPCSTR lp_str = formatted.data(); - succeeded = static_cast<bool>(::ReportEventA( - event_log_handle(), eventlog::get_event_type(msg), eventlog::get_event_category(msg), - event_id_, current_user_sid_.as_sid(), 1, 0, &lp_str, nullptr)); -#endif - - if (!succeeded) { - SPDLOG_THROW(win32_error("ReportEvent")); - } - } - - void flush_() override {} - -public: - win_eventlog_sink(std::string const &source, - DWORD event_id = 1000 /* according to mscoree.dll */) - : source_(source), - event_id_(event_id) { - try { - current_user_sid_ = internal::sid_t::get_current_user_sid(); - } catch (...) { - // get_current_user_sid() is unlikely to fail and if it does, we can still proceed - // without current_user_sid but in the event log the record will have no user name - } - } - - ~win_eventlog_sink() { - if (hEventLog_) DeregisterEventSource(hEventLog_); - } -}; - -} // namespace win_eventlog - -using win_eventlog_sink_mt = win_eventlog::win_eventlog_sink<std::mutex>; -using win_eventlog_sink_st = win_eventlog::win_eventlog_sink<details::null_mutex>; - -} // namespace sinks -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/sinks/wincolor_sink-inl.h b/thirdparty/spdlog/include/spdlog/sinks/wincolor_sink-inl.h deleted file mode 100644 index a9c0fa25c..000000000 --- a/thirdparty/spdlog/include/spdlog/sinks/wincolor_sink-inl.h +++ /dev/null @@ -1,172 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#ifndef SPDLOG_HEADER_ONLY - #include <spdlog/sinks/wincolor_sink.h> -#endif - -#include <spdlog/details/windows_include.h> -#include <wincon.h> - -#include <spdlog/common.h> -#include <spdlog/pattern_formatter.h> - -namespace spdlog { -namespace sinks { -template <typename ConsoleMutex> -SPDLOG_INLINE wincolor_sink<ConsoleMutex>::wincolor_sink(void *out_handle, color_mode mode) - : out_handle_(out_handle), - mutex_(ConsoleMutex::mutex()), - formatter_(details::make_unique<spdlog::pattern_formatter>()) { - set_color_mode_impl(mode); - // set level colors - colors_[level::trace] = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; // white - colors_[level::debug] = FOREGROUND_GREEN | FOREGROUND_BLUE; // cyan - colors_[level::info] = FOREGROUND_GREEN; // green - colors_[level::warn] = - FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY; // intense yellow - colors_[level::err] = FOREGROUND_RED | FOREGROUND_INTENSITY; // intense red - colors_[level::critical] = BACKGROUND_RED | FOREGROUND_RED | FOREGROUND_GREEN | - FOREGROUND_BLUE | - FOREGROUND_INTENSITY; // intense white on red background - colors_[level::off] = 0; -} - -template <typename ConsoleMutex> -SPDLOG_INLINE wincolor_sink<ConsoleMutex>::~wincolor_sink() { - this->flush(); -} - -// change the color for the given level -template <typename ConsoleMutex> -void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_color(level::level_enum level, - std::uint16_t color) { - std::lock_guard<mutex_t> lock(mutex_); - colors_[static_cast<size_t>(level)] = color; -} - -template <typename ConsoleMutex> -void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::log(const details::log_msg &msg) { - if (out_handle_ == nullptr || out_handle_ == INVALID_HANDLE_VALUE) { - return; - } - - std::lock_guard<mutex_t> lock(mutex_); - msg.color_range_start = 0; - msg.color_range_end = 0; - memory_buf_t formatted; - formatter_->format(msg, formatted); - if (should_do_colors_ && msg.color_range_end > msg.color_range_start) { - // before color range - print_range_(formatted, 0, msg.color_range_start); - // in color range - auto orig_attribs = - static_cast<WORD>(set_foreground_color_(colors_[static_cast<size_t>(msg.level)])); - print_range_(formatted, msg.color_range_start, msg.color_range_end); - // reset to orig colors - ::SetConsoleTextAttribute(static_cast<HANDLE>(out_handle_), orig_attribs); - print_range_(formatted, msg.color_range_end, formatted.size()); - } else // print without colors if color range is invalid (or color is disabled) - { - write_to_file_(formatted); - } -} - -template <typename ConsoleMutex> -void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::flush() { - // windows console always flushed? -} - -template <typename ConsoleMutex> -void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_pattern(const std::string &pattern) { - std::lock_guard<mutex_t> lock(mutex_); - formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern)); -} - -template <typename ConsoleMutex> -void SPDLOG_INLINE -wincolor_sink<ConsoleMutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) { - std::lock_guard<mutex_t> lock(mutex_); - formatter_ = std::move(sink_formatter); -} - -template <typename ConsoleMutex> -void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_color_mode(color_mode mode) { - std::lock_guard<mutex_t> lock(mutex_); - set_color_mode_impl(mode); -} - -template <typename ConsoleMutex> -void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_color_mode_impl(color_mode mode) { - if (mode == color_mode::automatic) { - // should do colors only if out_handle_ points to actual console. - DWORD console_mode; - bool in_console = ::GetConsoleMode(static_cast<HANDLE>(out_handle_), &console_mode) != 0; - should_do_colors_ = in_console; - } else { - should_do_colors_ = mode == color_mode::always ? true : false; - } -} - -// set foreground color and return the orig console attributes (for resetting later) -template <typename ConsoleMutex> -std::uint16_t SPDLOG_INLINE -wincolor_sink<ConsoleMutex>::set_foreground_color_(std::uint16_t attribs) { - CONSOLE_SCREEN_BUFFER_INFO orig_buffer_info; - if (!::GetConsoleScreenBufferInfo(static_cast<HANDLE>(out_handle_), &orig_buffer_info)) { - // just return white if failed getting console info - return FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; - } - - // change only the foreground bits (lowest 4 bits) - auto new_attribs = static_cast<WORD>(attribs) | (orig_buffer_info.wAttributes & 0xfff0); - auto ignored = - ::SetConsoleTextAttribute(static_cast<HANDLE>(out_handle_), static_cast<WORD>(new_attribs)); - (void)(ignored); - return static_cast<std::uint16_t>(orig_buffer_info.wAttributes); // return orig attribs -} - -// print a range of formatted message to console -template <typename ConsoleMutex> -void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::print_range_(const memory_buf_t &formatted, - size_t start, - size_t end) { - if (end > start) { -#if defined(SPDLOG_UTF8_TO_WCHAR_CONSOLE) - wmemory_buf_t wformatted; - details::os::utf8_to_wstrbuf(string_view_t(formatted.data() + start, end - start), - wformatted); - auto size = static_cast<DWORD>(wformatted.size()); - auto ignored = ::WriteConsoleW(static_cast<HANDLE>(out_handle_), wformatted.data(), size, - nullptr, nullptr); -#else - auto size = static_cast<DWORD>(end - start); - auto ignored = ::WriteConsoleA(static_cast<HANDLE>(out_handle_), formatted.data() + start, - size, nullptr, nullptr); -#endif - (void)(ignored); - } -} - -template <typename ConsoleMutex> -void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::write_to_file_(const memory_buf_t &formatted) { - auto size = static_cast<DWORD>(formatted.size()); - DWORD bytes_written = 0; - auto ignored = ::WriteFile(static_cast<HANDLE>(out_handle_), formatted.data(), size, - &bytes_written, nullptr); - (void)(ignored); -} - -// wincolor_stdout_sink -template <typename ConsoleMutex> -SPDLOG_INLINE wincolor_stdout_sink<ConsoleMutex>::wincolor_stdout_sink(color_mode mode) - : wincolor_sink<ConsoleMutex>(::GetStdHandle(STD_OUTPUT_HANDLE), mode) {} - -// wincolor_stderr_sink -template <typename ConsoleMutex> -SPDLOG_INLINE wincolor_stderr_sink<ConsoleMutex>::wincolor_stderr_sink(color_mode mode) - : wincolor_sink<ConsoleMutex>(::GetStdHandle(STD_ERROR_HANDLE), mode) {} -} // namespace sinks -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/sinks/wincolor_sink.h b/thirdparty/spdlog/include/spdlog/sinks/wincolor_sink.h deleted file mode 100644 index e62d14d3f..000000000 --- a/thirdparty/spdlog/include/spdlog/sinks/wincolor_sink.h +++ /dev/null @@ -1,82 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#include <spdlog/common.h> -#include <spdlog/details/console_globals.h> -#include <spdlog/details/null_mutex.h> -#include <spdlog/sinks/sink.h> - -#include <array> -#include <cstdint> -#include <memory> -#include <mutex> -#include <string> - -namespace spdlog { -namespace sinks { -/* - * Windows color console sink. Uses WriteConsoleA to write to the console with - * colors - */ -template <typename ConsoleMutex> -class wincolor_sink : public sink { -public: - wincolor_sink(void *out_handle, color_mode mode); - ~wincolor_sink() override; - - wincolor_sink(const wincolor_sink &other) = delete; - wincolor_sink &operator=(const wincolor_sink &other) = delete; - - // change the color for the given level - void set_color(level::level_enum level, std::uint16_t color); - void log(const details::log_msg &msg) override; - void flush() override; - void set_pattern(const std::string &pattern) override; - void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override; - void set_color_mode(color_mode mode); - -protected: - using mutex_t = typename ConsoleMutex::mutex_t; - void *out_handle_; - mutex_t &mutex_; - bool should_do_colors_; - std::unique_ptr<spdlog::formatter> formatter_; - std::array<std::uint16_t, level::n_levels> colors_; - - // set foreground color and return the orig console attributes (for resetting later) - std::uint16_t set_foreground_color_(std::uint16_t attribs); - - // print a range of formatted message to console - void print_range_(const memory_buf_t &formatted, size_t start, size_t end); - - // in case we are redirected to file (not in console mode) - void write_to_file_(const memory_buf_t &formatted); - - void set_color_mode_impl(color_mode mode); -}; - -template <typename ConsoleMutex> -class wincolor_stdout_sink : public wincolor_sink<ConsoleMutex> { -public: - explicit wincolor_stdout_sink(color_mode mode = color_mode::automatic); -}; - -template <typename ConsoleMutex> -class wincolor_stderr_sink : public wincolor_sink<ConsoleMutex> { -public: - explicit wincolor_stderr_sink(color_mode mode = color_mode::automatic); -}; - -using wincolor_stdout_sink_mt = wincolor_stdout_sink<details::console_mutex>; -using wincolor_stdout_sink_st = wincolor_stdout_sink<details::console_nullmutex>; - -using wincolor_stderr_sink_mt = wincolor_stderr_sink<details::console_mutex>; -using wincolor_stderr_sink_st = wincolor_stderr_sink<details::console_nullmutex>; -} // namespace sinks -} // namespace spdlog - -#ifdef SPDLOG_HEADER_ONLY - #include "wincolor_sink-inl.h" -#endif diff --git a/thirdparty/spdlog/include/spdlog/spdlog-inl.h b/thirdparty/spdlog/include/spdlog/spdlog-inl.h deleted file mode 100644 index e02081fe3..000000000 --- a/thirdparty/spdlog/include/spdlog/spdlog-inl.h +++ /dev/null @@ -1,96 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#ifndef SPDLOG_HEADER_ONLY - #include <spdlog/spdlog.h> -#endif - -#include <spdlog/common.h> -#include <spdlog/pattern_formatter.h> - -namespace spdlog { - -SPDLOG_INLINE void initialize_logger(std::shared_ptr<logger> logger) { - details::registry::instance().initialize_logger(std::move(logger)); -} - -SPDLOG_INLINE std::shared_ptr<logger> get(const std::string &name) { - return details::registry::instance().get(name); -} - -SPDLOG_INLINE void set_formatter(std::unique_ptr<spdlog::formatter> formatter) { - details::registry::instance().set_formatter(std::move(formatter)); -} - -SPDLOG_INLINE void set_pattern(std::string pattern, pattern_time_type time_type) { - set_formatter( - std::unique_ptr<spdlog::formatter>(new pattern_formatter(std::move(pattern), time_type))); -} - -SPDLOG_INLINE void enable_backtrace(size_t n_messages) { - details::registry::instance().enable_backtrace(n_messages); -} - -SPDLOG_INLINE void disable_backtrace() { details::registry::instance().disable_backtrace(); } - -SPDLOG_INLINE void dump_backtrace() { default_logger_raw()->dump_backtrace(); } - -SPDLOG_INLINE level::level_enum get_level() { return default_logger_raw()->level(); } - -SPDLOG_INLINE bool should_log(level::level_enum log_level) { - return default_logger_raw()->should_log(log_level); -} - -SPDLOG_INLINE void set_level(level::level_enum log_level) { - details::registry::instance().set_level(log_level); -} - -SPDLOG_INLINE void flush_on(level::level_enum log_level) { - details::registry::instance().flush_on(log_level); -} - -SPDLOG_INLINE void set_error_handler(void (*handler)(const std::string &msg)) { - details::registry::instance().set_error_handler(handler); -} - -SPDLOG_INLINE void register_logger(std::shared_ptr<logger> logger) { - details::registry::instance().register_logger(std::move(logger)); -} - -SPDLOG_INLINE void register_or_replace(std::shared_ptr<logger> logger) { - details::registry::instance().register_or_replace(std::move(logger)); -} - -SPDLOG_INLINE void apply_all(const std::function<void(std::shared_ptr<logger>)> &fun) { - details::registry::instance().apply_all(fun); -} - -SPDLOG_INLINE void drop(const std::string &name) { details::registry::instance().drop(name); } - -SPDLOG_INLINE void drop_all() { details::registry::instance().drop_all(); } - -SPDLOG_INLINE void shutdown() { details::registry::instance().shutdown(); } - -SPDLOG_INLINE void set_automatic_registration(bool automatic_registration) { - details::registry::instance().set_automatic_registration(automatic_registration); -} - -SPDLOG_INLINE std::shared_ptr<spdlog::logger> default_logger() { - return details::registry::instance().default_logger(); -} - -SPDLOG_INLINE spdlog::logger *default_logger_raw() { - return details::registry::instance().get_default_raw(); -} - -SPDLOG_INLINE void set_default_logger(std::shared_ptr<spdlog::logger> default_logger) { - details::registry::instance().set_default_logger(std::move(default_logger)); -} - -SPDLOG_INLINE void apply_logger_env_levels(std::shared_ptr<logger> logger) { - details::registry::instance().apply_logger_env_levels(std::move(logger)); -} - -} // namespace spdlog diff --git a/thirdparty/spdlog/include/spdlog/spdlog.h b/thirdparty/spdlog/include/spdlog/spdlog.h deleted file mode 100644 index 1a927ffc9..000000000 --- a/thirdparty/spdlog/include/spdlog/spdlog.h +++ /dev/null @@ -1,357 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -// spdlog main header file. -// see example.cpp for usage example - -#ifndef SPDLOG_H -#define SPDLOG_H - -#pragma once - -#include <spdlog/common.h> -#include <spdlog/details/registry.h> -#include <spdlog/details/synchronous_factory.h> -#include <spdlog/logger.h> -#include <spdlog/version.h> - -#include <chrono> -#include <functional> -#include <memory> -#include <string> - -namespace spdlog { - -using default_factory = synchronous_factory; - -// Create and register a logger with a templated sink type -// The logger's level, formatter and flush level will be set according to the -// global settings. -// -// Example: -// spdlog::create<daily_file_sink_st>("logger_name", "dailylog_filename", 11, 59); -template <typename Sink, typename... SinkArgs> -inline std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&...sink_args) { - return default_factory::create<Sink>(std::move(logger_name), - std::forward<SinkArgs>(sink_args)...); -} - -// Initialize and register a logger, -// formatter and flush level will be set according the global settings. -// -// Useful for initializing manually created loggers with the global settings. -// -// Example: -// auto mylogger = std::make_shared<spdlog::logger>("mylogger", ...); -// spdlog::initialize_logger(mylogger); -SPDLOG_API void initialize_logger(std::shared_ptr<logger> logger); - -// Return an existing logger or nullptr if a logger with such a name doesn't -// exist. -// example: spdlog::get("my_logger")->info("hello {}", "world"); -SPDLOG_API std::shared_ptr<logger> get(const std::string &name); - -// Set global formatter. Each sink in each logger will get a clone of this object -SPDLOG_API void set_formatter(std::unique_ptr<spdlog::formatter> formatter); - -// Set global format string. -// example: spdlog::set_pattern("%Y-%m-%d %H:%M:%S.%e %l : %v"); -SPDLOG_API void set_pattern(std::string pattern, - pattern_time_type time_type = pattern_time_type::local); - -// enable global backtrace support -SPDLOG_API void enable_backtrace(size_t n_messages); - -// disable global backtrace support -SPDLOG_API void disable_backtrace(); - -// call dump backtrace on default logger -SPDLOG_API void dump_backtrace(); - -// Get global logging level -SPDLOG_API level::level_enum get_level(); - -// Set the global logging level -SPDLOG_API void set_level(level::level_enum log_level); - -// Determine whether the default logger should log messages with a certain level -SPDLOG_API bool should_log(level::level_enum lvl); - -// Set a global flush level -SPDLOG_API void flush_on(level::level_enum log_level); - -// Start/Restart a periodic flusher thread -// Warning: Use only if all your loggers are thread safe! -template <typename Rep, typename Period> -inline void flush_every(std::chrono::duration<Rep, Period> interval) { - details::registry::instance().flush_every(interval); -} - -// Set global error handler -SPDLOG_API void set_error_handler(void (*handler)(const std::string &msg)); - -// Register the given logger with the given name -// Will throw if a logger with the same name already exists. -SPDLOG_API void register_logger(std::shared_ptr<logger> logger); - -// Register the given logger with the given name -// Will replace any existing logger with the same name. -SPDLOG_API void register_or_replace(std::shared_ptr<logger> logger); - -// Apply a user-defined function on all registered loggers -// Example: -// spdlog::apply_all([&](std::shared_ptr<spdlog::logger> l) {l->flush();}); -SPDLOG_API void apply_all(const std::function<void(std::shared_ptr<logger>)> &fun); - -// Drop the reference to the given logger -SPDLOG_API void drop(const std::string &name); - -// Drop all references from the registry -SPDLOG_API void drop_all(); - -// stop any running threads started by spdlog and clean registry loggers -SPDLOG_API void shutdown(); - -// Automatic registration of loggers when using spdlog::create() or spdlog::create_async -SPDLOG_API void set_automatic_registration(bool automatic_registration); - -// API for using default logger (stdout_color_mt), -// e.g.: spdlog::info("Message {}", 1); -// -// The default logger object can be accessed using the spdlog::default_logger(): -// For example, to add another sink to it: -// spdlog::default_logger()->sinks().push_back(some_sink); -// -// The default logger can be replaced using spdlog::set_default_logger(new_logger). -// For example, to replace it with a file logger. -// -// IMPORTANT: -// The default API is thread safe (for _mt loggers), but: -// set_default_logger() *should not* be used concurrently with the default API. -// e.g., do not call set_default_logger() from one thread while calling spdlog::info() from another. - -SPDLOG_API std::shared_ptr<spdlog::logger> default_logger(); - -SPDLOG_API spdlog::logger *default_logger_raw(); - -SPDLOG_API void set_default_logger(std::shared_ptr<spdlog::logger> default_logger); - -// Initialize logger level based on environment configs. -// -// Useful for applying SPDLOG_LEVEL to manually created loggers. -// -// Example: -// auto mylogger = std::make_shared<spdlog::logger>("mylogger", ...); -// spdlog::apply_logger_env_levels(mylogger); -SPDLOG_API void apply_logger_env_levels(std::shared_ptr<logger> logger); - -template <typename... Args> -inline void log(source_loc source, - level::level_enum lvl, - format_string_t<Args...> fmt, - Args &&...args) { - default_logger_raw()->log(source, lvl, fmt, std::forward<Args>(args)...); -} - -template <typename... Args> -inline void log(level::level_enum lvl, format_string_t<Args...> fmt, Args &&...args) { - default_logger_raw()->log(source_loc{}, lvl, fmt, std::forward<Args>(args)...); -} - -template <typename... Args> -inline void trace(format_string_t<Args...> fmt, Args &&...args) { - default_logger_raw()->trace(fmt, std::forward<Args>(args)...); -} - -template <typename... Args> -inline void debug(format_string_t<Args...> fmt, Args &&...args) { - default_logger_raw()->debug(fmt, std::forward<Args>(args)...); -} - -template <typename... Args> -inline void info(format_string_t<Args...> fmt, Args &&...args) { - default_logger_raw()->info(fmt, std::forward<Args>(args)...); -} - -template <typename... Args> -inline void warn(format_string_t<Args...> fmt, Args &&...args) { - default_logger_raw()->warn(fmt, std::forward<Args>(args)...); -} - -template <typename... Args> -inline void error(format_string_t<Args...> fmt, Args &&...args) { - default_logger_raw()->error(fmt, std::forward<Args>(args)...); -} - -template <typename... Args> -inline void critical(format_string_t<Args...> fmt, Args &&...args) { - default_logger_raw()->critical(fmt, std::forward<Args>(args)...); -} - -template <typename T> -inline void log(source_loc source, level::level_enum lvl, const T &msg) { - default_logger_raw()->log(source, lvl, msg); -} - -template <typename T> -inline void log(level::level_enum lvl, const T &msg) { - default_logger_raw()->log(lvl, msg); -} - -#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT -template <typename... Args> -inline void log(source_loc source, - level::level_enum lvl, - wformat_string_t<Args...> fmt, - Args &&...args) { - default_logger_raw()->log(source, lvl, fmt, std::forward<Args>(args)...); -} - -template <typename... Args> -inline void log(level::level_enum lvl, wformat_string_t<Args...> fmt, Args &&...args) { - default_logger_raw()->log(source_loc{}, lvl, fmt, std::forward<Args>(args)...); -} - -template <typename... Args> -inline void trace(wformat_string_t<Args...> fmt, Args &&...args) { - default_logger_raw()->trace(fmt, std::forward<Args>(args)...); -} - -template <typename... Args> -inline void debug(wformat_string_t<Args...> fmt, Args &&...args) { - default_logger_raw()->debug(fmt, std::forward<Args>(args)...); -} - -template <typename... Args> -inline void info(wformat_string_t<Args...> fmt, Args &&...args) { - default_logger_raw()->info(fmt, std::forward<Args>(args)...); -} - -template <typename... Args> -inline void warn(wformat_string_t<Args...> fmt, Args &&...args) { - default_logger_raw()->warn(fmt, std::forward<Args>(args)...); -} - -template <typename... Args> -inline void error(wformat_string_t<Args...> fmt, Args &&...args) { - default_logger_raw()->error(fmt, std::forward<Args>(args)...); -} - -template <typename... Args> -inline void critical(wformat_string_t<Args...> fmt, Args &&...args) { - default_logger_raw()->critical(fmt, std::forward<Args>(args)...); -} -#endif - -template <typename T> -inline void trace(const T &msg) { - default_logger_raw()->trace(msg); -} - -template <typename T> -inline void debug(const T &msg) { - default_logger_raw()->debug(msg); -} - -template <typename T> -inline void info(const T &msg) { - default_logger_raw()->info(msg); -} - -template <typename T> -inline void warn(const T &msg) { - default_logger_raw()->warn(msg); -} - -template <typename T> -inline void error(const T &msg) { - default_logger_raw()->error(msg); -} - -template <typename T> -inline void critical(const T &msg) { - default_logger_raw()->critical(msg); -} - -} // namespace spdlog - -// -// enable/disable log calls at compile time according to global level. -// -// define SPDLOG_ACTIVE_LEVEL to one of those (before including spdlog.h): -// SPDLOG_LEVEL_TRACE, -// SPDLOG_LEVEL_DEBUG, -// SPDLOG_LEVEL_INFO, -// SPDLOG_LEVEL_WARN, -// SPDLOG_LEVEL_ERROR, -// SPDLOG_LEVEL_CRITICAL, -// SPDLOG_LEVEL_OFF -// - -#ifndef SPDLOG_NO_SOURCE_LOC - #define SPDLOG_LOGGER_CALL(logger, level, ...) \ - (logger)->log(spdlog::source_loc{__FILE__, __LINE__, SPDLOG_FUNCTION}, level, __VA_ARGS__) -#else - #define SPDLOG_LOGGER_CALL(logger, level, ...) \ - (logger)->log(spdlog::source_loc{}, level, __VA_ARGS__) -#endif - -#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_TRACE - #define SPDLOG_LOGGER_TRACE(logger, ...) \ - SPDLOG_LOGGER_CALL(logger, spdlog::level::trace, __VA_ARGS__) - #define SPDLOG_TRACE(...) SPDLOG_LOGGER_TRACE(spdlog::default_logger_raw(), __VA_ARGS__) -#else - #define SPDLOG_LOGGER_TRACE(logger, ...) (void)0 - #define SPDLOG_TRACE(...) (void)0 -#endif - -#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_DEBUG - #define SPDLOG_LOGGER_DEBUG(logger, ...) \ - SPDLOG_LOGGER_CALL(logger, spdlog::level::debug, __VA_ARGS__) - #define SPDLOG_DEBUG(...) SPDLOG_LOGGER_DEBUG(spdlog::default_logger_raw(), __VA_ARGS__) -#else - #define SPDLOG_LOGGER_DEBUG(logger, ...) (void)0 - #define SPDLOG_DEBUG(...) (void)0 -#endif - -#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_INFO - #define SPDLOG_LOGGER_INFO(logger, ...) \ - SPDLOG_LOGGER_CALL(logger, spdlog::level::info, __VA_ARGS__) - #define SPDLOG_INFO(...) SPDLOG_LOGGER_INFO(spdlog::default_logger_raw(), __VA_ARGS__) -#else - #define SPDLOG_LOGGER_INFO(logger, ...) (void)0 - #define SPDLOG_INFO(...) (void)0 -#endif - -#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_WARN - #define SPDLOG_LOGGER_WARN(logger, ...) \ - SPDLOG_LOGGER_CALL(logger, spdlog::level::warn, __VA_ARGS__) - #define SPDLOG_WARN(...) SPDLOG_LOGGER_WARN(spdlog::default_logger_raw(), __VA_ARGS__) -#else - #define SPDLOG_LOGGER_WARN(logger, ...) (void)0 - #define SPDLOG_WARN(...) (void)0 -#endif - -#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_ERROR - #define SPDLOG_LOGGER_ERROR(logger, ...) \ - SPDLOG_LOGGER_CALL(logger, spdlog::level::err, __VA_ARGS__) - #define SPDLOG_ERROR(...) SPDLOG_LOGGER_ERROR(spdlog::default_logger_raw(), __VA_ARGS__) -#else - #define SPDLOG_LOGGER_ERROR(logger, ...) (void)0 - #define SPDLOG_ERROR(...) (void)0 -#endif - -#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_CRITICAL - #define SPDLOG_LOGGER_CRITICAL(logger, ...) \ - SPDLOG_LOGGER_CALL(logger, spdlog::level::critical, __VA_ARGS__) - #define SPDLOG_CRITICAL(...) SPDLOG_LOGGER_CRITICAL(spdlog::default_logger_raw(), __VA_ARGS__) -#else - #define SPDLOG_LOGGER_CRITICAL(logger, ...) (void)0 - #define SPDLOG_CRITICAL(...) (void)0 -#endif - -#ifdef SPDLOG_HEADER_ONLY - #include "spdlog-inl.h" -#endif - -#endif // SPDLOG_H diff --git a/thirdparty/spdlog/include/spdlog/stopwatch.h b/thirdparty/spdlog/include/spdlog/stopwatch.h deleted file mode 100644 index 54ab3d3b8..000000000 --- a/thirdparty/spdlog/include/spdlog/stopwatch.h +++ /dev/null @@ -1,66 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#include <chrono> -#include <spdlog/fmt/fmt.h> - -// Stopwatch support for spdlog (using std::chrono::steady_clock). -// Displays elapsed seconds since construction as double. -// -// Usage: -// -// spdlog::stopwatch sw; -// ... -// spdlog::debug("Elapsed: {} seconds", sw); => "Elapsed 0.005116733 seconds" -// spdlog::info("Elapsed: {:.6} seconds", sw); => "Elapsed 0.005163 seconds" -// -// -// If other units are needed (e.g. millis instead of double), include "fmt/chrono.h" and use -// "duration_cast<..>(sw.elapsed())": -// -// #include <spdlog/fmt/chrono.h> -//.. -// using std::chrono::duration_cast; -// using std::chrono::milliseconds; -// spdlog::info("Elapsed {}", duration_cast<milliseconds>(sw.elapsed())); => "Elapsed 5ms" - -namespace spdlog { -class stopwatch { - using clock = std::chrono::steady_clock; - std::chrono::time_point<clock> start_tp_; - -public: - stopwatch() - : start_tp_{clock::now()} {} - - std::chrono::duration<double> elapsed() const { - return std::chrono::duration<double>(clock::now() - start_tp_); - } - - std::chrono::milliseconds elapsed_ms() const { - return std::chrono::duration_cast<std::chrono::milliseconds>(clock::now() - start_tp_); - } - - void reset() { start_tp_ = clock::now(); } -}; -} // namespace spdlog - -// Support for fmt formatting (e.g. "{:012.9}" or just "{}") -namespace -#ifdef SPDLOG_USE_STD_FORMAT - std -#else - fmt -#endif -{ - -template <> -struct formatter<spdlog::stopwatch> : formatter<double> { - template <typename FormatContext> - auto format(const spdlog::stopwatch &sw, FormatContext &ctx) const -> decltype(ctx.out()) { - return formatter<double>::format(sw.elapsed().count(), ctx); - } -}; -} // namespace std diff --git a/thirdparty/spdlog/include/spdlog/tweakme.h b/thirdparty/spdlog/include/spdlog/tweakme.h deleted file mode 100644 index 17f7a4bc2..000000000 --- a/thirdparty/spdlog/include/spdlog/tweakme.h +++ /dev/null @@ -1,148 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -/////////////////////////////////////////////////////////////////////////////// -// -// Edit this file to squeeze more performance, and to customize supported -// features -// -/////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////// -// Under Linux, the much faster CLOCK_REALTIME_COARSE clock can be used. -// This clock is less accurate - can be off by dozens of millis - depending on -// the kernel HZ. -// Uncomment to use it instead of the regular clock. -// -// #define SPDLOG_CLOCK_COARSE -/////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////// -// Uncomment if source location logging is not needed. -// This will prevent spdlog from using __FILE__, __LINE__ and SPDLOG_FUNCTION -// -// #define SPDLOG_NO_SOURCE_LOC -/////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////// -// Uncomment if thread id logging is not needed (i.e. no %t in the log pattern). -// This will prevent spdlog from querying the thread id on each log call. -// -// WARNING: If the log pattern contains thread id (i.e, %t) while this flag is -// on, zero will be logged as thread id. -// -// #define SPDLOG_NO_THREAD_ID -/////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////// -// Uncomment to prevent spdlog from using thread local storage. -// -// WARNING: if your program forks, UNCOMMENT this flag to prevent undefined -// thread ids in the children logs. -// -#define SPDLOG_NO_TLS -/////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////// -// Uncomment to avoid spdlog's usage of atomic log levels -// Use only if your code never modifies a logger's log levels concurrently by -// different threads. -// -// #define SPDLOG_NO_ATOMIC_LEVELS -/////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////// -// Uncomment to enable usage of wchar_t for file names on Windows. -// -// #define SPDLOG_WCHAR_FILENAMES -/////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////// -// Uncomment to override default eol ("\n" or "\r\n" under Linux/Windows) -// -// #define SPDLOG_EOL ";-)\n" -/////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////// -// Uncomment to override default folder separators ("/" or "\\/" under -// Linux/Windows). Each character in the string is treated as a different -// separator. -// -// #define SPDLOG_FOLDER_SEPS "\\" -/////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////// -// Uncomment to use your own copy of the fmt library instead of spdlog's copy. -// In this case spdlog will try to include <fmt/format.h> so set your -I flag -// accordingly. -// -#define SPDLOG_FMT_EXTERNAL -/////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////// -// Uncomment to use C++20 std::format instead of fmt. -// -// #define SPDLOG_USE_STD_FORMAT -/////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////// -// Uncomment to enable wchar_t support (convert to utf8) -// -// #define SPDLOG_WCHAR_TO_UTF8_SUPPORT -/////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////// -// Uncomment to prevent child processes from inheriting log file descriptors -// -// #define SPDLOG_PREVENT_CHILD_FD -/////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////// -// Uncomment to customize level names (e.g. "MY TRACE") -// -// #define SPDLOG_LEVEL_NAMES { "MY TRACE", "MY DEBUG", "MY INFO", "MY WARNING", "MY ERROR", "MY -// CRITICAL", "OFF" } -// -// For C++17 use string_view_literals: -// -// #include <string_view> -// using namespace std::string_view_literals; -// #define SPDLOG_LEVEL_NAMES { "MY TRACE"sv, "MY DEBUG"sv, "MY INFO"sv, "MY WARNING"sv, "MY -// ERROR"sv, "MY CRITICAL"sv, "OFF"sv } -/////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////// -// Uncomment to customize short level names (e.g. "MT") -// These can be longer than one character. -// -// #define SPDLOG_SHORT_LEVEL_NAMES { "T", "D", "I", "W", "E", "C", "O" } -/////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////// -// Uncomment to disable default logger creation. -// This might save some (very) small initialization time if no default logger is needed. -// -// #define SPDLOG_DISABLE_DEFAULT_LOGGER -/////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////// -// Uncomment and set to compile time level with zero cost (default is INFO). -// Macros like SPDLOG_DEBUG(..), SPDLOG_INFO(..) will expand to empty statements if not enabled -// -// #define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_INFO -/////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////// -// Uncomment (and change if desired) macro to use for function names. -// This is compiler dependent. -// __PRETTY_FUNCTION__ might be nicer in clang/gcc, and __FUNCTION__ in msvc. -// Defaults to __FUNCTION__ (should work on all compilers) if not defined. -// -// #ifdef __PRETTY_FUNCTION__ -// # define SPDLOG_FUNCTION __PRETTY_FUNCTION__ -// #else -// # define SPDLOG_FUNCTION __FUNCTION__ -// #endif -/////////////////////////////////////////////////////////////////////////////// diff --git a/thirdparty/spdlog/include/spdlog/version.h b/thirdparty/spdlog/include/spdlog/version.h deleted file mode 100644 index 69ff2571d..000000000 --- a/thirdparty/spdlog/include/spdlog/version.h +++ /dev/null @@ -1,11 +0,0 @@ -// Copyright(c) 2015-present, Gabi Melman & spdlog contributors. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) - -#pragma once - -#define SPDLOG_VER_MAJOR 1 -#define SPDLOG_VER_MINOR 16 -#define SPDLOG_VER_PATCH 0 - -#define SPDLOG_TO_VERSION(major, minor, patch) (major * 10000 + minor * 100 + patch) -#define SPDLOG_VERSION SPDLOG_TO_VERSION(SPDLOG_VER_MAJOR, SPDLOG_VER_MINOR, SPDLOG_VER_PATCH) diff --git a/thirdparty/spdlog/tests/includes.h b/thirdparty/spdlog/tests/includes.h deleted file mode 100644 index 2e49a5cb7..000000000 --- a/thirdparty/spdlog/tests/includes.h +++ /dev/null @@ -1,42 +0,0 @@ -#pragma once - -#if defined(__GNUC__) && __GNUC__ == 12 - #pragma GCC diagnostic push - #pragma GCC diagnostic ignored "-Wmaybe-uninitialized" // Workaround for GCC 12 -#endif -#include <catch2/catch_all.hpp> -#if defined(__GNUC__) && __GNUC__ == 12 - #pragma GCC diagnostic pop -#endif - -#include "utils.h" -#include <chrono> -#include <cstdio> -#include <exception> -#include <fstream> -#include <iostream> -#include <ostream> -#include <sstream> -#include <string> -#include <iomanip> -#include <stdlib.h> - -#define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_DEBUG - -#include "spdlog/spdlog.h" -#include "spdlog/async.h" -#include "spdlog/details/fmt_helper.h" -#include "spdlog/details/os.h" - -#ifndef SPDLOG_NO_TLS - #include "spdlog/mdc.h" -#endif - -#include "spdlog/sinks/basic_file_sink.h" -#include "spdlog/sinks/daily_file_sink.h" -#include "spdlog/sinks/null_sink.h" -#include "spdlog/sinks/ostream_sink.h" -#include "spdlog/sinks/rotating_file_sink.h" -#include "spdlog/sinks/stdout_color_sinks.h" -#include "spdlog/sinks/msvc_sink.h" -#include "spdlog/pattern_formatter.h" diff --git a/thirdparty/spdlog/tests/main.cpp b/thirdparty/spdlog/tests/main.cpp deleted file mode 100644 index a4a4ff154..000000000 --- a/thirdparty/spdlog/tests/main.cpp +++ /dev/null @@ -1,10 +0,0 @@ -#if defined(__GNUC__) && __GNUC__ == 12 - #pragma GCC diagnostic push - #pragma GCC diagnostic ignored "-Wmaybe-uninitialized" // Workaround for GCC 12 -#endif - -#include <catch2/catch_all.hpp> - -#if defined(__GNUC__) && __GNUC__ == 12 - #pragma GCC diagnostic pop -#endif diff --git a/thirdparty/spdlog/tests/test_async.cpp b/thirdparty/spdlog/tests/test_async.cpp deleted file mode 100644 index 76fdd7c6b..000000000 --- a/thirdparty/spdlog/tests/test_async.cpp +++ /dev/null @@ -1,200 +0,0 @@ -#include "includes.h" -#include "spdlog/async.h" -#include "spdlog/sinks/basic_file_sink.h" -#include "test_sink.h" - -#define TEST_FILENAME "test_logs/async_test.log" - -TEST_CASE("basic async test ", "[async]") { - auto test_sink = std::make_shared<spdlog::sinks::test_sink_mt>(); - size_t overrun_counter = 0; - size_t queue_size = 128; - size_t messages = 256; - { - auto tp = std::make_shared<spdlog::details::thread_pool>(queue_size, 1); - auto logger = std::make_shared<spdlog::async_logger>("as", test_sink, tp, - spdlog::async_overflow_policy::block); - for (size_t i = 0; i < messages; i++) { - logger->info("Hello message #{}", i); - } - logger->flush(); - overrun_counter = tp->overrun_counter(); - } - REQUIRE(test_sink->msg_counter() == messages); - REQUIRE(test_sink->flush_counter() == 1); - REQUIRE(overrun_counter == 0); -} - -TEST_CASE("discard policy ", "[async]") { - auto test_sink = std::make_shared<spdlog::sinks::test_sink_mt>(); - test_sink->set_delay(std::chrono::milliseconds(1)); - size_t queue_size = 4; - size_t messages = 1024; - - auto tp = std::make_shared<spdlog::details::thread_pool>(queue_size, 1); - auto logger = std::make_shared<spdlog::async_logger>( - "as", test_sink, tp, spdlog::async_overflow_policy::overrun_oldest); - for (size_t i = 0; i < messages; i++) { - logger->info("Hello message"); - } - REQUIRE(test_sink->msg_counter() < messages); - REQUIRE(tp->overrun_counter() > 0); -} - -TEST_CASE("discard policy discard_new ", "[async]") { - auto test_sink = std::make_shared<spdlog::sinks::test_sink_mt>(); - test_sink->set_delay(std::chrono::milliseconds(1)); - size_t queue_size = 4; - size_t messages = 1024; - - auto tp = std::make_shared<spdlog::details::thread_pool>(queue_size, 1); - auto logger = std::make_shared<spdlog::async_logger>( - "as", test_sink, tp, spdlog::async_overflow_policy::discard_new); - for (size_t i = 0; i < messages; i++) { - logger->info("Hello message"); - } - REQUIRE(test_sink->msg_counter() < messages); - REQUIRE(tp->discard_counter() > 0); -} - -TEST_CASE("discard policy using factory ", "[async]") { - size_t queue_size = 4; - size_t messages = 1024; - spdlog::init_thread_pool(queue_size, 1); - - auto logger = spdlog::create_async_nb<spdlog::sinks::test_sink_mt>("as2"); - auto test_sink = std::static_pointer_cast<spdlog::sinks::test_sink_mt>(logger->sinks()[0]); - test_sink->set_delay(std::chrono::milliseconds(3)); - - for (size_t i = 0; i < messages; i++) { - logger->info("Hello message"); - } - - REQUIRE(test_sink->msg_counter() < messages); - spdlog::drop_all(); -} - -TEST_CASE("flush", "[async]") { - auto test_sink = std::make_shared<spdlog::sinks::test_sink_mt>(); - size_t queue_size = 256; - size_t messages = 256; - { - auto tp = std::make_shared<spdlog::details::thread_pool>(queue_size, 1); - auto logger = std::make_shared<spdlog::async_logger>("as", test_sink, tp, - spdlog::async_overflow_policy::block); - for (size_t i = 0; i < messages; i++) { - logger->info("Hello message #{}", i); - } - - logger->flush(); - } - // std::this_thread::sleep_for(std::chrono::milliseconds(250)); - REQUIRE(test_sink->msg_counter() == messages); - REQUIRE(test_sink->flush_counter() == 1); -} - -TEST_CASE("async periodic flush", "[async]") { - auto logger = spdlog::create_async<spdlog::sinks::test_sink_mt>("as"); - auto test_sink = std::static_pointer_cast<spdlog::sinks::test_sink_mt>(logger->sinks()[0]); - - spdlog::flush_every(std::chrono::seconds(1)); - std::this_thread::sleep_for(std::chrono::milliseconds(1700)); - REQUIRE(test_sink->flush_counter() == 1); - spdlog::flush_every(std::chrono::seconds(0)); - spdlog::drop_all(); -} - -TEST_CASE("tp->wait_empty() ", "[async]") { - auto test_sink = std::make_shared<spdlog::sinks::test_sink_mt>(); - test_sink->set_delay(std::chrono::milliseconds(5)); - size_t messages = 100; - - auto tp = std::make_shared<spdlog::details::thread_pool>(messages, 2); - auto logger = std::make_shared<spdlog::async_logger>("as", test_sink, tp, - spdlog::async_overflow_policy::block); - for (size_t i = 0; i < messages; i++) { - logger->info("Hello message #{}", i); - } - logger->flush(); - tp.reset(); - - REQUIRE(test_sink->msg_counter() == messages); - REQUIRE(test_sink->flush_counter() == 1); -} - -TEST_CASE("multi threads", "[async]") { - auto test_sink = std::make_shared<spdlog::sinks::test_sink_mt>(); - size_t queue_size = 128; - size_t messages = 256; - size_t n_threads = 10; - { - auto tp = std::make_shared<spdlog::details::thread_pool>(queue_size, 1); - auto logger = std::make_shared<spdlog::async_logger>("as", test_sink, tp, - spdlog::async_overflow_policy::block); - - std::vector<std::thread> threads; - for (size_t i = 0; i < n_threads; i++) { - threads.emplace_back([logger, messages] { - for (size_t j = 0; j < messages; j++) { - logger->info("Hello message #{}", j); - } - }); - logger->flush(); - } - - for (auto &t : threads) { - t.join(); - } - } - - REQUIRE(test_sink->msg_counter() == messages * n_threads); - REQUIRE(test_sink->flush_counter() == n_threads); -} - -TEST_CASE("to_file", "[async]") { - prepare_logdir(); - size_t messages = 1024; - size_t tp_threads = 1; - spdlog::filename_t filename = SPDLOG_FILENAME_T(TEST_FILENAME); - { - auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(filename, true); - auto tp = std::make_shared<spdlog::details::thread_pool>(messages, tp_threads); - auto logger = - std::make_shared<spdlog::async_logger>("as", std::move(file_sink), std::move(tp)); - - for (size_t j = 0; j < messages; j++) { - logger->info("Hello message #{}", j); - } - } - - require_message_count(TEST_FILENAME, messages); - auto contents = file_contents(TEST_FILENAME); - using spdlog::details::os::default_eol; - REQUIRE(ends_with(contents, spdlog::fmt_lib::format("Hello message #1023{}", default_eol))); -} - -TEST_CASE("to_file multi-workers", "[async]") { - prepare_logdir(); - size_t messages = 1024 * 10; - size_t tp_threads = 10; - spdlog::filename_t filename = SPDLOG_FILENAME_T(TEST_FILENAME); - { - auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(filename, true); - auto tp = std::make_shared<spdlog::details::thread_pool>(messages, tp_threads); - auto logger = - std::make_shared<spdlog::async_logger>("as", std::move(file_sink), std::move(tp)); - - for (size_t j = 0; j < messages; j++) { - logger->info("Hello message #{}", j); - } - } - require_message_count(TEST_FILENAME, messages); -} - -TEST_CASE("bad_tp", "[async]") { - auto test_sink = std::make_shared<spdlog::sinks::test_sink_mt>(); - std::shared_ptr<spdlog::details::thread_pool> const empty_tp; - auto logger = std::make_shared<spdlog::async_logger>("as", test_sink, empty_tp); - logger->info("Please throw an exception"); - REQUIRE(test_sink->msg_counter() == 0); -} diff --git a/thirdparty/spdlog/tests/test_backtrace.cpp b/thirdparty/spdlog/tests/test_backtrace.cpp deleted file mode 100644 index 4d78c0c21..000000000 --- a/thirdparty/spdlog/tests/test_backtrace.cpp +++ /dev/null @@ -1,73 +0,0 @@ -#include "includes.h" -#include "test_sink.h" -#include "spdlog/async.h" - -TEST_CASE("bactrace1", "[bactrace]") { - using spdlog::sinks::test_sink_st; - auto test_sink = std::make_shared<test_sink_st>(); - size_t backtrace_size = 5; - - spdlog::logger logger("test-backtrace", test_sink); - logger.set_pattern("%v"); - logger.enable_backtrace(backtrace_size); - - logger.info("info message"); - for (int i = 0; i < 100; i++) logger.debug("debug message {}", i); - - REQUIRE(test_sink->lines().size() == 1); - REQUIRE(test_sink->lines()[0] == "info message"); - - logger.dump_backtrace(); - REQUIRE(test_sink->lines().size() == backtrace_size + 3); - REQUIRE(test_sink->lines()[1] == "****************** Backtrace Start ******************"); - REQUIRE(test_sink->lines()[2] == "debug message 95"); - REQUIRE(test_sink->lines()[3] == "debug message 96"); - REQUIRE(test_sink->lines()[4] == "debug message 97"); - REQUIRE(test_sink->lines()[5] == "debug message 98"); - REQUIRE(test_sink->lines()[6] == "debug message 99"); - REQUIRE(test_sink->lines()[7] == "****************** Backtrace End ********************"); -} - -TEST_CASE("bactrace-empty", "[bactrace]") { - using spdlog::sinks::test_sink_st; - auto test_sink = std::make_shared<test_sink_st>(); - size_t backtrace_size = 5; - - spdlog::logger logger("test-backtrace", test_sink); - logger.set_pattern("%v"); - logger.enable_backtrace(backtrace_size); - logger.dump_backtrace(); - REQUIRE(test_sink->lines().size() == 0); -} - -TEST_CASE("bactrace-async", "[bactrace]") { - using spdlog::sinks::test_sink_mt; - auto test_sink = std::make_shared<test_sink_mt>(); - using spdlog::details::os::sleep_for_millis; - - size_t backtrace_size = 5; - - spdlog::init_thread_pool(120, 1); - auto logger = std::make_shared<spdlog::async_logger>("test-bactrace-async", test_sink, - spdlog::thread_pool()); - logger->set_pattern("%v"); - logger->enable_backtrace(backtrace_size); - - logger->info("info message"); - for (int i = 0; i < 100; i++) logger->debug("debug message {}", i); - - sleep_for_millis(100); - REQUIRE(test_sink->lines().size() == 1); - REQUIRE(test_sink->lines()[0] == "info message"); - - logger->dump_backtrace(); - sleep_for_millis(100); // give time for the async dump to complete - REQUIRE(test_sink->lines().size() == backtrace_size + 3); - REQUIRE(test_sink->lines()[1] == "****************** Backtrace Start ******************"); - REQUIRE(test_sink->lines()[2] == "debug message 95"); - REQUIRE(test_sink->lines()[3] == "debug message 96"); - REQUIRE(test_sink->lines()[4] == "debug message 97"); - REQUIRE(test_sink->lines()[5] == "debug message 98"); - REQUIRE(test_sink->lines()[6] == "debug message 99"); - REQUIRE(test_sink->lines()[7] == "****************** Backtrace End ********************"); -} diff --git a/thirdparty/spdlog/tests/test_bin_to_hex.cpp b/thirdparty/spdlog/tests/test_bin_to_hex.cpp deleted file mode 100644 index 45fc9fa96..000000000 --- a/thirdparty/spdlog/tests/test_bin_to_hex.cpp +++ /dev/null @@ -1,97 +0,0 @@ -#include "includes.h" -#include "test_sink.h" -#include "spdlog/fmt/bin_to_hex.h" - -TEST_CASE("to_hex", "[to_hex]") { - std::ostringstream oss; - auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss); - spdlog::logger oss_logger("oss", oss_sink); - - std::vector<unsigned char> v{9, 0xa, 0xb, 0xc, 0xff, 0xff}; - oss_logger.info("{}", spdlog::to_hex(v)); - - auto output = oss.str(); - REQUIRE(ends_with(output, - "0000: 09 0a 0b 0c ff ff" + std::string(spdlog::details::os::default_eol))); -} - -TEST_CASE("to_hex_upper", "[to_hex]") { - std::ostringstream oss; - auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss); - spdlog::logger oss_logger("oss", oss_sink); - - std::vector<unsigned char> v{9, 0xa, 0xb, 0xc, 0xff, 0xff}; - oss_logger.info("{:X}", spdlog::to_hex(v)); - - auto output = oss.str(); - REQUIRE(ends_with(output, - "0000: 09 0A 0B 0C FF FF" + std::string(spdlog::details::os::default_eol))); -} - -TEST_CASE("to_hex_no_delimiter", "[to_hex]") { - std::ostringstream oss; - auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss); - spdlog::logger oss_logger("oss", oss_sink); - - std::vector<unsigned char> v{9, 0xa, 0xb, 0xc, 0xff, 0xff}; - oss_logger.info("{:sX}", spdlog::to_hex(v)); - - auto output = oss.str(); - REQUIRE( - ends_with(output, "0000: 090A0B0CFFFF" + std::string(spdlog::details::os::default_eol))); -} - -TEST_CASE("to_hex_show_ascii", "[to_hex]") { - std::ostringstream oss; - auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss); - spdlog::logger oss_logger("oss", oss_sink); - - std::vector<unsigned char> v{9, 0xa, 0xb, 0x41, 0xc, 0x4b, 0xff, 0xff}; - oss_logger.info("{:Xsa}", spdlog::to_hex(v, 8)); - - REQUIRE(ends_with(oss.str(), "0000: 090A0B410C4BFFFF ...A.K.." + - std::string(spdlog::details::os::default_eol))); -} - -TEST_CASE("to_hex_different_size_per_line", "[to_hex]") { - std::ostringstream oss; - auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss); - spdlog::logger oss_logger("oss", oss_sink); - - std::vector<unsigned char> v{9, 0xa, 0xb, 0x41, 0xc, 0x4b, 0xff, 0xff}; - - oss_logger.info("{:Xsa}", spdlog::to_hex(v, 10)); - REQUIRE(ends_with(oss.str(), "0000: 090A0B410C4BFFFF ...A.K.." + - std::string(spdlog::details::os::default_eol))); - - oss_logger.info("{:Xs}", spdlog::to_hex(v, 10)); - REQUIRE(ends_with(oss.str(), - "0000: 090A0B410C4BFFFF" + std::string(spdlog::details::os::default_eol))); - - oss_logger.info("{:Xsa}", spdlog::to_hex(v, 6)); - REQUIRE(ends_with( - oss.str(), "0000: 090A0B410C4B ...A.K" + std::string(spdlog::details::os::default_eol) + - "0006: FFFF .." + std::string(spdlog::details::os::default_eol))); - - oss_logger.info("{:Xs}", spdlog::to_hex(v, 6)); - REQUIRE(ends_with(oss.str(), "0000: 090A0B410C4B" + - std::string(spdlog::details::os::default_eol) + "0006: FFFF" + - std::string(spdlog::details::os::default_eol))); -} - -TEST_CASE("to_hex_no_ascii", "[to_hex]") { - std::ostringstream oss; - auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss); - spdlog::logger oss_logger("oss", oss_sink); - - std::vector<unsigned char> v{9, 0xa, 0xb, 0x41, 0xc, 0x4b, 0xff, 0xff}; - oss_logger.info("{:Xs}", spdlog::to_hex(v, 8)); - - REQUIRE(ends_with(oss.str(), - "0000: 090A0B410C4BFFFF" + std::string(spdlog::details::os::default_eol))); - - oss_logger.info("{:Xsna}", spdlog::to_hex(v, 8)); - - REQUIRE( - ends_with(oss.str(), "090A0B410C4BFFFF" + std::string(spdlog::details::os::default_eol))); -} diff --git a/thirdparty/spdlog/tests/test_cfg.cpp b/thirdparty/spdlog/tests/test_cfg.cpp deleted file mode 100644 index 7dec94b44..000000000 --- a/thirdparty/spdlog/tests/test_cfg.cpp +++ /dev/null @@ -1,178 +0,0 @@ - -#include "includes.h" -#include "test_sink.h" - -#include <spdlog/cfg/env.h> -#include <spdlog/cfg/argv.h> - -using spdlog::cfg::load_argv_levels; -using spdlog::cfg::load_env_levels; -using spdlog::sinks::test_sink_st; - -TEST_CASE("env", "[cfg]") { - spdlog::drop("l1"); - auto l1 = spdlog::create<test_sink_st>("l1"); -#ifdef CATCH_PLATFORM_WINDOWS - _putenv_s("SPDLOG_LEVEL", "l1=warn"); -#else - setenv("SPDLOG_LEVEL", "l1=warn", 1); -#endif - load_env_levels(); - REQUIRE(l1->level() == spdlog::level::warn); - -#ifdef CATCH_PLATFORM_WINDOWS - _putenv_s("MYAPP_LEVEL", "l1=trace"); -#else - setenv("MYAPP_LEVEL", "l1=trace", 1); -#endif - load_env_levels("MYAPP_LEVEL"); - REQUIRE(l1->level() == spdlog::level::trace); - - spdlog::set_default_logger(spdlog::create<test_sink_st>("cfg-default")); - REQUIRE(spdlog::default_logger()->level() == spdlog::level::info); -} - -TEST_CASE("argv1", "[cfg]") { - spdlog::drop("l1"); - const char *argv[] = {"ignore", "SPDLOG_LEVEL=l1=warn"}; - load_argv_levels(2, argv); - auto l1 = spdlog::create<spdlog::sinks::test_sink_st>("l1"); - REQUIRE(l1->level() == spdlog::level::warn); - REQUIRE(spdlog::default_logger()->level() == spdlog::level::info); -} - -TEST_CASE("argv2", "[cfg]") { - spdlog::drop("l1"); - const char *argv[] = {"ignore", "SPDLOG_LEVEL=l1=warn,trace"}; - load_argv_levels(2, argv); - auto l1 = spdlog::create<test_sink_st>("l1"); - REQUIRE(l1->level() == spdlog::level::warn); - REQUIRE(spdlog::default_logger()->level() == spdlog::level::trace); -} - -TEST_CASE("argv3", "[cfg]") { - spdlog::set_level(spdlog::level::trace); - - spdlog::drop("l1"); - const char *argv[] = {"ignore", "SPDLOG_LEVEL=junk_name=warn"}; - load_argv_levels(2, argv); - auto l1 = spdlog::create<test_sink_st>("l1"); - REQUIRE(l1->level() == spdlog::level::trace); - REQUIRE(spdlog::default_logger()->level() == spdlog::level::trace); -} - -TEST_CASE("argv4", "[cfg]") { - spdlog::set_level(spdlog::level::info); - spdlog::drop("l1"); - const char *argv[] = {"ignore", "SPDLOG_LEVEL=junk"}; - load_argv_levels(2, argv); - auto l1 = spdlog::create<test_sink_st>("l1"); - REQUIRE(l1->level() == spdlog::level::info); -} - -TEST_CASE("argv5", "[cfg]") { - spdlog::set_level(spdlog::level::info); - spdlog::drop("l1"); - const char *argv[] = {"ignore", "ignore", "SPDLOG_LEVEL=l1=warn,trace"}; - load_argv_levels(3, argv); - auto l1 = spdlog::create<test_sink_st>("l1"); - REQUIRE(l1->level() == spdlog::level::warn); - REQUIRE(spdlog::default_logger()->level() == spdlog::level::trace); - spdlog::set_level(spdlog::level::info); -} - -TEST_CASE("argv6", "[cfg]") { - spdlog::set_level(spdlog::level::err); - const char *argv[] = {""}; - load_argv_levels(1, argv); - REQUIRE(spdlog::default_logger()->level() == spdlog::level::err); - spdlog::set_level(spdlog::level::info); -} - -TEST_CASE("argv7", "[cfg]") { - spdlog::set_level(spdlog::level::err); - const char *argv[] = {""}; - load_argv_levels(0, argv); - REQUIRE(spdlog::default_logger()->level() == spdlog::level::err); - spdlog::set_level(spdlog::level::info); -} - -TEST_CASE("level-not-set-test1", "[cfg]") { - spdlog::drop("l1"); - const char *argv[] = {"ignore", ""}; - load_argv_levels(2, argv); - auto l1 = spdlog::create<spdlog::sinks::test_sink_st>("l1"); - l1->set_level(spdlog::level::trace); - REQUIRE(l1->level() == spdlog::level::trace); - REQUIRE(spdlog::default_logger()->level() == spdlog::level::info); -} - -TEST_CASE("level-not-set-test2", "[cfg]") { - spdlog::drop("l1"); - spdlog::drop("l2"); - const char *argv[] = {"ignore", "SPDLOG_LEVEL=l1=trace"}; - - auto l1 = spdlog::create<spdlog::sinks::test_sink_st>("l1"); - l1->set_level(spdlog::level::warn); - auto l2 = spdlog::create<spdlog::sinks::test_sink_st>("l2"); - l2->set_level(spdlog::level::warn); - - load_argv_levels(2, argv); - - REQUIRE(l1->level() == spdlog::level::trace); - REQUIRE(l2->level() == spdlog::level::warn); - REQUIRE(spdlog::default_logger()->level() == spdlog::level::info); -} - -TEST_CASE("level-not-set-test3", "[cfg]") { - spdlog::drop("l1"); - spdlog::drop("l2"); - const char *argv[] = {"ignore", "SPDLOG_LEVEL=l1=trace"}; - - load_argv_levels(2, argv); - - auto l1 = spdlog::create<spdlog::sinks::test_sink_st>("l1"); - auto l2 = spdlog::create<spdlog::sinks::test_sink_st>("l2"); - - REQUIRE(l1->level() == spdlog::level::trace); - REQUIRE(l2->level() == spdlog::level::info); - REQUIRE(spdlog::default_logger()->level() == spdlog::level::info); -} - -TEST_CASE("level-not-set-test4", "[cfg]") { - spdlog::drop("l1"); - spdlog::drop("l2"); - const char *argv[] = {"ignore", "SPDLOG_LEVEL=l1=trace,warn"}; - - load_argv_levels(2, argv); - - auto l1 = spdlog::create<spdlog::sinks::test_sink_st>("l1"); - auto l2 = spdlog::create<spdlog::sinks::test_sink_st>("l2"); - - REQUIRE(l1->level() == spdlog::level::trace); - REQUIRE(l2->level() == spdlog::level::warn); - REQUIRE(spdlog::default_logger()->level() == spdlog::level::warn); -} - -TEST_CASE("level-not-set-test5", "[cfg]") { - spdlog::drop("l1"); - spdlog::drop("l2"); - const char *argv[] = {"ignore", "SPDLOG_LEVEL=l1=junk,warn"}; - - load_argv_levels(2, argv); - - auto l1 = spdlog::create<spdlog::sinks::test_sink_st>("l1"); - auto l2 = spdlog::create<spdlog::sinks::test_sink_st>("l2"); - - REQUIRE(l1->level() == spdlog::level::warn); - REQUIRE(l2->level() == spdlog::level::warn); - REQUIRE(spdlog::default_logger()->level() == spdlog::level::warn); -} - -TEST_CASE("restore-to-default", "[cfg]") { - spdlog::drop("l1"); - spdlog::drop("l2"); - const char *argv[] = {"ignore", "SPDLOG_LEVEL=info"}; - load_argv_levels(2, argv); - REQUIRE(spdlog::default_logger()->level() == spdlog::level::info); -} diff --git a/thirdparty/spdlog/tests/test_circular_q.cpp b/thirdparty/spdlog/tests/test_circular_q.cpp deleted file mode 100644 index c8b02d363..000000000 --- a/thirdparty/spdlog/tests/test_circular_q.cpp +++ /dev/null @@ -1,50 +0,0 @@ -#include "includes.h" -#include "spdlog/details/circular_q.h" - -using q_type = spdlog::details::circular_q<size_t>; -TEST_CASE("test_size", "[circular_q]") { - const size_t q_size = 4; - q_type q(q_size); - REQUIRE(q.size() == 0); - REQUIRE(q.empty() == true); - for (size_t i = 0; i < q_size; i++) { - q.push_back(std::move(i)); - } - REQUIRE(q.size() == q_size); - q.push_back(999); - REQUIRE(q.size() == q_size); -} - -TEST_CASE("test_rolling", "[circular_q]") { - const size_t q_size = 4; - q_type q(q_size); - - for (size_t i = 0; i < q_size + 2; i++) { - q.push_back(std::move(i)); - } - - REQUIRE(q.size() == q_size); - - REQUIRE(q.front() == 2); - q.pop_front(); - - REQUIRE(q.front() == 3); - q.pop_front(); - - REQUIRE(q.front() == 4); - q.pop_front(); - - REQUIRE(q.front() == 5); - q.pop_front(); - - REQUIRE(q.empty()); - - q.push_back(6); - REQUIRE(q.front() == 6); -} - -TEST_CASE("test_empty", "[circular_q]") { - q_type q(0); - q.push_back(1); - REQUIRE(q.empty()); -}
\ No newline at end of file diff --git a/thirdparty/spdlog/tests/test_create_dir.cpp b/thirdparty/spdlog/tests/test_create_dir.cpp deleted file mode 100644 index fd040339c..000000000 --- a/thirdparty/spdlog/tests/test_create_dir.cpp +++ /dev/null @@ -1,144 +0,0 @@ -/* - * This content is released under the MIT License as specified in - * https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE - */ -#include "includes.h" - -using spdlog::details::os::create_dir; -using spdlog::details::os::path_exists; - -bool try_create_dir(const spdlog::filename_t &path, const spdlog::filename_t &normalized_path) { - auto rv = create_dir(path); - REQUIRE(rv == true); - return path_exists(normalized_path); -} - -TEST_CASE("create_dir", "[create_dir]") { - prepare_logdir(); - - REQUIRE(try_create_dir(SPDLOG_FILENAME_T("test_logs/dir1/dir1"), - SPDLOG_FILENAME_T("test_logs/dir1/dir1"))); - REQUIRE(try_create_dir(SPDLOG_FILENAME_T("test_logs/dir1/dir1"), - SPDLOG_FILENAME_T("test_logs/dir1/dir1"))); // test existing - REQUIRE(try_create_dir(SPDLOG_FILENAME_T("test_logs/dir1///dir2//"), - SPDLOG_FILENAME_T("test_logs/dir1/dir2"))); - REQUIRE(try_create_dir(SPDLOG_FILENAME_T("./test_logs/dir1/dir3"), - SPDLOG_FILENAME_T("test_logs/dir1/dir3"))); - REQUIRE(try_create_dir(SPDLOG_FILENAME_T("test_logs/../test_logs/dir1/dir4"), - SPDLOG_FILENAME_T("test_logs/dir1/dir4"))); - -#ifdef WIN32 - // test backslash folder separator - REQUIRE(try_create_dir(SPDLOG_FILENAME_T("test_logs\\dir1\\dir222"), - SPDLOG_FILENAME_T("test_logs\\dir1\\dir222"))); - REQUIRE(try_create_dir(SPDLOG_FILENAME_T("test_logs\\dir1\\dir223\\"), - SPDLOG_FILENAME_T("test_logs\\dir1\\dir223\\"))); - REQUIRE(try_create_dir(SPDLOG_FILENAME_T(".\\test_logs\\dir1\\dir2\\dir99\\..\\dir23"), - SPDLOG_FILENAME_T("test_logs\\dir1\\dir2\\dir23"))); - REQUIRE(try_create_dir(SPDLOG_FILENAME_T("test_logs\\..\\test_logs\\dir1\\dir5"), - SPDLOG_FILENAME_T("test_logs\\dir1\\dir5"))); -#endif -} - -TEST_CASE("create_invalid_dir", "[create_dir]") { - REQUIRE(create_dir(SPDLOG_FILENAME_T("")) == false); - REQUIRE(create_dir(spdlog::filename_t{}) == false); -#ifdef __linux__ - REQUIRE(create_dir("/proc/spdlog-utest") == false); -#endif -} - -TEST_CASE("dir_name", "[create_dir]") { - using spdlog::details::os::dir_name; - REQUIRE(dir_name(SPDLOG_FILENAME_T("")).empty()); - REQUIRE(dir_name(SPDLOG_FILENAME_T("dir")).empty()); - -#ifdef WIN32 - REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(dir\)")) == SPDLOG_FILENAME_T("dir")); - REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(dir\\\)")) == SPDLOG_FILENAME_T(R"(dir\\)")); - REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(dir\file)")) == SPDLOG_FILENAME_T("dir")); - REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(dir/file)")) == SPDLOG_FILENAME_T("dir")); - REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(dir\file.txt)")) == SPDLOG_FILENAME_T("dir")); - REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(dir/file)")) == SPDLOG_FILENAME_T("dir")); - REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(dir\file.txt\)")) == - SPDLOG_FILENAME_T(R"(dir\file.txt)")); - REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(\dir\file.txt)")) == SPDLOG_FILENAME_T(R"(\dir)")); - REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(\\dir\file.txt)")) == SPDLOG_FILENAME_T(R"(\\dir)")); - REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(..\file.txt)")) == SPDLOG_FILENAME_T("..")); - REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(.\file.txt)")) == SPDLOG_FILENAME_T(".")); - REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(c:\\a\b\c\d\file.txt)")) == - SPDLOG_FILENAME_T(R"(c:\\a\b\c\d)")); - REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(c://a/b/c/d/file.txt)")) == - SPDLOG_FILENAME_T(R"(c://a/b/c/d)")); -#endif - REQUIRE(dir_name(SPDLOG_FILENAME_T("dir/")) == SPDLOG_FILENAME_T("dir")); - REQUIRE(dir_name(SPDLOG_FILENAME_T("dir///")) == SPDLOG_FILENAME_T("dir//")); - REQUIRE(dir_name(SPDLOG_FILENAME_T("dir/file")) == SPDLOG_FILENAME_T("dir")); - REQUIRE(dir_name(SPDLOG_FILENAME_T("dir/file.txt")) == SPDLOG_FILENAME_T("dir")); - REQUIRE(dir_name(SPDLOG_FILENAME_T("dir/file.txt/")) == SPDLOG_FILENAME_T("dir/file.txt")); - REQUIRE(dir_name(SPDLOG_FILENAME_T("/dir/file.txt")) == SPDLOG_FILENAME_T("/dir")); - REQUIRE(dir_name(SPDLOG_FILENAME_T("//dir/file.txt")) == SPDLOG_FILENAME_T("//dir")); - REQUIRE(dir_name(SPDLOG_FILENAME_T("../file.txt")) == SPDLOG_FILENAME_T("..")); - REQUIRE(dir_name(SPDLOG_FILENAME_T("./file.txt")) == SPDLOG_FILENAME_T(".")); -} - -#ifdef _WIN32 - - // - // test windows cases when drive letter is given e.g. C:\\some-folder - // - #include <windows.h> - #include <fileapi.h> - -std::string get_full_path(const std::string &relative_folder_path) { - char full_path[MAX_PATH]; - - DWORD result = ::GetFullPathNameA(relative_folder_path.c_str(), MAX_PATH, full_path, nullptr); - // Return an empty string if failed to get full path - return result > 0 && result < MAX_PATH ? std::string(full_path) : std::string(); -} - -std::wstring get_full_path(const std::wstring &relative_folder_path) { - wchar_t full_path[MAX_PATH]; - DWORD result = ::GetFullPathNameW(relative_folder_path.c_str(), MAX_PATH, full_path, nullptr); - return result > 0 && result < MAX_PATH ? std::wstring(full_path) : std::wstring(); -} - -spdlog::filename_t::value_type find_non_existing_drive() { - for (char drive = 'A'; drive <= 'Z'; ++drive) { - std::string root_path = std::string(1, drive) + ":\\"; - UINT drive_type = GetDriveTypeA(root_path.c_str()); - if (drive_type == DRIVE_NO_ROOT_DIR) { - return static_cast<spdlog::filename_t::value_type>(drive); - } - } - return '\0'; // No available drive found -} - -TEST_CASE("create_abs_path1", "[create_dir]") { - prepare_logdir(); - auto abs_path = get_full_path(SPDLOG_FILENAME_T("test_logs\\logdir1")); - REQUIRE(!abs_path.empty()); - REQUIRE(create_dir(abs_path) == true); -} - -TEST_CASE("create_abs_path2", "[create_dir]") { - prepare_logdir(); - auto abs_path = get_full_path(SPDLOG_FILENAME_T("test_logs/logdir2")); - REQUIRE(!abs_path.empty()); - REQUIRE(create_dir(abs_path) == true); -} - -TEST_CASE("non_existing_drive", "[create_dir]") { - prepare_logdir(); - spdlog::filename_t path; - - auto non_existing_drive = find_non_existing_drive(); - path += non_existing_drive; - path += SPDLOG_FILENAME_T(":\\"); - REQUIRE(create_dir(path) == false); - path += SPDLOG_FILENAME_T("subdir"); - REQUIRE(create_dir(path) == false); -} -// #endif // SPDLOG_WCHAR_FILENAMES -#endif // _WIN32 diff --git a/thirdparty/spdlog/tests/test_custom_callbacks.cpp b/thirdparty/spdlog/tests/test_custom_callbacks.cpp deleted file mode 100644 index f14572115..000000000 --- a/thirdparty/spdlog/tests/test_custom_callbacks.cpp +++ /dev/null @@ -1,37 +0,0 @@ -/* - * This content is released under the MIT License as specified in - * https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE - */ -#include "includes.h" -#include "test_sink.h" -#include "spdlog/sinks/callback_sink.h" -#include "spdlog/async.h" -#include "spdlog/common.h" - -TEST_CASE("custom_callback_logger", "[custom_callback_logger]") { - std::vector<std::string> lines; - spdlog::pattern_formatter formatter; - auto callback_logger = - std::make_shared<spdlog::sinks::callback_sink_st>([&](const spdlog::details::log_msg &msg) { - spdlog::memory_buf_t formatted; - formatter.format(msg, formatted); - auto eol_len = strlen(spdlog::details::os::default_eol); - using diff_t = - typename std::iterator_traits<decltype(formatted.end())>::difference_type; - lines.emplace_back(formatted.begin(), formatted.end() - static_cast<diff_t>(eol_len)); - }); - std::shared_ptr<spdlog::sinks::test_sink_st> test_sink(new spdlog::sinks::test_sink_st); - - spdlog::logger logger("test-callback", {callback_logger, test_sink}); - - logger.info("test message 1"); - logger.info("test message 2"); - logger.info("test message 3"); - - std::vector<std::string> ref_lines = test_sink->lines(); - - REQUIRE(lines[0] == ref_lines[0]); - REQUIRE(lines[1] == ref_lines[1]); - REQUIRE(lines[2] == ref_lines[2]); - spdlog::drop_all(); -} diff --git a/thirdparty/spdlog/tests/test_daily_logger.cpp b/thirdparty/spdlog/tests/test_daily_logger.cpp deleted file mode 100644 index 8a00c024a..000000000 --- a/thirdparty/spdlog/tests/test_daily_logger.cpp +++ /dev/null @@ -1,169 +0,0 @@ -/* - * This content is released under the MIT License as specified in - * https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE - */ -#include "includes.h" - -#ifdef SPDLOG_USE_STD_FORMAT -using filename_memory_buf_t = std::basic_string<spdlog::filename_t::value_type>; -#else -using filename_memory_buf_t = fmt::basic_memory_buffer<spdlog::filename_t::value_type, 250>; -#endif - -#ifdef SPDLOG_WCHAR_FILENAMES -std::string filename_buf_to_utf8string(const filename_memory_buf_t &w) { - spdlog::memory_buf_t buf; - spdlog::details::os::wstr_to_utf8buf(spdlog::wstring_view_t(w.data(), w.size()), buf); - return SPDLOG_BUF_TO_STRING(buf); -} -#else -std::string filename_buf_to_utf8string(const filename_memory_buf_t &w) { - return SPDLOG_BUF_TO_STRING(w); -} -#endif - -TEST_CASE("daily_logger with dateonly calculator", "[daily_logger]") { - using sink_type = - spdlog::sinks::daily_file_sink<std::mutex, spdlog::sinks::daily_filename_calculator>; - - prepare_logdir(); - - // calculate filename (time based) - spdlog::filename_t basename = SPDLOG_FILENAME_T("test_logs/daily_dateonly"); - std::tm tm = spdlog::details::os::localtime(); - filename_memory_buf_t w; - spdlog::fmt_lib::format_to(std::back_inserter(w), SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}"), - basename, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday); - - auto logger = spdlog::create<sink_type>("logger", basename, 0, 0); - for (int i = 0; i < 10; ++i) { - logger->info("Test message {}", i); - } - logger->flush(); - - require_message_count(filename_buf_to_utf8string(w), 10); -} - -struct custom_daily_file_name_calculator { - static spdlog::filename_t calc_filename(const spdlog::filename_t &basename, const tm &now_tm) { - return spdlog::fmt_lib::format(SPDLOG_FILENAME_T("{}{:04d}{:02d}{:02d}"), basename, - now_tm.tm_year + 1900, now_tm.tm_mon + 1, now_tm.tm_mday); - } -}; - -TEST_CASE("daily_logger with custom calculator", "[daily_logger]") { - using sink_type = spdlog::sinks::daily_file_sink<std::mutex, custom_daily_file_name_calculator>; - - prepare_logdir(); - - // calculate filename (time based) - spdlog::filename_t basename = SPDLOG_FILENAME_T("test_logs/daily_dateonly"); - std::tm tm = spdlog::details::os::localtime(); - filename_memory_buf_t w; - spdlog::fmt_lib::format_to(std::back_inserter(w), SPDLOG_FILENAME_T("{}{:04d}{:02d}{:02d}"), - basename, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday); - - auto logger = spdlog::create<sink_type>("logger", basename, 0, 0); - for (int i = 0; i < 10; ++i) { - logger->info("Test message {}", i); - } - - logger->flush(); - - require_message_count(filename_buf_to_utf8string(w), 10); -} - -/* - * File name calculations - */ - -TEST_CASE("rotating_file_sink::calc_filename1", "[rotating_file_sink]") { - auto filename = - spdlog::sinks::rotating_file_sink_st::calc_filename(SPDLOG_FILENAME_T("rotated.txt"), 3); - REQUIRE(filename == SPDLOG_FILENAME_T("rotated.3.txt")); -} - -TEST_CASE("rotating_file_sink::calc_filename2", "[rotating_file_sink]") { - auto filename = - spdlog::sinks::rotating_file_sink_st::calc_filename(SPDLOG_FILENAME_T("rotated"), 3); - REQUIRE(filename == SPDLOG_FILENAME_T("rotated.3")); -} - -TEST_CASE("rotating_file_sink::calc_filename3", "[rotating_file_sink]") { - auto filename = - spdlog::sinks::rotating_file_sink_st::calc_filename(SPDLOG_FILENAME_T("rotated.txt"), 0); - REQUIRE(filename == SPDLOG_FILENAME_T("rotated.txt")); -} - -// regex supported only from gcc 4.9 and above -#if defined(_MSC_VER) || !(__GNUC__ <= 4 && __GNUC_MINOR__ < 9) - - #include <regex> - -TEST_CASE("daily_file_sink::daily_filename_calculator", "[daily_file_sink]") { - // daily_YYYY-MM-DD_hh-mm.txt - auto filename = spdlog::sinks::daily_filename_calculator::calc_filename( - SPDLOG_FILENAME_T("daily.txt"), spdlog::details::os::localtime()); - // date regex based on https://www.regular-expressions.info/dates.html - std::basic_regex<spdlog::filename_t::value_type> re( - SPDLOG_FILENAME_T(R"(^daily_(19|20)\d\d-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])\.txt$)")); - std::match_results<spdlog::filename_t::const_iterator> match; - REQUIRE(std::regex_match(filename, match, re)); -} -#endif - -TEST_CASE("daily_file_sink::daily_filename_format_calculator", "[daily_file_sink]") { - std::tm tm = spdlog::details::os::localtime(); - // example-YYYY-MM-DD.log - auto filename = spdlog::sinks::daily_filename_format_calculator::calc_filename( - SPDLOG_FILENAME_T("example-%Y-%m-%d.log"), tm); - - REQUIRE(filename == - spdlog::fmt_lib::format(SPDLOG_FILENAME_T("example-{:04d}-{:02d}-{:02d}.log"), - tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday)); -} - -/* Test removal of old files */ -static spdlog::details::log_msg create_msg(std::chrono::seconds offset) { - using spdlog::log_clock; - spdlog::details::log_msg msg{"test", spdlog::level::info, "Hello Message"}; - msg.time = log_clock::now() + offset; - return msg; -} - -static void test_rotate(int days_to_run, uint16_t max_days, uint16_t expected_n_files) { - using spdlog::log_clock; - using spdlog::details::log_msg; - using spdlog::sinks::daily_file_sink_st; - - prepare_logdir(); - - spdlog::filename_t basename = SPDLOG_FILENAME_T("test_logs/daily_rotate.txt"); - daily_file_sink_st sink{basename, 2, 30, true, max_days}; - - // simulate messages with 24 intervals - - for (int i = 0; i < days_to_run; i++) { - auto offset = std::chrono::seconds{24 * 3600 * i}; - sink.log(create_msg(offset)); - } - - REQUIRE(count_files("test_logs") == static_cast<size_t>(expected_n_files)); -} - -TEST_CASE("daily_logger rotate", "[daily_file_sink]") { - int days_to_run = 1; - test_rotate(days_to_run, 0, 1); - test_rotate(days_to_run, 1, 1); - test_rotate(days_to_run, 3, 1); - test_rotate(days_to_run, 10, 1); - - days_to_run = 10; - test_rotate(days_to_run, 0, 10); - test_rotate(days_to_run, 1, 1); - test_rotate(days_to_run, 3, 3); - test_rotate(days_to_run, 9, 9); - test_rotate(days_to_run, 10, 10); - test_rotate(days_to_run, 11, 10); - test_rotate(days_to_run, 20, 10); -} diff --git a/thirdparty/spdlog/tests/test_dup_filter.cpp b/thirdparty/spdlog/tests/test_dup_filter.cpp deleted file mode 100644 index 78e22be3b..000000000 --- a/thirdparty/spdlog/tests/test_dup_filter.cpp +++ /dev/null @@ -1,83 +0,0 @@ -#include "includes.h" -#include "spdlog/sinks/dup_filter_sink.h" -#include "test_sink.h" - -TEST_CASE("dup_filter_test1", "[dup_filter_sink]") { - using spdlog::sinks::dup_filter_sink_st; - using spdlog::sinks::test_sink_mt; - - dup_filter_sink_st dup_sink{std::chrono::seconds{5}}; - auto test_sink = std::make_shared<test_sink_mt>(); - dup_sink.add_sink(test_sink); - - for (int i = 0; i < 10; i++) { - dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message1"}); - } - - REQUIRE(test_sink->msg_counter() == 1); -} - -TEST_CASE("dup_filter_test2", "[dup_filter_sink]") { - using spdlog::sinks::dup_filter_sink_st; - using spdlog::sinks::test_sink_mt; - - dup_filter_sink_st dup_sink{std::chrono::seconds{0}}; - auto test_sink = std::make_shared<test_sink_mt>(); - dup_sink.add_sink(test_sink); - - for (int i = 0; i < 10; i++) { - dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message1"}); - std::this_thread::sleep_for(std::chrono::milliseconds(5)); - } - - REQUIRE(test_sink->msg_counter() == 10); -} - -TEST_CASE("dup_filter_test3", "[dup_filter_sink]") { - using spdlog::sinks::dup_filter_sink_st; - using spdlog::sinks::test_sink_mt; - - dup_filter_sink_st dup_sink{std::chrono::seconds{1}}; - auto test_sink = std::make_shared<test_sink_mt>(); - dup_sink.add_sink(test_sink); - - for (int i = 0; i < 10; i++) { - dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message1"}); - dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message2"}); - } - - REQUIRE(test_sink->msg_counter() == 20); -} - -TEST_CASE("dup_filter_test4", "[dup_filter_sink]") { - using spdlog::sinks::dup_filter_sink_mt; - using spdlog::sinks::test_sink_mt; - - dup_filter_sink_mt dup_sink{std::chrono::milliseconds{10}}; - auto test_sink = std::make_shared<test_sink_mt>(); - dup_sink.add_sink(test_sink); - - dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message"}); - std::this_thread::sleep_for(std::chrono::milliseconds(50)); - dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message"}); - REQUIRE(test_sink->msg_counter() == 2); -} - -TEST_CASE("dup_filter_test5", "[dup_filter_sink]") { - using spdlog::sinks::dup_filter_sink_mt; - using spdlog::sinks::test_sink_mt; - - dup_filter_sink_mt dup_sink{std::chrono::seconds{5}}; - auto test_sink = std::make_shared<test_sink_mt>(); - test_sink->set_pattern("%v"); - dup_sink.add_sink(test_sink); - - dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message1"}); - dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message1"}); - dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message1"}); - dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message2"}); - - REQUIRE(test_sink->msg_counter() == - 3); // skip 2 messages but log the "skipped.." message before message2 - REQUIRE(test_sink->lines()[1] == "Skipped 2 duplicate messages.."); -} diff --git a/thirdparty/spdlog/tests/test_errors.cpp b/thirdparty/spdlog/tests/test_errors.cpp deleted file mode 100644 index 1c24cabc2..000000000 --- a/thirdparty/spdlog/tests/test_errors.cpp +++ /dev/null @@ -1,112 +0,0 @@ -/* - * This content is released under the MIT License as specified in - * https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE - */ -#include "includes.h" - -#include <iostream> - -#define SIMPLE_LOG "test_logs/simple_log.txt" -#define SIMPLE_ASYNC_LOG "test_logs/simple_async_log.txt" - -class failing_sink : public spdlog::sinks::base_sink<std::mutex> { -protected: - void sink_it_(const spdlog::details::log_msg &) final { - throw std::runtime_error("some error happened during log"); - } - - void flush_() final { throw std::runtime_error("some error happened during flush"); } -}; -struct custom_ex {}; - -#if !defined(SPDLOG_USE_STD_FORMAT) // std format doesn't fully support runtime strings -TEST_CASE("default_error_handler", "[errors]") { - prepare_logdir(); - spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG); - - auto logger = spdlog::create<spdlog::sinks::basic_file_sink_mt>("test-error", filename, true); - logger->set_pattern("%v"); - logger->info(SPDLOG_FMT_RUNTIME("Test message {} {}"), 1); - logger->info("Test message {}", 2); - logger->flush(); - using spdlog::details::os::default_eol; - REQUIRE(file_contents(SIMPLE_LOG) == spdlog::fmt_lib::format("Test message 2{}", default_eol)); - REQUIRE(count_lines(SIMPLE_LOG) == 1); -} - -TEST_CASE("custom_error_handler", "[errors]") { - prepare_logdir(); - spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG); - auto logger = spdlog::create<spdlog::sinks::basic_file_sink_mt>("logger", filename, true); - logger->flush_on(spdlog::level::info); - logger->set_error_handler([=](const std::string &) { throw custom_ex(); }); - logger->info("Good message #1"); - - REQUIRE_THROWS_AS(logger->info(SPDLOG_FMT_RUNTIME("Bad format msg {} {}"), "xxx"), custom_ex); - logger->info("Good message #2"); - require_message_count(SIMPLE_LOG, 2); -} -#endif - -TEST_CASE("default_error_handler2", "[errors]") { - spdlog::drop_all(); - auto logger = spdlog::create<failing_sink>("failed_logger"); - logger->set_error_handler([=](const std::string &) { throw custom_ex(); }); - REQUIRE_THROWS_AS(logger->info("Some message"), custom_ex); -} - -TEST_CASE("flush_error_handler", "[errors]") { - spdlog::drop_all(); - auto logger = spdlog::create<failing_sink>("failed_logger"); - logger->set_error_handler([=](const std::string &) { throw custom_ex(); }); - REQUIRE_THROWS_AS(logger->flush(), custom_ex); -} - -#if !defined(SPDLOG_USE_STD_FORMAT) -TEST_CASE("async_error_handler", "[errors]") { - prepare_logdir(); - std::string err_msg("log failed with some msg"); - - spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_ASYNC_LOG); - { - spdlog::init_thread_pool(128, 1); - auto logger = - spdlog::create_async<spdlog::sinks::basic_file_sink_mt>("logger", filename, true); - logger->set_error_handler([=](const std::string &) { - std::ofstream ofs("test_logs/custom_err.txt"); - if (!ofs) { - throw std::runtime_error("Failed open test_logs/custom_err.txt"); - } - ofs << err_msg; - }); - logger->info("Good message #1"); - logger->info(SPDLOG_FMT_RUNTIME("Bad format msg {} {}"), "xxx"); - logger->info("Good message #2"); - spdlog::drop("logger"); // force logger to drain the queue and shutdown - } - spdlog::init_thread_pool(128, 1); - require_message_count(SIMPLE_ASYNC_LOG, 2); - REQUIRE(file_contents("test_logs/custom_err.txt") == err_msg); -} -#endif - -// Make sure async error handler is executed -TEST_CASE("async_error_handler2", "[errors]") { - prepare_logdir(); - std::string err_msg("This is async handler error message"); - { - spdlog::details::os::create_dir(SPDLOG_FILENAME_T("test_logs")); - spdlog::init_thread_pool(128, 1); - auto logger = spdlog::create_async<failing_sink>("failed_logger"); - logger->set_error_handler([=](const std::string &) { - std::ofstream ofs("test_logs/custom_err2.txt"); - if (!ofs) throw std::runtime_error("Failed open test_logs/custom_err2.txt"); - ofs << err_msg; - }); - logger->info("Hello failure"); - spdlog::drop("failed_logger"); // force logger to drain the queue and shutdown - } - - spdlog::init_thread_pool(128, 1); - REQUIRE(file_contents("test_logs/custom_err2.txt") == err_msg); -} diff --git a/thirdparty/spdlog/tests/test_eventlog.cpp b/thirdparty/spdlog/tests/test_eventlog.cpp deleted file mode 100644 index 702eabea1..000000000 --- a/thirdparty/spdlog/tests/test_eventlog.cpp +++ /dev/null @@ -1,75 +0,0 @@ -#if _WIN32 - - #include "includes.h" - #include "test_sink.h" - - #include "spdlog/sinks/win_eventlog_sink.h" - -static const LPCSTR TEST_SOURCE = "spdlog_test"; - -static void test_single_print(std::function<void(std::string const &)> do_log, - std::string const &expected_contents, - WORD expected_ev_type) { - using namespace std::chrono; - do_log(expected_contents); - const auto expected_time_generated = - duration_cast<seconds>(system_clock::now().time_since_epoch()).count(); - - struct handle_t { - HANDLE handle_; - - ~handle_t() { - if (handle_) { - REQUIRE(CloseEventLog(handle_)); - } - } - } event_log{::OpenEventLogA(nullptr, TEST_SOURCE)}; - - REQUIRE(event_log.handle_); - - DWORD read_bytes{}, size_needed{}; - auto ok = ::ReadEventLogA(event_log.handle_, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_BACKWARDS_READ, - 0, &read_bytes, 0, &read_bytes, &size_needed); - REQUIRE(!ok); - REQUIRE(::GetLastError() == ERROR_INSUFFICIENT_BUFFER); - - std::vector<char> record_buffer(size_needed); - PEVENTLOGRECORD record = (PEVENTLOGRECORD)record_buffer.data(); - - ok = ::ReadEventLogA(event_log.handle_, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_BACKWARDS_READ, 0, - record, size_needed, &read_bytes, &size_needed); - REQUIRE(ok); - - REQUIRE(record->NumStrings == 1); - REQUIRE(record->EventType == expected_ev_type); - REQUIRE((expected_time_generated - record->TimeGenerated) <= 3u); - - std::string message_in_log(((char *)record + record->StringOffset)); - REQUIRE(message_in_log == expected_contents + spdlog::details::os::default_eol); -} - -TEST_CASE("eventlog", "[eventlog]") { - using namespace spdlog; - - auto test_sink = std::make_shared<sinks::win_eventlog_sink_mt>(TEST_SOURCE); - - spdlog::logger test_logger("eventlog", test_sink); - test_logger.set_level(level::trace); - - test_sink->set_pattern("%v"); - - test_single_print([&test_logger](std::string const &msg) { test_logger.trace(msg); }, - "my trace message", EVENTLOG_SUCCESS); - test_single_print([&test_logger](std::string const &msg) { test_logger.debug(msg); }, - "my debug message", EVENTLOG_SUCCESS); - test_single_print([&test_logger](std::string const &msg) { test_logger.info(msg); }, - "my info message", EVENTLOG_INFORMATION_TYPE); - test_single_print([&test_logger](std::string const &msg) { test_logger.warn(msg); }, - "my warn message", EVENTLOG_WARNING_TYPE); - test_single_print([&test_logger](std::string const &msg) { test_logger.error(msg); }, - "my error message", EVENTLOG_ERROR_TYPE); - test_single_print([&test_logger](std::string const &msg) { test_logger.critical(msg); }, - "my critical message", EVENTLOG_ERROR_TYPE); -} - -#endif //_WIN32 diff --git a/thirdparty/spdlog/tests/test_file_helper.cpp b/thirdparty/spdlog/tests/test_file_helper.cpp deleted file mode 100644 index 56ee75e3e..000000000 --- a/thirdparty/spdlog/tests/test_file_helper.cpp +++ /dev/null @@ -1,169 +0,0 @@ -/* - * This content is released under the MIT License as specified in - * https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE - */ -#include "includes.h" - -#define TEST_FILENAME "test_logs/file_helper_test.txt" - -using spdlog::details::file_helper; - -static void write_with_helper(file_helper &helper, size_t howmany) { - spdlog::memory_buf_t formatted; - spdlog::fmt_lib::format_to(std::back_inserter(formatted), "{}", std::string(howmany, '1')); - helper.write(formatted); - helper.flush(); -} - -TEST_CASE("file_helper_filename", "[file_helper::filename()]") { - prepare_logdir(); - - file_helper helper; - spdlog::filename_t target_filename = SPDLOG_FILENAME_T(TEST_FILENAME); - helper.open(target_filename); - REQUIRE(helper.filename() == target_filename); -} - -TEST_CASE("file_helper_size", "[file_helper::size()]") { - prepare_logdir(); - spdlog::filename_t target_filename = SPDLOG_FILENAME_T(TEST_FILENAME); - size_t expected_size = 123; - { - file_helper helper; - helper.open(target_filename); - write_with_helper(helper, expected_size); - REQUIRE(static_cast<size_t>(helper.size()) == expected_size); - } - REQUIRE(get_filesize(TEST_FILENAME) == expected_size); -} - -TEST_CASE("file_helper_reopen", "[file_helper::reopen()]") { - prepare_logdir(); - spdlog::filename_t target_filename = SPDLOG_FILENAME_T(TEST_FILENAME); - file_helper helper; - helper.open(target_filename); - write_with_helper(helper, 12); - REQUIRE(helper.size() == 12); - helper.reopen(true); - REQUIRE(helper.size() == 0); -} - -TEST_CASE("file_helper_reopen2", "[file_helper::reopen(false)]") { - prepare_logdir(); - spdlog::filename_t target_filename = SPDLOG_FILENAME_T(TEST_FILENAME); - size_t expected_size = 14; - file_helper helper; - helper.open(target_filename); - write_with_helper(helper, expected_size); - REQUIRE(helper.size() == expected_size); - helper.reopen(false); - REQUIRE(helper.size() == expected_size); -} - -static void test_split_ext(const spdlog::filename_t::value_type *fname, - const spdlog::filename_t::value_type *expect_base, - const spdlog::filename_t::value_type *expect_ext) { - spdlog::filename_t filename(fname); - spdlog::filename_t expected_base(expect_base); - spdlog::filename_t expected_ext(expect_ext); - - spdlog::filename_t basename; - spdlog::filename_t ext; - std::tie(basename, ext) = file_helper::split_by_extension(filename); - REQUIRE(basename == expected_base); - REQUIRE(ext == expected_ext); -} - -TEST_CASE("file_helper_split_by_extension", "[file_helper::split_by_extension()]") { - test_split_ext(SPDLOG_FILENAME_T("mylog.txt"), SPDLOG_FILENAME_T("mylog"), - SPDLOG_FILENAME_T(".txt")); - test_split_ext(SPDLOG_FILENAME_T(".mylog.txt"), SPDLOG_FILENAME_T(".mylog"), - SPDLOG_FILENAME_T(".txt")); - test_split_ext(SPDLOG_FILENAME_T(".mylog"), SPDLOG_FILENAME_T(".mylog"), SPDLOG_FILENAME_T("")); - test_split_ext(SPDLOG_FILENAME_T("/aaa/bb.d/mylog"), SPDLOG_FILENAME_T("/aaa/bb.d/mylog"), - SPDLOG_FILENAME_T("")); - test_split_ext(SPDLOG_FILENAME_T("/aaa/bb.d/mylog.txt"), SPDLOG_FILENAME_T("/aaa/bb.d/mylog"), - SPDLOG_FILENAME_T(".txt")); - test_split_ext(SPDLOG_FILENAME_T("aaa/bbb/ccc/mylog.txt"), - SPDLOG_FILENAME_T("aaa/bbb/ccc/mylog"), SPDLOG_FILENAME_T(".txt")); - test_split_ext(SPDLOG_FILENAME_T("aaa/bbb/ccc/mylog."), SPDLOG_FILENAME_T("aaa/bbb/ccc/mylog."), - SPDLOG_FILENAME_T("")); - test_split_ext(SPDLOG_FILENAME_T("aaa/bbb/ccc/.mylog.txt"), - SPDLOG_FILENAME_T("aaa/bbb/ccc/.mylog"), SPDLOG_FILENAME_T(".txt")); - test_split_ext(SPDLOG_FILENAME_T("/aaa/bbb/ccc/mylog.txt"), - SPDLOG_FILENAME_T("/aaa/bbb/ccc/mylog"), SPDLOG_FILENAME_T(".txt")); - test_split_ext(SPDLOG_FILENAME_T("/aaa/bbb/ccc/.mylog"), - SPDLOG_FILENAME_T("/aaa/bbb/ccc/.mylog"), SPDLOG_FILENAME_T("")); - test_split_ext(SPDLOG_FILENAME_T("../mylog.txt"), SPDLOG_FILENAME_T("../mylog"), - SPDLOG_FILENAME_T(".txt")); - test_split_ext(SPDLOG_FILENAME_T(".././mylog.txt"), SPDLOG_FILENAME_T(".././mylog"), - SPDLOG_FILENAME_T(".txt")); - test_split_ext(SPDLOG_FILENAME_T(".././mylog.txt/xxx"), SPDLOG_FILENAME_T(".././mylog.txt/xxx"), - SPDLOG_FILENAME_T("")); - test_split_ext(SPDLOG_FILENAME_T("/mylog.txt"), SPDLOG_FILENAME_T("/mylog"), - SPDLOG_FILENAME_T(".txt")); - test_split_ext(SPDLOG_FILENAME_T("//mylog.txt"), SPDLOG_FILENAME_T("//mylog"), - SPDLOG_FILENAME_T(".txt")); - test_split_ext(SPDLOG_FILENAME_T(""), SPDLOG_FILENAME_T(""), SPDLOG_FILENAME_T("")); - test_split_ext(SPDLOG_FILENAME_T("."), SPDLOG_FILENAME_T("."), SPDLOG_FILENAME_T("")); - test_split_ext(SPDLOG_FILENAME_T("..txt"), SPDLOG_FILENAME_T("."), SPDLOG_FILENAME_T(".txt")); -} - -TEST_CASE("file_event_handlers", "[file_helper]") { - enum class flags { before_open, after_open, before_close, after_close }; - prepare_logdir(); - - spdlog::filename_t test_filename = SPDLOG_FILENAME_T(TEST_FILENAME); - // define event handles that update vector of flags when called - std::vector<flags> events; - spdlog::file_event_handlers handlers; - handlers.before_open = [&](spdlog::filename_t filename) { - REQUIRE(filename == test_filename); - events.push_back(flags::before_open); - }; - handlers.after_open = [&](spdlog::filename_t filename, std::FILE *fstream) { - REQUIRE(filename == test_filename); - REQUIRE(fstream); - fputs("after_open\n", fstream); - events.push_back(flags::after_open); - }; - handlers.before_close = [&](spdlog::filename_t filename, std::FILE *fstream) { - REQUIRE(filename == test_filename); - REQUIRE(fstream); - fputs("before_close\n", fstream); - events.push_back(flags::before_close); - }; - handlers.after_close = [&](spdlog::filename_t filename) { - REQUIRE(filename == test_filename); - events.push_back(flags::after_close); - }; - { - spdlog::details::file_helper helper{handlers}; - REQUIRE(events.empty()); - - helper.open(test_filename); - REQUIRE(events == std::vector<flags>{flags::before_open, flags::after_open}); - - events.clear(); - helper.close(); - REQUIRE(events == std::vector<flags>{flags::before_close, flags::after_close}); - REQUIRE(file_contents(TEST_FILENAME) == "after_open\nbefore_close\n"); - - helper.reopen(true); - events.clear(); - } - // make sure that the file_helper destructor calls the close callbacks if needed - REQUIRE(events == std::vector<flags>{flags::before_close, flags::after_close}); - REQUIRE(file_contents(TEST_FILENAME) == "after_open\nbefore_close\n"); -} - -TEST_CASE("file_helper_open", "[file_helper]") { - prepare_logdir(); - spdlog::filename_t target_filename = SPDLOG_FILENAME_T(TEST_FILENAME); - file_helper helper; - helper.open(target_filename); - helper.close(); - - target_filename += SPDLOG_FILENAME_T("/invalid"); - REQUIRE_THROWS_AS(helper.open(target_filename), spdlog::spdlog_ex); -} diff --git a/thirdparty/spdlog/tests/test_file_logging.cpp b/thirdparty/spdlog/tests/test_file_logging.cpp deleted file mode 100644 index e3155effd..000000000 --- a/thirdparty/spdlog/tests/test_file_logging.cpp +++ /dev/null @@ -1,187 +0,0 @@ -/* - * This content is released under the MIT License as specified in - * https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE - */ -#include "includes.h" - -#define SIMPLE_LOG "test_logs/simple_log" -#define ROTATING_LOG "test_logs/rotating_log" - -TEST_CASE("simple_file_logger", "[simple_logger]") { - prepare_logdir(); - spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG); - - auto logger = spdlog::create<spdlog::sinks::basic_file_sink_mt>("logger", filename); - logger->set_pattern("%v"); - - logger->info("Test message {}", 1); - logger->info("Test message {}", 2); - - logger->flush(); - require_message_count(SIMPLE_LOG, 2); - using spdlog::details::os::default_eol; - REQUIRE(file_contents(SIMPLE_LOG) == - spdlog::fmt_lib::format("Test message 1{}Test message 2{}", default_eol, default_eol)); -} - -TEST_CASE("flush_on", "[flush_on]") { - prepare_logdir(); - spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG); - - auto logger = spdlog::create<spdlog::sinks::basic_file_sink_mt>("logger", filename); - logger->set_pattern("%v"); - logger->set_level(spdlog::level::trace); - logger->flush_on(spdlog::level::info); - logger->trace("Should not be flushed"); - REQUIRE(count_lines(SIMPLE_LOG) == 0); - - logger->info("Test message {}", 1); - logger->info("Test message {}", 2); - - require_message_count(SIMPLE_LOG, 3); - using spdlog::details::os::default_eol; - REQUIRE(file_contents(SIMPLE_LOG) == - spdlog::fmt_lib::format("Should not be flushed{}Test message 1{}Test message 2{}", - default_eol, default_eol, default_eol)); -} - -TEST_CASE("simple_file_logger", "[truncate]") { - prepare_logdir(); - const spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG); - const bool truncate = true; - const auto sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(filename, truncate); - const auto logger = std::make_shared<spdlog::logger>("simple_file_logger", sink); - - logger->info("Test message {}", 3.14); - logger->info("Test message {}", 2.71); - logger->flush(); - REQUIRE(count_lines(SIMPLE_LOG) == 2); - - sink->truncate(); - REQUIRE(count_lines(SIMPLE_LOG) == 0); - - logger->info("Test message {}", 6.28); - logger->flush(); - REQUIRE(count_lines(SIMPLE_LOG) == 1); -} - -TEST_CASE("rotating_file_logger1", "[rotating_logger]") { - prepare_logdir(); - size_t max_size = 1024 * 10; - spdlog::filename_t basename = SPDLOG_FILENAME_T(ROTATING_LOG); - auto logger = spdlog::rotating_logger_mt("logger", basename, max_size, 0); - - for (int i = 0; i < 10; ++i) { - logger->info("Test message {}", i); - } - - logger->flush(); - require_message_count(ROTATING_LOG, 10); -} - -TEST_CASE("rotating_file_logger2", "[rotating_logger]") { - prepare_logdir(); - size_t max_size = 1024 * 10; - spdlog::filename_t basename = SPDLOG_FILENAME_T(ROTATING_LOG); - - { - // make an initial logger to create the first output file - auto logger = spdlog::rotating_logger_mt("logger", basename, max_size, 2, true); - for (int i = 0; i < 10; ++i) { - logger->info("Test message {}", i); - } - // drop causes the logger destructor to be called, which is required so the - // next logger can rename the first output file. - spdlog::drop(logger->name()); - } - auto logger = spdlog::rotating_logger_mt("logger", basename, max_size, 2, true); - for (int i = 0; i < 10; ++i) { - logger->info("Test message {}", i); - } - logger->flush(); - require_message_count(ROTATING_LOG, 10); - - for (int i = 0; i < 1000; i++) { - logger->info("Test message {}", i); - } - - logger->flush(); - REQUIRE(get_filesize(ROTATING_LOG) <= max_size); - REQUIRE(get_filesize(ROTATING_LOG ".1") <= max_size); -} - -// test that passing max_size=0 throws -TEST_CASE("rotating_file_logger3", "[rotating_logger]") { - prepare_logdir(); - size_t max_size = 0; - spdlog::filename_t basename = SPDLOG_FILENAME_T(ROTATING_LOG); - REQUIRE_THROWS_AS(spdlog::rotating_logger_mt("logger", basename, max_size, 0), - spdlog::spdlog_ex); -} - -// test on-demand rotation of logs -TEST_CASE("rotating_file_logger4", "[rotating_logger]") { - prepare_logdir(); - size_t max_size = 1024 * 10; - spdlog::filename_t basename = SPDLOG_FILENAME_T(ROTATING_LOG); - auto sink = std::make_shared<spdlog::sinks::rotating_file_sink_st>(basename, max_size, 2); - auto logger = std::make_shared<spdlog::logger>("rotating_sink_logger", sink); - - logger->info("Test message - pre-rotation"); - logger->flush(); - - sink->rotate_now(); - - logger->info("Test message - post-rotation"); - logger->flush(); - - REQUIRE(get_filesize(ROTATING_LOG) > 0); - REQUIRE(get_filesize(ROTATING_LOG ".1") > 0); -} - -// test changing the max size of the rotating file sink -TEST_CASE("rotating_file_logger5", "[rotating_logger]") { - prepare_logdir(); - size_t max_size = 5 * 1024; - size_t max_files = 2; - spdlog::filename_t basename = SPDLOG_FILENAME_T(ROTATING_LOG); - auto sink = - std::make_shared<spdlog::sinks::rotating_file_sink_st>(basename, max_size, max_files); - auto logger = std::make_shared<spdlog::logger>("rotating_sink_logger", sink); - logger->set_pattern("%v"); - - REQUIRE(sink->get_max_size() == max_size); - REQUIRE(sink->get_max_files() == max_files); - max_size = 7 * 1024; - max_files = 3; - - sink->set_max_size(max_size); - sink->set_max_files(max_files); - REQUIRE(sink->get_max_size() == max_size); - REQUIRE(sink->get_max_files() == max_files); - - const auto message = std::string(200, 'x'); - assert(message.size() < max_size); - const auto n_messages = max_files * max_size / message.size(); - for (size_t i = 0; i < n_messages; ++i) { - logger->info(message); - } - logger.reset(); // force flush and close the file - - // validate that the files were rotated correctly with the new max size and max files - for (size_t i = 0; i <= max_files; i++) { - // calc filenames - // e.g. rotating_log, rotating_log.0 rotating_log.1, rotating_log.2, etc. - std::ostringstream oss; - oss << ROTATING_LOG; - if (i > 0) { - oss << '.' << i; - } - const auto filename = oss.str(); - const auto filesize = get_filesize(filename); - REQUIRE(filesize <= max_size); - if (i > 0) { - REQUIRE(filesize >= max_size - message.size() - 2); - } - } -} diff --git a/thirdparty/spdlog/tests/test_fmt_helper.cpp b/thirdparty/spdlog/tests/test_fmt_helper.cpp deleted file mode 100644 index 31b930672..000000000 --- a/thirdparty/spdlog/tests/test_fmt_helper.cpp +++ /dev/null @@ -1,82 +0,0 @@ - -#include "includes.h" - -using spdlog::memory_buf_t; -using spdlog::details::to_string_view; - -void test_pad2(int n, const char *expected) { - memory_buf_t buf; - spdlog::details::fmt_helper::pad2(n, buf); - - REQUIRE(to_string_view(buf) == expected); -} - -void test_pad3(uint32_t n, const char *expected) { - memory_buf_t buf; - spdlog::details::fmt_helper::pad3(n, buf); - - REQUIRE(to_string_view(buf) == expected); -} - -void test_pad6(std::size_t n, const char *expected) { - memory_buf_t buf; - spdlog::details::fmt_helper::pad6(n, buf); - - REQUIRE(to_string_view(buf) == expected); -} - -void test_pad9(std::size_t n, const char *expected) { - memory_buf_t buf; - spdlog::details::fmt_helper::pad9(n, buf); - - REQUIRE(to_string_view(buf) == expected); -} - -TEST_CASE("pad2", "[fmt_helper]") { - test_pad2(0, "00"); - test_pad2(3, "03"); - test_pad2(10, "10"); - test_pad2(23, "23"); - test_pad2(99, "99"); - test_pad2(100, "100"); - test_pad2(123, "123"); - test_pad2(1234, "1234"); - test_pad2(-5, "-5"); -} - -TEST_CASE("pad3", "[fmt_helper]") { - test_pad3(0, "000"); - test_pad3(3, "003"); - test_pad3(10, "010"); - test_pad3(23, "023"); - test_pad3(99, "099"); - test_pad3(100, "100"); - test_pad3(123, "123"); - test_pad3(999, "999"); - test_pad3(1000, "1000"); - test_pad3(1234, "1234"); -} - -TEST_CASE("pad6", "[fmt_helper]") { - test_pad6(0, "000000"); - test_pad6(3, "000003"); - test_pad6(23, "000023"); - test_pad6(123, "000123"); - test_pad6(1234, "001234"); - test_pad6(12345, "012345"); - test_pad6(123456, "123456"); -} - -TEST_CASE("pad9", "[fmt_helper]") { - test_pad9(0, "000000000"); - test_pad9(3, "000000003"); - test_pad9(23, "000000023"); - test_pad9(123, "000000123"); - test_pad9(1234, "000001234"); - test_pad9(12345, "000012345"); - test_pad9(123456, "000123456"); - test_pad9(1234567, "001234567"); - test_pad9(12345678, "012345678"); - test_pad9(123456789, "123456789"); - test_pad9(1234567891, "1234567891"); -} diff --git a/thirdparty/spdlog/tests/test_macros.cpp b/thirdparty/spdlog/tests/test_macros.cpp deleted file mode 100644 index 132706f13..000000000 --- a/thirdparty/spdlog/tests/test_macros.cpp +++ /dev/null @@ -1,53 +0,0 @@ -/* - * This content is released under the MIT License as specified in - * https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE - */ - -#include "includes.h" - -#if SPDLOG_ACTIVE_LEVEL != SPDLOG_LEVEL_DEBUG - #error "Invalid SPDLOG_ACTIVE_LEVEL in test. Should be SPDLOG_LEVEL_DEBUG" -#endif - -#define TEST_FILENAME "test_logs/simple_log" - -TEST_CASE("debug and trace w/o format string", "[macros]") { - prepare_logdir(); - spdlog::filename_t filename = SPDLOG_FILENAME_T(TEST_FILENAME); - - auto logger = spdlog::create<spdlog::sinks::basic_file_sink_mt>("logger", filename); - logger->set_pattern("%v"); - logger->set_level(spdlog::level::trace); - - SPDLOG_LOGGER_TRACE(logger, "Test message 1"); - SPDLOG_LOGGER_DEBUG(logger, "Test message 2"); - logger->flush(); - - using spdlog::details::os::default_eol; - REQUIRE(ends_with(file_contents(TEST_FILENAME), - spdlog::fmt_lib::format("Test message 2{}", default_eol))); - REQUIRE(count_lines(TEST_FILENAME) == 1); - - auto orig_default_logger = spdlog::default_logger(); - spdlog::set_default_logger(logger); - - SPDLOG_TRACE("Test message 3"); - SPDLOG_DEBUG("Test message {}", 4); - logger->flush(); - - require_message_count(TEST_FILENAME, 2); - REQUIRE(ends_with(file_contents(TEST_FILENAME), - spdlog::fmt_lib::format("Test message 4{}", default_eol))); - spdlog::set_default_logger(std::move(orig_default_logger)); -} - -TEST_CASE("disable param evaluation", "[macros]") { - SPDLOG_TRACE("Test message {}", throw std::runtime_error("Should not be evaluated")); -} - -TEST_CASE("pass logger pointer", "[macros]") { - auto logger = spdlog::create<spdlog::sinks::null_sink_mt>("refmacro"); - auto &ref = *logger; - SPDLOG_LOGGER_TRACE(&ref, "Test message 1"); - SPDLOG_LOGGER_DEBUG(&ref, "Test message 2"); -} diff --git a/thirdparty/spdlog/tests/test_misc.cpp b/thirdparty/spdlog/tests/test_misc.cpp deleted file mode 100644 index deb18e745..000000000 --- a/thirdparty/spdlog/tests/test_misc.cpp +++ /dev/null @@ -1,224 +0,0 @@ -#ifdef _WIN32 // to prevent fopen warning on windows - #define _CRT_SECURE_NO_WARNINGS -#endif - -#include "includes.h" -#include "test_sink.h" - -template <class T> -std::string log_info(const T& what, spdlog::level::level_enum logger_level = spdlog::level::info) { - std::ostringstream oss; - auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss); - - spdlog::logger oss_logger("oss", oss_sink); - oss_logger.set_level(logger_level); - oss_logger.set_pattern("%v"); - oss_logger.info(what); - - return oss.str().substr(0, oss.str().length() - strlen(spdlog::details::os::default_eol)); -} - -TEST_CASE("basic_logging ", "[basic_logging]") { - // const char - REQUIRE(log_info("Hello") == "Hello"); - REQUIRE(log_info("").empty()); - - // std::string - REQUIRE(log_info(std::string("Hello")) == "Hello"); - REQUIRE(log_info(std::string()).empty()); - - // Numbers - REQUIRE(log_info(5) == "5"); - REQUIRE(log_info(5.6) == "5.6"); - - // User defined class - // REQUIRE(log_info(some_logged_class("some_val")) == "some_val"); -} - -TEST_CASE("log_levels", "[log_levels]") { - REQUIRE(log_info("Hello", spdlog::level::err).empty()); - REQUIRE(log_info("Hello", spdlog::level::critical).empty()); - REQUIRE(log_info("Hello", spdlog::level::info) == "Hello"); - REQUIRE(log_info("Hello", spdlog::level::debug) == "Hello"); - REQUIRE(log_info("Hello", spdlog::level::trace) == "Hello"); -} - -TEST_CASE("level_to_string_view", "[convert_to_string_view]") { - REQUIRE(spdlog::level::to_string_view(spdlog::level::trace) == "trace"); - REQUIRE(spdlog::level::to_string_view(spdlog::level::debug) == "debug"); - REQUIRE(spdlog::level::to_string_view(spdlog::level::info) == "info"); - REQUIRE(spdlog::level::to_string_view(spdlog::level::warn) == "warning"); - REQUIRE(spdlog::level::to_string_view(spdlog::level::err) == "error"); - REQUIRE(spdlog::level::to_string_view(spdlog::level::critical) == "critical"); - REQUIRE(spdlog::level::to_string_view(spdlog::level::off) == "off"); -} - -TEST_CASE("to_short_c_str", "[convert_to_short_c_str]") { - REQUIRE(std::string(spdlog::level::to_short_c_str(spdlog::level::trace)) == "T"); - REQUIRE(std::string(spdlog::level::to_short_c_str(spdlog::level::debug)) == "D"); - REQUIRE(std::string(spdlog::level::to_short_c_str(spdlog::level::info)) == "I"); - REQUIRE(std::string(spdlog::level::to_short_c_str(spdlog::level::warn)) == "W"); - REQUIRE(std::string(spdlog::level::to_short_c_str(spdlog::level::err)) == "E"); - REQUIRE(std::string(spdlog::level::to_short_c_str(spdlog::level::critical)) == "C"); - REQUIRE(std::string(spdlog::level::to_short_c_str(spdlog::level::off)) == "O"); -} - -TEST_CASE("to_level_enum", "[convert_to_level_enum]") { - REQUIRE(spdlog::level::from_str("trace") == spdlog::level::trace); - REQUIRE(spdlog::level::from_str("debug") == spdlog::level::debug); - REQUIRE(spdlog::level::from_str("info") == spdlog::level::info); - REQUIRE(spdlog::level::from_str("warning") == spdlog::level::warn); - REQUIRE(spdlog::level::from_str("warn") == spdlog::level::warn); - REQUIRE(spdlog::level::from_str("error") == spdlog::level::err); - REQUIRE(spdlog::level::from_str("critical") == spdlog::level::critical); - REQUIRE(spdlog::level::from_str("off") == spdlog::level::off); - REQUIRE(spdlog::level::from_str("null") == spdlog::level::off); -} - -TEST_CASE("periodic flush", "[periodic_flush]") { - using spdlog::sinks::test_sink_mt; - auto logger = spdlog::create<test_sink_mt>("periodic_flush"); - auto test_sink = std::static_pointer_cast<test_sink_mt>(logger->sinks()[0]); - - spdlog::flush_every(std::chrono::seconds(1)); - std::this_thread::sleep_for(std::chrono::milliseconds(1250)); - REQUIRE(test_sink->flush_counter() == 1); - spdlog::flush_every(std::chrono::seconds(0)); - spdlog::drop_all(); -} - -TEST_CASE("clone-logger", "[clone]") { - using spdlog::sinks::test_sink_mt; - auto test_sink = std::make_shared<test_sink_mt>(); - auto logger = std::make_shared<spdlog::logger>("orig", test_sink); - logger->set_pattern("%v"); - auto cloned = logger->clone("clone"); - - REQUIRE(cloned->name() == "clone"); - REQUIRE(logger->sinks() == cloned->sinks()); - REQUIRE(logger->level() == cloned->level()); - REQUIRE(logger->flush_level() == cloned->flush_level()); - logger->info("Some message 1"); - cloned->info("Some message 2"); - - REQUIRE(test_sink->lines().size() == 2); - REQUIRE(test_sink->lines()[0] == "Some message 1"); - REQUIRE(test_sink->lines()[1] == "Some message 2"); - - spdlog::drop_all(); -} - -TEST_CASE("clone async", "[clone]") { - using spdlog::sinks::test_sink_mt; - spdlog::init_thread_pool(4, 1); - auto test_sink = std::make_shared<test_sink_mt>(); - auto logger = std::make_shared<spdlog::async_logger>("orig", test_sink, spdlog::thread_pool()); - logger->set_pattern("%v"); - auto cloned = logger->clone("clone"); - - REQUIRE(cloned->name() == "clone"); - REQUIRE(logger->sinks() == cloned->sinks()); - REQUIRE(logger->level() == cloned->level()); - REQUIRE(logger->flush_level() == cloned->flush_level()); - - logger->info("Some message 1"); - cloned->info("Some message 2"); - - spdlog::details::os::sleep_for_millis(100); - - REQUIRE(test_sink->lines().size() == 2); - REQUIRE(test_sink->lines()[0] == "Some message 1"); - REQUIRE(test_sink->lines()[1] == "Some message 2"); - - spdlog::drop_all(); -} - -TEST_CASE("default logger API", "[default logger]") { - std::ostringstream oss; - auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss); - - spdlog::set_default_logger(std::make_shared<spdlog::logger>("oss", oss_sink)); - spdlog::set_pattern("*** %v"); - - spdlog::default_logger()->set_level(spdlog::level::trace); - spdlog::trace("hello trace"); - REQUIRE(oss.str() == "*** hello trace" + std::string(spdlog::details::os::default_eol)); - - oss.str(""); - spdlog::debug("hello debug"); - REQUIRE(oss.str() == "*** hello debug" + std::string(spdlog::details::os::default_eol)); - - oss.str(""); - spdlog::info("Hello"); - REQUIRE(oss.str() == "*** Hello" + std::string(spdlog::details::os::default_eol)); - - oss.str(""); - spdlog::warn("Hello again {}", 2); - REQUIRE(oss.str() == "*** Hello again 2" + std::string(spdlog::details::os::default_eol)); - - oss.str(""); - spdlog::error(123); - REQUIRE(oss.str() == "*** 123" + std::string(spdlog::details::os::default_eol)); - - oss.str(""); - spdlog::critical(std::string("some string")); - REQUIRE(oss.str() == "*** some string" + std::string(spdlog::details::os::default_eol)); - - oss.str(""); - spdlog::set_level(spdlog::level::info); - spdlog::debug("should not be logged"); - REQUIRE(oss.str().empty()); - spdlog::drop_all(); - spdlog::set_pattern("%v"); -} - -#if (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32) -TEST_CASE("utf8 to utf16 conversion using windows api", "[windows utf]") { - spdlog::wmemory_buf_t buffer; - - spdlog::details::os::utf8_to_wstrbuf("", buffer); - REQUIRE(std::wstring(buffer.data(), buffer.size()) == std::wstring(L"")); - - spdlog::details::os::utf8_to_wstrbuf("abc", buffer); - REQUIRE(std::wstring(buffer.data(), buffer.size()) == std::wstring(L"abc")); - - spdlog::details::os::utf8_to_wstrbuf("\xc3\x28", buffer); // Invalid UTF-8 sequence. - REQUIRE(std::wstring(buffer.data(), buffer.size()) == std::wstring(L"\xfffd(")); - - spdlog::details::os::utf8_to_wstrbuf("\xe3\x81\xad\xe3\x81\x93", - buffer); // "Neko" in hiragana. - REQUIRE(std::wstring(buffer.data(), buffer.size()) == std::wstring(L"\x306d\x3053")); -} -#endif - -struct auto_closer { - FILE* fp = nullptr; - explicit auto_closer(FILE* f) - : fp(f) {} - auto_closer(const auto_closer&) = delete; - auto_closer& operator=(const auto_closer&) = delete; - ~auto_closer() { - if (fp != nullptr) (void)std::fclose(fp); - } -}; - -TEST_CASE("os::fwrite_bytes", "[os]") { - using spdlog::details::os::create_dir; - using spdlog::details::os::fwrite_bytes; - const char* filename = "log_tests/test_fwrite_bytes.txt"; - const char* msg = "hello"; - prepare_logdir(); - REQUIRE(create_dir(SPDLOG_FILENAME_T("log_tests")) == true); - { - auto_closer closer(std::fopen(filename, "wb")); - REQUIRE(closer.fp != nullptr); - REQUIRE(fwrite_bytes(msg, std::strlen(msg), closer.fp) == true); - REQUIRE(fwrite_bytes(msg, 0, closer.fp) == true); - std::fflush(closer.fp); - REQUIRE(spdlog::details::os::filesize(closer.fp) == 5); - } - // fwrite_bytes should return false on write failure - auto_closer closer(std::fopen(filename, "r")); - REQUIRE(closer.fp != nullptr); - REQUIRE_FALSE(fwrite_bytes("Hello", 5, closer.fp)); -} diff --git a/thirdparty/spdlog/tests/test_mpmc_q.cpp b/thirdparty/spdlog/tests/test_mpmc_q.cpp deleted file mode 100644 index bc7a37d9c..000000000 --- a/thirdparty/spdlog/tests/test_mpmc_q.cpp +++ /dev/null @@ -1,114 +0,0 @@ -#include "includes.h" - -using std::chrono::milliseconds; -using test_clock = std::chrono::high_resolution_clock; - -static milliseconds millis_from(const test_clock::time_point &tp0) { - return std::chrono::duration_cast<milliseconds>(test_clock::now() - tp0); -} -TEST_CASE("dequeue-empty-nowait", "[mpmc_blocking_q]") { - size_t q_size = 100; - milliseconds tolerance_wait(20); - spdlog::details::mpmc_blocking_queue<int> q(q_size); - int popped_item = 0; - - auto start = test_clock::now(); - auto rv = q.dequeue_for(popped_item, milliseconds::zero()); - auto delta_ms = millis_from(start); - - REQUIRE(rv == false); - INFO("Delta " << delta_ms.count() << " millis"); - REQUIRE(delta_ms <= tolerance_wait); -} - -TEST_CASE("dequeue-empty-wait", "[mpmc_blocking_q]") { - size_t q_size = 100; - milliseconds wait_ms(250); - milliseconds tolerance_wait(250); - - spdlog::details::mpmc_blocking_queue<int> q(q_size); - int popped_item = 0; - auto start = test_clock::now(); - auto rv = q.dequeue_for(popped_item, wait_ms); - auto delta_ms = millis_from(start); - - REQUIRE(rv == false); - - INFO("Delta " << delta_ms.count() << " millis"); - REQUIRE(delta_ms >= wait_ms - tolerance_wait); - REQUIRE(delta_ms <= wait_ms + tolerance_wait); -} - -TEST_CASE("dequeue-full-nowait", "[mpmc_blocking_q]") { - spdlog::details::mpmc_blocking_queue<int> q(1); - q.enqueue(42); - - int item = 0; - q.dequeue_for(item, milliseconds::zero()); - REQUIRE(item == 42); -} - -TEST_CASE("dequeue-full-wait", "[mpmc_blocking_q]") { - spdlog::details::mpmc_blocking_queue<int> q(1); - q.enqueue(42); - - int item = 0; - q.dequeue(item); - REQUIRE(item == 42); -} - -TEST_CASE("enqueue_nowait", "[mpmc_blocking_q]") { - size_t q_size = 1; - spdlog::details::mpmc_blocking_queue<int> q(q_size); - milliseconds tolerance_wait(10); - - q.enqueue(1); - REQUIRE(q.overrun_counter() == 0); - - auto start = test_clock::now(); - q.enqueue_nowait(2); - auto delta_ms = millis_from(start); - - INFO("Delta " << delta_ms.count() << " millis"); - REQUIRE(delta_ms <= tolerance_wait); - REQUIRE(q.overrun_counter() == 1); -} - -TEST_CASE("bad_queue", "[mpmc_blocking_q]") { - size_t q_size = 0; - spdlog::details::mpmc_blocking_queue<int> q(q_size); - q.enqueue_nowait(1); - REQUIRE(q.overrun_counter() == 1); - int i = 0; - REQUIRE(q.dequeue_for(i, milliseconds(0)) == false); -} - -TEST_CASE("empty_queue", "[mpmc_blocking_q]") { - size_t q_size = 10; - spdlog::details::mpmc_blocking_queue<int> q(q_size); - int i = 0; - REQUIRE(q.dequeue_for(i, milliseconds(10)) == false); -} - -TEST_CASE("full_queue", "[mpmc_blocking_q]") { - size_t q_size = 100; - spdlog::details::mpmc_blocking_queue<int> q(q_size); - for (int i = 0; i < static_cast<int>(q_size); i++) { - q.enqueue(i + 0); // i+0 to force rvalue and avoid tidy warnings on the same time if we - // std::move(i) instead - } - - q.enqueue_nowait(123456); - REQUIRE(q.overrun_counter() == 1); - - for (int i = 1; i < static_cast<int>(q_size); i++) { - int item = -1; - q.dequeue(item); - REQUIRE(item == i); - } - - // last item pushed has overridden the oldest. - int item = -1; - q.dequeue(item); - REQUIRE(item == 123456); -} diff --git a/thirdparty/spdlog/tests/test_pattern_formatter.cpp b/thirdparty/spdlog/tests/test_pattern_formatter.cpp deleted file mode 100644 index 17a1bbcb5..000000000 --- a/thirdparty/spdlog/tests/test_pattern_formatter.cpp +++ /dev/null @@ -1,660 +0,0 @@ -#include "includes.h" -#include "test_sink.h" - -#include <chrono> - -using spdlog::memory_buf_t; -using spdlog::details::to_string_view; - -// log to str and return it -template <typename... Args> -static std::string log_to_str(const std::string &msg, const Args &...args) { - std::ostringstream oss; - auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss); - spdlog::logger oss_logger("pattern_tester", oss_sink); - oss_logger.set_level(spdlog::level::info); - - oss_logger.set_formatter( - std::unique_ptr<spdlog::formatter>(new spdlog::pattern_formatter(args...))); - - oss_logger.info(msg); - return oss.str(); -} - -// log to str and return it with time -template <typename... Args> -static std::string log_to_str_with_time(spdlog::log_clock::time_point log_time, - const std::string &msg, - const Args &...args) { - std::ostringstream oss; - auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss); - spdlog::logger oss_logger("pattern_tester", oss_sink); - oss_logger.set_level(spdlog::level::info); - - oss_logger.set_formatter( - std::unique_ptr<spdlog::formatter>(new spdlog::pattern_formatter(args...))); - - oss_logger.log(log_time, {}, spdlog::level::info, msg); - return oss.str(); -} - -TEST_CASE("custom eol", "[pattern_formatter]") { - std::string msg = "Hello custom eol test"; - std::string eol = ";)"; - REQUIRE(log_to_str(msg, "%v", spdlog::pattern_time_type::local, ";)") == msg + eol); -} - -TEST_CASE("empty format", "[pattern_formatter]") { - REQUIRE(log_to_str("Some message", "", spdlog::pattern_time_type::local, "").empty()); -} - -TEST_CASE("empty format2", "[pattern_formatter]") { - REQUIRE(log_to_str("Some message", "", spdlog::pattern_time_type::local, "\n") == "\n"); -} - -TEST_CASE("level", "[pattern_formatter]") { - REQUIRE(log_to_str("Some message", "[%l] %v", spdlog::pattern_time_type::local, "\n") == - "[info] Some message\n"); -} - -TEST_CASE("short level", "[pattern_formatter]") { - REQUIRE(log_to_str("Some message", "[%L] %v", spdlog::pattern_time_type::local, "\n") == - "[I] Some message\n"); -} - -TEST_CASE("name", "[pattern_formatter]") { - REQUIRE(log_to_str("Some message", "[%n] %v", spdlog::pattern_time_type::local, "\n") == - "[pattern_tester] Some message\n"); -} - -TEST_CASE("date MM/DD/YY ", "[pattern_formatter]") { - auto now_tm = spdlog::details::os::localtime(); - std::stringstream oss; - oss << std::setfill('0') << std::setw(2) << now_tm.tm_mon + 1 << "/" << std::setw(2) - << now_tm.tm_mday << "/" << std::setw(2) << (now_tm.tm_year + 1900) % 1000 - << " Some message\n"; - REQUIRE(log_to_str("Some message", "%D %v", spdlog::pattern_time_type::local, "\n") == - oss.str()); -} - -TEST_CASE("GMT offset ", "[pattern_formatter]") { - using namespace std::chrono_literals; - const auto now = std::chrono::system_clock::now(); - const auto yesterday = now - 24h; - - REQUIRE(log_to_str_with_time(yesterday, "Some message", "%z", spdlog::pattern_time_type::utc, - "\n") == "+00:00\n"); -} - -TEST_CASE("color range test1", "[pattern_formatter]") { - auto formatter = std::make_shared<spdlog::pattern_formatter>( - "%^%v%$", spdlog::pattern_time_type::local, "\n"); - - memory_buf_t buf; - spdlog::fmt_lib::format_to(std::back_inserter(buf), "Hello"); - memory_buf_t formatted; - std::string logger_name = "test"; - spdlog::details::log_msg msg(logger_name, spdlog::level::info, - spdlog::string_view_t(buf.data(), buf.size())); - formatter->format(msg, formatted); - REQUIRE(msg.color_range_start == 0); - REQUIRE(msg.color_range_end == 5); - REQUIRE(log_to_str("hello", "%^%v%$", spdlog::pattern_time_type::local, "\n") == "hello\n"); -} - -TEST_CASE("color range test2", "[pattern_formatter]") { - auto formatter = - std::make_shared<spdlog::pattern_formatter>("%^%$", spdlog::pattern_time_type::local, "\n"); - std::string logger_name = "test"; - spdlog::details::log_msg msg(logger_name, spdlog::level::info, ""); - memory_buf_t formatted; - formatter->format(msg, formatted); - REQUIRE(msg.color_range_start == 0); - REQUIRE(msg.color_range_end == 0); - REQUIRE(log_to_str("", "%^%$", spdlog::pattern_time_type::local, "\n") == "\n"); -} - -TEST_CASE("color range test3", "[pattern_formatter]") { - auto formatter = std::make_shared<spdlog::pattern_formatter>("%^***%$"); - std::string logger_name = "test"; - spdlog::details::log_msg msg(logger_name, spdlog::level::info, "ignored"); - memory_buf_t formatted; - formatter->format(msg, formatted); - REQUIRE(msg.color_range_start == 0); - REQUIRE(msg.color_range_end == 3); -} - -TEST_CASE("color range test4", "[pattern_formatter]") { - auto formatter = std::make_shared<spdlog::pattern_formatter>( - "XX%^YYY%$", spdlog::pattern_time_type::local, "\n"); - std::string logger_name = "test"; - spdlog::details::log_msg msg(logger_name, spdlog::level::info, "ignored"); - - memory_buf_t formatted; - formatter->format(msg, formatted); - REQUIRE(msg.color_range_start == 2); - REQUIRE(msg.color_range_end == 5); - REQUIRE(log_to_str("ignored", "XX%^YYY%$", spdlog::pattern_time_type::local, "\n") == - "XXYYY\n"); -} - -TEST_CASE("color range test5", "[pattern_formatter]") { - auto formatter = std::make_shared<spdlog::pattern_formatter>("**%^"); - std::string logger_name = "test"; - spdlog::details::log_msg msg(logger_name, spdlog::level::info, "ignored"); - memory_buf_t formatted; - formatter->format(msg, formatted); - REQUIRE(msg.color_range_start == 2); - REQUIRE(msg.color_range_end == 0); -} - -TEST_CASE("color range test6", "[pattern_formatter]") { - auto formatter = std::make_shared<spdlog::pattern_formatter>("**%$"); - std::string logger_name = "test"; - spdlog::details::log_msg msg(logger_name, spdlog::level::info, "ignored"); - memory_buf_t formatted; - formatter->format(msg, formatted); - REQUIRE(msg.color_range_start == 0); - REQUIRE(msg.color_range_end == 2); -} - -// -// Test padding -// - -TEST_CASE("level_left_padded", "[pattern_formatter]") { - REQUIRE(log_to_str("Some message", "[%8l] %v", spdlog::pattern_time_type::local, "\n") == - "[ info] Some message\n"); - REQUIRE(log_to_str("Some message", "[%8!l] %v", spdlog::pattern_time_type::local, "\n") == - "[ info] Some message\n"); -} - -TEST_CASE("level_right_padded", "[pattern_formatter]") { - REQUIRE(log_to_str("Some message", "[%-8l] %v", spdlog::pattern_time_type::local, "\n") == - "[info ] Some message\n"); - REQUIRE(log_to_str("Some message", "[%-8!l] %v", spdlog::pattern_time_type::local, "\n") == - "[info ] Some message\n"); -} - -TEST_CASE("level_center_padded", "[pattern_formatter]") { - REQUIRE(log_to_str("Some message", "[%=8l] %v", spdlog::pattern_time_type::local, "\n") == - "[ info ] Some message\n"); - REQUIRE(log_to_str("Some message", "[%=8!l] %v", spdlog::pattern_time_type::local, "\n") == - "[ info ] Some message\n"); -} - -TEST_CASE("short level_left_padded", "[pattern_formatter]") { - REQUIRE(log_to_str("Some message", "[%3L] %v", spdlog::pattern_time_type::local, "\n") == - "[ I] Some message\n"); - REQUIRE(log_to_str("Some message", "[%3!L] %v", spdlog::pattern_time_type::local, "\n") == - "[ I] Some message\n"); -} - -TEST_CASE("short level_right_padded", "[pattern_formatter]") { - REQUIRE(log_to_str("Some message", "[%-3L] %v", spdlog::pattern_time_type::local, "\n") == - "[I ] Some message\n"); - REQUIRE(log_to_str("Some message", "[%-3!L] %v", spdlog::pattern_time_type::local, "\n") == - "[I ] Some message\n"); -} - -TEST_CASE("short level_center_padded", "[pattern_formatter]") { - REQUIRE(log_to_str("Some message", "[%=3L] %v", spdlog::pattern_time_type::local, "\n") == - "[ I ] Some message\n"); - REQUIRE(log_to_str("Some message", "[%=3!L] %v", spdlog::pattern_time_type::local, "\n") == - "[ I ] Some message\n"); -} - -TEST_CASE("left_padded_short", "[pattern_formatter]") { - REQUIRE(log_to_str("Some message", "[%3n] %v", spdlog::pattern_time_type::local, "\n") == - "[pattern_tester] Some message\n"); - REQUIRE(log_to_str("Some message", "[%3!n] %v", spdlog::pattern_time_type::local, "\n") == - "[pat] Some message\n"); -} - -TEST_CASE("right_padded_short", "[pattern_formatter]") { - REQUIRE(log_to_str("Some message", "[%-3n] %v", spdlog::pattern_time_type::local, "\n") == - "[pattern_tester] Some message\n"); - REQUIRE(log_to_str("Some message", "[%-3!n] %v", spdlog::pattern_time_type::local, "\n") == - "[pat] Some message\n"); -} - -TEST_CASE("center_padded_short", "[pattern_formatter]") { - REQUIRE(log_to_str("Some message", "[%=3n] %v", spdlog::pattern_time_type::local, "\n") == - "[pattern_tester] Some message\n"); - REQUIRE(log_to_str("Some message", "[%=3!n] %v", spdlog::pattern_time_type::local, "\n") == - "[pat] Some message\n"); -} - -TEST_CASE("left_padded_huge", "[pattern_formatter]") { - REQUIRE(log_to_str("Some message", "[%-300n] %v", spdlog::pattern_time_type::local, "\n") == - "[pattern_tester ] Some message\n"); - - REQUIRE(log_to_str("Some message", "[%-300!n] %v", spdlog::pattern_time_type::local, "\n") == - "[pattern_tester ] Some message\n"); -} - -TEST_CASE("left_padded_max", "[pattern_formatter]") { - REQUIRE(log_to_str("Some message", "[%-64n] %v", spdlog::pattern_time_type::local, "\n") == - "[pattern_tester ] Some message\n"); - - REQUIRE(log_to_str("Some message", "[%-64!n] %v", spdlog::pattern_time_type::local, "\n") == - "[pattern_tester ] Some message\n"); -} - -// Test padding + truncate flag - -TEST_CASE("paddinng_truncate", "[pattern_formatter]") { - REQUIRE(log_to_str("123456", "%6!v", spdlog::pattern_time_type::local, "\n") == "123456\n"); - REQUIRE(log_to_str("123456", "%5!v", spdlog::pattern_time_type::local, "\n") == "12345\n"); - REQUIRE(log_to_str("123456", "%7!v", spdlog::pattern_time_type::local, "\n") == " 123456\n"); - - REQUIRE(log_to_str("123456", "%-6!v", spdlog::pattern_time_type::local, "\n") == "123456\n"); - REQUIRE(log_to_str("123456", "%-5!v", spdlog::pattern_time_type::local, "\n") == "12345\n"); - REQUIRE(log_to_str("123456", "%-7!v", spdlog::pattern_time_type::local, "\n") == "123456 \n"); - - REQUIRE(log_to_str("123456", "%=6!v", spdlog::pattern_time_type::local, "\n") == "123456\n"); - REQUIRE(log_to_str("123456", "%=5!v", spdlog::pattern_time_type::local, "\n") == "12345\n"); - REQUIRE(log_to_str("123456", "%=7!v", spdlog::pattern_time_type::local, "\n") == "123456 \n"); - - REQUIRE(log_to_str("123456", "%0!v", spdlog::pattern_time_type::local, "\n") == "\n"); -} - -TEST_CASE("padding_truncate_funcname", "[pattern_formatter]") { - spdlog::sinks::test_sink_st test_sink; - - const char *pattern = "%v [%5!!]"; - auto formatter = std::unique_ptr<spdlog::formatter>(new spdlog::pattern_formatter(pattern)); - test_sink.set_formatter(std::move(formatter)); - - spdlog::details::log_msg msg1{spdlog::source_loc{"ignored", 1, "func"}, "test_logger", - spdlog::level::info, "message"}; - test_sink.log(msg1); - REQUIRE(test_sink.lines()[0] == "message [ func]"); - - spdlog::details::log_msg msg2{spdlog::source_loc{"ignored", 1, "function"}, "test_logger", - spdlog::level::info, "message"}; - test_sink.log(msg2); - REQUIRE(test_sink.lines()[1] == "message [funct]"); -} - -TEST_CASE("padding_funcname", "[pattern_formatter]") { - spdlog::sinks::test_sink_st test_sink; - - const char *pattern = "%v [%10!]"; - auto formatter = std::unique_ptr<spdlog::formatter>(new spdlog::pattern_formatter(pattern)); - test_sink.set_formatter(std::move(formatter)); - - spdlog::details::log_msg msg1{spdlog::source_loc{"ignored", 1, "func"}, "test_logger", - spdlog::level::info, "message"}; - test_sink.log(msg1); - REQUIRE(test_sink.lines()[0] == "message [ func]"); - - spdlog::details::log_msg msg2{spdlog::source_loc{"ignored", 1, "func567890123"}, "test_logger", - spdlog::level::info, "message"}; - test_sink.log(msg2); - REQUIRE(test_sink.lines()[1] == "message [func567890123]"); -} - -TEST_CASE("clone-default-formatter", "[pattern_formatter]") { - auto formatter_1 = std::make_shared<spdlog::pattern_formatter>(); - auto formatter_2 = formatter_1->clone(); - std::string logger_name = "test"; - spdlog::details::log_msg msg(logger_name, spdlog::level::info, "some message"); - - memory_buf_t formatted_1; - memory_buf_t formatted_2; - formatter_1->format(msg, formatted_1); - formatter_2->format(msg, formatted_2); - - REQUIRE(to_string_view(formatted_1) == to_string_view(formatted_2)); -} - -TEST_CASE("clone-default-formatter2", "[pattern_formatter]") { - auto formatter_1 = std::make_shared<spdlog::pattern_formatter>("%+"); - auto formatter_2 = formatter_1->clone(); - std::string logger_name = "test"; - spdlog::details::log_msg msg(logger_name, spdlog::level::info, "some message"); - - memory_buf_t formatted_1; - memory_buf_t formatted_2; - formatter_1->format(msg, formatted_1); - formatter_2->format(msg, formatted_2); - - REQUIRE(to_string_view(formatted_1) == to_string_view(formatted_2)); -} - -TEST_CASE("clone-formatter", "[pattern_formatter]") { - auto formatter_1 = std::make_shared<spdlog::pattern_formatter>("%D %X [%] [%n] %v"); - auto formatter_2 = formatter_1->clone(); - std::string logger_name = "test"; - spdlog::details::log_msg msg(logger_name, spdlog::level::info, "some message"); - - memory_buf_t formatted_1; - memory_buf_t formatted_2; - formatter_1->format(msg, formatted_1); - formatter_2->format(msg, formatted_2); - - REQUIRE(to_string_view(formatted_1) == to_string_view(formatted_2)); -} - -TEST_CASE("clone-formatter-2", "[pattern_formatter]") { - using spdlog::pattern_time_type; - auto formatter_1 = std::make_shared<spdlog::pattern_formatter>( - "%D %X [%] [%n] %v", pattern_time_type::utc, "xxxxxx\n"); - auto formatter_2 = formatter_1->clone(); - std::string logger_name = "test2"; - spdlog::details::log_msg msg(logger_name, spdlog::level::info, "some message"); - - memory_buf_t formatted_1; - memory_buf_t formatted_2; - formatter_1->format(msg, formatted_1); - formatter_2->format(msg, formatted_2); - - REQUIRE(to_string_view(formatted_1) == to_string_view(formatted_2)); -} - -class custom_test_flag : public spdlog::custom_flag_formatter { -public: - explicit custom_test_flag(std::string txt) - : some_txt{std::move(txt)} {} - - void format(const spdlog::details::log_msg &, - const std::tm &tm, - spdlog::memory_buf_t &dest) override { - if (some_txt == "throw_me") { - throw spdlog::spdlog_ex("custom_flag_exception_test"); - } else if (some_txt == "time") { - auto formatted = spdlog::fmt_lib::format("{:d}:{:02d}{:s}", tm.tm_hour % 12, tm.tm_min, - tm.tm_hour / 12 ? "PM" : "AM"); - dest.append(formatted.data(), formatted.data() + formatted.size()); - return; - } - some_txt = std::string(padinfo_.width_, ' ') + some_txt; - dest.append(some_txt.data(), some_txt.data() + some_txt.size()); - } - spdlog::details::padding_info get_padding_info() { return padinfo_; } - - std::string some_txt; - - std::unique_ptr<custom_flag_formatter> clone() const override { - return spdlog::details::make_unique<custom_test_flag>(some_txt); - } -}; -// test clone with custom flag formatters -TEST_CASE("clone-custom_formatter", "[pattern_formatter]") { - auto formatter_1 = std::make_shared<spdlog::pattern_formatter>(); - formatter_1->add_flag<custom_test_flag>('t', "custom_output").set_pattern("[%n] [%t] %v"); - auto formatter_2 = formatter_1->clone(); - std::string logger_name = "logger-name"; - spdlog::details::log_msg msg(logger_name, spdlog::level::info, "some message"); - - memory_buf_t formatted_1; - memory_buf_t formatted_2; - formatter_1->format(msg, formatted_1); - formatter_2->format(msg, formatted_2); - - auto expected = spdlog::fmt_lib::format("[logger-name] [custom_output] some message{}", - spdlog::details::os::default_eol); - - REQUIRE(to_string_view(formatted_1) == expected); - REQUIRE(to_string_view(formatted_2) == expected); -} - -// -// Test source location formatting -// - -#ifdef _WIN32 -static const char *const test_path = "\\a\\b\\c/myfile.cpp"; -#else -static const char *const test_path = "/a/b//myfile.cpp"; -#endif - -TEST_CASE("short filename formatter-1", "[pattern_formatter]") { - spdlog::pattern_formatter formatter("%s", spdlog::pattern_time_type::local, ""); - memory_buf_t formatted; - std::string logger_name = "logger-name"; - spdlog::source_loc source_loc{test_path, 123, "some_func()"}; - spdlog::details::log_msg msg(source_loc, "logger-name", spdlog::level::info, "Hello"); - formatter.format(msg, formatted); - - REQUIRE(to_string_view(formatted) == "myfile.cpp"); -} - -TEST_CASE("short filename formatter-2", "[pattern_formatter]") { - spdlog::pattern_formatter formatter("%s:%#", spdlog::pattern_time_type::local, ""); - memory_buf_t formatted; - std::string logger_name = "logger-name"; - spdlog::source_loc source_loc{"myfile.cpp", 123, "some_func()"}; - spdlog::details::log_msg msg(source_loc, "logger-name", spdlog::level::info, "Hello"); - formatter.format(msg, formatted); - - REQUIRE(to_string_view(formatted) == "myfile.cpp:123"); -} - -TEST_CASE("short filename formatter-3", "[pattern_formatter]") { - spdlog::pattern_formatter formatter("%s %v", spdlog::pattern_time_type::local, ""); - memory_buf_t formatted; - std::string logger_name = "logger-name"; - spdlog::source_loc source_loc{"", 123, "some_func()"}; - spdlog::details::log_msg msg(source_loc, "logger-name", spdlog::level::info, "Hello"); - formatter.format(msg, formatted); - - REQUIRE(to_string_view(formatted) == " Hello"); -} - -TEST_CASE("full filename formatter", "[pattern_formatter]") { - spdlog::pattern_formatter formatter("%g", spdlog::pattern_time_type::local, ""); - memory_buf_t formatted; - std::string logger_name = "logger-name"; - spdlog::source_loc source_loc{test_path, 123, "some_func()"}; - spdlog::details::log_msg msg(source_loc, "logger-name", spdlog::level::info, "Hello"); - formatter.format(msg, formatted); - - REQUIRE(to_string_view(formatted) == test_path); -} - -TEST_CASE("custom flags", "[pattern_formatter]") { - auto formatter = std::make_shared<spdlog::pattern_formatter>(); - formatter->add_flag<custom_test_flag>('t', "custom1") - .add_flag<custom_test_flag>('u', "custom2") - .set_pattern("[%n] [%t] [%u] %v"); - - memory_buf_t formatted; - - spdlog::details::log_msg msg(spdlog::source_loc{}, "logger-name", spdlog::level::info, - "some message"); - formatter->format(msg, formatted); - auto expected = spdlog::fmt_lib::format("[logger-name] [custom1] [custom2] some message{}", - spdlog::details::os::default_eol); - - REQUIRE(to_string_view(formatted) == expected); -} - -TEST_CASE("custom flags-padding", "[pattern_formatter]") { - auto formatter = std::make_shared<spdlog::pattern_formatter>(); - formatter->add_flag<custom_test_flag>('t', "custom1") - .add_flag<custom_test_flag>('u', "custom2") - .set_pattern("[%n] [%t] [%5u] %v"); - - memory_buf_t formatted; - - spdlog::details::log_msg msg(spdlog::source_loc{}, "logger-name", spdlog::level::info, - "some message"); - formatter->format(msg, formatted); - auto expected = spdlog::fmt_lib::format("[logger-name] [custom1] [ custom2] some message{}", - spdlog::details::os::default_eol); - - REQUIRE(to_string_view(formatted) == expected); -} - -TEST_CASE("custom flags-exception", "[pattern_formatter]") { - auto formatter = std::make_shared<spdlog::pattern_formatter>(); - formatter->add_flag<custom_test_flag>('t', "throw_me") - .add_flag<custom_test_flag>('u', "custom2") - .set_pattern("[%n] [%t] [%u] %v"); - - memory_buf_t formatted; - spdlog::details::log_msg msg(spdlog::source_loc{}, "logger-name", spdlog::level::info, - "some message"); - CHECK_THROWS_AS(formatter->format(msg, formatted), spdlog::spdlog_ex); -} - -TEST_CASE("override need_localtime", "[pattern_formatter]") { - auto formatter = - std::make_shared<spdlog::pattern_formatter>(spdlog::pattern_time_type::local, "\n"); - formatter->add_flag<custom_test_flag>('t', "time").set_pattern("%t> %v"); - - { - memory_buf_t formatted; - spdlog::details::log_msg msg(spdlog::source_loc{}, "logger-name", spdlog::level::info, - "some message"); - formatter->format(msg, formatted); - REQUIRE(to_string_view(formatted) == "0:00AM> some message\n"); - } - - { - formatter->need_localtime(); - - auto now_tm = spdlog::details::os::localtime(); - std::stringstream oss; - oss << (now_tm.tm_hour % 12) << ":" << std::setfill('0') << std::setw(2) << now_tm.tm_min - << (now_tm.tm_hour / 12 ? "PM" : "AM") << "> some message\n"; - - memory_buf_t formatted; - spdlog::details::log_msg msg(spdlog::source_loc{}, "logger-name", spdlog::level::info, - "some message"); - formatter->format(msg, formatted); - REQUIRE(to_string_view(formatted) == oss.str()); - } -} - -#ifndef SPDLOG_NO_TLS -TEST_CASE("mdc formatter test-1", "[pattern_formatter]") { - spdlog::mdc::put("mdc_key_1", "mdc_value_1"); - spdlog::mdc::put("mdc_key_2", "mdc_value_2"); - - auto formatter = std::make_shared<spdlog::pattern_formatter>(); - formatter->set_pattern("[%n] [%l] [%&] %v"); - - memory_buf_t formatted; - spdlog::details::log_msg msg(spdlog::source_loc{}, "logger-name", spdlog::level::info, - "some message"); - formatter->format(msg, formatted); - - auto expected = spdlog::fmt_lib::format( - "[logger-name] [info] [mdc_key_1:mdc_value_1 mdc_key_2:mdc_value_2] some message{}", - spdlog::details::os::default_eol); - REQUIRE(to_string_view(formatted) == expected); - - SECTION("Tear down") { spdlog::mdc::clear(); } -} - -TEST_CASE("mdc formatter value update", "[pattern_formatter]") { - spdlog::mdc::put("mdc_key_1", "mdc_value_1"); - spdlog::mdc::put("mdc_key_2", "mdc_value_2"); - - auto formatter = std::make_shared<spdlog::pattern_formatter>(); - formatter->set_pattern("[%n] [%l] [%&] %v"); - - memory_buf_t formatted_1; - spdlog::details::log_msg msg(spdlog::source_loc{}, "logger-name", spdlog::level::info, - "some message"); - formatter->format(msg, formatted_1); - - auto expected = spdlog::fmt_lib::format( - "[logger-name] [info] [mdc_key_1:mdc_value_1 mdc_key_2:mdc_value_2] some message{}", - spdlog::details::os::default_eol); - - REQUIRE(to_string_view(formatted_1) == expected); - - spdlog::mdc::put("mdc_key_1", "new_mdc_value_1"); - memory_buf_t formatted_2; - formatter->format(msg, formatted_2); - expected = spdlog::fmt_lib::format( - "[logger-name] [info] [mdc_key_1:new_mdc_value_1 mdc_key_2:mdc_value_2] some message{}", - spdlog::details::os::default_eol); - - REQUIRE(to_string_view(formatted_2) == expected); - - SECTION("Tear down") { spdlog::mdc::clear(); } -} - -TEST_CASE("mdc different threads", "[pattern_formatter]") { - auto formatter = std::make_shared<spdlog::pattern_formatter>(); - formatter->set_pattern("[%n] [%l] [%&] %v"); - spdlog::details::log_msg msg(spdlog::source_loc{}, "logger-name", spdlog::level::info, - "some message"); - - memory_buf_t formatted_2; - - auto lambda_1 = [formatter, msg]() { - spdlog::mdc::put("mdc_key", "thread_1_id"); - memory_buf_t formatted; - formatter->format(msg, formatted); - - auto expected = - spdlog::fmt_lib::format("[logger-name] [info] [mdc_key:thread_1_id] some message{}", - spdlog::details::os::default_eol); - - REQUIRE(to_string_view(formatted) == expected); - }; - - auto lambda_2 = [formatter, msg]() { - spdlog::mdc::put("mdc_key", "thread_2_id"); - memory_buf_t formatted; - formatter->format(msg, formatted); - - auto expected = - spdlog::fmt_lib::format("[logger-name] [info] [mdc_key:thread_2_id] some message{}", - spdlog::details::os::default_eol); - - REQUIRE(to_string_view(formatted) == expected); - }; - - std::thread thread_1(lambda_1); - std::thread thread_2(lambda_2); - - thread_1.join(); - thread_2.join(); - - SECTION("Tear down") { spdlog::mdc::clear(); } -} - -TEST_CASE("mdc remove key", "[pattern_formatter]") { - spdlog::mdc::put("mdc_key_1", "mdc_value_1"); - spdlog::mdc::put("mdc_key_2", "mdc_value_2"); - spdlog::mdc::remove("mdc_key_1"); - - auto formatter = std::make_shared<spdlog::pattern_formatter>(); - formatter->set_pattern("[%n] [%l] [%&] %v"); - - memory_buf_t formatted; - spdlog::details::log_msg msg(spdlog::source_loc{}, "logger-name", spdlog::level::info, - "some message"); - formatter->format(msg, formatted); - - auto expected = - spdlog::fmt_lib::format("[logger-name] [info] [mdc_key_2:mdc_value_2] some message{}", - spdlog::details::os::default_eol); - REQUIRE(to_string_view(formatted) == expected); - - SECTION("Tear down") { spdlog::mdc::clear(); } -} - -TEST_CASE("mdc empty", "[pattern_formatter]") { - auto formatter = std::make_shared<spdlog::pattern_formatter>(); - formatter->set_pattern("[%n] [%l] [%&] %v"); - - memory_buf_t formatted; - spdlog::details::log_msg msg(spdlog::source_loc{}, "logger-name", spdlog::level::info, - "some message"); - formatter->format(msg, formatted); - - auto expected = spdlog::fmt_lib::format("[logger-name] [info] [] some message{}", - spdlog::details::os::default_eol); - REQUIRE(to_string_view(formatted) == expected); - - SECTION("Tear down") { spdlog::mdc::clear(); } -} -#endif diff --git a/thirdparty/spdlog/tests/test_registry.cpp b/thirdparty/spdlog/tests/test_registry.cpp deleted file mode 100644 index 1805ae7f8..000000000 --- a/thirdparty/spdlog/tests/test_registry.cpp +++ /dev/null @@ -1,125 +0,0 @@ -#include "includes.h" - -static const char *const tested_logger_name = "null_logger"; -static const char *const tested_logger_name2 = "null_logger2"; - -#ifndef SPDLOG_NO_EXCEPTIONS -TEST_CASE("register_drop", "[registry]") { - spdlog::drop_all(); - spdlog::create<spdlog::sinks::null_sink_mt>(tested_logger_name); - REQUIRE(spdlog::get(tested_logger_name) != nullptr); - // Throw if registering existing name - REQUIRE_THROWS_AS(spdlog::create<spdlog::sinks::null_sink_mt>(tested_logger_name), - spdlog::spdlog_ex); -} - -TEST_CASE("explicit register", "[registry]") { - spdlog::drop_all(); - auto logger = std::make_shared<spdlog::logger>(tested_logger_name, - std::make_shared<spdlog::sinks::null_sink_st>()); - spdlog::register_logger(logger); - REQUIRE(spdlog::get(tested_logger_name) != nullptr); - // Throw if registering existing name - REQUIRE_THROWS_AS(spdlog::create<spdlog::sinks::null_sink_mt>(tested_logger_name), - spdlog::spdlog_ex); -} -#endif - -TEST_CASE("register_or_replace", "[registry]") { - spdlog::drop_all(); - auto logger1 = std::make_shared<spdlog::logger>( - tested_logger_name, std::make_shared<spdlog::sinks::null_sink_st>()); - spdlog::register_logger(logger1); - REQUIRE(spdlog::get(tested_logger_name) == logger1); - - auto logger2 = std::make_shared<spdlog::logger>( - tested_logger_name, std::make_shared<spdlog::sinks::null_sink_st>()); - spdlog::register_or_replace(logger2); - REQUIRE(spdlog::get(tested_logger_name) == logger2); -} - -TEST_CASE("apply_all", "[registry]") { - spdlog::drop_all(); - auto logger = std::make_shared<spdlog::logger>(tested_logger_name, - std::make_shared<spdlog::sinks::null_sink_st>()); - spdlog::register_logger(logger); - auto logger2 = std::make_shared<spdlog::logger>( - tested_logger_name2, std::make_shared<spdlog::sinks::null_sink_st>()); - spdlog::register_logger(logger2); - - int counter = 0; - spdlog::apply_all([&counter](std::shared_ptr<spdlog::logger>) { counter++; }); - REQUIRE(counter == 2); - - counter = 0; - spdlog::drop(tested_logger_name2); - spdlog::apply_all([&counter](std::shared_ptr<spdlog::logger> l) { - REQUIRE(l->name() == tested_logger_name); - counter++; - }); - REQUIRE(counter == 1); -} - -TEST_CASE("drop", "[registry]") { - spdlog::drop_all(); - spdlog::create<spdlog::sinks::null_sink_mt>(tested_logger_name); - spdlog::drop(tested_logger_name); - REQUIRE_FALSE(spdlog::get(tested_logger_name)); -} - -TEST_CASE("drop-default", "[registry]") { - spdlog::set_default_logger(spdlog::null_logger_st(tested_logger_name)); - spdlog::drop(tested_logger_name); - REQUIRE_FALSE(spdlog::default_logger()); - REQUIRE_FALSE(spdlog::get(tested_logger_name)); -} - -TEST_CASE("drop_all", "[registry]") { - spdlog::drop_all(); - spdlog::create<spdlog::sinks::null_sink_mt>(tested_logger_name); - spdlog::create<spdlog::sinks::null_sink_mt>(tested_logger_name2); - spdlog::drop_all(); - REQUIRE_FALSE(spdlog::get(tested_logger_name)); - REQUIRE_FALSE(spdlog::get(tested_logger_name2)); - REQUIRE_FALSE(spdlog::default_logger()); -} - -TEST_CASE("drop non existing", "[registry]") { - spdlog::drop_all(); - spdlog::create<spdlog::sinks::null_sink_mt>(tested_logger_name); - spdlog::drop("some_name"); - REQUIRE_FALSE(spdlog::get("some_name")); - REQUIRE(spdlog::get(tested_logger_name)); - spdlog::drop_all(); -} - -TEST_CASE("default logger", "[registry]") { - spdlog::drop_all(); - spdlog::set_default_logger(spdlog::null_logger_st(tested_logger_name)); - REQUIRE(spdlog::get(tested_logger_name) == spdlog::default_logger()); - spdlog::drop_all(); -} - -TEST_CASE("set_default_logger(nullptr)", "[registry]") { - spdlog::set_default_logger(nullptr); - REQUIRE_FALSE(spdlog::default_logger()); -} - -TEST_CASE("disable automatic registration", "[registry]") { - // set some global parameters - spdlog::level::level_enum log_level = spdlog::level::level_enum::warn; - spdlog::set_level(log_level); - // but disable automatic registration - spdlog::set_automatic_registration(false); - auto logger1 = spdlog::create<spdlog::sinks::daily_file_sink_st>( - tested_logger_name, SPDLOG_FILENAME_T("filename"), 11, 59); - auto logger2 = spdlog::create_async<spdlog::sinks::stdout_color_sink_mt>(tested_logger_name2); - // loggers should not be part of the registry - REQUIRE_FALSE(spdlog::get(tested_logger_name)); - REQUIRE_FALSE(spdlog::get(tested_logger_name2)); - // but make sure they are still initialized according to global defaults - REQUIRE(logger1->level() == log_level); - REQUIRE(logger2->level() == log_level); - spdlog::set_level(spdlog::level::info); - spdlog::set_automatic_registration(true); -} diff --git a/thirdparty/spdlog/tests/test_ringbuffer.cpp b/thirdparty/spdlog/tests/test_ringbuffer.cpp deleted file mode 100644 index 81d791656..000000000 --- a/thirdparty/spdlog/tests/test_ringbuffer.cpp +++ /dev/null @@ -1,52 +0,0 @@ -#include "includes.h" -#include "spdlog/sinks/ringbuffer_sink.h" - -TEST_CASE("ringbuffer invalid size", "[ringbuffer]") { - REQUIRE_THROWS_AS(spdlog::sinks::ringbuffer_sink_mt(0), spdlog::spdlog_ex); -} - -TEST_CASE("ringbuffer stores formatted messages", "[ringbuffer]") { - spdlog::sinks::ringbuffer_sink_st sink(3); - sink.set_pattern("%v"); - - sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "msg1"}); - sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "msg2"}); - sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "msg3"}); - - auto formatted = sink.last_formatted(); - REQUIRE(formatted.size() == 3); - using spdlog::details::os::default_eol; - REQUIRE(formatted[0] == spdlog::fmt_lib::format("msg1{}", default_eol)); - REQUIRE(formatted[1] == spdlog::fmt_lib::format("msg2{}", default_eol)); - REQUIRE(formatted[2] == spdlog::fmt_lib::format("msg3{}", default_eol)); -} - -TEST_CASE("ringbuffer overrun keeps last items", "[ringbuffer]") { - spdlog::sinks::ringbuffer_sink_st sink(2); - sink.set_pattern("%v"); - - sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "first"}); - sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "second"}); - sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "third"}); - - auto formatted = sink.last_formatted(); - REQUIRE(formatted.size() == 2); - using spdlog::details::os::default_eol; - REQUIRE(formatted[0] == spdlog::fmt_lib::format("second{}", default_eol)); - REQUIRE(formatted[1] == spdlog::fmt_lib::format("third{}", default_eol)); -} - -TEST_CASE("ringbuffer retrieval limit", "[ringbuffer]") { - spdlog::sinks::ringbuffer_sink_st sink(3); - sink.set_pattern("%v"); - - sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "A"}); - sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "B"}); - sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "C"}); - - auto formatted = sink.last_formatted(2); - REQUIRE(formatted.size() == 2); - using spdlog::details::os::default_eol; - REQUIRE(formatted[0] == spdlog::fmt_lib::format("B{}", default_eol)); - REQUIRE(formatted[1] == spdlog::fmt_lib::format("C{}", default_eol)); -} diff --git a/thirdparty/spdlog/tests/test_sink.h b/thirdparty/spdlog/tests/test_sink.h deleted file mode 100644 index 9c0945232..000000000 --- a/thirdparty/spdlog/tests/test_sink.h +++ /dev/null @@ -1,70 +0,0 @@ -// -// Copyright(c) 2018 Gabi Melman. -// Distributed under the MIT License (http://opensource.org/licenses/MIT) -// - -#pragma once - -#include "spdlog/details/null_mutex.h" -#include "spdlog/sinks/base_sink.h" -#include "spdlog/fmt/fmt.h" -#include <chrono> -#include <mutex> -#include <thread> - -namespace spdlog { -namespace sinks { - -template <class Mutex> -class test_sink : public base_sink<Mutex> { - const size_t lines_to_save = 100; - -public: - size_t msg_counter() { - std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_); - return msg_counter_; - } - - size_t flush_counter() { - std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_); - return flush_counter_; - } - - void set_delay(std::chrono::milliseconds delay) { - std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_); - delay_ = delay; - } - - // return last output without the eol - std::vector<std::string> lines() { - std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_); - return lines_; - } - -protected: - void sink_it_(const details::log_msg &msg) override { - memory_buf_t formatted; - base_sink<Mutex>::formatter_->format(msg, formatted); - // save the line without the eol - auto eol_len = strlen(details::os::default_eol); - using diff_t = typename std::iterator_traits<decltype(formatted.end())>::difference_type; - if (lines_.size() < lines_to_save) { - lines_.emplace_back(formatted.begin(), formatted.end() - static_cast<diff_t>(eol_len)); - } - msg_counter_++; - std::this_thread::sleep_for(delay_); - } - - void flush_() override { flush_counter_++; } - - size_t msg_counter_{0}; - size_t flush_counter_{0}; - std::chrono::milliseconds delay_{std::chrono::milliseconds::zero()}; - std::vector<std::string> lines_; -}; - -using test_sink_mt = test_sink<std::mutex>; -using test_sink_st = test_sink<details::null_mutex>; - -} // namespace sinks -} // namespace spdlog diff --git a/thirdparty/spdlog/tests/test_stdout_api.cpp b/thirdparty/spdlog/tests/test_stdout_api.cpp deleted file mode 100644 index 67659b84d..000000000 --- a/thirdparty/spdlog/tests/test_stdout_api.cpp +++ /dev/null @@ -1,90 +0,0 @@ -/* - * This content is released under the MIT License as specified in - * https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE - */ -#include "includes.h" -#include "spdlog/sinks/stdout_sinks.h" -#include "spdlog/sinks/stdout_color_sinks.h" -TEST_CASE("stdout_st", "[stdout]") { - auto l = spdlog::stdout_logger_st("test"); - l->set_pattern("%+"); - l->set_level(spdlog::level::trace); - l->trace("Test stdout_st"); - spdlog::drop_all(); -} - -TEST_CASE("stdout_mt", "[stdout]") { - auto l = spdlog::stdout_logger_mt("test"); - l->set_pattern("%+"); - l->set_level(spdlog::level::debug); - l->debug("Test stdout_mt"); - spdlog::drop_all(); -} - -TEST_CASE("stderr_st", "[stderr]") { - auto l = spdlog::stderr_logger_st("test"); - l->set_pattern("%+"); - l->info("Test stderr_st"); - spdlog::drop_all(); -} - -TEST_CASE("stderr_mt", "[stderr]") { - auto l = spdlog::stderr_logger_mt("test"); - l->set_pattern("%+"); - l->info("Test stderr_mt"); - l->warn("Test stderr_mt"); - l->error("Test stderr_mt"); - l->critical("Test stderr_mt"); - spdlog::drop_all(); -} - -// color loggers -TEST_CASE("stdout_color_st", "[stdout]") { - auto l = spdlog::stdout_color_st("test"); - l->set_pattern("%+"); - l->info("Test stdout_color_st"); - spdlog::drop_all(); -} - -TEST_CASE("stdout_color_mt", "[stdout]") { - auto l = spdlog::stdout_color_mt("test"); - l->set_pattern("%+"); - l->set_level(spdlog::level::trace); - l->trace("Test stdout_color_mt"); - spdlog::drop_all(); -} - -TEST_CASE("stderr_color_st", "[stderr]") { - auto l = spdlog::stderr_color_st("test"); - l->set_pattern("%+"); - l->set_level(spdlog::level::debug); - l->debug("Test stderr_color_st"); - spdlog::drop_all(); -} - -TEST_CASE("stderr_color_mt", "[stderr]") { - auto l = spdlog::stderr_color_mt("test"); - l->set_pattern("%+"); - l->info("Test stderr_color_mt"); - l->warn("Test stderr_color_mt"); - l->error("Test stderr_color_mt"); - l->critical("Test stderr_color_mt"); - spdlog::drop_all(); -} - -#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT - -TEST_CASE("wchar_api", "[stdout]") { - auto l = spdlog::stdout_logger_st("wchar_logger"); - l->set_pattern("%+"); - l->set_level(spdlog::level::trace); - l->trace(L"Test wchar_api"); - l->trace(L"Test wchar_api {}", L"param"); - l->trace(L"Test wchar_api {}", 1); - l->trace(L"Test wchar_api {}", std::wstring{L"wstring param"}); - l->trace(std::wstring{L"Test wchar_api wstring"}); - SPDLOG_LOGGER_DEBUG(l, L"Test SPDLOG_LOGGER_DEBUG {}", L"param"); - spdlog::drop_all(); -} - -#endif diff --git a/thirdparty/spdlog/tests/test_stopwatch.cpp b/thirdparty/spdlog/tests/test_stopwatch.cpp deleted file mode 100644 index b1b4b191c..000000000 --- a/thirdparty/spdlog/tests/test_stopwatch.cpp +++ /dev/null @@ -1,42 +0,0 @@ -#include "includes.h" -#include "test_sink.h" -#include "spdlog/stopwatch.h" - -TEST_CASE("stopwatch1", "[stopwatch]") { - using std::chrono::milliseconds; - using clock = std::chrono::steady_clock; - milliseconds wait_ms(500); - milliseconds tolerance_ms(250); - auto start = clock::now(); - spdlog::stopwatch sw; - std::this_thread::sleep_for(wait_ms); - auto stop = clock::now(); - auto diff_ms = std::chrono::duration_cast<milliseconds>(stop - start); - REQUIRE(sw.elapsed() >= diff_ms); - REQUIRE(sw.elapsed() <= diff_ms + tolerance_ms); -} - -TEST_CASE("stopwatch2", "[stopwatch]") { - using spdlog::sinks::test_sink_st; - using std::chrono::duration_cast; - using std::chrono::milliseconds; - using clock = std::chrono::steady_clock; - - clock::duration wait_duration(milliseconds(500)); - clock::duration tolerance_duration(milliseconds(250)); - - auto test_sink = std::make_shared<test_sink_st>(); - - auto start = clock::now(); - spdlog::stopwatch sw; - spdlog::logger logger("test-stopwatch", test_sink); - logger.set_pattern("%v"); - std::this_thread::sleep_for(wait_duration); - auto stop = clock::now(); - logger.info("{}", sw); - auto val = std::stod(test_sink->lines()[0]); - auto diff_duration = duration_cast<std::chrono::duration<double>>(stop - start); - - REQUIRE(val >= (diff_duration).count() - 0.001); - REQUIRE(val <= (diff_duration + tolerance_duration).count()); -} diff --git a/thirdparty/spdlog/tests/test_systemd.cpp b/thirdparty/spdlog/tests/test_systemd.cpp deleted file mode 100644 index e36365741..000000000 --- a/thirdparty/spdlog/tests/test_systemd.cpp +++ /dev/null @@ -1,14 +0,0 @@ -#include "includes.h" -#include "spdlog/sinks/systemd_sink.h" - -TEST_CASE("systemd", "[all]") { - auto systemd_sink = std::make_shared<spdlog::sinks::systemd_sink_st>(); - spdlog::logger logger("spdlog_systemd_test", systemd_sink); - logger.set_level(spdlog::level::trace); - logger.trace("test spdlog trace"); - logger.debug("test spdlog debug"); - SPDLOG_LOGGER_INFO((&logger), "test spdlog info"); - SPDLOG_LOGGER_WARN((&logger), "test spdlog warn"); - SPDLOG_LOGGER_ERROR((&logger), "test spdlog error"); - SPDLOG_LOGGER_CRITICAL((&logger), "test spdlog critical"); -} diff --git a/thirdparty/spdlog/tests/test_time_point.cpp b/thirdparty/spdlog/tests/test_time_point.cpp deleted file mode 100644 index b7b1b2323..000000000 --- a/thirdparty/spdlog/tests/test_time_point.cpp +++ /dev/null @@ -1,35 +0,0 @@ -#include "includes.h" -#include "test_sink.h" -#include "spdlog/async.h" - -TEST_CASE("time_point1", "[time_point log_msg]") { - std::shared_ptr<spdlog::sinks::test_sink_st> test_sink(new spdlog::sinks::test_sink_st); - spdlog::logger logger("test-time_point", test_sink); - - spdlog::source_loc source{}; - std::chrono::system_clock::time_point tp{std::chrono::system_clock::now()}; - test_sink->set_pattern("%T.%F"); // interested in the time_point - - // all the following should have the same time - test_sink->set_delay(std::chrono::milliseconds(10)); - for (int i = 0; i < 5; i++) { - spdlog::details::log_msg msg{tp, source, "test_logger", spdlog::level::info, "message"}; - test_sink->log(msg); - } - - logger.log(tp, source, spdlog::level::info, "formatted message"); - logger.log(tp, source, spdlog::level::info, "formatted message"); - logger.log(tp, source, spdlog::level::info, "formatted message"); - logger.log(tp, source, spdlog::level::info, "formatted message"); - logger.log(source, spdlog::level::info, - "formatted message"); // last line has different time_point - - // now the real test... that the times are the same. - std::vector<std::string> lines = test_sink->lines(); - REQUIRE(lines[0] == lines[1]); - REQUIRE(lines[2] == lines[3]); - REQUIRE(lines[4] == lines[5]); - REQUIRE(lines[6] == lines[7]); - REQUIRE(lines[8] != lines[9]); - spdlog::drop_all(); -} diff --git a/thirdparty/spdlog/tests/utils.cpp b/thirdparty/spdlog/tests/utils.cpp deleted file mode 100644 index 405b5e5a2..000000000 --- a/thirdparty/spdlog/tests/utils.cpp +++ /dev/null @@ -1,102 +0,0 @@ -#include "includes.h" - -#ifdef _WIN32 - #include <windows.h> -#else - #include <sys/types.h> - #include <dirent.h> -#endif - -void prepare_logdir() { - spdlog::drop_all(); -#ifdef _WIN32 - system("rmdir /S /Q test_logs"); -#else - auto rv = system("rm -rf test_logs"); - if (rv != 0) { - throw std::runtime_error("Failed to rm -rf test_logs"); - } -#endif -} - -std::string file_contents(const std::string &filename) { - std::ifstream ifs(filename, std::ios_base::binary); - if (!ifs) { - throw std::runtime_error("Failed open file "); - } - return std::string((std::istreambuf_iterator<char>(ifs)), (std::istreambuf_iterator<char>())); -} - -std::size_t count_lines(const std::string &filename) { - std::ifstream ifs(filename); - if (!ifs) { - throw std::runtime_error("Failed open file "); - } - - std::string line; - size_t counter = 0; - while (std::getline(ifs, line)) counter++; - return counter; -} - -void require_message_count(const std::string &filename, const std::size_t messages) { - if (strlen(spdlog::details::os::default_eol) == 0) { - REQUIRE(count_lines(filename) == 1); - } else { - REQUIRE(count_lines(filename) == messages); - } -} - -std::size_t get_filesize(const std::string &filename) { - std::ifstream ifs(filename, std::ifstream::ate | std::ifstream::binary); - if (!ifs) { - throw std::runtime_error("Failed open file " + filename); - } - return static_cast<std::size_t>(ifs.tellg()); -} - -// source: https://stackoverflow.com/a/2072890/192001 -bool ends_with(std::string const &value, std::string const &ending) { - if (ending.size() > value.size()) { - return false; - } - return std::equal(ending.rbegin(), ending.rend(), value.rbegin()); -} - -#ifdef _WIN32 -// Based on: https://stackoverflow.com/a/37416569/192001 -std::size_t count_files(const std::string &folder) { - size_t counter = 0; - WIN32_FIND_DATAA ffd; - - // Start iterating over the files in the folder directory. - HANDLE hFind = ::FindFirstFileA((folder + "\\*").c_str(), &ffd); - if (hFind != INVALID_HANDLE_VALUE) { - do // Managed to locate and create an handle to that folder. - { - if (ffd.cFileName[0] != '.') counter++; - } while (::FindNextFileA(hFind, &ffd) != 0); - ::FindClose(hFind); - } else { - throw std::runtime_error("Failed open folder " + folder); - } - - return counter; -} -#else -// Based on: https://stackoverflow.com/a/2802255/192001 -std::size_t count_files(const std::string &folder) { - size_t counter = 0; - DIR *dp = opendir(folder.c_str()); - if (dp == nullptr) { - throw std::runtime_error("Failed open folder " + folder); - } - - struct dirent *ep = nullptr; - while ((ep = readdir(dp)) != nullptr) { - if (ep->d_name[0] != '.') counter++; - } - (void)closedir(dp); - return counter; -} -#endif diff --git a/thirdparty/spdlog/tests/utils.h b/thirdparty/spdlog/tests/utils.h deleted file mode 100644 index 53c09b469..000000000 --- a/thirdparty/spdlog/tests/utils.h +++ /dev/null @@ -1,18 +0,0 @@ -#pragma once - -#include <cstddef> -#include <string> - -std::size_t count_files(const std::string &folder); - -void prepare_logdir(); - -std::string file_contents(const std::string &filename); - -std::size_t count_lines(const std::string &filename); - -void require_message_count(const std::string &filename, const std::size_t messages); - -std::size_t get_filesize(const std::string &filename); - -bool ends_with(std::string const &value, std::string const &ending);
\ No newline at end of file diff --git a/thirdparty/xmake.lua b/thirdparty/xmake.lua index a4a183910..f929656a6 100644 --- a/thirdparty/xmake.lua +++ b/thirdparty/xmake.lua @@ -50,12 +50,6 @@ target('protozero') add_headerfiles("protozero/**.hpp") add_includedirs("protozero/include", {public=true}) -target('spdlog') - set_kind('headeronly') - set_group('thirdparty') - add_headerfiles("spdlog/include/spdlog/**.h") - add_includedirs("spdlog/include", {public=true}) - target('cpr') set_kind('static') set_group('thirdparty') |