mirrors/spdlog
1
0
Fork 0
mirror of https://github.com/gabime/spdlog.git synced 2025-04-01 02:42:41 +08:00
Code

Default formatter and common types into common.h

Browse Source
This commit is contained in:
gabi 2014-10-24 01:59:39 +03:00
parent 6080436e8b
commit 319db7bccc
9 changed files with 204 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
example/bench.cpp
View File

@ -2,6 +2,7 @@
// //
#include <mutex> #include <mutex>
#include "c11log/logger.h" #include "c11log/logger.h"
#include "c11log/factory.h"
#include "c11log/sinks/async_sink.h" #include "c11log/sinks/async_sink.h"
#include "c11log/sinks/file_sinks.h" #include "c11log/sinks/file_sinks.h"
#include "c11log/sinks/stdout_sinks.h" #include "c11log/sinks/stdout_sinks.h"
@ -12,27 +13,45 @@ using namespace std::chrono;
using namespace c11log; using namespace c11log;
using namespace utils; using namespace utils;
std::ostringstream f1(int i)
{
std::ostringstream oss;
oss << "Hello oss " << i;
return oss;
}
details::fast_oss f2(int i)
{
details::fast_oss oss;
oss << "Hello oss " << i;
return oss;
}
int main(int argc, char* argv[]) int main(int argc, char* argv[])
{ {
const unsigned int howmany = argc <= 1 ? 500000 : atoi(argv[1]); const unsigned int howmany = argc <= 1 ? 600000 : atoi(argv[1]);
std::string pattern = "%z %B %d, %Y %H:%M:%S.%e **************[%n:%l] %t"; const std::string pattern = "%+";
//std::string pattern = " [%z] %t";
auto formatter = std::make_shared<details::pattern_formatter>(pattern); auto formatter = std::make_shared<details::pattern_formatter>(pattern);
//logger cout_logger("bench", { std::make_shared<sinks::stderr_sink_mt>() }, pattern);
//logger::default_formatter(formatter);
logger cout_logger("bench", { std::make_shared<sinks::stderr_sink_mt>() }); logger cout_logger("bench", { std::make_shared<sinks::stderr_sink_mt>() });
cout_logger.formatter(formatter); logger::default_formatter(formatter);
cout_logger.info() << "Hello logger " << 1234; cout_logger.info() << "Hello logger " << 12.4 << 5 << ',' << 6 << 7 <<8<<9<<10;
auto nullsink = std::make_shared<sinks::null_sink_st>(); auto nullsink = std::make_shared<sinks::null_sink_st>();
auto rotating = std::make_shared<sinks::rotating_file_sink_mt>("myrotating", "txt", 1024 * 1024 * 5, 5, 100); auto rotating = std::make_shared<sinks::rotating_file_sink_st>("myrotating", "txt", 1024 * 1024 * 5, 20, 100);
logger my_logger("my_logger", { nullsink });
logger my_logger("my_logger", { nullsink }, formatter);
auto start = system_clock::now(); auto start = system_clock::now();
for (unsigned int i = 1; i <= howmany; ++i) for (unsigned int i = 1; i <= howmany; ++i)
{
my_logger.info() << "Hello logger: msg #" << i; my_logger.info() << "Hello logger: msg #" << i;
}
auto delta = system_clock::now() - start; auto delta = system_clock::now() - start;
auto delta_d = duration_cast<duration<double>> (delta).count(); auto delta_d = duration_cast<duration<double>> (delta).count();

2
example/example.cpp
View File

@ -17,7 +17,7 @@ details::fast_oss f(const std::string& what)
oss << what; oss << what;
return oss; return oss;
} }
int main(int, char* []) int main_(int, char* [])
{ {
auto foss = f("test2"); auto foss = f("test2");

4
example/utils.h
View File

@ -11,7 +11,7 @@ namespace utils
{ {
template<typename T> template<typename T>
std::string format(const T& value) inline std::string format(const T& value)
{ {
static std::locale loc(""); static std::locale loc("");
std::stringstream ss; std::stringstream ss;
@ -21,7 +21,7 @@ std::string format(const T& value)
} }
template<> template<>
std::string format(const double & value) inline std::string format(const double & value)
{ {
static std::locale loc(""); static std::locale loc("");
std::stringstream ss; std::stringstream ss;

14
include/c11log/common.h
View File

@ -1,9 +1,23 @@
#pragma once #pragma once
#include<initializer_list>
#include<memory>
#include<chrono>
namespace c11log namespace c11log
{ {
class formatter;
namespace sinks {
class sink;
}
// Common types across the lib
using log_clock = std::chrono::system_clock; using log_clock = std::chrono::system_clock;
using sink_ptr = std::shared_ptr < sinks::sink > ;
using sinks_init_list = std::initializer_list < sink_ptr > ;
using formatter_ptr = std::shared_ptr<c11log::formatter>;
//Log level enum
namespace level namespace level
{ {
typedef enum typedef enum

40
include/c11log/details/pattern_formatter.h
View File

@ -298,8 +298,6 @@ private:
class t_formatter :public flag_formatter class t_formatter :public flag_formatter
{ {
void format(details::log_msg& msg) override void format(details::log_msg& msg) override
@ -340,6 +338,40 @@ private:
std::string _str; std::string _str;
}; };
// Full info formatter
// pattern: [%Y-%m-%d %H:%M:%S.%e] [%n] [%l] %t
class full_formatter :public flag_formatter
{
void format(details::log_msg& msg) override
{
msg.formatted.putc('[');
msg.formatted.put_int(msg.tm_time.tm_year+1900, 4);
msg.formatted.putc('-');
msg.formatted.put_int(msg.tm_time.tm_mon+ 1, 2);
msg.formatted.putc('-');
msg.formatted.put_int(msg.tm_time.tm_mday, 2);
msg.formatted.putc(' ');
msg.formatted.put_int(msg.tm_time.tm_hour, 2);
msg.formatted.putc(':');
msg.formatted.put_int(msg.tm_time.tm_min, 2);
msg.formatted.putc(':');
msg.formatted.put_int(msg.tm_time.tm_sec, 2);
//millis
msg.formatted.putc('.');
auto duration = msg.time.time_since_epoch();
auto millis = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count() % 1000;
msg.formatted.put_int(static_cast<int>(millis), 3);
msg.formatted.putc(']');
msg.formatted << " [";
msg.formatted << msg.logger_name;
msg.formatted << "] [";
msg.formatted << level::to_str(msg.level);
msg.formatted << "] ";
msg.formatted.put_fast_oss(msg.raw);
}
};
class pattern_formatter : public formatter class pattern_formatter : public formatter
@ -494,6 +526,10 @@ inline void c11log::details::pattern_formatter::handle_flag(char flag)
_formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::z_formatter())); _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::z_formatter()));
break; break;
case ('+'):
_formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::full_formatter()));
break;
default: //Unkown flag appears as is default: //Unkown flag appears as is
_formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::ch_formatter('%'))); _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::ch_formatter('%')));
_formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::ch_formatter(flag))); _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::ch_formatter(flag)));

