kcenon::logger::utils Namespace Reference

Classes
struct	error_context
	Structured error context for debugging. More...
class	file_utils
	File utility functions for path validation and sanitization. More...
class	string_utils
	String utility functions for log formatting and conversion. More...
class	time_utils
	Time utility functions for timestamp formatting. More...

Functions
void	log_error_context (const error_context &context)
	Log error to stderr with context.
template<typename F >
common::VoidResult	try_write_operation (F &&operation, logger_error_code default_error_code=logger_error_code::file_write_failed)
	Error handling helper for write operations.
template<typename F >
common::VoidResult	try_open_operation (F &&operation)
	Error handling helper for file open operations.
template<typename F >
common::VoidResult	try_network_operation (F &&operation)
	Error handling helper for network operations.
template<typename F >
common::VoidResult	try_encryption_operation (F &&operation)
	Error handling helper for encryption operations.
common::VoidResult	check_condition (bool condition, logger_error_code error_code, const std::string &message)
	Condition verification helper.
template<typename Stream >
common::VoidResult	check_stream_state (const Stream &stream, const std::string &operation_name="operation")
	Stream state verification helper.
common::VoidResult	check_file_exists (const std::filesystem::path &path)
	File existence verification helper.
common::VoidResult	ensure_directory_exists (const std::filesystem::path &dir)
	Directory creation helper.
template<typename F >
void	safe_destructor_operation (const std::string &operation_name, F &&operation) noexcept
	Safe operation execution for destructors.
template<typename F >
void	safe_destructor_result_operation (const std::string &operation_name, F &&operation) noexcept
	Safe operation with result for destructors.

Function Documentation

check_condition()

common::VoidResult kcenon::logger::utils::check_condition ( bool condition, logger_error_code error_code, const std::string & message )

inline

Condition verification helper.

Checks a boolean condition and returns an error if the condition is false. This helper reduces boilerplate code for precondition checks.

Usage example:

auto check = check_condition(
    file_stream_.is_open(),
    logger_error_code::file_write_failed,
    "File stream is not open"
);
if (check.is_err()) return check;

Parameters

condition	The condition to check
error_code	Error code to return if condition is false
message	Error message

Returns

common::VoidResult Success if condition is true, error otherwise

Definition at line 282 of file error_handling_utils.h.

  {
    if (!condition) {
        return make_logger_void_result(error_code, message);
    }
    return common::ok();
}

References kcenon::logger::make_logger_void_result(), and kcenon::common::ok().

Referenced by kcenon::logger::file_writer::open_internal().

Here is the call graph for this function:

Here is the caller graph for this function:

check_file_exists()

common::VoidResult kcenon::logger::utils::check_file_exists ( const std::filesystem::path & path )

inline

File existence verification helper.

Checks if a file exists at the given path.

Parameters

path	The file path to check

Returns

common::VoidResult Success if file exists, error otherwise

Definition at line 344 of file error_handling_utils.h.

                                                                         {
    try {
        if (!std::filesystem::exists(path)) {
            return make_logger_void_result(
                logger_error_code::file_open_failed,
                "File does not exist: " + path.string()
            );
        }
        return common::ok();
    } catch (const std::filesystem::filesystem_error& e) {
        return make_logger_void_result(
            logger_error_code::file_permission_denied,
            std::string("Cannot access file: ") + e.what()
        );
    }
}

References kcenon::logger::file_open_failed, kcenon::logger::file_permission_denied, kcenon::logger::make_logger_void_result(), and kcenon::common::ok().

Here is the call graph for this function:

check_stream_state()

template<typename Stream >

common::VoidResult kcenon::logger::utils::check_stream_state ( const Stream & stream, const std::string & operation_name = "operation" )

inline

Stream state verification helper.

Checks if a stream is in a good state and returns an appropriate error if not. This is a specialized version of check_condition for stream operations.

Template Parameters

Stream

Stream type (e.g., std::ofstream, std::ifstream)

Parameters

stream	The stream to check
operation_name	Name of the operation for error message (e.g., "write", "open")

Returns

common::VoidResult Success if stream is good, error otherwise

Definition at line 305 of file error_handling_utils.h.

  {
    if (!stream.good()) {
        if (stream.eof()) {
            return make_logger_void_result(
                logger_error_code::file_write_failed,
                "Stream error: Unexpected end of file during " + operation_name
            );
        }
        if (stream.fail()) {
            return make_logger_void_result(
                logger_error_code::file_write_failed,
                "Stream error: Logical error during " + operation_name
            );
        }
        if (stream.bad()) {
            return make_logger_void_result(
                logger_error_code::file_write_failed,
                "Stream error: Read/write error during " + operation_name
            );
        }
        return make_logger_void_result(
            logger_error_code::file_write_failed,
            "Stream is in an error state after " + operation_name
        );
    }
    return common::ok();
}

