./sysutils/py-structlog, Painless structural logging

[ CVSweb ] [ Homepage ] [ RSS ] [ Required by ] [ Add to tracker ]


Branch: CURRENT, Version: 20.2.0, Package name: py38-structlog-20.2.0, Maintainer: pkgsrc-users

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.


Required to run:
[devel/py-setuptools] [lang/py-six] [lang/python37]

Required to build:
[pkgtools/cwrappers]

Master sites:

SHA1: e7a1f2fb6ed8ba4627c2211bbebcddc71eadec1d
RMD160: f4b2adfb97efb5a0018fd1003f8d162e787daa05
Filesize: 363.079 KB

Version history: (Expand)


CVS history: (Expand)


   2021-02-07 16:42:49 by Adam Ciarcinski | Files touched by this commit (3) | Package updated
Log message:
py-structlog: updated to 20.2.0

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.
   2020-09-30 09:01:52 by Adam Ciarcinski | Files touched by this commit (3) | Package updated
Log message:
py-structlog: updated to 20.1.0

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.
   2019-10-19 16:41:27 by Adam Ciarcinski | Files touched by this commit (2) | Package updated
Log message:
py-structlog: updated to 19.2.0

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.
   2019-03-04 09:40:57 by Adam Ciarcinski | Files touched by this commit (2) | Package updated
Log message:
py-structlog: updated to 19.1.0

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.
   2018-10-07 09:19:22 by Adam Ciarcinski | Files touched by this commit (2) | Package updated
Log message:
py-structlog: updated to 18.2.0

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.
   2018-02-06 09:09:08 by Adam Ciarcinski | Files touched by this commit (2) | Package updated
Log message:
py-structlog: updated to 18.1.0

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.
   2017-10-07 13:18:28 by Adam Ciarcinski | Files touched by this commit (3) | Package updated
Log message:
py-structlog: update to 17.2.0

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.
   2017-09-16 21:27:31 by Thomas Klausner | Files touched by this commit (372)
Log message:
Reset maintainer