writer_builder_example.cpp File Reference

Demonstrates writer_builder usage patterns. More...

#include <kcenon/logger/builders/writer_builder.h>
#include <kcenon/logger/core/logger.h>
#include <kcenon/logger/interfaces/log_filter_interface.h>
#include <kcenon/logger/writers/async_writer.h>
#include <iostream>
#include <memory>

Include dependency graph for writer_builder_example.cpp:

Go to the source code of this file.

Classes
class	level_filter
	Custom filter that only allows specific log levels. More...

Functions
void	example_basic_file_writer ()
	Example 1: Basic file writer.
void	example_async_buffered_file ()
	Example 2: Async + Buffered File Writer.
void	example_filtered_console ()
	Example 3: Console Writer with Filtering.
void	example_production_setup ()
	Example 5: Production Setup with Multiple Writers.
void	example_builder_vs_manual ()
	Example 6: Comparing Builder vs Manual Composition.
int	main ()

Detailed Description

Demonstrates writer_builder usage patterns.

Author

kcenon

Since

4.1.0

Definition in file writer_builder_example.cpp.

Function Documentation

example_async_buffered_file()

void example_async_buffered_file

(

)

Example 2: Async + Buffered File Writer.

High-performance setup combining buffering and async writing.

• Buffered: Batches up to 500 entries before writing
• Async: Processes writes in background thread with 20000-entry queue

Examples

writer_builder_example.cpp.

Definition at line 77 of file writer_builder_example.cpp.

                                   {
    std::cout << "\n=== Example 2: Async + Buffered File Writer ===\n";
 
    auto writer = writer_builder()
        .file("app.log")
        .buffered(500)       // Buffer up to 500 entries
        .async(20000)        // Large queue for high throughput
        .build();
 
    std::cout << "Created async+buffered writer: " << writer->get_name() << "\n";
    std::cout << "  - Buffering reduces I/O operations\n";
    std::cout << "  - Async processing enables high throughput\n";
 
    // Note: async_writer needs to be started
    if (auto* async_w = dynamic_cast<async_writer*>(writer.get())) {
        async_w->start();
        std::cout << "  - Async writer started\n";
        async_w->stop();
    }
}

Referenced by main().

Here is the caller graph for this function:

example_basic_file_writer()

void example_basic_file_writer

(

)

Example 1: Basic file writer.

The simplest usage - just a file writer with no decorators.

Examples

writer_builder_example.cpp.

Definition at line 60 of file writer_builder_example.cpp.

                                 {
    std::cout << "\n=== Example 1: Basic File Writer ===\n";
 
    auto writer = writer_builder()
        .file("basic.log")
        .build();
 
    std::cout << "Created basic file writer: " << writer->get_name() << "\n";
}

Referenced by main().

Here is the caller graph for this function:

example_builder_vs_manual()

void example_builder_vs_manual

(

)

Example 6: Comparing Builder vs Manual Composition.

Shows the difference between using the builder and manual nesting.

Examples

writer_builder_example.cpp.

Definition at line 218 of file writer_builder_example.cpp.

                                 {
    std::cout << "\n=== Example 6: Builder vs Manual Composition ===\n";
 
    std::cout << "\nManual composition (verbose):\n";
    std::cout << "  auto writer = std::make_unique<async_writer>(\n";
    std::cout << "      std::make_unique<buffered_writer>(\n";
    std::cout << "          std::make_unique<file_writer>(\"app.log\"),\n";
    std::cout << "          500\n";
    std::cout << "      ),\n";
    std::cout << "      20000\n";
    std::cout << "  );\n";
 
    std::cout << "\nBuilder pattern (readable):\n";
    std::cout << "  auto writer = writer_builder()\n";
    std::cout << "      .file(\"app.log\")\n";
    std::cout << "      .buffered(500)\n";
    std::cout << "      .async(20000)\n";
    std::cout << "      .build();\n";
 
    auto writer = writer_builder()
        .file("app.log")
        .buffered(500)
        .async(20000)
        .build();
 
    std::cout << "\nResult: " << writer->get_name() << "\n";
    std::cout << "Benefits:\n";
    std::cout << "  ✓ More readable and self-documenting\n";
    std::cout << "  ✓ Less error-prone (no manual nesting)\n";
    std::cout << "  ✓ Easy to add/remove decorators\n";
    std::cout << "  ✓ Type-safe at compile time\n";
 
    if (auto* async_w = dynamic_cast<async_writer*>(writer.get())) {
        async_w->start();
        async_w->stop();
    }
}

