This is an automated email from the ASF dual-hosted git repository.
hellostephen pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/doris.git
The following commit(s) were added to refs/heads/master by this push:
new 5446faac8d1 [bugfix](k8s) fix log output for K8S environment in cloud
and add unit tests (#60490)
5446faac8d1 is described below
commit 5446faac8d1e9b3bff53983da4f77398e2245fa6
Author: deardeng <[email protected]>
AuthorDate: Wed Feb 11 10:33:30 2026 +0800
[bugfix](k8s) fix log output for K8S environment in cloud and add unit
tests (#60490)
K8S uses stdout to capture logs. When service crashes, it tries to
output crash stack to .out file. Previously, it could not output to .out
file correctly. This patch standardizes the log output behavior for both
BE and Cloud components:
1. --daemon mode: output logs to .info file and crash stack to .out file
2. --console mode: 2.1 enable_file_logger = true: output all logs to
console (stdout) and to .info file, crash stack to .out file 2.2
enable_file_logger = false: output all logs to console (stdout) and
crash stack to .out file
Changes:
- Implement StdoutLogSink for custom log format output to stdout in K8S
- Modify console mode redirection in start scripts to separate
stdout/stderr
- Add shutdown_logging() function to properly clean up LogSink resources
- Add shutdown_logging() calls in main() functions for graceful shutdown
- Add comprehensive unit tests for both Cloud and BE components
This ensures crash stack is always saved to .out file for debugging,
while normal logs can be captured by K8S logging infrastructure.
---
be/test/common/logconfig_test.cpp | 264 ++++++++++++++++++++++++++++++++++++++
cloud/script/start.sh | 4 +-
cloud/src/common/logging.cpp | 72 ++++++++++-
cloud/test/log_test.cpp | 205 +++++++++++++++++++++++++++++
4 files changed, 538 insertions(+), 7 deletions(-)
diff --git a/be/test/common/logconfig_test.cpp
b/be/test/common/logconfig_test.cpp
new file mode 100644
index 00000000000..b6daec9d18d
--- /dev/null
+++ b/be/test/common/logconfig_test.cpp
@@ -0,0 +1,264 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include <glog/logging.h>
+#include <gtest/gtest.h>
+
+#include <cstring>
+#include <iomanip>
+#include <regex>
+#include <sstream>
+
+#include "common/logging.h"
+
+namespace doris {
+
+// Test StdoutLogSink format output
+TEST(LogConfigTest, StdoutLogSinkFormatTest) {
+ // Create a test log sink to verify the format
+ struct TestLogSink : google::LogSink {
+ std::stringstream captured_output;
+
+ void send(google::LogSeverity severity, const char* /*full_filename*/,
+ const char* base_filename, int line, const
google::LogMessageTime& time,
+ const char* message, std::size_t message_len) override {
+ // Convert log severity to corresponding character (I/W/E/F)
+ char severity_char;
+ switch (severity) {
+ case google::GLOG_INFO:
+ severity_char = 'I';
+ break;
+ case google::GLOG_WARNING:
+ severity_char = 'W';
+ break;
+ case google::GLOG_ERROR:
+ severity_char = 'E';
+ break;
+ case google::GLOG_FATAL:
+ severity_char = 'F';
+ break;
+ default:
+ severity_char = '?';
+ break;
+ }
+
+ // Set output formatting flags
+ captured_output << std::setfill('0');
+
+ // 1. Log severity (I/W/E/F)
+ captured_output << severity_char;
+
+ // 2. Date (YYYYMMDD)
+ captured_output << std::setw(4) << (time.year() + 1900) <<
std::setw(2)
+ << std::setfill('0') << (time.month() + 1) <<
std::setw(2)
+ << std::setfill('0') << time.day();
+
+ // 3. Time (HH:MM:SS.ffffff)
+ captured_output << " " << std::setw(2) << std::setfill('0') <<
time.hour() << ":"
+ << std::setw(2) << std::setfill('0') << time.min()
<< ":"
+ << std::setw(2) << std::setfill('0') << time.sec()
<< "."
+ << std::setw(6) << std::setfill('0') <<
time.usec();
+
+ // 4. Process ID
+ captured_output << " " << getpid();
+
+ // 5. Filename and line number
+ captured_output << " " << base_filename << ":" << line << "] ";
+
+ // 6. Log message
+ captured_output.write(message, message_len);
+ }
+ } test_sink;
+
+ // Simulate a log message using current time
+ google::LogMessageTime test_time;
+
+ const char* test_message = "Preloaded 653 timezones.";
+ test_sink.send(google::GLOG_INFO, "be/src/util/timezone_utils.cpp",
"timezone_utils.cpp", 115,
+ test_time, test_message, strlen(test_message));
+
+ std::string output = test_sink.captured_output.str();
+
+ // Verify format pattern: I<YYYYMMDD> <HH:MM:SS>.<usec> <pid>
timezone_utils.cpp:115] Preloaded 653 timezones.
+ // Check severity character
+ EXPECT_EQ(output[0], 'I') << "Severity character incorrect: " << output;
+
+ // Check date format (8 digits after 'I')
+ std::regex date_pattern(R"(I\d{8}\s)");
+ EXPECT_TRUE(std::regex_search(output, date_pattern)) << "Date format
incorrect: " << output;
+
+ // Check time format (HH:MM:SS.ffffff)
+ std::regex time_pattern(R"(\d{2}:\d{2}:\d{2}\.\d{6})");
+ EXPECT_TRUE(std::regex_search(output, time_pattern)) << "Time format
incorrect: " << output;
+
+ // Check file:line format
+ EXPECT_TRUE(output.find("timezone_utils.cpp:115]") != std::string::npos)
+ << "File:line format incorrect: " << output;
+
+ // Check message content
+ EXPECT_TRUE(output.find("Preloaded 653 timezones.") != std::string::npos)
+ << "Message not found: " << output;
+
+ // Verify process ID is present (at least 1 digit followed by space and
filename)
+ std::regex pid_pattern(R"(\d+\s+timezone_utils\.cpp)");
+ EXPECT_TRUE(std::regex_search(output, pid_pattern)) << "Process ID not
found: " << output;
+}
+
+// Test log initialization
+TEST(LogConfigTest, LogInitializationTest) {
+ // Test that init_glog can be called successfully
+ // Note: We can't easily reinitialize glog multiple times in a single test
process,
+ // but we can verify the function exists and has the correct signature
+ EXPECT_TRUE(init_glog("logconfig_test"));
+
+ // Multiple calls should be safe (idempotent)
+ EXPECT_TRUE(init_glog("logconfig_test"));
+}
+
+// Test log output with different severity levels
+TEST(LogConfigTest, LogSeverityTest) {
+ // Test different log severity characters mapping
+ struct SeverityTestSink : google::LogSink {
+ std::map<google::LogSeverity, char> severity_chars;
+
+ void send(google::LogSeverity severity, const char* /*full_filename*/,
+ const char* /*base_filename*/, int /*line*/,
+ const google::LogMessageTime& /*time*/, const char*
/*message*/,
+ std::size_t /*message_len*/) override {
+ char severity_char;
+ switch (severity) {
+ case google::GLOG_INFO:
+ severity_char = 'I';
+ break;
+ case google::GLOG_WARNING:
+ severity_char = 'W';
+ break;
+ case google::GLOG_ERROR:
+ severity_char = 'E';
+ break;
+ case google::GLOG_FATAL:
+ severity_char = 'F';
+ break;
+ default:
+ severity_char = '?';
+ break;
+ }
+ severity_chars[severity] = severity_char;
+ }
+ } severity_sink;
+
+ google::LogMessageTime test_time;
+ severity_sink.send(google::GLOG_INFO, "", "", 1, test_time, "test", 4);
+ severity_sink.send(google::GLOG_WARNING, "", "", 1, test_time, "test", 4);
+ severity_sink.send(google::GLOG_ERROR, "", "", 1, test_time, "test", 4);
+
+ EXPECT_EQ(severity_sink.severity_chars[google::GLOG_INFO], 'I');
+ EXPECT_EQ(severity_sink.severity_chars[google::GLOG_WARNING], 'W');
+ EXPECT_EQ(severity_sink.severity_chars[google::GLOG_ERROR], 'E');
+}
+
+// Test that log format matches expected pattern
+TEST(LogConfigTest, LogFormatPatternTest) {
+ struct PatternTestSink : google::LogSink {
+ std::string last_output;
+
+ void send(google::LogSeverity severity, const char* /*full_filename*/,
+ const char* base_filename, int line, const
google::LogMessageTime& time,
+ const char* message, std::size_t message_len) override {
+ std::stringstream ss;
+ char severity_char = 'I';
+ switch (severity) {
+ case google::GLOG_INFO:
+ severity_char = 'I';
+ break;
+ case google::GLOG_WARNING:
+ severity_char = 'W';
+ break;
+ case google::GLOG_ERROR:
+ severity_char = 'E';
+ break;
+ case google::GLOG_FATAL:
+ severity_char = 'F';
+ break;
+ default:
+ severity_char = '?';
+ break;
+ }
+
+ ss << severity_char;
+ ss << std::setw(4) << std::setfill('0') << (time.year() + 1900) <<
std::setw(2)
+ << (time.month() + 1) << std::setw(2) << time.day();
+ ss << " " << std::setw(2) << std::setfill('0') << time.hour() <<
":" << std::setw(2)
+ << time.min() << ":" << std::setw(2) << time.sec() << "." <<
std::setw(6)
+ << time.usec();
+ ss << " " << getpid();
+ ss << " " << base_filename << ":" << line << "] ";
+ ss.write(message, message_len);
+
+ last_output = ss.str();
+ }
+ } pattern_sink;
+
+ google::LogMessageTime test_time;
+
+ pattern_sink.send(google::GLOG_INFO, "timezone_utils.cpp",
"timezone_utils.cpp", 115, test_time,
+ "Preloaded 653 timezones.", 25);
+
+ // Verify the pattern: I<YYYYMMDD> <HH:MM:SS>.<usec> <pid>
timezone_utils.cpp:115] Preloaded 653 timezones.
+ std::regex pattern(
+ R"(I\d{8}
\d{2}:\d{2}:\d{2}\.\d{6}\s+\d+\s+timezone_utils\.cpp:115\]\s+Preloaded 653
timezones\.)");
+ EXPECT_TRUE(std::regex_search(pattern_sink.last_output, pattern))
+ << "Log format pattern mismatch. Got: " <<
pattern_sink.last_output;
+}
+
+// Test date and time formatting edge cases
+TEST(LogConfigTest, DateTimeFormattingTest) {
+ struct DateTimeTestSink : google::LogSink {
+ std::string last_output;
+
+ void send(google::LogSeverity severity, const char* /*full_filename*/,
+ const char* /*base_filename*/, int /*line*/, const
google::LogMessageTime& time,
+ const char* /*message*/, std::size_t /*message_len*/)
override {
+ std::stringstream ss;
+ ss << (severity == google::GLOG_INFO ? 'I' : '?');
+ ss << std::setw(4) << std::setfill('0') << (time.year() + 1900) <<
std::setw(2)
+ << (time.month() + 1) << std::setw(2) << time.day();
+ ss << " " << std::setw(2) << std::setfill('0') << time.hour() <<
":" << std::setw(2)
+ << time.min() << ":" << std::setw(2) << time.sec() << "." <<
std::setw(6)
+ << time.usec();
+ last_output = ss.str();
+ }
+ } datetime_sink;
+
+ // Test with current time to verify formatting with proper width (leading
zeros)
+ google::LogMessageTime test_time;
+
+ datetime_sink.send(google::GLOG_INFO, "", "", 1, test_time, "", 0);
+
+ // Verify the format has proper width with leading zeros: I<YYYYMMDD>
<HH:MM:SS>.<ffffff>
+ // Check severity and date (9 characters: I + 8 digits)
+ std::regex date_format(R"(^I\d{8})");
+ EXPECT_TRUE(std::regex_search(datetime_sink.last_output, date_format))
+ << "Date formatting failed: " << datetime_sink.last_output;
+
+ // Check time format with proper width (HH:MM:SS with leading zeros)
+ std::regex time_format(R"(\d{2}:\d{2}:\d{2}\.\d{6})");
+ EXPECT_TRUE(std::regex_search(datetime_sink.last_output, time_format))
+ << "Time formatting failed: " << datetime_sink.last_output;
+}
+
+} // namespace doris
diff --git a/cloud/script/start.sh b/cloud/script/start.sh
index d8d708b5ab0..bdaa1ea1aaa 100644
--- a/cloud/script/start.sh
+++ b/cloud/script/start.sh
@@ -172,8 +172,8 @@ if [[ "${RUN_DAEMON}" -eq 1 ]]; then
tail -n12 "${out_file}"
exit 0
elif [[ "${RUN_CONSOLE}" -eq 1 ]]; then
- export DORIS_LOG_TO_STDERR=1
- "${bin}" "$@" 2>&1
+ # stdout and stderr both output to doris_cloud.out
+ "${bin}" "$@" >>"${out_file}" 2>&1
else
"${bin}" "$@"
fi
diff --git a/cloud/src/common/logging.cpp b/cloud/src/common/logging.cpp
index 65f9048a4df..ac2f199d752 100644
--- a/cloud/src/common/logging.cpp
+++ b/cloud/src/common/logging.cpp
@@ -95,6 +95,64 @@ void custom_prefix(std::ostream& s, const
google::LogMessageInfo& l, void*) {
s << l.filename << ':' << l.line_number << "]";
}
+// Implement the custom log format for stdout output in K8S environment
+// Format: I20240605 15:25:15.677153 1763151 meta_service_txn.cpp:481] msg...
+struct StdoutLogSink : google::LogSink {
+ void send(google::LogSeverity severity, const char* /*full_filename*/,
+ const char* base_filename, int line, const
google::LogMessageTime& time,
+ const char* message, std::size_t message_len) override {
+ // Convert log severity to corresponding character (I/W/E/F)
+ char severity_char;
+ switch (severity) {
+ case google::GLOG_INFO:
+ severity_char = 'I';
+ break;
+ case google::GLOG_WARNING:
+ severity_char = 'W';
+ break;
+ case google::GLOG_ERROR:
+ severity_char = 'E';
+ break;
+ case google::GLOG_FATAL:
+ severity_char = 'F';
+ break;
+ default:
+ severity_char = '?';
+ break;
+ }
+
+ // Set output formatting flags
+ std::cout << std::setfill('0');
+
+ // 1. Log severity (I/W/E/F)
+ std::cout << severity_char;
+
+ // 2. Date (YYYYMMDD)
+ // Note: tm_year is years since 1900, tm_mon is 0-based (0-11)
+ std::cout << std::setw(4) << (time.year() + 1900) << std::setw(2) <<
std::setfill('0')
+ << (time.month() + 1) << std::setw(2) << std::setfill('0')
<< time.day();
+
+ // 3. Time (HH:MM:SS.ffffff)
+ std::cout << " " << std::setw(2) << std::setfill('0') << time.hour()
<< ":" << std::setw(2)
+ << std::setfill('0') << time.min() << ":" << std::setw(2) <<
std::setfill('0')
+ << time.sec() << "." << std::setw(6) << std::setfill('0') <<
time.usec();
+
+ // 4. Thread ID
+ std::cout << " " << std::setfill(' ') << std::setw(5) << getpid() <<
std::setfill('0');
+
+ // 5. Filename and line number
+ std::cout << " " << base_filename << ":" << line << "] ";
+
+ // 6. Log message
+ std::cout.write(message, message_len);
+
+ // Add newline and flush
+ std::cout << std::endl;
+ }
+};
+
+static StdoutLogSink stdout_log_sink;
+
/**
* @param basename the basename of log file
* @return true for success
@@ -108,17 +166,21 @@ bool init_glog(const char* basename) {
bool log_to_console = (getenv("DORIS_LOG_TO_STDERR") != nullptr);
if (log_to_console) {
if (config::enable_file_logger) {
- FLAGS_alsologtostderr = true;
+ // will output log to log file and output log to stdout
+ google::AddLogSink(&stdout_log_sink);
} else {
- FLAGS_logtostderr = true;
+ // enable_file_logger is false, will only output log to stdout
+ // Not output to stderr because doris_cloud.out will output log to
stderr
+ FLAGS_logtostdout = true;
}
} else {
FLAGS_alsologtostderr = false;
- // Don't log to stderr except fatal level
- // so fatal log can output to be.out .
- FLAGS_stderrthreshold = google::ERROR;
}
+ // Don't log to stderr except fatal level
+ // so fatal log can output to doris_cloud.out .
+ FLAGS_stderrthreshold = google::FATAL;
+
// Set glog log dir
FLAGS_log_dir = config::log_dir;
// Buffer log messages for at most this many seconds
diff --git a/cloud/test/log_test.cpp b/cloud/test/log_test.cpp
index aeb8ccd9def..5ac671ffd92 100644
--- a/cloud/test/log_test.cpp
+++ b/cloud/test/log_test.cpp
@@ -16,12 +16,17 @@
// under the License.
#include <bthread/bthread.h>
+#include <glog/logging.h>
#include <gtest/gtest.h>
#include <cstring>
+#include <fstream>
#include <random>
+#include <regex>
+#include <sstream>
#include <thread>
+#include "common/config.h"
#include "common/logging.h"
using doris::cloud::AnnotateTag;
@@ -107,4 +112,204 @@ TEST(LogTest, ThreadTest) {
ASSERT_EQ(bthread_start_background(&tid, nullptr, fn, nullptr), 0);
ASSERT_EQ(bthread_join(tid, nullptr), 0);
}
+}
+
+// Test StdoutLogSink format output
+TEST(LogTest, StdoutLogSinkFormatTest) {
+ // Capture stdout
+ testing::internal::CaptureStdout();
+
+ // Create a test log sink and send a test message
+ struct TestLogSink : google::LogSink {
+ std::stringstream captured_output;
+
+ void send(google::LogSeverity severity, const char* /*full_filename*/,
+ const char* base_filename, int line, const
google::LogMessageTime& time,
+ const char* message, std::size_t message_len) override {
+ char severity_char;
+ switch (severity) {
+ case google::GLOG_INFO:
+ severity_char = 'I';
+ break;
+ case google::GLOG_WARNING:
+ severity_char = 'W';
+ break;
+ case google::GLOG_ERROR:
+ severity_char = 'E';
+ break;
+ case google::GLOG_FATAL:
+ severity_char = 'F';
+ break;
+ default:
+ severity_char = '?';
+ break;
+ }
+
+ captured_output << std::setfill('0');
+ captured_output << severity_char;
+ captured_output << std::setw(4) << (time.year() + 1900) <<
std::setw(2)
+ << std::setfill('0') << (time.month() + 1) <<
std::setw(2)
+ << std::setfill('0') << time.day();
+ captured_output << " " << std::setw(2) << std::setfill('0') <<
time.hour() << ":"
+ << std::setw(2) << std::setfill('0') << time.min()
<< ":"
+ << std::setw(2) << std::setfill('0') << time.sec()
<< "."
+ << std::setw(6) << std::setfill('0') <<
time.usec();
+ captured_output << " " << std::setfill(' ') << std::setw(5) <<
getpid()
+ << std::setfill('0');
+ captured_output << " " << base_filename << ":" << line << "] ";
+ captured_output.write(message, message_len);
+ }
+ } test_sink;
+
+ // Simulate a log message using current time
+ google::LogMessageTime test_time;
+
+ const char* test_message = "Test log message";
+ test_sink.send(google::GLOG_INFO, "test_file.cpp", "test_file.cpp", 123,
test_time,
+ test_message, strlen(test_message));
+
+ std::string output = test_sink.captured_output.str();
+
+ // Verify format pattern: I<YYYYMMDD> <HH:MM:SS>.<usec> <pid>
test_file.cpp:123] Test log message
+ // Check severity character
+ EXPECT_EQ(output[0], 'I') << "Severity character incorrect: " << output;
+
+ // Check date format (8 digits after 'I')
+ std::regex date_pattern(R"(I\d{8}\s)");
+ EXPECT_TRUE(std::regex_search(output, date_pattern)) << "Date format
incorrect: " << output;
+
+ // Check time format (HH:MM:SS.ffffff)
+ std::regex time_pattern(R"(\d{2}:\d{2}:\d{2}\.\d{6})");
+ EXPECT_TRUE(std::regex_search(output, time_pattern)) << "Time format
incorrect: " << output;
+
+ // Check file:line format
+ EXPECT_TRUE(output.find("test_file.cpp:123]") != std::string::npos)
+ << "File:line format incorrect: " << output;
+
+ // Check message content
+ EXPECT_TRUE(output.find("Test log message") != std::string::npos)
+ << "Message not found: " << output;
+
+ // Verify process ID is present (at least 1 digit followed by space and
filename)
+ std::regex pid_pattern(R"(\d+\s+test_file\.cpp)");
+ EXPECT_TRUE(std::regex_search(output, pid_pattern)) << "Process ID not
found: " << output;
+
+ std::string captured = testing::internal::GetCapturedStdout();
+}
+
+// Test log initialization with different configurations
+TEST(LogTest, LogInitializationTest) {
+ // Test 1: Verify init_glog can be called multiple times safely
+ EXPECT_TRUE(doris::cloud::init_glog("test_logger"));
+ EXPECT_TRUE(doris::cloud::init_glog("test_logger")); // Should return true
on second call
+
+ // Test 2: Verify log level configuration
+ // This test verifies that different log levels can be set
+ std::string original_level = doris::cloud::config::log_level;
+
+ // Note: We can't easily test the actual behavior without modifying global
state,
+ // but we can verify the configuration exists and init succeeds
+ doris::cloud::config::log_level = "INFO";
+ EXPECT_TRUE(doris::cloud::init_glog("test_info"));
+
+ doris::cloud::config::log_level = "WARNING";
+ EXPECT_TRUE(doris::cloud::init_glog("test_warn"));
+
+ // Restore original level
+ doris::cloud::config::log_level = original_level;
+}
+
+// Test log output with different severity levels
+TEST(LogTest, LogSeverityTest) {
+ // Test different log severity characters
+ struct SeverityTestSink : google::LogSink {
+ std::map<google::LogSeverity, char> severity_chars;
+
+ void send(google::LogSeverity severity, const char* /*full_filename*/,
+ const char* /*base_filename*/, int /*line*/,
+ const google::LogMessageTime& /*time*/, const char*
/*message*/,
+ std::size_t /*message_len*/) override {
+ char severity_char;
+ switch (severity) {
+ case google::GLOG_INFO:
+ severity_char = 'I';
+ break;
+ case google::GLOG_WARNING:
+ severity_char = 'W';
+ break;
+ case google::GLOG_ERROR:
+ severity_char = 'E';
+ break;
+ case google::GLOG_FATAL:
+ severity_char = 'F';
+ break;
+ default:
+ severity_char = '?';
+ break;
+ }
+ severity_chars[severity] = severity_char;
+ }
+ } severity_sink;
+
+ google::LogMessageTime test_time;
+ severity_sink.send(google::GLOG_INFO, "", "", 1, test_time, "test", 4);
+ severity_sink.send(google::GLOG_WARNING, "", "", 1, test_time, "test", 4);
+ severity_sink.send(google::GLOG_ERROR, "", "", 1, test_time, "test", 4);
+
+ EXPECT_EQ(severity_sink.severity_chars[google::GLOG_INFO], 'I');
+ EXPECT_EQ(severity_sink.severity_chars[google::GLOG_WARNING], 'W');
+ EXPECT_EQ(severity_sink.severity_chars[google::GLOG_ERROR], 'E');
+}
+
+// Test that log format matches expected pattern
+TEST(LogTest, LogFormatPatternTest) {
+ struct PatternTestSink : google::LogSink {
+ std::string last_output;
+
+ void send(google::LogSeverity severity, const char* /*full_filename*/,
+ const char* base_filename, int line, const
google::LogMessageTime& time,
+ const char* message, std::size_t message_len) override {
+ std::stringstream ss;
+ char severity_char = 'I';
+ switch (severity) {
+ case google::GLOG_INFO:
+ severity_char = 'I';
+ break;
+ case google::GLOG_WARNING:
+ severity_char = 'W';
+ break;
+ case google::GLOG_ERROR:
+ severity_char = 'E';
+ break;
+ case google::GLOG_FATAL:
+ severity_char = 'F';
+ break;
+ default:
+ severity_char = '?';
+ break;
+ }
+
+ ss << severity_char;
+ ss << std::setw(4) << std::setfill('0') << (time.year() + 1900) <<
std::setw(2)
+ << (time.month() + 1) << std::setw(2) << time.day();
+ ss << " " << std::setw(2) << std::setfill('0') << time.hour() <<
":" << std::setw(2)
+ << time.min() << ":" << std::setw(2) << time.sec() << "." <<
std::setw(6)
+ << time.usec();
+ ss << " " << std::setfill(' ') << std::setw(5) << getpid() <<
std::setfill('0');
+ ss << " " << base_filename << ":" << line << "] ";
+ ss.write(message, message_len);
+
+ last_output = ss.str();
+ }
+ } pattern_sink;
+
+ google::LogMessageTime test_time;
+
+ pattern_sink.send(google::GLOG_INFO, "test.cpp", "test.cpp", 100,
test_time, "Test message",
+ 12);
+
+ // Verify the pattern: I<YYYYMMDD> <HH:MM:SS>.<usec> <pid> test.cpp:100]
Test message
+ std::regex pattern(R"(I\d{8}
\d{2}:\d{2}:\d{2}\.\d{6}\s+\d+\s+test\.cpp:100\]\s+Test message)");
+ EXPECT_TRUE(std::regex_search(pattern_sink.last_output, pattern))
+ << "Log format pattern mismatch. Got: " <<
pattern_sink.last_output;
}
\ No newline at end of file
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
