spdlog/include/c11log/sinks/file_sinks.h

166 lines
4.6 KiB
C
Raw Normal View History

2014-01-25 04:09:04 -05:00
#pragma once
2014-01-25 08:52:10 -05:00
2014-01-25 04:09:04 -05:00
#include <fstream>
#include <iomanip>
2014-01-25 18:53:23 -05:00
#include <mutex>
2014-01-25 04:09:04 -05:00
#include "base_sink.h"
namespace c11log {
namespace sinks {
/*
* Trivial file sink with single file as target
*/
2014-01-25 18:53:23 -05:00
class simple_file_sink : public base_sink {
2014-01-25 04:09:04 -05:00
public:
simple_file_sink(const std::string &filename, const std::string& extension = "txt")
{
std::ostringstream oss;
oss << filename << "." << extension;
_ofstream.open(oss.str(), std::ofstream::app);
}
protected:
2014-01-25 08:52:10 -05:00
void sink_it_(const std::string& msg) override
2014-01-25 04:09:04 -05:00
{
2014-01-25 18:53:23 -05:00
std::lock_guard<std::mutex> lock(mutex_);
2014-01-25 04:09:04 -05:00
_ofstream << msg;
_ofstream.flush();
}
2014-01-25 18:53:23 -05:00
private:
std::mutex mutex_;
2014-01-25 04:09:04 -05:00
std::ofstream _ofstream;
};
2014-01-25 18:53:23 -05:00
2014-01-25 04:09:04 -05:00
/*
2014-01-25 18:53:23 -05:00
* Thread safe, size limited file sink
*/
class rotating_file_sink : public base_sink {
2014-01-25 04:09:04 -05:00
public:
rotating_file_sink(const std::string &base_filename, const std::string &extension, size_t max_size, size_t max_files):
_base_filename(base_filename),
_extension(extension),
_max_size(max_size),
_max_files(max_files),
_current_size(0),
_index(0)
{
_ofstream.open(_calc_filename(_base_filename, 0, _extension));
}
protected:
2014-01-25 18:53:23 -05:00
void sink_it_(const std::string& msg) override
2014-01-25 04:09:04 -05:00
{
2014-01-25 18:53:23 -05:00
std::lock_guard<std::mutex> lock(mutex_);
2014-01-25 04:09:04 -05:00
_current_size += msg.length();
2014-01-25 18:53:23 -05:00
if (_current_size > _max_size)
{
_rotate();
_current_size = msg.length();
}
_ofstream << msg;
_ofstream.flush();
2014-01-25 04:09:04 -05:00
}
2014-01-25 18:53:23 -05:00
private:
static std::string _calc_filename(const std::string& filename, std::size_t index, const std::string& extension)
2014-01-25 04:09:04 -05:00
{
2014-01-25 18:53:23 -05:00
std::ostringstream oss;
if (index)
oss << filename << "." << index << "." << extension;
else
oss << filename << "." << extension;
return oss.str();
2014-01-25 04:09:04 -05:00
}
2014-01-25 18:53:23 -05:00
2014-01-25 04:09:04 -05:00
// Rotate old files:
// log.n-1.txt -> log.n.txt
// log n-2.txt -> log.n-1.txt
// ...
// log.txt -> log.1.txt
2014-01-25 18:53:23 -05:00
void _rotate()
2014-01-25 04:09:04 -05:00
{
_ofstream.close();
//Remove oldest file
for (auto i = _max_files; i > 0; --i) {
auto src = _calc_filename(_base_filename, i - 1, _extension);
auto target = _calc_filename(_base_filename, i, _extension);
if (i == _max_files)
std::remove(target.c_str());
std::rename(src.c_str(), target.c_str());
}
_ofstream.open(_calc_filename(_base_filename, 0, _extension));
}
2014-01-25 18:53:23 -05:00
2014-01-25 04:09:04 -05:00
std::string _base_filename;
std::string _extension;
std::size_t _max_size;
std::size_t _max_files;
std::size_t _current_size;
std::size_t _index;
2014-01-25 18:53:23 -05:00
std::ofstream _ofstream;
std::mutex mutex_;
2014-01-25 04:09:04 -05:00
};
/*
2014-01-25 18:53:23 -05:00
* Thread safe file sink that closes the log file at midnight and opens new one
2014-01-25 04:09:04 -05:00
*/
2014-01-25 18:53:23 -05:00
class midnight_file_sink:public base_sink {
2014-01-25 04:09:04 -05:00
public:
2014-01-25 10:28:56 -05:00
midnight_file_sink(const std::string& base_filename, const std::string& extension = "txt"):
2014-01-25 04:09:04 -05:00
_base_filename(base_filename),
_extension(extension),
_midnight_tp { _calc_midnight_tp() }
{
_ofstream.open(_calc_filename(_base_filename, _extension));
}
protected:
2014-01-25 18:53:23 -05:00
void sink_it_(const std::string& msg) override
2014-01-25 04:09:04 -05:00
{
2014-01-25 18:53:23 -05:00
std::lock_guard<std::mutex> lock(mutex_);
if (std::chrono::system_clock::now() >= _midnight_tp)
{
_ofstream.close();
_ofstream.open(_calc_filename(_base_filename, _extension));
_midnight_tp = _calc_midnight_tp();
}
_ofstream << msg;
_ofstream.flush();
2014-01-25 04:09:04 -05:00
}
private:
// Return next midnight's time_point
static std::chrono::system_clock::time_point _calc_midnight_tp()
{
using namespace std::chrono;
auto now = system_clock::now();
time_t tnow = std::chrono::system_clock::to_time_t(now);
tm date = c11log::details::os::localtime(tnow);
date.tm_hour = date.tm_min = date.tm_sec = 0;
auto midnight = std::chrono::system_clock::from_time_t(std::mktime(&date));
return system_clock::time_point(midnight + hours(24));
}
static std::string _calc_filename(const std::string& basename, const std::string& extension)
{
2014-01-27 04:44:10 -05:00
std::tm tm = c11log::details::os::localtime();
char buf[32];
2014-01-27 06:03:16 -05:00
sprintf(buf, ".%d-%02d-%02d.", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);
2014-01-27 06:07:17 -05:00
return basename+buf+extension;
2014-01-25 04:09:04 -05:00
}
2014-01-25 18:53:23 -05:00
2014-01-25 04:09:04 -05:00
std::string _base_filename;
std::string _extension;
std::chrono::system_clock::time_point _midnight_tp;
2014-01-25 18:53:23 -05:00
std::ofstream _ofstream;
std::mutex mutex_;
2014-01-25 04:09:04 -05:00
};
}
2014-01-27 04:44:10 -05:00
}