hynek/structlog
Structlog
structlog is a structured logging library for Python that treats log entries as dictionaries instead of strings. This data-centric approach enables machine-readable output and precise data analysis by generating log entries as key-value pairs. It functions as both a standalone logging framework and a compatibility layer that adds structured capabilities to the Python standard library logging module.
The library features a processor-pipeline architecture that passes log dictionaries through a sequence of functions to modify events or add metadata before final rendering. It includes a contextual logging utility for binding key-value metadata to loggers, ensuring traceability across execution boundaries and threads. For high-volume environments, it provides an asynchronous logging framework with awaitable methods to prevent blocking the event loop.
The project covers a broad observability surface, including multi-format rendering for JSON and colorized console output, as well as log volume throttling and severity level filtering. It supports routing processed log data to external services, system journals, and network sockets. Additionally, it includes utilities for automated logging verification to validate that applications emit expected log entries and metadata during testing.
Features
- Structured Log Capture - Treats log events as dictionaries and captures parameters as key-value pairs for precise querying and serialization.
- Dictionary-Based Event Representation - Treats log entries as mutable dictionaries instead of strings to enable precise, machine-readable processing throughout the pipeline.
- Standard Library Adapters - Provides compatibility layers that wrap standard library logging interfaces to inject structured capabilities into existing code.
- Persistent Log Context - Provides mechanisms to attach predefined key-value pairs to loggers that are automatically included in all subsequent log entries.
- Multi-Format Renderers - Converts structured log data into various formats including JSON and colorized text for both machine and human consumption.
- Pipeline Architectures - Utilizes a pipeline architecture that passes log dictionaries through a sequence of independent functions to modify events.
- Asynchronous Logging - Provides a logging system with awaitable methods to prevent blocking the event loop in high-volume asynchronous environments.
- Contextual Logging - Provides utilities for binding key-value metadata to loggers to maintain traceability across execution boundaries.
- Context Attachments - Attaches key-value pairs to a logger so all subsequent entries automatically include the same metadata.
- Log Processing Pipelines - Passes log dictionaries through a processor pipeline to automatically enrich events with timestamps and call stacks.
- Structured Logging - Creates machine-readable log entries as key-value pairs to enable precise filtering and automated data analysis.
- Structured Logging Frameworks - Implements a logging framework that treats log entries as dictionaries for machine-readable output and precise analysis.
- Log Formatters - Converts structured application events into JSON and logfmt for ingestion by centralized monitoring systems.
- Console Log Formatting - Formats Python log output as colorized, human-readable text to simplify troubleshooting during active development.
- Log Target Wrappers - Acts as a wrapper for standard library loggers to add structured capabilities while maintaining compatibility.
- Console Log Formatters - Transforms structured log data into colorized, human-friendly console output for local development debugging.
- Asynchronous Metadata Propagation - Passes metadata to background worker threads to maintain traceability across asynchronous execution boundaries.
- Deferred Log Rendering - Implements a strategy that keeps logs in a structured format until final rendering to optimize processing and flexibility.
- Thread-Local Context Management - Maintains global state across applications using thread-local storage to ensure log consistency without explicit parameter passing.
- Severity Level Filtering - Controls which messages are emitted by filtering them based on predefined severity levels.
- Centralized Logging Systems - Routes structured log data to external services and system journals for unified monitoring in distributed environments.
- Global Log Contexts - Maintains application-wide shared data using local storage variables to ensure consistent logs across different components.
- Log Event Filtering - Provides logic to determine whether a log event should be processed or discarded based on content criteria.
- Log Frequency Throttling - Implements mechanisms to limit the rate of log emission to prevent system flooding during high-volume events.
- Pluggable Logging Backends - Supports directing processed log data to interchangeable output destinations by decoupling event generation from delivery.
- Log Message Assertions - Includes utilities to assert that specific log keys and metadata were emitted during automated test execution.
- Logging - Structured logging framework.
- डेवलपर टूल्स - Structured logging for Python.
- Development Utilities - Structured logging for Python applications.
- Logging and Output - Structured logging for production-ready applications.
