#define LOG(severity) COMPACT_GOOGLE_LOG_ ## severity.stream()#define SYSLOG(severity) SYSLOG_ ## severity(0).stream()

// Initialize.GOOGLE_GLOG_DLL_DECL void InitGoogleLogging(const char* argv0);

// ShutdownGOOGLE_GLOG_DLL_DECL void ShutdownGoogleLogging();

// 设置回调接口，如果失败调用接口.GOOGLE_GLOG_DLL_DECL void InstallFailureFunction(void (*fail_func)());

// Add or remove a LogSink as a consumer of logging data.  Thread-safe.
GOOGLE_GLOG_DLL_DECL void AddLogSink(LogSink *destination);
GOOGLE_GLOG_DLL_DECL void RemoveLogSink(LogSink *destination);//设置日志扩展名称，thread-safe。
GOOGLE_GLOG_DLL_DECL void SetLogFilenameExtension(const char* filename_extension);//
// 设置某种等级的日志标准输出，thread-safe.
//
GOOGLE_GLOG_DLL_DECL void SetStderrLogging(LogSeverity min_severity);//
// 设置所有的日志标准输出.  Thread-safe.
//
GOOGLE_GLOG_DLL_DECL void LogToStderr();//
// Make it so that all log messages of at least a particular severity are
// logged via email to a list of addresses (in addition to logging to the
// usual log file(s)).  The list of addresses is just a string containing
// the email addresses to send to (separated by spaces, say).  Thread-safe.
//
GOOGLE_GLOG_DLL_DECL void SetEmailLogging(LogSeverity min_severity,const char* addresses);// A simple function that sends email. dest is a commma-separated
// list of addressess.  Thread-safe.
GOOGLE_GLOG_DLL_DECL bool SendEmail(const char *dest,const char *subject, const char *body);GOOGLE_GLOG_DLL_DECL const std::vector<std::string>& GetLoggingDirectories();// For tests only:  Clear the internal [cached] list of logging directories to
// force a refresh the next time GetLoggingDirectories is called.
// Thread-hostile.
void TestOnly_ClearLoggingDirectoriesList();// Returns a set of existing temporary directories, which will be a
// subset of the directories returned by GetLogginDirectories().
// Thread-safe.
GOOGLE_GLOG_DLL_DECL void GetExistingTempDirectories(std::vector<std::string>* list);// Print any fatal message again -- useful to call from signal handler
// so that the last thing in the output is the fatal message.
// Thread-hostile, but a race is unlikely.
GOOGLE_GLOG_DLL_DECL void ReprintFatalMessage();// Truncate a log file that may be the append-only output of multiple
// processes and hence can't simply be renamed/reopened (typically a
// stdout/stderr).  If the file "path" is > "limit" bytes, copy the
// last "keep" bytes to offset 0 and truncate the rest. Since we could
// be racing with other writers, this approach has the potential to
// lose very small amounts of data. For security, only follow symlinks
// if the path is /proc/self/fd/*
GOOGLE_GLOG_DLL_DECL void TruncateLogFile(const char *path,int64 limit, int64 keep);// Truncate stdout and stderr if they are over the value specified by
// --max_log_size; keep the final 1MB.  This function has the same
// race condition as TruncateLogFile.
GOOGLE_GLOG_DLL_DECL void TruncateStdoutStderr();// Return the string representation of the provided LogSeverity level.
// Thread-safe.
GOOGLE_GLOG_DLL_DECL const char* GetLogSeverityName(LogSeverity severity);

 1 #define LOG(severity) COMPACT_GOOGLE_LOG_ ## severity.stream()
 2 #define SYSLOG(severity) SYSLOG_ ## severity(0).stream()
 3
 4 #if GOOGLE_STRIP_LOG == 0
 5 #define COMPACT_GOOGLE_LOG_INFO google::LogMessage( \
 6       __FILE__, __LINE__)
 7 #define LOG_TO_STRING_INFO(message) google::LogMessage( \
 8       __FILE__, __LINE__, google::GLOG_INFO, message)
 9 #else
10 #define COMPACT_GOOGLE_LOG_INFO google::NullStream()
11 #define LOG_TO_STRING_INFO(message) google::NullStream()
12 #endif

 1 LogMessage::LogMessage(const char* file, int line)
 2     : allocated_(NULL) {
 3   Init(file, line, GLOG_INFO, &LogMessage::SendToLog);
 4 }
 5
 6 void LogMessage::Init(const char* file,int line,LogSeverity severity,void (LogMessage::*send_method)()) {/*do something*/ }

1 LogMessage::~LogMessage() {
2   Flush();//写数据
3 }
4 // Flush buffered message, called by the destructor, or any other function
5 // that needs to synchronize the log.
6 void LogMessage::Flush() {/*flush*/}

