ADC/common/adc_spdlog.h

#pragma once



#ifdef USE_SPDLOG_LIBRARY

#include <spdlog/logger.h>
#include <thread>


#include "adc_traits.h"

namespace adc
{


/*  SPDLOG-library based advanced single/multithreaded logger  */

class AdcSpdlogLogger
{
public:
    // [year-month-day time.millisecs][log-level]: log-message
    constexpr static std::string_view LOGGER_DEFAULT_FORMAT = "[%Y-%m-%d %T.%e][%l]: %v";

    typedef spdlog::level::level_enum loglevel_t;

    template <traits::adc_input_char_range R = decltype(LOGGER_DEFAULT_FORMAT)>
    AdcSpdlogLogger(std::shared_ptr<spdlog::logger> logger, const R& pattern = LOGGER_DEFAULT_FORMAT)
        : _loggerSPtr(logger), _currentLogPattern()
    {
        std::ranges::copy(pattern, std::back_inserter(_currentLogPattern));
        _loggerSPtr->set_pattern(_currentLogPattern);
    }


    virtual ~AdcSpdlogLogger() = default;


    void setLogLevel(loglevel_t log_level)
    {
        _loggerSPtr->set_level(log_level);
    }

    loglevel_t getLogLevel() const
    {
        return _loggerSPtr->level();
    }

    void logMessage(loglevel_t level, const std::string& msg)
    {
        _loggerSPtr->log(level, msg);
    }

    // specialized for given level methods

    void logCritical(const std::string& msg)
    {
        logMessage(spdlog::level::critical, msg);
    }

    void logError(const std::string& msg)
    {
        logMessage(spdlog::level::err, msg);
    }

    void logWarn(const std::string& msg)
    {
        logMessage(spdlog::level::warn, msg);
    }

    void logInfo(const std::string& msg)
    {
        logMessage(spdlog::level::info, msg);
    }

    void logDebug(const std::string& msg)
    {
        logMessage(spdlog::level::debug, msg);
    }

    void logTrace(const std::string& msg)
    {
        logMessage(spdlog::level::trace, msg);
    }

    template <traits::formattable... ArgTs>
    void logCritical(spdlog::format_string_t<ArgTs...> fmt, ArgTs&&... args)
    {
        _loggerSPtr->log(spdlog::level::critical, fmt, std::forward<ArgTs>(args)...);
    }

    template <typename... ArgTs>
    void logError(spdlog::format_string_t<ArgTs...> fmt, ArgTs&&... args)
    {
        _loggerSPtr->log(spdlog::level::err, fmt, std::forward<ArgTs>(args)...);
    }

    template <traits::formattable... ArgTs>
    void logWarn(spdlog::format_string_t<ArgTs...> fmt, ArgTs&&... args)
    {
        _loggerSPtr->log(spdlog::level::warn, fmt, std::forward<ArgTs>(args)...);
    }

    template <traits::formattable... ArgTs>
    void logInfo(spdlog::format_string_t<ArgTs...> fmt, ArgTs&&... args)
    {
        _loggerSPtr->log(spdlog::level::info, fmt, std::forward<ArgTs>(args)...);
    }

    template <traits::formattable... ArgTs>
    void logDebug(spdlog::format_string_t<ArgTs...> fmt, ArgTs&&... args)
    {
        _loggerSPtr->log(spdlog::level::debug, fmt, std::forward<ArgTs>(args)...);
    }

    template <traits::formattable... ArgTs>
    void logTrace(spdlog::format_string_t<ArgTs...> fmt, ArgTs&&... args)
    {
        _loggerSPtr->log(spdlog::level::trace, fmt, std::forward<ArgTs>(args)...);
    }

protected:
    static constexpr size_t LOGGER_DEFAULT_FORMAT_MARK_POS = 20;

    std::string _currentLogPattern;
    std::shared_ptr<spdlog::logger> _loggerSPtr;