Referenced by main().

Here is the caller graph for this function:

example_filtered_console()

void example_filtered_console

(

)

Example 3: Console Writer with Filtering.

Console writer that only logs warnings and errors.

Examples

writer_builder_example.cpp.

Definition at line 103 of file writer_builder_example.cpp.

                                {
    std::cout << "\n=== Example 3: Filtered Console Writer ===\n";
 
    auto filter = std::make_unique<level_filter>(log_level::warning);
 
    auto writer = writer_builder()
        .console()
        .filtered(std::move(filter))
        .build();
 
    std::cout << "Created filtered console writer: " << writer->get_name() << "\n";
    std::cout << "  - Only logs WARNING and above\n";
}

Referenced by main().

Here is the caller graph for this function:

example_production_setup()

void example_production_setup

(

)

Example 5: Production Setup with Multiple Writers.

Realistic production scenario with multiple log destinations:

• Main log: All messages with async+buffered
• Error log: Only errors with separate file

Definition at line 162 of file writer_builder_example.cpp.

                                {
    std::cout << "\n=== Example 5: Production Multi-Writer Setup ===\n";
 
    logger log;
 
    // Main log: async file with buffering
    auto main_writer = writer_builder()
        .file("app.log")
        .buffered(500)
        .async(20000)
        .build();
 
    std::cout << "Main writer: " << main_writer->get_name() << "\n";
 
    // Start async writer before adding to logger
    if (auto* async_main = dynamic_cast<async_writer*>(main_writer.get())) {
        async_main->start();
    }
 
    log.add_writer("main", std::move(main_writer));
 
    // Error log: separate file for errors only
    auto error_filter = std::make_unique<level_filter>(log_level::error);
 
    auto error_writer = writer_builder()
        .file("errors.log")
        .filtered(std::move(error_filter))
        .async()
        .build();
 
    std::cout << "Error writer: " << error_writer->get_name() << "\n";
 
    if (auto* async_error = dynamic_cast<async_writer*>(error_writer.get())) {
        async_error->start();
    }
 
    log.add_writer("errors", std::move(error_writer));
 
    // Log some messages
    std::cout << "\nLogging messages:\n";
    log.log(log_level::info, std::string("Application started"));
    log.log(log_level::warning, std::string("Low disk space"));
    log.log(log_level::error, std::string("Failed to connect to database"));
 
    std::cout << "  - INFO: Goes to app.log\n";
    std::cout << "  - WARNING: Goes to app.log\n";
    std::cout << "  - ERROR: Goes to both app.log and errors.log\n";
 
    log.flush();
}

References kcenon::logger::logger::add_writer(), kcenon::logger::logger::flush(), and kcenon::logger::logger::log().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main

(

)

Definition at line 256 of file writer_builder_example.cpp.

           {
    std::cout << "Writer Builder Examples\n";
    std::cout << "=======================\n";
    std::cout << "\nThese examples demonstrate how to use writer_builder\n";
    std::cout << "to compose log writers using the Decorator pattern.\n";
 
    try {
        example_basic_file_writer();
        example_async_buffered_file();
        example_filtered_console();
 
#ifdef LOGGER_WITH_ENCRYPTION
        example_encrypted_logging();
#else
        std::cout << "\n=== Example 4: Encrypted Logging ===\n";
        std::cout << "Skipped (LOGGER_WITH_ENCRYPTION not defined)\n";
#endif
 
        example_production_setup();
        example_builder_vs_manual();
 
        std::cout << "\n=== All Examples Completed Successfully ===\n";
    } catch (const std::exception& e) {
        std::cerr << "\nError: " << e.what() << "\n";
        return 1;
    }
 
    return 0;
}

References example_async_buffered_file(), example_basic_file_writer(), example_builder_vs_manual(), example_filtered_console(), and example_production_setup().

Here is the call graph for this function: