Allow binary-to-text conversion to be moved to a background thread (#554)

* Update example benchmark data

* Allow all wide or all narrow strings in XXXXX_FMT_ASYNC macros

* Add a unit test

* Older fmt version fails so remove it from CI

* Include XXXXX_ASYNC macro support in the Log4cxx configuration summary

Author: swebb2066

.github/workflows/log4cxx-ubuntu.yml

@@ -42,7 +42,7 @@ jobs:
           - name: ubuntu22-clang
             os: ubuntu-22.04
             cxx: clang++
-            fmt: ON
+            fmt: OFF
             qt: OFF
             qt6: OFF
             odbc: ON
@@ -55,7 +55,7 @@ jobs:
           - name: ubuntu24-gcc
             os: ubuntu-24.04
             cxx: g++
-            fmt: OFF
+            fmt: ON
             qt: ON
             qt6: ON
             odbc: OFF

CMakeLists.txt

@@ -105,8 +105,10 @@ endif(LOG4CXX_ENABLE_ESMTP)
 find_package(fmt 7.1 QUIET)
 if(${fmt_FOUND})
     option(ENABLE_FMT_LAYOUT "Enable the FMT layout(if libfmt found)" ON)
+    option(ENABLE_FMT_ASYNC "Add support for the LOG4CXX_XXXX_FMT_ASYNC macros (if libfmt found)" ON)
 else()
     set(ENABLE_FMT_LAYOUT "OFF")
+    set(ENABLE_FMT_ASYNC "OFF")
 endif()
 
 option(LOG4CXX_CONFIG_VAR_EXPANSION "Expand \${varname} instances in LOG4CXX_CONFIGURATION" ON)
@@ -299,6 +301,8 @@ message(STATUS "  character encoding .............. : ${LOG4CXX_CHARSET}")
 message(STATUS "  Networking support .............. : ${LOG4CXX_NETWORKING_SUPPORT}")
 message(STATUS "  DOMConfigurator support ......... : ${LOG4CXX_DOMCONFIGURATOR_SUPPORT}")
 message(STATUS "  Qt support ...................... : ${LOG4CXX_QT_SUPPORT}")
+message(STATUS "  LOG4CXX_XXXX_ASYNC macros ....... : ON")
+message(STATUS "  LOG4CXX_XXXX_FMT_ASYNC macros ... : ${ENABLE_FMT_ASYNC}")
 message(STATUS "C++ version and Boost settings:")
 message(STATUS "  Prefer boost: ................... : ${PREFER_BOOST}")
 message(STATUS "  make_unique implementation :..... : ${STD_MAKE_UNIQUE_IMPL}")

src/examples/cpp/CMakeLists.txt

@@ -74,3 +74,17 @@ if(${fmt_FOUND})
         )
     endif()
 endif(${fmt_FOUND})
+
+if(ENABLE_FMT_ASYNC)
+    add_executable( format-async format-async.cpp )
+    target_compile_definitions(format-async PRIVATE ${LOG4CXX_COMPILE_DEFINITIONS} ${APR_COMPILE_DEFINITIONS} ${APR_UTIL_COMPILE_DEFINITIONS} )
+    target_include_directories(format-async PRIVATE ${CMAKE_CURRENT_LIST_DIR} $<TARGET_PROPERTY:log4cxx,INCLUDE_DIRECTORIES>)
+    target_link_libraries(format-async PRIVATE log4cxx ${APR_UTIL_LIBRARIES} ${EXPAT_LIBRARIES} ${APR_LIBRARIES} ${APR_SYSTEM_LIBS} fmt::fmt)
+    if( WIN32 )
+        set_target_properties( format-async PROPERTIES
+          VS_DEBUGGER_ENVIRONMENT "PATH=${ESCAPED_PATH}"
+          VS_DEBUGGER_WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}
+          FOLDER Examples
+        )
+    endif()
+endif(ENABLE_FMT_ASYNC)

src/examples/cpp/format-async.cpp

