easylogging/easyloggingppArchived
Easyloggingpp
Easyloggingpp is a header-only C++ logging framework and diagnostic tool designed for recording system events and diagnostic messages. It functions as a thread-safe logging library that synchronizes access across multiple concurrent execution threads to prevent data corruption during event recording.
The framework features an asynchronous logger that processes messages on a background thread to minimize latency and prevent blocking the main application. It also acts as a log dispatcher, capable of routing data to local files, system syslog facilities, or remote network destinations for system monitoring.
The toolset covers a broad range of observability capabilities, including stack trace capture, crash log handling, and execution time tracking for performance profiling. It provides management utilities for size-based file rotation, custom log layouts, and severity-level filtering, alongside support for serializing complex types and user-defined objects.
Features
- C++ Logging Libraries - Provides a high-performance, header-only C++ library specifically designed for diagnostic event recording.
- Thread-Safe Logging - Ensures multiple threads can log simultaneously without data corruption using synchronization mechanisms.
- C++ Diagnostic Utilities - Provides a comprehensive set of tools for capturing stack traces, measuring execution time, and recording system errors.
- Asynchronous Processing - Provides mechanisms to offload log event processing to background threads to minimize application latency.
- Multi-Threaded Synchronization Primitives - Implements mutexes and synchronization primitives to ensure thread-safe access to shared logging state.
- Thread-Safe Logging Frameworks - Ships a logging system that ensures data integrity across concurrent threads using synchronization primitives.
- Application Event Recording - Captures and writes runtime diagnostic messages and system events using configurable formats and severity levels.
- Asynchronous Logging - Processes log entries on a background thread to minimize latency and prevent blocking the main application.
- Severity Level Filtering - Filters log output based on predefined severity levels to discard low-priority entries.
- Log Rotation Utilities - Automatically archives or deletes log files when they reach a predefined size limit to maintain disk space.
- Logging Configurations - Defines logging rules, file paths, and output destinations using configuration files or programmatic setup.
- Logging Verbosity Controls - Controls the level of detail in logs using severity levels and fine-grained overrides.
- Complex Data Serialization - Provides serialization support for non-primitive data types, custom classes, and containers within the log stream.
- Log File Rotators - Manages log file lifecycles by rotating files when they reach predefined size limits.
- Log Formatting - Uses C++ variadic templates to provide type-safe log messages and custom object serialization.
- Conditional Logging - Allows recording log entries only when specific boolean expressions are true to reduce noise.
- Custom Object Logging - Allows recording of user-defined classes through loggable interfaces or type wrappers.
- Function Execution Timing - Tracks the duration of functions and code blocks to identify and analyze performance bottlenecks.
- Log Layout Customization - Defines the visual arrangement and structure of log messages using custom specifiers.
- Log Entry Filters - Implements predicate-based logic to determine if a log entry should be emitted based on runtime conditions.
- Variadic Formatting - Provides type-safe log messages using a universal value specifier and a printf-like syntax.
- Log Message Routing - Dispatches log events from a generic API to specific handler implementations based on registration.
- Multi-Destination Log Routings - Routes log data to multiple configurable destinations including local files, syslog, and remote network endpoints.
- Independent Logger Instances - Creates and manages isolated logger instances to organize different event streams.
- Log Output Formatting - Controls the appearance and structure of log entries to meet specific readability or reporting requirements.
- Log Sinks - Supports pluggable output destinations via custom callbacks to route log events to various backends.
- Stack Trace Capturers - Records the current sequence of method calls to identify the exact cause of a logging event.
- Remote Application Logging - Provides frameworks for streaming application logs to central monitoring interfaces or remote network destinations.
- Application Crash Logging - Intercepts critical system signals to capture software failure data and write crash logs for troubleshooting.
- Custom Log Writers - Implements custom writers to intercept and route diagnostic messages to external destinations.
- Performance Profilers - Measures function execution time and records checkpoints to identify performance bottlenecks.
- Logging Libraries - Header-only C++ logging library.
