fix(FastLogger): enable SplitterChannel #5379

Author: aleks-f

Foundation/include/Poco/SplitterChannel.h

@@ -63,6 +63,12 @@ class Foundation_API SplitterChannel: public Channel
 	int count() const;
 		/// Returns the number of channels in the SplitterChannel.
 
+	Channel::Ptr getChannel(int index) const;
+		/// Returns the channel at the given (0-based) index, or null when index
+		/// is out of range. Together with count() this lets callers enumerate the
+		/// attached channels (e.g. FastLogger maps a SplitterChannel onto
+		/// multiple Quill sinks).
+
 protected:
 	~SplitterChannel() override;
 

Foundation/src/FastLogger.cpp

@@ -33,6 +33,7 @@
 #include "Poco/PatternFormatter.h"
 #include "Poco/AsyncChannel.h"
 #include "Poco/SplitterChannel.h"
+#include "Poco/EventChannel.h"
 #include "Poco/StreamChannel.h"
 #include "Poco/Environment.h"
 #if defined(POCO_OS_FAMILY_UNIX) && !defined(POCO_NO_SYSLOG_CHANNEL)
@@ -739,14 +740,16 @@ void collectSinksFromChannel(Channel::Ptr pChannel, SinkInfo& info)
 		return;
 	}
 
-	// SplitterChannel - the internal channel list is not accessible, so we fall back to console.
-	// Users needing multiple sinks should configure them directly with FastLogger::addFileSink()
-	// or by creating multiple FastLoggers.
-	if (dynamic_cast<SplitterChannel*>(pChannel.get()))
+	// SplitterChannel - recurse into each attached channel so a single
+	// root.channel = splitter (e.g. console + file) maps to multiple Quill
+	// sinks, and per-child PatternFormatter patterns are picked up. (Previously
+	// this fell back to a lone console sink because SplitterChannel exposed no
+	// accessor for its children, so file output and formatting were lost.)
+	if (SplitterChannel* pSplitter = dynamic_cast<SplitterChannel*>(pChannel.get()))
 	{
-		// SplitterChannel's _channels vector is private with no accessor.
-		// Fall back to console as a reasonable default.
-		info.sinks.push_back(getConsoleSink());
+		const int n = pSplitter->count();
+		for (int i = 0; i < n; ++i)
+			collectSinksFromChannel(pSplitter->getChannel(i), info);
 		return;
 	}
 
@@ -894,6 +897,18 @@ void collectSinksFromChannel(Channel::Ptr pChannel, SinkInfo& info)
 	}
 #endif
 
+	// EventChannel - dispatches Poco Messages to in-process listeners (e.g. a
+	// web console). FastLogger/Quill bypasses Poco's Message/Channel pipeline
+	// entirely, so it cannot feed an EventChannel. Skip it (rather than add a
+	// spurious duplicate console sink via the fallback below) and warn.
+	if (dynamic_cast<EventChannel*>(pChannel.get()))
+	{
+		std::cerr << "FastLogger warning: EventChannel is not supported by the fast "
+		          << "logger; its output is omitted. Use a regular Logger for that "
+		          << "channel if you need it." << std::endl;
+		return;
+	}
+
 	// Unknown channel type - fall back to console
 	info.sinks.push_back(getConsoleSink());
 }
@@ -956,6 +971,21 @@ void FastLogger::setChannel(Channel::Ptr pChannel)
 	SinkInfo info;
 	collectSinksFromChannel(pChannel, info);
 
+	// Some sinks are process-wide singletons (e.g. the shared console sink), so a
+	// channel tree can surface the same sink more than once; de-duplicate so Quill
+	// doesn't emit each line multiple times.
+	if (info.sinks.size() > 1)
+	{
+		std::vector<std::shared_ptr<quill::Sink>> uniqueSinks;
+		for (auto& s: info.sinks)
+		{
+			bool dup = false;
+			for (auto& u: uniqueSinks) { if (u == s) { dup = true; break; } }
+			if (!dup) uniqueSinks.push_back(s);
+		}
+		info.sinks.swap(uniqueSinks);
+	}
+
 	if (!info.sinks.empty())
 	{
 		// Quill doesn't support changing sinks on an existing logger.

Foundation/src/SplitterChannel.cpp

@@ -105,4 +105,14 @@ int SplitterChannel::count() const
 }
 
 
+Channel::Ptr SplitterChannel::getChannel(int index) const
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	if (index >= 0 && index < (int) _channels.size())
+		return _channels[index];
+	return Channel::Ptr();
+}
+
+
 } // namespace Poco

Foundation/testsuite/src/FastLoggerChannelsTest.cpp

@@ -32,6 +32,7 @@
 #include "Poco/PatternFormatter.h"
 #include "Poco/AsyncChannel.h"
 #include "Poco/SplitterChannel.h"
+#include "Poco/EventChannel.h"
 #include "Poco/File.h"
 #include "Poco/TemporaryFile.h"
 #include "Poco/FileStream.h"
@@ -53,6 +54,7 @@ using Poco::FormattingChannel;
 using Poco::PatternFormatter;
 using Poco::AsyncChannel;
 using Poco::SplitterChannel;
+using Poco::EventChannel;
 using Poco::Channel;
 using Poco::Message;
 using Poco::AutoPtr;
