目录
前言
日志存储的实现
日志输出的实现
总结
前言
muduo中的日志，是诊断日志。用于将代码运行时的重要信息进行保存，方便故障诊断和追踪。
日志一般有两种，一种是同步日志，一种是异步日志，同步日志就是当需要写出一条日志信息的时候，只有等到这条日志消息完全写出之后才能执行后续的程序，可见，这种方式的日志的问题就在于程序可能会阻塞在磁盘写入操作上；
而另一种异步日志则不会，异步日志的思路是需要写日志消息的时候只是将日志消息进行存储，当积累到一定量或者到达一定时间间隔时，由后台线程自动将存储的所有日志进行输出，可见，对于异步日志来说，每次有日志消息产生的时候，只需要一个存储的行为即可，存储结束就可以执行后面的业务代码了，而真正写入到磁盘的操作，是由后台线程进行的，这样做的好处就是：前台线程不会阻塞在写日志上，后台线程真正写出日志时，日志消息往往已经积累了很多，此时只需要调用一次IO函数，如fwrite，而不需要每条消息都调用一个IO函数，如此减少了IO函数调用次数，提高了效率。
而muduo中实现的，就是异步日志。
muduo中的日志消息格式为：时间 线程id 日志级别 日志正文 源文件名及行号。
日志设置了6种级别：TRACE、DEBUG、INFO、WARN、ERROR和FATAL。
日志的输出形式为流形式：日志级别<<message; 如 LOG_ERROR<<"file cannot open!";
如上所述，异步日志的实现关键，是先将日志消息进行存储，然后由后台线程进行写出。muduo将“日志存储”和“日志输出”分为了两大块，现在先来看看日志的存储部分。
日志存储的实现
前面说过，日志的输出形式为流形式，但muduo并没有使用C++自带的iostream等流库，而是使用自己实现的LogStream，用简短的代码量实现需要的功能，抛去其它不需要的冗杂的功能，使得代码效率更高。
实现”日志流“的基础，还需要一个内置的缓冲区，muduo通过FixedBuffer类来实现，如下所示：
/*LogStream.h*/
template<int SIZE>//构造时需要指定缓冲区大小
class FixedBuffer : noncopyable
{
public:
FixedBuffer()
: cur_(data_)
{
setCookie(cookieStart);
}
~FixedBuffer()
{
setCookie(cookieEnd);
}
void append(const char* /*restrict*/ buf, size_t len)//在缓冲区空闲处memcpy
{
// FIXME: append partially
if (implicit_cast<size_t>(avail()) > len)//如果剩余的缓冲区空间足以放下len长度的buf
{
memcpy(cur_, buf, len);
cur_ += len;
}
}
const char* data() const { return data_; }
int length() const { return static_cast<int>(cur_ - data_); }
char* current() { return cur_; }//返回当前缓冲区空闲位置
int avail() const { return static_cast<int>(end() - cur_); } //返回剩余有用的空间大小
void add(size_t len) { cur_ += len; }//当前位置指针往后偏移
void reset() { cur_ = data_; }//相当于缓冲区重置为空闲
void bzero() { memZero(data_, sizeof data_); }//清零
...
// for used by unit test
string toString() const { return string(data_, length()); }//把当前缓冲区的内容转换为string
StringPiece toStringPiece() const { return StringPiece(data_, length()); }//
private:
const char* end() const { return data_ + sizeof data_; } //返回最后一个字符的地址
...
char data_[SIZE]; //缓冲区
char* cur_; //当前空闲缓冲区头部地址
};
FixedBuffer是一个模板类，模板参数用来指定缓冲区data_的大小，并提供一系列缓冲区操作函数。
此时再来看LogStream类，LogStream重载了多个版本的"<<"运算符，如下所示：
/*LogStream.h*/
class LogStream : noncopyable
{
typedef LogStream self;
public:
typedef detail::FixedBuffer<detail::kSmallBuffer> Buffer; //4K大小的缓冲区类型
/*多个<<重载版本，内部实际上都调用了append函数*/
self& operator<<(bool v);
self& operator<<(short);
self& operator<<(unsigned short);
self& operator<<(int);
self& operator<<(unsigned int);
self& operator<<(long);
self& operator<<(unsigned long);
self& operator<<(long long);
self& operator<<(unsigned long long);
self& operator<<(const void*);
self& operator<<(float v);
self& operator<<(char v);
self& operator<<(const char* str);
self& operator<<(const unsigned char* str);
self& operator<<(const string& v);
self& operator<<(const StringPiece& v);
self& operator<<(const Buffer& v);
void append(const char* data, int len) { buffer_.append(data, len); }
const Buffer& buffer() const { return buffer_; }
void resetBuffer() { buffer_.reset(); }
private:
void staticCheck();
template<typename T>
void formatInteger(T); //用来将T类型的数字转换为字符串，放到缓冲区中
Buffer buffer_; //缓冲区
static const int kMaxNumericSize = 32;
};
可以看到，LogStream类通过重载”<<“来实现”日志流“的形式，不管是哪一种重载版本，最终都是会调用append函数，而append函数中又会去调用LogStream类中buffer_的append函数，可以看到，这里的buffer_实际上就是一个FixedBuffer的对象，也就相当于是一个缓冲区，其大小由kSmallBuffer指定，为4K字节。
通过上面的分析，可以知道”日志流“是通过LogStream来实现的，而”日志流“中的缓冲区则是由FixedBuffer来实现。
至此也就明白了每条日志是如何通过"<<"来进行存储的，但是光是存储是不行的，存储只是一个收集日志消息的作用，不可能把大量的日志都放在内存中，最终还是得将收集到的所有日志输出到某一个指定的地方去，因此接着来分析日志的输出。
日志输出的实现
显然，作为一个日志输出的类，其中应包含LogStream的一个实例用来存储日志消息，这一点体现在Impl类中，如下所示：
class Impl
{
public:
typedef Logger::LogLevel LogLevel;
Impl(LogLevel level, int old_errno, const SourceFile& file, int line);//需要用日志级别、错误信息、文件名和行号构造
void formatTime(); //获取当前的时间到time_中
void finish();
Timestamp time_; //时间
LogStream stream_; //自带一个4K大小缓冲区
LogLevel level_; //日志级别
int line_; //行数
SourceFile basename_; //文件名
};
Impl的5个成员，分别对应了日志消息生成的时间、存储的日志消息、日志消息级别、日志消息所在的文件名（注意，这个文件名指的是产生日志的线程所在的文件名）及其行数，这几乎构成了在本文最初所说的muduo日志消息格式中的大部分要素。而对于Impl的构造函数，则需要指定这些信息，来看下Impl类唯一的构造函数以及finish函数：
Impl::Impl(LogLevel level, int savedErrno, const SourceFile& file, int line)
: time_(Timestamp::now()),
stream_(),
level_(level),
line_(line),
basename_(file)
{
formatTime();//根据time_获取当前时间，写入缓冲区
CurrentThread::tid();
stream_ << T(CurrentThread::tidString(), CurrentThread::tidStringLength());//向缓冲区中写入线程id
stream_ << T(LogLevelName[level], 6);//向缓冲区中写入日志级别
if (savedErrno != 0)
{
stream_ << strerror_tl(savedErrno) << " (errno=" << savedErrno << ") ";
}
}
void Impl::finish()//向缓冲区中写入文件名和行号
{
stream_ << " - " << basename_ << ':' << line_ << '\n';
}
可以看到，在构造函数中，就会将当前时间、当前线程id以及日志级别写入到缓冲区stream_中，如果构造函数的第二个参数不为0，那么还会把系统错误errno对应的错误描述也添加到缓冲区stream_中。而在finish函数中，则会将文件名和行号写入缓冲区。至此可以看到，通过Impl类可以将日志格式中除日志正文外的所有要素都写入缓冲区stream_中，那么，日志正文又是何时写入呢？
完整的日志输出，是通过Logger类来实现的，其定义如下所示：
class Logger
{
public:
enum LogLevel //几种日志级别
{
TRACE,
DEBUG,
INFO,
WARN,
ERROR,
FATAL,
NUM_LOG_LEVELS,
};
// compile time calculation of basename of source file
...
//用构造函数的参数去初始化impl类型成员，即初始化缓冲区
Logger(SourceFile file, int line);
Logger(SourceFile file, int line, LogLevel level);
Logger(SourceFile file, int line, LogLevel level, const char* func);
Logger(SourceFile file, int line, bool toAbort);
~Logger();
LogStream& stream() { return impl_.stream_; }
static LogLevel logLevel();
static void setLogLevel(LogLevel level);
typedef void (*OutputFunc)(const char* msg, int len);
typedef void (*FlushFunc)();
static void setOutput(OutputFunc);
static void setFlush(FlushFunc);
static void setTimeZone(const TimeZone& tz);
private:
Impl impl_;//构造Logger类时就会构造impl_，此时缓冲区中就会自动写入当前线程id和日志级别
};
Logger::~Logger()
{
impl_.finish();//析构时向缓冲区写入文件名和行号
const LogStream::Buffer& buf(stream().buffer());//获取当前缓冲区的所有数据
g_output(buf.data(), buf.length());//调用输出函数
...
}
可以看到，在Logger类中，存在一个Impl类的实例，Logger类的多种构造函数实际上也是用构造参数去构造了impl，因此，日志消息本身实际上是存在于impl_中的，如前所述，它在构造时会向impl_的缓冲区stream_中写入时间、线程id和日志级别，而在Logger析构时，又会调用finish函数，向impl_的缓冲区stream_中写入文件名和行号。因此，如果想要写入日志正文，实际上也是对impl_的缓冲区stream_进行写入，如通过Logger实例执行stream()<<"log message";那么在该Logger实例析构时，就会将时间+线程id+日志级别+"log message"+文件名+行号写到Logger中impl_成员的缓冲区中。
当然，Logger调用析构函数时，日志才算是按照格式完整写好，此时就需要立刻将这条日志”写出到某个指定的地方“来完成日志的输出功能。实际的日志输出，是通过一个全局函数指针g_output实现的，当日志写完后，Logger的析构函数就会调用g_output所指向的函数进行日志输出，g_output可由setOutput函数进行设置，也提供默认的输出函数，如下所示：
void defaultOutput(const char* msg, int len)
{
size_t n = fwrite(msg, 1, len, stdout);
//FIXME check n
(void)n;
}
可见，默认的输出函数就是将日志消息写到到stdout即标准输出中，在未重定向stdout的情况下，会将这条日志消息打印到终端屏幕上。
至此，也就完成了日志的输出。
根据Logger类也可以知道，每一条日志消息应当都对应一个Logger类的实例，实例构造和析构时会自动写入一些必备的消息元素，并在析构时自动将该日志消息通过g_output进行输出。
muduo中每一种日志级别都对应了一条宏定义，如下所示：
#define LOG_TRACE if (muduo::Logger::logLevel() <= muduo::Logger::TRACE) \
muduo::Logger(__FILE__, __LINE__, muduo::Logger::TRACE, __func__).stream()
#define LOG_DEBUG if (muduo::Logger::logLevel() <= muduo::Logger::DEBUG) \
muduo::Logger(__FILE__, __LINE__, muduo::Logger::DEBUG, __func__).stream()
#define LOG_INFO if (muduo::Logger::logLevel() <= muduo::Logger::INFO) \
muduo::Logger(__FILE__, __LINE__).stream()
#define LOG_WARN muduo::Logger(__FILE__, __LINE__, muduo::Logger::WARN).stream()
#define LOG_ERROR muduo::Logger(__FILE__, __LINE__, muduo::Logger::ERROR).stream()
#define LOG_FATAL muduo::Logger(__FILE__, __LINE__, muduo::Logger::FATAL).stream()
#define LOG_SYSERR muduo::Logger(__FILE__, __LINE__, false).stream()
#define LOG_SYSFATAL muduo::Logger(__FILE__, __LINE__, true).stream()
这些宏定义，最终都是对应impl_成员的缓冲区，只不过用来构造impl_的日志级别参数有所不同。这也就相当于构造了不同的临时缓冲区对象，如调用LOG_Info<<"log info";就会构造一个临时的Logger对象，在该条语句执行结束后就会析构，这样就可以通过一条语句实现日志消息的写入和输出，最终将 时间+线程id+日志级别+"log message"+文件名+行号 打印到终端屏幕上。
每一条日志消息都会对应一个Logger的临时对象，这样的好处是可以及时的将日志消息进行输出，占用的内存也可以立即释放。
总结
至此，分析了muduo中日志消息的存储以及输出，不过还未涉及到异步的实现，将在下文中分析。
日志的存储主要涉及到两个类：
FixedBuffer用于实现一个指定大小的缓冲区，是每条日志消息的实际存储位置；
LogSteam中含有FixedBuffer的一个实例，其大小默认为4K，因此LogStream也通过FixedBuffer实现了日志消息的存储，除此之外，LogStream类还重载了一系列的"<<"，由此来实现”日志流“，从而可以流的形式来写入日志消息；
日志的输出也主要涉及到两个类：
Impl类包含了一个LogStream实例，用于存储日志消息，Impl类在构造和调用finish函数时会向LogStream中写入时间等信息；
Logger类中包含了一个Impl类实例，可以通过stream()函数来获取该实例下的LogStream，从而向其中写入日志正文。在Logger析构时调用g_output所指向的函数，将缓冲区中的日志消息全部输出。
每条日志消息对应了一个Logger的临时对象，每条日志消息对应的缓冲区大小默认为4K。
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)
