Skip to content

S
spdlog
Unverified Commit 2e973c8b authored by Gabi Melman's avatar Gabi Melman Committed by GitHub
Browse files
Options

Merge pull request #647 from DanielChabrowski/clang-tidy 

Applied some of clang-tidy fixes
parents abc0d439 de642b62
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 244 additions and 284 deletions
include/spdlog/async_logger.h
View file @ 2e973c8b
......@@ -31,7 +31,7 @@ namespace details
class async_log_helper;
}
class async_logger SPDLOG_FINAL :public logger
class async_logger SPDLOG_FINAL : public logger
{
public:
template<class It>
......@@ -39,12 +39,12 @@ public:
const It& begin,
const It& end,
size_t queue_size,
const async_overflow_policy overflow_policy = async_overflow_policy::block_retry,
const async_overflow_policy overflow_policy = async_overflow_policy::block_retry,
const std::function<void()>& worker_warmup_cb = nullptr,
const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(),
const std::function<void()>& worker_teardown_cb = nullptr);
async_logger(const std::string& logger_name,
async_logger(const std::string& name,
sinks_init_list sinks,
size_t queue_size,
const async_overflow_policy overflow_policy = async_overflow_policy::block_retry,
......@@ -52,10 +52,10 @@ public:
const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(),
const std::function<void()>& worker_teardown_cb = nullptr);
async_logger(const std::string& logger_name,
async_logger(const std::string& name,
sink_ptr single_sink,
size_t queue_size,
const async_overflow_policy overflow_policy = async_overflow_policy::block_retry,
const async_overflow_policy overflow_policy = async_overflow_policy::block_retry,
const std::function<void()>& worker_warmup_cb = nullptr,
const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(),
const std::function<void()>& worker_teardown_cb = nullptr);
......@@ -65,8 +65,8 @@ public:
void flush() override;
// Error handler
virtual void set_error_handler(log_err_handler) override;
virtual log_err_handler error_handler() override;
void set_error_handler(log_err_handler) override;
log_err_handler error_handler() override;
protected:
void _sink_it(details::log_msg& msg) override;
......@@ -78,5 +78,4 @@ private:
};
}
#include "details/async_logger_impl.h"
include/spdlog/common.h
View file @ 2e973c8b
......@@ -75,7 +75,7 @@ using log_err_handler = std::function<void(const std::string &err_msg)>;
//Log level enum
namespace level
{
typedef enum
enum level_enum
{
trace = 0,
debug = 1,
......@@ -84,10 +84,10 @@ typedef enum
err = 4,
critical = 5,
off = 6
} level_enum;
};
#if !defined(SPDLOG_LEVEL_NAMES)
#define SPDLOG_LEVEL_NAMES { "trace", "debug", "info", "warning", "error", "critical", "off" }
#define SPDLOG_LEVEL_NAMES { "trace", "debug", "info", "warning", "error", "critical", "off" }
#endif
static const char* level_names[] SPDLOG_LEVEL_NAMES;
......@@ -106,7 +106,6 @@ using level_hasher = std::hash<int>;
} //level
//
// Async overflow policy - block by default.
//
......@@ -136,22 +135,24 @@ namespace os
std::string errno_str(int err_num);
}
}
class spdlog_ex: public std::exception
class spdlog_ex : public std::exception
{
public:
spdlog_ex(const std::string& msg):_msg(msg)
explicit spdlog_ex(std::string msg) : _msg(std::move(msg))
{}
spdlog_ex(const std::string& msg, int last_errno)
{
_msg = msg + ": " + details::os::errno_str(last_errno);
}
const char* what() const SPDLOG_NOEXCEPT override
{
return _msg.c_str();
}
private:
std::string _msg;
};
//
......@@ -163,5 +164,4 @@ using filename_t = std::wstring;
using filename_t = std::string;
#endif
} //spdlog
include/spdlog/details/async_log_helper.h
View file @ 2e973c8b
......@@ -43,6 +43,7 @@ class async_log_helper
flush,
terminate
};
struct async_msg
{
std::string logger_name;
......@@ -56,8 +57,14 @@ class async_log_helper
async_msg() = default;
~async_msg() = default;
explicit async_msg(async_msg_type m_type) :
level(level::info),
thread_id(0),
msg_type(m_type),
msg_id(0)
{}
async_msg(async_msg&& other) SPDLOG_NOEXCEPT:
async_msg(async_msg&& other) SPDLOG_NOEXCEPT :
logger_name(std::move(other.logger_name)),
level(std::move(other.level)),
time(std::move(other.time)),
......@@ -67,13 +74,6 @@ async_msg(async_msg&& other) SPDLOG_NOEXCEPT:
msg_id(other.msg_id)
{}
async_msg(async_msg_type m_type):
level(level::info),
thread_id(0),
msg_type(m_type),
msg_id(0)
{}
async_msg& operator=(async_msg&& other) SPDLOG_NOEXCEPT
{
logger_name = std::move(other.logger_name);
......@@ -91,7 +91,7 @@ async_msg(async_msg&& other) SPDLOG_NOEXCEPT:
async_msg& operator=(const async_msg& other) = delete;
// construct from log_msg
async_msg(const details::log_msg& m):
explicit async_msg(const details::log_msg& m):
level(m.level),
time(m.time),
thread_id(m.thread_id),
......@@ -104,7 +104,6 @@ async_msg(async_msg&& other) SPDLOG_NOEXCEPT:
#endif
}
// copy into log_msg
void fill_log_msg(log_msg &msg)
{
......@@ -118,28 +117,29 @@ async_msg(async_msg&& other) SPDLOG_NOEXCEPT:
};
public:
using item_type = async_msg;
using q_type = details::mpmc_bounded_queue<item_type>;
using clock = std::chrono::steady_clock;
async_log_helper(formatter_ptr formatter,
const std::vector<sink_ptr>& sinks,
std::vector<sink_ptr> sinks,
size_t queue_size,
const log_err_handler err_handler,
const async_overflow_policy overflow_policy = async_overflow_policy::block_retry,
const std::function<void()>& worker_warmup_cb = nullptr,
std::function<void()> worker_warmup_cb = nullptr,
const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(),
const std::function<void()>& worker_teardown_cb = nullptr);
std::function<void()> worker_teardown_cb = nullptr);
void log(const details::log_msg& msg);
// stop logging and join the back thread
~async_log_helper();
void set_formatter(formatter_ptr);
async_log_helper(const async_log_helper&) = delete;
async_log_helper& operator=(const async_log_helper&) = delete;
void set_formatter(formatter_ptr msg_formatter);
void flush(bool wait_for_q);
......@@ -158,7 +158,6 @@ private:
bool _terminate_requested;
// overflow policy
const async_overflow_policy _overflow_policy;
......@@ -200,23 +199,23 @@ private:
///////////////////////////////////////////////////////////////////////////////
inline spdlog::details::async_log_helper::async_log_helper(
formatter_ptr formatter,
const std::vector<sink_ptr>& sinks,
std::vector<sink_ptr> sinks,
size_t queue_size,
log_err_handler err_handler,
const async_overflow_policy overflow_policy,
const std::function<void()>& worker_warmup_cb,
std::function<void()> worker_warmup_cb,
const std::chrono::milliseconds& flush_interval_ms,
const std::function<void()>& worker_teardown_cb):
_formatter(formatter),
_sinks(sinks),
std::function<void()> worker_teardown_cb):
_formatter(std::move(formatter)),
_sinks(std::move(sinks)),
_q(queue_size),
_err_handler(err_handler),
_err_handler(std::move(err_handler)),
_flush_requested(false),
_terminate_requested(false),
_overflow_policy(overflow_policy),
_worker_warmup_cb(worker_warmup_cb),
_worker_warmup_cb(std::move(worker_warmup_cb)),
_flush_interval_ms(flush_interval_ms),
_worker_teardown_cb(worker_teardown_cb)
_worker_teardown_cb(std::move(worker_teardown_cb))
{
_worker_thread = std::thread(&async_log_helper::worker_loop, this);
}
......@@ -328,13 +327,10 @@ inline bool spdlog::details::async_log_helper::process_next_msg(log_clock::time_
// Handle empty queue..
// This is the only place where the queue can terminate or flush to avoid losing messages already in the queue
else
{
auto now = details::os::now();
handle_flush_interval(now, last_flush);
sleep_or_yield(now, last_pop);
return !_terminate_requested;
}
auto now = details::os::now();
handle_flush_interval(now, last_flush);
sleep_or_yield(now, last_pop);
return !_terminate_requested;
}
// flush all sinks if _flush_interval_ms has expired
......@@ -352,10 +348,9 @@ inline void spdlog::details::async_log_helper::handle_flush_interval(log_clock::
inline void spdlog::details::async_log_helper::set_formatter(formatter_ptr msg_formatter)
{
_formatter = msg_formatter;
_formatter = std::move(msg_formatter);
}
// spin, yield or sleep. use the time passed since last message as a hint
inline void spdlog::details::async_log_helper::sleep_or_yield(const spdlog::log_clock::time_point& now, const spdlog::log_clock::time_point& last_op_time)
{
......@@ -392,8 +387,5 @@ inline void spdlog::details::async_log_helper::wait_empty_q()
inline void spdlog::details::async_log_helper::set_error_handler(spdlog::log_err_handler err_handler)
{
_err_handler = err_handler;
_err_handler = std::move(err_handler);
}
include/spdlog/details/async_logger_impl.h
View file @ 2e973c8b
......@@ -17,38 +17,38 @@
#include <memory>
template<class It>
inline spdlog::async_logger::async_logger(const std::string& logger_name,
inline spdlog::async_logger::async_logger(const std::string& name,
const It& begin,
const It& end,
size_t queue_size,
const async_overflow_policy overflow_policy,
const async_overflow_policy overflow_policy,
const std::function<void()>& worker_warmup_cb,
const std::chrono::milliseconds& flush_interval_ms,
const std::function<void()>& worker_teardown_cb) :
logger(logger_name, begin, end),
logger(name, begin, end),
_async_log_helper(new details::async_log_helper(_formatter, _sinks, queue_size, _err_handler, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb))
{
}
inline spdlog::async_logger::async_logger(const std::string& logger_name,
sinks_init_list sinks_list,
inline spdlog::async_logger::async_logger(const std::string& name,
sinks_init_list sinks,
size_t queue_size,
const async_overflow_policy overflow_policy,
const async_overflow_policy overflow_policy,
const std::function<void()>& worker_warmup_cb,
const std::chrono::milliseconds& flush_interval_ms,
const std::function<void()>& worker_teardown_cb) :
async_logger(logger_name, sinks_list.begin(), sinks_list.end(), queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb) {}
async_logger(name, sinks.begin(), sinks.end(), queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb) {}
inline spdlog::async_logger::async_logger(const std::string& logger_name,
inline spdlog::async_logger::async_logger(const std::string& name,
sink_ptr single_sink,
size_t queue_size,
const async_overflow_policy overflow_policy,
const async_overflow_policy overflow_policy,
const std::function<void()>& worker_warmup_cb,
const std::chrono::milliseconds& flush_interval_ms,
const std::function<void()>& worker_teardown_cb) :
async_logger(logger_name,
async_logger(name,
{
single_sink
std::move(single_sink)
}, queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb) {}
......
include/spdlog/details/file_helper.h
View file @ 2e973c8b
......@@ -31,9 +31,7 @@ public:
const int open_tries = 5;
const int open_interval = 10;
explicit file_helper() :
_fd(nullptr)
{}
explicit file_helper() = default;
file_helper(const file_helper&) = delete;
file_helper& operator=(const file_helper&) = delete;
......@@ -46,7 +44,6 @@ public:
void open(const filename_t& fname, bool truncate = false)
{
close();
auto *mode = truncate ? SPDLOG_FILENAME_T("wb") : SPDLOG_FILENAME_T("ab");
_filename = fname;
......@@ -76,7 +73,7 @@ public:
void close()
{
if (_fd)
if (_fd != nullptr)
{
std::fclose(_fd);
_fd = nullptr;
......@@ -93,8 +90,10 @@ public:
size_t size() const
{
if (!_fd)
if (_fd == nullptr)
{
throw spdlog_ex("Cannot use size() on closed file " + os::filename_to_str(_filename));
}
return os::filesize(_fd);
}
......@@ -137,8 +136,9 @@ public:
// finally - return a valid base and extension tuple
return std::make_tuple(fname.substr(0, ext_index), fname.substr(ext_index));
}
private:
FILE* _fd;
FILE* _fd{ nullptr };
filename_t _filename;
};
}
......
include/spdlog/details/log_msg.h
View file @ 2e973c8b
......@@ -8,7 +8,6 @@
#include "../common.h"
#include "../details/os.h"
#include <string>
#include <utility>
......@@ -21,8 +20,7 @@ struct log_msg
log_msg() = default;
log_msg(const std::string *loggers_name, level::level_enum lvl) :
logger_name(loggers_name),
level(lvl),
msg_id(0)
level(lvl)
{
#ifndef SPDLOG_NO_DATETIME
time = os::now();
......@@ -33,18 +31,18 @@ struct log_msg
#endif
}
log_msg(const log_msg& other) = delete;
log_msg(const log_msg& other) = delete;
log_msg& operator=(log_msg&& other) = delete;
log_msg(log_msg&& other) = delete;
const std::string *logger_name;
const std::string *logger_name{ nullptr };
level::level_enum level;
log_clock::time_point time;
size_t thread_id;
fmt::MemoryWriter raw;
fmt::MemoryWriter formatted;
size_t msg_id;
size_t msg_id{ 0 };
};
}
}
include/spdlog/details/logger_impl.h
View file @ 2e973c8b
......@@ -14,14 +14,14 @@
// create logger with given name, sinks and the default pattern formatter
// all other ctors will call this one
template<class It>
inline spdlog::logger::logger(const std::string& logger_name, const It& begin, const It& end):
_name(logger_name),
inline spdlog::logger::logger(std::string name, const It& begin, const It& end):
_name(std::move(name)),
_sinks(begin, end),
_formatter(std::make_shared<pattern_formatter>("%+")),
_level(level::info),
_flush_level(level::off),
_last_err_time(0),
_msg_counter(1) // message counter will start from 1. 0-message id will be reserved for controll messages
_msg_counter(1) // message counter will start from 1. 0-message id will be reserved for controll messages
{
_err_handler = [this](const std::string &msg)
{
......@@ -30,16 +30,16 @@ inline spdlog::logger::logger(const std::string& logger_name, const It& begin, c
}
// ctor with sinks as init list
inline spdlog::logger::logger(const std::string& logger_name, sinks_init_list sinks_list):
logger(logger_name, sinks_list.begin(), sinks_list.end())
inline spdlog::logger::logger(const std::string& name, sinks_init_list sinks):
logger(name, sinks.begin(), sinks.end())
{}
// ctor with single sink
inline spdlog::logger::logger(const std::string& logger_name, spdlog::sink_ptr single_sink):
logger(logger_name,
inline spdlog::logger::logger(const std::string& name, spdlog::sink_ptr single_sink):
logger(name,
{
single_sink
std::move(single_sink)
})
{}
......@@ -49,7 +49,7 @@ inline spdlog::logger::~logger() = default;
inline void spdlog::logger::set_formatter(spdlog::formatter_ptr msg_formatter)
{
_set_formatter(msg_formatter);
_set_formatter(std::move(msg_formatter));
}
inline void spdlog::logger::set_pattern(const std::string& pattern, pattern_time_type pattern_time)
......@@ -281,7 +281,7 @@ inline void spdlog::logger::set_level(spdlog::level::level_enum log_level)
inline void spdlog::logger::set_error_handler(spdlog::log_err_handler err_handler)
{
_err_handler = err_handler;
_err_handler = std::move(err_handler);
}
inline spdlog::log_err_handler spdlog::logger::error_handler()
......@@ -289,7 +289,6 @@ inline spdlog::log_err_handler spdlog::logger::error_handler()
return _err_handler;
}
inline void spdlog::logger::flush_on(level::level_enum log_level)
{
_flush_level.store(log_level);
......@@ -330,9 +329,10 @@ inline void spdlog::logger::_set_pattern(const std::string& pattern, pattern_tim
{
_formatter = std::make_shared<pattern_formatter>(pattern, pattern_time);
}
inline void spdlog::logger::_set_formatter(formatter_ptr msg_formatter)
{
_formatter = msg_formatter;
_formatter = std::move(msg_formatter);
}
inline void spdlog::logger::flush()
......@@ -349,7 +349,7 @@ inline void spdlog::logger::_default_err_handler(const std::string &msg)
auto tm_time = details::os::localtime(now);
char date_buf[100];
std::strftime(date_buf, sizeof(date_buf), "%Y-%m-%d %H:%M:%S", &tm_time);
details::log_msg err_msg;
details::log_msg err_msg;
err_msg.formatted.write("[*** LOG ERROR ***] [{}] [{}] [{}]{}", name(), msg, date_buf, details::os::default_eol);
sinks::stderr_sink_mt::instance()->log(err_msg);
_last_err_time = now;
......
include/spdlog/details/mpmc_bounded_q.h
View file @ 2e973c8b
......@@ -53,13 +53,13 @@ namespace spdlog
namespace details
{
template<typename T>
template <typename T>
class mpmc_bounded_queue
{
public:
using item_type = T;
mpmc_bounded_queue(size_t buffer_size)
explicit mpmc_bounded_queue(size_t buffer_size)
:max_size_(buffer_size),
buffer_(new cell_t[buffer_size]),
buffer_mask_(buffer_size - 1)
......@@ -79,6 +79,8 @@ public:
delete[] buffer_;
}
mpmc_bounded_queue(mpmc_bounded_queue const&) = delete;
void operator=(mpmc_bounded_queue const&) = delete;
bool enqueue(T&& data)
{
......@@ -157,7 +159,7 @@ private:
size_t const max_size_;
static size_t const cacheline_size = 64;
typedef char cacheline_pad_t[cacheline_size];
using cacheline_pad_t = char[cacheline_size];
cacheline_pad_t pad0_;
cell_t* const buffer_;
......@@ -167,9 +169,6 @@ private:
cacheline_pad_t pad2_;
std::atomic<size_t> dequeue_pos_;
cacheline_pad_t pad3_;
mpmc_bounded_queue(mpmc_bounded_queue const&) = delete;
void operator= (mpmc_bounded_queue const&) = delete;
};
} // ns details
......
include/spdlog/details/null_mutex.h
View file @ 2e973c8b
......@@ -27,7 +27,7 @@ struct null_atomic_int
int value;
null_atomic_int() = default;
null_atomic_int(int val):value(val)
explicit null_atomic_int(int val) : value(val)
{}
int load(std::memory_order) const
......
include/spdlog/details/os.h
View file @ 2e973c8b
......@@ -81,10 +81,10 @@ inline std::tm localtime(const std::time_t &time_tt)
{
#ifdef _WIN32
std::tm tm;
std::tm tm {};
localtime_s(&tm, &time_tt);
#else
std::tm tm;
std::tm tm {};
localtime_r(&time_tt, &tm);
#endif
return tm;
......@@ -96,15 +96,14 @@ inline std::tm localtime()
return localtime(now_t);
}
inline std::tm gmtime(const std::time_t &time_tt)
{
#ifdef _WIN32
std::tm tm;
std::tm tm {};
gmtime_s(&tm, &time_tt);
#else
std::tm tm;
std::tm tm {};
gmtime_r(&time_tt, &tm);
#endif
return tm;
......@@ -170,7 +169,7 @@ inline void prevent_child_fd(FILE *f)
//fopen_s on non windows for writing
inline int fopen_s(FILE** fp, const filename_t& filename, const filename_t& mode)
inline bool fopen_s(FILE** fp, const filename_t& filename, const filename_t& mode)
{
#ifdef _WIN32
#ifdef SPDLOG_WCHAR_FILENAMES
......@@ -220,7 +219,7 @@ inline bool file_exists(const filename_t& filename)
#endif
return (attribs != INVALID_FILE_ATTRIBUTES && !(attribs & FILE_ATTRIBUTE_DIRECTORY));
#else //common linux/unix all have the stat system call
struct stat buffer;
struct stat buffer {};
return (stat(filename.c_str(), &buffer) == 0);
#endif
}
......@@ -250,11 +249,11 @@ inline size_t filesize(FILE *f)
int fd = fileno(f);
//64 bits(but not in osx or cygwin, where fstat64 is deprecated)
#if !defined(__FreeBSD__) && !defined(__APPLE__) && (defined(__x86_64__) || defined(__ppc64__)) && !defined(__CYGWIN__)
struct stat64 st;
struct stat64 st {};
if (fstat64(fd, &st) == 0)
return static_cast<size_t>(st.st_size);
#else // unix 32 bits or cygwin
struct stat st;
struct stat st {};
if (fstat(fd, &st) == 0)
return static_cast<size_t>(st.st_size);
#endif
......@@ -318,9 +317,9 @@ inline int utc_minutes_offset(const std::tm& tm = details::os::localtime())
}
};
long int offset_seconds = helper::calculate_gmt_offset(tm);
auto offset_seconds = helper::calculate_gmt_offset(tm);
#else
long int offset_seconds = tm.tm_gmtoff;
auto offset_seconds = tm.tm_gmtoff;
#endif
return static_cast<int>(offset_seconds / 60);
......@@ -332,12 +331,12 @@ inline int utc_minutes_offset(const std::tm& tm = details::os::localtime())
inline size_t _thread_id()
{
#ifdef _WIN32
return static_cast<size_t>(::GetCurrentThreadId());
return static_cast<size_t>(::GetCurrentThreadId());
#elif __linux__
# if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21)
# define SYS_gettid __NR_gettid
# endif
return static_cast<size_t>(syscall(SYS_gettid));
return static_cast<size_t>(syscall(SYS_gettid));
#elif __FreeBSD__
long tid;
thr_self(&tid);
......@@ -403,10 +402,7 @@ inline std::string errno_to_string(char buf[256], int res)
{
return std::string(buf);
}
else
{
return "Unknown error";
}
return "Unknown error";
}
// Return errno string (thread safe)
......@@ -482,9 +478,9 @@ inline bool in_terminal(FILE* file)
{
#ifdef _WIN32
return _isatty(_fileno(file)) ? true : false;
return _isatty(_fileno(file)) != 0;
#else
return isatty(fileno(file)) ? true : false;
return isatty(fileno(file)) != 0;
#endif
}
} //os
......
include/spdlog/details/registry.h
View file @ 2e973c8b
......@@ -26,9 +26,12 @@ namespace spdlog
{
namespace details
{
template <class Mutex> class registry_t
template <class Mutex>
class registry_t
{
public:
registry_t<Mutex>(const registry_t<Mutex>&) = delete;
registry_t<Mutex>& operator=(const registry_t<Mutex>&) = delete;
void register_logger(std::shared_ptr<logger> logger)
{
......@@ -38,7 +41,6 @@ public:
_loggers[logger_name] = logger;
}
std::shared_ptr<logger> get(const std::string& logger_name)
{
std::lock_guard<Mutex> lock(_mutex);
......@@ -111,6 +113,7 @@ public:
std::lock_guard<Mutex> lock(_mutex);
_loggers.clear();
}
std::shared_ptr<logger> create(const std::string& logger_name, sinks_init_list sinks)
{
return create(logger_name, sinks.begin(), sinks.end());
......@@ -194,15 +197,14 @@ public:
}
private:
registry_t<Mutex>() {}
registry_t<Mutex>(const registry_t<Mutex>&) = delete;
registry_t<Mutex>& operator=(const registry_t<Mutex>&) = delete;
registry_t<Mutex>() = default;
void throw_if_exists(const std::string &logger_name)
{
if (_loggers.find(logger_name) != _loggers.end())
throw spdlog_ex("logger with name '" + logger_name + "' already exists");
}
Mutex _mutex;
std::unordered_map <std::string, std::shared_ptr<logger>> _loggers;
formatter_ptr _formatter;
......@@ -212,14 +214,16 @@ private:
bool _async_mode = false;
size_t _async_q_size = 0;
async_overflow_policy _overflow_policy = async_overflow_policy::block_retry;
std::function<void()> _worker_warmup_cb = nullptr;
std::function<void()> _worker_warmup_cb;
std::chrono::milliseconds _flush_interval_ms;
std::function<void()> _worker_teardown_cb = nullptr;
std::function<void()> _worker_teardown_cb;
};
#ifdef SPDLOG_NO_REGISTRY_MUTEX
typedef registry_t<spdlog::details::null_mutex> registry;
using registry = registry_t<spdlog::details::null_mutex>;
#else
typedef registry_t<std::mutex> registry;
using registry = registry_t<std::mutex>;
#endif
}
}
include/spdlog/details/spdlog_impl.h
View file @ 2e973c8b
......@@ -34,7 +34,7 @@
inline void spdlog::register_logger(std::shared_ptr<logger> logger)
{
return details::registry::instance().register_logger(logger);
return details::registry::instance().register_logger(std::move(logger));
}
inline std::shared_ptr<spdlog::logger> spdlog::get(const std::string& name)
......@@ -183,13 +183,11 @@ inline std::shared_ptr<spdlog::logger> spdlog::create(const std::string& logger_
}
//Create logger with multiple sinks
inline std::shared_ptr<spdlog::logger> spdlog::create(const std::string& logger_name, spdlog::sinks_init_list sinks)
{
return details::registry::instance().create(logger_name, sinks);
}
template <typename Sink, typename... Args>
inline std::shared_ptr<spdlog::logger> spdlog::create(const std::string& logger_name, Args... args)
{
......@@ -197,7 +195,6 @@ inline std::shared_ptr<spdlog::logger> spdlog::create(const std::string& logger_
return details::registry::instance().create(logger_name, { sink });
}
template<class It>
inline std::shared_ptr<spdlog::logger> spdlog::create(const std::string& logger_name, const It& sinks_begin, const It& sinks_end)
{
......@@ -224,7 +221,7 @@ inline std::shared_ptr<spdlog::logger> spdlog::create_async(const std::string& l
inline void spdlog::set_formatter(spdlog::formatter_ptr f)
{
details::registry::instance().formatter(f);
details::registry::instance().formatter(std::move(f));
}
inline void spdlog::set_pattern(const std::string& format_string)
......@@ -244,10 +241,9 @@ inline void spdlog::flush_on(level::level_enum log_level)
inline void spdlog::set_error_handler(log_err_handler handler)
{
return details::registry::instance().set_error_handler(handler);
return details::registry::instance().set_error_handler(std::move(handler));
}
inline void spdlog::set_async_mode(size_t queue_size, const async_overflow_policy overflow_policy, const std::function<void()>& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms, const std::function<void()>& worker_teardown_cb)
{
details::registry::instance().set_async_mode(queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb);
......@@ -260,7 +256,7 @@ inline void spdlog::set_sync_mode()
inline void spdlog::apply_all(std::function<void(std::shared_ptr<logger>)> fun)
{
details::registry::instance().apply_all(fun);
details::registry::instance().apply_all(std::move(fun));
}
inline void spdlog::drop_all()
......
include/spdlog/formatter.h
View file @ 2e973c8b
......@@ -21,18 +21,18 @@ class flag_formatter;
class formatter
{
public:
virtual ~formatter() {}
virtual ~formatter() = default;
virtual void format(details::log_msg& msg) = 0;
};
class pattern_formatter SPDLOG_FINAL : public formatter
{
public:
explicit pattern_formatter(const std::string& pattern, pattern_time_type pattern_time = pattern_time_type::local, const std::string& eol = spdlog::details::os::default_eol);
explicit pattern_formatter(const std::string& pattern, pattern_time_type pattern_time = pattern_time_type::local, std::string eol = spdlog::details::os::default_eol);
pattern_formatter(const pattern_formatter&) = delete;
pattern_formatter& operator=(const pattern_formatter&) = delete;
void format(details::log_msg& msg) override;
private:
const std::string _eol;
const std::string _pattern;
......@@ -45,4 +45,3 @@ private:
}
#include "details/pattern_formatter_impl.h"
include/spdlog/logger.h
View file @ 2e973c8b
......@@ -25,16 +25,17 @@ namespace spdlog
class logger
{
public:
logger(const std::string& logger_name, sink_ptr single_sink);
logger(const std::string& name, sinks_init_list);
template<class It>
logger(const std::string& name, const It& begin, const It& end);
logger(const std::string& name, sink_ptr single_sink);
logger(const std::string& name, sinks_init_list sinks);
template <class It>
logger(std::string name, const It& begin, const It& end);
virtual ~logger();
logger(const logger&) = delete;
logger& operator=(const logger&) = delete;
template <typename... Args> void log(level::level_enum lvl, const char* fmt, const Args&... args);
template <typename... Args> void log(level::level_enum lvl, const char* msg);
template <typename Arg1, typename... Args> void trace(const char* fmt, const Arg1&, const Args&... args);
......@@ -44,7 +45,6 @@ public:
template <typename Arg1, typename... Args> void error(const char* fmt, const Arg1&, const Args&... args);
template <typename Arg1, typename... Args> void critical(const char* fmt, const Arg1&, const Args&... args);
#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
template <typename... Args> void log(level::level_enum lvl, const wchar_t* msg);
template <typename... Args> void log(level::level_enum lvl, const wchar_t* fmt, const Args&... args);
......@@ -57,19 +57,19 @@ public:
#endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT
template <typename T> void log(level::level_enum lvl, const T&);
template <typename T> void trace(const T&);
template <typename T> void debug(const T&);
template <typename T> void info(const T&);
template <typename T> void warn(const T&);
template <typename T> void error(const T&);
template <typename T> void critical(const T&);
bool should_log(level::level_enum) const;
void set_level(level::level_enum);
template <typename T> void trace(const T& msg);
template <typename T> void debug(const T& msg);
template <typename T> void info(const T& msg);
template <typename T> void warn(const T& msg);
template <typename T> void error(const T& msg);
template <typename T> void critical(const T& msg);
bool should_log(level::level_enum msg_level) const;
void set_level(level::level_enum log_level);
level::level_enum level() const;
const std::string& name() const;
void set_pattern(const std::string&, pattern_time_type = pattern_time_type::local);
void set_formatter(formatter_ptr);
void set_pattern(const std::string& pattern, pattern_time_type pattern_time = pattern_time_type::local);
void set_formatter(formatter_ptr msg_formatter);
// automatically call flush() if message level >= log_level
void flush_on(level::level_enum log_level);
......@@ -79,22 +79,22 @@ public:
const std::vector<sink_ptr>& sinks() const;
// error handler
virtual void set_error_handler(log_err_handler);
virtual void set_error_handler(log_err_handler err_handler);
virtual log_err_handler error_handler();
protected:
virtual void _sink_it(details::log_msg&);
virtual void _set_pattern(const std::string&, pattern_time_type);
virtual void _set_formatter(formatter_ptr);
virtual void _sink_it(details::log_msg& msg);
virtual void _set_pattern(const std::string& pattern, pattern_time_type pattern_time);
virtual void _set_formatter(formatter_ptr msg_formatter);
// default error handler: print the error to stderr with the max rate of 1 message/minute
virtual void _default_err_handler(const std::string &msg);
// return true if the given message level should trigger a flush
bool _should_flush_on(const details::log_msg&);
bool _should_flush_on(const details::log_msg& msg);
// increment the message count (only if defined(SPDLOG_ENABLE_MESSAGE_COUNTER))
void _incr_msg_counter(details::log_msg &msg);
void _incr_msg_counter(details::log_msg& msg);
const std::string _name;
std::vector<sink_ptr> _sinks;
......
include/spdlog/sinks/ansicolor_sink.h
View file @ 2e973c8b
......@@ -23,10 +23,10 @@ namespace sinks
* If no color terminal detected, omit the escape codes.
*/
template <class Mutex>
class ansicolor_sink: public base_sink<Mutex>
class ansicolor_sink : public base_sink<Mutex>
{
public:
ansicolor_sink(FILE* file): target_file_(file)
explicit ansicolor_sink(FILE* file) : target_file_(file)
{
should_do_colors_ = details::os::in_terminal(file) && details::os::is_color_terminal();
colors_[level::trace] = cyan;
......@@ -37,7 +37,8 @@ public:
colors_[level::critical] = bold + on_red;
colors_[level::off] = reset;
}
virtual ~ansicolor_sink()
~ansicolor_sink() override
{
_flush();
}
......@@ -79,7 +80,7 @@ public:
const std::string on_white = "\033[47m";
protected:
virtual void _sink_it(const details::log_msg& msg) override
void _sink_it(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.
......@@ -102,6 +103,7 @@ protected:
{
fflush(target_file_);
}
FILE* target_file_;
bool should_do_colors_;
std::unordered_map<level::level_enum, std::string, level::level_hasher> colors_;
......@@ -116,6 +118,9 @@ public:
{}
};
using ansicolor_stdout_sink_mt = ansicolor_stdout_sink<std::mutex>;
using ansicolor_stdout_sink_st = ansicolor_stdout_sink<details::null_mutex>;
template<class Mutex>
class ansicolor_stderr_sink: public ansicolor_sink<Mutex>
{
......@@ -124,11 +129,8 @@ public:
{}
};
typedef ansicolor_stdout_sink<std::mutex> ansicolor_stdout_sink_mt;
typedef ansicolor_stdout_sink<details::null_mutex> ansicolor_stdout_sink_st;
typedef ansicolor_stderr_sink<std::mutex> ansicolor_stderr_sink_mt;
typedef ansicolor_stderr_sink<details::null_mutex> ansicolor_stderr_sink_st;
using ansicolor_stderr_sink_mt = ansicolor_stderr_sink<std::mutex>;
using ansicolor_stderr_sink_st = ansicolor_stderr_sink<details::null_mutex>;
} // namespace sinks
} // namespace spdlog
......
include/spdlog/sinks/base_sink.h
View file @ 2e973c8b
......@@ -22,11 +22,10 @@ namespace spdlog
namespace sinks
{
template<class Mutex>
class base_sink:public sink
class base_sink : public sink
{
public:
base_sink():_mutex() {}
virtual ~base_sink() = default;
base_sink() = default;
base_sink(const base_sink&) = delete;
base_sink& operator=(const base_sink&) = delete;
......@@ -36,6 +35,7 @@ public:
std::lock_guard<Mutex> lock(_mutex);
_sink_it(msg);
}
void flush() SPDLOG_FINAL override
{
std::lock_guard<Mutex> lock(_mutex);
......
include/spdlog/sinks/dist_sink.h
View file @ 2e973c8b
......@@ -22,13 +22,12 @@ namespace spdlog
namespace sinks
{
template<class Mutex>
class dist_sink: public base_sink<Mutex>
class dist_sink : public base_sink<Mutex>
{
public:
explicit dist_sink() :_sinks() {}
dist_sink(const dist_sink&) = delete;
dist_sink& operator=(const dist_sink&) = delete;
virtual ~dist_sink() = default;
protected:
std::vector<std::shared_ptr<sink>> _sinks;
......@@ -51,8 +50,6 @@ protected:
}
public:
void add_sink(std::shared_ptr<sink> sink)
{
std::lock_guard<Mutex> lock(base_sink<Mutex>::_mutex);
......@@ -66,7 +63,8 @@ public:
}
};
typedef dist_sink<std::mutex> dist_sink_mt;
typedef dist_sink<details::null_mutex> dist_sink_st;
using dist_sink_mt = dist_sink<std::mutex>;
using dist_sink_st = dist_sink<details::null_mutex>;
}
}
include/spdlog/sinks/file_sinks.h
View file @ 2e973c8b
......@@ -25,8 +25,8 @@ namespace sinks
/*
* Trivial file sink with single file as target
*/
template<class Mutex>
class simple_file_sink SPDLOG_FINAL : public base_sink < Mutex >
template <class Mutex>
class simple_file_sink SPDLOG_FINAL : public base_sink<Mutex>
{
public:
explicit simple_file_sink(const filename_t &filename, bool truncate = false):_force_flush(false)
......@@ -46,32 +46,32 @@ protected:
if(_force_flush)
_file_helper.flush();
}
void _flush() override
{
_file_helper.flush();
}
private:
details::file_helper _file_helper;
bool _force_flush;
};
typedef simple_file_sink<std::mutex> simple_file_sink_mt;
typedef simple_file_sink<details::null_mutex> simple_file_sink_st;
using simple_file_sink_mt = simple_file_sink<std::mutex>;
using simple_file_sink_st = simple_file_sink<details::null_mutex>;
/*
* Rotating file sink based on size
*/
template<class Mutex>
class rotating_file_sink SPDLOG_FINAL : public base_sink < Mutex >
template <class Mutex>
class rotating_file_sink SPDLOG_FINAL : public base_sink<Mutex>
{
public:
rotating_file_sink(const filename_t &base_filename,
rotating_file_sink(filename_t base_filename,
std::size_t max_size, std::size_t max_files) :
_base_filename(base_filename),
_base_filename(std::move(base_filename)),
_max_size(max_size),
_max_files(max_files),
_current_size(0),
_file_helper()
_max_files(max_files)
{
_file_helper.open(calc_filename(_base_filename, 0));
_current_size = _file_helper.size(); //expensive. called only once
......@@ -82,7 +82,7 @@ public:
static filename_t calc_filename(const filename_t& filename, std::size_t index)
{
typename std::conditional<std::is_same<filename_t::value_type, char>::value, fmt::MemoryWriter, fmt::WMemoryWriter>::type w;
if (index)
if (index != 0u)
{
filename_t basename, ext;
std::tie(basename, ext) = details::file_helper::split_by_extenstion(filename);
......@@ -112,7 +112,6 @@ protected:
_file_helper.flush();
}
private:
// Rotate files:
// log.txt -> log.1.txt
......@@ -135,13 +134,14 @@ private:
throw spdlog_ex("rotating_file_sink: failed removing " + filename_to_str(target), errno);
}
}
if (details::file_helper::file_exists(src) && details::os::rename(src, target))
if (details::file_helper::file_exists(src) && details::os::rename(src, target) != 0)
{
throw spdlog_ex("rotating_file_sink: failed renaming " + filename_to_str(src) + " to " + filename_to_str(target), errno);
}
}
_file_helper.reopen(true);
}
filename_t _base_filename;
std::size_t _max_size;
std::size_t _max_files;
......@@ -149,8 +149,8 @@ private:
details::file_helper _file_helper;
};
typedef rotating_file_sink<std::mutex> rotating_file_sink_mt;
typedef rotating_file_sink<details::null_mutex>rotating_file_sink_st;
using rotating_file_sink_mt = rotating_file_sink<std::mutex>;
using rotating_file_sink_st = rotating_file_sink<details::null_mutex>;
/*
* Default generator of daily log file names.
......@@ -195,9 +195,10 @@ class daily_file_sink SPDLOG_FINAL :public base_sink < Mutex >
public:
//create daily file sink which rotates on given time
daily_file_sink(
const filename_t& base_filename,
filename_t base_filename,
int rotation_hour,
int rotation_minute) : _base_filename(base_filename),
int rotation_minute) :
_base_filename(std::move(base_filename)),
_rotation_h(rotation_hour),
_rotation_m(rotation_minute)
{
......@@ -235,9 +236,10 @@ private:
date.tm_sec = 0;
auto rotation_time = std::chrono::system_clock::from_time_t(std::mktime(&date));
if (rotation_time > now)
{
return rotation_time;
else
return std::chrono::system_clock::time_point(rotation_time + std::chrono::hours(24));
}
return{ rotation_time + std::chrono::hours(24) };
}
filename_t _base_filename;
......@@ -247,7 +249,8 @@ private:
details::file_helper _file_helper;
};
typedef daily_file_sink<std::mutex> daily_file_sink_mt;
typedef daily_file_sink<details::null_mutex> daily_file_sink_st;
using daily_file_sink_mt = daily_file_sink<std::mutex>;
using daily_file_sink_st = daily_file_sink<details::null_mutex>;
}
}
include/spdlog/sinks/msvc_sink.h
View file @ 2e973c8b
......@@ -23,15 +23,13 @@ namespace sinks
* MSVC sink (logging using OutputDebugStringA)
*/
template<class Mutex>
class msvc_sink : public base_sink < Mutex >
class msvc_sink : public base_sink<Mutex>
{
public:
explicit msvc_sink()
{
}
protected:
void _sink_it(const details::log_msg& msg) override
{
......@@ -42,8 +40,8 @@ protected:
{}
};
typedef msvc_sink<std::mutex> msvc_sink_mt;
typedef msvc_sink<details::null_mutex> msvc_sink_st;
using msvc_sink_mt = msvc_sink<std::mutex>;
using msvc_sink_st = msvc_sink<details::null_mutex>;
}
}
......
include/spdlog/sinks/null_sink.h
View file @ 2e973c8b
......@@ -16,7 +16,7 @@ namespace sinks
{
template <class Mutex>
class null_sink : public base_sink < Mutex >
class null_sink : public base_sink<Mutex>
{
protected:
void _sink_it(const details::log_msg&) override
......@@ -26,8 +26,9 @@ protected:
{}
};
typedef null_sink<details::null_mutex> null_sink_st;
typedef null_sink<details::null_mutex> null_sink_mt;
using null_sink_mt = null_sink<details::null_mutex>;
using null_sink_st = null_sink<details::null_mutex>;
}
}
......
include/spdlog/sinks/ostream_sink.h
View file @ 2e973c8b
......@@ -16,13 +16,12 @@ namespace spdlog
namespace sinks
{
template<class Mutex>
class ostream_sink: public base_sink<Mutex>
class ostream_sink : public base_sink<Mutex>
{
public:
explicit ostream_sink(std::ostream& os, bool force_flush=false) :_ostream(os), _force_flush(force_flush) {}
ostream_sink(const ostream_sink&) = delete;
ostream_sink& operator=(const ostream_sink&) = delete;
virtual ~ostream_sink() = default;
protected:
void _sink_it(const details::log_msg& msg) override
......@@ -41,7 +40,8 @@ protected:
bool _force_flush;
};
typedef ostream_sink<std::mutex> ostream_sink_mt;
typedef ostream_sink<details::null_mutex> ostream_sink_st;
using ostream_sink_mt = ostream_sink<std::mutex>;
using ostream_sink_st = ostream_sink<details::null_mutex>;
}
}
include/spdlog/sinks/sink.h
View file @ 2e973c8b
......@@ -3,7 +3,6 @@
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
//
#pragma once
#include "../details/log_msg.h"
......@@ -15,12 +14,8 @@ namespace sinks
class sink
{
public:
sink()
{
_level = level::trace;
}
virtual ~sink() = default;
virtual ~sink() {}
virtual void log(const details::log_msg& msg) = 0;
virtual void flush() = 0;
......@@ -29,8 +24,7 @@ public:
level::level_enum level() const;
private:
level_t _level;
level_t _level{ level::trace };
};
inline bool sink::should_log(level::level_enum msg_level) const
......@@ -50,4 +44,3 @@ inline level::level_enum sink::level() const
}
}
include/spdlog/sinks/stdout_sinks.h
View file @ 2e973c8b
......@@ -21,14 +21,16 @@ template <class Mutex>
class stdout_sink SPDLOG_FINAL : public base_sink<Mutex>
{
using MyType = stdout_sink<Mutex>;
public:
stdout_sink()
{}
explicit stdout_sink() = default;
static std::shared_ptr<MyType> instance()
{
static std::shared_ptr<MyType> instance = std::make_shared<MyType>();
return instance;
}
protected:
void _sink_it(const details::log_msg& msg) override
{
......@@ -42,22 +44,23 @@ protected:
}
};
typedef stdout_sink<details::null_mutex> stdout_sink_st;
typedef stdout_sink<std::mutex> stdout_sink_mt;
using stdout_sink_mt = stdout_sink<std::mutex>;
using stdout_sink_st = stdout_sink<details::null_mutex>;
template <class Mutex>
class stderr_sink SPDLOG_FINAL : public base_sink<Mutex>
{
using MyType = stderr_sink<Mutex>;
public:
stderr_sink()
{}
explicit stderr_sink() = default;
static std::shared_ptr<MyType> instance()
{
static std::shared_ptr<MyType> instance = std::make_shared<MyType>();
return instance;
}
protected:
void _sink_it(const details::log_msg& msg) override
{
......@@ -71,7 +74,8 @@ protected:
}
};
typedef stderr_sink<std::mutex> stderr_sink_mt;
typedef stderr_sink<details::null_mutex> stderr_sink_st;
using stderr_sink_mt = stderr_sink<std::mutex>;
using stderr_sink_st = stderr_sink<details::null_mutex>;
}
}
include/spdlog/sinks/syslog_sink.h
View file @ 2e973c8b
......@@ -44,7 +44,8 @@ public:
//set ident to be program name if empty
::openlog(_ident.empty()? nullptr:_ident.c_str(), syslog_option, syslog_facility);
}
~syslog_sink()
~syslog_sink() override
{
::closelog();
}
......
include/spdlog/sinks/wincolor_sink.h
View file @ 2e973c8b
......@@ -21,8 +21,8 @@ namespace sinks
/*
* Windows color console sink. Uses WriteConsoleA to write to the console with colors
*/
template<class Mutex>
class wincolor_sink: public base_sink<Mutex>
template <class Mutex>
class wincolor_sink : public base_sink<Mutex>
{
public:
const WORD BOLD = FOREGROUND_INTENSITY;
......@@ -42,7 +42,7 @@ public:
colors_[level::off] = 0;
}
virtual ~wincolor_sink()
~wincolor_sink() override
{
this->flush();
}
......@@ -50,7 +50,7 @@ public:
wincolor_sink(const wincolor_sink& other) = delete;
wincolor_sink& operator=(const wincolor_sink& other) = delete;
// change the color for the given level
// change the color for the given level
void set_color(level::level_enum level, WORD color)
{
std::lock_guard<Mutex> lock(base_sink<Mutex>::_mutex);
......@@ -58,7 +58,7 @@ public:
}
protected:
virtual void _sink_it(const details::log_msg& msg) override
void _sink_it(const details::log_msg& msg) override
{
auto color = colors_[msg.level];
auto orig_attribs = set_console_attribs(color);
......@@ -66,7 +66,7 @@ protected:
SetConsoleTextAttribute(out_handle_, orig_attribs); //reset to orig colors
}
virtual void _flush() override
void _flush() override
{
// windows console always flushed?
}
......@@ -85,37 +85,37 @@ private:
back_color &= static_cast<WORD>(~(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY));
// keep the background color unchanged
SetConsoleTextAttribute(out_handle_, attribs | back_color);
return orig_buffer_info.wAttributes; //return orig attribs
return orig_buffer_info.wAttributes; //return orig attribs
}
};
//
// windows color console to stdout
//
template<class Mutex>
class wincolor_stdout_sink: public wincolor_sink<Mutex>
template <class Mutex>
class wincolor_stdout_sink : public wincolor_sink<Mutex>
{
public:
wincolor_stdout_sink() : wincolor_sink<Mutex>(GetStdHandle(STD_OUTPUT_HANDLE))
{}
};
typedef wincolor_stdout_sink<std::mutex> wincolor_stdout_sink_mt;
typedef wincolor_stdout_sink<details::null_mutex> wincolor_stdout_sink_st;
using wincolor_stdout_sink_mt = wincolor_stdout_sink<std::mutex>;
using wincolor_stdout_sink_st = wincolor_stdout_sink<details::null_mutex>;
//
// windows color console to stderr
//
template<class Mutex>
class wincolor_stderr_sink: public wincolor_sink<Mutex>
template <class Mutex>
class wincolor_stderr_sink : public wincolor_sink<Mutex>
{
public:
wincolor_stderr_sink() : wincolor_sink<Mutex>(GetStdHandle(STD_ERROR_HANDLE))
{}
};
typedef wincolor_stderr_sink<std::mutex> wincolor_stderr_sink_mt;
typedef wincolor_stderr_sink<details::null_mutex> wincolor_stderr_sink_st;
using wincolor_stderr_sink_mt = wincolor_stderr_sink<std::mutex>;
using wincolor_stderr_sink_st = wincolor_stderr_sink<details::null_mutex>;
}
}
include/spdlog/sinks/windebug_sink.h
View file @ 2e973c8b
......@@ -17,11 +17,11 @@ namespace sinks
/*
* Windows debug sink (logging using OutputDebugStringA, synonym for msvc_sink)
*/
template<class Mutex>
template <class Mutex>
using windebug_sink = msvc_sink<Mutex>;
typedef msvc_sink_mt windebug_sink_mt;
typedef msvc_sink_st windebug_sink_st;
using windebug_sink_mt = msvc_sink_mt;
using windebug_sink_st = msvc_sink_st;
}
}
......
include/spdlog/spdlog.h
View file @ 2e973c8b
......@@ -46,7 +46,7 @@ void flush_on(level::level_enum log_level);
//
// Set global error handler
//
void set_error_handler(log_err_handler);
void set_error_handler(log_err_handler handler);
//
// Turn on async mode (off by default) and set the queue size for each async_logger.
......@@ -56,7 +56,7 @@ void set_error_handler(log_err_handler);
//
// async_overflow_policy (optional, block_retry by default):
// async_overflow_policy::block_retry - if queue is full, block until queue has room for the new log entry.
// async_overflow_policy::discard_log_msg - never block and discard any new messages when queue overflows.
// async_overflow_policy::discard_log_msg - never block and discard any new messages when queue overflows.
//
// worker_warmup_cb (optional):
// callback function that will be called in worker thread upon start (can be used to init stuff like thread affinity)
......@@ -84,7 +84,7 @@ std::shared_ptr<logger> rotating_logger_mt(const std::string& logger_name, const
std::shared_ptr<logger> rotating_logger_st(const std::string& logger_name, const filename_t& filename, size_t max_file_size, size_t max_files);
//
// Create file logger which creates new file on the given time (default in midnight):
// Create file logger which creates new file on the given time (default in midnight):
//
std::shared_ptr<logger> daily_logger_mt(const std::string& logger_name, const filename_t& filename, int hour=0, int minute=0);
std::shared_ptr<logger> daily_logger_st(const std::string& logger_name, const filename_t& filename, int hour=0, int minute=0);
......@@ -129,7 +129,7 @@ std::shared_ptr<logger> create(const std::string& logger_name, const It& sinks_b
// Example:
// spdlog::create<daily_file_sink_st>("mylog", "dailylog_filename");
template <typename Sink, typename... Args>
std::shared_ptr<spdlog::logger> create(const std::string& logger_name, Args...);
std::shared_ptr<spdlog::logger> create(const std::string& logger_name, Args... args);
// Create and register an async logger with a single sink
std::shared_ptr<logger> create_async(const std::string& logger_name, const sink_ptr& sink, size_t queue_size, const async_overflow_policy overflow_policy = async_overflow_policy::block_retry, const std::function<void()>& worker_warmup_cb = nullptr, const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(), const std::function<void()>& worker_teardown_cb = nullptr);
......
include/spdlog/tweakme.h
View file @ 2e973c8b
......@@ -54,7 +54,7 @@
///////////////////////////////////////////////////////////////////////////////
// Uncomment if logger name logging is not needed.
// This will prevent spdlog from copying the logger name on each log call.
// This will prevent spdlog from copying the logger name on each log call.
//
// #define SPDLOG_NO_NAME
///////////////////////////////////////////////////////////////////////////////
......@@ -156,5 +156,5 @@
///////////////////////////////////////////////////////////////////////////////
// Uncomment to customize level names (e.g. "MT TRACE")
//
// #define SPDLOG_LEVEL_NAMES { "MY TRACE", "MY DEBUG", "MY INFO", "MY WARNING", "MY ERROR", "MY CRITICAL", "OFF" }
// #define SPDLOG_LEVEL_NAMES { "MY TRACE", "MY DEBUG", "MY INFO", "MY WARNING", "MY ERROR", "MY CRITICAL", "OFF" }
///////////////////////////////////////////////////////////////////////////////
tests/file_helper.cpp
View file @ 2e973c8b
......@@ -3,7 +3,8 @@
*/
#include "includes.h"
using namespace spdlog::details;
using spdlog::details::log_msg;
using spdlog::details::file_helper;
static const std::string target_filename = "logs/file_helper_test.txt";
......@@ -15,7 +16,6 @@ static void write_with_helper(file_helper &helper, size_t howmany)
helper.flush();
}
TEST_CASE("file_helper_filename", "[file_helper::filename()]]")
{
prepare_logdir();
......@@ -25,8 +25,6 @@ TEST_CASE("file_helper_filename", "[file_helper::filename()]]")
REQUIRE(helper.filename() == target_filename);
}
TEST_CASE("file_helper_size", "[file_helper::size()]]")
{
prepare_logdir();
......@@ -40,7 +38,6 @@ TEST_CASE("file_helper_size", "[file_helper::size()]]")
REQUIRE(get_filesize(target_filename) == expected_size);
}
TEST_CASE("file_helper_exists", "[file_helper::file_exists()]]")
{
prepare_logdir();
......@@ -73,8 +70,6 @@ TEST_CASE("file_helper_reopen2", "[file_helper::reopen(false)]]")
REQUIRE(helper.size() == expected_size);
}
static void test_split_ext(const char* fname, const char* expect_base, const char* expect_ext)
{
spdlog::filename_t filename(fname);
......@@ -91,7 +86,6 @@ static void test_split_ext(const char* fname, const char* expect_base, const cha
REQUIRE(ext == expected_ext);
}
TEST_CASE("file_helper_split_by_extenstion", "[file_helper::split_by_extenstion()]]")
{
test_split_ext("mylog.txt", "mylog", ".txt");
......@@ -113,6 +107,3 @@ TEST_CASE("file_helper_split_by_extenstion", "[file_helper::split_by_extenstion(
test_split_ext(".", ".", "");
test_split_ext("..txt", ".", ".txt");
}
tests/test_misc.cpp
View file @ 2e973c8b
#include "includes.h"
template<class T>
......@@ -16,11 +15,6 @@ std::string log_info(const T& what, spdlog::level::level_enum logger_level = spd
return oss.str().substr(0, oss.str().length() - strlen(spdlog::details::os::default_eol));
}
TEST_CASE("basic_logging ", "[basic_logging]")
{
//const char
......
tests/test_pattern_formatter.cpp
View file @ 2e973c8b
#include "includes.h"
// log to str and return it
static std::string log_to_str(const std::string& msg, std::shared_ptr<spdlog::formatter> formatter = nullptr)
static std::string log_to_str(const std::string& msg, const std::shared_ptr<spdlog::formatter>& formatter = nullptr)
{
std::ostringstream oss;
auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss);
......@@ -11,6 +11,7 @@ static std::string log_to_str(const std::string& msg, std::shared_ptr<spdlog::fo
oss_logger.info(msg);
return oss.str();
}
TEST_CASE("custom eol", "[pattern_formatter]")
{
std::string msg = "Hello custom eol test";
......@@ -38,7 +39,6 @@ TEST_CASE("level", "[pattern_formatter]")
REQUIRE(log_to_str("Some message", formatter) == "[info] Some message\n");
}
TEST_CASE("short level", "[pattern_formatter]")
{
auto formatter = std::make_shared<spdlog::pattern_formatter>("[%L] %v", spdlog::pattern_time_type::local, "\n");
......@@ -51,19 +51,11 @@ TEST_CASE("name", "[pattern_formatter]")
REQUIRE(log_to_str("Some message", formatter) == "[pattern_tester] Some message\n");
}
TEST_CASE("date MM/DD/YY ", "[pattern_formatter]")
{
using namespace::std::chrono;
auto formatter = std::make_shared<spdlog::pattern_formatter>("%D %v", spdlog::pattern_time_type::local, "\n");
auto now_tm = spdlog::details::os::localtime();
std::stringstream oss;
oss << std::setfill('0') << std::setw(2) << now_tm.tm_mon + 1 << "/" << now_tm.tm_mday << "/" << (now_tm.tm_year + 1900) % 1000 << " Some message\n";
REQUIRE(log_to_str("Some message", formatter) == oss.str());
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment