logger-inl.h

Go to the documentation of this file.

// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
 
#pragma once
 
#ifndef SPDLOG_HEADER_ONLY
#include <spdlog/logger.h>
#endif
 
#include <spdlog/sinks/sink.h>
#include <spdlog/details/backtracer.h>
#include <spdlog/pattern_formatter.h>
 
#include <cstdio>
 
namespace spdlog
{
 
    // public methods
    SPDLOG_INLINE logger::logger(const logger& other)
        : name_(other.name_), sinks_(other.sinks_), level_(other.level_.load(std::memory_order_relaxed)), flush_level_(other.flush_level_.load(std::memory_order_relaxed)), custom_err_handler_(other.custom_err_handler_), tracer_(other.tracer_)
    {
    }
 
    SPDLOG_INLINE logger::logger(logger&& other) SPDLOG_NOEXCEPT : name_(std::move(other.name_)),
                                                                   sinks_(std::move(other.sinks_)),
                                                                   level_(other.level_.load(std::memory_order_relaxed)),
                                                                   flush_level_(other.flush_level_.load(std::memory_order_relaxed)),
                                                                   custom_err_handler_(std::move(other.custom_err_handler_)),
                                                                   tracer_(std::move(other.tracer_))
 
    {
    }
 
    SPDLOG_INLINE logger& logger::operator=(logger other) SPDLOG_NOEXCEPT
    {
        this->swap(other);
        return *this;
    }
 
    SPDLOG_INLINE void logger::swap(spdlog::logger& other) SPDLOG_NOEXCEPT
    {
        name_.swap(other.name_);
        sinks_.swap(other.sinks_);
 
        // swap level_
        auto other_level = other.level_.load();
        auto my_level    = level_.exchange(other_level);
        other.level_.store(my_level);
 
        // swap flush level_
        other_level = other.flush_level_.load();
        my_level    = flush_level_.exchange(other_level);
        other.flush_level_.store(my_level);
 
        custom_err_handler_.swap(other.custom_err_handler_);
        std::swap(tracer_, other.tracer_);
    }
 
    SPDLOG_INLINE void swap(logger& a, logger& b)
    {
        a.swap(b);
    }
 
    SPDLOG_INLINE void logger::set_level(level::level_enum log_level)
    {
        level_.store(log_level);
    }
 
    SPDLOG_INLINE level::level_enum logger::level() const
    {
        return static_cast<level::level_enum>(level_.load(std::memory_order_relaxed));
    }
 
    SPDLOG_INLINE const std::string& logger::name() const
    {
        return name_;
    }
 
    // set formatting for the sinks in this logger.
    // each sink will get a separate instance of the formatter object.
    SPDLOG_INLINE void logger::set_formatter(std::unique_ptr<formatter> f)
    {
        for (auto it = sinks_.begin(); it != sinks_.end(); ++it)
        {
            if (std::next(it) == sinks_.end())
            {
                // last element - we can be move it.
                (*it)->set_formatter(std::move(f));
                break; // to prevent clang-tidy warning
            }
            else
            {
                (*it)->set_formatter(f->clone());
            }
        }
    }
 
    SPDLOG_INLINE void logger::set_pattern(std::string pattern, pattern_time_type time_type)
    {
        auto new_formatter = details::make_unique<pattern_formatter>(std::move(pattern), time_type);
        set_formatter(std::move(new_formatter));
    }
 
    // create new backtrace sink and move to it all our child sinks
    SPDLOG_INLINE void logger::enable_backtrace(size_t n_messages)
    {
        tracer_.enable(n_messages);
    }
 
    // restore orig sinks and level and delete the backtrace sink
    SPDLOG_INLINE void logger::disable_backtrace()
    {
        tracer_.disable();
    }
 
    SPDLOG_INLINE void logger::dump_backtrace()
    {
        dump_backtrace_();
    }
 
    // flush functions
    SPDLOG_INLINE void logger::flush()
    {
        flush_();
    }
 
