file_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 "../interfaces/log_writer_interface.h"
#include "../interfaces/log_formatter_interface.h"
#include "../interfaces/writer_category.h"
 
#include <kcenon/logger/logger_export.h>
 
#include <fstream>
#include <atomic>
#include <memory>
#include <mutex>
 
namespace kcenon::logger {
 
namespace security { class integrity_policy; }
 
class LOGGER_SYSTEM_API file_writer : public log_writer_interface, public sync_writer_tag {
public:
    explicit file_writer(const std::string& filename,
                        bool append = true,
                        std::unique_ptr<log_formatter_interface> formatter = nullptr,
                        bool binary = false);
 
    ~file_writer() override;
 
    // Non-copyable and non-movable
    file_writer(const file_writer&) = delete;
    file_writer& operator=(const file_writer&) = delete;
    file_writer(file_writer&&) = delete;
    file_writer& operator=(file_writer&&) = delete;
 
    common::VoidResult write(const log_entry& entry) override;
 
    common::VoidResult flush() override;
 
    common::VoidResult close() override;
 
    std::string get_name() const override { return "file"; }
 
    [[nodiscard]] bool is_open() const override { return is_open_; }
 
    bool is_healthy() const override;
 
    size_t get_file_size() const { return bytes_written_.load(); }
 
    void set_integrity_policy(std::shared_ptr<security::integrity_policy> policy);
 
protected:
    std::string format_entry(const log_entry& entry) const;
 
    common::VoidResult open_internal();
 
    void close_internal();
 
    std::mutex& get_mutex() const { return mutex_; }
 
protected:
    std::string filename_;
    bool append_mode_;
    bool binary_mode_ = false;
 
    std::ofstream file_stream_;
    std::atomic<bool> is_open_{false};
    std::atomic<size_t> bytes_written_{0};
 
    std::unique_ptr<log_formatter_interface> formatter_;
    std::shared_ptr<security::integrity_policy> integrity_policy_;
    mutable std::mutex mutex_;
};
 
} // namespace kcenon::logger