https://github.com/cwahn/efp-logger
High performance logging system for real-time application
https://github.com/cwahn/efp-logger
Last synced: 3 months ago
JSON representation
High performance logging system for real-time application
- Host: GitHub
- URL: https://github.com/cwahn/efp-logger
- Owner: cwahn
- License: mit
- Created: 2023-11-26T16:31:09.000Z (over 2 years ago)
- Default Branch: main
- Last Pushed: 2024-11-24T02:45:24.000Z (over 1 year ago)
- Last Synced: 2025-02-03T10:33:39.045Z (over 1 year ago)
- Language: CMake
- Size: 80.1 KB
- Stars: 1
- Watchers: 1
- Forks: 0
- Open Issues: 1
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# EFP Logger
## Overview
EFP Logger is a C++ logging library designed for real-time concurrency application. The typical log-writing takes only "tens of nano seconds".
## Exmaple
```c++
int main()
{
using namespace efp;
// Optional log level setting. Default is LogLevel::Info
Logger::set_log_level(LogLevel::Trace);
// Optional log output setting. // default is stdout
Logger::set_output("./efp_logger_test.log");
// Logger::set_output(stdout);
// Use the logging functions
trace("This is a trace message with no formating");
debug("This is a debug message with a pointer: {:p}", (void *)nullptr);
info("This is a info message with a float: {}", 3.14f);
warn("This is a warn message with a int: {}", 42);
error("This is a error message with a string literal: {}", "error");
// ! Sending std::string to the buffer is O(n) and may increase risk of buffer overflow
// ! Every 20 ~ 30 char will take one buffer space.
fatal("This is a fatal message with a std::string: {}", std::string("fatal error"));
// Since the logging is done in a separate thread, wait for a while to see the logs
std::this_thread::sleep_for(std::chrono::milliseconds(10));
return 0;
}
```
```log
2023-12-02 03:25:28 TRACE This is a trace message with no formating
2023-12-02 03:25:28 DEBUG This is a debug message with a pointer: 0x0
2023-12-02 03:25:28 INFO This is a info message with a float: 3.14
2023-12-02 03:25:28 WARN This is a warn message with a int: 42
2023-12-02 03:25:28 ERROR This is a error message with a string literal: error
2023-12-02 03:25:28 FATAL This is a fatal message with a std::string: fatal error
```
## Features
In order to implement such functionality a few techniques are combined.
- **Asynchronous Processing**: Festival the lock is processed by separate external thread. Regardless of the destination of log, overhead of making side effect is not acceptable. By utilizing `efp::Enum` type, parsing, and printing will be handled by external thread.
- **Zero Allocation Logging**: Allocation often cause unbounded amount of overhead, which is not acceptable for real time application. EFP RtLog utilize zero allocation ring, buffer, which guarantees uniform operation. The small cost is doubled memory and dual copy.
- **Double Buffering with Spinlock**: Synchronization Should be also minimized in real time application. EFP RtLog Implement double buffering, Which will make logging sync free and non-blocking. Upper bound of blocking time would be approximately the same with a single pointer swap.
- **Formatting**: By utilizing the excellent `fmt` internally, `efp::RtLog` buffers virtually the same core API with `fmt::format` and `fmt::print`.
## Performance
EFP RT Log's design is benchmarked to handle high-throughput scenarios, ensuring efficient logging even under heavy load.
```plaintext
Logged 1000000 messages in 0.0203815 seconds.
Average time per message: 2.03815e-08 seconds.
Messages per second: 4.90641e+07
```
## Todo
- Pointer type auto conversion to void *
## Integration
To use EFP RT Log, include `logger.hpp` in your project and ensure dependencies, especially the `fmt` library, are correctly linked.