writer_factory.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <memory>
#include <string>
#include <unordered_map>
#include <functional>
#include <chrono>
 
#include "../writers/base_writer.h"
#include "../writers/console_writer.h"
#include "../writers/file_writer.h"
#include "../writers/rotating_file_writer.h"
#include "../writers/network_writer.h"
#include "../writers/batch_writer.h"
 
namespace kcenon::logger {
 
class writer_factory {
public:
    using creator_fn = std::function<log_writer_ptr()>;
 
    //========================================================================
    // Static Factory Methods
    //========================================================================
 
    static log_writer_ptr create_console(
        bool use_stderr = false,
        bool auto_detect_color = true
    ) {
        return std::make_unique<console_writer>(use_stderr, auto_detect_color);
    }
 
    static log_writer_ptr create_file(
        const std::string& filename,
        bool append = true,
        std::size_t buffer_size = 8192
    ) {
        return std::make_unique<file_writer>(filename, append, buffer_size);
    }
 
    static log_writer_ptr create_rotating_file(
        const std::string& filename,
        std::size_t max_size,
        std::size_t max_files,
        std::size_t check_interval = 100
    ) {
        return std::make_unique<rotating_file_writer>(
            filename, max_size, max_files, check_interval
        );
    }
 
    static log_writer_ptr create_rotating_file(
        const std::string& filename,
        rotation_type type,
        std::size_t max_files,
        std::size_t check_interval = 100
    ) {
        return std::make_unique<rotating_file_writer>(
            filename, type, max_files, check_interval
        );
    }
 
    static log_writer_ptr create_network(
        const std::string& host,
        uint16_t port,
        network_writer::protocol_type protocol = network_writer::protocol_type::tcp,
        std::size_t buffer_size = 8192,
        std::chrono::seconds reconnect_interval = std::chrono::seconds(5)
    ) {
        return std::make_unique<network_writer>(
            host, port, protocol, buffer_size, reconnect_interval
        );
    }
 
    static log_writer_ptr create_batch(
        log_writer_ptr writer,
        std::size_t batch_size = 100,
        std::chrono::milliseconds flush_interval = std::chrono::milliseconds(1000)
    ) {
        batch_writer::config cfg;
        cfg.max_batch_size = batch_size;
        cfg.flush_interval = flush_interval;
        return std::make_unique<batch_writer>(std::move(writer), cfg);
    }
 
    //========================================================================
    // Preset Factory Methods
    //========================================================================
 
    static log_writer_ptr create_development() {
        return create_console(false, true);
    }
 
    static log_writer_ptr create_production(
        const std::string& log_directory = "./logs",
        const std::string& filename = "app.log"
    ) {
        std::string full_path = log_directory + "/" + filename;
        auto rotating = create_rotating_file(
            full_path,
            100 * 1024 * 1024,  // 100MB
            10
        );
        return create_batch(std::move(rotating), 200, std::chrono::milliseconds(2000));
    }
 
    static log_writer_ptr create_high_performance(
        const std::string& filename = "./logs/app.log"
    ) {
        auto file = std::make_unique<file_writer>(filename, true, 65536);
        return create_batch(std::move(file), 500, std::chrono::milliseconds(5000));
    }
 
    //========================================================================
    // Registry Pattern
    //========================================================================
 
    static void register_type(const std::string& name, creator_fn creator) {
        registry()[name] = std::move(creator);
    }
 
    static log_writer_ptr create(const std::string& name) {
        auto it = registry().find(name);
        if (it == registry().end()) {
            return nullptr;
        }
        return it->second();
    }
 
    static bool has_type(const std::string& name) {
        return registry().find(name) != registry().end();
    }
 
private:
    static std::unordered_map<std::string, creator_fn>& registry() {
        static std::unordered_map<std::string, creator_fn> instance;
        return instance;
    }
};
 
} // namespace kcenon::logger