log.h

Go to the documentation of this file.

// MIT License
//
// Copyright (c) 2019 Ruhr University Bochum, Chair for Embedded Security. All Rights reserved.
// Copyright (c) 2019 Marc Fyrbiak, Sebastian Wallat, Max Hoffmann ("ORIGINAL AUTHORS"). All rights reserved.
// Copyright (c) 2021 Max Planck Institute for Security and Privacy. All Rights reserved.
// Copyright (c) 2021 Jörn Langheinrich, Julian Speith, Nils Albartus, René Walendy, Simon Klix ("ORIGINAL AUTHORS"). All Rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
 
#pragma once
 
#include "hal_core/defines.h"
#include "hal_core/utilities/callback_hook.h"
#include "hal_core/utilities/program_arguments.h"
#include "hal_core/utilities/program_options.h"
#include "hal_core/utilities/utils.h"
 
#include <functional>
#include <map>
#include <memory>
#include <mutex>
#include <set>
#include <string>
#include <tuple>
 
#define FMT_HEADER_ONLY
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wshadow"
#include <spdlog/sinks/base_sink.h>
#include <spdlog/spdlog.h>
#pragma GCC diagnostic pop
 
namespace hal
{
// macros to stringify to transform int to const char*
#define STRINGISTRINGIFY(x) #x
#define STRINGIFY(x) STRINGISTRINGIFY(x)
 
// macro to get the log channel
#define LOG_CHANNEL(channel) LogManager::get_instance()->get_channel(channel)
 
#define log_info(channel, ...) LOG_CHANNEL(channel)->info(__VA_ARGS__)
 
#define log_trace(channel, ...) LOG_CHANNEL(channel)->trace("[" __FILE__ ":" STRINGIFY(__LINE__) "] " __VA_ARGS__)
 
#define log_debug(channel, ...) LOG_CHANNEL(channel)->debug("[" __FILE__ ":" STRINGIFY(__LINE__) "] " __VA_ARGS__)
 
#define log_warning(channel, ...) LOG_CHANNEL(channel)->warn("[" __FILE__ ":" STRINGIFY(__LINE__) "] " __VA_ARGS__)
 
#define log_error(channel, ...) LOG_CHANNEL(channel)->error("[" __FILE__ ":" STRINGIFY(__LINE__) "] " __VA_ARGS__)
 
#define log_critical(channel, ...) LOG_CHANNEL(channel)->critical("[" __FILE__ ":" STRINGIFY(__LINE__) "] " __VA_ARGS__)
 
#define die(channel, ...)                                                                      \
    do                                                                                         \
    {                                                                                          \
        LOG_CHANNEL(channel)->critical("[" __FILE__ ":" STRINGIFY(__LINE__) "] " __VA_ARGS__); \
        exit(1);                                                                               \
    } while (0);
 
    class CORE_API LogManager
    {
    public:
        struct log_sink
        {
            std::shared_ptr<spdlog::sinks::sink> spdlog_sink;
            std::string sink_type;
            bool is_file_sink;
            bool truncate;
            std::filesystem::path path;
        };
 
        static LogManager* get_instance(const std::filesystem::path& file_name = "");
 
        void set_file_name(const std::filesystem::path& file_name);
 
        void set_format_pattern(const std::string& format);
 
        std::shared_ptr<spdlog::logger> get_channel(const std::string& channel_name = "stdout");
 
        std::set<std::string> get_channels() const;
 
        std::shared_ptr<spdlog::logger> add_channel(const std::string& channel_name, const std::vector<std::shared_ptr<log_sink>>& sinks, const std::string& level = "info");
 
        void remove_channel(const std::string& channel_name);
 
        std::string get_level_of_channel(const std::string& channel_name) const;
 
        void set_level_of_channel(const std::string& channel_name, const std::string& level);
 
        std::set<std::string> get_available_log_levels() const;
 
        void activate_channel(const std::string& channel_name);
 
        void activate_all_channels();
 
        void deactivate_channel(const std::string& channel_name);
 
        void deactivate_all_channels();
 
        CallbackHook<void(const spdlog::level::level_enum&, const std::string&, const std::string&)>& get_gui_callback();
 
        ProgramOptions& get_option_descriptions();
 
        void handle_options(ProgramArguments& args);
 
        std::vector<std::shared_ptr<hal::LogManager::log_sink>> get_default_sinks();
 
        void remove_sink_from_default(const std::string& sink_type);
 
        static std::shared_ptr<log_sink> create_stdout_sink(const bool colored = true);
 
        static std::shared_ptr<log_sink> create_file_sink(const std::filesystem::path& file_name = "", const bool truncate = false);
 
        static std::shared_ptr<log_sink> create_gui_sink();
 
    private:
        static std::map<std::string, std::shared_ptr<log_sink>> m_file_sinks;
 
        // LogManager class constructor (private due to singleton)
        LogManager(const std::filesystem::path& file_name);
 
        // LogManager class destructor (private due to singleton)
        ~LogManager();
 
        // LogManager class object non-copyable
        LogManager(const LogManager&) = delete;
 
        // LogManager class object non-copyable
        LogManager& operator=(const LogManager&) = delete;
 
        std::filesystem::path m_file_path;
 
        std::map<std::string, spdlog::level::level_enum> m_level;
 
        std::map<std::string, std::shared_ptr<spdlog::logger>> m_logger;
 
        std::map<std::string, std::vector<std::shared_ptr<log_sink>>> m_logger_sinks;
 
        CallbackHook<void(const spdlog::level::level_enum&, const std::string&, const std::string&)> m_gui_callback;
 
        ProgramOptions m_descriptions;
 
        std::string m_enforce_level;
 
        std::vector<std::shared_ptr<hal::LogManager::log_sink>> m_default_sinks;
 
        static LogManager* m_instance;
    };
 
    class log_gui_sink : public spdlog::sinks::base_sink<std::mutex>
    {
    public:
        log_gui_sink() = default;
        ~log_gui_sink() = default;
 
    protected:
        void sink_it_(const spdlog::details::log_msg& msg) override;
        void flush_() override;
    };
}    // namespace hal