pdxcodemonkey commented on a change in pull request #761:
URL: https://github.com/apache/geode-native/pull/761#discussion_r591788176
##########
File path: cppcache/src/Log.cpp
##########
@@ -107,334 +78,280 @@ void Log::init(LogLevel level, const char* logFileName,
int32_t logFileLimit,
init(level, logFileNameString, logFileLimit, logDiskSpaceLimit);
}
-void Log::rollLogFile() {
- if (g_log) {
- fclose(g_log);
- g_log = nullptr;
- }
-
- auto rollFileName =
- (g_fullpath.parent_path() /
- (g_fullpath.stem().string() + "-" + std::to_string(g_rollIndex) +
- g_fullpath.extension().string()))
- .string();
- try {
- auto rollFile = boost::filesystem::path(rollFileName);
- boost::filesystem::rename(g_fullpath, rollFile);
- g_rollFiles[g_rollIndex] = rollFile;
- g_rollIndex++;
- } catch (const boost::filesystem::filesystem_error&) {
- throw IllegalStateException("Failed to roll log file");
- }
-}
-
-void Log::removeOldestRolledLogFile() {
- if (g_rollFiles.size()) {
- auto index = g_rollFiles.begin()->first;
- auto fileToRemove = g_rollFiles.begin()->second;
- auto fileSize = boost::filesystem::file_size(fileToRemove);
- boost::filesystem::remove(fileToRemove);
- g_rollFiles.erase(index);
- g_spaceUsed -= fileSize;
- } else {
- throw IllegalStateException(
- "Failed to free sufficient disk space for logs");
- }
-}
-
-void Log::calculateUsedDiskSpace() {
- g_spaceUsed = 0;
- if (boost::filesystem::exists(g_fullpath)) {
- g_spaceUsed = boost::filesystem::file_size(g_fullpath);
- for (auto const& item : g_rollFiles) {
- g_spaceUsed += boost::filesystem::file_size(item.second);
- }
- }
-}
+std::string Log::logLineFormat() {
+ std::stringstream format;
+ const size_t MINBUFSIZE = 128;
+ auto now = std::chrono::system_clock::now();
+ auto secs = std::chrono::system_clock::to_time_t(now);
+ auto tm_val = apache::geode::util::chrono::localtime(secs);
-void Log::buildRollFileMapping() {
- const auto filterstring = g_fullpath.stem().string() + "-(\\d+)\\.log$";
- const std::regex my_filter(filterstring);
-
- g_rollFiles.clear();
-
- boost::filesystem::directory_iterator end_itr;
- for (boost::filesystem::directory_iterator i(
- g_fullpath.parent_path().string());
- i != end_itr; ++i) {
- if (boost::filesystem::is_regular_file(i->status())) {
- std::string filename = i->path().filename().string();
- std::regex testPattern(filterstring);
- std::match_results<std::string::const_iterator> testMatches;
- if (std::regex_search(std::string::const_iterator(filename.begin()),
- filename.cend(), testMatches, testPattern)) {
- auto index = std::atoi(
- std::string(testMatches[1].first, testMatches[1].second).c_str());
- g_rollFiles[index] = i->path();
- }
- }
- }
-}
+ format << "[%l %Y/%m/%d %H:%M:%S.%f " << std::put_time(&tm_val, "%Z ")
+ << boost::asio::ip::host_name() << ":%P %t] %v";
-void Log::setRollFileIndex() {
- g_rollIndex = 0;
- if (g_rollFiles.size()) {
- g_rollIndex = g_rollFiles.rbegin()->first + 1;
- }
+ return format.str();
}
-void Log::setSizeLimits(int32_t logFileLimit, int64_t logDiskSpaceLimit) {
+void Log::setSizeLimits(int32_t logFileLimit, int64_t logDiskSpaceLimit,
+ int32_t& adjustedFileLimit,
+ int64_t& adjustedDiskLimit) {
validateSizeLimits(logFileLimit, logDiskSpaceLimit);
// Default to 10MB file limit and 1GB disk limit
if (logFileLimit == 0 && logDiskSpaceLimit == 0) {
- g_fileSizeLimit = 10 * __1M__;
- g_diskSpaceLimit = 1000 * __1M__;
+ adjustedFileLimit = 10 * __1M__;
+ adjustedDiskLimit = 1000 * __1M__;
}
// disk space specified but file size is defaulted. Just use a single
// log file, i.e. set file limit == disk limit
else if (logFileLimit == 0) {
- g_diskSpaceLimit = logDiskSpaceLimit * __1M__;
- g_fileSizeLimit = g_diskSpaceLimit;
+ adjustedDiskLimit = logDiskSpaceLimit * __1M__;
+ adjustedFileLimit = static_cast<int32_t>(adjustedDiskLimit);
} else if (logDiskSpaceLimit == 0) {
- g_fileSizeLimit = logFileLimit * __1M__;
- g_diskSpaceLimit = g_fileSizeLimit;
+ adjustedFileLimit = logFileLimit * __1M__;
+ adjustedDiskLimit = adjustedFileLimit;
} else {
- g_fileSizeLimit = logFileLimit * __1M__;
- g_diskSpaceLimit = logDiskSpaceLimit * __1M__;
+ adjustedFileLimit = logFileLimit * __1M__;
+ adjustedDiskLimit = logDiskSpaceLimit * __1M__;
+ }
+}
+
+uint32_t Log::calculateMaxFilesForSpaceLimit(uint64_t logDiskSpaceLimit,
+ uint32_t logFileSizeLimit) {
+ uint32_t maxFiles = 1;
+
+ maxFiles = static_cast<uint32_t>(logDiskSpaceLimit / logFileSizeLimit) - 1;
+ // Must specify at least 1!
+ maxFiles = maxFiles > 0 ? maxFiles : 0;
+
+ return maxFiles;
+}
+
+spdlog::level::level_enum geodeLogLevelToSpdlogLevel(LogLevel logLevel) {
+ auto level = spdlog::level::level_enum::off;
+ switch (logLevel) {
+ case LogLevel::None:
+ level = spdlog::level::level_enum::off;
+ break;
+ case LogLevel::Error:
+ level = spdlog::level::level_enum::err;
+ break;
+ case LogLevel::Warning:
+ level = spdlog::level::level_enum::warn;
+ break;
+ case LogLevel::Info:
+ level = spdlog::level::level_enum::info;
+ break;
+ case LogLevel::Default:
+ level = spdlog::level::level_enum::info;
+ break;
+ case LogLevel::Config:
+ level = spdlog::level::level_enum::info;
+ break;
+ case LogLevel::Fine:
+ level = spdlog::level::level_enum::debug;
+ break;
+ case LogLevel::Finer:
+ level = spdlog::level::level_enum::debug;
+ break;
+ case LogLevel::Finest:
+ level = spdlog::level::level_enum::debug;
+ break;
+ case LogLevel::Debug:
+ level = spdlog::level::level_enum::debug;
+ break;
+ case LogLevel::All:
+ level = spdlog::level::level_enum::debug;
+ break;
}
+
+ return level;
}
-void Log::init(LogLevel level, const std::string& logFileName,
- int32_t logFileLimit, int64_t logDiskSpaceLimit) {
- if (g_log != nullptr) {
- throw IllegalStateException(
- "The Log has already been initialized. "
- "Call Log::close() before calling Log::init again.");
+void Log::init(LogLevel logLevel, const std::string& logFilename,
+ uint32_t logFileSizeLimit, uint64_t logDiskSpaceLimit) {
+ if (logLevel == LogLevel::None) {
+ return;
}
- s_logLevel = level;
try {
std::lock_guard<decltype(g_logMutex)> guard(g_logMutex);
- g_hostName = boost::asio::ip::host_name();
+ if (logFilename.empty()) {
+ if (logFileSizeLimit || logDiskSpaceLimit) {
+ IllegalArgumentException ex(
+ "Cannot specify a file or disk space size limit without specifying
"
+ "a log file name.");
+ throw ex;
+ }
+ currentLevel = logLevel;
+ // Check for multiple initialization
+ if (currentLogger && currentLogger->name() == "console") {
+ return;
+ } else {
+ close();
+ }
+ currentLogger = spdlog::stderr_color_mt("console");
+ currentLogger->set_level(geodeLogLevelToSpdlogLevel(currentLevel));
+ currentLogger->set_pattern(logLineFormat());
+ return;
+ } else if (logDiskSpaceLimit && logFileSizeLimit > logDiskSpaceLimit) {
+ IllegalArgumentException ex(
+ "File size limit must be smaller than disk space limit for "
+ "logging.");
+ throw ex;
+ }
- g_fullpath =
- boost::filesystem::absolute(boost::filesystem::path(logFileName));
+ int32_t adjustedFileSizeLimit;
Review comment:
We're not... really. Our two existing properties are file size and disk
space, specified in MB. spdlog uses two properties, file size and max number
of files, specified in bytes. So we calculate limits like we did before, then
translate disk space to a max number of files and give those limits to the
spdlog file sink. There's no logic anymore in our code to check file size,
roll logs, delete old files, etc.
----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
[email protected]