@@ -0,0 +1,69 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdlib.h>
+#include <log4cxx/logger.h>
+#include <log4cxx/logmanager.h>
+#include <log4cxx/basicconfigurator.h>
+#include <locale.h>
+#include <fmt/core.h>
+#include <fmt/args.h>
+#include <fmt/color.h>
+#include <fmt/ostream.h>
+#include <iomanip>
+
+using namespace log4cxx;
+using OutputStreamType = std::basic_ostream<logchar>;
+
+struct MyStruct {
+	int x;
+};
+	OutputStreamType& 
+operator<<(OutputStreamType& stream, const MyStruct& mystruct )
+{
+	stream << LOG4CXX_STR("[MyStruct x: ") << mystruct.x << LOG4CXX_STR("]");
+	return stream;
+}
+#if FMT_VERSION >= (9 * 10000)
+template <> struct fmt::formatter<MyStruct, logchar> : fmt::basic_ostream_formatter<logchar> {};
+#endif
+
+int main()
+{
+	setlocale(LC_ALL, "");
+
+	BasicConfigurator::configureAsync();
+	auto rootLogger = LogManager::getRootLogger();
+
+	LOG4CXX_INFO_FMT_ASYNC( rootLogger, "This is a {} message", "char" );
+	LOG4CXX_INFO_FMT_ASYNC( rootLogger, LOG4CXX_STR("This is a {} message"), LOG4CXX_STR("LogString") );
+	LOG4CXX_INFO_FMT_ASYNC( rootLogger, LOG4CXX_STR("We can also align text to the {:<10} or {:>10}"), LOG4CXX_STR("left"), LOG4CXX_STR("right") );
+
+	MyStruct mine{ 42 };
+	LOG4CXX_INFO_FMT_ASYNC( rootLogger, LOG4CXX_STR("This custom type {} can also be logged, since it implements operator<<"), mine );
+
+	LOG4CXX_INFO_ASYNC( rootLogger, LOG4CXX_STR("Numbers can be formatted with excessive operator<<: ")
+				  << std::setprecision(3) << 22.456
+				  << LOG4CXX_STR(" And as hex: ")
+				  << std::setbase( 16 ) << 123 );
+	LOG4CXX_INFO_FMT_ASYNC( rootLogger, LOG4CXX_STR("Numbers can be formatted with a format string {:.1f} and as hex: {:x}"), 22.456, 123 );
+	// Uncomment the next line to verify that compile time type checking works
+	//LOG4CXX_INFO_FMT_ASYNC( rootLogger, LOG4CXX_STR("Numbers can be formatted with a format string {:.1f} and as hex: {:x}"), "wrong type", 123 );
+
+	LogManager::shutdown();
+	return 0;
+}

src/main/cpp/asyncbuffer.cpp

@@ -16,6 +16,7 @@
  */
 
 #include <log4cxx/helpers/asyncbuffer.h>
