danny
/
spdlog
mirror of https://github.com/gabime/spdlog.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

#1838 Factor out file rotation.

Browse Source 
Purpose to make the file rotation code reusable in new sink types.
pull/3112/head
Patrick Rotsaert 1 year ago
parent c3aed4b683
commit 3d91da64b0
7 changed files with 200 additions and 111 deletions
Show Stats Download Patch File Download Diff File

9
include/spdlog/details/file_helper-inl.h
Unescape Escape View File

@ -106,6 +106,15 @@ SPDLOG_INLINE void file_helper::write(const memory_buf_t &buf) {
}
}
SPDLOG_INLINE void file_helper::write(string_view_t buf) {
if (fd_ == nullptr) return;
size_t msg_size = buf.size();
auto data = buf.data();
if (std::fwrite(data, 1, msg_size, fd_) != msg_size) {
throw_spdlog_ex("Failed writing to file " + os::filename_to_str(filename_), errno);
}
}
SPDLOG_INLINE size_t file_helper::size() const {
if (fd_ == nullptr) {
throw_spdlog_ex("Cannot use size() on closed file " + os::filename_to_str(filename_));

1
include/spdlog/details/file_helper.h
Unescape Escape View File

@ -28,6 +28,7 @@ public:
void sync();
void close();
void write(const memory_buf_t &buf);
void write(string_view_t buf);
size_t size() const;
const filename_t &filename() const;

123
include/spdlog/details/rotating_file-inl.h
Unescape Escape View File

@ -0,0 +1,123 @@
// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#pragma once
#ifndef SPDLOG_HEADER_ONLY
#include <spdlog/details/rotating_file.h>
#endif
#include <spdlog/fmt/fmt.h>
#include <spdlog/details/file_helper.h>
namespace spdlog {
namespace details {
SPDLOG_INLINE rotating_file::rotating_file(filename_t base_filename,
std::size_t max_size,
std::size_t max_files,
bool rotate_on_open,
const file_event_handlers &event_handlers)
: base_filename_(std::move(base_filename)),
max_size_(max_size),
max_files_(max_files),
file_helper_{event_handlers} {
if (max_size == 0) {
throw_spdlog_ex("rotating sink constructor: max_size arg cannot be zero");
}
if (max_files > 200000) {
throw_spdlog_ex("rotating sink constructor: max_files arg cannot exceed 200000");
}
file_helper_.open(calc_filename(base_filename_, 0));
current_size_ = file_helper_.size(); // expensive. called only once
if (rotate_on_open && current_size_ > 0) {
rotate_();
current_size_ = 0;
}
}
SPDLOG_INLINE void rotating_file::write(const memory_buf_t &buf) {
write(string_view_t{buf.data(), buf.size()});
}
SPDLOG_INLINE void rotating_file::write(string_view_t buf) {
auto new_size = current_size_ + buf.size();
// rotate if the new estimated file size exceeds max size.
// rotate only if the real size > 0 to better deal with full disk (see issue #2261).
// we only check the real size when new_size > max_size_ because it is relatively expensive.
if (new_size > max_size_) {
file_helper_.flush();
if (file_helper_.size() > 0) {
rotate_();
new_size = buf.size();
}
}
file_helper_.write(buf);
current_size_ = new_size;
}
// Rotate files:
// log.txt -> log.1.txt
// log.1.txt -> log.2.txt
// log.2.txt -> log.3.txt
// log.3.txt -> delete
SPDLOG_INLINE void rotating_file::rotate_() {
using details::os::filename_to_str;
using details::os::path_exists;
file_helper_.close();
for (auto i = max_files_; i > 0; --i) {
filename_t src = calc_filename(base_filename_, i - 1);
if (!path_exists(src)) {
continue;
}
filename_t target = calc_filename(base_filename_, i);
if (!rename_file_(src, target)) {
// if failed try again after a small delay.
// this is a workaround to a windows issue, where very high rotation
// rates can cause the rename to fail with permission denied (because of antivirus?).
details::os::sleep_for_millis(100);
if (!rename_file_(src, target)) {
file_helper_.reopen(
true); // truncate the log file anyway to prevent it to grow beyond its limit!
current_size_ = 0;
throw_spdlog_ex("rotating_file_sink: failed renaming " + filename_to_str(src) +
" to " + filename_to_str(target),
errno);
}
}
}
file_helper_.reopen(true);
}
SPDLOG_INLINE void rotating_file::flush() { file_helper_.flush(); }
// calc filename according to index and file extension if exists.
// e.g. calc_filename("logs/mylog.txt, 3) => "logs/mylog.3.txt".
SPDLOG_INLINE filename_t rotating_file::calc_filename(const filename_t &filename,
std::size_t index) {
if (index == 0u) {
return filename;
}
filename_t basename, ext;
std::tie(basename, ext) = details::file_helper::split_by_extension(filename);
return fmt_lib::format(SPDLOG_FILENAME_T("{}.{}{}"), basename, index, ext);
}
SPDLOG_INLINE filename_t rotating_file::filename() const { return file_helper_.filename(); }
// delete the target if exists, and rename the src file to target
// return true on success, false otherwise.
SPDLOG_INLINE bool rotating_file::rename_file_(const filename_t &src_filename,
const filename_t &target_filename) {
// try to delete the target file in case it already exists.
(void)details::os::remove(target_filename);
return details::os::rename(src_filename, target_filename) == 0;
}
} // namespace details
} // namespace spdlog

58
include/spdlog/details/rotating_file.h
Unescape Escape View File

@ -0,0 +1,58 @@
// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#pragma once
#include <spdlog/common.h>
#include <spdlog/details/file_helper.h>
#include <tuple>
namespace spdlog {
namespace details {
class SPDLOG_API rotating_file {
public:
explicit rotating_file(filename_t base_filename,
std::size_t max_size,
std::size_t max_files,
bool rotate_on_open,
const file_event_handlers &event_handlers);
rotating_file(const rotating_file &) = delete;
rotating_file &operator=(const rotating_file &) = delete;
static filename_t calc_filename(const filename_t &filename, std::size_t index);
void write(const memory_buf_t &buf);
void write(string_view_t buf);
void flush();
filename_t filename() const;
private:
// Rotate files:
// log.txt -> log.1.txt
// log.1.txt -> log.2.txt
// log.2.txt -> log.3.txt
// log.3.txt -> delete
void rotate_();
// delete the target if exists, and rename the src file to target
// return true on success, false otherwise.
bool rename_file_(const filename_t &src_filename, const filename_t &target_filename);
filename_t base_filename_;
std::size_t max_size_;
std::size_t max_files_;
std::size_t current_size_;
file_helper file_helper_;
};
} // namespace details
} // namespace spdlog
#ifdef SPDLOG_HEADER_ONLY
#include "rotating_file-inl.h"
#endif

100
include/spdlog/sinks/rotating_file_sink-inl.h
Unescape Escape View File

@ -9,16 +9,11 @@
#include <spdlog/common.h>
#include <spdlog/details/file_helper.h>
#include <spdlog/details/rotating_file.h>
#include <spdlog/details/null_mutex.h>
#include <spdlog/fmt/fmt.h>
#include <cerrno>
#include <chrono>
#include <ctime>
#include <mutex>
#include <string>
#include <tuple>
namespace spdlog {
namespace sinks {
@ -30,114 +25,31 @@ SPDLOG_INLINE rotating_file_sink<Mutex>::rotating_file_sink(
std::size_t max_files,
bool rotate_on_open,
const file_event_handlers &event_handlers)
: base_filename_(std::move(base_filename)),
max_size_(max_size),
max_files_(max_files),
file_helper_{event_handlers} {
if (max_size == 0) {
throw_spdlog_ex("rotating sink constructor: max_size arg cannot be zero");
}
if (max_files > 200000) {
throw_spdlog_ex("rotating sink constructor: max_files arg cannot exceed 200000");
}
file_helper_.open(calc_filename(base_filename_, 0));
current_size_ = file_helper_.size(); // expensive. called only once
if (rotate_on_open && current_size_ > 0) {
rotate_();
current_size_ = 0;
}
}
: file_{base_filename, max_size, max_files, rotate_on_open, event_handlers} {}
// calc filename according to index and file extension if exists.
// e.g. calc_filename("logs/mylog.txt, 3) => "logs/mylog.3.txt".
template <typename Mutex>
SPDLOG_INLINE filename_t rotating_file_sink<Mutex>::calc_filename(const filename_t &filename,
std::size_t index) {
if (index == 0u) {
return filename;
}
filename_t basename, ext;
std::tie(basename, ext) = details::file_helper::split_by_extension(filename);
return fmt_lib::format(SPDLOG_FILENAME_T("{}.{}{}"), basename, index, ext);
return details::rotating_file::calc_filename(filename, index);
}
template <typename Mutex>
SPDLOG_INLINE filename_t rotating_file_sink<Mutex>::filename() {
std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
return file_helper_.filename();
return file_.filename();
}
template <typename Mutex>
SPDLOG_INLINE void rotating_file_sink<Mutex>::sink_it_(const details::log_msg &msg) {
memory_buf_t formatted;
base_sink<Mutex>::formatter_->format(msg, formatted);
auto new_size = current_size_ + formatted.size();
// rotate if the new estimated file size exceeds max size.
// rotate only if the real size > 0 to better deal with full disk (see issue #2261).
// we only check the real size when new_size > max_size_ because it is relatively expensive.
if (new_size > max_size_) {
file_helper_.flush();
if (file_helper_.size() > 0) {
rotate_();
new_size = formatted.size();
}
}
file_helper_.write(formatted);
current_size_ = new_size;
file_.write(formatted);
}
template <typename Mutex>
SPDLOG_INLINE void rotating_file_sink<Mutex>::flush_() {
file_helper_.flush();
}
// Rotate files:
// log.txt -> log.1.txt
// log.1.txt -> log.2.txt
// log.2.txt -> log.3.txt
// log.3.txt -> delete
template <typename Mutex>
SPDLOG_INLINE void rotating_file_sink<Mutex>::rotate_() {
using details::os::filename_to_str;
using details::os::path_exists;
file_helper_.close();
for (auto i = max_files_; i > 0; --i) {
filename_t src = calc_filename(base_filename_, i - 1);
if (!path_exists(src)) {
continue;
}
filename_t target = calc_filename(base_filename_, i);
if (!rename_file_(src, target)) {
// if failed try again after a small delay.
// this is a workaround to a windows issue, where very high rotation
// rates can cause the rename to fail with permission denied (because of antivirus?).
details::os::sleep_for_millis(100);
if (!rename_file_(src, target)) {
file_helper_.reopen(
true); // truncate the log file anyway to prevent it to grow beyond its limit!
current_size_ = 0;
throw_spdlog_ex("rotating_file_sink: failed renaming " + filename_to_str(src) +
" to " + filename_to_str(target),
errno);
}
}
}
file_helper_.reopen(true);
}
// delete the target if exists, and rename the src file to target
// return true on success, false otherwise.
template <typename Mutex>
SPDLOG_INLINE bool rotating_file_sink<Mutex>::rename_file_(const filename_t &src_filename,
const filename_t &target_filename) {
// try to delete the target file in case it already exists.
(void)details::os::remove(target_filename);
return details::os::rename(src_filename, target_filename) == 0;
file_.flush();
}
} // namespace sinks

19
include/spdlog/sinks/rotating_file_sink.h
Unescape Escape View File

@ -3,7 +3,7 @@
#pragma once
#include <spdlog/details/file_helper.h>
#include <spdlog/details/rotating_file.h>
#include <spdlog/details/null_mutex.h>
#include <spdlog/details/synchronous_factory.h>
#include <spdlog/sinks/base_sink.h>
@ -34,22 +34,7 @@ protected:
void flush_() override;
private:
// Rotate files:
// log.txt -> log.1.txt
// log.1.txt -> log.2.txt
// log.2.txt -> log.3.txt
// log.3.txt -> delete
void rotate_();
// delete the target if exists, and rename the src file to target
// return true on success, false otherwise.
bool rename_file_(const filename_t &src_filename, const filename_t &target_filename);
filename_t base_filename_;
std::size_t max_size_;
std::size_t max_files_;
std::size_t current_size_;
details::file_helper file_helper_;
details::rotating_file file_;
};
using rotating_file_sink_mt = rotating_file_sink<std::mutex>;

1
src/spdlog.cpp
Unescape Escape View File

@ -12,6 +12,7 @@
#include <spdlog/details/null_mutex.h>
#include <spdlog/details/os-inl.h>
#include <spdlog/details/registry-inl.h>
#include <spdlog/details/rotating_file-inl.h>
#include <spdlog/logger-inl.h>
#include <spdlog/pattern_formatter-inl.h>
#include <spdlog/sinks/base_sink-inl.h>

Write Preview
Loading…
Cancel
Save