logging_impl.hpp

Go to the documentation of this file.

/*
Copyright (c) 2025 acrion innovations GmbH
Authors: Stefan Zipproth, s.zipproth@acrion.ch
 
This file is part of Cbeam, see https://github.com/acrion/cbeam and https://cbeam.org
 
Cbeam is offered under a commercial and under the AGPL license.
For commercial licensing, contact us at https://acrion.ch/sales. For AGPL licensing, see below.
 
AGPL licensing:
 
Cbeam is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
 
Cbeam is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
 
You should have received a copy of the GNU Affero General Public License
along with Cbeam. If not, see <https://www.gnu.org/licenses/>.
*/
 
#pragma once
 
namespace cbeam::concurrency
{
    template <typename Derived, typename MessageType>
    class threaded_object;
 
    template <typename Message>
    class message_manager;
}
 
#include <cbeam/concurrency/message_manager.hpp>
#include <cbeam/concurrency/thread.hpp> // for cbeam::concurrency::get_thread_name, cbeam::concurrency::thread_id_type, cbeam::concurrency::to_string, CBEAM:CONCURRENCY::GET_CURRENT_THREAD_ID, CBEAM_DEFAULT_THREAD_ID
#include <cbeam/convert/string.hpp>     // for cbeam::convert::from_string, cbeam::convert::to_string
 
#include <cassert> // for assert
 
#include <chrono>     // for std::chrono::system_clock
#include <exception>  // for std::exception
#include <filesystem> // for std::filesystem::path, std::filesystem::remove
#include <fstream>    // for std::operator<<, std::basic_ostream, std::endl, std::basic_ofstream, std::ofstream, std::wofstream, std::wstringstream
#include <iostream>   // for std::wcerr
#include <memory>     // for std::unique_ptr, std::make_unique
#include <mutex>      // for std::mutex, std::lock_guard
#include <string>     // for std::char_traits, std::operator<<, std::wstring, std::string_literals::operator""s, std::operator+, std::string_literals, std::string
 
namespace cbeam::logging
{
    class log
    {
    public:
        explicit log(const std::filesystem::path& log_path)
        {
            using namespace std::string_literals;
            _log_path = log_path;
 
            std::filesystem::create_directories(log_path.parent_path());
 
            try
            {
                std::filesystem::remove(_log_path);
            }
            catch (const std::exception& ex)
            {
                do_append(convert::from_string<std::wstring>("Could not delete old log file: "s + ex.what()));
            }
 
            do_append(L"-------------------------------- start of log --------------------------------"s);
        }

        ~log() noexcept
        {
            try
            {
                using namespace std::string_literals;
                std::lock_guard<std::mutex> lock(_mtx);
                do_append(L"--------------------------------  end of log  --------------------------------"s);
            }
            catch (const std::system_error& ex)
            {
                std::wcerr << "cbeam::logging::~log: Could not lock the mutex. This indicates a serious (unexpected) bug that must be fixed during development phase: "
                           << ex.what() << std::endl;
                assert(false);
            }
        }

        void append(const std::wstring& str) noexcept
        {
            try
            {
                std::wstring                header;
                concurrency::thread_id_type thread_id = cbeam::concurrency::get_current_thread_id();
                if (!_mtx.try_lock())
                {
                    // We just try to lock to optimize performance. If locking fails, we postpone the creation of the header
                    header = create_header(thread_id);
                    _mtx.lock();
                }
 
                do_append(str, thread_id, header);
            }
            catch (const std::exception& ex)
            {
                std::wcerr << "cbeam::logging::append: " << ex.what() << std::endl;
                assert(false);
            }
 
            _mtx.unlock();
        }

        void append(const std::string& str) noexcept
        {
            append(std::wstring(str.begin(), str.end()));
        }
 
    private:
        struct message
        {
            std::wstring                text;
            concurrency::thread_id_type threadId{};
        };

        void do_append(const std::wstring& str, concurrency::thread_id_type thread_id = {}, std::wstring time = {}) const noexcept
        {
            try
            {
                if (thread_id == cbeam::concurrency::thread_id_type{})
                    thread_id = cbeam::concurrency::get_current_thread_id();
                if (time.empty())
                    time = create_header(thread_id);
 
                std::wofstream(_log_path, std::ofstream::app) << time << str << std::endl;
            }
            catch (const std::exception& ex)
            {
                std::wcerr << str << " " << ex.what() << std::endl;
            }
        }

        static std::wstring create_header(concurrency::thread_id_type thread_id)
        {
            std::wstringstream stream;
            stream << current_time_to_wstring() << L" ("
                   << concurrency::to_string(thread_id, 0xFFFF) << L" "
                   << concurrency::get_thread_name(thread_id)
                   << L"): ";
            return stream.str();
        }

        static std::wstring current_time_to_wstring()
        {
            return convert::from_string<std::wstring>(convert::to_string(std::chrono::system_clock::now()));
        }
 
        std::unique_ptr<concurrency::message_manager<message>> _message_manager;
        std::filesystem::path                                  _log_path;
        std::mutex                                             _mtx;
    };
}