glog学习（二）：glog主要接口和类分析

1.glog的主要接口如下。

#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);

// Shutdown
GOOGLE_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）初始化

（2）logdestination提供文件地址，文件前缀名，输出属性的设置接口。

（3）logmessage提供日志内容的具体输出接口，封装为LOG（…）。

（4）shutdown，析构

2.直接用到的类。

 从上述接口分析，我们可以得到我们直接接触到的类和文件。

2.1

LogMessage：This class more or less represents a particular log message.  You create an instance of LogMessage and then stream stuff to it. When you finish streaming to it, ~LogMessage is called and the full message gets streamed to the appropriate destination.从日志中我们可以看出，日志信息的输出主要看这个类，创建LogMessage的实例，获得数据流，结束后，调用析构函数~LogMessage()，然后stream流向目的文件。

LogMessage的主要成员说明，由于一些参数太长我就省略掉了，大家可以参考具体的文档。

 

LogMessage

Public:

class LogStream : public std::ostream  //流

LogMessage(***);//构造函数

~LogMessage();//析构函数

void Flush();

void SendToLog(); 

void SendToSyslogAndLog();   

static void __declspec(noreturn) Fail();

std::ostream& stream();

Private:

void SendToSinkAndLog(); 

void SendToSink();

void WriteToStringAndLog();

void SaveOrSendToLog();

void Init(……);

LogMessageData* allocated_;

LogMessageData* data_;

friend class LogDestination;

LogMessage(const LogMessage&);

void operator=(const LogMessage&);

 

日志内容的具体输出接口为LOG(***);其实是LogMessage封装后的接口，##起到连接的作用。 LOG(INFO) << str;其实替换过去就是COMPACT_GOOGLE_LOG_INFO.stream()<<str;最终调用的还是LogMessage的构造函数。

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

#if GOOGLE_STRIP_LOG == 0
#define COMPACT_GOOGLE_LOG_INFO google::LogMessage( \
      __FILE__, __LINE__)
#define LOG_TO_STRING_INFO(message) google::LogMessage( \
      __FILE__, __LINE__, google::GLOG_INFO, message)
#else
#define COMPACT_GOOGLE_LOG_INFO google::NullStream()
#define LOG_TO_STRING_INFO(message) google::NullStream()
#endif

下面我们看看构造函数的内容，就是初始化了一些东西，文件名称，Log等级，行号等参数。

LogMessage::LogMessage(const char* file, int line)
    : allocated_(NULL) {
  Init(file, line, GLOG_INFO, &LogMessage::SendToLog);
}

void LogMessage::Init(const char* file,int line,LogSeverity severity,void (LogMessage::*send_method)()) {/*do something*/ }

析构函数：

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

LogMessage中有一个友类，LogDestination，接下来我们看一下这个类。

2.2

LogDestination

LogDestination

Public:

  friend class LogMessage;

  friend void ReprintFatalMessage();

  friend base::Logger* base::GetLogger(LogSeverity);

  friend void base::SetLogger(LogSeverity, base::Logger*);

  static void SetLogDestination(LogSeverity severity, const char* base_filename);

  static void SetLogSymlink(LogSeverity severity, const char* symlink_basename);

  static void AddLogSink(LogSink *destination);

  static void RemoveLogSink(LogSink *destination);

  static void SetLogFilenameExtension(const char* filename_extension);

  static void SetStderrLogging(LogSeverity min_severity);

  static void SetEmailLogging(LogSeverity min_severity, const char* addresses);

  static void LogToStderr();

  static void FlushLogFiles(int min_severity);

  static void FlushLogFilesUnsafe(int min_severity);

  static const int kNetworkBytes = 1400;

  static const string& hostname();

  static const bool& terminal_supports_color();

  static void DeleteLogDestinations();

Private:

  LogDestination(LogSeverity severity, const char* base_filename);

  ~LogDestination() { }

  static vector<LogSink*>* sinks_;

  static Mutex sink_mutex_;

  LogDestination(const LogDestination&);

  LogDestination& operator=(const LogDestination&);

LogDestination主要提供了日志文件的名称设置接口和日志的书写方式。我们看个例子：

SetLogFilenameExtension：文件后缀名设置
效果如图

 

具体代码：

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

而SetExtension来自类LogFileObject，此处先不展开。我们看setExtension

/*
string filename_extension_;     // option users can specify (eg to add port#)
*/
void LogFileObject::SetExtension(const char* ext) {
  MutexLock l(&lock_);
  if (filename_extension_ != ext) {
    // Get rid of old log file since we are changing names
    if (file_ != NULL) {
      fclose(file_);
      file_ = NULL;
      rollover_attempt_ = kRolloverAttemptFrequency-1;
    }
    filename_extension_ = ext;
  }
}

可以看出LogDestination其实只是一个壳，负责和LogMessage以及其他的一些类进行互动。真正实现还得看LogFileObject类。

2.3

LogFileObject

