<ins> diff --git a/CMakeLists.txt b/CMakeLists.txt index 846b4448..b4900ead 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -39,6 +39,7 @@ option (PRINT_UNSYMBOLIZED_STACK_TRACES "Print file offsets in traces instead of symbolizing" OFF) option (WITH_CUSTOM_PREFIX "Enable support for user-generated message prefixes" ON) option (WITH_GFLAGS "Use gflags" ON) +option (WITH_ABSL "Use absl flags" OFF) option (WITH_GTEST "Use Google Test" ON) option (WITH_PKGCONFIG "Enable pkg-config support" ON) option (WITH_SYMBOLIZE "Enable symbolize module" ON) @@ -87,6 +88,13 @@ if (WITH_GFLAGS) endif (gflags_FOUND) endif (WITH_GFLAGS) +if (WITH_ABSL) +  set (HAVE_ABSL_FLAGS 1) +  set (ac_cv_have_abslflags 1) +else (WITH_ABSL) +set (ac_cv_have_abslflags 0) +endif (WITH_ABSL) + find_package (Threads) find_package (Unwind) @@ -1025,7 +1033,7 @@ write_basic_package_version_file ( ${CMAKE_CURRENT_BINARY_DIR}/glog-config-version.cmake COMPATIBILITY SameMajorVersion) -export (TARGETS glog NAMESPACE glog:: FILE glog-targets.cmake) +# export (TARGETS glog NAMESPACE glog:: FILE glog-targets.cmake) export (PACKAGE glog) get_filename_component (_PREFIX "${CMAKE_INSTALL_PREFIX}" ABSOLUTE) diff --git a/src/base/commandlineflags.h b/src/base/commandlineflags.h index bcb12dea..1c9d9294 100644 --- a/src/base/commandlineflags.h +++ b/src/base/commandlineflags.h @@ -57,6 +57,25 @@ #include <gflags/gflags.h> +#else +#ifdef HAVE_ABSL_FLAGS +#include <absl/flags/flag.h> + +#define FLAG(name) absl::GetFlag(FLAGS_##name) + +#define DEFINE_bool(name, value, meaning)  +  ABSL_FLAG(bool, name, value, meaning) + +#define DEFINE_int32(name, value, meaning)  +  ABSL_FLAG(GOOGLE_NAMESPACE::int32, name, value, meaning) + +#define DEFINE_uint32(name, value, meaning)  +  ABSL_FLAG(GOOGLE_NAMESPACE::uint32, name, value, meaning) + +#define DEFINE_string(name, value, meaning)  +  ABSL_FLAG(std::string, name, value, meaning) + + #else #include <glog/logging.h> @@ -108,6 +127,7 @@ }                                                            using fLS::FLAGS_##name +#endif #endif  // HAVE_LIB_GFLAGS // Define GLOG_DEFINE_* using DEFINE_* . By using these macros, we diff --git a/src/base/mutex.h b/src/base/mutex.h index e82c597f..a58c1412 100644 --- a/src/base/mutex.h +++ b/src/base/mutex.h @@ -319,11 +319,6 @@ class WriterMutexLock { void operator=(const WriterMutexLock&); }; -// Catch bug where variable name is omitted, e.g. MutexLock (&mu); -#define MutexLock(x) COMPILE_ASSERT(0, mutex_lock_decl_missing_var_name) -#define ReaderMutexLock(x) COMPILE_ASSERT(0, rmutex_lock_decl_missing_var_name) -#define WriterMutexLock(x) COMPILE_ASSERT(0, wmutex_lock_decl_missing_var_name) - }  // namespace MUTEX_NAMESPACE using namespace MUTEX_NAMESPACE; diff --git a/src/config.h.cmake.in b/src/config.h.cmake.in index b225b7ec..a4c58c96 100644 --- a/src/config.h.cmake.in +++ b/src/config.h.cmake.in @@ -34,6 +34,8 @@ /* define if you have google gflags library */ #cmakedefine HAVE_LIB_GFLAGS +#cmakedefine HAVE_ABSL_FLAGS + /* define if you have google gmock library */ #cmakedefine HAVE_LIB_GMOCK diff --git a/src/glog/logging.h.in b/src/glog/logging.h.in index 95a573b1..54cd838f 100644 --- a/src/glog/logging.h.in +++ b/src/glog/logging.h.in @@ -89,6 +89,10 @@ #include <gflags/gflags.h> #endif +#if @ac_cv_have_abslflags@ +#include <absl/flags/declare.h> +#endif + #if @ac_cv_cxx11_atomic@ && __cplusplus >= 201103L #include <atomic> #elif defined(GLOG_OS_WINDOWS) @@ -395,6 +399,14 @@ typedef void(*CustomPrefixCallback)(std::ostream& s, const LogMessageInfo& l, vo #undef DECLARE_uint32 #endif +#if @ac_cv_have_abslflags@ +#define DECLARE_VARIABLE 1 +#define DECLARE_bool(name) ABSL_DECLARE_FLAG(bool, name) +#define DECLARE_int32(name) ABSL_DECLARE_FLAG(@ac_google_namespace@::int32, name) +#define DECLARE_uint32(name) ABSL_DECLARE_FLAG(@ac_google_namespace@::uint32, name) +#define DECLARE_string(name) ABSL_DECLARE_FLAG(std::string, name) +#endif + #ifndef DECLARE_VARIABLE #define DECLARE_VARIABLE(type, shorttype, name, tn)                      namespace fL##shorttype {                                              diff --git a/src/glog/vlog_is_on.h.in b/src/glog/vlog_is_on.h.in index 7526fc34..16e60f46 100644 --- a/src/glog/vlog_is_on.h.in +++ b/src/glog/vlog_is_on.h.in @@ -64,6 +64,14 @@ #include <glog/log_severity.h> #if defined(__GNUC__) + +#if @ac_cv_have_abslflags@ +  extern int32_t absl_proxy_v; +  #define VLEVEL (@ac_google_namespace@::absl_proxy_v) +#else +  #define VLEVEL (FLAGS_v) +#endif + // We emit an anonymous static int* variable at every VLOG_IS_ON(n) site. // (Normally) the first time every VLOG_IS_ON(n) site is hit, // we determine what variable will dynamically control logging at this site: @@ -74,7 +82,7 @@ __extension__   ({ static @ac_google_namespace@::SiteFlag vlocal__ = {NULL, NULL, 0, NULL};        @ac_google_namespace@::int32 verbose_level__ = (verboselevel);                     -     (vlocal__.level == NULL ? @ac_google_namespace@::InitVLOG3__(&vlocal__, &FLAGS_v,  +     (vlocal__.level == NULL ? @ac_google_namespace@::InitVLOG3__(&vlocal__, &VLEVEL,  __FILE__, verbose_level__) : *vlocal__.level >= verbose_level__);  }) #else diff --git a/src/logging.cc b/src/logging.cc index 4028ccc0..fc618d3a 100644 --- a/src/logging.cc +++ b/src/logging.cc @@ -103,7 +103,9 @@ using std::fdopen; #endif // There is no thread annotation support. +#ifndef EXCLUSIVE_LOCKS_REQUIRED #define EXCLUSIVE_LOCKS_REQUIRED(mu) +#endif static bool BoolFromEnv(const char *varname, bool defval) { const char* const valstr = getenv(varname); @@ -351,8 +353,9 @@ static const char* GetAnsiColorCode(GLogColor color) { // Safely get max_log_size, overriding to 1 if it somehow gets defined as 0 static uint32 MaxLogSize() { -  return (FLAGS_max_log_size > 0 && FLAGS_max_log_size < 4096 -              ? FLAGS_max_log_size +  uint32 maxlogsize = FLAG(max_log_size); +  return (maxlogsize > 0 && maxlogsize < 4096 +              ? maxlogsize : 1); } @@ -721,7 +724,7 @@ inline void LogDestination::SetStderrLogging(LogSeverity min_severity) { // Prevent any subtle race conditions by wrapping a mutex lock around // all this stuff. MutexLock l(&log_mutex); -  FLAGS_stderrthreshold = min_severity; +  absl::SetFlag(&FLAGS_stderrthreshold, min_severity); } inline void LogDestination::LogToStderr() { @@ -747,8 +750,8 @@ static void ColoredWriteToStderrOrStdout(FILE* output, LogSeverity severity, const char* message, size_t len) { bool is_stdout = (output == stdout); const GLogColor color = (LogDestination::terminal_supports_color() && -                           ((!is_stdout && FLAGS_colorlogtostderr) || -                            (is_stdout && FLAGS_colorlogtostdout))) +                           ((!is_stdout && FLAG(colorlogtostderr)) || +                            (is_stdout && FLAG(colorlogtostdout)))) ? SeverityToColor(severity) : COLOR_DEFAULT; @@ -789,7 +792,7 @@ static void ColoredWriteToStdout(LogSeverity severity, const char* message, FILE* output = stdout; // We also need to send logs to the stderr when the severity is // higher or equal to the stderr threshold. -  if (severity >= FLAGS_stderrthreshold) { +  if (severity >= FLAG(stderrthreshold)) { output = stderr; } ColoredWriteToStderrOrStdout(output, severity, message, len); @@ -808,7 +811,7 @@ static void WriteToStderr(const char* message, size_t len) { inline void LogDestination::MaybeLogToStderr(LogSeverity severity, const char* message, size_t message_len, size_t prefix_len) { -  if ((severity >= FLAGS_stderrthreshold) || FLAGS_alsologtostderr) { +  if ((severity >= FLAG(stderrthreshold)) || FLAG(alsologtostderr)) { ColoredWriteToStderr(severity, message, message_len); #ifdef GLOG_OS_WINDOWS (void) prefix_len; @@ -835,8 +838,8 @@ inline void LogDestination::MaybeLogToStderr(LogSeverity severity, inline void LogDestination::MaybeLogToEmail(LogSeverity severity, const char* message, size_t len) { if (severity >= email_logging_severity_ || -      severity >= FLAGS_logemaillevel) { -    string to(FLAGS_alsologtoemail); +      severity >= FLAG(logemaillevel)) { +    string to(FLAG(alsologtoemail)); if (!addresses_.empty()) { if (!to.empty()) { to += ","; @@ -862,7 +865,7 @@ inline void LogDestination::MaybeLogToLogfile(LogSeverity severity, time_t timestamp, const char* message, size_t len) { -  const bool should_flush = severity > FLAGS_logbuflevel; +  const bool should_flush = severity > FLAG(logbuflevel); LogDestination* destination = log_destination(severity); destination->logger_->Write(should_flush, timestamp, message, len); } @@ -871,9 +874,9 @@ inline void LogDestination::LogToAllLogfiles(LogSeverity severity, time_t timestamp, const char* message, size_t len) { -  if (FLAGS_logtostdout) {  // global flag: never log to file +  if (FLAG(logtostdout)) {  // global flag: never log to file ColoredWriteToStdout(severity, message, len); -  } else if (FLAGS_logtostderr) {  // global flag: never log to file +  } else if (FLAG(logtostderr)) {  // global flag: never log to file ColoredWriteToStderr(severity, message, len); } else { for (int i = severity; i >= 0; --i) { @@ -1032,25 +1035,25 @@ void LogFileObject::FlushUnlocked(){ bytes_since_flush_ = 0; } // Figure out when we are due for another flush. -  const int64 next = (FLAGS_logbufsecs +  const int64 next = (FLAG(logbufsecs) * static_cast<int64>(1000000));  // in usec next_flush_time_ = CycleClock_Now() + UsecToCycles(next); } bool LogFileObject::CreateLogfile(const string& time_pid_string) { string string_filename = base_filename_; -  if (FLAGS_timestamp_in_logfile_name) { +  if (FLAG(timestamp_in_logfile_name)) { string_filename += time_pid_string; } string_filename += filename_extension_; const char* filename = string_filename.c_str(); //only write to files, create if non-existant. int flags = O_WRONLY | O_CREAT; -  if (FLAGS_timestamp_in_logfile_name) { +  if (FLAG(timestamp_in_logfile_name)) { //demand that the file is unique for our timestamp (fail if it exists). flags = flags | O_EXCL; } -  int fd = open(filename, flags, FLAGS_logfile_mode); +  int fd = open(filename, flags, FLAG(logfile_mode)); if (fd == -1) return false; #ifdef HAVE_FCNTL // Mark the file close-on-exec. We don't really care if this fails @@ -1083,7 +1086,7 @@ bool LogFileObject::CreateLogfile(const string& time_pid_string) { file_ = fdopen(fd, "a");  // Make a FILE*. if (file_ == NULL) {  // Man, we're screwed! close(fd); -    if (FLAGS_timestamp_in_logfile_name) { +    if (FLAG(timestamp_in_logfile_name)) { unlink(filename);  // Erase the half-baked evidence: an unusable log file, only if we just created it. } return false; @@ -1125,8 +1128,8 @@ bool LogFileObject::CreateLogfile(const string& time_pid_string) { // Make an additional link to the log file in a place specified by // FLAGS_log_link, if indicated -    if (!FLAGS_log_link.empty()) { -      linkpath = FLAGS_log_link + "/" + linkname; +    if (!FLAG(log_link).empty()) { +      linkpath = FLAG(log_link) + "/" + linkname; unlink(linkpath.c_str());                  // delete old one if it exists if (symlink(filename, linkpath.c_str()) != 0) { // silently ignore failures @@ -1165,7 +1168,7 @@ void LogFileObject::Write(bool force_flush, rollover_attempt_ = 0; struct ::tm tm_time; -    if (FLAGS_log_utc_time) { +    if (FLAG(log_utc_time)) { gmtime_r(&timestamp, &tm_time); } else { localtime_r(&timestamp, &tm_time); @@ -1253,14 +1256,14 @@ void LogFileObject::Write(bool force_flush, << ' ' << setw(2) << tm_time.tm_hour << ':' << setw(2) << tm_time.tm_min << ':' -                       << setw(2) << tm_time.tm_sec << (FLAGS_log_utc_time ? " UTCn" : "n") +                       << setw(2) << tm_time.tm_sec << (FLAG(log_utc_time) ? " UTCn" : "n") << "Running on machine: " << LogDestination::hostname() << 'n'; if(!g_application_fingerprint.empty()) { file_header_stream << "Application fingerprint: " << g_application_fingerprint << 'n'; } -    const char* const date_time_format = FLAGS_log_year_in_prefix +    const char* const date_time_format = FLAG(log_year_in_prefix) ? "yyyymmdd hh:mm:ss.uuuuuu" : "mmdd hh:mm:ss.uuuuuu"; file_header_stream << "Running duration (h:mm:ss): " @@ -1284,7 +1287,7 @@ void LogFileObject::Write(bool force_flush, // greater than 4096, thereby indicating an error. errno = 0; fwrite(message, 1, message_len, file_); -    if ( FLAGS_stop_logging_if_full_disk && +    if ( FLAG(stop_logging_if_full_disk) && errno == ENOSPC ) {  // disk full, stop writing to disk stop_writing = true;  // until the disk is return; @@ -1307,7 +1310,7 @@ void LogFileObject::Write(bool force_flush, FlushUnlocked(); #ifdef GLOG_OS_LINUX // Only consider files >= 3MiB -    if (FLAGS_drop_log_memory && file_length_ >= (3U << 20U)) { +    if (FLAG(drop_log_memory) && file_length_ >= (3U << 20U)) { // Don't evict the most recent 1-2MiB so as not to impact a tailer // of the log file and to avoid page rounding issue on linux < 4.7 uint32 total_drop_length = @@ -1348,7 +1351,7 @@ void LogCleaner::Disable() { } void LogCleaner::UpdateCleanUpTime() { -  const int64 next = (FLAGS_logcleansecs +  const int64 next = (FLAG(logcleansecs) * 1000000);  // in usec next_cleanup_time_ = CycleClock_Now() + UsecToCycles(next); } @@ -1664,7 +1667,7 @@ void LogMessage::Init(const char* file, //    I20201018 160715 f5d4fbb0 logging.cc:1153] //    (log level, GMT year, month, date, time, thread_id, file basename, line) // We exclude the thread_id for the default thread. -  if (FLAGS_log_prefix && (line != kNoLogPrefix)) { +  if (FLAG(log_prefix) && (line != kNoLogPrefix)) { std::ios saved_fmt(NULL); saved_fmt.copyfmt(stream()); stream().fill('0'); @@ -1672,7 +1675,7 @@ void LogMessage::Init(const char* file, if (custom_prefix_callback == NULL) { #endif stream() << LogSeverityNames[severity][0]; -          if (FLAGS_log_year_in_prefix) { +          if (FLAG(log_year_in_prefix)) { stream() << setw(4) << 1900 + logmsgtime_.year(); } stream() << setw(2) << 1 + logmsgtime_.month() @@ -1703,11 +1706,11 @@ void LogMessage::Init(const char* file, } data_->num_prefix_chars_ = data_->stream_.pcount(); -  if (!FLAGS_log_backtrace_at.empty()) { +  if (!FLAG(log_backtrace_at).empty()) { char fileline[128]; snprintf(fileline, sizeof(fileline), "%s:%d", data_->basename_, line); #ifdef HAVE_STACKTRACE -    if (FLAGS_log_backtrace_at == fileline) { +    if (FLAG(log_backtrace_at) == fileline) { string stacktrace; DumpStackTraceToString(&stacktrace); stream() << " (stacktrace:n" << stacktrace << ") "; @@ -1746,7 +1749,7 @@ ostream& LogMessage::stream() { // Flush buffered message, called by the destructor, or any other function // that needs to synchronize the log. void LogMessage::Flush() { -  if (data_->has_been_flushed_ || data_->severity_ < FLAGS_minloglevel) { +  if (data_->has_been_flushed_ || data_->severity_ < FLAG(minloglevel)) { return; } @@ -1808,7 +1811,7 @@ static char fatal_message[256]; void ReprintFatalMessage() { if (fatal_message[0]) { const size_t n = strlen(fatal_message); -    if (!FLAGS_logtostderr) { +    if (!FLAG(logtostderr)) { // Also write to stderr (don't color to avoid terminal checks) WriteToStderr(fatal_message, n); } @@ -1837,8 +1840,8 @@ void LogMessage::SendToLog() EXCLUSIVE_LOCKS_REQUIRED(log_mutex) { // global flag: never log to file if set.  Also -- don't log to a // file if we haven't parsed the command line flags to get the // program name. -  if (FLAGS_logtostderr || FLAGS_logtostdout || !IsGoogleLoggingInitialized()) { -    if (FLAGS_logtostdout) { +  if (FLAG(logtostderr) || FLAG(logtostdout) || !IsGoogleLoggingInitialized()) { +    if (FLAG(logtostdout)) { ColoredWriteToStdout(data_->severity_, data_->message_text_, data_->num_chars_to_log_); } else { @@ -1891,7 +1894,7 @@ void LogMessage::SendToLog() EXCLUSIVE_LOCKS_REQUIRED(log_mutex) { fatal_time = logmsgtime_.timestamp(); } -    if (!FLAGS_logtostderr && !FLAGS_logtostdout) { +    if (!FLAG(logtostderr) && !FLAG(logtostdout)) { for (int i = 0; i < NUM_SEVERITIES; ++i) { if (LogDestination::log_destinations_[i]) { LogDestination::log_destinations_[i]->logger_->Write(true, 0, "", 0); @@ -2238,7 +2241,7 @@ static bool SendEmailInternal(const char*dest, const char *subject, subject, body, dest); } -    string logmailer = FLAGS_logmailer; +    string logmailer = FLAG(logmailer); if (logmailer.empty()) { logmailer = "/bin/mail"; } @@ -2338,9 +2341,9 @@ const vector<string>& GetLoggingDirectories() { if (logging_directories_list == NULL) { logging_directories_list = new vector<string>; -    if ( !FLAGS_log_dir.empty() ) { +    if ( !FLAG(log_dir).empty() ) { // A dir was specified, we should use it -      logging_directories_list->push_back(FLAGS_log_dir); +      logging_directories_list->push_back(FLAG(log_dir)); } else { GetTempDirectories(logging_directories_list); #ifdef GLOG_OS_WINDOWS @@ -2654,7 +2657,7 @@ LogMessageTime::LogMessageTime(std::tm t) { LogMessageTime::LogMessageTime(std::time_t timestamp, WallTime now) { std::tm t; -  if (FLAGS_log_utc_time) +  if (FLAG(log_utc_time)) gmtime_r(&timestamp, &t); else localtime_r(&timestamp, &t); @@ -2673,7 +2676,7 @@ void LogMessageTime::init(const std::tm& t, std::time_t timestamp, void LogMessageTime::CalcGmtOffset() { std::tm gmt_struct; int isDst = 0; -  if ( FLAGS_log_utc_time ) { +  if ( FLAG(log_utc_time )) { localtime_r(&timestamp_, &gmt_struct); isDst = gmt_struct.tm_isdst; gmt_struct = time_struct_; diff --git a/src/raw_logging.cc b/src/raw_logging.cc index 43159832..8532362b 100644 --- a/src/raw_logging.cc +++ b/src/raw_logging.cc @@ -123,8 +123,8 @@ static char crash_buf[kLogBufSize + 1] = { 0 };  // Will end in '0' GLOG_ATTRIBUTE_FORMAT(printf, 4, 5) void RawLog__(LogSeverity severity, const char* file, int line, const char* format, ...) { -  if (!(FLAGS_logtostdout || FLAGS_logtostderr || -        severity >= FLAGS_stderrthreshold || FLAGS_alsologtostderr || +  if (!(FLAG(logtostdout) || FLAG(logtostderr) || +        severity >= FLAG(stderrthreshold) || FLAG(alsologtostderr) || !IsGoogleLoggingInitialized())) { return;  // this stderr log message is suppressed } diff --git a/src/utilities.cc b/src/utilities.cc index a332f1a1..a9d5102a 100644 --- a/src/utilities.cc +++ b/src/utilities.cc @@ -141,7 +141,7 @@ static void DumpStackTrace(int skip_count, DebugWriter *writerfn, void *arg) { int depth = GetStackTrace(stack, ARRAYSIZE(stack), skip_count+1); for (int i = 0; i < depth; i++) { #if defined(HAVE_SYMBOLIZE) -    if (FLAGS_symbolize_stacktrace) { +    if (FLAG(symbolize_stacktrace)) { DumpPCAndSymbol(writerfn, arg, stack[i], "    "); } else { DumpPC(writerfn, arg, stack[i], "    "); diff --git a/src/vlog_is_on.cc b/src/vlog_is_on.cc index e478a366..4b7a5cae 100644 --- a/src/vlog_is_on.cc +++ b/src/vlog_is_on.cc @@ -43,14 +43,24 @@ #include <glog/logging.h> #include <glog/raw_logging.h> #include "base/googleinit.h" +#include "config.h" // glog doesn't have annotation #define ANNOTATE_BENIGN_RACE(address, description) using std::string; +#ifdef HAVE_ABSL_FLAGS + +ABSL_FLAG(int32_t, v, 0, "Show all VLOG(m) messages for m <= this." +" Overridable by --vmodule.").OnUpdate([] { +      GOOGLE_NAMESPACE::absl_proxy_v = absl::GetFlag(FLAGS_v); +    }); + +#else GLOG_DEFINE_int32(v, 0, "Show all VLOG(m) messages for m <= this." " Overridable by --vmodule."); +#endif GLOG_DEFINE_string(vmodule, "", "per-module verbose level." " Argument is a comma-separated list of <module name>=<log level>." @@ -60,6 +70,8 @@ GLOG_DEFINE_string(vmodule, "", "per-module verbose level." _START_GOOGLE_NAMESPACE_ +int32_t absl_proxy_v = 0; + namespace glog_internal_namespace_ { // Used by logging_unittests.cc so can't make it static here. @@ -132,7 +144,8 @@ static void VLOG2Initializer() { // Can now parse --vmodule flag and initialize mapping of module-specific // logging levels. inited_vmodule = false; -  const char* vmodule = FLAGS_vmodule.c_str(); +  string vmodule_str = FLAG(vmodule); +  const char* vmodule = vmodule_str.c_str(); const char* sep; VModuleInfo* head = NULL; VModuleInfo* tail = NULL; @@ -164,7 +177,7 @@ static void VLOG2Initializer() { // This can be called very early, so we use SpinLock and RAW_VLOG here. int SetVLOGLevel(const char* module_pattern, int log_level) { -  int result = FLAGS_v; +  int result = FLAG(v); size_t const pattern_len = strlen(module_pattern); bool found = false; { </ins>