Mirror/spdlog
1
0
Fork 0
mirror of https://github.com/gabime/spdlog.git synced 2025-10-02 03:19:02 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/v1.x' into pwm1234/rotate_on_open

Browse Source
This commit is contained in:
Philip Miller
2018-09-06 11:40:46 -04:00
parent 52a01b2cf2 1cb49bfe72
commit 22f85deb2c
51 changed files with 718 additions and 318 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/spdlog/async.h
View File

@@ -42,7 +42,7 @@ struct async_factory_impl
auto &registry_inst = details::registry::instance();
// create global thread pool if not already exists..
std::lock_guard<std::recursive_mutex>(registry_inst.tp_mutex());
std::lock_guard<std::recursive_mutex> tp_lock(registry_inst.tp_mutex());
auto tp = registry_inst.get_tp();
if (tp == nullptr)
{

4
include/spdlog/async_logger.h
View File

@@ -49,12 +49,14 @@ public:
async_logger(std::string logger_name, const It &begin, const It &end, std::weak_ptr<details::thread_pool> tp,
async_overflow_policy overflow_policy = async_overflow_policy::block);
async_logger(std::string logger_name, sinks_init_list sinks, std::weak_ptr<details::thread_pool> tp,
async_logger(std::string logger_name, sinks_init_list sinks_list, std::weak_ptr<details::thread_pool> tp,
async_overflow_policy overflow_policy = async_overflow_policy::block);
async_logger(std::string logger_name, sink_ptr single_sink, std::weak_ptr<details::thread_pool> tp,
async_overflow_policy overflow_policy = async_overflow_policy::block);
std::shared_ptr<logger> clone(std::string new_name) override;
protected:
void sink_it_(details::log_msg &msg) override;
void flush_() override;

41
include/spdlog/common.h
View File

@@ -100,6 +100,7 @@ inline const char *to_short_c_str(spdlog::level::level_enum l)
{
return short_level_names[l];
}
inline spdlog::level::level_enum from_str(const std::string &name)
{
static std::unordered_map<std::string, level_enum> name_to_level = // map string->level
@@ -131,35 +132,28 @@ enum class pattern_time_type
//
// Log exception
//
class spdlog_ex : public std::runtime_error
class spdlog_ex : public std::exception
{
public:
explicit spdlog_ex(const std::string &msg)
: runtime_error(msg)
: msg_(msg)
{
}
spdlog_ex(std::string msg, int last_errno)
: runtime_error(std::move(msg))
, last_errno_(last_errno)
spdlog_ex(const std::string &msg, int last_errno)
{
fmt::memory_buffer outbuf;
fmt::format_system_error(outbuf, last_errno, msg);
msg_ = fmt::to_string(outbuf);
}
const char *what() const SPDLOG_NOEXCEPT override
{
if (last_errno_)
{
fmt::memory_buffer buf;
std::string msg(runtime_error::what());
fmt::format_system_error(buf, last_errno_, msg);
return fmt::to_string(buf).c_str();
}
else
{
return runtime_error::what();
}
return msg_.c_str();
}
private:
int last_errno_{0};
std::string msg_;
};
//
@@ -180,4 +174,17 @@ using filename_t = std::string;
{ \
err_handler_("Unknown exeption in logger"); \
}
//
// make_unique support
//
#if __cplusplus >= 201402L // C++14 and beyond
using std::make_unique;
#else
template<typename T, typename... Args>
std::unique_ptr<T> make_unique(Args &&... args)
{
return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}
#endif
} // namespace spdlog

12
include/spdlog/details/async_logger_impl.h
View File

@@ -47,7 +47,7 @@ inline void spdlog::async_logger::sink_it_(details::log_msg &msg)
}
else
{
throw spdlog_ex("async log: thread pool doens't exist anymore");
throw spdlog_ex("async log: thread pool doesn't exist anymore");
}
}
@@ -98,3 +98,13 @@ inline void spdlog::async_logger::backend_flush_()
}
SPDLOG_CATCH_AND_HANDLE
}
inline std::shared_ptr<spdlog::logger> spdlog::async_logger::clone(std::string new_name)
{
auto cloned = std::make_shared<spdlog::async_logger>(std::move(new_name), sinks_.begin(), sinks_.end(), thread_pool_, overflow_policy_);
cloned->set_level(this->level());
cloned->flush_on(this->flush_level());
cloned->set_error_handler(this->error_handler());
return std::move(cloned);
}

