mirrors/spdlog
1
0
Fork 0
mirror of https://github.com/gabime/spdlog.git synced 2024-12-24 09:31:34 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Added registry

Browse Source
This commit is contained in:
gabi 2014-10-24 18:01:11 +03:00
parent 319db7bccc
commit 796ec3db89
9 changed files with 160 additions and 161 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
c11logtest/c11logtest/c11logtest.vcxproj
View File

@ -95,8 +95,8 @@
<ClInclude Include="..\..\include\c11log\details\null_mutex.h" />
<ClInclude Include="..\..\include\c11log\details\os.h" />
<ClInclude Include="..\..\include\c11log\details\pattern_formatter.h" />
<ClInclude Include="..\..\include\c11log\details\registry.h" />
<ClInclude Include="..\..\include\c11log\details\stack_buf.h" />
<ClInclude Include="..\..\include\c11log\factory.h" />
<ClInclude Include="..\..\include\c11log\formatter.h" />
<ClInclude Include="..\..\include\c11log\logger.h" />
<ClInclude Include="..\..\include\c11log\sinks\async_sink.h" />
@ -114,6 +114,9 @@
<ClCompile Include="..\..\example\example.cpp" />
<ClCompile Include="stdafx.cpp" />
</ItemGroup>
<ItemGroup>
<None Include="ClassDiagram.cd" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>

9
c11logtest/c11logtest/c11logtest.vcxproj.filters
View File

@ -84,9 +84,6 @@
<ClInclude Include="..\..\include\c11log\common.h">
<Filter>Header Files\c11log</Filter>
</ClInclude>
<ClInclude Include="..\..\include\c11log\factory.h">
<Filter>Header Files\c11log</Filter>
</ClInclude>
<ClInclude Include="..\..\include\c11log\details\fast_istostr.h">
<Filter>Header Files\c11log\details</Filter>
</ClInclude>
@ -96,6 +93,9 @@
<ClInclude Include="..\..\include\c11log\details\pattern_formatter.h">
<Filter>Header Files\c11log\details</Filter>
</ClInclude>
<ClInclude Include="..\..\include\c11log\details\registry.h">
<Filter>Header Files\c11log</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="stdafx.cpp">
@ -108,4 +108,7 @@
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<None Include="ClassDiagram.cd" />
</ItemGroup>
</Project>

43
example/bench.cpp
View File

@ -2,63 +2,40 @@
//
#include <mutex>
#include "c11log/logger.h"
#include "c11log/factory.h"
#include "c11log/sinks/async_sink.h"
#include "c11log/sinks/file_sinks.h"
#include "c11log/sinks/stdout_sinks.h"
#include "c11log/sinks/null_sink.h"
#include "utils.h"
#include "c11log/details/registry.h"
using namespace std::chrono;
using namespace c11log;
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[])
{
const unsigned int howmany = argc <= 1 ? 600000 : atoi(argv[1]);
const std::string 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::default_formatter(formatter);
cout_logger.info() << "Hello logger " << 12.4 << 5 << ',' << 6 << 7 <<8<<9<<10;
auto nullsink = std::make_shared<sinks::null_sink_st>();
auto rotating = std::make_shared<sinks::rotating_file_sink_st>("myrotating", "txt", 1024 * 1024 * 5, 20, 100);
logger my_logger("my_logger", { nullsink });
auto console = c11log::create<sinks::stderr_sink_st>("reporter");
console->set_format("[%n %l] %t");
console->set_level(c11log::level::INFO);
console->info("Starting bench with", howmany, "iterations..");
auto bench = c11log::create<sinks::rotating_file_sink_st>("bench", "myrotating", "txt", 1024 * 1024 * 5, 3, 100);
auto start = system_clock::now();
for (unsigned int i = 1; i <= howmany; ++i)
{
my_logger.info() << "Hello logger: msg #" << i;
bench->info() << "Hello logger: msg number " << i;
}
auto delta = system_clock::now() - start;
auto delta_d = duration_cast<duration<double>> (delta).count();
cout_logger.info("Total:") << format(howmany);
cout_logger.info("Delta:") << format(delta_d);
cout_logger.info("Rate:") << format(howmany / delta_d) << "/sec";
console->info("Total:") << format(howmany);
console->info("Delta:") << format(delta_d);
console->info("Rate:") << format(howmany / delta_d) << "/sec";
return 0;
}

1
example/example.cpp
View File

@ -4,7 +4,6 @@
#include <iostream>
#include "c11log/logger.h"
#include "c11log/factory.h"
#include "c11log/sinks/stdout_sinks.h"
#include "c11log/sinks/file_sinks.h"
using namespace std;

