21.5.0 (2021-12-16)
-------------------
Changes:
- Added the ``structlog.processors.LogfmtRenderer`` processor to render log lines using the `logfmt <https://brandur.org/logfmt>`_ format.
- Added the ``structlog.stdlib.ExtraAdder`` processor that adds extra attributes of ``logging.LogRecord`` objects to the event dictionary.
This processor can be used for adding data passed in the ``extra`` parameter of the ``logging`` module's log methods to the event dictionary.
- Added the ``structlog.processor.CallsiteParameterAdder`` processor that adds parameters of the callsite that an event dictionary orginated from to the event dictionary.
This processor can be used to enrich events dictionaries with information such as the function name, line number and filename that an event dictionary orignated from.
21.4.0 (2021-11-25)
-------------------
Changes:
- Fixed import when running in optimized mode (``PYTHONOPTIMIZE=2`` or ``python -OO``).
- Added the ``structlog.threadlocal.bound_threadlocal`` and ``structlog.contextvars.bound_contextvars`` decorator/context managers to temporarily bind key/value pairs to a thread-local and context-local context.
21.3.0 (2021-11-20)
-------------------
Backward-incompatible changes:
- ``structlog`` switched its packaging to `flit <https://flit.readthedocs.io/>`_.
Users shouldn't notice a difference, but (re-)packagers might.
Changes:
- ``structlog.dev.ConsoleRenderer`` now has ``sort_keys`` boolean parameter that allows to disable the sorting of keys on output.
- ``structlog.processors.TimeStamper`` now works well with FreezeGun even when it gets applied before the loggers are configured.
- ``structlog.stdlib.AsyncBoundLogger`` now determines the running loop when logging, not on instantiation.
That has a minor performance impact, but makes it more robust when loops change (e.g. ``aiohttp.web.run_app()``), or you want to use ``sync_bl`` *before* a loop has started.
- ``structlog.stdlib.ProcessorFormatter`` now has a *processors* argument that allows to define a processor chain to run over *all* log entries.
Before running the chain, two additional keys are added to the event dictionary: ``_record`` and ``_from_structlog``.
With them it's possible to extract information from ``logging.LogRecord``\s and differentiate between ``structlog`` and ``logging`` log entries while processing them.
The old *processor* (singular) parameter is now deprecated, but no plans exist to remove it.
21.2.0 (2021-10-12)
-------------------
Backward-incompatible changes:
- To implement pretty exceptions (see Changes below), ``structlog.dev.ConsoleRenderer`` now formats exceptions itself.
Make sure to remove ``format_exc_info`` from your processor chain if you configure ``structlog`` manually.
This change is not really breaking, because the old use-case will keep working as before.
However if you pass ``pretty_exceptions=True`` (which is the default if either ``rich`` or ``better-exceptions`` is installed), a warning will be raised and the exception will be renderered without prettyfication.
Changes:
- ``structlog`` is now importable if ``sys.stdout`` is ``None`` (e.g. when running using ``pythonw``).
- ``structlog.threadlocal.get_threadlocal()`` and ``structlog.contextvars.get_contextvars()`` can now be used to get a copy of the current thread-local/context-local context that has been bound using ``structlog.threadlocal.bind_threadlocal()`` and ``structlog.contextvars.bind_contextvars()``.
- ``structlog.threadlocal.get_merged_threadlocal(bl)`` and ``structlog.contextvars.get_merged_contextvars(bl)`` do the same, but also merge the context from a bound logger *bl*.
Same pull requests as previous change.
- ``structlog.contextvars.bind_contextvars()`` now returns a mapping of keys to ``contextvars.Token``\s, allowing you to reset values using the new ``structlog.contextvars.reset_contextvars()``.
- Exception rendering in ``structlog.dev.ConsoleLogger`` is now configurable using the ``exception_formatter`` setting.
If either the `rich <https://github.com/willmcgugan/rich>`_ or the `better-exceptions <https://github.com/qix-/better-exceptions>`_ package is present, ``structlog`` will use them for pretty-printing tracebacks.
``rich`` takes precedence over ``better-exceptions`` if both are present.
This only works if ``format_exc_info`` is **absent** in the processor chain.
- All use of ``colorama`` on non-Windows systems has been excised.
Thus, colors are now enabled by default in ``structlog.dev.ConsoleRenderer`` on non-Windows systems.
You can keep using ``colorama`` to customize colors, of course.
- The final processor can now return a ``bytearray`` (additionally to ``str`` and ``bytes``).
21.1.0 (2021-02-18)
Changes:
- ``structlog.threadlocal.wrap_dict()`` now has a correct type annotation.
- Fix isolation in ``structlog.contextvars``.
- The default configuration and loggers are pickleable again.
- ``structlog.dev.ConsoleRenderer`` will now look for a ``logger_name`` key if no
``logger`` key is set.
20.2.0
Backward-incompatible changes:
- Python 2.7 and 3.5 aren't supported anymore.
The package meta data should ensure that you keep getting 20.1.0 on those versions.
- ``structlog`` is now fully type-annotated.
This won't break your applications, but if you use Mypy, it will most likely break your CI.
Check out the new chapter on typing for details.
Deprecations:
- Accessing the ``_context`` attribute of a bound logger is now deprecated.
Please use the new ``structlog.get_context()``.
Changes:
- ``structlog`` has now type hints for all of its APIs!
Since ``structlog`` is highly dynamic and configurable, this led to a few concessions like a specialized ``structlog.stdlib.get_logger()`` whose only difference to ``structlog.get_logger()`` is that it has the correct type hints.
We consider them provisional for the time being – i.e. the backward compatibility does not apply to them in its full strength until we feel we got it right.
Please feel free to provide feedback!
- Added ``structlog.make_filtering_logger`` that can be used like ``configure(wrapper_class=make_filtering_bound_logger(logging.INFO))``.
It creates a highly optimized bound logger whose inactive methods only consist of a ``return None``.
This is now also the default logger.
- As a complement, ``structlog.stdlib.add_log_level()`` can now additionally be imported as ``structlog.processors.add_log_level`` since it just adds the method name to the event dict.
- ``structlog.processors.add_log_level()`` is now part of the default configuration.
- ``structlog.stdlib.ProcessorFormatter`` no longer uses exceptions for control flow, allowing ``foreign_pre_chain`` processors to use ``sys.exc_info()`` to access the real exception.
- Added ``structlog.BytesLogger`` to avoid unnecessary encoding round trips.
Concretely this is useful with *orjson* which returns bytes.
- The final processor now also may return bytes that are passed untouched to the wrapped logger.
- ``structlog.get_context()`` allows you to retrieve the original context of a bound logger.
- ``structlog.PrintLogger`` now supports ``copy.deepcopy()``.
- Added ``structlog.testing.CapturingLogger`` for more unit testing goodness.
- Added ``structlog.stdlib.AsyncBoundLogger`` that executes logging calls in a thread executor and therefore doesn't block.
20.1.0
Deprecations:
- This is the last version to support Python 2.7 (including PyPy) and 3.5.
All following versions will only support Python 3.6 or later.
Changes:
- Added a new module ``structlog.contextvars`` that allows to have a global but context-local ``structlog`` context the same way as with ``structlog.threadlocal`` since 19.2.0.
- Added a new module ``structlog.testing`` for first class testing support.
The first entry is the context manager ``capture_logs()`` that allows to make assertions about structured log calls.
- Added ``structlog.threadlocal.unbind_threadlocal()``.
- The logger created by ``structlog.get_logger()`` is not detected as an abstract method anymore, when attached to an abstract base class.
- ``colorama`` isn't initialized lazily on Windows anymore because it breaks rendering.
19.2.0:
Backward-incompatible changes:
- Python 3.4 is not supported anymore.
It has been unsupported by the Python core team for a while now and its PyPI downloads are negligible.
It's very unlikely that ``structlog`` will break under 3.4 anytime soon, but we don't test it anymore.
Changes:
- Full Python 3.8 support for ``structlog.stdlib``.
- Added more pass-through properties to ``structlog.stdlib.BoundLogger``.
To makes it easier to use it as a drop-in replacement for ``logging.Logger``.
- ``structlog.stdlib.ProcessorFormatter`` now takes a logger object as an optional keyword argument.
This makes ``ProcessorFormatter`` work properly with ``stuctlog.stdlib.filter_by_level()``.
- ``structlog.dev.ConsoleRenderer`` now uses no colors by default, if ``colorama`` is not available.
- ``structlog.dev.ConsoleRenderer`` now initializes ``colorama`` lazily, to prevent accidental side-effects just by importing ``structlog``.
- Added new processor ``structlog.dev.set_exc_info()`` that will set ``exc_info=True`` if the method's name is `exception` and ``exc_info`` isn't set at all.
*This is only necessary when the standard library integration is not used*.
It fixes the problem that in the default configuration, ``structlog.get_logger().exception("hi")`` in an ``except`` block would not print the exception without passing ``exc_info=True`` to it explicitly.
- A best effort has been made to make as much of ``structlog`` pickleable as possible to make it friendlier with ``multiprocessing`` and similar libraries.
Some classes can only be pickled on Python 3 or using the `dill <https://pypi.org/project/dill/>`_ library though and that is very unlikely to change.
So far, the configuration proxy, ``structlog.processor.TimeStamper``, ``structlog.BoundLogger``, ``structlog.PrintLogger`` and ``structlog.dev.ConsoleRenderer`` have been made pickelable.
- Added a new thread-local API that allows binding values to a thread-local context explicitly without affecting the default behavior of ``bind()``.
- Added ``pass_foreign_args`` argument to ``structlog.stdlib.ProcessorFormatter``.
It allows to pass a foreign log record's ``args`` attribute to the event dictionary under the ``positional_args`` key.
- ``structlog.dev.ConsoleRenderer`` now calls ``str()`` on the event value.
19.1.0:
Backward-incompatible changes:
- As announced in 18.1.0, pip install -e .[dev] now installs all development dependencies.
Sorry for the inconveniences this undoubtedly will cause!
Changes:
- structlog.ReturnLogger and structlog.PrintLogger now have a fatal() log method.
- Under certain (rather unclear) circumstances, the frame extraction could throw an SystemError: error return without exception set.
A workaround has been added.
- structlog now tolerates passing through dict\ s to stdlib logging.
18.2.0:
Changes:
- Added structlog.stdlib.add_log_level_number() processor that adds the level *number* to the event dictionary.
Can be used to simplify log filtering.
- structlog.processors.JSONRenderer now allows for overwriting the *default* argument of its serializer.
- Added try_unbind() that works like unbind() but doesn't raise a KeyError if one of the keys is missing.
18.1.0:
Deprecations:
- The meaning of the structlog[dev] installation target will change from "colorful output" to "dependencies to develop structlog" in 19.1.0.
The main reason behind this decision is that it's impossible to have a structlog in your normal dependencies and additionally a structlog[dev] for developement (pip will report an error).
Changes:
- Empty strings are valid events now.
- Do not encapsulate Twisted failures twice with newer versions of Twisted.
- structlog.dev.ConsoleRenderer now accepts a *force_colors* argument to output colored logs even if the destination is not a tty.
Use this option if your logs are stored in files that are intended to be streamed to the console.
- structlog.dev.ConsoleRenderer now accepts a *level_styles* argument for overriding the colors for individual levels, as well as to add new levels.
- structlog.stdlib.BoundLogger.exception() now uses the exc_info argument if it has been passed instead of setting it unconditionally to True.
- Default configuration now uses plain dict\ s on Python 3.6+ and PyPy since they are ordered by default.
- Added structlog.is_configured() to check whether or not structlog has been configured.
- Added structlog.get_config() to introspect current configuration.
17.2.0:
- ``structlog.stdlib.ProcessorFormatter`` now accepts *keep_exc_info* and *keep_stack_info* arguments to control what to do with this information on log records.
Most likely you want them both to be ``False`` therefore it's the default.
- ``structlog.stdlib.add_logger_name()`` now works in ``structlog.stdlib.ProcessorFormatter``'s ``foreign_pre_chain``.
- Clear log record args in ``structlog.stdlib.ProcessorFormatter`` after rendering.
This fix is for you if you tried to use it and got ``TypeError: not all arguments converted during string formatting`` exceptions.
Problems found with existing digests:
Package memconf distfile memconf-2.16/memconf.gz
b6f4b736cac388dddc5070670351cf7262aba048 [recorded]
95748686a5ad8144232f4d4abc9bf052721a196f [calculated]
Problems found locating distfiles:
Package dc-tools: missing distfile dc-tools/abs0-dc-burn-netbsd-1.5-0-gae55ec9
Package ipw-firmware: missing distfile ipw2100-fw-1.2.tgz
Package iwi-firmware: missing distfile ipw2200-fw-2.3.tgz
Package nvnet: missing distfile nvnet-netbsd-src-20050620.tgz
Package syslog-ng: missing distfile syslog-ng-3.7.2.tar.gz
Otherwise, existing SHA1 digests verified and found to be the same on
the machine holding the existing distfiles (morden). All existing
SHA1 digests retained for now as an audit trail.
Changelog
=========
- :release:`15.1.0 <2015-02-24>`
- 🐛`- major` Tolerate frames without a ``__name__``.
- :release:`15.0.0 <2015-01-23>`
- :feature:`44` Add :func:`structlog.stdlib.add_log_level` and :func:`structlog.stdlib.add_logger_name` processors.
- :feature:`42` Add :func:`structlog.stdlib.BoundLogger.log`.
- :feature:`19` Pass positional arguments to stdlib wrapped loggers that use string formatting.
- :feature:`28` structlog is now dually licensed under the `Apache License, Version 2 <http://choosealicense.com/licenses/apache-2.0/>`_ and the `MIT <http://choosealicense.com/licenses/mit/>`_ license.
Therefore it is now legal to use structlog with `GPLv2 <http://choosealicense.com/licenses/gpl-2.0/>`_-licensed projects.
- :feature:`22` Add :func:`structlog.stdlib.BoundLogger.exception`.
structlog makes structured logging in Python easy by augmenting your existing
logger. It allows you to split your log entries up into key/value pairs and
build them incrementally without annoying boilerplate code.
