Daiquiri (Logging Library)

3.4.0 · active · verified Thu Apr 16

Daiquiri is a Python library designed to simplify the configuration of Python's built-in `logging` module. It provides an easy-to-use interface for setting up basic logging functionalities, including custom formatters and handlers, often with a single call to `daiquiri.setup()`. The library is actively maintained, with its current version being 3.4.0, and has a consistent update cadence.

Common errors

```
No logging output appears in the console or file, or 'No handlers could be found for logger'
```
cause Daiquiri's logging setup function, `daiquiri.setup()`, has not been called, or was called incorrectly, preventing handlers from being attached to the root logger.

fix Call `daiquiri.setup()` at the beginning of your application's entry point, specifying desired levels and outputs. E.g., `import daiquiri; daiquiri.setup(level=logging.INFO)`.
```
ModuleNotFoundError: No module named 'python_json_logger'
```
cause You are attempting to use `daiquiri.formatter.JSON_FORMATTER` without installing its required dependency, `python-json-logger`.

fix Install the missing dependency: `pip install python-json-logger`.
```
Confusion with another library or framework named 'Daiquiri'
```
cause There are other Python projects, such as `django-daiquiri` (a framework for scientific databases) and `daiquiri` (a data quality reporting package for R, sometimes confused with Python). Users might install the wrong package or search for documentation of the wrong project.

fix Ensure you are installing `pip install daiquiri` for the logging library, and refer to its official documentation at `http://daiquiri.readthedocs.io/` or the GitHub repository at `https://github.com/Mergifyio/daiquiri`.

Warnings

gotcha Daiquiri by default overrides Python's standard `warnings` module behavior, routing warnings to the `py.warnings` logger. If you rely on default `warnings` module behavior or custom warning filters, this might affect your application.
Fix: To disable this, pass `capture_warnings=False` to `daiquiri.setup()`: `daiquiri.setup(capture_warnings=False)`.
gotcha While standard `logging.getLogger()` works, `daiquiri.getLogger()` is recommended. It provides an enhanced logger object that allows passing arbitrary keyword arguments to logging methods, which are then included as part of the log record. This enables rich, structured logging without extra boilerplate.
Fix: Always retrieve loggers using `logger = daiquiri.getLogger(__name__)` to leverage all of Daiquiri's features.
gotcha For structured JSON logging using `daiquiri.formatter.JSON_FORMATTER`, the `python-json-logger` library is a required dependency and must be installed separately.
Fix: Ensure `pip install python-json-logger` is run if you intend to use JSON formatting.

Install

pip install daiquiri Install latest version

Imports

setup
```
import daiquiri
daiquiri.setup(...)
```

getLogger

import daiquiri
logger = daiquiri.getLogger(__name__)

Stream
```
from daiquiri.output import Stream
```
Used to configure logging output to streams like stdout or stderr.
File
```
from daiquiri.output import File
```
Used to configure logging output to a file.
JSON_FORMATTER
```
from daiquiri.formatter import JSON_FORMATTER
```
Requires 'python-json-logger' to be installed.
TEXT_FORMATTER
```
from daiquiri.formatter import TEXT_FORMATTER
```
Default text formatter, no extra dependencies.

Quickstart

This quickstart demonstrates how to initialize Daiquiri for basic logging to `stderr` with colored output. It also shows how to obtain a logger instance and log messages at different levels, including custom keyword arguments which Daiquiri supports natively. An commented-out example for JSON file logging is also provided, highlighting the need for an additional dependency.

import logging
import daiquiri

# Basic setup to log to stderr with colors
daiquiri.setup(level=logging.INFO)

# Get a logger instance
logger = daiquiri.getLogger(__name__)

logger.info('This is an info message.')
logger.warning('This is a warning message.')
logger.error('This is an error message with extra context!', user_id='123', transaction_id='abc')

# Example with JSON output to a file (requires 'pip install python-json-logger')
# from daiquiri.output import File
# from daiquiri.formatter import JSON_FORMATTER
# daiquiri.setup(
#     level=logging.INFO,
#     outputs=(
#         File('app.log', formatter=JSON_FORMATTER),
#     )
# )
# logger_json = daiquiri.getLogger('json_example')
# logger_json.info('JSON message', data={'key': 'value'})

view raw JSON →