kcenon::logger::critical_writer Class Reference

Synchronous wrapper ensuring critical logs are never lost. More...

#include <critical_writer.h>

Inheritance diagram for kcenon::logger::critical_writer:

Collaboration diagram for kcenon::logger::critical_writer:

Classes
struct	critical_stats
	Get statistics about critical writes. More...

Public Member Functions
	critical_writer (log_writer_ptr wrapped_writer, critical_writer_config config={})
	Constructor.
	~critical_writer () override
	Destructor - ensures final flush.
common::VoidResult	write (const log_entry &entry) override
	Write a log entry with critical handling.
common::VoidResult	flush () override
	Flush all pending messages.
bool	is_healthy () const override
	Check if the writer is healthy.
std::string	get_name () const override
	Get the name of this writer.
void	set_use_color (bool use_color) override
	Set whether to use color output.
void	set_force_flush_on_critical (bool enable)
	Enable/disable critical flushing at runtime.
const critical_writer_config &	get_config () const
	Get current configuration.
const critical_stats &	get_stats () const
Public Member Functions inherited from kcenon::logger::base_writer
	base_writer (std::unique_ptr< log_formatter_interface > formatter=nullptr)
	Constructor with optional formatter.
virtual	~base_writer ()=default
bool	use_color () const
	Get current color output setting.
log_formatter_interface *	get_formatter () const
	Get the current formatter.
Public Member Functions inherited from kcenon::logger::log_writer_interface
virtual	~log_writer_interface ()=default
virtual common::VoidResult	close ()
	Close the writer and release resources.
virtual auto	is_open () const -> bool
	Check if writer is open and ready.

Private Member Functions
bool	is_critical_level (common::interfaces::log_level level) const
	Check if log level requires critical handling.
void	write_to_wal (const log_entry &entry)
	Write to write-ahead log.
void	sync_file_descriptor ()
	Force sync of underlying file descriptor.

Private Attributes
critical_writer_config	config_
	Configuration.
log_writer_ptr	wrapped_writer_
	Wrapped writer.
std::mutex	critical_mutex_
	Mutex for critical section.
std::unique_ptr< std::ofstream >	wal_stream_
	Write-ahead log stream.
critical_stats	stats_
	Statistics.
std::atomic< bool >	shutting_down_ {false}
	Flag for shutdown.

Additional Inherited Members
Static Public Attributes inherited from kcenon::logger::decorator_writer_tag
static constexpr writer_category	category = writer_category::decorator
Protected Member Functions inherited from kcenon::logger::base_writer
std::string	format_log_entry (const log_entry &entry) const
	Format a log entry using the current formatter.

Detailed Description

Synchronous wrapper ensuring critical logs are never lost.

This writer prevents message loss by:

1. Bypassing async queue for critical/fatal messages
2. Forcing immediate flush after critical writes
3. Optional write-ahead logging for crash recovery
4. File descriptor synchronization (fsync) for durability

For signal handling, use signal_manager or crash_safe_logger instead.

Thread Safety: All methods are thread-safe. Critical writes are serialized to ensure ordering and prevent interleaving.

Category: Decorator (wraps another writer to add critical message handling)

Since

1.4.0 Added decorator_writer_tag for category classification

Definition at line 103 of file critical_writer.h.

Constructor & Destructor Documentation

critical_writer()

kcenon::logger::critical_writer::critical_writer ( log_writer_ptr wrapped_writer, critical_writer_config config = {} )

explicit

Constructor.

Parameters

wrapped_writer	The underlying writer to wrap
config	Configuration options

Exceptions

std::invalid_argument

if wrapped_writer is null

Definition at line 24 of file critical_writer.cpp.

    : config_(std::move(config))
    , wrapped_writer_(std::move(wrapped_writer))
{
    if (!wrapped_writer_) {
        throw std::invalid_argument("Wrapped writer cannot be null");
    }
 
    // Initialize write-ahead log if enabled
    if (config_.write_ahead_log) {
        auto wal_result = utils::try_open_operation([&]() -> common::VoidResult {
            wal_stream_ = std::make_unique<std::ofstream>(
                config_.wal_path,
                std::ios::app | std::ios::binary
            );
 
            auto check = utils::check_condition(
                wal_stream_->is_open(),
                logger_error_code::file_open_failed,
                "Failed to open WAL: " + config_.wal_path
            );
 
            if (check.is_err()) {
                wal_stream_.reset();
                return check;
            }
 
            return common::ok();
        });
 
        if (wal_result.is_err()) {
            std::cerr << "[critical_writer] WAL initialization failed: "
                      << wal_result.error().message << std::endl;
            wal_stream_.reset();
        }
    }
 
}

References config_, wrapped_writer_, and kcenon::logger::critical_writer_config::write_ahead_log.

~critical_writer()

kcenon::logger::critical_writer::~critical_writer ( )

override

Destructor - ensures final flush.

