一个轻巧高效的多线程c++stream风格异步日志
-
- 一个轻巧高效的多线程c++stream风格异步日志
- 前言
- 功能需求
- 性能需求
- Logger实现
- LogStream类
- Logger类
- LogStream及Logger cpp源码
- 一个轻巧高效的多线程c++stream风格异步日志
前言
本文主要实现muduo的异步日志.省去boost库中特性的引用,轻巧简洁。
对于编程而言,日志是必不可少的,对于关键进程,日志通常需要记录：
1.收到的每条内部消息id.
2.收到的每条外部消息全文.
3.发出的每条消息全文,每条消息都有全局唯一的id.
4.关键内部状态变更，等等.
5.每条日志都有时间戳,以方便的追踪分布式系统中一个时间的来龙去脉.
c++日志大体上有两种API风格: C/JAVA的printf(fmt, ...)风格：
log_info(“received %d bytes from %s”, len, getName.c_str()); c++的stream<<风格：
LOG_INFO << “received << len << bytes from << getName.c_str();
本文实现的是c++的stream风格, 优点是使用起来更自然，不用保持格式的一致性.
功能需求
常规的通用日志库如log4j/logback通常会提供丰富的功能,但不一定是必须的功能.
1.日志有多种级别：TRACE、DEBUG、INFO、WARN、ERROR、FATAL等。
2.日志可能会有多个目的地：文件、socket、SMTP等。
3.日志消息格式可配置。
4.可设置运行时过滤器(filter)、控制不同的组件的日志消息级别和目的地.
这四项中,除了第一项之外,其余并非是必须的功能.本文内容只包含第一项功能.
对于分布式系统中的服务进程而言,日志的目的地只有一个：本地文件,往网络写日志消息是不可靠的，另一个坏处就是网络带宽的消耗.
muduo日志格式如下，本日志对格式有所改动，但基本信息不变。
日期 时间 微妙 线程 级别 函数名 正文 源文件名: 行号
20180802 12
:42
:50.621354 44321
WARN
main
just
test
-
test
.cpp
:445
20180802 12
:42
:50.621359 44321
INFO
main
just
test
-
test
.cpp
:446
20180802 12
:42
:50.621364 44321
ERROR
main
just
test
-
test
.cpp
:447
- 时间戳精确到微妙，每条消息通过gettimeofday(2)获取当前时间.这样做不会有什么性能损失,在x86-64Linux上,gettimeofday()不是系统调用,不会陷入内核
- 打印线程ID,便于分析多线程程序时序,也可以检测死锁(未加入)
- 打印日志级别,通过查看有无ERROR日志快速定位
- 打印文件名和行号,修复问题不至于搞错对象
- 每条日志尽量占一行,便于分析日志
性能需求
只有日志库足够高效，程序员才敢在代码中输出足够多的诊断信息，减小运维难度，提升效率.它体现在：
- 每秒几千万条日志没有明显的性能损失
- 能应对一个进程产生大量日志数据的场景，如1GB/min。
- 不阻塞正常的执行流程
- 在多线程程序中，不造成争用
为了实现性能指标，本日志设计中几点优化：
- 时间戳字符串中的日期和时间两部分是缓存的,一秒之内的多条日志只需格式化微妙即可
- 日志消息 的前四段是定长的,可避免运行时字串长度的计算
- 线程id是预先格式化的字符串
- 原文件名部分通过编译期计算来获得,避免运行期strrchr()的开销
Logger实现
LogStream类
LogStream类，主要作用是重载<<操作符，将基本类型的数据格式成字符串通过append接口存入LogBuffer中。
#ifndef _LOG_STREAM_HH
#define _LOG_STREAM_HH
#include */ (avail()) > len)
{
memcpy(m_cur, buf, len);
m_cur += len;
}
}
// write in m_data directly
char* current() {
return m_cur; };
int avail() const {
return
static_cast<
int> (end() - m_cur); }
void add(size_t len) { m_cur += len; }
int length() const {
return m_cur - m_data;}
const char* data() const {
return m_data; }
private:
const char* end() const {
return m_data +
sizeof(m_data); }
char m_data[SIZE];
char* m_cur;
};
class LogStream{
public:
LogStream();
~LogStream();
typedef LogBuffer Buffer;
typedef LogStream self;
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<<(
double);
self&
operator<<(
char v);
self&
operator<<(
const
char *);
void append(const char* data, int len) {
return m_buffer.append(data, len); }
const Buffer& buffer() const {
return m_buffer; }
private:
LogStream(
const LogStream& ls);
//no copyable
LogStream&
operator=(
const LogStream& ls);
template<
typename T>
void formatInteger(T v);
Buffer m_buffer;
static
const
int kMaxNumericSize =
32;
};
class Fmt{
public:
template<
typename T>
Fmt(
const
char* fmt, T val);
const char* data() const {
return m_buf; }
int length() const {
return m_length; }
private:
char m_buf[
32];
int m_length;
};
inline LogStream&
operator<<(LogStream &s,
const Fmt& fmt){
s.append(fmt.data(), fmt.length());
return s;
}
#endif
Logger类
Logger类，使用LogStream的<<操作符将文件名，日志级别，时间等信息格式好提前写入LogBuffer中.
它实际上是一个临时对象,通过宏定义临时构造一个logger对象，构造的时候即将上面信息写入LogBuffer,之后通过stream()接口引用LogStream的<<操作符写入我们的日志信息.
优点是 ：对于日志级别低的log那么它将是一个空的操作.
// CAUTION: do not write:
//
// if (good)
// LOG_INFO << "Good news";
// else
// LOG_WARN << "Bad news";
//
// this expends to
//
// if (good)
// if (logging_INFO)
// logInfoStream << "Good news";
// else
// logWarnStream << "Bad news";
//
#define
LOG_TRACE
if (
Logger::logLevel() <=
Logger::TRACE) \
Logger(__FILE__, __LINE__,
Logger::TRACE, __func__)
.stream()
#define
LOG_DEBUG
if (
Logger::logLevel() <=
Logger::DEBUG) \
Logger(__FILE__, __LINE__,
Logger::DEBUG, __func__)
.stream()
#define
LOG_INFO
if (
Logger::logLevel() <=
Logger::INFO) \
Logger(__FILE__, __LINE__)
.stream()
#define
LOG_WARN
Logger(__FILE__, __LINE__,
Logger::WARN)
.stream()
#define
LOG_ERROR
Logger(__FILE__, __LINE__,
Logger::ERROR)
.stream()
#define
LOG_FATAL
Logger(__FILE__, __LINE__,
Logger::FATAL)
.stream()
#define
LOG_SYSERR
Logger(__FILE__, __LINE__, false)
.stream()
#define
LOG_SYSFATAL
Logger(__FILE__, __LINE__, true)
.stream()
它的成员结构如下图所示:
Impl对象是个私有类,主要是为了闭源，构造Impl的时候后写入时间戳，日志级别，文件名等等.
logLevel()、setlogLevel()、为两个静态成员函数，用于设置日志级别.
setOutput()也是个静态成员函数，主要作用是重定向日志的输出.默认是输出至stdout.
#ifndef _LOGGER_HH
#define _LOGGER_HH
#include 完成Logger即可直接使用了。
直接通过宏LOG_DEBUG << 即可打印格式化好的日志信息. 只是默认输出到stdout.
后面文章会给出日志文件类及异步线程类的实现.
LogStream及Logger cpp源码
//LogStream
#include (m_length) <
sizeof(m_buf));
}
// Explicit instantiations
template Fmt::Fmt(
const
char* fmt,
char);
template Fmt::Fmt(
const
char* fmt,
short);
template Fmt::Fmt(
const
char* fmt,
unsigned
short);
template Fmt::Fmt(
const
char* fmt,
int);
template Fmt::Fmt(
const
char* fmt,
unsigned
int);
template Fmt::Fmt(
const
char* fmt,
long);
template Fmt::Fmt(
const
char* fmt,
unsigned
long);
template Fmt::Fmt(
const
char* fmt,
long
long);
template Fmt::Fmt(
const
char* fmt,
unsigned
long
long);
template Fmt::Fmt(
const
char* fmt,
float);
template Fmt::Fmt(
const
char* fmt,
double);
//Logger
#include (microSecondsSinceEpoch / TimeStamp::kMicroSecondsPerSecond);
int microseconds =
static_cast<
int>(microSecondsSinceEpoch % TimeStamp::kMicroSecondsPerSecond);
if (seconds != t_lastSecond){
t_lastSecond = seconds;
struct tm tm_time;
::gmtime_r(&seconds, &tm_time);
// FIXME TimeZone::fromUtcTime
int len = snprintf(t_time,
sizeof(t_time),
"%4d-%02d-%02d %02d:%02d:%02d",
tm_time.tm_year +
1900, tm_time.tm_mon +
1, tm_time.tm_mday,
tm_time.tm_hour +
8, tm_time.tm_min, tm_time.tm_sec);
assert(len ==
19); (
void)len;
}
Fmt us(
".%06d ", microseconds);
assert(us.length() ==
8);
m_stream << t_time << us.data();
}