153
include/c11log/factory.h
View File

@ -11,85 +11,96 @@ namespace c11log
{ {
namespace factory namespace factory
{ {
//
//
//std::shared_ptr<logger> get(const std::string& name);
//std::shared_ptr<logger> create(const std::string& name, sinks_init_list , formatter_ptr);
//std::shared_ptr<logger> create(const std::string& name, sinks_init_list, string format);
//template<class It>
//std::shared_ptr<logger> create (const std::string& name, const It& begin, const It& end);
// //
// console loggers single/multi threaded
// //
std::unique_ptr<logger> stdout_logger(const std::string& name = "") ////
{ //// console loggers single/multi threaded
auto sink = std::make_shared<sinks::stderr_sink_st>(); ////
return std::unique_ptr<logger>(new logger(name, { sink })); //std::unique_ptr<logger> stdout_logger(const std::string& name = "")
} //{
// auto sink = std::make_shared<sinks::stderr_sink_st>();
std::unique_ptr<logger> stdout_logger_mt(const std::string& name = "") // return std::unique_ptr<logger>(new logger(name, { sink }));
{ //}
auto sink = std::make_shared<sinks::stderr_sink_mt>();
return std::unique_ptr<logger>(new logger(name, { sink }));
}
// //
// simple file logger single/multi threaded //std::unique_ptr<logger> stdout_logger_mt(const std::string& name = "")
//{
// auto sink = std::make_shared<sinks::stderr_sink_mt>();
// return std::unique_ptr<logger>(new logger(name, { sink }));
//}
// //
std::unique_ptr<logger> simple_file_logger(const std::string& filename, const std::string& logger_name = "" ) ////
{ //// simple file logger single/multi threaded
auto fsink = std::make_shared<sinks::simple_file_sink_st>(filename); ////
return std::unique_ptr<logger>(new c11log::logger(logger_name, { fsink })); //std::unique_ptr<logger> simple_file_logger(const std::string& filename, const std::string& logger_name = "" )
//{
} // auto fsink = std::make_shared<sinks::simple_file_sink_st>(filename);
std::unique_ptr<logger> simple_file_logger_mt(const std::string& filename, const std::string& logger_name = "") // return std::unique_ptr<logger>(new c11log::logger(logger_name, { fsink }));
{
auto fsink = std::make_shared<sinks::simple_file_sink_mt>(filename);
return std::unique_ptr<logger>(new c11log::logger(logger_name, { fsink }));
}
// //
// daily file logger single/multi threaded //}
//std::unique_ptr<logger> simple_file_logger_mt(const std::string& filename, const std::string& logger_name = "")
//{
// auto fsink = std::make_shared<sinks::simple_file_sink_mt>(filename);
// return std::unique_ptr<logger>(new c11log::logger(logger_name, { fsink }));
//}
// //
std::unique_ptr<logger> daily_file_logger( ////
const std::string &filename, //// daily file logger single/multi threaded
const std::string &extension, ////
const std::size_t flush_every, //std::unique_ptr<logger> daily_file_logger(
const std::string& logger_name = "") // const std::string &filename,
{ // const std::string &extension,
auto fsink = std::make_shared<sinks::daily_file_sink_st>(filename, extension, flush_every); // const std::size_t flush_every,
return std::unique_ptr<logger>(new c11log::logger(logger_name, { fsink })); // const std::string& logger_name = "")
} //{
// auto fsink = std::make_shared<sinks::daily_file_sink_st>(filename, extension, flush_every);
std::unique_ptr<logger> daily_file_logger_mt( // return std::unique_ptr<logger>(new c11log::logger(logger_name, { fsink }));
const std::string &filename, //}
const std::string &extension,
const std::size_t flush_every,
const std::string& logger_name = "")
{
auto fsink = std::make_shared<sinks::daily_file_sink_mt>(filename, extension, flush_every);
return std::unique_ptr<logger>(new c11log::logger(logger_name, { fsink }));
}
// //
// rotating file logger single/multi threaded //std::unique_ptr<logger> daily_file_logger_mt(
// const std::string &filename,
// const std::string &extension,
// const std::size_t flush_every,
// const std::string& logger_name = "")
//{
// auto fsink = std::make_shared<sinks::daily_file_sink_mt>(filename, extension, flush_every);
// return std::unique_ptr<logger>(new c11log::logger(logger_name, { fsink }));
//}
// //
std::unique_ptr<logger> rotating_file_logger( ////
const std::string &filename, //// rotating file logger single/multi threaded
const std::string &extension, ////
const std::size_t max_size, //std::unique_ptr<logger> rotating_file_logger(
const std::size_t max_files, // const std::string &filename,
const std::size_t flush_every, // const std::string &extension,
const std::string& logger_name = "") // const std::size_t max_size,
{ // const std::size_t max_files,
auto fsink = std::make_shared<sinks::rotating_file_sink_st>(filename, extension, max_size, max_files, flush_every); // const std::size_t flush_every,
return std::unique_ptr<logger>(new c11log::logger(logger_name, { fsink })); // const std::string& logger_name = "")
} //{
// auto fsink = std::make_shared<sinks::rotating_file_sink_st>(filename, extension, max_size, max_files, flush_every);
std::unique_ptr<logger> rotating_file_logger_mt( // return std::unique_ptr<logger>(new c11log::logger(logger_name, { fsink }));
const std::string &filename, //}
const std::string &extension, //
const std::size_t max_size, //std::unique_ptr<logger> rotating_file_logger_mt(
const std::size_t max_files, // const std::string &filename,
const std::size_t flush_every, // const std::string &extension,
const std::string& logger_name = "") // const std::size_t max_size,
{ // const std::size_t max_files,
auto fsink = std::make_shared<sinks::rotating_file_sink_mt>(filename, extension, max_size, max_files, flush_every); // const std::size_t flush_every,
return std::unique_ptr<logger>(new c11log::logger(logger_name, { fsink })); // const std::string& logger_name = "")
} //{
// auto fsink = std::make_shared<sinks::rotating_file_sink_mt>(filename, extension, max_size, max_files, flush_every);
// return std::unique_ptr<logger>(new c11log::logger(logger_name, { fsink }));
//}
} // ns factory } // ns factory
} // ns c11log } // ns c11log

2
include/c11log/formatter.h
View File

@ -6,7 +6,7 @@ namespace c11log
class formatter class formatter
{ {
public: public:
virtual formatter() {} virtual ~formatter() {}
virtual void format(details::log_msg& msg) = 0; virtual void format(details::log_msg& msg) = 0;
}; };
} }