Definition at line 66 of file critical_writer.cpp.

                                  {
    shutting_down_.store(true);
 
    // Final flush - use safe operation to log any errors
    utils::safe_destructor_result_operation("final_flush", [this]() {
        return flush();
    });
 
    // Close WAL with proper error logging
    if (wal_stream_) {
        utils::safe_destructor_operation("wal_close", [this]() {
            wal_stream_->flush();
            wal_stream_->close();
        });
    }
}

Member Function Documentation

flush()

common::VoidResult kcenon::logger::critical_writer::flush ( )

overridevirtual

Flush all pending messages.

Returns

common::VoidResult indicating success or error

Implements kcenon::logger::base_writer.

Definition at line 138 of file critical_writer.cpp.

                                        {
    std::lock_guard<std::mutex> lock(critical_mutex_);
 
    // Flush WAL
    if (wal_stream_ && wal_stream_->is_open()) {
        wal_stream_->flush();
    }
 
    // Flush wrapped writer
    auto result = wrapped_writer_->flush();
    stats_.total_flushes.fetch_add(1, std::memory_order_relaxed);
 
    return result;
}

get_config()

const critical_writer_config & kcenon::logger::critical_writer::get_config ( ) const

inline

Get current configuration.

Returns

Current configuration

Definition at line 173 of file critical_writer.h.

{ return config_; }

get_name()

std::string kcenon::logger::critical_writer::get_name ( ) const

overridevirtual

Get the name of this writer.

Returns

Writer name

Implements kcenon::logger::base_writer.

Definition at line 162 of file critical_writer.cpp.

                                          {
    return "critical_" + wrapped_writer_->get_name();
}

get_stats()

const critical_stats & kcenon::logger::critical_writer::get_stats ( ) const

inline

Definition at line 185 of file critical_writer.h.

{ return stats_; }

is_critical_level()

bool kcenon::logger::critical_writer::is_critical_level ( common::interfaces::log_level level ) const

private

Check if log level requires critical handling.

Parameters

level

Log level to check

Returns

true if level requires immediate flush

Definition at line 176 of file critical_writer.cpp.

                                                                             {
    // Critical and fatal always require immediate flush
    if (level >= common::interfaces::log_level::critical) {
        return config_.force_flush_on_critical;
    }
 
    // Error level if configured
    if (level == common::interfaces::log_level::error) {
        return config_.force_flush_on_error;
    }
 
    return false;
}

is_healthy()

bool kcenon::logger::critical_writer::is_healthy ( ) const

overridevirtual

Check if the writer is healthy.

Returns

true if healthy, false otherwise

Reimplemented from kcenon::logger::base_writer.

Definition at line 153 of file critical_writer.cpp.

                                       {
    // Check WAL health
    if (config_.write_ahead_log && (!wal_stream_ || !wal_stream_->good())) {
        return false;
    }
 
    return wrapped_writer_->is_healthy();
}

set_force_flush_on_critical()

void kcenon::logger::critical_writer::set_force_flush_on_critical

(

bool

enable

)

Enable/disable critical flushing at runtime.

Parameters

enable

Enable or disable

Definition at line 172 of file critical_writer.cpp.

                                                             {
    config_.force_flush_on_critical = enable;
}

set_use_color()

void kcenon::logger::critical_writer::set_use_color ( bool use_color )

overridevirtual

Set whether to use color output.

Parameters

use_color

Enable/disable color output

Reimplemented from kcenon::logger::base_writer.

Definition at line 166 of file critical_writer.cpp.

                                                  {
    // Color setting is now handled by formatter, not writer interface
    // This method is kept for backward compatibility but is deprecated
    (void)use_color;  // Suppress unused parameter warning
}

sync_file_descriptor()

void kcenon::logger::critical_writer::sync_file_descriptor ( )

private

Force sync of underlying file descriptor.

Definition at line 226 of file critical_writer.cpp.

                                           {
#ifdef _WIN32
    // Windows: Use _commit() to flush file buffers to disk
    // Note: std::ofstream doesn't expose HANDLE, so we flush the stream
    // For a complete implementation, would need native Windows file handling
    if (wal_stream_) {
        wal_stream_->flush();
    }
    // Could use _flushall() to flush all open streams, but it's global
    ::_flushall();
#elif defined(__unix__) || defined(__APPLE__)
    // POSIX: Use fsync() to synchronize file to disk
    // Get file descriptor from wrapped writer if it's a file writer
    // This is a simplified implementation - actual implementation would need
    // to query the wrapped writer for its file descriptor
 
    // For now, sync stdout/stderr as fallback
    ::fsync(STDOUT_FILENO);
    ::fsync(STDERR_FILENO);
 
    // Sync WAL
    if (wal_stream_) {
        wal_stream_->flush();
        // Note: std::ofstream doesn't expose fd, would need native file handling
    }
#endif
}

write()

common::VoidResult kcenon::logger::critical_writer::write ( const log_entry & entry )

overridevirtual

Write a log entry with critical handling.

Parameters

entry

The log entry to write

Returns

common::VoidResult indicating success or error

For critical/fatal messages:

• Acquires exclusive lock
• Writes to WAL (if enabled)
• Writes to wrapped writer
• Forces immediate flush
• Syncs file descriptor (if configured)

For non-critical messages, delegates to wrapped writer normally.

