LogStream

最新推荐文章于 2024-09-08 09:32:16 发布
最新推荐文章于 2024-09-08 09:32:16 发布
阅读量494 收藏
点赞数 1
分类专栏： muduo 文章标签： LogStream muduo
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qu1993/article/details/109390452
版权

这个文件涉及的内容比较多，分开描述

const char digits[] = "9876543210123456789";
const char* zero = digits + 9;
static_assert(sizeof(digits) == 20, "wrong number of digits");

const char digitsHex[] = "0123456789ABCDEF";
static_assert(sizeof digitsHex == 17, "wrong number of digitsHex");

// Efficient Integer to String Conversions, by Matthew Wilson.
template<typename T>
size_t convert(char buf[], T value)
{
  T i = value;
  char* p = buf;

  do
  {
    int lsd = static_cast<int>(i % 10);
    i /= 10;
    *p++ = zero[lsd];
  } while (i != 0);

  if (value < 0)
  {
    *p++ = '-';
  }
  *p = '\0';
  std::reverse(buf, p);

  return p - buf;
}

size_t convertHex(char buf[], uintptr_t value)
{
  uintptr_t i = value;
  char* p = buf;

  do
  {
    int lsd = static_cast<int>(i % 16);
    i /= 16;
    *p++ = digitsHex[lsd];
  } while (i != 0);

  *p = '\0';
  std::reverse(buf, p);

  return p - buf;
}

比较容易理解，但是感觉很实用。convert就是实现的整型转字符串，convertHex实现了从非负数转十六进制表示的字符串。比较有趣的是 转的时候是反方向的，最后使用reverse又进行了反转。

/*
 Format a number with 5 characters, including SI units.
 [0,     999]
 [1.00k, 999k]
 [1.00M, 999M]
 [1.00G, 999G]
 [1.00T, 999T]
 [1.00P, 999P]
 [1.00E, inf)
*/
std::string formatSI(int64_t s)
{
  double n = static_cast<double>(s);
  char buf[64];
  if (s < 1000)
    snprintf(buf, sizeof(buf), "%" PRId64, s);
  else if (s < 9995)
    snprintf(buf, sizeof(buf), "%.2fk", n/1e3);
  else if (s < 99950)
    snprintf(buf, sizeof(buf), "%.1fk", n/1e3);
  else if (s < 999500)
    snprintf(buf, sizeof(buf), "%.0fk", n/1e3);
  else if (s < 9995000)
    snprintf(buf, sizeof(buf), "%.2fM", n/1e6);
  else if (s < 99950000)
    snprintf(buf, sizeof(buf), "%.1fM", n/1e6);
  else if (s < 999500000)
    snprintf(buf, sizeof(buf), "%.0fM", n/1e6);
  else if (s < 9995000000)
    snprintf(buf, sizeof(buf), "%.2fG", n/1e9);
  else if (s < 99950000000)
    snprintf(buf, sizeof(buf), "%.1fG", n/1e9);
  else if (s < 999500000000)
    snprintf(buf, sizeof(buf), "%.0fG", n/1e9);
  else if (s < 9995000000000)
    snprintf(buf, sizeof(buf), "%.2fT", n/1e12);
  else if (s < 99950000000000)
    snprintf(buf, sizeof(buf), "%.1fT", n/1e12);
  else if (s < 999500000000000)
    snprintf(buf, sizeof(buf), "%.0fT", n/1e12);
  else if (s < 9995000000000000)
    snprintf(buf, sizeof(buf), "%.2fP", n/1e15);
  else if (s < 99950000000000000)
    snprintf(buf, sizeof(buf), "%.1fP", n/1e15);
  else if (s < 999500000000000000)
    snprintf(buf, sizeof(buf), "%.0fP", n/1e15);
  else
    snprintf(buf, sizeof(buf), "%.2fE", n/1e18);
  return buf;
}

