file_sink.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 <fstream>
#include <mutex>
#include <filesystem>
#include "../interfaces/output_sink_interface.h"
 
namespace kcenon::logger {
 
class file_sink : public output_sink_interface {
public:
    explicit file_sink(const std::string& file_path, bool append = true)
        : file_path_(file_path)
        , is_healthy_(false)
    {
        auto mode = append ? (std::ios::out | std::ios::app) : std::ios::out;
        file_.open(file_path, mode);
        is_healthy_ = file_.is_open() && file_.good();
    }
 
    ~file_sink() override {
        if (file_.is_open()) {
            file_.flush();
            file_.close();
        }
    }
 
    common::VoidResult write_raw(std::string_view message) override {
        std::lock_guard<std::mutex> lock(mutex_);
 
        if (!file_.is_open() || !file_.good()) {
            is_healthy_ = false;
            return make_logger_void_result(logger_error_code::file_write_failed);
        }
 
        file_ << message;
 
        if (file_.fail()) {
            is_healthy_ = false;
            return make_logger_void_result(logger_error_code::file_write_failed);
        }
 
        return common::ok();
    }
 
    common::VoidResult flush() override {
        std::lock_guard<std::mutex> lock(mutex_);
 
        if (!file_.is_open()) {
            return make_logger_void_result(logger_error_code::file_write_failed);
        }
 
        file_.flush();
 
        if (file_.fail()) {
            is_healthy_ = false;
            return make_logger_void_result(logger_error_code::file_write_failed);
        }
 
        return common::ok();
    }
 
    bool is_healthy() const override {
        return is_healthy_ && file_.is_open() && file_.good();
    }
 
    std::string get_name() const override {
        return "file";
    }
 
    std::string get_info() const override {
        std::lock_guard<std::mutex> lock(mutex_);
        std::string info = "file: " + file_path_;
        if (file_.is_open()) {
            try {
                auto size = std::filesystem::file_size(file_path_);
                info += ", size: " + std::to_string(size / 1024) + "KB";
            } catch (...) {
                // Ignore file size error
            }
        }
        return info;
    }
 
    std::string get_file_path() const {
        return file_path_;
    }
 
private:
    std::string file_path_;
    std::ofstream file_;
    mutable std::mutex mutex_;
    bool is_healthy_;
};
 
} // namespace kcenon::logger