12
include/spdlog/details/circular_q.h
View File

@@ -6,6 +6,8 @@
// cirucal q view of std::vector.
#pragma once
#include <vector>
namespace spdlog {
namespace details {
template<typename T>
@@ -29,6 +31,7 @@ public:
if (tail_ == head_) // overrun last item if full
{
head_ = (head_ + 1) % max_items_;
++overrun_counter_;
}
}
@@ -51,12 +54,19 @@ public:
return ((tail_ + 1) % max_items_) == head_;
}
size_t overrun_counter() const
{
return overrun_counter_;
}
private:
size_t max_items_;
typename std::vector<T>::size_type head_ = 0;
typename std::vector<T>::size_type tail_ = 0;
std::vector<T> v_;
size_t overrun_counter_ = 0;
};
} // namespace details
} // namespace spdlog
} // namespace spdlog

19
include/spdlog/details/console_globals.h
View File

@@ -5,14 +5,27 @@
//
#include "spdlog/details/null_mutex.h"
#include "stdio.h"
#include <cstdio>
#include <mutex>
#ifdef _WIN32
#ifndef NOMINMAX
#define NOMINMAX // prevent windows redefining min/max
#endif
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#include <windows.h>
#endif
namespace spdlog {
namespace details {
struct console_stdout
{
static FILE *stream()
static std::FILE *stream()
{
return stdout;
}
@@ -26,7 +39,7 @@ struct console_stdout
struct console_stderr
{
static FILE *stream()
static std::FILE *stream()
{
return stderr;
}

15
include/spdlog/details/file_helper.h
View File

@@ -5,13 +5,12 @@
#pragma once
// Helper class for file sink
// When failing to open a file, retry several times(5) with small delay between
// the tries(10 ms)
// Throw spdlog_ex exception on errors
// Helper class for file sinks.
// When failing to open a file, retry several times(5) with a delay interval(10 ms).
// Throw spdlog_ex exception on errors.
#include "../details/log_msg.h"
#include "../details/os.h"
#include "spdlog/details/log_msg.h"
#include "spdlog/details/os.h"
#include <cerrno>
#include <chrono>
@@ -136,7 +135,7 @@ public:
// treat casese like "/etc/rc.d/somelogfile or "/abc/.hiddenfile"
auto folder_index = fname.rfind(details::os::folder_sep);
if (folder_index != fname.npos && folder_index >= ext_index - 1)
if (folder_index != filename_t::npos && folder_index >= ext_index - 1)
{
return std::make_tuple(fname, spdlog::filename_t());
}
@@ -146,7 +145,7 @@ public:
}
private:
FILE *fd_{nullptr};
std::FILE *fd_{nullptr};
filename_t _filename;
};
} // namespace details

22
include/spdlog/details/fmt_helper.h
View File

@@ -22,12 +22,8 @@ inline void append_str(const std::string &str, fmt::basic_memory_buffer<char, Bu
template<size_t Buffer_Size>
inline void append_c_str(const char *c_str, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
{
char ch;
while ((ch = *c_str) != '\0')
{
dest.push_back(ch);
++c_str;
}
auto len = std::char_traits<char>::length(c_str);
dest.append(c_str, c_str + len);
}
template<size_t Buffer_Size1, size_t Buffer_Size2>
@@ -54,14 +50,14 @@ inline void pad2(int n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
}
if (n > 9) // 10-99
{
dest.push_back('0' + static_cast<char>(n / 10));
dest.push_back('0' + static_cast<char>(n % 10));
dest.push_back(static_cast<char>('0' + n / 10));
dest.push_back(static_cast<char>('0' + n % 10));
return;
}
if (n >= 0) // 0-9
{
dest.push_back('0');
dest.push_back('0' + static_cast<char>(n));
dest.push_back(static_cast<char>('0' + n));
return;
}
// negatives (unlikely, but just in case, let fmt deal with it)
@@ -86,15 +82,15 @@ inline void pad3(int n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
if (n > 9) // 10-99
{
dest.push_back('0');
dest.push_back('0' + static_cast<char>(n / 10));
dest.push_back('0' + static_cast<char>(n % 10));
dest.push_back(static_cast<char>('0' + n / 10));
dest.push_back(static_cast<char>('0' + n % 10));
return;
}
if (n >= 0)
{
dest.push_back('0');
dest.push_back('0');
dest.push_back('0' + static_cast<char>(n));
dest.push_back(static_cast<char>('0' + n));
return;
}
// negatives (unlikely, but just in case let fmt deal with it)
@@ -127,4 +123,4 @@ inline ToDuration time_fraction(const log_clock::time_point &tp)
} // namespace fmt_helper
} // namespace details
} // namespace spdlog
} // namespace spdlog