/*
 [0, 1023]
 [1.00Ki, 9.99Ki]
 [10.0Ki, 99.9Ki]
 [ 100Ki, 1023Ki]
 [1.00Mi, 9.99Mi]
*/
std::string formatIEC(int64_t s)
{
  double n = static_cast<double>(s);
  char buf[64];
  const double Ki = 1024.0;
  const double Mi = Ki * 1024.0;
  const double Gi = Mi * 1024.0;
  const double Ti = Gi * 1024.0;
  const double Pi = Ti * 1024.0;
  const double Ei = Pi * 1024.0;

  if (n < Ki)
    snprintf(buf, sizeof buf, "%" PRId64, s);
  else if (n < Ki*9.995)
    snprintf(buf, sizeof buf, "%.2fKi", n / Ki);
  else if (n < Ki*99.95)
    snprintf(buf, sizeof buf, "%.1fKi", n / Ki);
  else if (n < Ki*1023.5)
    snprintf(buf, sizeof buf, "%.0fKi", n / Ki);

  else if (n < Mi*9.995)
    snprintf(buf, sizeof buf, "%.2fMi", n / Mi);
  else if (n < Mi*99.95)
    snprintf(buf, sizeof buf, "%.1fMi", n / Mi);
  else if (n < Mi*1023.5)
    snprintf(buf, sizeof buf, "%.0fMi", n / Mi);

  else if (n < Gi*9.995)
    snprintf(buf, sizeof buf, "%.2fGi", n / Gi);
  else if (n < Gi*99.95)
    snprintf(buf, sizeof buf, "%.1fGi", n / Gi);
  else if (n < Gi*1023.5)
    snprintf(buf, sizeof buf, "%.0fGi", n / Gi);

  else if (n < Ti*9.995)
    snprintf(buf, sizeof buf, "%.2fTi", n / Ti);
  else if (n < Ti*99.95)
    snprintf(buf, sizeof buf, "%.1fTi", n / Ti);
  else if (n < Ti*1023.5)
    snprintf(buf, sizeof buf, "%.0fTi", n / Ti);

  else if (n < Pi*9.995)
    snprintf(buf, sizeof buf, "%.2fPi", n / Pi);
  else if (n < Pi*99.95)
    snprintf(buf, sizeof buf, "%.1fPi", n / Pi);
  else if (n < Pi*1023.5)
    snprintf(buf, sizeof buf, "%.0fPi", n / Pi);

  else if (n < Ei*9.995)
    snprintf(buf, sizeof buf, "%.2fEi", n / Ei );
  else
    snprintf(buf, sizeof buf, "%.1fEi", n / Ei );
  return buf;
}

这两个函数就是以不同的单位表示数据，第一个k是1000，第二个Ki是1024，之前没有太多考虑的地方是四舍五入。可以看到在判断中，都是以5作为分界线的，就是因为四舍五入。在我自己的环境中，我测试发现默认的进位是5舍6入。举个例子：

#include <stdio.h>

int main()
{
    printf("%.2f\n", 9995/1e3);
}
~

打印结果为9.99，把9995改为9996，打印结果为10.00。

template<int SIZE>
const char* FixedBuffer<SIZE>::debugString()
{
  *cur_ = '\0';
  return data_;
}

template<int SIZE>
void FixedBuffer<SIZE>::cookieStart()
{
}

template<int SIZE>
void FixedBuffer<SIZE>::cookieEnd()
{
}

void LogStream::staticCheck()
{
  static_assert(kMaxNumericSize - 10 > std::numeric_limits<double>::digits10,
                "kMaxNumericSize is large enough");
  static_assert(kMaxNumericSize - 10 > std::numeric_limits<long double>::digits10,
                "kMaxNumericSize is large enough");
  static_assert(kMaxNumericSize - 10 > std::numeric_limits<long>::digits10,
                "kMaxNumericSize is large enough");
  static_assert(kMaxNumericSize - 10 > std::numeric_limits<long long>::digits10,
                "kMaxNumericSize is large enough");
}

template<typename T>
void LogStream::formatInteger(T v)
{
  if (buffer_.avail() >= kMaxNumericSize)
  {
    size_t len = convert(buffer_.current(), v);
    buffer_.add(len);
  }
}

LogStream& LogStream::operator<<(short v)
{
  *this << static_cast<int>(v);
  return *this;
}

LogStream& LogStream::operator<<(unsigned short v)
{
  *this << static_cast<unsigned int>(v);
  return *this;
}

LogStream& LogStream::operator<<(int v)
{
  formatInteger(v);
  return *this;
}

LogStream& LogStream::operator<<(unsigned int v)
{
  formatInteger(v);
  return *this;
}

LogStream& LogStream::operator<<(long v)
{
  formatInteger(v);
  return *this;
}

LogStream& LogStream::operator<<(unsigned long v)
{
  formatInteger(v);
  return *this;
}

LogStream& LogStream::operator<<(long long v)
{
  formatInteger(v);
  return *this;
}

LogStream& LogStream::operator<<(unsigned long long v)
{
  formatInteger(v);
  return *this;
}