LogFileObject : public base::Logger

  LogFileObject(LogSeverity severity, const char* base_filename);
  ~LogFileObject();

  virtual void Write(bool force_flush, // Should we force a flush here?
                     time_t timestamp,  // Timestamp for this entry
                     const char* message,
                     int message_len);

  // Configuration options
  void SetBasename(const char* basename);
  void SetExtension(const char* ext);
  void SetSymlinkBasename(const char* symlink_basename);

  // Normal flushing routine
  virtual void Flush();

  virtual uint32 LogSize() {
    MutexLock l(&lock_);
    return file_length_;
  }

  void FlushUnlocked();

  Mutex lock_;
  bool base_filename_selected_;
  string base_filename_;
  string symlink_basename_;
  string filename_extension_;   // option users can specify (eg to add port#)
  FILE* file_;
  LogSeverity severity_;
  uint32 bytes_since_flush_;
  uint32 dropped_mem_length_;
  uint32 file_length_;
  unsigned int rollover_attempt_;
  int64 next_flush_time_;

关于这个类，我们看一个函数：

void LogFileObject::Write(bool force_flush,
                          time_t timestamp,
                          const char* message,
                          int message_len) {
  MutexLock l(&lock_);

  //条件判断，不符合直接return
  if (base_filename_selected_ && base_filename_.empty()) {
    return;
  }


    if (base_filename_selected_) 
    {
        /*如果没有创建日志文件，return*/
      if (!CreateLogfile(time_pid_string)) {
        perror("Could not create log file");
        fprintf(stderr, "COULD NOT CREATE LOGFILE '%s'!\n",
                time_pid_string.c_str());
        return;
      }
    } 
    else
    {
    ostringstream file_header_stream;
    file_header_stream.fill('0');

    file_header_stream << "Log file created at: "
                       << 1900+tm_time.tm_year << '/'
                       << setw(2) << 1+tm_time.tm_mon << '/'
                       << setw(2) << tm_time.tm_mday
                       << ' '
                       << setw(2) << tm_time.tm_hour << ':'
                       << setw(2) << tm_time.tm_min << ':'
                       << setw(2) << tm_time.tm_sec << '\n'
                       << "Running on machine: "
                       << LogDestination::hostname() << '\n'
                       << "Log line format: [IWEF]mmdd hh:mm:ss.uuuuuu "
                       << "threadid file:line] msg" << '\n';
    const string& file_header_string = file_header_stream.str();

    const int header_len = file_header_string.size();
    fwrite(file_header_string.data(), 1, header_len, file_);
    file_length_ += header_len;
    bytes_since_flush_ += header_len;
  }
    /*写满了怎么办？*/
  // Write to LOG file
  if ( !stop_writing ) {
    // fwrite() doesn't return an error when the disk is full, for
    // messages that are less than 4096 bytes. When the disk is full,
    // it returns the message length for messages that are less than
    // 4096 bytes. fwrite() returns 4096 for message lengths that are
    // greater than 4096, thereby indicating an error.
    errno = 0;
    fwrite(message, 1, message_len, file_);
    if ( FLAGS_stop_logging_if_full_disk &&
         errno == ENOSPC ) {  // disk full, stop writing to disk
      stop_writing = true;  // until the disk is
      return;
    } else {
      file_length_ += message_len;
      bytes_since_flush_ += message_len;
    }
  } 
  else {
    if ( CycleClock_Now() >= next_flush_time_ )
      stop_writing = false;  // check to see if disk has free space.
    return;  // no need to flush
  }
/*do otherthings*/
}

对应的就是以下内容

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

我们再看一个函数：可以看出这个函数的功能就是创建文件名称。如果我们可以修改time_pid_string这个值，或者直接修改string_filename的值，就可以直接修改文件的名字，因为原始的名字真的是太长了，而且不便查找。

bool LogFileObject::CreateLogfile(const string& time_pid_string) {
  string string_filename = base_filename_+filename_extension_+
                           time_pid_string;
  const char* filename = string_filename.c_str();
  int fd = open(filename, O_WRONLY | O_CREAT | O_EXCL, FLAGS_logfile_mode);
  if (fd == -1) return false;
#ifdef HAVE_FCNTL
  // Mark the file close-on-exec. We don't really care if this fails
  fcntl(fd, F_SETFD, FD_CLOEXEC);
#endif

  file_ = fdopen(fd, "a");  // Make a FILE*.
  if (file_ == NULL) {  // Man, we're screwed!
    close(fd);
    unlink(filename);  // Erase the half-baked evidence: an unusable log file
    return false;
  }

  // We try to create a symlink called <program_name>.<severity>,
  // which is easier to use.  (Every time we create a new logfile,
  // we destroy the old symlink and create a new one, so it always
  // points to the latest logfile.)  If it fails, we're sad but it's
  // no error.
  /*do something*/
  
   return true;  // Everything worked
}

 

 

3.太深了……写不动了

 

参考网站：http://www.cnblogs.com/tianyajuanke/archive/2013/02/22/2921850.html