    // helper method
    void addMarkToPattern(traits::adc_input_char_range auto& mark, size_t pos = LOGGER_DEFAULT_FORMAT_MARK_POS)
    {
        std::string ptrn = _currentLogPattern.substr(0, pos);

        ptrn += " [";
        std::ranges::copy(mark, std::back_inserter(ptrn));
        ptrn += "] ";

        std::ranges::copy(_currentLogPattern | std::views::drop(pos), std::back_inserter(ptrn));

        _currentLogPattern = ptrn;

        _loggerSPtr->set_pattern(_currentLogPattern);
    }
};


/*

template <typename BaseT>
class AdcSpdlogGenericDecorator : public BaseT
{
protected:
    std::shared_ptr<spdlog::logger> _logger;

    void* _thisAddress;
    std::string _currentPattern;

public:
    constexpr static std::string_view LOGGER_DEFAULT_FORMAT = "[%Y-%m-%d %T.%e] [%l]: %v";

    template <traits::adc_input_char_range R, typename... BaseCtorArgTs>
    AdcSpdlogGenericDecorator(const R& pattern, std::shared_ptr<spdlog::logger> logger, BaseCtorArgTs&&... ctor_args)
        : BaseT(std::forward<BaseCtorArgTs>(ctor_args)...),
          _logger(logger),
          _thisAddress((void*)std::addressof(*this)),
          _currentPattern(pattern.begin(), pattern.end())
    {
        _logger->set_pattern(_currentPattern);

        if (_logger->level() == spdlog::level::trace) {
            logMethodCalling(__PRETTY_FUNCTION__);  // in trace
        } else {
            logMethodCalling("AdcSpdlogGenericDecorator", __FUNCTION__);  // in debug
        }

        _logger->debug("set logger with {}", loggerInfo());
    }


    template <typename... BaseCtorArgTs>
    AdcSpdlogGenericDecorator(std::shared_ptr<spdlog::logger> logger, BaseCtorArgTs&&... ctor_args)
        : AdcSpdlogGenericDecorator(LOGGER_DEFAULT_FORMAT, logger, std::forward<BaseCtorArgTs>(ctor_args)...)
    {
    }

    virtual ~AdcSpdlogGenericDecorator()
    {
        logMethodCalling("AdcSpdlogGenericDecorator", __FUNCTION__);  // in debug

        _logger->flush();
    }


    template <traits::adc_input_char_range R>
    void setPattern(const R& pattern)
    {
        logMethodCalling("AdcSpdlogGenericDecorator", __FUNCTION__);  // in debug

        _currentPattern = {pattern.begin(), pattern.end()};

        _logger->debug("set current logging pattern to: {}", _currentPattern);
    }


    std::string pattern() const
    {
        logMethodCalling();

        return _currentPattern;
    }

    template <traits::formattable... ArgTs>
    void logMessage(spdlog::level::level_enum level, std::string_view fmt, ArgTs&&... args)
    {
        _logger->log(level, fmt, std::forward<ArgTs>(args)...);
    }

    template <traits::formattable... ArgTs>
    void logCritical(std::string_view fmt, ArgTs&&... args)
    {
        _logger->log(spdlog::level::critical, fmt, std::forward<ArgTs>(args)...);
    }

    template <traits::formattable... ArgTs>
    void logError(std::string_view fmt, ArgTs&&... args)
    {
        _logger->log(spdlog::level::err, fmt, std::forward<ArgTs>(args)...);
    }

    template <traits::formattable... ArgTs>
    void logWarn(std::string_view fmt, ArgTs&&... args)
    {
        _logger->log(spdlog::level::warn, fmt, std::forward<ArgTs>(args)...);
    }

    template <traits::formattable... ArgTs>
    void logInfo(std::string_view fmt, ArgTs&&... args)
    {
        _logger->log(spdlog::level::info, fmt, std::forward<ArgTs>(args)...);
    }

    template <traits::formattable... ArgTs>
    void logDebug(std::string_view fmt, ArgTs&&... args)
    {
        _logger->log(spdlog::level::debug, fmt, std::forward<ArgTs>(args)...);
    }

    template <traits::formattable... ArgTs>
    void logTrace(std::string_view fmt, ArgTs&&... args)
    {
        _logger->log(spdlog::level::trace, fmt, std::forward<ArgTs>(args)...);
    }

protected:
    // format string must contain two formating specifications:
    //    1 - logger name (string)
    //    2 - logging level (string)
    template <traits::adc_output_char_range R>
    R loggerInfo(std::string_view fmt) const
    {
        R info;

        std::format_to(std::back_inserter(info), fmt, _logger->name(), spdlog::level::to_string_view(_logger->level()));

        return info;
    }

    std::string loggerInfo() const
    {
        //
        return loggerInfo<std::string>("name [{}] and log-level [{}]");
    }

    void logMethodCalling(std::string_view class_name,
                          std::string_view method_name,
                          spdlog::level::level_enum level = spdlog::level::debug) const
    {
        _logger->log(level, "call {}::{} (this: {}, thread ID: {})", class_name, method_name, _thisAddress,
                     std::this_thread::get_id());
    }


    void logMethodCalling(std::string_view log_msg, spdlog::level::level_enum level = spdlog::level::debug) const
    {
        _logger->log(level, "call {} (this: {}, thread ID: {})", log_msg, _thisAddress, std::this_thread::get_id());
    }
};

template <typename BaseT>
class AdcSpdlogGenericMarkDecorator : public AdcSpdlogGenericDecorator<BaseT>
{
protected:
    using base_t = AdcSpdlogGenericDecorator<BaseT>;

public:
    constexpr static std::array<std::string_view, 2> LOGGER_DEFAULT_FORMAT{"[%Y-%m-%d %T.%e] [%l] ", "%v"};

    template <traits::adc_input_char_range R, traits::adc_range_of_input_char_range IR>
    static std::string constructPattern(const R& mark, size_t after_idx = 0, const IR& format = LOGGER_DEFAULT_FORMAT)
    {
        std::string pattern;

        std::ranges::copy(format | std::views::take(after_idx + 1) | std::views::join, std::back_inserter(pattern));
        std::ranges::copy(std::string_view("["), std::back_inserter(pattern));
        std::ranges::copy(mark, std::back_inserter(pattern));
        std::ranges::copy(std::string_view("]: "), std::back_inserter(pattern));
        std::ranges::copy(format | std::views::drop(after_idx + 1) | std::views::join, std::back_inserter(pattern));

        return pattern;
    }


    template <traits::adc_input_char_range R, typename... BaseCtorArgTs>
    AdcSpdlogGenericMarkDecorator(const R& mark, std::shared_ptr<spdlog::logger> logger, BaseCtorArgTs&&... ctor_args)
        : base_t(constructPattern(mark), logger, std::forward<BaseCtorArgTs>(ctor_args)...)
    {
    }
};

*/
}  // namespace adc

#endif