mirrors/spdlog
1
0
Fork 0
mirror of https://github.com/gabime/spdlog.git synced 2024-12-25 18:11:33 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

static lib wip

Browse Source
This commit is contained in:
gabime 2019-04-05 23:05:46 +03:00
parent 156b856a80
commit 17f9cdd401
14 changed files with 1455 additions and 1464 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
example/example.cpp
View File

@ -14,8 +14,9 @@ spdlog::logger *get_logger();
int main(int, char *[]) int main(int, char *[])
{ {
auto *l = get_logger(); auto *l = get_logger();
l->info("HELLO {}", "GA"); l->info("HE LO ", "GA");
l->error("Some {}", "error"); l->error("Some {} {} {}", "er or");
l->error("Some {} {} {}", "er or");
} }

18
include/spdlog/common.h
View File

@ -9,22 +9,16 @@
#include <atomic> #include <atomic>
#include <chrono> #include <chrono>
#include <functional>
#include <initializer_list> #include <initializer_list>
#include <memory> #include <memory>
#include <stdexcept> #include <stdexcept>
#include <string> #include <string>
#include <cstring>
#include <type_traits>
#include <unordered_map>
#if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) #if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
#include <codecvt> #include <codecvt>
#include <locale> #include <locale>
#endif #endif
#include "spdlog/details/null_mutex.h"
#include "spdlog/fmt/fmt.h" #include "spdlog/fmt/fmt.h"
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY
@ -75,6 +69,17 @@
#define SPDLOG_FUNCTION __FUNCTION__ #define SPDLOG_FUNCTION __FUNCTION__
#endif #endif
#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
#define SPDLOG_FILENAME_T(s) L##s
SPDLOG_INLINE std::string filename_to_str(const filename_t &filename)
{
std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t> c;
return c.to_bytes(filename);
}
#else
#define SPDLOG_FILENAME_T(s) s
#endif
namespace spdlog { namespace spdlog {
class formatter; class formatter;
@ -86,7 +91,6 @@ class sink;
using log_clock = std::chrono::system_clock; using log_clock = std::chrono::system_clock;
using sink_ptr = std::shared_ptr<sinks::sink>; using sink_ptr = std::shared_ptr<sinks::sink>;
using sinks_init_list = std::initializer_list<sink_ptr>; using sinks_init_list = std::initializer_list<sink_ptr>;
using log_err_handler = std::function<void(const std::string &err_msg)>;
// string_view type - either std::string_view or fmt::string_view (pre c++17) // string_view type - either std::string_view or fmt::string_view (pre c++17)
#if defined(FMT_USE_STD_STRING_VIEW) #if defined(FMT_USE_STD_STRING_VIEW)

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

@ -38,9 +38,6 @@ inline spdlog::async_logger::async_logger(
// send the log message to the thread pool // send the log message to the thread pool
inline void spdlog::async_logger::sink_it_(details::log_msg &msg) inline void spdlog::async_logger::sink_it_(details::log_msg &msg)
{ {
#if defined(SPDLOG_ENABLE_MESSAGE_COUNTER)
incr_msg_counter_(msg);
#endif
if (auto pool_ptr = thread_pool_.lock()) if (auto pool_ptr = thread_pool_.lock())
{ {
pool_ptr->post_log(shared_from_this(), msg, overflow_policy_); pool_ptr->post_log(shared_from_this(), msg, overflow_policy_);
@ -119,6 +116,6 @@ inline std::shared_ptr<spdlog::logger> spdlog::async_logger::clone(std::string n
cloned->set_level(this->level()); cloned->set_level(this->level());
cloned->flush_on(this->flush_level()); cloned->flush_on(this->flush_level());
cloned->set_error_handler(this->error_handler()); cloned->set_error_handler(this->custom_err_handler_);
return std::move(cloned); return std::move(cloned);
} }

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

File diff suppressed because it is too large Load Diff

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

@ -154,7 +154,7 @@ public:
periodic_flusher_ = details::make_unique<periodic_worker>(clbk, interval); periodic_flusher_ = details::make_unique<periodic_worker>(clbk, interval);
} }
void set_error_handler(log_err_handler handler) void set_error_handler(void (*handler)(const std::string &msg))
{ {
std::lock_guard<std::mutex> lock(logger_map_mutex_); std::lock_guard<std::mutex> lock(logger_map_mutex_);
for (auto &l : loggers_) for (auto &l : loggers_)
@ -275,7 +275,7 @@ private:
std::unique_ptr<formatter> formatter_; std::unique_ptr<formatter> formatter_;
level::level_enum level_ = spdlog::logger::default_level(); level::level_enum level_ = spdlog::logger::default_level();
level::level_enum flush_level_ = level::off; level::level_enum flush_level_ = level::off;
log_err_handler err_handler_; void (*err_handler_)(const std::string &msg);
std::shared_ptr<thread_pool> tp_; std::shared_ptr<thread_pool> tp_;
std::unique_ptr<periodic_worker> periodic_flusher_; std::unique_ptr<periodic_worker> periodic_flusher_;
std::shared_ptr<logger> default_logger_; std::shared_ptr<logger> default_logger_;

239
include/spdlog/logger.h
View File

@ -17,22 +17,17 @@
// The use of private formatter per sink provides the opportunity to cache some // The use of private formatter per sink provides the opportunity to cache some
// formatted data, and support for different format per sink. // formatted data, and support for different format per sink.
#include "spdlog/common.h" #include "spdlog/common.h"
#include "spdlog/details/log_msg.h" #include "spdlog/details/log_msg.h"
//#include "spdlog/formatter.h"
//#include "spdlog/sinks/sink.h"
#include <memory> #include <memory>
#include <string> #include <string>
#include <vector> #include <vector>
namespace spdlog namespace spdlog {
class logger
{ {
class logger public:
{
public:
template<typename It> template<typename It>
logger(std::string name, It begin, It end) logger(std::string name, It begin, It end)
: name_(std::move(name)) : name_(std::move(name))
@ -57,32 +52,32 @@ namespace spdlog
template<typename... Args> template<typename... Args>
void log(source_loc loc, level::level_enum lvl, const char *fmt, const Args &... args) void log(source_loc loc, level::level_enum lvl, const char *fmt, const Args &... args)
{ {
if (!should_log(lvl)) if (!should_log(lvl))
{ {
return; return;
} }
try try
{ {
fmt::memory_buffer buf; fmt::memory_buffer buf;
fmt::format_to(buf, fmt, args...); fmt::format_to(buf, fmt, args...);
details::log_msg log_msg(loc, &name_, lvl, string_view_t(buf.data(), buf.size())); details::log_msg log_msg(loc, &name_, lvl, string_view_t(buf.data(), buf.size()));
sink_it_(log_msg); sink_it_(log_msg);
} }
catch (const std::exception &ex) catch (const std::exception &ex)
{ {
err_handler_(ex.what()); err_handler_(ex.what());
} }
catch (...) catch (...)
{ {
err_handler_("Unknown exception in logger"); err_handler_("Unknown exception in logger");
} }
} }
template<typename... Args> template<typename... Args>
void log(level::level_enum lvl, const char *fmt, const Args &... args) void log(level::level_enum lvl, const char *fmt, const Args &... args)
{ {
log(source_loc{}, lvl, fmt, args...); log(source_loc{}, lvl, fmt, args...);
} }
void log(source_loc loc, level::level_enum lvl, const char *msg); void log(source_loc loc, level::level_enum lvl, const char *msg);
void log(level::level_enum lvl, const char *msg); void log(level::level_enum lvl, const char *msg);
@ -90,37 +85,37 @@ namespace spdlog
template<typename... Args> template<typename... Args>
void trace(const char *fmt, const Args &... args) void trace(const char *fmt, const Args &... args)
{ {
log(level::trace, fmt, args...); log(level::trace, fmt, args...);
} }
template<typename... Args> template<typename... Args>
void debug(const char *fmt, const Args &... args) void debug(const char *fmt, const Args &... args)
{ {
log(level::debug, fmt, args...); log(level::debug, fmt, args...);
} }
template<typename... Args> template<typename... Args>
void info(const char *fmt, const Args &... args) void info(const char *fmt, const Args &... args)
{ {
log(level::info, fmt, args...); log(level::info, fmt, args...);
} }
template<typename... Args> template<typename... Args>
void warn(const char *fmt, const Args &... args) void warn(const char *fmt, const Args &... args)
{ {
log(level::warn, fmt, args...); log(level::warn, fmt, args...);
} }
template<typename... Args> template<typename... Args>
void error(const char *fmt, const Args &... args) void error(const char *fmt, const Args &... args)
{ {
log(level::err, fmt, args...); log(level::err, fmt, args...);
} }
template<typename... Args> template<typename... Args>
void critical(const char *fmt, const Args &... args) void critical(const char *fmt, const Args &... args)
{ {
log(level::critical, fmt, args...); log(level::critical, fmt, args...);
} }
#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
@ -129,87 +124,87 @@ namespace spdlog
#else #else
inline void wbuf_to_utf8buf(const fmt::wmemory_buffer &wbuf, fmt::memory_buffer &target) inline void wbuf_to_utf8buf(const fmt::wmemory_buffer &wbuf, fmt::memory_buffer &target)
{ {
int wbuf_size = static_cast<int>(wbuf.size()); int wbuf_size = static_cast<int>(wbuf.size());
if (wbuf_size == 0) if (wbuf_size == 0)
{ {
return; return;
} }
auto result_size = ::WideCharToMultiByte(CP_UTF8, 0, wbuf.data(), wbuf_size, NULL, 0, NULL, NULL); auto result_size = ::WideCharToMultiByte(CP_UTF8, 0, wbuf.data(), wbuf_size, NULL, 0, NULL, NULL);
if (result_size > 0) if (result_size > 0)
{ {
target.resize(result_size); target.resize(result_size);
::WideCharToMultiByte(CP_UTF8, 0, wbuf.data(), wbuf_size, &target.data()[0], result_size, NULL, NULL); ::WideCharToMultiByte(CP_UTF8, 0, wbuf.data(), wbuf_size, &target.data()[0], result_size, NULL, NULL);
} }
else else
{ {
throw spdlog::spdlog_ex(fmt::format("WideCharToMultiByte failed. Last error: {}", ::GetLastError())); throw spdlog::spdlog_ex(fmt::format("WideCharToMultiByte failed. Last error: {}", ::GetLastError()));
} }
} }
template<typename... Args> template<typename... Args>
void log(source_loc source, level::level_enum lvl, const wchar_t *fmt, const Args &... args) void log(source_loc source, level::level_enum lvl, const wchar_t *fmt, const Args &... args)
{ {
if (!should_log(lvl)) if (!should_log(lvl))
{ {
return; return;
} }
try try
{ {
// format to wmemory_buffer and convert to utf8 // format to wmemory_buffer and convert to utf8
using details::fmt_helper::to_string_view; using details::fmt_helper::to_string_view;
fmt::wmemory_buffer wbuf; fmt::wmemory_buffer wbuf;
fmt::format_to(wbuf, fmt, args...); fmt::format_to(wbuf, fmt, args...);
fmt::memory_buffer buf; fmt::memory_buffer buf;
wbuf_to_utf8buf(wbuf, buf); wbuf_to_utf8buf(wbuf, buf);
details::log_msg log_msg(source, &name_, lvl, to_string_view(buf)); details::log_msg log_msg(source, &name_, lvl, to_string_view(buf));
sink_it_(log_msg); sink_it_(log_msg);
} }
SPDLOG_CATCH_AND_HANDLE SPDLOG_CATCH_AND_HANDLE
} }
template<typename... Args> template<typename... Args>
void log(level::level_enum lvl, const wchar_t *fmt, const Args &... args) void log(level::level_enum lvl, const wchar_t *fmt, const Args &... args)
{ {
log(source_loc{}, lvl, fmt, args...); log(source_loc{}, lvl, fmt, args...);
} }
template<typename... Args> template<typename... Args>
void trace(const wchar_t *fmt, const Args &... args) void trace(const wchar_t *fmt, const Args &... args)
{ {
log(level::trace, fmt, args...); log(level::trace, fmt, args...);
} }
template<typename... Args> template<typename... Args>
void debug(const wchar_t *fmt, const Args &... args) void debug(const wchar_t *fmt, const Args &... args)
{ {
log(level::debug, fmt, args...); log(level::debug, fmt, args...);
} }
template<typename... Args> template<typename... Args>
void info(const wchar_t *fmt, const Args &... args) void info(const wchar_t *fmt, const Args &... args)
{ {
log(level::info, fmt, args...); log(level::info, fmt, args...);
} }
template<typename... Args> template<typename... Args>
void warn(const wchar_t *fmt, const Args &... args) void warn(const wchar_t *fmt, const Args &... args)
{ {
log(level::warn, fmt, args...); log(level::warn, fmt, args...);
} }
template<typename... Args> template<typename... Args>
void error(const wchar_t *fmt, const Args &... args) void error(const wchar_t *fmt, const Args &... args)
{ {
log(level::err, fmt, args...); log(level::err, fmt, args...);
} }
template<typename... Args> template<typename... Args>
void critical(const wchar_t *fmt, const Args &... args) void critical(const wchar_t *fmt, const Args &... args)
{ {
log(level::critical, fmt, args...); log(level::critical, fmt, args...);
} }
#endif // _WIN32 #endif // _WIN32
#endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT #endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT
@ -217,92 +212,92 @@ namespace spdlog
template<typename T> template<typename T>
void log(level::level_enum lvl, const T &msg) void log(level::level_enum lvl, const T &msg)
{ {
log(source_loc{}, lvl, msg); log(source_loc{}, lvl, msg);
} }
// T can be statically converted to string_view // T can be statically converted to string_view
template<class T, typename std::enable_if<std::is_convertible<T, spdlog::string_view_t>::value, T>::type * = nullptr> template<class T, typename std::enable_if<std::is_convertible<T, spdlog::string_view_t>::value, T>::type * = nullptr>
void log(source_loc loc, level::level_enum lvl, const T &msg) void log(source_loc loc, level::level_enum lvl, const T &msg)
{ {
if (!should_log(lvl)) if (!should_log(lvl))
{ {
return; return;
} }
try try
{ {
details::log_msg log_msg(loc, &name_, lvl, msg); details::log_msg log_msg(loc, &name_, lvl, msg);
sink_it_(log_msg); sink_it_(log_msg);
} }
catch (const std::exception &ex) catch (const std::exception &ex)
{ {
err_handler_(ex.what()); err_handler_(ex.what());
} }
catch (...) catch (...)
{ {
err_handler_("Unknown exception in logger"); err_handler_("Unknown exception in logger");
} }
} }
// T cannot be statically converted to string_view // T cannot be statically converted to string_view
template<class T, typename std::enable_if<!std::is_convertible<T, spdlog::string_view_t>::value, T>::type * = nullptr> template<class T, typename std::enable_if<!std::is_convertible<T, spdlog::string_view_t>::value, T>::type * = nullptr>
void log(source_loc loc, level::level_enum lvl, const T &msg) void log(source_loc loc, level::level_enum lvl, const T &msg)
{ {
if (!should_log(lvl)) if (!should_log(lvl))
{ {
return; return;
} }
try try
{ {
using details::fmt_helper::to_string_view; using details::fmt_helper::to_string_view;
fmt::memory_buffer buf; fmt::memory_buffer buf;
fmt::format_to(buf, "{}", msg); fmt::format_to(buf, "{}", msg);
details::log_msg log_msg(loc, &name_, lvl, to_string_view(buf)); details::log_msg log_msg(loc, &name_, lvl, to_string_view(buf));
sink_it_(log_msg); sink_it_(log_msg);
} }
catch (const std::exception &ex) catch (const std::exception &ex)
{ {
err_handler_(ex.what()); err_handler_(ex.what());
} }
catch (...) catch (...)
{ {
err_handler_("Unknown exception in logger"); err_handler_("Unknown exception in logger");
} }
} }
template<typename T> template<typename T>
void trace(const T &msg) void trace(const T &msg)
{ {
log(level::trace, msg); log(level::trace, msg);
} }
template<typename T> template<typename T>
void debug(const T &msg) void debug(const T &msg)
{ {
log(level::debug, msg); log(level::debug, msg);
} }
template<typename T> template<typename T>
void info(const T &msg) void info(const T &msg)
{ {
log(level::info, msg); log(level::info, msg);
} }
template<typename T> template<typename T>
void warn(const T &msg) void warn(const T &msg)
{ {
log(level::warn, msg); log(level::warn, msg);
} }
template<typename T> template<typename T>
void error(const T &msg) void error(const T &msg)
{ {
log(level::err, msg); log(level::err, msg);
} }
template<typename T> template<typename T>
void critical(const T &msg) void critical(const T &msg)
{ {
log(level::critical, msg); log(level::critical, msg);
} }
bool should_log(level::level_enum msg_level) const; bool should_log(level::level_enum msg_level) const;
@ -332,9 +327,7 @@ namespace spdlog
std::vector<sink_ptr> &sinks(); std::vector<sink_ptr> &sinks();
// error handler // error handler
void set_error_handler(log_err_handler err_handler); void set_error_handler(void (*handler)(const std::string& msg));
log_err_handler error_handler() const;
// create new logger with same sinks and configuration. // create new logger with same sinks and configuration.
virtual std::shared_ptr<logger> clone(std::string logger_name); virtual std::shared_ptr<logger> clone(std::string logger_name);
@ -347,7 +340,7 @@ namespace spdlog
// default error handler. // default error handler.
// print the error to stderr with the max rate of 1 message/minute. // print the error to stderr with the max rate of 1 message/minute.
void default_err_handler_(const std::string &msg); void err_handler_(const std::string &msg);
// increment the message count (only if defined(SPDLOG_ENABLE_MESSAGE_COUNTER)) // 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);
@ -356,10 +349,8 @@ namespace spdlog
std::vector<sink_ptr> sinks_; std::vector<sink_ptr> sinks_;
spdlog::level_t level_{spdlog::logger::default_level()}; spdlog::level_t level_{spdlog::logger::default_level()};
spdlog::level_t flush_level_{level::off}; spdlog::level_t flush_level_{level::off};
log_err_handler err_handler_{[this](const std::string &msg) { this->default_err_handler_(msg); }}; void (*custom_err_handler_)(const std::string &msg) {nullptr};
std::atomic<time_t> last_err_time_{0}; };
std::atomic<size_t> msg_counter_{1};
};
} // namespace spdlog } // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY #ifdef SPDLOG_HEADER_ONLY

4
include/spdlog/spdlog.h
View File

@ -103,9 +103,9 @@ inline void flush_every(std::chrono::seconds interval)
} }
// Set global error handler // Set global error handler
inline void set_error_handler(log_err_handler handler) inline void set_error_handler(void (*handler)(const std::string &msg))
{ {
details::registry::instance().set_error_handler(std::move(handler)); details::registry::instance().set_error_handler(handler);
} }
// Register the given logger with the given name // Register the given logger with the given name

7
include/spdlog/tweakme.h
View File

@ -107,13 +107,6 @@
// #define SPDLOG_PREVENT_CHILD_FD // #define SPDLOG_PREVENT_CHILD_FD
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// Uncomment to enable message counting feature.
// Use the %i in the logger pattern to display log message sequence id.
//
// #define SPDLOG_ENABLE_MESSAGE_COUNTER
///////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// Uncomment to customize level names (e.g. "MT TRACE") // Uncomment to customize level names (e.g. "MT TRACE")
// //

38
src/logger.cpp
View File

@ -113,14 +113,9 @@ SPDLOG_INLINE std::vector<spdlog::sink_ptr> &spdlog::logger::sinks()
} }
// error handler // error handler
SPDLOG_INLINE void spdlog::logger::set_error_handler(spdlog::log_err_handler err_handler) SPDLOG_INLINE void spdlog::logger::set_error_handler(void (*handler)(const std::string &msg))
{ {
err_handler_ = std::move(err_handler); custom_err_handler_ = handler;
}
SPDLOG_INLINE spdlog::log_err_handler spdlog::logger::error_handler() const
{
return err_handler_;
} }
// create new logger with same sinks and configuration. // create new logger with same sinks and configuration.
@ -129,16 +124,13 @@ SPDLOG_INLINE std::shared_ptr<spdlog::logger> spdlog::logger::clone(std::string
auto cloned = std::make_shared<spdlog::logger>(std::move(logger_name), sinks_.begin(), sinks_.end()); auto cloned = std::make_shared<spdlog::logger>(std::move(logger_name), sinks_.begin(), sinks_.end());
cloned->set_level(this->level()); cloned->set_level(this->level());
cloned->flush_on(this->flush_level()); cloned->flush_on(this->flush_level());
cloned->set_error_handler(this->error_handler()); cloned->set_error_handler(this->custom_err_handler_);
return cloned; return cloned;
} }
// protected methods // protected methods
SPDLOG_INLINE void spdlog::logger::sink_it_(spdlog::details::log_msg &msg) SPDLOG_INLINE void spdlog::logger::sink_it_(spdlog::details::log_msg &msg)
{ {
#if defined(SPDLOG_ENABLE_MESSAGE_COUNTER)
incr_msg_counter_(msg);
#endif
for (auto &sink : sinks_) for (auto &sink : sinks_)
{ {
if (sink->should_log(msg.level)) if (sink->should_log(msg.level))
@ -167,21 +159,17 @@ SPDLOG_INLINE bool spdlog::logger::should_flush_(const spdlog::details::log_msg
return (msg.level >= flush_level) && (msg.level != level::off); return (msg.level >= flush_level) && (msg.level != level::off);
} }
SPDLOG_INLINE void spdlog::logger::default_err_handler_(const std::string &msg) void spdlog::logger::err_handler_(const std::string &msg)
{ {
auto now = time(nullptr); if (custom_err_handler_)
if (now - last_err_time_ < 60) {
custom_err_handler_(msg);
}
else
{ {
return; auto tm_time = spdlog::details::os::localtime();
char date_buf[64];
std::strftime(date_buf, sizeof(date_buf), "%Y-%m-%d %H:%M:%S", &tm_time);
fmt::print(stderr, "[*** LOG ERROR ***] [{}] [{}] {}\n", date_buf, name(), msg);
} }
last_err_time_ = now;
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);
fmt::print(stderr, "[*** LOG ERROR ***] [{}] [{}] {}\n", date_buf, name(), msg);
}
SPDLOG_INLINE void spdlog::logger::incr_msg_counter_(spdlog::details::log_msg &msg)
{
msg.msg_id = msg_counter_.fetch_add(1, std::memory_order_relaxed);
} }

2
src/os.cpp
View File

@ -344,14 +344,12 @@ SPDLOG_INLINE void sleep_for_millis(int milliseconds) SPDLOG_NOEXCEPT
// wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined) // wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined)
#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES) #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
#define SPDLOG_FILENAME_T(s) L##s
SPDLOG_INLINE std::string filename_to_str(const filename_t &filename) SPDLOG_INLINE std::string filename_to_str(const filename_t &filename)
{ {
std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t> c; std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t> c;
return c.to_bytes(filename); return c.to_bytes(filename);
} }
#else #else
#define SPDLOG_FILENAME_T(s) s
SPDLOG_INLINE std::string filename_to_str(const filename_t &filename) SPDLOG_INLINE std::string filename_to_str(const filename_t &filename)
{ {
return filename; return filename;

1266
src/pattern_formatter.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

1
tests/includes.h
View File

@ -11,7 +11,6 @@
#include <string> #include <string>
#define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_DEBUG #define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_DEBUG
#define SPDLOG_ENABLE_MESSAGE_COUNTER
#include "spdlog/spdlog.h" #include "spdlog/spdlog.h"
#include "spdlog/async.h" #include "spdlog/async.h"

26
tests/test_errors.cpp
View File

@ -41,13 +41,18 @@ TEST_CASE("default_error_handler", "[errors]]")
struct custom_ex struct custom_ex
{ {
}; };
static void custom_handler(const std::string &msg)
{
throw custom_ex();
}
TEST_CASE("custom_error_handler", "[errors]]") TEST_CASE("custom_error_handler", "[errors]]")
{ {
prepare_logdir(); prepare_logdir();
std::string filename = "logs/simple_log.txt"; std::string filename = "logs/simple_log.txt";
auto logger = spdlog::create<spdlog::sinks::basic_file_sink_mt>("logger", filename, true); auto logger = spdlog::create<spdlog::sinks::basic_file_sink_mt>("logger", filename, true);
logger->flush_on(spdlog::level::info); logger->flush_on(spdlog::level::info);
logger->set_error_handler([=](const std::string &) { throw custom_ex(); }); logger->set_error_handler(custom_handler);
logger->info("Good message #1"); logger->info("Good message #1");
REQUIRE_THROWS_AS(logger->info("Bad format msg {} {}", "xxx"), custom_ex); REQUIRE_THROWS_AS(logger->info("Bad format msg {} {}", "xxx"), custom_ex);
@ -59,7 +64,7 @@ TEST_CASE("default_error_handler2", "[errors]]")
{ {
spdlog::drop_all(); spdlog::drop_all();
auto logger = spdlog::create<failing_sink>("failed_logger"); auto logger = spdlog::create<failing_sink>("failed_logger");
logger->set_error_handler([=](const std::string &) { throw custom_ex(); }); logger->set_error_handler(custom_handler);
REQUIRE_THROWS_AS(logger->info("Some message"), custom_ex); REQUIRE_THROWS_AS(logger->info("Some message"), custom_ex);
} }
@ -67,26 +72,26 @@ TEST_CASE("flush_error_handler", "[errors]]")
{ {
spdlog::drop_all(); spdlog::drop_all();
auto logger = spdlog::create<failing_sink>("failed_logger"); auto logger = spdlog::create<failing_sink>("failed_logger");
logger->set_error_handler([=](const std::string &) { throw custom_ex(); }); logger->set_error_handler(custom_handler);
REQUIRE_THROWS_AS(logger->flush(), custom_ex); REQUIRE_THROWS_AS(logger->flush(), custom_ex);
} }
TEST_CASE("async_error_handler", "[errors]]") TEST_CASE("async_error_handler", "[errors]]")
{ {
prepare_logdir(); prepare_logdir();
std::string err_msg("log failed with some msg");
std::string filename = "logs/simple_async_log.txt"; std::string filename = "logs/simple_async_log.txt";
{ {
spdlog::init_thread_pool(128, 1); spdlog::init_thread_pool(128, 1);
auto logger = spdlog::create_async<spdlog::sinks::basic_file_sink_mt>("logger", filename, true); auto logger = spdlog::create_async<spdlog::sinks::basic_file_sink_mt>("logger", filename, true);
logger->set_error_handler([=](const std::string &) { logger->set_error_handler([](const std::string &) {
std::ofstream ofs("logs/custom_err.txt"); std::ofstream ofs("logs/custom_err.txt");
if (!ofs) if (!ofs)
{ {
throw std::runtime_error("Failed open logs/custom_err.txt"); throw std::runtime_error("Failed open logs/custom_err.txt");
} }
ofs << err_msg; ofs << "log failed with some msg";
}); });
logger->info("Good message #1"); logger->info("Good message #1");
logger->info("Bad format msg {} {}", "xxx"); logger->info("Bad format msg {} {}", "xxx");
@ -95,27 +100,26 @@ TEST_CASE("async_error_handler", "[errors]]")
} }
spdlog::init_thread_pool(128, 1); spdlog::init_thread_pool(128, 1);
REQUIRE(count_lines(filename) == 2); REQUIRE(count_lines(filename) == 2);
REQUIRE(file_contents("logs/custom_err.txt") == err_msg); REQUIRE(file_contents("logs/custom_err.txt") == "log failed with some msg");
} }
// Make sure async error handler is executed // Make sure async error handler is executed
TEST_CASE("async_error_handler2", "[errors]]") TEST_CASE("async_error_handler2", "[errors]]")
{ {
prepare_logdir(); prepare_logdir();
std::string err_msg("This is async handler error message");
{ {
spdlog::init_thread_pool(128, 1); spdlog::init_thread_pool(128, 1);
auto logger = spdlog::create_async<failing_sink>("failed_logger"); auto logger = spdlog::create_async<failing_sink>("failed_logger");
logger->set_error_handler([=](const std::string &) { logger->set_error_handler([](const std::string &) {
std::ofstream ofs("logs/custom_err2.txt"); std::ofstream ofs("logs/custom_err2.txt");
if (!ofs) if (!ofs)
throw std::runtime_error("Failed open logs/custom_err2.txt"); throw std::runtime_error("Failed open logs/custom_err2.txt");
ofs << err_msg; ofs << "handler error message";
}); });
logger->info("Hello failure"); logger->info("Hello failure");
spdlog::drop("failed_logger"); // force logger to drain the queue and shutdown spdlog::drop("failed_logger"); // force logger to drain the queue and shutdown
} }
spdlog::init_thread_pool(128, 1); spdlog::init_thread_pool(128, 1);
REQUIRE(file_contents("logs/custom_err2.txt") == err_msg); REQUIRE(file_contents("logs/custom_err2.txt") == "handler error message");
} }

18
tests/test_misc.cpp
View File

@ -107,7 +107,6 @@ TEST_CASE("clone-logger", "[clone]")
cloned->info("Some message 2"); cloned->info("Some message 2");
auto test_sink = std::static_pointer_cast<sinks::test_sink_mt>(cloned->sinks()[0]); auto test_sink = std::static_pointer_cast<sinks::test_sink_mt>(cloned->sinks()[0]);
REQUIRE(test_sink->msg_counter() == 2);
spdlog::drop_all(); spdlog::drop_all();
} }
@ -130,7 +129,6 @@ TEST_CASE("clone async", "[clone]")
spdlog::details::os::sleep_for_millis(10); spdlog::details::os::sleep_for_millis(10);
auto test_sink = std::static_pointer_cast<sinks::test_sink_mt>(cloned->sinks()[0]); auto test_sink = std::static_pointer_cast<sinks::test_sink_mt>(cloned->sinks()[0]);
REQUIRE(test_sink->msg_counter() == 2);
spdlog::drop_all(); spdlog::drop_all();
} }
@ -176,22 +174,6 @@ TEST_CASE("to_hex_no_delimiter", "[to_hex]")
REQUIRE(ends_with(output, "0000: 090A0B0CFFFF" + std::string(spdlog::details::os::default_eol))); REQUIRE(ends_with(output, "0000: 090A0B0CFFFF" + std::string(spdlog::details::os::default_eol)));
} }
TEST_CASE("message_counter", "[message_counter]")
{
std::ostringstream oss;
auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss);
spdlog::logger oss_logger("oss", oss_sink);
oss_logger.set_pattern("%i %v");
oss_logger.info("Hello");
REQUIRE(oss.str() == "000001 Hello" + std::string(spdlog::details::os::default_eol));
oss.str("");
oss_logger.info("Hello again");
REQUIRE(oss.str() == "000002 Hello again" + std::string(spdlog::details::os::default_eol));
}
TEST_CASE("default logger API", "[default logger]") TEST_CASE("default logger API", "[default logger]")
{ {
std::ostringstream oss; std::ostringstream oss;