LOGCXX-431

src/cmake/pthread/log4cxx-pthread.cmake

@@ -0,0 +1,6 @@
+include(FindThreads)
+
+try_compile(PTHREAD_SETNAME_NP_FOUND "${CMAKE_BINARY_DIR}/pthread-compile-tests"
+    "${CMAKE_CURRENT_LIST_DIR}/test-pthread.cpp"
+    LINK_LIBRARIES Threads::Threads )
+

src/cmake/pthread/test-pthread.cpp

@@ -0,0 +1,6 @@
+#include <pthread.h>
+
+int main(){
+	pthread_t tid;
+	pthread_setname_np(tid, "name");
+}

src/main/cpp/CMakeLists.txt

@@ -147,6 +147,7 @@ target_sources(log4cxx
   threadlocal.cpp
   threadpatternconverter.cpp
   threadspecificdata.cpp
+  threadutility.cpp
   throwableinformationpatternconverter.cpp
   timebasedrollingpolicy.cpp
   timezone.cpp

src/main/cpp/asyncappender.cpp

@@ -30,6 +30,7 @@
 #include <log4cxx/helpers/stringhelper.h>
 #include <apr_atomic.h>
 #include <log4cxx/helpers/optionconverter.h>
+#include <log4cxx/helpers/threadutility.h>
 
 
 using namespace log4cxx;
@@ -50,7 +51,7 @@ AsyncAppender::AsyncAppender()
 	  locationInfo(false),
 	  blocking(true)
 {
-	dispatcher = std::thread( &AsyncAppender::dispatch, this );
+	dispatcher = ThreadUtility::instance()->createThread( LOG4CXX_STR("AyncAppend"), &AsyncAppender::dispatch, this );
 }
 
 AsyncAppender::~AsyncAppender()

src/main/cpp/filewatchdog.cpp

@@ -23,6 +23,7 @@
 #include <apr_atomic.h>
 #include <log4cxx/helpers/transcoder.h>
 #include <log4cxx/helpers/exception.h>
+#include <log4cxx/helpers/threadutility.h>
 #include <functional>
 
 using namespace log4cxx;
@@ -92,7 +93,7 @@ void FileWatchdog::start()
 {
 	checkAndConfigure();
 
-	thread = std::thread( &FileWatchdog::run, this );
+	thread = ThreadUtility::instance()->createThread( LOG4CXX_STR("Filewatchdog"), &FileWatchdog::run, this );
 }
 
 bool FileWatchdog::is_interrupted()

src/main/cpp/socketappenderskeleton.cpp

@@ -26,6 +26,7 @@
 #include <log4cxx/spi/loggingevent.h>
 #include <log4cxx/helpers/transcoder.h>
 #include <log4cxx/helpers/bytearrayoutputstream.h>
+#include <log4cxx/helpers/threadutility.h>
 #include <functional>
 
 using namespace log4cxx;
@@ -162,7 +163,7 @@ void SocketAppenderSkeleton::fireConnector()
 	{
 		LogLog::debug(LOG4CXX_STR("Connector thread not alive: starting monitor."));
 
-		thread = std::thread( &SocketAppenderSkeleton::monitor, this );
+		thread = ThreadUtility::instance()->createThread( LOG4CXX_STR("SocketAppend"), &SocketAppenderSkeleton::monitor, this );
 	}
 }
 

src/main/cpp/sockethubappender.cpp

@@ -30,6 +30,7 @@
 #include <log4cxx/helpers/objectoutputstream.h>
 #include <log4cxx/helpers/socketoutputstream.h>
 #include <log4cxx/helpers/exception.h>
+#include <log4cxx/helpers/threadutility.h>
 #include <mutex>
 
 using namespace log4cxx;
