logging.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cstdint>
 
#include <map>
#include <memory>
#include <ostream>
 
#include <boost/log/attributes/clock.hpp>
#include <boost/log/expressions/keyword.hpp>
#include <boost/log/sinks/sync_frontend.hpp>
#include <boost/log/sinks/text_ostream_backend.hpp>
#include <boost/log/sources/severity_channel_logger.hpp>
#include <boost/log/utility/manipulators/add_value.hpp>
#include <boost/utility/string_view.hpp>
 
namespace viam {
namespace sdk {
 
 
enum class log_level : std::int8_t {
    trace = -2,
    debug = -1,
    info = 0,  // default value is info
    warn = 1,
    error = 2,
    fatal = 3,
};
 
std::string to_string(log_level);
 
log_level level_from_string(std::string level);
 
std::ostream& operator<<(std::ostream&, log_level);
 
using LogSource = boost::log::sources::severity_channel_logger_mt<log_level>;
 
const char* global_resource_name();
 
const char* default_module_name();
 
class LogManager {
   public:
    struct Filter {
        const LogManager* parent;
 
        bool operator()(const boost::log::attribute_value_set&) const;
    };
 
    static LogManager& get();
 
    void set_global_resource_name(const std::string& name);
 
    void set_global_log_level(log_level);
 
    void set_global_log_level(int argc, char** argv);
 
    void set_module_name(const std::string& name);
 
    void set_module_log_level(log_level);
 
    void set_resource_log_level(const std::string& resource, log_level);
 
    LogSource& global_logger();
 
    LogSource& module_logger();
 
   private:
    friend class RobotClient;
    friend class Instance;
    LogManager() = default;
 
    LogManager(const LogManager&) = delete;
    LogManager(LogManager&&) = delete;
 
    LogManager& operator=(const LogManager&) = delete;
    LogManager& operator=(LogManager&&) = delete;
 
    void init_logging();
    void enable_console_logging();
    void disable_console_logging();
 
    LogSource sdk_logger_;
 
    LogSource module_logger_;
 
    boost::shared_ptr<boost::log::sinks::synchronous_sink<boost::log::sinks::text_ostream_backend>>
        console_sink_;
 
    log_level global_level_{log_level::info};
    log_level module_level_{log_level::info};
 
    std::map<std::string, log_level> resource_levels_;
};
 
namespace log_detail {
 
// Some of the filenames in the SDK are not unique, eg config/resource.hpp, resource/resource.hpp.
// This function trims a full filename /path/to/some/file.xpp to some/file.xpp
boost::string_view trim_filename(const char* file);
 
}  // namespace log_detail
 
BOOST_LOG_ATTRIBUTE_KEYWORD_TYPE(attr_channel, "Channel", std::string);
BOOST_LOG_ATTRIBUTE_KEYWORD_TYPE(attr_sev, "Severity", viam::sdk::log_level);
BOOST_LOG_ATTRIBUTE_KEYWORD_TYPE(attr_file, "file", boost::string_view);
BOOST_LOG_ATTRIBUTE_KEYWORD_TYPE(attr_line, "line", unsigned int);
BOOST_LOG_ATTRIBUTE_KEYWORD_TYPE(attr_time,
                                 "TimeStamp",
                                 boost::log::attributes::local_clock::value_type);
 
#define VIAM_SDK_LOG_IMPL(lg, level)                                                 \
    BOOST_LOG_SEV((lg), ::viam::sdk::log_level::level)                               \
        << ::boost::log::add_value(::viam::sdk::attr_file_type{},                    \
                                   ::viam::sdk::log_detail::trim_filename(__FILE__)) \
        << ::boost::log::add_value(::viam::sdk::attr_line_type{}, __LINE__)
 
#define VIAM_SDK_LOG(level) VIAM_SDK_LOG_IMPL(::viam::sdk::LogManager::get().global_logger(), level)
 
#define VIAM_MODULE_LOG(level) \
    VIAM_SDK_LOG_IMPL(::viam::sdk::LogManager::get().module_logger(), level)
 
#define VIAM_RESOURCE_LOG(level) VIAM_SDK_LOG_IMPL(this->logger_, level)
 
}  // namespace sdk
}  // namespace viam