logger.hpp

Go to the documentation of this file.

//    OpenVPN -- An application to securely tunnel IP networks
//               over a single port, with support for SSL/TLS-based
//               session authentication and key exchange,
//               packet encryption, packet authentication, and
//               packet compression.
//
//    Copyright (C) 2024- OpenVPN Inc.
//
//    SPDX-License-Identifier: MPL-2.0 OR AGPL-3.0-only WITH openvpn3-openssl-exception
//
 
 
#pragma once
 
namespace openvpn::logging {
 
constexpr int LOG_LEVEL_ERROR = 0;
constexpr int LOG_LEVEL_INFO = 1;
constexpr int LOG_LEVEL_VERB = 2;
constexpr int LOG_LEVEL_DEBUG = 3;
constexpr int LOG_LEVEL_TRACE = 4;
 
template <int DEFAULT_LOG_LEVEL, int MAX_LEVEL = LOG_LEVEL_DEBUG>
class Logger
{
  public:
    static constexpr int max_log_level = std::max(MAX_LEVEL, DEFAULT_LOG_LEVEL);
    static constexpr int default_log_level = DEFAULT_LOG_LEVEL;
 
 
    int log_level() const
    {
        return current_log_level;
    }
 
    void set_log_level(int level)
    {
        current_log_level = level;
    }
 
    std::string log_prefix() const
    {
        return prefix_;
    }
 
    void set_log_prefix(const std::string &prefix)
    {
        prefix_ = prefix;
    }
 
    template <int LEVEL, typename T>
    void log(T &&msg) const
    {
        /* this ensures that the function is empty if MAX_LEVEL excludes this level */
        if constexpr (max_log_level >= LEVEL)
        {
            if (current_log_level >= LEVEL)
                OPENVPN_LOG(prefix_ << std::forward<T>(msg));
        }
    }
 
    template <typename T>
    void log_trace(T &&msg) const
    {
        log<LOG_LEVEL_TRACE>(std::forward<T>(msg));
    }
 
    template <typename T>
    void log_debug(T &&msg) const
    {
        log<LOG_LEVEL_DEBUG>(std::forward<T>(msg));
    }
 
    template <typename T>
    void log_info(T &&msg) const
    {
        log<LOG_LEVEL_INFO>(std::forward<T>(msg));
    }
 
    template <typename T>
    void log_verbose(T &&msg) const
    {
        log<LOG_LEVEL_VERB>(std::forward<T>(msg));
    }
 
    template <typename T>
    void log_error(T &&msg) const
    {
        log<LOG_LEVEL_ERROR>(std::forward<T>(msg));
    }
 
  protected:
    int current_log_level = DEFAULT_LOG_LEVEL;
    std::string prefix_;
};
 
template <int DEFAULT_LOG_LEVEL, int MAX_LEVEL = LOG_LEVEL_TRACE, typename TagT = std::nullptr_t>
class LoggingMixin
{
  public:
    static int log_level()
    {
        return log_.log_level();
    }
 
    static void set_log_level(int level)
    {
        log_.set_log_level(level);
    }
 
    static constexpr int max_log_level = logging::Logger<DEFAULT_LOG_LEVEL, MAX_LEVEL>::max_log_level;
    static constexpr int default_log_level = logging::Logger<DEFAULT_LOG_LEVEL, MAX_LEVEL>::default_log_level;
 
  protected:
    static inline logging::Logger<DEFAULT_LOG_LEVEL, MAX_LEVEL> log_;
};
 
 
/* Log helper macros that allow to not instantiate/execute the code that builds the log messsage if the message is
 * not logged or MAX_LEVEL is not compiled. This are not as nice as using the log_ members methods but are nicer than
 * other #defines that do not use if constexpr */
 
#define LOGGER_LOG(VERB, logger, args)                                                       \
    do                                                                                       \
    {                                                                                        \
        if constexpr (decltype(logger)::max_log_level >= openvpn::logging::LOG_LEVEL_##VERB) \
        {                                                                                    \
            if (logger.log_level() >= openvpn::logging::LOG_LEVEL_##VERB)                    \
            {                                                                                \
                std::ostringstream _ovpn_log_ss;                                             \
                _ovpn_log_ss << args;                                                        \
                logger.log_info(_ovpn_log_ss.str());                                         \
            }                                                                                \
        }                                                                                    \
    } while (0)
 
#define LOGGER_LOG_INFO(logger, args) LOGGER_LOG(INFO, logger, args)
#define LOGGER_LOG_VERBOSE(logger, args) LOGGER_LOG(VERB, logger, args)
#define LOGGER_LOG_DEBUG(logger, args) LOGGER_LOG(DEBUG, logger, args)
#define LOGGER_LOG_TRACE(logger, args) LOGGER_LOG(TRACE, logger, args)
#define LOGGER_LOG_ERROR(logger, args) LOGGER_LOG(ERROR, logger, args)
 
#define OVPN_LOG_ERROR(args) LOGGER_LOG_ERROR(log_, args)
#define OVPN_LOG_INFO(args) LOGGER_LOG_INFO(log_, args)
#define OVPN_LOG_VERBOSE(args) LOGGER_LOG_VERBOSE(log_, args)
#define OVPN_LOG_DEBUG(args) LOGGER_LOG_DEBUG(log_, args)
#define OVPN_LOG_TRACE(args) LOGGER_LOG_TRACE(log_, args)
 
} // namespace openvpn::logging