References kcenon::logger::file_write_failed, kcenon::logger::make_logger_void_result(), and kcenon::common::ok().

Referenced by kcenon::logger::file_writer::flush(), kcenon::logger::console_writer::write(), and kcenon::logger::file_writer::write().

Here is the call graph for this function:

Here is the caller graph for this function:

ensure_directory_exists()

common::VoidResult kcenon::logger::utils::ensure_directory_exists ( const std::filesystem::path & dir )

inline

Directory creation helper.

Creates a directory if it doesn't exist, with proper error handling.

Parameters

dir	The directory path to create

Returns

common::VoidResult Success if directory exists or was created, error otherwise

Definition at line 369 of file error_handling_utils.h.

                                                                              {
    if (dir.empty()) {
        return common::ok(); // Empty path is valid (current directory)
    }
 
    return try_open_operation([&]() -> common::VoidResult {
        if (!std::filesystem::exists(dir)) {
            if (!std::filesystem::create_directories(dir)) {
                return make_logger_void_result(
                    logger_error_code::file_permission_denied,
                    "Failed to create directory: " + dir.string()
                );
            }
        }
        return common::ok();
    });
}

References kcenon::logger::file_permission_denied, kcenon::logger::make_logger_void_result(), kcenon::common::ok(), and try_open_operation().

Referenced by kcenon::logger::file_writer::open_internal(), and kcenon::logger::rotating_file_writer::perform_rotation().

Here is the call graph for this function:

Here is the caller graph for this function:

log_error_context()

void kcenon::logger::utils::log_error_context ( const error_context & context )

inline

Log error to stderr with context.

Used primarily in destructors where throwing exceptions is not allowed. Provides diagnostic information without propagating errors.

Parameters

context

Error context to log

Definition at line 129 of file error_handling_utils.h.

                                                            {
    std::cerr << "[logger_system] Error: " << context.to_string() << std::endl;
}

References kcenon::logger::utils::error_context::to_string().

Referenced by safe_destructor_operation(), and safe_destructor_result_operation().

Here is the call graph for this function:

Here is the caller graph for this function:

safe_destructor_operation()

template<typename F >

void kcenon::logger::utils::safe_destructor_operation ( const std::string & operation_name, F && operation )

inlinenoexcept

Safe operation execution for destructors.

Executes an operation in a destructor-safe manner. Exceptions are caught and logged to stderr instead of being propagated, preventing std::terminate.

This function should be used in destructors where throwing exceptions would be unsafe.

Usage example:

~my_writer() {
    safe_destructor_operation("flush", [this]() {
        flush();
    });
}

Template Parameters

F	Callable type

Parameters

operation_name	Name of the operation for logging
operation	The operation to execute

Definition at line 410 of file error_handling_utils.h.

           {
    try {
        operation();
    }
    catch (const std::exception& e) {
        error_context ctx(
            logger_error_code::destructor_cleanup_failed,
            e.what(),
            operation_name
        );
        log_error_context(ctx);
    }
    catch (...) {
        error_context ctx(
            logger_error_code::destructor_cleanup_failed,
            "Unknown exception",
            operation_name
        );
        log_error_context(ctx);
    }
}

References kcenon::logger::destructor_cleanup_failed, and log_error_context().

Referenced by kcenon::logger::network_writer::~network_writer().

Here is the call graph for this function:

Here is the caller graph for this function:

safe_destructor_result_operation()

template<typename F >

void kcenon::logger::utils::safe_destructor_result_operation ( const std::string & operation_name, F && operation )

inlinenoexcept

Safe operation with result for destructors.

Similar to safe_destructor_operation but for operations that return common::VoidResult. Logs both exceptions and result errors.

Template Parameters

F	Callable type that returns common::VoidResult

Parameters

operation_name	Name of the operation for logging
operation	The operation to execute

Definition at line 446 of file error_handling_utils.h.

           {
    try {
        auto result = operation();
        if (result.is_err()) {
            error_context ctx(
                get_logger_error_code(result),
                result.error().message,
                operation_name
            );
            log_error_context(ctx);
        }
    }
    catch (const std::exception& e) {
        error_context ctx(
            logger_error_code::destructor_cleanup_failed,
            e.what(),
            operation_name
        );
        log_error_context(ctx);
    }
    catch (...) {
        error_context ctx(
            logger_error_code::destructor_cleanup_failed,
            "Unknown exception",
            operation_name
        );
        log_error_context(ctx);
    }
}

References kcenon::logger::destructor_cleanup_failed, kcenon::logger::get_logger_error_code(), and log_error_context().

Referenced by kcenon::logger::batch_writer::~batch_writer().

Here is the call graph for this function:

Here is the caller graph for this function:

try_encryption_operation()

template<typename F >

common::VoidResult kcenon::logger::utils::try_encryption_operation