@@ -177,7 +178,7 @@ void SocketHubAppender::append(const spi::LoggingEventPtr& event, Pool& p)
 
 void SocketHubAppender::startServer()
 {
-	thread = std::thread( &SocketHubAppender::monitor, this );
+	thread = ThreadUtility::instance()->createThread( LOG4CXX_STR("SocketHub"), &SocketHubAppender::monitor, this );
 }
 
 void SocketHubAppender::monitor()

src/main/cpp/telnetappender.cpp

@@ -24,6 +24,7 @@
 #include <apr_strings.h>
 #include <log4cxx/helpers/charsetencoder.h>
 #include <log4cxx/helpers/bytebuffer.h>
+#include <log4cxx/helpers/threadutility.h>
 #include <mutex>
 
 using namespace log4cxx;
@@ -61,7 +62,7 @@ void TelnetAppender::activateOptions(Pool& /* p */)
 		serverSocket->setSoTimeout(1000);
 	}
 
-	sh = std::thread( &TelnetAppender::acceptConnections, this );
+	sh = ThreadUtility::instance()->createThread( LOG4CXX_STR("TelnetAppend"), &TelnetAppender::acceptConnections, this );
 }
 
 void TelnetAppender::setOption(const LogString& option,

src/main/cpp/threadutility.cpp

@@ -0,0 +1,91 @@
+#include "log4cxx/helpers/threadutility.h"
+#include "log4cxx/private/log4cxx_private.h"
+#include "log4cxx/helpers/loglog.h"
+
+#include <signal.h>
+
+#if LOG4CXX_HAS_SETTHREADDESCRIPTION
+#include <windows.h>
+#include <processthreadsapi.h>
+#endif
+
+using log4cxx::helpers::ThreadUtility;
+
+struct ThreadUtility::priv_data{
+	priv_data(){
+		pre_start = nullptr;
+		thread_start = nullptr;
+		post_start = nullptr;
+	}
+
+	log4cxx::helpers::pre_thread_start pre_start;
+	log4cxx::helpers::thread_started thread_start;
+	log4cxx::helpers::post_thread_start post_start;
+};
+
+ThreadUtility::ThreadUtility() :
+	m_priv( new priv_data() )
+{}
+
+ThreadUtility::~ThreadUtility(){}
+
+std::shared_ptr<ThreadUtility> ThreadUtility::instance(){
+	static std::shared_ptr<ThreadUtility> instance( new ThreadUtility() );
+	return instance;
+}
+
+void ThreadUtility::configureThreadFunctions( pre_thread_start pre_start1,
+							   thread_started started,
+							   post_thread_start post_start1 ){
+	m_priv->pre_start = pre_start1;
+	m_priv->thread_start = started;
+	m_priv->post_start = post_start1;
+}
+
+void ThreadUtility::preThreadBlockSignals(){
+#if LOG4CXX_HAS_PTHREAD_SIGMASK
+	sigset_t set;
+	sigfillset(&set);
+	if( pthread_sigmask(SIG_SETMASK, &set, nullptr) < 0 ){
+		LOGLOG_ERROR( LOG4CXX_STR("Unable to set thread sigmask") );
+	}
+#endif /* LOG4CXX_HAS_PTHREAD_SIGMASK */
+}
+
+void ThreadUtility::threadStartedNameThread(LogString threadName,
+							 std::thread::id /*thread_id*/,
+							 std::thread::native_handle_type native_handle){
+#if LOG4CXX_HAS_PTHREAD_SETNAME
+	if( pthread_setname_np( static_cast<pthread_t>( native_handle ), threadName.c_str() ) < 0 ){
+		LOGLOG_ERROR( LOG4CXX_STR("unable to set thread name") );
+	}
+#elif LOG4CXX_HAS_SETTHREADDESCRIPTION
+	HRESULT hr = SetThreadDescription(static_cast<HANDLE>(native_handle), threadName.c_str());
+	if(FAILED(hr)){
+		LOGLOG_ERROR( LOG4CXX_STR("unable to set thread name") );
+	}
+#endif
+}
+
+void ThreadUtility::postThreadUnblockSignals(){
+#if LOG4CXX_HAS_PTHREAD_SIGMASK
+	sigset_t set;
+	sigemptyset(&set);
+	if( pthread_sigmask(SIG_SETMASK, &set, nullptr) < 0 ){
+		LOGLOG_ERROR( LOG4CXX_STR("Unable to set thread sigmask") );
+	}
+#endif /* LOG4CXX_HAS_PTHREAD_SIGMASK */
+}
+
+
+log4cxx::helpers::pre_thread_start ThreadUtility::preStartFunction(){
+	return m_priv->pre_start;
+}
+
+log4cxx::helpers::thread_started ThreadUtility::threadStartedFunction(){
+	return m_priv->thread_start;
+}
+
+log4cxx::helpers::post_thread_start ThreadUtility::postStartFunction(){
+	return m_priv->post_start;
+}

src/main/include/CMakeLists.txt

@@ -85,8 +85,26 @@ CHECK_FUNCTION_EXISTS(wcstombs HAS_WCSTOMBS)
 CHECK_FUNCTION_EXISTS(fwide HAS_FWIDE)
 CHECK_LIBRARY_EXISTS(esmtp smtp_create_session "" HAS_LIBESMTP)
 CHECK_FUNCTION_EXISTS(syslog HAS_SYSLOG)
+if(UNIX)
+    set(CMAKE_REQUIRED_LIBRARIES "pthread")
+    CHECK_SYMBOL_EXISTS(pthread_sigmask "signal.h" HAS_PTHREAD_SIGMASK)
+
+    # Check for the (linux) pthread_setname_np.
+    # OSX and BSD are special apparently.  OSX only lets you name
+    # the current thread, while BSD calls it pthread_set_name_np.
+    # Since this is really not a core feature and the end-user can configure
+    # it anyway, we're only going to worry about linux.
+    include(${LOG4CXX_SOURCE_DIR}/src/cmake/pthread/log4cxx-pthread.cmake)
+    if(${PTHREAD_SETNAME_NP_FOUND})
+	set(HAS_PTHREAD_SETNAME 1)
+    endif()
+endif(UNIX)
 
-foreach(varName HAS_STD_LOCALE  HAS_ODBC  HAS_MBSRTOWCS  HAS_WCSTOMBS  HAS_FWIDE  HAS_LIBESMTP  HAS_SYSLOG)
+if(WIN32)
+    CHECK_SYMBOL_EXISTS(SetThreadDescription "windows.h;processthreadsapi.h" HAS_SETTHREADDESCRIPTION)
+endif(WIN32)
+
+foreach(varName HAS_STD_LOCALE  HAS_ODBC  HAS_MBSRTOWCS  HAS_WCSTOMBS  HAS_FWIDE  HAS_LIBESMTP  HAS_SYSLOG HAS_PTHREAD_SIGMASK HAS_PTHREAD_SETNAME HAS_SETTHREADDESCRIPTION)
   if(${varName} EQUAL 0)
     continue()
   elseif(${varName} EQUAL 1)

src/main/include/log4cxx/helpers/threadutility.h

@@ -0,0 +1,119 @@
+#ifndef _LOG4CXX_THREADUTILITY_H
+#define _LOG4CXX_THREADUTILITY_H
+
+#include <thread>
+#include <functional>
+#include <memory>
+
+#include "log4cxx/logstring.h"
+
+namespace log4cxx {
+namespace helpers {
+
+/**
+ * A function that will be called before a thread is started.  This can
+ * be used to (for example) block all of the signals in the thread, so
+ * that when the thread is created it will have a correct signal mask.
+ */
+typedef std::function<void()> pre_thread_start;
+
+/**
+ * Called when a new thread has started.  This can be used to set
+ * parameters for the thread in a platform-specific manner.
+ *
+ * @param threadName The name of the thread
+ * @param thread_id The ID of the thread as reported by std::thread::get_id
+ * @param native_handle The native handle of the thread, as reported by
+ * std::thread::native_handle
+ */
+typedef std::function<void( LogString threadName,
+                                std::thread::id thread_id,
+                                std::thread::native_handle_type native_handle )> thread_started;
+
+/**
+ * Called after a thread has started. This can be used to (for example)
+ * unblock the signals in the thread.
+ */
+typedef std::function<void()> post_thread_start;
+
+class ThreadUtility;
+LOG4CXX_PTR_DEF(ThreadUtility);
+
+class LOG4CXX_EXPORT ThreadUtility {
+private:
+	ThreadUtility();
+
+	log4cxx::helpers::pre_thread_start preStartFunction();
+	log4cxx::helpers::thread_started threadStartedFunction();
+	log4cxx::helpers::post_thread_start postStartFunction();
+
+	struct priv_data;
+	std::unique_ptr<priv_data> m_priv;
+
+public:
+	~ThreadUtility();
+
+	static std::shared_ptr<ThreadUtility> instance();
+
+	/**
+	 * Configure the thread functions that log4cxx will use.
+	 * Note that setting any of these parameters to nullptr is valid,
+	 * and simply results in the callback not being called.	 *
+	 */
+	void configureThreadFunctions( pre_thread_start pre_start,
+								   thread_started started,
+								   post_thread_start post_start );
+
+	/**
+	 * A pre-start thread function that blocks signals to the new thread
+	 * (if the system has pthreads).  If the system does not have pthreads,
+	 * is equivalent to preThreadDoNothing();
+	 */
+	void preThreadBlockSignals();
+
+	/**
+	 * A thread_started function that names the thread using the appropriate
+	 * system call.
+	 */
+	void threadStartedNameThread(LogString threadName,
+								 std::thread::id thread_id,
+								 std::thread::native_handle_type native_handle);
+
+	/**
+	 * A post-start thread function that unblocks signals that preThreadBlockSignals
+	 * blocked before starting the thread.  If the system does not have pthreads,
+	 * is equivalent to postThreadDoNothing();
+	 */
+	void postThreadUnblockSignals();
+
+	/**
+	 * Start a thread
+	 */
+	template<class Function, class... Args>
+	std::thread createThread(LogString name,
+							 Function&& f,
+							 Args&&... args){
+		log4cxx::helpers::pre_thread_start pre_start = preStartFunction();
+		log4cxx::helpers::thread_started thread_start = threadStartedFunction();
+		log4cxx::helpers::post_thread_start post_start = postStartFunction();
+
+		if( pre_start ){
+			pre_start();
+		}
+		std::thread t( f, args... );
+		if( thread_start ){
+			thread_start( name,
+					  t.get_id(),
+					  t.native_handle() );
+		}
+		if( post_start ){
+			post_start();
+		}
+		return t;
+	}
+};
+
+} /* namespace helpers */
+} /* namespace log4cxx */
+
+#endif

src/main/include/log4cxx/private/log4cxx_private.h.in

@@ -53,6 +53,10 @@
 #define LOG4CXX_WIN32_THREAD_FMTSPEC "0x%.8x"
 #define LOG4CXX_APR_THREAD_FMTSPEC "0x%pt"
 
+#define LOG4CXX_HAS_PTHREAD_SIGMASK @HAS_PTHREAD_SIGMASK@
+#define LOG4CXX_HAS_PTHREAD_SETNAME @HAS_PTHREAD_SETNAME@
+#define LOG4CXX_HAS_SETTHREADDESCRIPTION @HAS_SETTHREADDESCRIPTION@
+
 #ifdef __BORLANDC__
 /*
  * embarcadero/RAD Studio compilers don't support thread_local:

src/site/markdown/1-usage.md

@@ -24,6 +24,7 @@ Usage {#usage-overview}
 See the following pages for usage information:
 
 * @subpage usage
+* @subpage threading
 * @subpage extending-log4cxx
 * @subpage faq
 * @subpage configuration-samples