LogStream& LogStream::operator<<(const void* p)
{
  uintptr_t v = reinterpret_cast<uintptr_t>(p);
  if (buffer_.avail() >= kMaxNumericSize)
  {
    char* buf = buffer_.current();
    buf[0] = '0';
    buf[1] = 'x';
    size_t len = convertHex(buf+2, v);
    buffer_.add(len+2);
  }
  return *this;
}

// FIXME: replace this with Grisu3 by Florian Loitsch.
LogStream& LogStream::operator<<(double v)
{
  if (buffer_.avail() >= kMaxNumericSize)
  {
    int len = snprintf(buffer_.current(), kMaxNumericSize, "%.12g", v);
    buffer_.add(len);
  }
  return *this;
}

template<typename T>
Fmt::Fmt(const char* fmt, T val)
{
  static_assert(std::is_arithmetic<T>::value == true, "Must be arithmetic type");

  length_ = snprintf(buf_, sizeof buf_, fmt, val);
  assert(static_cast<size_t>(length_) < sizeof 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);

那个cookieStart和cookieEnd没搞明白在muduo中起了什么作用，根据作者的说法，是为了gdb可以找到没有打印出来的日志信息，但是怎么实现的，还不清楚。

之后就是输出操作符的各种重载，整型输出最终是使用formatInteger函数，将整型通过convert转为字符串，并添加到buffer_中；还有一个void *的指针重载，使用convertHex以十六进制的形式输出。还有一个浮点型的重载，使用snprintf函数转字符串。

最后是Fmt的定义已经一些显式具现化。这样可以避免在多个文件实例化相同模板的额外开销。LogStream类本身不支持格式化，所以作者提供了Fmt类用来提供格式化功能。在Logging.cc文件中，就有这样的例子：

    Fmt us(".%06d ", microseconds);
    assert(us.length() == 8);
    stream_ << T(t_time, 17) << T(us.data(), 8);

通过使用Fmt，设置microseconds的输出形式。

LogStream.h

const int kSmallBuffer = 4000;
const int kLargeBuffer = 4000*1000;

template<int SIZE>
class FixedBuffer : noncopyable
{
 public:
  FixedBuffer()
    : cur_(data_)
  {
    setCookie(cookieStart);
  }

  ~FixedBuffer()
  {
    setCookie(cookieEnd);
  }

  void append(const char* /*restrict*/ buf, size_t len)
  {
    // FIXME: append partially
    if (implicit_cast<size_t>(avail()) > len)
    {
      memcpy(cur_, buf, len);
      cur_ += len;
    }
  }

  const char* data() const { return data_; }
  int length() const { return static_cast<int>(cur_ - data_); }

  // write to data_ directly
  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 GDB
  const char* debugString();
  void setCookie(void (*cookie)()) { cookie_ = cookie; }
  // for used by unit test
  string toString() const { return string(data_, length()); }
  StringPiece toStringPiece() const { return StringPiece(data_, length()); }

 private:
  const char* end() const { return data_ + sizeof data_; }
  // Must be outline function for cookies.
  static void cookieStart();
  static void cookieEnd();

  void (*cookie_)();
  char data_[SIZE];
  char* cur_;
};

}  // namespace detail

class LogStream : noncopyable
{
  typedef LogStream self;
 public:
  typedef detail::FixedBuffer<detail::kSmallBuffer> Buffer;

  self& operator<<(bool v)
  {
    buffer_.append(v ? "1" : "0", 1);
    return *this;
  }

  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)
  {
    *this << static_cast<double>(v);
    return *this;
  }
  self& operator<<(double);
  // self& operator<<(long double);

  self& operator<<(char v)
  {
    buffer_.append(&v, 1);
    return *this;
  }

  // self& operator<<(signed char);
  // self& operator<<(unsigned char);

  self& operator<<(const char* str)
  {
    if (str)
    {
      buffer_.append(str, strlen(str));
    }
    else
    {
      buffer_.append("(null)", 6);
    }
    return *this;
  }

  self& operator<<(const unsigned char* str)
  {
    return operator<<(reinterpret_cast<const char*>(str));
  }

  self& operator<<(const string& v)
  {
    buffer_.append(v.c_str(), v.size());
    return *this;
  }

  self& operator<<(const StringPiece& v)
  {
    buffer_.append(v.data(), v.size());
    return *this;
  }

  self& operator<<(const Buffer& v)
  {
    *this << v.toStringPiece();
    return *this;
  }

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

  Buffer buffer_;

  static const int kMaxNumericSize = 32;
};

