log.hpp

Go to the documentation of this file.

//
// Copyright 2011 Ettus Research LLC
// Copyright 2018 Ettus Research, a National Instruments Company
//
// SPDX-License-Identifier: GPL-3.0-or-later
//
 
#pragma once
 
#include <uhd/config.hpp>
#include <type_traits>
#include <boost/none.hpp>
#include <boost/optional.hpp>
#include <chrono>
#include <iomanip>
#include <iostream>
#include <optional>
#include <ostream>
#include <sstream>
#include <string>
#include <thread>
 
/*
 * Advanced logging macros
 * UHD_LOG_MIN_LEVEL definitions
 * trace: 0
 * debug: 1
 * info: 2
 * warning: 3
 * error: 4
 * fatal: 5
 */
 
namespace uhd { namespace log {
enum severity_level {
    trace   = 0, 
    debug   = 1, 
    info    = 2, 
    warning = 3, 
    error   = 4, 
    fatal   = 5, 
    off     = 6, 
};
 
namespace detail {
UHD_API std::optional<uhd::log::severity_level> parse_log_level_from_string_impl(
    const std::string& log_level_str);
 
struct UHD_API logging_info
{
    logging_info() : verbosity(uhd::log::off), line(0) {}
    logging_info(const std::chrono::system_clock::time_point& time_,
        const uhd::log::severity_level& verbosity_,
        const std::string& file_,
        const unsigned int& line_,
        const std::string& component_,
        const std::thread::id& thread_id_)
        : time(time_)
        , verbosity(verbosity_)
        , file(file_)
        , line(line_)
        , component(component_)
        , thread_id(thread_id_)
    { /* nop */
    }
 
    std::chrono::system_clock::time_point time;
    uhd::log::severity_level verbosity;
    std::string file;
    unsigned int line;
    std::string component;
    std::thread::id thread_id;
    std::string message;
};
 
} // namespace detail
 
template <typename T = boost::optional<uhd::log::severity_level>,
    std::enable_if_t<
        std::is_same_v<T,
            boost::optional<uhd::log::
                    severity_level>> || std::is_same_v<T, std::optional<uhd::log::severity_level>>,
        int> = 0>
T parse_log_level_from_string(const std::string& log_level_str)
{
    if constexpr (std::is_same_v<T, boost::optional<uhd::log::severity_level>>) {
        const auto level = detail::parse_log_level_from_string_impl(log_level_str);
        return bool(level) ? boost::make_optional(*level) : boost::none;
    } else {
        return detail::parse_log_level_from_string_impl(log_level_str);
    }
}
 
UHD_API void set_log_level(uhd::log::severity_level level);
 
UHD_API void set_console_level(uhd::log::severity_level level);
 
UHD_API void set_file_level(uhd::log::severity_level level);
 
UHD_API void set_logger_level(const std::string& logger, uhd::log::severity_level level);
}} // namespace uhd::log
 
#define _UHD_LOG_INTERNAL(component, level) \
    uhd::_log::log(level, __FILE__, __LINE__, component, std::this_thread::get_id())
 
// macro-style logging (compile-time determined)
#if UHD_LOG_MIN_LEVEL < 1
#    define UHD_LOG_TRACE(component, message) \
        _UHD_LOG_INTERNAL(component, uhd::log::trace) << message;
#else
#    define UHD_LOG_TRACE(component, message)
#endif
 
#if UHD_LOG_MIN_LEVEL < 2
#    define UHD_LOG_DEBUG(component, message) \
        _UHD_LOG_INTERNAL(component, uhd::log::debug) << message;
#else
#    define UHD_LOG_DEBUG(component, message)
#endif
 
#if UHD_LOG_MIN_LEVEL < 3
#    define UHD_LOG_INFO(component, message) \
        _UHD_LOG_INTERNAL(component, uhd::log::info) << message;
#else
#    define UHD_LOG_INFO(component, message)
#endif
 
#if UHD_LOG_MIN_LEVEL < 4
#    define UHD_LOG_WARNING(component, message) \
        _UHD_LOG_INTERNAL(component, uhd::log::warning) << message;
#else
#    define UHD_LOG_WARNING(component, message)
#endif
 
#if UHD_LOG_MIN_LEVEL < 5
#    define UHD_LOG_ERROR(component, message) \
        _UHD_LOG_INTERNAL(component, uhd::log::error) << message;
