Merge branch 'main' into lm/restrict-content-type

1 files changed, 71 insertions, 78 deletions

diff --git a/src/zenutil/logging.cpp b/src/zenutil/logging.cpp
index 806b96d52..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,41 +199,47 @@ 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
 
+	// If the console logger was initialized before, the above will change the output format
+	// so we need to reset it
+
+	logging::ResetConsoleLog();
+
 	if (g_FileSink)
 	{
 		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;
@@ -263,7 +256,7 @@ ShutdownLogging()
 
 	zen::logging::ShutdownLogging();
 
-	g_FileSink.reset();
+	g_FileSink = nullptr;
 }
 
 }  // namespace zen