log.hpp

Go to the documentation of this file.

//
// Copyright 2011 Ettus Research LLC
//
// SPDX-License-Identifier: GPL-3.0
//

#ifndef INCLUDED_UHD_UTILS_LOG_HPP
#define INCLUDED_UHD_UTILS_LOG_HPP

#include <uhd/config.hpp>
#include <boost/current_function.hpp>
#include <boost/thread/thread.hpp>
#include <ostream>
#include <string>
#include <sstream>
#include <iostream>

/*
 * 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, 
        };

        struct UHD_API logging_info {
            logging_info()
                : verbosity(uhd::log::off) {}
            logging_info(
                const boost::posix_time::ptime &time_,
                const uhd::log::severity_level &verbosity_,
                const std::string &file_,
                const size_t &line_,
                const std::string &component_,
                const boost::thread::id &thread_id_
            ) : time(time_),
                verbosity(verbosity_),
                file(file_),
                line(line_),
                component(component_),
                thread_id(thread_id_)
            { /* nop */ }

            boost::posix_time::ptime time;
            uhd::log::severity_level verbosity;
            std::string file;
            unsigned int line;
            std::string component;
            boost::thread::id thread_id;
            std::string message;
        };

        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);
    }
}

#define _UHD_LOG_INTERNAL(component, level) \
    uhd::_log::log(level, __FILE__, __LINE__, component, boost::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

#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

#ifndef UHD_LOG_FASTPATH_DISABLE
// No metadata is tracked. Only the message is displayed. This does not go
// through the regular backends. Mostly used for printing the UOSDL characters
// during streaming.
#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__ << " (" << __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 &msg);

    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 boost::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::logging_info _log_info;
        std::ostringstream _ss;
        const bool _log_it;
    };

} //namespace uhd::_log
} /* namespace uhd */

#endif /* INCLUDED_UHD_UTILS_LOG_HPP */