    SPDLOG_INLINE void logger::flush_on(level::level_enum log_level)
    {
        flush_level_.store(log_level);
    }
 
    SPDLOG_INLINE level::level_enum logger::flush_level() const
    {
        return static_cast<level::level_enum>(flush_level_.load(std::memory_order_relaxed));
    }
 
    // sinks
    SPDLOG_INLINE const std::vector<sink_ptr>& logger::sinks() const
    {
        return sinks_;
    }
 
    SPDLOG_INLINE std::vector<sink_ptr>& logger::sinks()
    {
        return sinks_;
    }
 
    // error handler
    SPDLOG_INLINE void logger::set_error_handler(err_handler handler)
    {
        custom_err_handler_ = std::move(handler);
    }
 
    // create new logger with same sinks and configuration.
    SPDLOG_INLINE std::shared_ptr<logger> logger::clone(std::string logger_name)
    {
        auto cloned   = std::make_shared<logger>(*this);
        cloned->name_ = std::move(logger_name);
        return cloned;
    }
 
    // protected methods
    SPDLOG_INLINE void logger::log_it_(const spdlog::details::log_msg& log_msg, bool log_enabled, bool traceback_enabled)
    {
        if (log_enabled)
        {
            sink_it_(log_msg);
        }
        if (traceback_enabled)
        {
            tracer_.push_back(log_msg);
        }
    }
 
    SPDLOG_INLINE void logger::sink_it_(const details::log_msg& msg)
    {
        for (auto& sink : sinks_)
        {
            if (sink->should_log(msg.level))
            {
                SPDLOG_TRY
                {
                    sink->log(msg);
                }
                SPDLOG_LOGGER_CATCH(msg.source)
            }
        }
 
        if (should_flush_(msg))
        {
            flush_();
        }
    }
 
    SPDLOG_INLINE void logger::flush_()
    {
        for (auto& sink : sinks_)
        {
            SPDLOG_TRY
            {
                sink->flush();
            }
            SPDLOG_LOGGER_CATCH(source_loc())
        }
    }
 
    SPDLOG_INLINE void logger::dump_backtrace_()
    {
        using details::log_msg;
        if (tracer_.enabled() && !tracer_.empty())
        {
            sink_it_(log_msg{name(), level::info, "****************** Backtrace Start ******************"});
            tracer_.foreach_pop([this](const log_msg& msg) { this->sink_it_(msg); });
            sink_it_(log_msg{name(), level::info, "****************** Backtrace End ********************"});
        }
    }
 
    SPDLOG_INLINE bool logger::should_flush_(const details::log_msg& msg)
    {
        auto flush_level = flush_level_.load(std::memory_order_relaxed);
        return (msg.level >= flush_level) && (msg.level != level::off);
    }
 
    SPDLOG_INLINE void logger::err_handler_(const std::string& msg)
    {
        if (custom_err_handler_)
        {
            custom_err_handler_(msg);
        }
        else
        {
            using std::chrono::system_clock;
            static std::mutex                            mutex;
            static std::chrono::system_clock::time_point last_report_time;
            static size_t                                err_counter = 0;
            std::lock_guard<std::mutex>                  lk{mutex};
            auto                                         now = system_clock::now();
            err_counter++;
            if (now - last_report_time < std::chrono::seconds(1))
            {
                return;
            }
            last_report_time = now;
            auto tm_time     = details::os::localtime(system_clock::to_time_t(now));
            char date_buf[64];
            std::strftime(date_buf, sizeof(date_buf), "%Y-%m-%d %H:%M:%S", &tm_time);
#if defined(USING_R) && defined(R_R_H) // if in R environment
            REprintf("[*** LOG ERROR #%04zu ***] [%s] [%s] {%s}\n", err_counter, date_buf, name().c_str(), msg.c_str());
#else
            std::fprintf(stderr, "[*** LOG ERROR #%04zu ***] [%s] [%s] {%s}\n", err_counter, date_buf, name().c_str(), msg.c_str());
#endif
        }
    }
} // namespace spdlog