ue_log

ue_log is a powerful logging library for C++ programmers. This library provides a simple and easy-to-use interface for logging events or messages of different levels in your C++ program. It also supports logging to different output destinations, such as console, files, and syslog.

Features

• Simple and easy-to-use logging API
• Supports different log levels, including trace, debug, info, warning, error, and fatal
• Supports logging to console, files, and syslog
• Supports logging with different formats and styles
• Supports logging with custom tags and metadata

Usage

Initialization

The first step to using ue_log is to initialize the logging system. You can do this by calling the ue_log::init() function, which sets up the default logging configuration.

#include <ue_log.h>

int main() {
    // Initialize the logging system
    ue_log::init();
    
    // Your code here
    return 0;
}

Logging Events

Once you have initialized the logging system, you can start logging events by calling the appropriate logging functions, such as ue_log::debug(), ue_log::info(), ue_log::warning(), ue_log::error(), and ue_log::fatal(). Each of these functions takes a message string as its first argument.

ue_log::debug("This is a debug message.");
ue_log::info("This is an informational message.");
ue_log::warning("This is a warning message.");
ue_log::error("This is an error message.");
ue_log::fatal("This is a fatal message.");

Setting the Logging Level

By default, all log events are logged to the console and files with the info level or higher. You can change the logging level by calling the ue_log::set_level() function.

ue_log::set_level(ue_log::debug);

Logging to Files

In addition to logging to the console, you can also log events to files using the ue_log::file_sink class. This class takes a file path as its constructor argument, and logs events to the file in addition to the console output.

#include <ue_log.h>
#include <ue_log_sink_file.h>

int main() {
    // Initialize the logging system
    ue_log::init();

    // Create a file sink and add it to the logging system
    auto file_sink = std::make_shared<ue_log::file_sink>("log.txt");
    ue_log::add_sink(file_sink);

    // Your code here
    return 0;
}

Logging to Syslog

If you are working on a Unix-like system, you can also log events to the syslog using the ue_log::syslog_sink class. This class takes a syslog facility as its constructor argument, and logs events to the syslog in addition to the console output.

#include <ue_log.h>
#include <ue_log_sink_syslog.h>

int main() {
    // Initialize the logging system
    ue_log::init();

    // Create a syslog sink and add it to the logging system
    auto syslog_sink = std::make_shared<ue_log::syslog_sink>(LOG_DAEMON);
    ue_log::add_sink(syslog_sink);

    // Your code here
    return 0;
}

Customizing the Output Format

By default, log events are formatted using the following format:

[timestamp] [level] message

You can change the output format by creating a custom sink class that inherits from ue_log::sink and overrides the log() function. The log() function is responsible for formatting the log event and writing it to the output destination.

Here's an example of a custom sink class that formats the log event with color and additional metadata:

#include <ue_log.h>

class custom_sink : public ue_log::sink {
public:
    void log(const ue_log::log_event& event) override {
        switch(event.level) {
            case ue_log::trace:
                std::cout << "\033[0;37m[TRACE] ";
                break;
            case ue_log::debug:
                std::cout << "\033[1;34m[DEBUG] ";
                break;
            case ue_log::info:
                std::cout << "\033[0;32m[INFO] ";
                break;
            case ue_log::warning:
                std::cout << "\033[1;33m[WARNING] ";
                break;
            case ue_log::error:
                std::cout << "\033[0;31m[ERROR] ";
                break;
            case ue_log::fatal:
                std::cout << "\033[1;31m[FATAL] ";
                break;
            default:
                std::cout << "\033[1;37m[UNKNOWN] ";
                break;
        }

        std::cout << "[" << event.timestamp << "] ";
        std::cout << "[" << event.thread_id << "] ";
        std::cout << "[" << event.file << ":" << event.line << "] ";
        std::cout << event.tag << " " << event.message << std::endl;

        std::cout << "\033[0m";
    }
};

int main() {
    // Initialize the logging system
    ue_log::init();

    // Create a custom sink and add it to the logging system
    auto custom_sink = std::make_shared<custom_sink>();
    ue_log::add_sink(custom_sink);

    // Your code here
    return 0;
}

Adding Custom Metadata

You can add custom metadata to each log event by creating a custom ue_log::logger instance and using it to log events. The ue_log::logger class provides additional logging functions that take a ue_log::metadata object as an additional argument. This metadata object can contain any additional information you want to log with the event, such as the user ID, request ID, or any custom data relevant to your application.

#include <ue_log.h>

int main() {
    // Initialize the logging system
    ue_log::init();

    // Create a custom logger with a user ID metadata
    auto logger = ue_log::create_logger("my-app");
    ue_log::metadata metadata;
    metadata["userId"] = "123";
    logger->info("Logged in.", metadata);

    // Your code here
    return 0;
}

Conclusion

ue_log is a powerful logging library that can help you keep track of events and errors in your C++ program. It provides a simple and easy-to-use interface for logging events with different levels, formats, and output destinations. With ue_log, you can turn your application's log data into valuable insights that can help you improve performance, identify bugs, and troubleshoot issues.