7
include/spdlog/details/log_msg.h
View File

@@ -16,17 +16,18 @@ namespace details {
struct log_msg
{
log_msg() = default;
log_msg(const std::string *loggers_name, level::level_enum lvl)
: logger_name(loggers_name)
, level(lvl)
{
#ifndef SPDLOG_NO_DATETIME
time = os::now();
, time(os::now())
#endif
#ifndef SPDLOG_NO_THREAD_ID
thread_id = os::thread_id();
, thread_id(os::thread_id())
#endif
{
}
log_msg(const log_msg &other) = delete;

18
include/spdlog/details/logger_impl.h
View File

@@ -5,6 +5,8 @@
#pragma once
#include "spdlog/details/fmt_helper.h"
#include <memory>
#include <string>
@@ -77,7 +79,7 @@ inline void spdlog::logger::log(level::level_enum lvl, const char *msg)
try
{
details::log_msg log_msg(&name_, lvl);
fmt::format_to(log_msg.raw, "{}", msg);
details::fmt_helper::append_c_str(msg, log_msg.raw);
sink_it_(log_msg);
}
SPDLOG_CATCH_AND_HANDLE
@@ -268,6 +270,11 @@ inline void spdlog::logger::flush_on(level::level_enum log_level)
flush_level_.store(log_level);
}
inline spdlog::level::level_enum spdlog::logger::flush_level() const
{
return static_cast<spdlog::level::level_enum>(flush_level_.load(std::memory_order_relaxed));
}
inline bool spdlog::logger::should_flush_(const details::log_msg &msg)
{
auto flush_level = flush_level_.load(std::memory_order_relaxed);
@@ -343,3 +350,12 @@ inline std::vector<spdlog::sink_ptr> &spdlog::logger::sinks()
{
return sinks_;
}
inline std::shared_ptr<spdlog::logger> spdlog::logger::clone(std::string logger_name)
{
auto cloned = std::make_shared<spdlog::logger>(std::move(logger_name), sinks_.begin(), sinks_.end());
cloned->set_level(this->level());
cloned->flush_on(this->flush_level());
cloned->set_error_handler(this->error_handler());
return cloned;
}

6
include/spdlog/details/mpmc_blocking_q.h
View File

@@ -105,6 +105,12 @@ public:
#endif
size_t overrun_counter()
{
std::unique_lock<std::mutex> lock(queue_mutex_);
return q_.overrun_counter();
}
private:
std::mutex queue_mutex_;
std::condition_variable push_cv_;

4
include/spdlog/details/os.h
View File

@@ -159,9 +159,9 @@ inline bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mod
{
#ifdef _WIN32
#ifdef SPDLOG_WCHAR_FILENAMES
*fp = _wfsopen((filename.c_str()), mode.c_str(), _SH_DENYWR);
*fp = _wfsopen((filename.c_str()), mode.c_str(), _SH_DENYNO);
#else
*fp = _fsopen((filename.c_str()), mode.c_str(), _SH_DENYWR);
*fp = _fsopen((filename.c_str()), mode.c_str(), _SH_DENYNO);
#endif
#else // unix
*fp = fopen((filename.c_str()), mode.c_str());

81
include/spdlog/details/pattern_formatter.h
View File

@@ -69,7 +69,7 @@ static const char *ampm(const tm &t)
return t.tm_hour >= 12 ? "PM" : "AM";
}
static unsigned int to12h(const tm &t)
static int to12h(const tm &t)
{
return t.tm_hour > 12 ? t.tm_hour - 12 : t.tm_hour;
}
@@ -242,7 +242,7 @@ class f_formatter SPDLOG_FINAL : public flag_formatter
void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
{
auto micros = fmt_helper::time_fraction<std::chrono::microseconds>(msg.time);
fmt_helper::pad6(static_cast<int>(micros.count()), dest);
fmt_helper::pad6(static_cast<size_t>(micros.count()), dest);
}
};
@@ -545,9 +545,9 @@ public:
pattern_formatter(const pattern_formatter &other) = delete;
pattern_formatter &operator=(const pattern_formatter &other) = delete;
virtual std::unique_ptr<formatter> clone() const override
std::unique_ptr<formatter> clone() const override
{
return std::unique_ptr<formatter>(new pattern_formatter(pattern_, pattern_time_type_, eol_));
return spdlog::make_unique<pattern_formatter>(pattern_, pattern_time_type_, eol_);
}
void format(const details::log_msg &msg, fmt::memory_buffer &dest) override
@@ -592,141 +592,141 @@ private:
{
// logger name
case 'n':
formatters_.emplace_back(new details::name_formatter());
formatters_.push_back(spdlog::make_unique<details::name_formatter>());
break;
case 'l':
formatters_.emplace_back(new details::level_formatter());
formatters_.push_back(spdlog::make_unique<details::level_formatter>());
break;
case 'L':
formatters_.emplace_back(new details::short_level_formatter());
formatters_.push_back(spdlog::make_unique<details::short_level_formatter>());
break;
case ('t'):
formatters_.emplace_back(new details::t_formatter());
formatters_.push_back(spdlog::make_unique<details::t_formatter>());
break;
case ('v'):
formatters_.emplace_back(new details::v_formatter());
formatters_.push_back(spdlog::make_unique<details::v_formatter>());
break;
case ('a'):
formatters_.emplace_back(new details::a_formatter());
formatters_.push_back(spdlog::make_unique<details::a_formatter>());
break;
case ('A'):
formatters_.emplace_back(new details::A_formatter());
formatters_.push_back(spdlog::make_unique<details::A_formatter>());
break;
case ('b'):
case ('h'):
formatters_.emplace_back(new details::b_formatter());
formatters_.push_back(spdlog::make_unique<details::b_formatter>());
break;
case ('B'):
formatters_.emplace_back(new details::B_formatter());
formatters_.push_back(spdlog::make_unique<details::B_formatter>());
break;
case ('c'):
formatters_.emplace_back(new details::c_formatter());
formatters_.push_back(spdlog::make_unique<details::c_formatter>());
break;
case ('C'):
formatters_.emplace_back(new details::C_formatter());
formatters_.push_back(spdlog::make_unique<details::C_formatter>());
break;
case ('Y'):
formatters_.emplace_back(new details::Y_formatter());
formatters_.push_back(spdlog::make_unique<details::Y_formatter>());
break;
case ('D'):
case ('x'):
formatters_.emplace_back(new details::D_formatter());
formatters_.push_back(spdlog::make_unique<details::D_formatter>());
break;
case ('m'):
formatters_.emplace_back(new details::m_formatter());
formatters_.push_back(spdlog::make_unique<details::m_formatter>());
break;
case ('d'):
formatters_.emplace_back(new details::d_formatter());
formatters_.push_back(spdlog::make_unique<details::d_formatter>());
break;
case ('H'):
formatters_.emplace_back(new details::H_formatter());
formatters_.push_back(spdlog::make_unique<details::H_formatter>());
break;
case ('I'):
formatters_.emplace_back(new details::I_formatter());
formatters_.push_back(spdlog::make_unique<details::I_formatter>());
break;
case ('M'):
formatters_.emplace_back(new details::M_formatter());
formatters_.push_back(spdlog::make_unique<details::M_formatter>());
break;
case ('S'):
formatters_.emplace_back(new details::S_formatter());
formatters_.push_back(spdlog::make_unique<details::S_formatter>());
break;
case ('e'):
formatters_.emplace_back(new details::e_formatter());
formatters_.push_back(spdlog::make_unique<details::e_formatter>());
break;
case ('f'):
formatters_.emplace_back(new details::f_formatter());
formatters_.push_back(spdlog::make_unique<details::f_formatter>());
break;
case ('F'):
formatters_.emplace_back(new details::F_formatter());
formatters_.push_back(spdlog::make_unique<details::F_formatter>());
break;
case ('E'):
formatters_.emplace_back(new details::E_formatter());
formatters_.push_back(spdlog::make_unique<details::E_formatter>());
break;
case ('p'):
formatters_.emplace_back(new details::p_formatter());
formatters_.push_back(spdlog::make_unique<details::p_formatter>());
break;
case ('r'):
formatters_.emplace_back(new details::r_formatter());
formatters_.push_back(spdlog::make_unique<details::r_formatter>());
break;
case ('R'):
formatters_.emplace_back(new details::R_formatter());
formatters_.push_back(spdlog::make_unique<details::R_formatter>());
break;
case ('T'):
case ('X'):
formatters_.emplace_back(new details::T_formatter());
formatters_.push_back(spdlog::make_unique<details::T_formatter>());
break;
case ('z'):
formatters_.emplace_back(new details::z_formatter());
formatters_.push_back(spdlog::make_unique<details::z_formatter>());
break;
case ('+'):
formatters_.emplace_back(new details::full_formatter());
formatters_.push_back(spdlog::make_unique<details::full_formatter>());
break;
case ('P'):
formatters_.emplace_back(new details::pid_formatter());
formatters_.push_back(spdlog::make_unique<details::pid_formatter>());
break;
case ('i'):
formatters_.emplace_back(new details::i_formatter());
formatters_.push_back(spdlog::make_unique<details::i_formatter>());
break;
case ('^'):
formatters_.emplace_back(new details::color_start_formatter());
formatters_.push_back(spdlog::make_unique<details::color_start_formatter>());
break;
case ('$'):
formatters_.emplace_back(new details::color_stop_formatter());
formatters_.push_back(spdlog::make_unique<details::color_stop_formatter>());
break;
default: // Unknown flag appears as is
formatters_.emplace_back(new details::ch_formatter('%'));
formatters_.emplace_back(new details::ch_formatter(flag));
formatters_.push_back(spdlog::make_unique<details::ch_formatter>('%'));
formatters_.push_back(spdlog::make_unique<details::ch_formatter>(flag));
break;
}
}
@@ -744,7 +744,6 @@ private:
{
formatters_.push_back(std::move(user_chars));
}
// if(
if (++it != end)
{
handle_flag_(*it);
@@ -758,7 +757,7 @@ private:
{
if (!user_chars)
{
user_chars = std::unique_ptr<details::aggregate_formatter>(new details::aggregate_formatter());
user_chars = spdlog::make_unique<details::aggregate_formatter>();
}
user_chars->add_ch(*it);
}

2
include/spdlog/details/periodic_worker.h
View File

@@ -23,7 +23,7 @@ namespace details {
class periodic_worker
{
public:
periodic_worker(std::function<void()> callback_fun, std::chrono::seconds interval)
periodic_worker(const std::function<void()> &callback_fun, std::chrono::seconds interval)
{
active_ = (interval > std::chrono::seconds::zero());
if (!active_)

16
include/spdlog/details/registry.h
View File

@@ -35,7 +35,7 @@ public:
std::lock_guard<std::mutex> lock(logger_map_mutex_);
auto logger_name = new_logger->name();
throw_if_exists_(logger_name);
loggers_[logger_name] = new_logger;
loggers_[logger_name] = std::move(new_logger);
}
void register_and_init(std::shared_ptr<logger> new_logger)
@@ -56,7 +56,7 @@ public:
new_logger->flush_on(flush_level_);
// add to registry
loggers_[logger_name] = new_logger;
loggers_[logger_name] = std::move(new_logger);
}
std::shared_ptr<logger> get(const std::string &logger_name)
@@ -112,8 +112,8 @@ public:
void flush_every(std::chrono::seconds interval)
{
std::lock_guard<std::mutex> lock(flusher_mutex_);
std::function<void()> clbk(std::bind(&registry::flush_all, this));
periodic_flusher_.reset(new periodic_worker(clbk, interval));
std::function<void()> clbk = std::bind(&registry::flush_all, this);
periodic_flusher_ = spdlog::make_unique<periodic_worker>(clbk, interval);
}
void set_error_handler(log_err_handler handler)
@@ -126,7 +126,7 @@ public:
err_handler_ = handler;
}
void apply_all(std::function<void(std::shared_ptr<logger>)> fun)
void apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun)
{
std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_)
@@ -189,11 +189,7 @@ private:
{
}
~registry()
{
/*std::lock_guard<std::mutex> lock(flusher_mutex_);
periodic_flusher_.reset();*/
}
~registry() = default;
void throw_if_exists_(const std::string &logger_name)
{

31
include/spdlog/details/thread_pool.h
View File

@@ -64,8 +64,8 @@ struct async_msg
return *this;
}
#else // (_MSC_VER) && _MSC_VER <= 1800
async_msg(async_msg &&other) = default;
async_msg &operator=(async_msg &&other) = default;
async_msg(async_msg &&) = default;
async_msg &operator=(async_msg &&) = default;
#endif
// construct from log_msg with given type
@@ -122,7 +122,7 @@ public:
}
for (size_t i = 0; i < threads_n; i++)
{
threads_.emplace_back(std::bind(&thread_pool::worker_loop_, this));
threads_.emplace_back(&thread_pool::worker_loop_, this);
}
}
@@ -157,6 +157,11 @@ public:
post_async_msg_(async_msg(std::move(worker_ptr), async_msg_type::flush), overflow_policy);
}
size_t overrun_counter()
{
return q_.overrun_counter();
}
private:
q_type q_;
@@ -193,6 +198,13 @@ private:
switch (incoming_async_msg.msg_type)
{
case async_msg_type::log:
{
log_msg msg;
incoming_async_msg.to_log_msg(msg);
incoming_async_msg.worker_ptr->backend_log_(msg);
return true;
}
case async_msg_type::flush:
{
incoming_async_msg.worker_ptr->backend_flush_();
@@ -203,18 +215,11 @@ private:
{
return false;
}
default:
{
log_msg msg;
incoming_async_msg.to_log_msg(msg);
incoming_async_msg.worker_ptr->backend_log_(msg);
return true;
}
}
return true; // should not be reached
assert(false && "Unexpected async_msg_type");
return true;
}
};
} // namespace details
} // namespace spdlog
} // namespace spdlog