@@ -281,21 +283,82 @@ void FastLoggerChannelsTest::testAsyncChannel()
 
 void FastLoggerChannelsTest::testSplitterChannel()
 {
-	// Test SplitterChannel handling
-	// Note: SplitterChannel's internal channels are private, so FastLogger
-	// falls back to console output. Use NullChannel for test.
-	AutoPtr<NullChannel> pNullChannel(new NullChannel);
+	// A SplitterChannel must fan out to ALL its children. Previously FastLogger
+	// could not see inside a SplitterChannel and fell back to a single console
+	// sink, losing file output and per-child patterns. Verify both children of
+	// the splitter receive the (formatted) output.
+	std::string file1 = TemporaryFile::tempName() + "_split1.log";
+	std::string file2 = TemporaryFile::tempName() + "_split2.log";
+
+	AutoPtr<FileChannel> pFile1(new FileChannel(file1));
+	// Wrap the second file in a FormattingChannel so we also exercise pattern
+	// extraction through the splitter.
+	AutoPtr<FileChannel> pFile2(new FileChannel(file2));
+	AutoPtr<PatternFormatter> pFormatter(new PatternFormatter("[%p] %t"));
+	AutoPtr<FormattingChannel> pFmt2(new FormattingChannel(pFormatter, pFile2));
+
+	AutoPtr<SplitterChannel> pSplitter(new SplitterChannel);
+	pSplitter->addChannel(pFile1);
+	pSplitter->addChannel(pFmt2);
+
+	// SplitterChannel introspection API (used by FastLogger to map a splitter
+	// onto multiple sinks).
+	assertTrue(pSplitter->count() == 2);
+	assertTrue(pSplitter->getChannel(0).get() == pFile1.get());
+	assertTrue(pSplitter->getChannel(1).get() == pFmt2.get());
+	assertTrue(pSplitter->getChannel(2).isNull());
+	assertTrue(pSplitter->getChannel(-1).isNull());
 
 	FastLogger& logger = FastLogger::get("TestAdapters.SplitterChannel");
-	logger.setChannel(pNullChannel);  // Use null to avoid console spam
+	logger.setChannel(pSplitter);
 	logger.setLevel(Message::PRIO_TRACE);
+	logger.information("splitter routed message");
+	logger.flush();
+
+	// Both children received output - not just a single console fallback.
+	File f1(file1);
+	File f2(file2);
+	assertTrue(f1.exists() && f1.getSize() > 0);
+	assertTrue(f2.exists() && f2.getSize() > 0);
+
+	// The message reached the file sinks (pattern was extracted via the splitter).
+	Poco::FileInputStream fis(file2);
+	std::string content;
+	std::getline(fis, content);
+	fis.close();
+	assertTrue(content.find("splitter routed message") != std::string::npos);
+
+	try { f1.remove(); } catch (...) {}
+	try { f2.remove(); } catch (...) {}
+}
 
-	// Log messages
-	logger.information("Test message to splitter channel (falls back to console)");
 
+void FastLoggerChannelsTest::testEventChannelSkipped()
+{
+	// EventChannel cannot be mapped to a Quill sink (FastLogger bypasses Poco's
+	// Message/Channel pipeline). FastLogger must skip it gracefully - no crash,
+	// no spurious duplicate console sink - while still serving the splitter's
+	// other children. (A warning is printed to stderr; that is expected.)
+	std::string tempFile = TemporaryFile::tempName() + "_evt.log";
+
+	AutoPtr<FileChannel> pFile(new FileChannel(tempFile));
+	AutoPtr<EventChannel> pEvent(new EventChannel);
+
+	AutoPtr<SplitterChannel> pSplitter(new SplitterChannel);
+	pSplitter->addChannel(pEvent);
+	pSplitter->addChannel(pFile);
+
+	FastLogger& logger = FastLogger::get("TestAdapters.SplitterEventChannel");
+	logger.setChannel(pSplitter);
+	logger.setLevel(Message::PRIO_TRACE);
+	logger.information("message with an EventChannel sibling");
 	logger.flush();
 
-	// Test passes if no crash occurs
+	// The FileChannel sibling still works despite the unsupported EventChannel.
+	File file(tempFile);
+	assertTrue(file.exists() && file.getSize() > 0);
+
+	try { file.remove(); } catch (...) {}
 }
 
 
@@ -346,6 +409,7 @@ CppUnit::Test* FastLoggerChannelsTest::suite()
 	CppUnit_addTest(pSuite, FastLoggerChannelsTest, testFormattingChannel);
 	CppUnit_addTest(pSuite, FastLoggerChannelsTest, testAsyncChannel);
 	CppUnit_addTest(pSuite, FastLoggerChannelsTest, testSplitterChannel);
+	CppUnit_addTest(pSuite, FastLoggerChannelsTest, testEventChannelSkipped);
 #if defined(POCO_OS_FAMILY_UNIX) && !defined(POCO_NO_SYSLOG_CHANNEL)
 	CppUnit_addTest(pSuite, FastLoggerChannelsTest, testSyslogChannel);
 #endif
@@ -426,6 +490,12 @@ void FastLoggerChannelsTest::testSplitterChannel()
 }
 
 
+void FastLoggerChannelsTest::testEventChannelSkipped()
+{
+	// FastLogger not enabled
+}
+
+
 #if defined(POCO_OS_FAMILY_UNIX) && !defined(POCO_NO_SYSLOG_CHANNEL)
 void FastLoggerChannelsTest::testSyslogChannel()
 {

Foundation/testsuite/src/FastLoggerChannelsTest.h

@@ -34,6 +34,7 @@ class FastLoggerChannelsTest: public CppUnit::TestCase
 	void testFormattingChannel();
 	void testAsyncChannel();
 	void testSplitterChannel();
+	void testEventChannelSkipped();
 #if defined(POCO_OS_FAMILY_UNIX) && !defined(POCO_NO_SYSLOG_CHANNEL)
 	void testSyslogChannel();
 #endif