4
include/c11log/common.h
View File

@ -25,8 +25,8 @@ typedef enum
TRACE,
DEBUG,
INFO,
WARNING,
ERROR,
WARN,
ERR,
CRITICAL,
NONE = 99
} level_enum;

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

@ -19,7 +19,9 @@ public:
virtual void format(details::log_msg& msg) = 0;
};
// log name appender
///////////////////////////////////////////////////////////////////////
// name & level pattern appenders
///////////////////////////////////////////////////////////////////////
class name_formatter :public flag_formatter
{
void format(details::log_msg& msg) override

59
include/c11log/details/registry.h Normal file
View File

@ -0,0 +1,59 @@
#pragma once
// Loggers registy of unique name->logger pointer
// If 2 loggers with same name are added, the last will be used
// If user requests a non existing logger, nullptr will be returned
// This class is thread safe
#include <string>
#include <mutex>
#include <unordered_map>
#include "../logger.h"
#include "../common.h"
namespace c11log {
namespace details {
class registry {
public:
std::shared_ptr<logger> get(const std::string& name)
{
std::lock_guard<std::mutex> l(_mutex);
auto found = _loggers.find(name);
return found == _loggers.end() ? nullptr : found->second;
}
std::shared_ptr<logger> create(const std::string& logger_name, sinks_init_list sinks)
{
std::lock_guard<std::mutex> l(_mutex);
return _loggers[logger_name] = std::make_shared<logger>(logger_name, sinks);
}
std::shared_ptr<logger> create(const std::string& logger_name, sink_ptr sink)
{
create(logger_name, { sink });
}
template<class It>
std::shared_ptr<logger> create (const std::string& logger_name, const It& sinks_begin, const It& sinks_end)
{
std::lock_guard<std::mutex> l(_mutex);
return _loggers[logger_name] = std::make_shared<logger>(logger_name, sinks_begin, sinks_end);
}
static registry& instance()
{
static registry s_instance;
return s_instance;
}
private:
registry() = default;
registry(const registry&) = delete;
std::mutex _mutex;
std::unordered_map <std::string, std::shared_ptr<logger>> _loggers;
};
}
}

106
include/c11log/factory.h
View File

@ -1,106 +0,0 @@
#pragma once
#include <memory>
#include "logger.h"
#include "sinks/file_sinks.h"
#include "sinks/stdout_sinks.h"
//
// logger creation shotcuts
//
namespace c11log
{
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 = "")
//{
// auto sink = std::make_shared<sinks::stderr_sink_st>();
// return std::unique_ptr<logger>(new logger(name, { sink }));
//}
//
//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 }));
//}
//
////
//// simple file logger single/multi threaded
////
//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);
// return std::unique_ptr<logger>(new c11log::logger(logger_name, { fsink }));
//
//}
//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 }));
//}
//
////
//// daily file logger single/multi threaded
////
//std::unique_ptr<logger> daily_file_logger(
// 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_st>(filename, extension, flush_every);
// return std::unique_ptr<logger>(new c11log::logger(logger_name, { fsink }));
//}
//
//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 }));
//}
//
////
//// rotating file logger single/multi threaded
////
//std::unique_ptr<logger> rotating_file_logger(
// const std::string &filename,
// const std::string &extension,
// const std::size_t max_size,
// const std::size_t max_files,
// const std::size_t flush_every,
// const std::string& logger_name = "")
//{
// auto fsink = std::make_shared<sinks::rotating_file_sink_st>(filename, extension, max_size, max_files, flush_every);
// return std::unique_ptr<logger>(new c11log::logger(logger_name, { fsink }));
//}
//
//std::unique_ptr<logger> rotating_file_logger_mt(
// const std::string &filename,
// const std::string &extension,
// const std::size_t max_size,
// const std::size_t max_files,
// const std::size_t flush_every,
// 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 c11log

90
include/c11log/logger.h
View File

@ -16,6 +16,7 @@
#include "common.h"
#include "details/pattern_formatter.h"
namespace c11log
{
@ -32,20 +33,15 @@ public:
template<class It>
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 c11log::logger::set_format(const std::string& format);
void set_formatter(formatter_ptr);
formatter_ptr get_formatter() const;
logger(const logger&) = delete;
logger& operator=(const logger&) = delete;
void level(level::level_enum);
void set_level(level::level_enum);
level::level_enum level() const;
const std::string& name() const;
@ -59,6 +55,11 @@ public:
template <typename... Args> details::line_logger error(const Args&... args);
template <typename... Args> details::line_logger critical(const Args&... args);
//static functions
//get/set default formatter
static formatter_ptr default_formatter(formatter_ptr formatter = nullptr);
static formatter_ptr default_format(const std::string& format);
private:
friend details::line_logger;
std::string _name;
@ -70,10 +71,27 @@ private:
void _variadic_log(details::line_logger&l, const First& first, const Rest&... rest);
void _log_msg(details::log_msg& msg);
};
//
// Registry functions for easy loggers creation and retrieval
// example
// auto console_logger = c11log::create("my_logger", c11log::sinks<stdout_sink_mt>);
// auto same_logger = c11log::get("my_logger");
// auto file_logger = c11
//
std::shared_ptr<logger> get(const std::string& name);
std::shared_ptr<logger> create(const std::string& logger_name, sinks_init_list sinks);
template <typename Sink, typename... Args>
std::shared_ptr<c11log::logger> create(const std::string& logger_name, const Args&... args);
template<class It>
std::shared_ptr<logger> create(const std::string& logger_name, const It& sinks_begin, const It& sinks_end);
}
//
// trace & debug macros
// Trace & debug macros
//
#ifdef FFLOG_ENABLE_TRACE
#define FFLOG_TRACE(logger, ...) logger->log(c11log::level::TRACE, __FILE__, " #", __LINE__,": " __VA_ARGS__)
@ -114,12 +132,17 @@ inline void c11log::logger::set_formatter(c11log::formatter_ptr msg_formatter)
_formatter = msg_formatter;
}
inline void c11log::logger::set_format(const std::string& format)
{
_formatter = std::make_shared<details::pattern_formatter>(format);
}
inline c11log::formatter_ptr c11log::logger::get_formatter() const
{
return _formatter;
}
inline c11log::formatter_ptr& c11log::logger::default_formatter(formatter_ptr 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)
@ -127,6 +150,11 @@ inline c11log::formatter_ptr& c11log::logger::default_formatter(formatter_ptr fo
return g_default_formatter;
}
inline c11log::formatter_ptr c11log::logger::default_format(const std::string& format)
{
return default_formatter(std::make_shared<details::pattern_formatter>(format));
}
template <typename... Args>
inline c11log::details::line_logger c11log::logger::log(level::level_enum lvl, const Args&... args) {
bool msg_enabled = should_log(lvl);
@ -157,13 +185,13 @@ inline c11log::details::line_logger c11log::logger::info(const Args&... args)
template <typename... Args>
inline c11log::details::line_logger c11log::logger::warn(const Args&... args)
{
return log(level::WARNING, args...);
return log(level::WARN, args...);
}
template <typename... Args>
inline c11log::details::line_logger c11log::logger::error(const Args&... args)
{
return log(level::ERROR, args...);
return log(level::ERR, args...);
}
template <typename... Args>
@ -177,7 +205,7 @@ inline const std::string& c11log::logger::name() const
return _name;
}
inline void c11log::logger::level(c11log::level::level_enum log_level)
inline void c11log::logger::set_level(c11log::level::level_enum log_level)
{
_level.store(log_level);
}
@ -201,15 +229,49 @@ template <typename First, typename... Rest>
void c11log::logger::_variadic_log(c11log::details::line_logger& l, const First& first, const Rest&... rest)
{
l.write(first);
l.write(' ');
_variadic_log(l, rest...);
}
inline void c11log::logger::_log_msg(details::log_msg& msg)
{
auto& formatter = _formatter ? _formatter : logger::default_formatter();
formatter->format(msg);
if(!_formatter)
_formatter = logger::default_formatter();
_formatter->format(msg);
for (auto &sink : _sinks)
sink->log(msg);
}
//
// Global registry functions
//
#include "details/registry.h"
inline std::shared_ptr<c11log::logger> c11log::get(const std::string& name)
{
return details::registry::instance().get(name);
}
inline std::shared_ptr<c11log::logger> c11log::create(const std::string& logger_name, c11log::sinks_init_list sinks)
{
return details::registry::instance().create(logger_name, sinks);
}
template <typename Sink, typename... Args>
inline std::shared_ptr<c11log::logger> c11log::create(const std::string& logger_name, const Args&... args)
{
sink_ptr sink = std::make_shared<Sink>(args...);
return details::registry::instance().create(logger_name, { sink });
}
template<class It>
inline std::shared_ptr<c11log::logger> c11log::create(const std::string& logger_name, const It& sinks_begin, const It& sinks_end)
{
std::lock_guard<std::mutex> l(_mutex);
return details::registry::instance().create(logger_name, std::forward(sinks_begin), std::forward(sinks_end));
}