Skip to content

MINIFICPP-2256 Remove LoggerConfiguration::newInstance #2102

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
fgerlits wants to merge 1 commit into
base: main
Choose a base branch
from
+47 −53
Open

MINIFICPP-2256 Remove LoggerConfiguration::newInstance #2102

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
9 changes: 1 addition & 8 deletions libminifi/include/core/logging/LoggerConfiguration.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -71,15 +71,9 @@ class LoggerConfiguration {
friend class ::LogTestController;

public:
/**
* Gets the current log configuration
*/
LoggerConfiguration(); // used in some tests only
static LoggerConfiguration& getConfiguration();

static std::unique_ptr<LoggerConfiguration> newInstance() {
return std::unique_ptr<LoggerConfiguration>(new LoggerConfiguration()); // NOLINT(modernize-make-unique, cppcoreguidelines-owning-memory
}

void disableLogging() {
controller_->setEnabled(false);
}
Expand Down Expand Up @@ -163,7 +157,6 @@ class LoggerConfiguration {

static std::shared_ptr<spdlog::sinks::rotating_file_sink_mt> getRotatingFileSink(const std::string& appender_key, const std::shared_ptr<LoggerProperties>& properties);

LoggerConfiguration();
internal::CompressionManager compression_manager_;
std::shared_ptr<internal::LoggerNamespace> root_namespace_;

Expand Down
7 changes: 4 additions & 3 deletions libminifi/test/libtest/unit/TestBase.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -158,8 +158,9 @@ void LogTestController::reset() {
setLevel(name, spdlog::level::err);
}
modified_loggers.clear();
if (config)
config = logging::LoggerConfiguration::newInstance();
if (config) {
config = std::make_unique<logging::LoggerConfiguration>();
}
my_properties_ = std::make_shared<logging::LoggerProperties>("");
clear();
init(nullptr);
Expand Down Expand Up @@ -195,7 +196,7 @@ void LogTestController::init(const std::shared_ptr<logging::LoggerProperties>& l
logging::LoggerConfiguration::getConfiguration().initialize(my_properties_);
logger_ = logging::LoggerConfiguration::getConfiguration().getLogger(minifi::core::className<LogTestController>());
} else {
config = logging::LoggerConfiguration::newInstance();
config = std::make_unique<logging::LoggerConfiguration>();
// create for test purposes. most tests use the main logging factory, but this exists to test the logging
// framework itself.
config->initialize(my_properties_);
Expand Down
84 changes: 42 additions & 42 deletions libminifi/test/unit/LoggerTests.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -228,7 +228,7 @@ class LoggerTestAccessor {
};

TEST_CASE("Test Compression", "[ttl9]") {
auto log_config = logging::LoggerConfiguration::newInstance();
logging::LoggerConfiguration log_config;
auto properties = std::make_shared<logging::LoggerProperties>("");
std::string className;
SECTION("Using root logger") {
Expand All @@ -241,38 +241,38 @@ TEST_CASE("Test Compression", "[ttl9]") {
properties->set("appender.null", "null");
properties->set("logger." + className, "INFO,null");
}
log_config->initialize(properties);
auto logger = log_config->getLogger(className);
log_config.initialize(properties);
auto logger = log_config.getLogger(className);
logger->log_error("Hi there");

REQUIRE(LoggerTestAccessor::waitForCompressionToHappen(*log_config));
auto compressed_logs = LoggerTestAccessor::getCompressedLogs(*log_config);
REQUIRE(LoggerTestAccessor::waitForCompressionToHappen(log_config));
auto compressed_logs = LoggerTestAccessor::getCompressedLogs(log_config);
REQUIRE(compressed_logs.size() == 1);
auto logs = decompress(compressed_logs[0]);
REQUIRE(logs.find("Hi there") != std::string::npos);
}

TEST_CASE("Test Compression cache overflow is discarded intermittently", "[ttl10]") {
auto log_config = logging::LoggerConfiguration::newInstance();
logging::LoggerConfiguration log_config;
auto properties = std::make_shared<logging::LoggerProperties>("");
properties->set(logging::internal::CompressionManager::compression_cached_log_max_size_, "10 KB");
LoggerTestAccessor::setCompressionCacheSegmentSize(*log_config, 1_KiB);
LoggerTestAccessor::setCompressionCacheSegmentSize(log_config, 1_KiB);
std::string className = "CompressionTestCacheCleaned";
// by default the root logger is OFF
properties->set("logger.root", "INFO");
log_config->initialize(properties);
auto logger = log_config->getLogger(className);
log_config.initialize(properties);
auto logger = log_config.getLogger(className);
for (size_t idx = 0; idx < 10000; ++idx) {
logger->log_error("Hi there");
}
bool cache_shrunk = minifi::test::utils::verifyEventHappenedInPollTime(std::chrono::seconds{1}, [&] {
return LoggerTestAccessor::getUncompressedSize(*log_config) <= 10_KiB;
return LoggerTestAccessor::getUncompressedSize(log_config) <= 10_KiB;
});
REQUIRE(cache_shrunk);
}

TEST_CASE("Setting either properties to 0 disables in-memory compressed logs", "[ttl11]") {
auto log_config = logging::LoggerConfiguration::newInstance();
logging::LoggerConfiguration log_config;
auto properties = std::make_shared<logging::LoggerProperties>("");
bool is_empty = false;
SECTION("Cached log size is set to 0") {
Expand All @@ -289,70 +289,70 @@ TEST_CASE("Setting either properties to 0 disables in-memory compressed logs", "
}
// by default the root logger is OFF
properties->set("logger.root", "INFO");
log_config->initialize(properties);
auto logger = log_config->getLogger("DisableCompressionTestLogger");
log_config.initialize(properties);
auto logger = log_config.getLogger("DisableCompressionTestLogger");
logger->log_error("Hi there");

REQUIRE(LoggerTestAccessor::waitForCompressionToHappen(*log_config));
auto compressed_logs = LoggerTestAccessor::getCompressedLogs(*log_config);
REQUIRE(LoggerTestAccessor::waitForCompressionToHappen(log_config));
auto compressed_logs = LoggerTestAccessor::getCompressedLogs(log_config);
REQUIRE(compressed_logs.empty() == is_empty);
}

TEST_CASE("Setting max log entry length property trims long log entries", "[ttl12]") {
auto log_config = logging::LoggerConfiguration::newInstance();
logging::LoggerConfiguration log_config;
auto properties = std::make_shared<logging::LoggerProperties>("");
properties->set("max.log.entry.length", "2");
properties->set("logger.root", "INFO");
log_config->initialize(properties);
auto logger = log_config->getLogger("SetMaxLogEntryLengthTestLogger");
log_config.initialize(properties);
auto logger = log_config.getLogger("SetMaxLogEntryLengthTestLogger");
logger->log_error("Hi there");

REQUIRE(LoggerTestAccessor::waitForCompressionToHappen(*log_config));
auto compressed_logs = LoggerTestAccessor::getCompressedLogs(*log_config);
REQUIRE(LoggerTestAccessor::waitForCompressionToHappen(log_config));
auto compressed_logs = LoggerTestAccessor::getCompressedLogs(log_config);
REQUIRE(compressed_logs.size() == 1);
auto logs = decompress(compressed_logs[0]);
REQUIRE(logs.find("Hi ") == std::string::npos);
REQUIRE(logs.find("Hi") != std::string::npos);
}

TEST_CASE("Setting max log entry length property trims long formatted log entries", "[ttl13]") {
auto log_config = logging::LoggerConfiguration::newInstance();
logging::LoggerConfiguration log_config;
auto properties = std::make_shared<logging::LoggerProperties>("");
properties->set("max.log.entry.length", "2");
properties->set("logger.root", "INFO");
log_config->initialize(properties);
auto logger = log_config->getLogger("SetMaxLogEntryLengthInFormattedTestLogger");
log_config.initialize(properties);
auto logger = log_config.getLogger("SetMaxLogEntryLengthInFormattedTestLogger");
logger->log_error("Hi there {}", "John");

REQUIRE(LoggerTestAccessor::waitForCompressionToHappen(*log_config));
auto compressed_logs = LoggerTestAccessor::getCompressedLogs(*log_config);
REQUIRE(LoggerTestAccessor::waitForCompressionToHappen(log_config));
auto compressed_logs = LoggerTestAccessor::getCompressedLogs(log_config);
REQUIRE(compressed_logs.size() == 1);
auto logs = decompress(compressed_logs[0]);
REQUIRE(logs.find("Hi ") == std::string::npos);
REQUIRE(logs.find("Hi") != std::string::npos);
}

TEST_CASE("Setting max log entry length to a size larger than the internal buffer size", "[ttl14]") {
auto log_config = logging::LoggerConfiguration::newInstance();
logging::LoggerConfiguration log_config;
auto properties = std::make_shared<logging::LoggerProperties>("");
properties->set("max.log.entry.length", "1500");
properties->set("logger.root", "INFO");
log_config->initialize(properties);
auto logger = log_config->getLogger("SetMaxLogEntryLengthToLargerThanBufferSizeTestLogger");
log_config.initialize(properties);
auto logger = log_config.getLogger("SetMaxLogEntryLengthToLargerThanBufferSizeTestLogger");
std::string log(2000, 'a');
std::string expected_log(1500, 'a');
logger->log_error("{}", log);

REQUIRE(LoggerTestAccessor::waitForCompressionToHappen(*log_config));
auto compressed_logs = LoggerTestAccessor::getCompressedLogs(*log_config);
REQUIRE(LoggerTestAccessor::waitForCompressionToHappen(log_config));
auto compressed_logs = LoggerTestAccessor::getCompressedLogs(log_config);
REQUIRE(compressed_logs.size() == 1);
auto logs = decompress(compressed_logs[0]);
REQUIRE(logs.find(log) == std::string::npos);
REQUIRE(logs.find(expected_log) != std::string::npos);
}

TEST_CASE("Setting max log entry length to unlimited results in unlimited log entry size", "[ttl15]") {
auto log_config = logging::LoggerConfiguration::newInstance();
logging::LoggerConfiguration log_config;
auto properties = std::make_shared<logging::LoggerProperties>("");
std::string_view logger_name;
SECTION("Use unlimited value") {
Expand All @@ -364,13 +364,13 @@ TEST_CASE("Setting max log entry length to unlimited results in unlimited log en
logger_name = "SetMaxLogEntryLengthTo-1TestLogger";
}
properties->set("logger.root", "INFO");
log_config->initialize(properties);
auto logger = log_config->getLogger(logger_name);
log_config.initialize(properties);
auto logger = log_config.getLogger(logger_name);
std::string log(5000, 'a');
logger->log_error("{}", log);

REQUIRE(LoggerTestAccessor::waitForCompressionToHappen(*log_config));
auto compressed_logs = LoggerTestAccessor::getCompressedLogs(*log_config);
REQUIRE(LoggerTestAccessor::waitForCompressionToHappen(log_config));
auto compressed_logs = LoggerTestAccessor::getCompressedLogs(log_config);
REQUIRE(compressed_logs.size() == 1);
auto logs = decompress(compressed_logs[0]);
REQUIRE(logs.find(log) != std::string::npos);
Expand Down Expand Up @@ -417,22 +417,22 @@ std::vector<std::string> generateRandomStrings() {
}

TEST_CASE("Test sending multiple segments at once", "[ttl16]") {
auto log_config = logging::LoggerConfiguration::newInstance();
LoggerTestAccessor::setCompressionCompressedSegmentSize(*log_config, 100);
LoggerTestAccessor::setCompressionCacheSegmentSize(*log_config, 100);
logging::LoggerConfiguration log_config;
LoggerTestAccessor::setCompressionCompressedSegmentSize(log_config, 100);
LoggerTestAccessor::setCompressionCacheSegmentSize(log_config, 100);
auto properties = std::make_shared<logging::LoggerProperties>("");
// by default the root logger is OFF
properties->set("logger.root", "INFO");
log_config->initialize(properties);
auto logger = log_config->getLogger("CompressionTestMultiSegment");
log_config.initialize(properties);
auto logger = log_config.getLogger("CompressionTestMultiSegment");

const auto random_strings = generateRandomStrings();
for (const auto& random_string : random_strings) {
logger->log_error("{}", random_string);
}

REQUIRE(LoggerTestAccessor::waitForCompressionToHappen(*log_config));
auto compressed_logs = LoggerTestAccessor::getCompressedLogs(*log_config);
REQUIRE(LoggerTestAccessor::waitForCompressionToHappen(log_config));
auto compressed_logs = LoggerTestAccessor::getCompressedLogs(log_config);
REQUIRE(compressed_logs.size() == random_strings.size());
for (size_t i = 0; i < compressed_logs.size(); ++i) {
auto logs = decompress(compressed_logs[i]);
Expand Down
Loading