C++:log日志

最新推荐文章于 2024-10-09 09:32:06 发布

熊叫大雄

最新推荐文章于 2024-10-09 09:32:06 发布

阅读量6.2k

点赞数 6

分类专栏： C-Cpp 文章标签： c++

本文链接：https://blog.csdn.net/yz2zcx/article/details/105939827

版权

C-Cpp 专栏收录该内容

77 篇文章 7 订阅

订阅专栏

前言

日志一般是记录一些程序运行信息的文件，一般是用于快速定位错误所在，追踪程序运行的过程和进度、采集运行环境等作用。说白了简单粗暴点就是程序挂了，可以看到大概在哪里挂的，挂的原因可能有哪些等作用。
最近在github上找了些C++的日志库，做了些简单的使用记录。

一、NanoLog C++ 11

在github上找到的NanoLog有几个版本，不过我只下载了两个星星数量最高的，一个是C++11的，一个是C++17的。
C++11这个比较简单，就一个头文件和源文件，使用起来也比较简单，首先包含头文件NanoLog.hpp，然后通过nanolog::initialize()初始化一个实例，nanolog::initialize的第二个参数和第三个参数是设置日志的存放路径和文件名，第四个参数设置当日志文件大小超过多少Mb的时候会生成新的日志文件，这样可以防止某个日志文件变得特别大，而第一个参数是干嘛的呢？看到它传入的参数有两种：

GuaranteedLogger：提供保证日志行不会被删除。
NonGuaranteedLogger：不保证日志记录。使用环缓冲区保存日志行。当环满时，插槽中的前一个日志行将被丢弃。即使环缓冲区已满，也不会阻止生产者。环缓冲区大小-日志行被推入由此参数确定大小的mpsc环缓冲区。由于每条日志行是256字节，所以ring_buffer_size = ring_buffer_size_mb * 1024 * 1024 / 256

使用的程序例子如下：

#include "NanoLog.hpp"

int main()
{
    // Ensure initialize is called once prior to logging.
    // This will create log files like /tmp/nanolog1.txt, /tmp/nanolog2.txt etc.
    // Log will roll to the next file after every 1MB.
    // This will initialize the guaranteed logger.
    nanolog::initialize(nanolog::GuaranteedLogger(), "./", "nanolog", 1);

    // Or if you want to use the non guaranteed logger -
    // ring_buffer_size_mb - LogLines are pushed into a mpsc ring buffer whose size
    // is determined by this parameter. Since each LogLine is 256 bytes,
    // ring_buffer_size = ring_buffer_size_mb * 1024 * 1024 / 256
    // In this example ring_buffer_size_mb = 3.
    // nanolog::initialize(nanolog::NonGuaranteedLogger(3), "/tmp/", "nanolog", 1);
    for (int j=0; j<100000;j++)
    {
        for (int i = 0; i < 50000; ++i)
        {
            LOG_INFO << "Sample NanoLog: " << i;
        }
    }

    // Change log level at run-time.
    nanolog::set_log_level(nanolog::LogLevel::CRIT);
    LOG_WARN << "This log line will not be logged since we are at loglevel = CRIT";

    return 0;
}

使用的程序例子还是比较简单，而且速度其实还是很快的，所以基本上这个库还是够用的。

二、NanoLog C++ 17

C++17这个的工程稍微复杂一丢丢，我决定洗澡睡觉…后面有空补上…

三、spdlog

spdlog是另一款C++的日志库，速度也是非常快的，且可编译成库的，并且支持跨平台（包括windows、Linux、MacOS、Android等）。spdlog在github上的星星数超过8.5K了，可见还是很多人用的且认可的。下载之后解压，然后编译成库，编译的过程基本是cmake、make、make install三连，基本没啥报错，在树莓派上编译也是很快的，所以也没啥问题。然后简单跑了他提供的例子，例子代码如下：

//
// Copyright(c) 2015 Gabi Melman.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)

// spdlog usage example

#include <cstdio>

