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

Simplified sink interface - to just accept char* and size_t

Browse Source
This commit is contained in:
gabi 2014-11-21 00:13:24 +02:00
parent a9abfbb005
commit 66039c7c0e
8 changed files with 60 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -82,10 +82,10 @@ public:
void reopen()
{
if(_filename.empty())
throw spdlog_ex("Failed re opening file - was not opened before");
open(_filename);
if(_filename.empty())
throw spdlog_ex("Failed re opening file - was not opened before");
open(_filename);
}
void close()
@ -97,11 +97,11 @@ public:
}
}
void write(const log_msg& msg)
void write(const char* data, size_t size)
{
auto& buf = msg.formatted.buf();
size_t size = buf.size();
if(std::fwrite(buf.data(), sizeof(char), size, _fd) != size)
if(std::fwrite(data, sizeof(char), size, _fd) != size)
throw spdlog_ex("Failed writing to file " + _filename);
if(--_flush_countdown == 0)

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

@ -184,7 +184,8 @@ inline void spdlog::logger::_variadic_log(spdlog::details::line_logger& l, const
inline void spdlog::logger::_log_msg(details::log_msg& msg)
{
_formatter->format(msg);
auto buf = msg.formatted.buf();
for (auto &sink : _sinks)
sink->log(msg);
sink->sink_it(buf.data(), buf.size());
}

51
include/spdlog/sinks/async_sink.h
View File

@ -53,7 +53,8 @@ namespace sinks
class async_sink : public base_sink < details::null_mutex >
{
public:
using q_type = details::blocking_queue < details::log_msg > ;
using data_type = std::pair < const char*, size_t > ;
using q_type = details::blocking_queue < data_type > ;
explicit async_sink(const q_type::size_type max_queue_size);
@ -68,7 +69,7 @@ public:
protected:
void _sink_it(const details::log_msg& msg) override;
void _sink_it(const char*, size_t) override;
void _thread_loop();
private:
@ -106,10 +107,12 @@ inline spdlog::sinks::async_sink::~async_sink()
_join();
}
inline void spdlog::sinks::async_sink::_sink_it(const details::log_msg& msg)
inline void spdlog::sinks::async_sink::_sink_it(const char* data, size_t size)
{
_push_sentry();
_q.push(msg);
auto data_copy = new char[size];
std::memcpy(data_copy, data, size);
_q.push(data_type(data_copy, size));
}
@ -120,31 +123,35 @@ inline void spdlog::sinks::async_sink::_thread_loop()
while (_active)
{
q_type::item_type msg;
if (_q.pop(msg, pop_timeout))
if (!_q.pop(msg, pop_timeout))
continue;
if (!_active)
return;
for (auto &s : _sinks)
{
if (!_active)
return;
for (auto &s : _sinks)
try
{
try
{
s->log(msg);
}
catch (const std::exception& ex)
{
_last_backthread_ex = std::make_shared<spdlog_ex>(ex.what());
}
catch (...)
{
_last_backthread_ex = std::make_shared<spdlog_ex>("Unknown exception");
}
s->sink_it(msg.first, msg.second);
}
catch (const std::exception& ex)
{
_last_backthread_ex = std::make_shared<spdlog_ex>(ex.what());
}
catch (...)
{
_last_backthread_ex = std::make_shared<spdlog_ex>("Unknown exception");
}
}
delete[] msg.first;
}
}
inline void spdlog::sinks::async_sink::add_sink(spdlog::sink_ptr s)
{
std::lock_guard<std::mutex> guard(_mutex);

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

@ -52,15 +52,15 @@ public:
base_sink(const base_sink&) = delete;
base_sink& operator=(const base_sink&) = delete;
void log(const details::log_msg& msg) override
void sink_it(const char* data, size_t size) override
{
std::lock_guard<Mutex> lock(_mutex);
_sink_it(msg);
_sink_it(data, size);
};
protected:
virtual void _sink_it(const details::log_msg& msg) = 0;
virtual void _sink_it(const char* data, size_t size) = 0;
Mutex _mutex;
};
}

28
include/spdlog/sinks/file_sinks.h
View File

@ -52,9 +52,9 @@ public:
}
protected:
void _sink_it(const details::log_msg& msg) override
void _sink_it(const char* data, size_t size) override
{
_file_helper.write(msg);
_file_helper.write(data, size);
}
private:
details::file_helper _file_helper;
@ -85,15 +85,15 @@ public:
protected:
void _sink_it(const details::log_msg& msg) override
void _sink_it(const char* data, size_t size) override
{
_current_size += msg.formatted.size();
_current_size += size;
if (_current_size > _max_size)
{
_rotate();
_current_size = msg.formatted.size();
_current_size = size;
}
_file_helper.write(msg);
_file_helper.write(data, size);
}
@ -125,12 +125,12 @@ private:
std::string target = calc_filename(_base_filename, i, _extension);
if (details::file_helper::file_exists(target))
{
if (std::remove(target.c_str()) != 0)
{
throw spdlog_ex("rotating_file_sink: failed removing " + target);
}
}
{
if (std::remove(target.c_str()) != 0)
{
throw spdlog_ex("rotating_file_sink: failed removing " + target);
}
}
if (details::file_helper::file_exists(src) && std::rename(src.c_str(), target.c_str()))
{
throw spdlog_ex("rotating_file_sink: failed renaming " + src + " to " + target);
@ -169,7 +169,7 @@ public:
protected:
void _sink_it(const details::log_msg& msg) override
void _sink_it(const char* data, size_t size) override
{
if (std::chrono::system_clock::now() >= _midnight_tp)
{
@ -177,7 +177,7 @@ protected:
_file_helper.open(calc_filename(_base_filename, _extension));
_midnight_tp = _calc_midnight_tp();
}
_file_helper.write(msg);
_file_helper.write(data, size);
}
private:

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

@ -37,7 +37,7 @@ template <class Mutex>
class null_sink : public base_sink < Mutex >
{
protected:
void _sink_it(const details::log_msg&) override
void _sink_it(const char*, size_t) override
{}
};

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

@ -45,10 +45,9 @@ public:
virtual ~ostream_sink() = default;
protected:
virtual void _sink_it(const details::log_msg& msg) override
void _sink_it(const char* data, size_t size) override
{
auto& buf = msg.formatted.buf();
_ostream.write(buf.data(), buf.size());
_ostream.write(data, size);
}
std::ostream& _ostream;
};

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

@ -24,7 +24,6 @@
#pragma once
#include "../details/log_msg.h"
namespace spdlog
{
@ -34,7 +33,7 @@ class sink
{
public:
virtual ~sink() {}
virtual void log(const details::log_msg& msg) = 0;
virtual void sink_it(const char* data, size_t size) = 0;
};
}
}