sirupsen/logrus
Logrus
Logrus is a structured logging library for Go that produces machine-readable output using key-value pairs and JSON formatting. It serves as a pluggable logging framework providing a thread-safe event logger with configurable mutex locking to manage concurrent writes across multiple goroutines.
The project distinguishes itself through a pluggable hook system that routes log entries to external services or custom destinations. It also features a contextual logger capable of attaching persistent metadata and request-scoped fields to entries to improve traceability.
The framework covers broad observability capabilities, including call site tracking for source code location, severity-based verbosity control, and the ability to redirect output from the standard library into a structured pipeline. It supports multiple output formats, such as JSON and plain text with ANSI color styling, and includes mechanisms for log data redaction and log-to-metric translation.
Performance is managed through memory buffer pooling and deferred log evaluation to reduce allocation overhead.
Features
- Structured Logging - Records operational data as machine-readable key-value pairs for efficient search and analysis in Go.
- Structured Logging Frameworks - Implements a structured logging framework that produces machine-readable key-value pairs and JSON output.
- Log Formatters - Decouples log data from output representation using pluggable formatters for JSON and plain text.
- Logging and Verbosity Tools - Sets a minimum severity threshold to determine which log messages are recorded and which are ignored.
- Persistent Log Context - Creates logger entries with predefined fields that are automatically included in every subsequent log statement.
- Custom Log Formatting - Allows the definition of custom layouts to convert log data between JSON and plain text formats.
- Event Callbacks - Executes user-defined callback functions during log events to route data to external monitoring services.
- Thread-Safe Logging - Ensures thread-safe logging across multiple goroutines using configurable mutex locking to prevent data corruption.
- Application Observability - Tracks execution flows and system health by attaching request metadata and severity levels to log entries.
- Log Severity Categorization - Assigns priority levels to logs to distinguish between operational noise, warnings, and critical errors.
- Multi-Level Message Emission - Records events at various severity levels using an interface compatible with standard logging patterns.
- Hierarchical Log Entries - Allows deriving new log entries from a parent to inherit existing fields while adding unique metadata.
- Logger Hierarchies - Provides hierarchical logger instances that inherit persistent key-value pairs from parent loggers for contextual tracing.
- Contextual Logger Instances - Attaches persistent metadata and request-scoped fields to entries to improve traceability and debugging.
- Logging Pipelines - Routes application logs to external services or custom destinations via a pluggable hook system.
- Request-Scoped Log Context - Links request-scoped metadata to log entries to track execution flows using unique trace identifiers.
- Logging Frameworks - Implements a pluggable framework for extending log behavior via hooks that route entries to external destinations.
- Automatic Field Injectors - Automatically adds custom fields to every log entry by intercepting the event before it is written.
- Runtime Call-Stack Capturers - Inspects the execution stack at runtime to capture the filename and line number of the calling function.
- Go - Captures precise call site information and error metadata in Go to accelerate the troubleshooting process.
- Deferred Log Evaluation - Optimizes performance by executing log argument generation functions only when the active log level permits writing.
- Standard Library Adapters - Implements compatibility layers that capture logs from the Go standard library and integrate them into a structured logging pipeline.
- Memory Object Pools - Implements memory object pools to recycle byte buffers and minimize garbage collection overhead during log serialization.
- Logging - Provides a pluggable hook system to execute custom logic or route logs to external services based on severity levels.
- Call Site Capturers - Records the specific method and file location in the call stack to simplify the debugging process.
- Application Log Redirection - Provides the ability to route log entries to different destinations such as the standard output stream or a file.
- Monitoring Service Log Exporters - Forwards log events to external monitoring endpoints or third-party platforms through a pluggable hook system.
- Error Logging Utilities - Integrates error objects as structured fields within log entries for improved error reporting and stack trace capture.
- Plain Text Log Formatting - Converts structured entries into space-separated key-value pairs with customizable quoting and ANSI color coding.
- Custom Log Writers - Ships custom writers that wrap standard output streams to route external library logs into the structured pipeline.
- Logging - Structured logging library.
- Monitoring and Logging - A structured logging library compatible with the standard logger.
- Logging - Structured logging library.
- Logging Frameworks - Structured logging library for Go.
- Logging Libraries - Structured logger for Go applications.
Star history
How this analysis was created: This summary and feature list were written by an AI model that read the project's README and public documentation pages. Each feature links to the documentation it came from; stars, license and language come straight from the GitHub API. The model does not read the source code, and the analysis is refreshed when the project is re-analysed. Learn more on our About page.