void stdout_logger_example();
void basic_example();
void rotating_example();
void daily_example();
void async_example();
void binary_example();
void trace_example();
void multi_sink_example();
void user_defined_example();
void err_handler_example();
void syslog_example();

#include "spdlog/spdlog.h"

int main(int, char *[])
{
    spdlog::info("Welcome to spdlog version {}.{}.{}  !", SPDLOG_VER_MAJOR, SPDLOG_VER_MINOR, SPDLOG_VER_PATCH);
    spdlog::warn("Easy padding in numbers like {:08d}", 12);
    spdlog::critical("Support for int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
    spdlog::info("Support for floats {:03.2f}", 1.23456);
    spdlog::info("Positional args are {1} {0}..", "too", "supported");
    spdlog::info("{:>8} aligned, {:<8} aligned", "right", "left");

    // Runtime log levels
    spdlog::set_level(spdlog::level::info); // Set global log level to info
    spdlog::debug("This message should not be displayed!");
    spdlog::set_level(spdlog::level::trace); // Set specific logger's log level
    spdlog::debug("This message should be displayed..");

    // Customize msg format for all loggers
    spdlog::set_pattern("[%H:%M:%S %z] [%^%L%$] [thread %t] %v");
    spdlog::info("This an info message with custom format");
    spdlog::set_pattern("%+"); // back to default format
    spdlog::set_level(spdlog::level::info);

    // Backtrace support
    // Loggers can store in a ring buffer all messages (including debug/trace) for later inspection.
    // When needed, call dump_backtrace() to see what happened:
    spdlog::enable_backtrace(10); // create ring buffer with capacity of 10  messages
    for (int i = 0; i < 100; i++)
    {
        spdlog::debug("Backtrace message {}", i); // not logged..
    }
    // e.g. if some error happened:
    spdlog::dump_backtrace(); // log them now!

    try
    {
        stdout_logger_example();
        basic_example();
        rotating_example();
        daily_example();
        async_example();
        binary_example();
        multi_sink_example();
        user_defined_example();
        err_handler_example();
        trace_example();

        // Flush all *registered* loggers using a worker thread every 3 seconds.
        // note: registered loggers *must* be thread safe for this to work correctly!
        spdlog::flush_every(std::chrono::seconds(3));

        // Apply some function on all registered loggers
        spdlog::apply_all([&](std::shared_ptr<spdlog::logger> l) { l->info("End of example."); });

        // Release all spdlog resources, and drop all loggers in the registry.
        // This is optional (only mandatory if using windows + async log).
        spdlog::shutdown();
    }

    // Exceptions will only be thrown upon failed logger or sink construction (not during logging).
    catch (const spdlog::spdlog_ex &ex)
    {
        std::printf("Log initialization failed: %s\n", ex.what());
        return 1;
    }
}

#include "spdlog/sinks/stdout_color_sinks.h"
// or #include "spdlog/sinks/stdout_sinks.h" if no colors needed.
void stdout_logger_example()
{
    // Create color multi threaded logger.
    auto console = spdlog::stdout_color_mt("console");
    // or for stderr:
    // auto console = spdlog::stderr_color_mt("error-logger");
}

#include "spdlog/sinks/basic_file_sink.h"
void basic_example()
{
    // Create basic file logger (not rotated).
    auto my_logger = spdlog::basic_logger_mt("file_logger", "logs/basic-log.txt");
}

#include "spdlog/sinks/rotating_file_sink.h"
void rotating_example()
{
    // Create a file rotating logger with 5mb size max and 3 rotated files.
    auto rotating_logger = spdlog::rotating_logger_mt("some_logger_name", "logs/rotating.txt", 1048576 * 5, 3);
}

#include "spdlog/sinks/daily_file_sink.h"
void daily_example()
{
    // Create a daily logger - a new file is created every day on 2:30am.
    auto daily_logger = spdlog::daily_logger_mt("daily_logger", "logs/daily.txt", 2, 30);
}

#include "spdlog/async.h"
void async_example()
{
    // Default thread pool settings can be modified *before* creating the async logger:
    // spdlog::init_thread_pool(32768, 1); // queue with max 32k items 1 backing thread.
    auto async_file = spdlog::basic_logger_mt<spdlog::async_factory>("async_file_logger", "logs/async_log.txt");
    // alternatively:
    // auto async_file = spdlog::create_async<spdlog::sinks::basic_file_sink_mt>("async_file_logger", "logs/async_log.txt");

    for (int i = 1; i < 101; ++i)
    {
        async_file->info("Async message #{}", i);
    }
}

// Log binary data as hex.
// Many types of std::container<char> types can be used.
// Iterator ranges are supported too.
// Format flags:
// {:X} - print in uppercase.
// {:s} - don't separate each byte with space.
// {:p} - don't print the position on each line start.
// {:n} - don't split the output to lines.

#include "spdlog/fmt/bin_to_hex.h"
void binary_example()
{
    std::vector<char> buf(80);
    for (int i = 0; i < 80; i++)
    {
        buf.push_back(static_cast<char>(i & 0xff));
    }
    spdlog::info("Binary example: {}", spdlog::to_hex(buf));
    spdlog::info("Another binary example:{:n}", spdlog::to_hex(std::begin(buf), std::begin(buf) + 10));
    // more examples:
    // logger->info("uppercase: {:X}", spdlog::to_hex(buf));
    // logger->info("uppercase, no delimiters: {:Xs}", spdlog::to_hex(buf));
    // logger->info("uppercase, no delimiters, no position info: {:Xsp}", spdlog::to_hex(buf));
}

// Compile time log levels.
// define SPDLOG_ACTIVE_LEVEL to required level (e.g. SPDLOG_LEVEL_TRACE)
void trace_example()
{
    // trace from default logger
    SPDLOG_TRACE("Some trace message.. {} ,{}", 1, 3.23);
    // debug from default logger
    SPDLOG_DEBUG("Some debug message.. {} ,{}", 1, 3.23);

    // trace from logger object
    auto logger = spdlog::get("file_logger");
    SPDLOG_LOGGER_TRACE(logger, "another trace message");
}

// A logger with multiple sinks (stdout and file) - each with a different format and log level.
void multi_sink_example()
{
    auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
    console_sink->set_level(spdlog::level::warn);
    console_sink->set_pattern("[multi_sink_example] [%^%l%$] %v");

    auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>("logs/multisink.txt", true);
    file_sink->set_level(spdlog::level::trace);

    spdlog::logger logger("multi_sink", {console_sink, file_sink});
    logger.set_level(spdlog::level::debug);
    logger.warn("this should appear in both console and file");
    logger.info("this message should not appear in the console, only in the file");
}

// User defined types logging by implementing operator<<
#include "spdlog/fmt/ostr.h" // must be included
struct my_type
{
    int i;
    template<typename OStream>
    friend OStream &operator<<(OStream &os, const my_type &c)
    {
        return os << "[my_type i=" << c.i << "]";
    }
};

void user_defined_example()
{
    spdlog::info("user defined type: {}", my_type{14});
}

// Custom error handler. Will be triggered on log failure.
void err_handler_example()
{
    // can be set globally or per logger(logger->set_error_handler(..))
    spdlog::set_error_handler([](const std::string &msg) { printf("*** Custom log error handler: %s ***\n", msg.c_str()); });
}

// syslog example (linux/osx/freebsd)
#ifndef _WIN32
#include "spdlog/sinks/syslog_sink.h"
void syslog_example()
{
    std::string ident = "spdlog-example";
    auto syslog_logger = spdlog::syslog_logger_mt("syslog", ident, LOG_PID);
    syslog_logger->warn("This is warning that will end up in syslog.");
}
#endif

// Android example.
#if defined(__ANDROID__)
#include "spdlog/sinks/android_sink.h"
void android_example()
{
    std::string tag = "spdlog-android";
    auto android_logger = spdlog::android_logger_mt("android", tag);
    android_logger->critical("Use \"adb shell logcat\" to view this message.");
}
#endif