Since

3.5.0 Changed to use log_entry directly

Implements kcenon::logger::base_writer.

Definition at line 83 of file critical_writer.cpp.

                                                              {
    // Convert log_level from logger_system to common::interfaces
    auto level = static_cast<common::interfaces::log_level>(static_cast<int>(entry.level));
 
    // Check if we're in emergency shutdown (signal received)
    if (shutting_down_.load(std::memory_order_acquire)) {
        // In shutdown mode, all writes become critical to ensure they're flushed
        // before process termination
        std::lock_guard<std::mutex> lock(critical_mutex_);
 
        auto result = wrapped_writer_->write(entry);
        if (result.is_ok()) {
            wrapped_writer_->flush();
            stats_.total_flushes.fetch_add(1, std::memory_order_relaxed);
        }
        return result;
    }
 
    // Check if this is a critical level
    const bool is_critical = is_critical_level(level);
 
    if (is_critical) {
        // Acquire exclusive lock for critical writes
        std::lock_guard<std::mutex> lock(critical_mutex_);
 
        // Write to WAL first (if enabled)
        if (wal_stream_ && wal_stream_->is_open()) {
            write_to_wal(entry);
            stats_.wal_writes.fetch_add(1, std::memory_order_relaxed);
        }
 
        // Write to wrapped writer
        auto result = wrapped_writer_->write(entry);
        if (result.is_err()) {
            return result;
        }
 
        // Force flush immediately
        auto flush_result = wrapped_writer_->flush();
        stats_.total_flushes.fetch_add(1, std::memory_order_relaxed);
 
        // Sync file descriptor if configured
        if (config_.sync_on_critical) {
            sync_file_descriptor();
            stats_.sync_calls.fetch_add(1, std::memory_order_relaxed);
        }
 
        stats_.total_critical_writes.fetch_add(1, std::memory_order_relaxed);
        return flush_result;
    }
 
    // Non-critical: delegate to wrapped writer normally
    return wrapped_writer_->write(entry);
}

References kcenon::logger::log_entry::level.

write_to_wal()

void kcenon::logger::critical_writer::write_to_wal ( const log_entry & entry )

private

Write to write-ahead log.

Parameters

entry

Log entry to write to WAL

Definition at line 190 of file critical_writer.cpp.

                                                         {
    if (!wal_stream_ || !wal_stream_->is_open()) {
        return;
    }
 
    try {
        // Convert log_level
        auto level = static_cast<common::interfaces::log_level>(static_cast<int>(entry.level));
 
        // Extract source location
        std::string file = entry.location ? entry.location->file.to_string() : "";
        int line = entry.location ? entry.location->line : 0;
        std::string function = entry.location ? entry.location->function.to_string() : "";
 
        // Format: [timestamp] [LEVEL] [file:line:function] message\n
        auto time_t = std::chrono::system_clock::to_time_t(entry.timestamp);
        auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
            entry.timestamp.time_since_epoch()
        ).count() % 1000;
 
        std::ostringstream oss;
        oss << "[" << std::put_time(std::localtime(&time_t), "%Y-%m-%d %H:%M:%S")
            << "." << std::setfill('0') << std::setw(3) << ms << "] "
            << "[" << utils::string_utils::level_to_string(level) << "] "
            << "[" << file << ":" << line << ":" << function << "] "
            << entry.message.to_string() << "\n";
 
        *wal_stream_ << oss.str();
        wal_stream_->flush();
 
    } catch (const std::exception& e) {
        std::cerr << "[critical_writer] WAL write exception: "
                  << e.what() << std::endl;
    }
}

References kcenon::logger::log_entry::level, kcenon::logger::log_entry::location, kcenon::logger::log_entry::message, kcenon::logger::log_entry::timestamp, and kcenon::logger::small_string< SSO_SIZE >::to_string().

Here is the call graph for this function:

Member Data Documentation

config_

critical_writer_config kcenon::logger::critical_writer::config_

private

Configuration.

Definition at line 208 of file critical_writer.h.

Referenced by critical_writer().

critical_mutex_

std::mutex kcenon::logger::critical_writer::critical_mutex_

mutableprivate

Mutex for critical section.

Definition at line 214 of file critical_writer.h.

shutting_down_

std::atomic<bool> kcenon::logger::critical_writer::shutting_down_ {false}

private

Flag for shutdown.

Definition at line 223 of file critical_writer.h.

{false};

stats_

critical_stats kcenon::logger::critical_writer::stats_

mutableprivate

Statistics.

Definition at line 220 of file critical_writer.h.

wal_stream_

std::unique_ptr<std::ofstream> kcenon::logger::critical_writer::wal_stream_

private

Write-ahead log stream.

Definition at line 217 of file critical_writer.h.

wrapped_writer_

log_writer_ptr kcenon::logger::critical_writer::wrapped_writer_

private

Wrapped writer.

Definition at line 211 of file critical_writer.h.

Referenced by critical_writer().

---

The documentation for this class was generated from the following files:

• include/kcenon/logger/writers/critical_writer.h
• src/impl/writers/critical_writer.cpp