awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
abumq avatar

abumq/easyloggingppArchived

0
View on GitHub↗
3,937 stars·945 forks·C++·MIT·24 views

Easyloggingpp

This project is a thread-safe, asynchronous logging library designed for C++ applications. It provides a comprehensive diagnostic toolkit that enables developers to record system events, track execution flow across multiple threads, and manage log output through severity-based filtering and automated file maintenance. By offloading log formatting and disk input/output to background worker threads, the library minimizes latency on the main execution path, ensuring high performance in time-critical systems.

The framework distinguishes itself through its flexible configuration and diagnostic capabilities. It supports runtime setup via external configuration files, allowing for adjustments to log levels and output patterns without requiring recompilation. Beyond standard logging, it includes built-in crash analysis tools that capture system signals and stack traces to facilitate post-mortem debugging, as well as performance profiling utilities to measure function execution times and identify bottlenecks.

The library offers a versatile routing system that dispatches diagnostic messages to multiple destinations, including files, consoles, and network sockets, or through custom interception callbacks. It handles complex data types and standard containers using template metaprogramming, ensuring consistent inspection of application state. Additionally, it provides granular control over log volume through conditional logic, frequency throttling, and module-specific verbosity settings.

Features

  • C++ Diagnostic Utilities - Provides a comprehensive diagnostic toolkit for recording stack traces, measuring execution time, and validating program state.
  • C++ Logging Libraries - Provides a high-performance, thread-safe logging library specifically designed for diagnostic event recording in C++ applications.
  • Thread-Safe Logging - Coordinates logging operations across multiple threads using internal synchronization to prevent data corruption.
  • Thread-Safe Logging Frameworks - Coordinates logging operations across multiple threads using internal synchronization to prevent data races.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI
  • Thread-Safe State Synchronization - Ensures thread-safe access to shared logger instances and output streams using internal synchronization primitives.
  • Worker Thread Patterns - Offloads log formatting and disk I/O to dedicated background threads to minimize latency on the main execution path.
  • Asynchronous Log Processing - Offloads log processing to background threads to maintain low latency and high performance in time-critical systems.
  • Severity Level Filtering - Controls log volume by enabling or disabling specific severity levels globally or per individual logger.
  • Log Sinks - Dispatches log records to multiple output destinations including files, consoles, and network sockets through a pluggable interface.
  • Template-Based Type Serializers - Uses template metaprogramming to resolve and format complex data types and standard containers for deep object inspection.
  • Loggable Type Resolvers - Records containers, templates, and custom classes by extending a loggable base class for deep object inspection.
  • Function Performance Tracking - Tracks the duration of functions or code blocks and records performance results using optional checkpoints to identify bottlenecks.
  • Log File Rotators - Manages log file lifecycles through automatic rotation based on size thresholds to prevent disk overflow.
  • Configuration File Loading - Loads runtime settings such as output destinations and log levels from external configuration files.
  • Crash State Capturing - Intercepts system signals during fatal crashes to record call stacks and application state for post-mortem debugging.
  • Custom Log Formatting - Constructs log messages using placeholders for timestamps, thread IDs, and custom application data.
  • Multi-Destination Log Routings - Dispatches log messages to multiple destinations including files, consoles, and network sockets.
  • Log File Rotation - Automatically truncates or archives log files when they reach a maximum size threshold to prevent disk overflow.
  • Logger Registries - Provides a centralized registry to manage and retrieve independent logger instances by name for different application components.
  • Application Stack Trace Capturers - Records the current call stack during execution to diagnose the exact location of system events and errors.
  • Unified Log Management - Synchronizes logging configurations and storage across multiple modules to maintain a unified diagnostic state.
  • Performance Profiling - Measures function execution times and records performance checkpoints to identify bottlenecks in C++ code.
  • Logging Configuration Files - Provides runtime configuration of logging levels and output patterns via external files without requiring recompilation.
  • Star history

    Star history chart for abumq/easyloggingppStar history chart for abumq/easyloggingpp

    How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

    Frequently asked questions

    What does abumq/easyloggingpp do?

    This project is a thread-safe, asynchronous logging library designed for C++ applications. It provides a comprehensive diagnostic toolkit that enables developers to record system events, track execution flow across multiple threads, and manage log output through severity-based filtering and automated file maintenance. By offloading log formatting and disk input/output to background worker threads, the library minimizes latency on the main execution path, ensuring high…

    What are the main features of abumq/easyloggingpp?

    The main features of abumq/easyloggingpp are: C++ Diagnostic Utilities, C++ Logging Libraries, Thread-Safe Logging, Thread-Safe Logging Frameworks, Thread-Safe State Synchronization, Worker Thread Patterns, Asynchronous Log Processing, Severity Level Filtering.

    Which projects share features with abumq/easyloggingpp?

    Projects with overlapping indexed features include: amrayn/easyloggingpp — Easyloggingpp is a C++ logging library and thread-safe logging framework used for recording diagnostic messages and… easylogging/easyloggingpp — Easyloggingpp is a header-only C++ logging framework and diagnostic tool designed for recording system events and… gabime/spdlog — spdlog is a high-performance C++ logging library designed to record diagnostic messages and application events. It… klauscfhq/signale — Signale is a formatted console logging library for Node.js applications. It serves as a pluggable logging framework… davewoodcom/xcglogger — XCGLogger is a logging framework for Swift applications designed to capture events and system state for debugging and… delgan/loguru — Loguru is a Python logging library and thread-safe framework designed for recording system events and diagnostic…

    Projects sharing features with Easyloggingpp

    These projects share indexed features with Easyloggingpp. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
    • amrayn/easyloggingppamrayn avatar

      amrayn/easyloggingpp

      3,937View on GitHub↗

      Easyloggingpp is a C++ logging library and thread-safe logging framework used for recording diagnostic messages and application events. It functions as an asynchronous logger, processing messages on a background thread to reduce latency and prevent blocking the main execution path. The project includes a log rotation manager to automatically truncate or roll over files once they reach a specified disk size limit. It also serves as a performance tracking tool for measuring function execution timing and recording checkpoints to identify processing bottlenecks. The library covers a broad range

      C++
      View on GitHub↗3,937
    • easylogging/easyloggingppeasylogging avatar

      easylogging/easyloggingpp

      3,938View on GitHub↗

      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

      C++
      View on GitHub↗3,938
    • gabime/spdloggabime avatar

      gabime/spdlog

      28,922View on GitHub↗

      spdlog is a high-performance C++ logging library designed to record diagnostic messages and application events. It serves as an asynchronous logging framework and thread-safe library that coordinates access across concurrent threads to maintain message integrity. The project functions as a multi-target log router, distributing single events to multiple destinations such as consoles, files, and system daemons. It includes a log rotation manager that handles file lifecycles through basic, rotating, or daily rollover strategies to prevent disk exhaustion. The library covers a broad range of cap

      C++cppcpp11header-only
      View on GitHub↗28,922
    • klauscfhq/signaleklauscfhq avatar

      klauscfhq/signale

      9,176View on GitHub↗

      Signale is a formatted console logging library for Node.js applications. It serves as a pluggable logging framework and stream-based log router that allows users to record system events using customizable levels, colors, and output styles. The project distinguishes itself as an interactive console logger capable of overwriting previous messages to reduce terminal clutter during long-running tasks. It also functions as an application performance monitor, providing tools to measure and track execution time between specific code points to identify performance bottlenecks. The library covers a b

      JavaScript
      View on GitHub↗9,176
    Compare all 30 related projects→