lwlog Logging Library

You can categorize log messages using a hierarchical topic system. This is useful for filtering and organizing logs in complex applications.

• Use start_topic("Name") to begin a topic.
• Use end_topic() to close the current topic.
• Topics can be nested to create subtopics. The pattern flag %? shows the current topic, while %? (or {full_topic}) shows the full path of all topics and subtopics (e.g., topic1/topic2/topic3).

Example:

console->start_topic("Main Topic");
{
    console->start_topic("Sub Topic");
    console->critical("Message in both topics");
    console->end_topic();
}
console->end_topic();

#include "lwlog.h"

int main()
{
	auto console = std::make_shared<lwlog::console_logger>("CONSOLE");
	console->set_pattern("{full_topic} .red([%T] [%n]) .level([%l]): .cyan(%v)");

	console->start_topic("Main Topic");
	{
		console->start_topic("Sub Topic");
		{
			console->critical("Message in both topics");
		}
		console->end_topic();

		console->critical("Message in main topic");
	}
	console->end_topic();
	
	return 0;
}

The lwlog::logger template accepts several policy structures to define its behavior:

Execution Policies

Overflow Policies (for asynchronous_policy)

Flush Policies (for stream sinks like stdout/file)

Threading Policies

To extend lwlog, implement a custom sink by following these steps:

1. Inherit from lwlog::sinks::sink: The base class requires template parameters for BufferLimits, FlushPolicy, and ThreadingPolicy. The first template parameter of sink is a boolean indicating if the sink supports ANSI colors.
2. Implement sink_it(const details::record<BufferLimits>& record): This handles formatted log messages. You should set the current severity level, compile the pattern, and output the message. Crucially, call m_pattern.reset_pattern() to prevent data bleeding from previous logs due to the static buffer design.
3. Implement sink_it(std::string_view message): This handles raw messages. Since raw logs have no metadata, you simply output the string.
4. Handle Flushing: If your sink is stream-based, ensure you respect the FlushPolicy provided in the template.

namespace lwlog::sinks
{
	template<typename BufferLimits, typename FlushPolicy, typename ThreadingPolicy>
	class new_custom_sink
		: public sink</*EnableAnsiColors*/, BufferLimits, ThreadingPolicy>
	{
		using sink_t = sink</*EnableAnsiColors*/, BufferLimits, ThreadingPolicy>;

	public:
		void sink_it(const details::record<BufferLimits>& record) override
		{
        	sink_t::m_current_level = record.log_level;
			// sink message to somewhere
			sink_t::m_pattern.reset_pattern();
		}

		void sink_it(std::string_view message) override
		{
			// sink message to somewhere
		}
	};
}

For rapid integration, lwlog.h provides predefined aliases that come with default configurations.

Note on Thread-Safety: The standard aliases (e.g., console_logger) are not thread-safe. For multi-threaded applications, use the variants suffixed with _mt (e.g., async_console_logger_mt).

#include "lwlog.h"

int main()
{
	auto basic = std::make_shared<lwlog::basic_logger<lwlog::sinks::stdout_sink>>("CONSOLE");
	
	auto console = std::make_shared<lwlog::console_logger>("CONSOLE");
	auto file = std::make_shared<lwlog::file_logger>("FILE", "C:/Users/user/Desktop/LogFolder/LOGS.txt");
	
	return 0;
}

The first template parameter of lwlog::logger is lwlog::memory_buffer_limits. This allows you to tailor pre-allocated static buffers for specific use cases to optimize performance and memory usage.

Use lwlog::default_memory_buffer_limits for standard settings. Otherwise, you can specify individual limits using the following template structures:

#include "lwlog.h"

int main()
{
	using buffer_limits = lwlog::memory_buffer_limits<
		lwlog::pattern_limit<256>,
			lwlog::message_limit<128>,
				lwlog::argument_limit<64>,
				lwlog::arg_count_limit<4>,
				lwlog::padding_limit<24>,
				lwlog::conv_limit<64>
		>;

	auto console = std::make_shared<
		lwlog::logger<
			buffer_limits,
			lwlog::synchronous_policy,
			lwlog::default_flush_policy,
			lwlog::single_threaded_policy,
			lwlog::sinks::stdout_sink
		>
		>("CONSOLE");
	
	return 0;
}