critical_writer.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 "base_writer.h"
#include "../interfaces/writer_category.h"
 
#include <kcenon/logger/logger_export.h>
 
#include <atomic>
#include <memory>
#include <mutex>
#include <fstream>
#include <functional>
 
namespace kcenon::logger {
 
struct critical_writer_config {
    bool force_flush_on_critical = true;
 
    bool force_flush_on_error = false;
 
    // Signal handling is managed by logger and signal_manager (DI pattern).
    // Use logger_context for signal handling instead.
 
    bool write_ahead_log = false;
 
    std::string wal_path = "logs/.wal";
 
    bool sync_on_critical = true;
 
    uint32_t critical_write_timeout_ms = 5000;
};
 
class LOGGER_SYSTEM_API critical_writer : public base_writer, public decorator_writer_tag {
public:
    explicit critical_writer(
        log_writer_ptr wrapped_writer,
        critical_writer_config config = {}
    );
 
    ~critical_writer() override;
 
    common::VoidResult write(const log_entry& entry) override;
 
    common::VoidResult flush() override;
 
    bool is_healthy() const override;
 
    std::string get_name() const override;
 
    void set_use_color(bool use_color) override;
 
    void set_force_flush_on_critical(bool enable);
 
    const critical_writer_config& get_config() const { return config_; }
 
    struct critical_stats {
        std::atomic<uint64_t> total_critical_writes{0};
        std::atomic<uint64_t> total_flushes{0};
        std::atomic<uint64_t> wal_writes{0};
        std::atomic<uint64_t> sync_calls{0};
    };
 
    const critical_stats& get_stats() const { return stats_; }
 
private:
    bool is_critical_level(common::interfaces::log_level level) const;
 
    void write_to_wal(const log_entry& entry);
 
    void sync_file_descriptor();
 
 
    critical_writer_config config_;
 
    log_writer_ptr wrapped_writer_;
 
    mutable std::mutex critical_mutex_;
 
    std::unique_ptr<std::ofstream> wal_stream_;
 
    mutable critical_stats stats_;
 
    std::atomic<bool> shutting_down_{false};
};
 
class hybrid_writer : public base_writer, public composite_writer_tag, public decorator_writer_tag {
public:
    explicit hybrid_writer(
        log_writer_ptr wrapped_writer,
        critical_writer_config critical_config = {},
        std::size_t async_queue_size = 10000
    );
 
    ~hybrid_writer() override;
 
    common::VoidResult write(const log_entry& entry) override;
 
    common::VoidResult flush() override;
    bool is_healthy() const override;
    std::string get_name() const override;
    void set_use_color(bool use_color) override;
 
private:
    log_writer_ptr critical_writer_;
    std::size_t async_queue_size_;
};
 
} // namespace kcenon::logger