(

F &&

operation

)

Error handling helper for encryption operations.

Specialized version of try_write_operation for encryption operations. Uses encryption_failed as the default error code.

Template Parameters

F	Callable type that returns common::VoidResult

Parameters

operation

The operation to execute

Returns

common::VoidResult Success or error result

Definition at line 254 of file error_handling_utils.h.

                                                         {
    return try_write_operation(
        std::forward<F>(operation),
        logger_error_code::encryption_failed
    );
}

References kcenon::logger::encryption_failed, and try_write_operation().

Here is the call graph for this function:

try_network_operation()

template<typename F >

common::VoidResult kcenon::logger::utils::try_network_operation

(

F &&

operation

)

Error handling helper for network operations.

Specialized version of try_write_operation for network operations. Uses network_send_failed as the default error code.

Template Parameters

F	Callable type that returns common::VoidResult

Parameters

operation

The operation to execute

Returns

common::VoidResult Success or error result

Definition at line 236 of file error_handling_utils.h.

                                                      {
    return try_write_operation(
        std::forward<F>(operation),
        logger_error_code::network_send_failed
    );
}

References kcenon::logger::network_send_failed, and try_write_operation().

Here is the call graph for this function:

try_open_operation()

template<typename F >

common::VoidResult kcenon::logger::utils::try_open_operation

(

F &&

operation

)

Error handling helper for file open operations.

Specialized version of try_write_operation for file open operations. Uses file_open_failed as the default error code.

Template Parameters

F	Callable type that returns common::VoidResult

Parameters

operation

The operation to execute

Returns

common::VoidResult Success or error result

Definition at line 218 of file error_handling_utils.h.

                                                   {
    return try_write_operation(
        std::forward<F>(operation),
        logger_error_code::file_open_failed
    );
}

References kcenon::logger::file_open_failed, and try_write_operation().

Referenced by ensure_directory_exists(), kcenon::logger::file_writer::open_internal(), and kcenon::logger::rotating_file_writer::perform_rotation().

Here is the call graph for this function:

Here is the caller graph for this function:

try_write_operation()

template<typename F >

common::VoidResult kcenon::logger::utils::try_write_operation	(	F &&	operation,
		logger_error_code	default_error_code = logger_error_code::file_write_failed )

Error handling helper for write operations.

This function wraps write operations with comprehensive exception handling, mapping different exception types to appropriate logger error codes.

Usage example:

common::VoidResult write(const log_entry& entry) {
    return try_write_operation([&]() -> common::VoidResult {
        // Perform write operation
        file_stream_ << formatted << '\n';
        return common::ok();
    });
}

Template Parameters

F	Callable type that returns common::VoidResult

Parameters

operation	The operation to execute
default_error_code	Error code to use for unexpected exceptions (default: file_write_failed)

Returns

common::VoidResult Success or error result

Definition at line 156 of file error_handling_utils.h.

  {
    try {
        return operation();
    }
    catch (const std::filesystem::filesystem_error& e) {
        // Filesystem-specific errors (permission denied, disk full, etc.)
        return make_logger_void_result(
            logger_error_code::file_permission_denied,
            std::string("Filesystem error: ") + e.what()
        );
    }
    catch (const std::ios_base::failure& e) {
        // I/O operation failures (stream errors, write errors, etc.)
        return make_logger_void_result(
            logger_error_code::file_write_failed,
            std::string("I/O error: ") + e.what()
        );
    }
    catch (const std::system_error& e) {
        // System-level errors
        return make_logger_void_result(
            default_error_code,
            std::string("System error: ") + e.what()
        );
    }
    catch (const std::bad_alloc& e) {
        // Memory allocation failures
        return make_logger_void_result(
            logger_error_code::buffer_overflow,
            std::string("Memory allocation failed: ") + e.what()
        );
    }
    catch (const std::exception& e) {
        // Generic exception catch-all
        return make_logger_void_result(
            default_error_code,
            std::string("Unexpected error: ") + e.what()
        );
    }
    catch (...) {
        // Non-standard exception
        return make_logger_void_result(
            default_error_code,
            "Unknown error (non-standard exception)"
        );
    }
}

References kcenon::logger::buffer_overflow, kcenon::logger::file_permission_denied, kcenon::logger::file_write_failed, and kcenon::logger::make_logger_void_result().

Referenced by kcenon::logger::rotating_file_writer::cleanup_old_files(), kcenon::logger::console_writer::flush(), kcenon::logger::file_writer::flush(), kcenon::logger::rotating_file_writer::get_backup_files(), kcenon::logger::rotating_file_writer::perform_rotation(), try_encryption_operation(), try_network_operation(), try_open_operation(), kcenon::logger::console_writer::write(), and kcenon::logger::file_writer::write().

Here is the call graph for this function:

Here is the caller graph for this function: