tdlight/tdutils/test/log.cpp

188 lines
5.5 KiB
C++
Raw Normal View History

//
2024-01-01 01:07:21 +01:00
// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2024
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
2022-10-09 12:04:57 +02:00
#include "td/utils/AsyncFileLog.h"
#include "td/utils/benchmark.h"
2021-05-17 15:53:35 +02:00
#include "td/utils/CombinedLog.h"
#include "td/utils/FileLog.h"
#include "td/utils/format.h"
#include "td/utils/logging.h"
#include "td/utils/MemoryLog.h"
2021-05-18 16:06:22 +02:00
#include "td/utils/NullLog.h"
#include "td/utils/port/path.h"
#include "td/utils/port/thread.h"
#include "td/utils/Slice.h"
#include "td/utils/SliceBuilder.h"
#include "td/utils/tests.h"
#include "td/utils/TsFileLog.h"
2021-05-18 16:40:37 +02:00
#include "td/utils/TsLog.h"
#include <functional>
#include <limits>
char disable_linker_warning_about_empty_file_tdutils_test_log_cpp TD_UNUSED;
#if !TD_THREAD_UNSUPPORTED
template <class Log>
class LogBenchmark final : public td::Benchmark {
public:
LogBenchmark(std::string name, int threads_n, bool test_full_logging, std::function<td::unique_ptr<Log>()> creator)
: name_(std::move(name))
, threads_n_(threads_n)
, test_full_logging_(test_full_logging)
, creator_(std::move(creator)) {
}
2021-07-03 22:51:36 +02:00
std::string get_description() const final {
return PSTRING() << name_ << " " << (test_full_logging_ ? "ERROR" : "PLAIN") << " "
<< td::tag("threads_n", threads_n_);
}
2021-07-03 22:51:36 +02:00
void start_up() final {
log_ = creator_();
threads_.resize(threads_n_);
}
2021-07-03 22:51:36 +02:00
void tear_down() final {
if (log_ == nullptr) {
return;
}
2021-10-21 11:51:16 +02:00
for (const auto &path : log_->get_file_paths()) {
td::unlink(path).ignore();
}
log_.reset();
}
2021-07-03 22:51:36 +02:00
void run(int n) final {
auto old_log_interface = td::log_interface;
if (log_ != nullptr) {
td::log_interface = log_.get();
}
for (auto &thread : threads_) {
thread = td::thread([this, n] { this->run_thread(n); });
}
for (auto &thread : threads_) {
thread.join();
}
td::log_interface = old_log_interface;
}
void run_thread(int n) {
auto str = PSTRING() << "#" << n << " : fsjklfdjsklfjdsklfjdksl\n";
for (int i = 0; i < n; i++) {
if (i % 10000 == 0 && log_ != nullptr) {
log_->after_rotation();
}
if (test_full_logging_) {
LOG(ERROR) << str;
} else {
LOG(PLAIN) << str;
}
}
}
private:
std::string name_;
td::unique_ptr<td::LogInterface> log_;
int threads_n_{0};
bool test_full_logging_{false};
std::function<td::unique_ptr<Log>()> creator_;
std::vector<td::thread> threads_;
};
template <class F>
static void bench_log(std::string name, F &&f) {
for (auto test_full_logging : {false, true}) {
for (auto threads_n : {1, 4, 8}) {
bench(LogBenchmark<typename decltype(f())::element_type>(name, threads_n, test_full_logging, f));
}
}
2021-08-30 22:27:32 +02:00
}
TEST(Log, Bench) {
bench_log("NullLog", [] { return td::make_unique<td::NullLog>(); });
// bench_log("Default", []() -> td::unique_ptr<td::NullLog> { return nullptr; });
bench_log("MemoryLog", [] { return td::make_unique<td::MemoryLog<1 << 20>>(); });
2021-05-17 15:53:35 +02:00
bench_log("CombinedLogEmpty", [] { return td::make_unique<td::CombinedLog>(); });
bench_log("CombinedLogMemory", [] {
auto result = td::make_unique<td::CombinedLog>();
static td::NullLog null_log;
static td::MemoryLog<1 << 20> memory_log;
result->set_first(&null_log);
result->set_second(&memory_log);
result->set_first_verbosity_level(VERBOSITY_NAME(DEBUG));
result->set_second_verbosity_level(VERBOSITY_NAME(DEBUG));
return result;
});
bench_log("TsFileLog",
[] { return td::TsFileLog::create("tmplog", std::numeric_limits<td::int64>::max(), false).move_as_ok(); });
bench_log("FileLog + TsLog", [] {
class FileLog final : public td::LogInterface {
public:
FileLog() {
file_log_.init("tmplog", std::numeric_limits<td::int64>::max(), false).ensure();
ts_log_.init(&file_log_);
}
2021-05-17 15:18:19 +02:00
void do_append(int log_level, td::CSlice slice) final {
static_cast<td::LogInterface &>(ts_log_).do_append(log_level, slice);
}
2021-05-17 15:18:19 +02:00
std::vector<std::string> get_file_paths() final {
return file_log_.get_file_paths();
}
private:
td::FileLog file_log_;
td::TsLog ts_log_{nullptr};
};
return td::make_unique<FileLog>();
});
bench_log("FileLog", [] {
class FileLog final : public td::LogInterface {
public:
FileLog() {
file_log_.init("tmplog", std::numeric_limits<td::int64>::max(), false).ensure();
}
2021-05-17 15:18:19 +02:00
void do_append(int log_level, td::CSlice slice) final {
static_cast<td::LogInterface &>(file_log_).do_append(log_level, slice);
}
2021-05-17 15:18:19 +02:00
std::vector<std::string> get_file_paths() final {
return file_log_.get_file_paths();
}
private:
td::FileLog file_log_;
};
return td::make_unique<FileLog>();
});
2022-10-09 12:04:57 +02:00
#if !TD_EVENTFD_UNSUPPORTED
bench_log("AsyncFileLog", [] {
class AsyncFileLog final : public td::LogInterface {
public:
AsyncFileLog() {
2023-05-18 12:09:59 +02:00
file_log_.init("tmplog", std::numeric_limits<td::int64>::max(), false).ensure();
2022-10-09 12:04:57 +02:00
}
void do_append(int log_level, td::CSlice slice) final {
static_cast<td::LogInterface &>(file_log_).do_append(log_level, slice);
}
std::vector<std::string> get_file_paths() final {
return static_cast<td::LogInterface &>(file_log_).get_file_paths();
}
private:
td::AsyncFileLog file_log_;
};
return td::make_unique<AsyncFileLog>();
});
#endif
}
#endif