8
include/spdlog/logger.h
View File

@@ -120,16 +120,22 @@ public:
void set_formatter(std::unique_ptr<formatter> formatter);
void set_pattern(std::string pattern, pattern_time_type time_type = pattern_time_type::local);
// flush functions
void flush();
void flush_on(level::level_enum log_level);
level::level_enum flush_level() const;
// sinks
const std::vector<sink_ptr> &sinks() const;
std::vector<sink_ptr> &sinks();
// error handler
void set_error_handler(log_err_handler err_handler);
log_err_handler error_handler();
// create new logger with same sinks and configuration.
virtual std::shared_ptr<logger> clone(std::string logger_name);
protected:
virtual void sink_it_(details::log_msg &msg);
virtual void flush_();

8
include/spdlog/sinks/android_sink.h
View File

@@ -30,8 +30,8 @@ template<typename Mutex>
class android_sink SPDLOG_FINAL : public base_sink<Mutex>
{
public:
explicit android_sink(const std::string &tag = "spdlog", bool use_raw_msg = false)
: tag_(tag)
explicit android_sink(std::string tag = "spdlog", bool use_raw_msg = false)
: tag_(std::move(tag))
, use_raw_msg_(use_raw_msg)
{
}
@@ -43,11 +43,11 @@ protected:
fmt::memory_buffer formatted;
if (use_raw_msg_)
{
fmt_helper::append_buf(msg.raw, formatted);
details::fmt_helper::append_buf(msg.raw, formatted);
}
else
{
formatter_->format(msg, formatted);
sink::formatter_->format(msg, formatted);
}
formatted.push_back('\0');
const char *msg_output = formatted.data();

10
include/spdlog/sinks/ansicolor_sink.h
View File

@@ -24,7 +24,7 @@ namespace sinks {
* If no color terminal detected, omit the escape codes.
*/
template<typename TargetStream, class ConsoleMutex>
class ansicolor_sink : public sink
class ansicolor_sink SPDLOG_FINAL : public sink
{
public:
using mutex_t = typename ConsoleMutex::mutex_t;
@@ -84,7 +84,7 @@ public:
const std::string on_cyan = "\033[46m";
const std::string on_white = "\033[47m";
void log(const details::log_msg &msg) SPDLOG_FINAL override
void log(const details::log_msg &msg) override
{
// Wrap the originally formatted message in color codes.
// If color is not supported in the terminal, log as is instead.
@@ -110,19 +110,19 @@ public:
fflush(target_file_);
}
void flush() SPDLOG_FINAL override
void flush() override
{
std::lock_guard<mutex_t> lock(mutex_);
fflush(target_file_);
}
void set_pattern(const std::string &pattern) override SPDLOG_FINAL
void set_pattern(const std::string &pattern) SPDLOG_FINAL
{
std::lock_guard<mutex_t> lock(mutex_);
formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
}
void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override SPDLOG_FINAL
void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override
{
std::lock_guard<mutex_t> lock(mutex_);
formatter_ = std::move(sink_formatter);

2
include/spdlog/sinks/base_sink.h
View File

@@ -30,7 +30,7 @@ public:
base_sink(const base_sink &) = delete;
base_sink &operator=(const base_sink &) = delete;
void log(const details::log_msg &msg) SPDLOG_FINAL override
void log(const details::log_msg &msg) SPDLOG_FINAL
{
std::lock_guard<Mutex> lock(mutex_);
sink_it_(msg);

6
include/spdlog/sinks/dist_sink.h
View File

@@ -40,6 +40,12 @@ public:
sinks_.erase(std::remove(sinks_.begin(), sinks_.end(), sink), sinks_.end());
}
void set_sinks(std::vector<std::shared_ptr<sink>> sinks)
{
std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
sinks_ = std::move(sinks);
}
protected:
void sink_it_(const details::log_msg &msg) override
{

2
include/spdlog/sinks/ostream_sink.h
View File

@@ -30,7 +30,7 @@ protected:
{
fmt::memory_buffer formatted;
sink::formatter_->format(msg, formatted);
ostream_.write(formatted.data(), formatted.size());
ostream_.write(formatted.data(), static_cast<std::streamsize>(formatted.size()));
if (force_flush_)
ostream_.flush();
}

6
include/spdlog/sinks/sink.h
View File

@@ -20,9 +20,11 @@ public:
{
}
sink(std::unique_ptr<spdlog::pattern_formatter> formatter)
explicit sink(std::unique_ptr<spdlog::pattern_formatter> formatter)
: level_(level::trace)
, formatter_(std::move(formatter)){};
, formatter_(std::move(formatter))
{
}
virtual ~sink() = default;
virtual void log(const details::log_msg &msg) = 0;

9
include/spdlog/sinks/stdout_sinks.h
View File

@@ -12,14 +12,13 @@
#include <cstdio>
#include <memory>
#include <mutex>
#include <spdlog/details/console_globals.h>
namespace spdlog {
namespace sinks {
template<typename TargetStream, typename ConsoleMutex>
class stdout_sink : public sink
class stdout_sink SPDLOG_FINAL : public sink
{
public:
using mutex_t = typename ConsoleMutex::mutex_t;
@@ -28,7 +27,7 @@ public:
, file_(TargetStream::stream())
{
}
~stdout_sink() = default;
~stdout_sink() override = default;
stdout_sink(const stdout_sink &other) = delete;
stdout_sink &operator=(const stdout_sink &other) = delete;
@@ -48,13 +47,13 @@ public:
fflush(file_);
}
void set_pattern(const std::string &pattern) override SPDLOG_FINAL
void set_pattern(const std::string &pattern) override
{
std::lock_guard<mutex_t> lock(mutex_);
formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
}
void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override SPDLOG_FINAL
void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override
{
std::lock_guard<mutex_t> lock(mutex_);
formatter_ = std::move(sink_formatter);

4
include/spdlog/sinks/syslog_sink.h
View File

@@ -24,8 +24,8 @@ class syslog_sink : public base_sink<Mutex>
{
public:
//
syslog_sink(const std::string &ident = "", int syslog_option = 0, int syslog_facility = LOG_USER)
: ident_(ident)
explicit syslog_sink(std::string ident = "", int syslog_option = 0, int syslog_facility = LOG_USER)
: ident_(std::move(ident))
{
priorities_[static_cast<size_t>(level::trace)] = LOG_DEBUG;
priorities_[static_cast<size_t>(level::debug)] = LOG_DEBUG;

6
include/spdlog/spdlog.h
View File

@@ -64,7 +64,7 @@ inline void set_formatter(std::unique_ptr<spdlog::formatter> formatter)
// example: spdlog::set_pattern("%Y-%m-%d %H:%M:%S.%e %l : %v");
inline void set_pattern(std::string pattern, pattern_time_type time_type = pattern_time_type::local)
{
set_formatter(std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern, time_type)));
set_formatter(std::unique_ptr<spdlog::formatter>(new pattern_formatter(std::move(pattern), time_type)));
}
// Set global logging level
@@ -101,9 +101,9 @@ inline void register_logger(std::shared_ptr<logger> logger)
// Apply a user defined function on all registered loggers
// Example:
// spdlog::apply_all([&](std::shared_ptr<spdlog::logger> l) {l->flush();});
inline void apply_all(std::function<void(std::shared_ptr<logger>)> fun)
inline void apply_all(const std::function<void(std::shared_ptr<logger>)> &fun)
{
details::registry::instance().apply_all(std::move(fun));
details::registry::instance().apply_all(fun);
}
// Drop the reference to the given logger

2
include/spdlog/version.h
View File

@@ -6,7 +6,7 @@
#pragma once
#define SPDLOG_VER_MAJOR 1
#define SPDLOG_VER_MINOR 0
#define SPDLOG_VER_MINOR 1
#define SPDLOG_VER_PATCH 0
#define SPDLOG_VERSION (SPDLOG_VER_MAJOR * 10000 + SPDLOG_VER_MINOR * 100 + SPDLOG_VER_PATCH)