file_writer.cpp

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.
 
#include <kcenon/logger/writers/file_writer.h>
#include <kcenon/logger/interfaces/log_entry.h>
#include <kcenon/logger/formatters/timestamp_formatter.h>
#include <kcenon/logger/security/integrity_policy.h>
#include <kcenon/logger/utils/error_handling_utils.h>
#include <filesystem>
#include <iostream>
 
namespace kcenon::logger {
 
file_writer::file_writer(const std::string& filename,
                        bool append,
                        std::unique_ptr<log_formatter_interface> formatter,
                        bool binary)
    : filename_(filename)
    , append_mode_(append)
    , binary_mode_(binary)
    , formatter_(formatter ? std::move(formatter) : std::make_unique<timestamp_formatter>()) {
    std::lock_guard<std::mutex> lock(mutex_);
    open_internal();
}
 
file_writer::~file_writer() {
    std::lock_guard<std::mutex> lock(mutex_);
    close_internal();
}
 
common::VoidResult file_writer::write(const log_entry& entry) {
    std::lock_guard<std::mutex> lock(mutex_);
 
    return utils::try_write_operation([&]() -> common::VoidResult {
        // Check precondition
        if (!is_open_) {
            return make_logger_void_result(logger_error_code::file_write_failed, "File is not open");
        }
 
        // Format and write
        std::string formatted = format_entry(entry);
 
        // Append tamper-evident signature (Issue #612) when a policy is set.
        // The signature covers the formatted record so verifiers can
        // reconstruct and check it without re-formatting.
        if (integrity_policy_) {
            formatted.append(
                security::format_signature_suffix(*integrity_policy_, formatted));
        }
 
        if (binary_mode_) {
            // Binary mode writes the payload verbatim. Callers (for example,
            // encrypted_writer) produce fully-framed byte streams that must
            // not be corrupted by a trailing newline or CRLF translation.
            file_stream_.write(formatted.data(),
                               static_cast<std::streamsize>(formatted.size()));
            bytes_written_.fetch_add(formatted.size());
        } else {
            file_stream_ << formatted << '\n';
            bytes_written_.fetch_add(formatted.size() + 1);  // +1 for newline
        }
 
        // Verify stream state
        return utils::check_stream_state(file_stream_, "write");
    });
}
 
common::VoidResult file_writer::flush() {
    std::lock_guard<std::mutex> lock(mutex_);
 
    return utils::try_write_operation([&]() -> common::VoidResult {
        if (is_open_) {
            file_stream_.flush();
            return utils::check_stream_state(file_stream_, "flush");
        }
        return common::ok();
    }, logger_error_code::flush_timeout);
}
 
common::VoidResult file_writer::close() {
    std::lock_guard<std::mutex> lock(mutex_);
    close_internal();
    return common::ok();
}
 
bool file_writer::is_healthy() const {
    return is_open_ && file_stream_.good();
}
 
void file_writer::set_integrity_policy(
    std::shared_ptr<security::integrity_policy> policy) {
    std::lock_guard<std::mutex> lock(mutex_);
    integrity_policy_ = std::move(policy);
}
 
std::string file_writer::format_entry(const log_entry& entry) const {
    if (!formatter_) {
        // Fallback if formatter is somehow null
        return entry.message.to_string();
    }
    return formatter_->format(entry);
}
 
common::VoidResult file_writer::open_internal() {
    // IMPORTANT: Caller must hold the mutex before calling this method
 
    return utils::try_open_operation([&]() -> common::VoidResult {
        // Create directory if it doesn't exist
        std::filesystem::path file_path(filename_);
        std::filesystem::path dir = file_path.parent_path();
 
        auto dir_result = utils::ensure_directory_exists(dir);
        if (dir_result.is_err()) return dir_result;
 
        // Open file
        auto mode = append_mode_ ? std::ios::app : std::ios::trunc;
        auto flags = std::ios::out | mode;
        if (binary_mode_) {
            flags |= std::ios::binary;
        }
        file_stream_.open(filename_, flags);
 
        // Check if file opened successfully
        auto check = utils::check_condition(
            file_stream_.is_open(),
            logger_error_code::file_open_failed,
            "Failed to open file: " + filename_
        );
        if (check.is_err()) return check;
 
        // Get current file size if appending
        if (append_mode_) {
            file_stream_.seekp(0, std::ios::end);
            bytes_written_ = file_stream_.tellp();
        } else {
            bytes_written_ = 0;
        }
 
        is_open_ = true;
        return common::ok();
    });
}
 
void file_writer::close_internal() {
    // IMPORTANT: Caller must hold the mutex before calling this method
 
    if (is_open_) {
        if (file_stream_.is_open()) {
            file_stream_.flush();
            file_stream_.close();
        }
        is_open_ = false;
    }
}
 
} // namespace kcenon::logger