log流程
宏定义：
#define LOG(severity) COMPACT_GOOGLE_LOG_ ## severity.stream()
498 #if GOOGLE_STRIP_LOG == 0
499 #define COMPACT_GOOGLE_LOG_INFO @ac_google_namespace@::LogMessage( \
500 __FILE__, __LINE__)
501 #define LOG_TO_STRING_INFO(message) @ac_google_namespace@::LogMessage( \
502 __FILE__, __LINE__, @ac_google_namespace@::GLOG_INFO, message)
503 #else
504 #define COMPACT_GOOGLE_LOG_INFO @ac_google_namespace@::NullStream()
505 #define LOG_TO_STRING_INFO(message) @ac_google_namespace@::NullStream()
506 #endif
构造对象LogMessage
1574 LogMessage::LogMessage(const char* file, int line)
1575 : allocated_(NULL) {
1576 Init(file, line, GLOG_INFO, &LogMessage::SendToLog);
1577 }
然后获取stream()
1742 ostream& LogMessage::stream() {
1743 return data_->stream_;
1744 }
1745
data类型LogMessageData，stream_类型LogStream
class GLOG_EXPORT LogStream : public std::ostream {
}
最终会通过操作符 << 向std::ostream中写入数据?
LogMessageData初始化
在LogMessage构造下Init函数中完成
如果支持线程数据，则在thread_msg_data处调用placement new构造LogMessageData
thread_msg_data定义如下，即线程存储：
1546 #if defined(HAVE_ALIGNED_STORAGE) && __cplusplus >= 201103L
1547 static GLOG_THREAD_LOCAL_STORAGE
1548 std::aligned_storage<sizeof(LogMessage::LogMessageData),
1549 alignof(LogMessage::LogMessageData)>::type thread_msg_data;
1550 #else
1551 static GLOG_THREAD_LOCAL_STORAGE
1552 char thread_msg_data[sizeof(void*) + sizeof(LogMessage::LogMessageData)];
1553 #endif // HAVE_ALIGNED_STORAGE
1554 #endif // defined(GLOG_THREAD_LOCAL_STORAGE)
LogMessageData构造：
1556 LogMessage::LogMessageData::LogMessageData()
1557 : stream_(message_text_, LogMessage::kMaxLogMessageLen, 0) {
1558 }
这里message_text_是 字符数组?
LogStream构造?：
1484 LogStream(char *buf, int len, int64 ctr)
1485 : std::ostream(NULL),
1486 streambuf_(buf, len),
1487 ctr_(ctr),
1488 self_(this) {
1489 rdbuf(&streambuf_);
1490 }
LogMessage构造下Init函数中会设置回调函数：
data_->send_method_ = send_method
即LogMessage::SendToLog
磁盘刷新时机
1723 LogMessage::~LogMessage() {
1724 Flush();
1725 #ifdef GLOG_THREAD_LOCAL_STORAGE
1726 if (data_ == static_cast<void*>(&thread_msg_data)) {
1727 data_->~LogMessageData();
1728 thread_data_available = true;
1729 }
1730 else {
1731 delete allocated_;
1732 }
1733 #else // !defined(GLOG_THREAD_LOCAL_STORAGE)
1734 delete allocated_;
1735 #endif // defined(GLOG_THREAD_LOCAL_STORAGE)
1736 }
LogMessage::Flush()实现
1748 void LogMessage::Flush() {
1775 {
1776 MutexLock l(&log_mutex);
1777 (this->*(data_->send_method_))();
1778 ++num_messages_[static_cast<int>(data_->severity_)];
1779 }
}
写文件实现
SendToLog实现
void LogMessage::SendToLog() EXCLUSIVE_LOCKS_REQUIRED(log_mutex) {
1858 LogDestination::LogToAllLogfiles(data_->severity_, logmsgtime_.timestamp(),
1859 data_->message_text_,
1860 data_->num_chars_to_log_);
1861
1862 LogDestination::MaybeLogToStderr(data_->severity_, data_->message_text_,
1863 data_->num_chars_to_log_,
1864 data_->num_prefix_chars_);
1865 LogDestination::MaybeLogToEmail(data_->severity_, data_->message_text_,
1866 data_->num_chars_to_log_);
1867 LogDestination::LogToSinks(data_->severity_,
1868 data_->fullname_, data_->basename_,
1869 data_->line_, logmsgtime_,
1870 data_->message_text_ + data_->num_prefix_chars_,
1871 (data_->num_chars_to_log_
1872 - data_->num_prefix_chars_ - 1) );
}
具体实现在LogToAllLogfiles?
870 inline void LogDestination::LogToAllLogfiles(LogSeverity severity,
871 time_t timestamp,
872 const char* message,
873 size_t len) {
874 if (FLAGS_logtostdout) { // global flag: never log to file
875 ColoredWriteToStdout(severity, message, len);
876 } else if (FLAGS_logtostderr) { // global flag: never log to file
877 ColoredWriteToStderr(severity, message, len);
878 } else {
879 for (int i = severity; i >= 0; --i) {
880 LogDestination::MaybeLogToLogfile(i, timestamp, message, len);
881 }
882 }
883 }
然后
861 inline void LogDestination::MaybeLogToLogfile(LogSeverity severity,
862 time_t timestamp,
863 const char* message,
864 size_t len) {
865 const bool should_flush = severity > FLAGS_logbuflevel;
866 LogDestination* destination = log_destination(severity);
867 destination->logger_->Write(should_flush, timestamp, message, len);
868 }
最终调用LogFileObject::Write：
- 如果file_length_过大，关闭file_
- 获取时间，调用CreateLogfile创建文件，使用文件锁fcntl(fd, F_SETLK, &w_lock）防止多个客户端写文件，创建软连接
- 生成文件头信息，写入文件，fwrite(file_header_string.data(), 1, header_len, file_)，更新字段
????????1274 ? ? file_length_ += header_len;
????????1275 ? ? bytes_since_flush_ += header_len;
- 写入消息，调用fwrite(message, 1, message_len, file_);更新字段
????????1274 ? ? file_length_ += header_len;
????????1275 ? ? bytes_since_flush_ += header_len;
1304 if ( force_flush ||
1305 (bytes_since_flush_ >= 1000000) ||
1306 (CycleClock_Now() >= next_flush_time_) ) {
1307 FlushUnlocked();
即满足下面其一：
1.?force_flush =severity > FLAGS_logbuflevel（默认0）
2.fwrite写入数据大约超过980k
3.FLAGS_logbufsecs默认30秒，即超过30秒更新
1035 ? const int64 next = (FLAGS_logbufsecs * static_cast<int64>(1000000)); ?// in usec
1037 ? next_flush_time_ = CycleClock_Now() + UsecToCycles(next);
C标准缓冲刷新
1024 void LogFileObject::Flush() {
1025 MutexLock l(&lock_);
1026 FlushUnlocked();
1027 }
1028
1029 void LogFileObject::FlushUnlocked(){
1030 if (file_ != NULL) {
1031 fflush(file_);
1032 bytes_since_flush_ = 0;
1033 }
1034 // Figure out when we are due for another flush.
1035 const int64 next = (FLAGS_logbufsecs
1036 * static_cast<int64>(1000000)); // in usec
1037 next_flush_time_ = CycleClock_Now() + UsecToCycles(next);
1038 }
配置项
logging.cpp中
116 GLOG_DEFINE_bool(timestamp_in_logfile_name,
117 BoolFromEnv("GOOGLE_TIMESTAMP_IN_LOGFILE_NAME", true),
118 "put a timestamp at the end of the log file name");
119 GLOG_DEFINE_bool(logtostderr, BoolFromEnv("GOOGLE_LOGTOSTDERR", false),
120 "log messages go to stderr instead of logfiles");
121 GLOG_DEFINE_bool(alsologtostderr, BoolFromEnv("GOOGLE_ALSOLOGTOSTDERR", false),
122 "log messages go to stderr in addition to logfiles");
123 GLOG_DEFINE_bool(colorlogtostderr, false,
124 "color messages logged to stderr (if supported by terminal)");
125 GLOG_DEFINE_bool(colorlogtostdout, false,
126 "color messages logged to stdout (if supported by terminal)");
127 GLOG_DEFINE_bool(logtostdout, BoolFromEnv("GOOGLE_LOGTOSTDOUT", false),
128 "log messages go to stdout instead of logfiles");
129 #ifdef GLOG_OS_LINUX
130 GLOG_DEFINE_bool(drop_log_memory, true, "Drop in-memory buffers of log contents. "
131 "Logs can grow very quickly and they are rarely read before they "
132 "need to be evicted from memory. Instead, drop them from memory "
133 "as soon as they are flushed to disk.");
134 #endif
141 DEFINE_int32(stderrthreshold,
142 GOOGLE_NAMESPACE::GLOG_ERROR,
143 "log messages at or above this level are copied to stderr in "
144 "addition to logfiles. This flag obsoletes --alsologtostderr.");
145
146 GLOG_DEFINE_string(alsologtoemail, "",
147 "log messages go to these email addresses "
148 "in addition to logfiles");
149 GLOG_DEFINE_bool(log_prefix, true,
150 "Prepend the log prefix to the start of each log line");
151 GLOG_DEFINE_bool(log_year_in_prefix, true,
152 "Include the year in the log prefix");
153 GLOG_DEFINE_int32(minloglevel, 0, "Messages logged at a lower level than this don't "
154 "actually get logged anywhere");
155 GLOG_DEFINE_int32(logbuflevel, 0,
156 "Buffer log messages logged at this level or lower"
157 " (-1 means don't buffer; 0 means buffer INFO only;"
158 " ...)");
159 GLOG_DEFINE_int32(logbufsecs, 30,
160 "Buffer log messages for at most this many seconds");
161
162 GLOG_DEFINE_int32(logcleansecs, 60 * 5, // every 5 minutes
163 "Clean overdue logs every this many seconds");
164
165 GLOG_DEFINE_int32(logemaillevel, 999,
166 "Email log messages logged at this level or higher"
167 " (0 means email all; 3 means email FATAL only;"
168 " ...)");
169 GLOG_DEFINE_string(logmailer, "",
170 "Mailer used to send logging email");
186 GLOG_DEFINE_int32(logfile_mode, 0664, "Log file mode/permissions.");
187
188 GLOG_DEFINE_string(log_dir, DefaultLogDir(),
189 "If specified, logfiles are written into this directory instead "
190 "of the default logging directory.");
191 GLOG_DEFINE_string(log_link, "", "Put additional links to the log "
192 "files in this directory");
193
194 GLOG_DEFINE_uint32(max_log_size, 1800,
195 "approx. maximum log file size (in MB). A value of 0 will "
196 "be silently overridden to 1.");
197
198 GLOG_DEFINE_bool(stop_logging_if_full_disk, false,
199 "Stop attempting to log to disk if the disk is full.");
200
201 GLOG_DEFINE_string(log_backtrace_at, "",
202 "Emit a backtrace when logging at file:linenum.");
203
204 GLOG_DEFINE_bool(log_utc_time, false,
205 "Use UTC time for logging.");
minloglevel，小于该值不会fwrite
logbuflevel，大于该值强制刷新
logbufsecs（单位秒），超过该时间刷新
max_log_size（单位M），文件大小
drop_log_memory，当为true且?file_length_ >= (3U << 20U)即大于3M，会通过计算决定是否调用
1322 posix_fadvise(fileno(file_), dropped_mem_length_, this_drop_length,
1323 POSIX_FADV_DONTNEED);
posix_fadvise是一个用于控制 page cache 预读或清理策略的接口。应用可以使用这个接口来告诉内核，接下来将以何种模式访问文件数据，从而允许内核执行适当的优化。但是，这个接口对内核提交的是建议，不一定会被采纳。
POSIX_FADV_DONTNEED ：指定的数据将不会被访问，丢弃 page cache 中的数据，内核先将脏页异步刷盘，并且只会尽力而为，清除掉自己能清除的缓存，而不会等待刷脏完成后再清除文件的全部缓存。
总结
1.基本上可以做到同步刷新（但没调用fsync相关）
2.多线程下有锁，性能会差
3.每次写日志的构造和析构，性能影响未知
4.设计较好，扩展多，方便使用，适用于通用场景，不适用高性能场景
5.如果再深究，就需要看fwrite源码了
|