+#include <log4cxx/helpers/transcoder.h>
 
 namespace LOG4CXX_NS
 {
@@ -26,8 +27,59 @@ namespace helpers
 struct AsyncBuffer::Private
 {
 	std::vector<MessageBufferAppender> data;
+
+	Private(const MessageBufferAppender& f)
+		: data{ f }
+	{}
+
+#if LOG4CXX_ASYNC_BUFFER_SUPPORTS_FMT
+	StringViewType fmt_string;
+	FmtArgStore    fmt_args;
+
+	Private(StringViewType&& format_string, FmtArgStore&& args)
+		: fmt_string{ std::move(format_string) }
+		, fmt_args{ std::move(args) }
+	{}
+
+#if LOG4CXX_WCHAR_T_API || LOG4CXX_LOGCHAR_IS_WCHAR
+	WideStringViewType fmt_wstring;
+	WideFmtArgStore    fmt_wargs;
+
+	Private(WideStringViewType&& format_string, WideFmtArgStore&& args)
+		: fmt_wstring{ std::move(format_string) }
+		, fmt_wargs{ std::move(args) }
+	{}
+#endif // LOG4CXX_WCHAR_T_API || LOG4CXX_LOGCHAR_IS_WCHAR
+#endif // LOG4CXX_ASYNC_BUFFER_SUPPORTS_FMT
+
 };
 
+#if LOG4CXX_ASYNC_BUFFER_SUPPORTS_FMT
+void AsyncBuffer::initializeForFmt(StringViewType&& format_string, FmtArgStore&& args)
+{
+	if (!m_priv)
+		m_priv = std::make_unique<Private>(std::move(format_string), std::move(args));
+	else
+	{
+		m_priv->fmt_string = std::move(format_string);
+		m_priv->fmt_args = std::move(args);
+	}
+}
+
+#if LOG4CXX_WCHAR_T_API || LOG4CXX_LOGCHAR_IS_WCHAR
+void AsyncBuffer::initializeForFmt(WideStringViewType&& format_string, WideFmtArgStore&& args)
+{
+	if (!m_priv)
+		m_priv = std::make_unique<Private>(std::move(format_string), std::move(args));
+	else
+	{
+		m_priv->fmt_wstring = std::move(format_string);
+		m_priv->fmt_wargs = std::move(args);
+	}
+}
+#endif // LOG4CXX_WCHAR_T_API || LOG4CXX_LOGCHAR_IS_WCHAR
+#endif // LOG4CXX_ASYNC_BUFFER_SUPPORTS_FMT
+
 /** An empty buffer.
 */
 AsyncBuffer::AsyncBuffer()
@@ -49,16 +101,57 @@ AsyncBuffer::~AsyncBuffer()
 /**
 * Has no item been added to this?
 */
-bool AsyncBuffer::empty() const { return !m_priv || m_priv->data.empty(); }
+bool AsyncBuffer::empty() const
+{
+	bool result{ true };
+	if (m_priv)
+	{
+		result = m_priv->data.empty();
+#if LOG4CXX_ASYNC_BUFFER_SUPPORTS_FMT
+		if (result)
+			result = (0 == m_priv->fmt_string.size());
+#if LOG4CXX_WCHAR_T_API || LOG4CXX_LOGCHAR_IS_WCHAR
+		if (result)
+			result = (0 == m_priv->fmt_wstring.size());
+#endif // LOG4CXX_WCHAR_T_API || LOG4CXX_LOGCHAR_IS_WCHAR
+#endif
+	}
+	return result;
+}
 
 /**
 * Add text version of buffered values to \c msg
 */
-void AsyncBuffer::renderMessage(LogCharMessageBuffer& msg)
+void AsyncBuffer::renderMessage(LogCharMessageBuffer& msg) const
 {
 	if (m_priv)
+	{
 		for (auto& renderer : m_priv->data)
 			renderer(msg);
+#if LOG4CXX_ASYNC_BUFFER_SUPPORTS_FMT
+#if LOG4CXX_LOGCHAR_IS_UTF8
+		if (0 < m_priv->fmt_string.size())
+			msg << fmt::vformat(m_priv->fmt_string, m_priv->fmt_args);
+#if LOG4CXX_WCHAR_T_API
+		if (0 < m_priv->fmt_wstring.size())
+		{
+			LOG4CXX_DECODE_WCHAR(lsMsg, fmt::vformat(m_priv->fmt_wstring, m_priv->fmt_wargs));
+			msg << lsMsg;
+		}
+#endif // LOG4CXX_WCHAR_T_API
+#endif // LOG4CXX_LOGCHAR_IS_UTF8
+
+#if LOG4CXX_LOGCHAR_IS_WCHAR
+		if (0 < m_priv->fmt_wstring.size())
+			msg << fmt::vformat(m_priv->fmt_wstring, m_priv->fmt_wargs);
+		if (0 < m_priv->fmt_string.size())
+		{
+			LOG4CXX_DECODE_CHAR(lsMsg, fmt::vformat(m_priv->fmt_string, m_priv->fmt_args));
+			msg << lsMsg;
+		}
+#endif // LOG4CXX_LOGCHAR_IS_WCHAR
+#endif // LOG4CXX_ASYNC_BUFFER_SUPPORTS_FMT
+	}
 }
 
 /**
@@ -67,7 +160,15 @@ void AsyncBuffer::renderMessage(LogCharMessageBuffer& msg)
 void AsyncBuffer::clear()
 {
 	if (m_priv)
+	{
 		m_priv->data.clear();
+#if LOG4CXX_ASYNC_BUFFER_SUPPORTS_FMT
+		m_priv->fmt_string = {};
+#if LOG4CXX_WCHAR_T_API || LOG4CXX_LOGCHAR_IS_WCHAR
+		m_priv->fmt_wstring = {};
+#endif // LOG4CXX_WCHAR_T_API || LOG4CXX_LOGCHAR_IS_WCHAR
+#endif // LOG4CXX_ASYNC_BUFFER_SUPPORTS_FMT
+	}
 }
 
 /**
@@ -76,8 +177,9 @@ void AsyncBuffer::clear()
 void AsyncBuffer::append(const MessageBufferAppender& f)
 {
 	if (!m_priv)
-		m_priv = std::make_unique<Private>();
-	m_priv->data.push_back(f);
+		m_priv = std::make_unique<Private>(f);
+	else
+		m_priv->data.push_back(f);
 }
 
 } // namespace helpers

src/main/cpp/basicconfigurator.cpp

@@ -18,34 +18,63 @@
 #include <log4cxx/basicconfigurator.h>
 #include <log4cxx/patternlayout.h>
 #include <log4cxx/consoleappender.h>
+#include <log4cxx/asyncappender.h>
 #include <log4cxx/logmanager.h>
 #include <log4cxx/logger.h>
 #include <log4cxx/helpers/loglog.h>
 
 using namespace LOG4CXX_NS;
 
+namespace
+{
+
+LayoutPtr getDefaultLayout()
+{
+	auto pattern = LogString
+		{ helpers::LogLog::isColorEnabled()
+		? LOG4CXX_STR("%r [%t] %p %c %x - %Y%m%y%n")
+		: LOG4CXX_STR("%r [%t] %p %c %x - %m%n")
+		};
+	return std::make_shared<PatternLayout>(pattern);
+}
+
+} // namespace
+
+
 void BasicConfigurator::configure(const LayoutPtr& layoutArg)
 {
-	LogManager::getLoggerRepository()->setConfigured(true);
-	auto layout = layoutArg;
-	if (!layout)
-	{
-		auto pattern = LogString
-			{ helpers::LogLog::isColorEnabled()
-			? LOG4CXX_STR("%r [%t] %p %c %x - %Y%m%y%n")
-			: LOG4CXX_STR("%r [%t] %p %c %x - %m%n")
-			};
-		layout = std::make_shared<PatternLayout>(pattern);
-	}
-	auto appender = std::make_shared<ConsoleAppender>(layout);
-	Logger::getRootLogger()->addAppender(appender);
+	auto appender = std::make_shared<ConsoleAppender>(layoutArg ? layoutArg : getDefaultLayout());
+	appender->setName(LOG4CXX_STR("BasicConfigurator"));
+	auto r = LogManager::getLoggerRepository();
+	r->getRootLogger()->addAppender(appender);
+	r->setConfigured(true);
 }
 
 void BasicConfigurator::configure(const AppenderPtr& appender)
 {
-	LogManager::getLoggerRepository()->setConfigured(true);
-	LoggerPtr root = Logger::getRootLogger();
-	root->addAppender(appender);
+	auto r = LogManager::getLoggerRepository();
+	r->getRootLogger()->addAppender(appender);
+	r->setConfigured(true);
+}
+
+void BasicConfigurator::configureAsync(const LayoutPtr& layoutArg)
+{
+	auto ringBuffer = std::make_shared<AsyncAppender>();
+	ringBuffer->setName(LOG4CXX_STR("Default"));
+	ringBuffer->addAppender(std::make_shared<ConsoleAppender>(layoutArg ? layoutArg : getDefaultLayout()));
+	auto r = LogManager::getLoggerRepository();
+	r->getRootLogger()->addAppender(ringBuffer);
+	r->setConfigured(true);
+}
+
+void BasicConfigurator::configureAsync(const AppenderPtr& appender)
+{
+	auto ringBuffer = std::make_shared<AsyncAppender>();
+	ringBuffer->addAppender(appender);
+	ringBuffer->setName(LOG4CXX_STR("Default"));
+	auto r = LogManager::getLoggerRepository();
+	r->getRootLogger()->addAppender(ringBuffer);
+	r->setConfigured(true);
 }
 
 void BasicConfigurator::resetConfiguration()

src/main/include/CMakeLists.txt

@@ -164,6 +164,7 @@ foreach(varName
   HAS_PTHREAD_SIGMASK
   HAS_PTHREAD_SETNAME
   HAS_PTHREAD_GETNAME
+  ENABLE_FMT_ASYNC
   )
   if(${varName} EQUAL 0)
     continue()