class Fmt // : noncopyable
{
 public:
  template<typename T>
  Fmt(const char* fmt, T val);

  const char* data() const { return buf_; }
  int length() const { return length_; }

 private:
  char buf_[32];
  int length_;
};

inline LogStream& operator<<(LogStream& s, const Fmt& fmt)
{
  s.append(fmt.data(), fmt.length());
  return s;
}

// Format quantity n in SI units (k, M, G, T, P, E).
// The returned string is atmost 5 characters long.
// Requires n >= 0
string formatSI(int64_t n);

// Format quantity n in IEC (binary) units (Ki, Mi, Gi, Ti, Pi, Ei).
// The returned string is atmost 6 characters long.
// Requires n >= 0
string formatIEC(int64_t n);

在头文件中，定义了FixedBuffer，指定长度的一个buffer，并且长度是不可修改的。该类在LogStream中作为一条日志的缓冲区。其他的内容都比较简单。

不闻窗外事
关注
专栏目录
kinesis-logstream-reader
07-12
《Kinesis LogStream 读取器深度解析》 在当今的大数据时代，实时流处理成为了一个不可或缺的部分。Amazon Kinesis 是 Amazon Web Services (AWS) 提供的一种强大的大数据处理服务，它能够处理并分析实时的数据流，...
muduo库的高性能日志库（二）——LogStream文件
m0_61705102的博客
11-17 989
该文件下有三个类如下图所示复杂的C/C++代码很可能会包含错误，并且在编写代码后尝试对其进行测试类似于在大海捞针。一种更审慎的方法是通过添加专门针对特定区域的小型（单元）测试来测试编写的各个代码段，例如，一些计算密集型C函数或某些C++类声称对某个数据结构进行建模，例如队列。然后，以此理念构建的回归套件将具有单元测试的集合以及运行测试并报告结果的测试驱动程序。
muduo学习笔记：base部分之高性能日志库-LogStream
热爱生活，忠于自己
07-29 1061
muduo日志库是C++ stream风格，用起来自然，不必费心保持格式字符串和参数类型的一致性，可以随用随写，而且是类型安全的。 stream风格的另一个好处是当输出的日志级别高于语句的日志级别是，打印日志是个空操作，运行开销接近零，而printf风格不易做到。 muduo没有用到标准库的iostream，而是自己写的LogStream类，这主要是出于性能。 设计这个LogStream类，让它如同C++的标准输出流对象cout，能用<<符号接收输入，cout是输出到终端，而LogStream类
Stream Log 开源项目教程
最新发布
gitblog_00374的博客
09-08 846
Stream Log 开源项目教程 stream-log???? A lightweight and extensible logger library for Kotlin and Android.项目地址:https://gitcode.com/gh_mirrors/st/stream-log 1. 项目介绍 Stream Log 是一个轻量级且可扩展的日志库，专为 Kotlin 和 Androi...
muduo库学习笔记十五：base库之日志库二 LogStream类
mazi的博客
02-07 535
LogStream类： muduo没有用到标准库的iostream，而是自己写的LogStream类，这主要是出于性能。LogStream类，让它如同C++的标准输出流对象cout，能用<<符号接收输入，cout是输出到终端，而LogStream类是把输出保存自己内部的缓冲区，可以让外部程序把缓冲区的内容重定向输出到不同的目标，如文件、终端、socket。 LogStream类图：...
muduo LogStream详解
aixiaoql的博客
04-15 434
LogStream用于加载任意数据到字符缓冲区。 对于任意数据，总是可以使用LogStream os;os << 数据;的方式加载数据到字符缓冲区，之后缓冲区的内容可以根据需求重定向输出到不同的目标，如文件、终端、socket。
muduo的日志库分析一之LogStream
q5707802的专栏
02-07 2144
muduo日志库是C++ stream风格，这样用起来更自然，不必费心保持格式字符串和参数类型的一致性，可以随用随写，而且是类型安全的。 stream风格的另一个好处是当输出的日志级别高于语句的日志级别是，打印日志是个空操作，运行是开销接近零，而printf风格不易做到。 muduo没有用到标准库的iostream，而是自己写的LogStream类，这主要是出于性能。 设计这个L
logStream:用Flask编写的博客引擎
04-28
"logStream" 是一个使用 Flask 框架编写的博客引擎。Flask 是一个轻量级的 Web 开发框架，适合构建小型到中等规模的应用程序，如个人博客。这个项目的名称表明它专注于日志流式处理，可能意味着它可以实时或近乎实时...
aws-quickstart-cribl-logstream：适用于AWS中Cribl LogStream部署的快速入门指南
02-11
亚马逊上的Cribl LogStream 此快速入门指南是由创建的，帮助您在AWS环境中自动化Cribl LogStream的部署。 这些自动参考部署遵循AWS最佳实践，使用AWS CloudFormation模板部署EC2实例，IAM策略和S3存储桶。总览Cribl...
Python库 | logstream-0.0.0.tar.gz
05-17
资源分类：Python库 所属语言：Python 资源全名：logstream-0.0.0.tar.gz 资源来源：官方 安装方法：https://lanzao.blog.csdn.net/article/details/101784059
LogStream:具有实时websocket的轻量级日志文件Web gui
04-05
日志流具有实时websocket的轻量级日志文件Web gui 警告：这不会实现任何形式的身份验证或SSL。 我建议在反向代理（例如NGINX）之后运行此命令，并在代理层处理身份验证。 在appsettings.json中，您可以找到两个配置...
log-stream:纯粹的流媒体日志记录
05-08
日志流 记录非常简单。 这个包本身与传输，持久性或任何种类无关。 相反，它将公开流，您可以根据需要在.pipe（）周围添加流。 安装 npm install -- save log - stream 用法 var log = require ( 'log-stream' ) ( { name : 'myApp' } ) log . stream . pipe ( process . stdout ) log ( 'The sky is falling!' ) log . fatal ( 'This message should be %s.' , 'fatal' ) 选项 LogStream接受以下选项。 name ：必填-将作为name包含在消息中。 levels ：默认{ trace': 10, 'debug': 20,'info': 30,'warn': 40,'error':
muduo之LogStream
热门推荐
后台开发
10-29 1万+
LogStream.h // Use of this source code is governed by a BSD-style license // that can be found in the License file. // // Author: Shuo Chen (chenshuo at chenshuo dot com) #ifndef MUDUO_BAS...
多线程日志库
qq_39805297的博客
11-23 325
本文参考自陈硕老师的muduo网络库，删减的繁多的依赖文件，精简如此，供更多的人参考学习（感谢陈硕老师的muduo）。 copyable.h #ifndef MUDUO_BASE_COPYABLE_H #define MUDUO_BASE_COPYABLE_H namespace muduo { /// A tag class emphasises the objects are copyable. /// The empty base class optimization applies. //
AIX上DB2数据库日志满了的解决办法
一个老IT的成长日记
09-05 9598
现象：AIX上的DB2数据库，使用过程中，DataGrip忽然提示日志已满，数据无法保存。 调查：由于DBA不在，所以只能自己解决。先用连接用的账号登录了，执行db2 get db cfg for  dbname，发现没有权限。只好要来 instance的账号密码。 $su - instname $#取得设置内容 $db2 get db cfg for dbname $#找到以下设置,确定是...
DB2的日志相关参数
nayanminxing的专栏
10-13 2919
重要观点明晰1.LOGARCHMETH1和Path to log files的区别1.创建一个新数据库 [db2inst1@db22 ~]$ db2 create database yynewlog DB20000I The CREATE DATABASE command completed successfully. ####2.此时查看数据库目录 [db2inst1@db22 YYNEWLOG
muduo网络库学习（九）日志类Logger和LogStream，将日志信息打印到屏幕
一个程序渣渣的小后院
10-29 2184
每一个成熟的项目都有大大小小的日志系统，在关键的地方打印日志信息，常用来跟踪程序运行，查找错误原因等，可以节省大量的debug时间muduo的日志信息有5个级别 TRACE，细粒度最高的日志信息，打印的最详细 DEBUG，细粒度级别上对调试有帮助的日志信息 INFO，粗粒度级别上强调程序的运行信息 WARN，程序能正常运行，但存在潜在风险的信息 ERROR，执行出错，但不影响程序继续执行的错误信息
muduo::Logging、LogStream分析
KangRoger的专栏
07-28 3543
Logging、LogStream代码分析
muduo LogStream解析
weixin_40021744的博客
04-02 299
数字转字符串 template<typename T> size_t convert(char buf[], T value) { T i = value; char* p = buf; // 201 分别取数字 1 0 2 do { int lsd = static_cast<int>(i % 10); i /= 10; *p++...
muduo logstream
07-27
muduo logstream是一个用于日志记录的工具，它是muduo网络库中的一部分。muduo是一个基于事件驱动的网络库，用于开发高性能的服务器应用程序。logstream是muduo库中的一个类，用于将日志消息写入到缓冲区中。它提供...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值