60
include/c11log/logger.h
View File

@ -14,7 +14,6 @@
#include "sinks/base_sink.h" #include "sinks/base_sink.h"
#include "common.h" #include "common.h"
#include "formatter.h"
#include "details/pattern_formatter.h" #include "details/pattern_formatter.h"
namespace c11log namespace c11log
@ -28,13 +27,21 @@ class line_logger;
class logger class logger
{ {
public: public:
using sink_ptr = std::shared_ptr<sinks::sink>;
using formatter_ptr = std::shared_ptr<c11log::formatter>;
logger(const std::string& name, std::initializer_list<sink_ptr>, formatter_ptr formatter = nullptr); logger(const std::string& name, sinks_init_list);
template<class It> template<class It>
logger(const std::string& name, const It& begin, const It& end); logger(const std::string& name, const It& begin, const It& end);
//get/set default formatter
static formatter_ptr& default_formatter(formatter_ptr formatter = nullptr);
void set_formatter(formatter_ptr);
formatter_ptr get_formatter() const;
logger(const logger&) = delete; logger(const logger&) = delete;
logger& operator=(const logger&) = delete; logger& operator=(const logger&) = delete;
@ -44,10 +51,6 @@ public:
const std::string& name() const; const std::string& name() const;
bool should_log(level::level_enum) const; bool should_log(level::level_enum) const;
void formatter(formatter_ptr);
formatter_ptr formatter() const;
template <typename... Args> details::line_logger log(level::level_enum lvl, const Args&... args); template <typename... Args> details::line_logger log(level::level_enum lvl, const Args&... args);
template <typename... Args> details::line_logger trace(const Args&... args); template <typename... Args> details::line_logger trace(const Args&... args);
template <typename... Args> details::line_logger debug(const Args&... args); template <typename... Args> details::line_logger debug(const Args&... args);
@ -66,8 +69,6 @@ private:
template <typename First, typename... Rest> template <typename First, typename... Rest>
void _variadic_log(details::line_logger&l, const First& first, const Rest&... rest); void _variadic_log(details::line_logger&l, const First& first, const Rest&... rest);
void _log_msg(details::log_msg& msg); void _log_msg(details::log_msg& msg);
formatter_ptr _default_formatter();
const char* _default_pattern = "[%Y:%m:%d %H:%M:%S.%e] [%n:%l] %t";
}; };
} }
@ -93,25 +94,39 @@ private:
#include "details/line_logger.h" #include "details/line_logger.h"
inline c11log::logger::logger(const std::string& logger_name, std::initializer_list<sink_ptr> sinks_list, formatter_ptr msg_formatter) : inline c11log::logger::logger(const std::string& logger_name, sinks_init_list sinks_list):
_name(logger_name), _name(logger_name),
_formatter(msg_formatter),
_sinks(sinks_list) _sinks(sinks_list)
{ {
if (!msg_formatter) //default formatter
_formatter = std::make_shared<details::pattern_formatter>(_default_pattern);
// no support under vs2013 for member initialization for std::atomic // no support under vs2013 for member initialization for std::atomic
_level = level::INFO; _level = level::INFO;
} }
template<class It> template<class It>
inline c11log::logger::logger(const std::string& logger_name, const It& begin, const It& end): inline c11log::logger::logger(const std::string& logger_name, const It& begin, const It& end) :
_name(logger_name), _name(logger_name),
_sinks(begin, end) _sinks(begin, end)
{} {}
inline void c11log::logger::set_formatter(c11log::formatter_ptr msg_formatter)
{
_formatter = msg_formatter;
}
inline c11log::formatter_ptr c11log::logger::get_formatter() const
{
return _formatter;
}
inline c11log::formatter_ptr& c11log::logger::default_formatter(formatter_ptr formatter)
{
static formatter_ptr g_default_formatter = std::make_shared<details::pattern_formatter>("[%Y-%m-%d %H:%M:%S.%e] [%n] [%l] %t");
if (formatter)
g_default_formatter = formatter;
return g_default_formatter;
}
template <typename... Args> template <typename... Args>
inline c11log::details::line_logger c11log::logger::log(level::level_enum lvl, const Args&... args) { inline c11log::details::line_logger c11log::logger::log(level::level_enum lvl, const Args&... args) {
bool msg_enabled = should_log(lvl); bool msg_enabled = should_log(lvl);
@ -177,15 +192,7 @@ inline bool c11log::logger::should_log(c11log::level::level_enum msg_level) cons
return msg_level >= _level.load(); return msg_level >= _level.load();
} }
inline void c11log::logger::formatter(formatter_ptr msg_formatter)
{
_formatter = msg_formatter;
}
inline c11log::logger::formatter_ptr c11log::logger::formatter() const
{
return _formatter;
}
inline void c11log::logger::_variadic_log(c11log::details::line_logger&) {} inline void c11log::logger::_variadic_log(c11log::details::line_logger&) {}
@ -199,7 +206,8 @@ void c11log::logger::_variadic_log(c11log::details::line_logger& l, const First&
inline void c11log::logger::_log_msg(details::log_msg& msg) inline void c11log::logger::_log_msg(details::log_msg& msg)
{ {
_formatter->format(msg); auto& formatter = _formatter ? _formatter : logger::default_formatter();
formatter->format(msg);
for (auto &sink : _sinks) for (auto &sink : _sinks)
sink->log(msg); sink->log(msg);
} }

8
include/c11log/sinks/async_sink.h
View File

@ -27,8 +27,8 @@ public:
//Stop logging and join the back thread //Stop logging and join the back thread
~async_sink(); ~async_sink();
void add_sink(logger::sink_ptr sink); void add_sink(sink_ptr sink);
void remove_sink(logger::sink_ptr sink_ptr); void remove_sink(sink_ptr sink_ptr);
q_type& q(); q_type& q();
//Wait to remaining items (if any) in the queue to be written and shutdown //Wait to remaining items (if any) in the queue to be written and shutdown
void shutdown(const std::chrono::milliseconds& timeout); void shutdown(const std::chrono::milliseconds& timeout);
@ -90,14 +90,14 @@ inline void c11log::sinks::async_sink::_thread_loop()
} }
} }
inline void c11log::sinks::async_sink::add_sink(logger::sink_ptr s) inline void c11log::sinks::async_sink::add_sink(c11log::sink_ptr s)
{ {
std::lock_guard<std::mutex> guard(_mutex); std::lock_guard<std::mutex> guard(_mutex);
_sinks.push_back(s); _sinks.push_back(s);
} }
inline void c11log::sinks::async_sink::remove_sink(logger::sink_ptr s) inline void c11log::sinks::async_sink::remove_sink(c11log::sink_ptr s)
{ {
std::lock_guard<std::mutex> guard(_mutex); std::lock_guard<std::mutex> guard(_mutex);
_sinks.erase(std::remove(_sinks.begin(), _sinks.end(), s), _sinks.end()); _sinks.erase(std::remove(_sinks.begin(), _sinks.end(), s), _sinks.end());