#else
#    define UHD_LOG_ERROR(component, message)
#endif
 
#define UHD_LOG_THROW(exception_type, component, message) \
    {                                                     \
        std::ostringstream __ss;                          \
        __ss << message;                                  \
        UHD_LOG_ERROR(component, __ss.str());             \
        throw exception_type(__ss.str());                 \
    }
 
#if UHD_LOG_MIN_LEVEL < 6
#    define UHD_LOG_FATAL(component, message) \
        _UHD_LOG_INTERNAL(component, uhd::log::fatal) << message;
#else
#    define UHD_LOG_FATAL(component, message)
#endif
 
#define RFNOC_LOG_TRACE(message)   UHD_LOG_TRACE(this->get_unique_id(), message)
#define RFNOC_LOG_DEBUG(message)   UHD_LOG_DEBUG(this->get_unique_id(), message)
#define RFNOC_LOG_INFO(message)    UHD_LOG_INFO(this->get_unique_id(), message)
#define RFNOC_LOG_WARNING(message) UHD_LOG_WARNING(this->get_unique_id(), message)
#define RFNOC_LOG_ERROR(message)   UHD_LOG_ERROR(this->get_unique_id(), message)
#define RFNOC_LOG_FATAL(message)   UHD_LOG_FATAL(this->get_unique_id(), message)
 
#ifndef UHD_LOG_FASTPATH_DISABLE
#    define UHD_LOG_FASTPATH(message) uhd::_log::log_fastpath(message);
#else
#    define UHD_LOG_FASTPATH(message)
#endif
 
// iostream-style logging
#define UHD_LOGGER_TRACE(component)   _UHD_LOG_INTERNAL(component, uhd::log::trace)
#define UHD_LOGGER_DEBUG(component)   _UHD_LOG_INTERNAL(component, uhd::log::debug)
#define UHD_LOGGER_INFO(component)    _UHD_LOG_INTERNAL(component, uhd::log::info)
#define UHD_LOGGER_WARNING(component) _UHD_LOG_INTERNAL(component, uhd::log::warning)
#define UHD_LOGGER_ERROR(component)   _UHD_LOG_INTERNAL(component, uhd::log::error)
#define UHD_LOGGER_FATAL(component)   _UHD_LOG_INTERNAL(component, uhd::log::fatal)
 
 
#if defined(__GNUG__)
#    define UHD_HERE()            \
        UHD_LOGGER_DEBUG("DEBUG") \
            << __FILE__ << ":" << __LINE__ << " (" << UHD_PRETTY_FUNCTION << ")";
#else
#    define UHD_HERE() UHD_LOGGER_DEBUG("DEBUG") << __FILE__ << ":" << __LINE__;
#endif
 
#define UHD_VAR(var) UHD_LOGGER_DEBUG("DEBUG") << #var << " = " << var;
 
#define UHD_HEX(var)                                                              \
    UHD_LOGGER_DEBUG("DEBUG") << #var << " = 0x" << std::hex << std::setfill('0') \
                              << std::setw(8) << var << std::dec;
 
namespace uhd {
namespace _log {
 
void UHD_API log_fastpath(const std::string&);
 
class UHD_API log
{
public:
    log(const uhd::log::severity_level verbosity,
        const std::string& file,
        const unsigned int line,
        const std::string& component,
        const std::thread::id thread_id);
 
    ~log(void);
 
// Macro for overloading insertion operators to avoid costly
// conversion of types if not logging.
#define INSERTION_OVERLOAD(x) \
    log& operator<<(x)        \
    {                         \
        if (_log_it) {        \
            _ss << val;       \
        }                     \
        return *this;         \
    }
 
    // General insertion overload
    template <typename T>
    INSERTION_OVERLOAD(T val);
 
    // Insertion overloads for std::ostream manipulators
    INSERTION_OVERLOAD(std::ostream& (*val)(std::ostream&));
    INSERTION_OVERLOAD(std::ios& (*val)(std::ios&));
    INSERTION_OVERLOAD(std::ios_base& (*val)(std::ios_base&));
 
private:
    uhd::log::detail::logging_info _log_info;
    std::ostringstream _ss;
    const bool _log_it;
};
 
} // namespace _log
} /* namespace uhd */