1 inline void LogDestination::SetLogFilenameExtension(const char* ext) {
2   // Prevent any subtle race conditions by wrapping a mutex lock around
3   // all this stuff.
4   MutexLock l(&log_mutex);
5   for ( int severity = 0; severity < NUM_SEVERITIES; ++severity ) {
6     log_destination(severity)->fileobject_.SetExtension(ext);
7   }
8 }

 1 /*
 2 string filename_extension_;     // option users can specify (eg to add port#)
 3 */
 4 void LogFileObject::SetExtension(const char* ext) {
 5   MutexLock l(&lock_);
 6   if (filename_extension_ != ext) {
 7     // Get rid of old log file since we are changing names
 8     if (file_ != NULL) {
 9       fclose(file_);
10       file_ = NULL;
11       rollover_attempt_ = kRolloverAttemptFrequency-1;
12     }
13     filename_extension_ = ext;
14   }
15 }

 1 void LogFileObject::Write(bool force_flush,
 2                           time_t timestamp,
 3                           const char* message,
 4                           int message_len) {
 5   MutexLock l(&lock_);
 6
 7   //条件判断，不符合直接return
 8   if (base_filename_selected_ && base_filename_.empty()) {
 9     return;
10   }
11
12
13     if (base_filename_selected_)
14     {
15         /*如果没有创建日志文件，return*/
16       if (!CreateLogfile(time_pid_string)) {
17         perror("Could not create log file");
18         fprintf(stderr, "COULD NOT CREATE LOGFILE '%s'!\n",
19                 time_pid_string.c_str());
20         return;
21       }
22     }
23     else
24     {
25     ostringstream file_header_stream;
26     file_header_stream.fill('0');
27
28     file_header_stream << "Log file created at: "
29                        << 1900+tm_time.tm_year << '/'
30                        << setw(2) << 1+tm_time.tm_mon << '/'
31                        << setw(2) << tm_time.tm_mday
32                        << ' '
33                        << setw(2) << tm_time.tm_hour << ':'
34                        << setw(2) << tm_time.tm_min << ':'
35                        << setw(2) << tm_time.tm_sec << '\n'
36                        << "Running on machine: "
37                        << LogDestination::hostname() << '\n'
38                        << "Log line format: [IWEF]mmdd hh:mm:ss.uuuuuu "
39                        << "threadid file:line] msg" << '\n';
40     const string& file_header_string = file_header_stream.str();
41
42     const int header_len = file_header_string.size();
43     fwrite(file_header_string.data(), 1, header_len, file_);
44     file_length_ += header_len;
45     bytes_since_flush_ += header_len;
46   }
47     /*写满了怎么办？*/
48   // Write to LOG file
49   if ( !stop_writing ) {
50     // fwrite() doesn't return an error when the disk is full, for
51     // messages that are less than 4096 bytes. When the disk is full,
52     // it returns the message length for messages that are less than
53     // 4096 bytes. fwrite() returns 4096 for message lengths that are
54     // greater than 4096, thereby indicating an error.
55     errno = 0;
56     fwrite(message, 1, message_len, file_);
57     if ( FLAGS_stop_logging_if_full_disk &&
58          errno == ENOSPC ) {  // disk full, stop writing to disk
59       stop_writing = true;  // until the disk is
60       return;
61     } else {
62       file_length_ += message_len;
63       bytes_since_flush_ += message_len;
64     }
65   }
66   else {
67     if ( CycleClock_Now() >= next_flush_time_ )
68       stop_writing = false;  // check to see if disk has free space.
69     return;  // no need to flush
70   }
71 /*do otherthings*/
72 }

Log file created at: 2019/01/28 15:27:56
Running on machine: HostName
Log line format: [IWEF]mmdd hh:mm:ss.uuuuuu threadid file:line] msg
I0128 15:27:56.937649 16208 glogtest.cpp:20] hello log!
I0128 15:27:56.958592 16208 glogtest.cpp:21] info testhello log!
W0128 15:27:56.958592 16208 glogtest.cpp:22] warning test
E0128 15:27:56.958592 16208 glogtest.cpp:23] error test

 1 bool LogFileObject::CreateLogfile(const string& time_pid_string) {
 2   string string_filename = base_filename_+filename_extension_+
 3                            time_pid_string;
 4   const char* filename = string_filename.c_str();
 5   int fd = open(filename, O_WRONLY | O_CREAT | O_EXCL, FLAGS_logfile_mode);
 6   if (fd == -1) return false;
 7 #ifdef HAVE_FCNTL
 8   // Mark the file close-on-exec. We don't really care if this fails
 9   fcntl(fd, F_SETFD, FD_CLOEXEC);
10 #endif
11
12   file_ = fdopen(fd, "a");  // Make a FILE*.
13   if (file_ == NULL) {  // Man, we're screwed!
14     close(fd);
15     unlink(filename);  // Erase the half-baked evidence: an unusable log file
16     return false;
17   }
18
19   // We try to create a symlink called <program_name>.<severity>,
20   // which is easier to use.  (Every time we create a new logfile,
21   // we destroy the old symlink and create a new one, so it always
22   // points to the latest logfile.)  If it fails, we're sad but it's
23   // no error.
24   /*do something*/
25
26    return true;  // Everything worked
27 }