commit bda3ec9860cf0b003a4abf527119086a07d84d646f5ada749139b7464cbcf220 Author: Michael Vetter Date: Thu Oct 30 08:14:57 2025 +0000 - Update to 25.5.0: Deprecated: * structlog.dev.ConsoleRenderer()'s pad_event argument has been renamed to pad_event_to to differentiate it from the boolean pad_level argument. pad_event is now deprecated. Added: * Added structlog.dev.ConsoleRenderer.get_active() that returns the currently active structlog.dev.ConsoleRenderer(). #749 * structlog.dev.ConsoleRenderer() now supports setting the exception_formatter attribute. * You can now disable the pretty-printing of exceptions by setting it to structlog.dev.plain_traceback: cr = structlog.dev.ConsoleRenderer.get_active() cr.exception_formatter = structlog.dev.plain_traceback Same goes for sort_keys, columns, colors, force_colors, level_styles, pad_event_to, event_key, timestamp_key, and repr_native_str. #749 #756 #757 #759 * Added structlog.dev.ConsoleRenderer.get_default_column_styles() for reuse the default column styles. #741 * structlog.testing.capture_logs() now optionally accepts processors to apply before capture. #728 * structlog.dev.RichTracebackFormatter now exposes the upstream code_width parameter. Default width is now None for full terminal width. Full terminal width is now handled by Rich itself, bringing support for reflow and COLUMN environment variable. Passing -1 for width is now deprecated and automatically replaced by None. #717 * Native loggers now allow the passing of a dictionary for dictionary-based interpolation log.info("hello %(name)s!", {"name": "world"}). #748 * On Python 3.11+, structlog.processors.CallsiteParameterAdder now supports CallsiteParameter.QUAL_NAME that adds the qualified name of the callsite, including scope and class names. This is only available for structlog-originated events since the standard library has no equivalent. * structlog.stdlib.LoggerFactory now supports the stacklevel parameter. #763 Changed: OBS-URL: https://build.opensuse.org/package/show/devel:languages:python/python-structlog?expand=0&rev=34 diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..9b03811 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,23 @@ +## Default LFS +*.7z filter=lfs diff=lfs merge=lfs -text +*.bsp filter=lfs diff=lfs merge=lfs -text +*.bz2 filter=lfs diff=lfs merge=lfs -text +*.gem filter=lfs diff=lfs merge=lfs -text +*.gz filter=lfs diff=lfs merge=lfs -text +*.jar filter=lfs diff=lfs merge=lfs -text +*.lz filter=lfs diff=lfs merge=lfs -text +*.lzma filter=lfs diff=lfs merge=lfs -text +*.obscpio filter=lfs diff=lfs merge=lfs -text +*.oxt filter=lfs diff=lfs merge=lfs -text +*.pdf filter=lfs diff=lfs merge=lfs -text +*.png filter=lfs diff=lfs merge=lfs -text +*.rpm filter=lfs diff=lfs merge=lfs -text +*.tbz filter=lfs diff=lfs merge=lfs -text +*.tbz2 filter=lfs diff=lfs merge=lfs -text +*.tgz filter=lfs diff=lfs merge=lfs -text +*.ttf filter=lfs diff=lfs merge=lfs -text +*.txz filter=lfs diff=lfs merge=lfs -text +*.whl filter=lfs diff=lfs merge=lfs -text +*.xz filter=lfs diff=lfs merge=lfs -text +*.zip filter=lfs diff=lfs merge=lfs -text +*.zst filter=lfs diff=lfs merge=lfs -text diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..57affb6 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +.osc diff --git a/25.4.0.tar.gz b/25.4.0.tar.gz new file mode 100644 index 0000000..3b61061 --- /dev/null +++ b/25.4.0.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:45833c9b50a947e936dff0b0065919e292a38beef2461a218048d120e507789c +size 1375639 diff --git a/25.5.0.tar.gz b/25.5.0.tar.gz new file mode 100644 index 0000000..4646e91 --- /dev/null +++ b/25.5.0.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ca447e91f03a18b3ae1f1917342c023091e923418409e19cfe67b90dbdce2694 +size 1465162 diff --git a/python-structlog.changes b/python-structlog.changes new file mode 100644 index 0000000..ffd5ee6 --- /dev/null +++ b/python-structlog.changes @@ -0,0 +1,547 @@ +------------------------------------------------------------------- +Thu Oct 30 08:03:20 UTC 2025 - Michael Vetter + +- Update to 25.5.0: + Deprecated: + * structlog.dev.ConsoleRenderer()'s pad_event argument has been renamed + to pad_event_to to differentiate it from the boolean pad_level argument. + pad_event is now deprecated. + Added: + * Added structlog.dev.ConsoleRenderer.get_active() that returns the currently + active structlog.dev.ConsoleRenderer(). #749 + * structlog.dev.ConsoleRenderer() now supports setting the exception_formatter attribute. + * You can now disable the pretty-printing of exceptions by setting it to + structlog.dev.plain_traceback: + cr = structlog.dev.ConsoleRenderer.get_active() + cr.exception_formatter = structlog.dev.plain_traceback + Same goes for sort_keys, columns, colors, force_colors, level_styles, pad_event_to, + event_key, timestamp_key, and repr_native_str. #749 #756 #757 #759 + * Added structlog.dev.ConsoleRenderer.get_default_column_styles() for reuse the + default column styles. #741 + * structlog.testing.capture_logs() now optionally accepts processors to apply before capture. #728 + * structlog.dev.RichTracebackFormatter now exposes the upstream code_width parameter. + Default width is now None for full terminal width. Full terminal width is now handled by + Rich itself, bringing support for reflow and COLUMN environment variable. Passing -1 for + width is now deprecated and automatically replaced by None. #717 + * Native loggers now allow the passing of a dictionary for dictionary-based interpolation + log.info("hello %(name)s!", {"name": "world"}). #748 + * On Python 3.11+, structlog.processors.CallsiteParameterAdder now supports + CallsiteParameter.QUAL_NAME that adds the qualified name of the callsite, including scope + and class names. This is only available for structlog-originated events since the standard + library has no equivalent. + * structlog.stdlib.LoggerFactory now supports the stacklevel parameter. #763 + Changed: + * structlog.dev.rich_traceback() now throws a more helpful error when Rich is missing. #735 + Fixed: + * structlog.processors.MaybeTimeStamper now respects the key argument when determining + whether to overwrite the timestamp field. #747 + * structlog.tracebacks.extract() no longer raises a RecursionError when the cause chain + of an exception contains itself. #739 + * Default config now respects FORCE_COLOR on Windows. #758 + +------------------------------------------------------------------- +Mon Jun 2 17:09:13 UTC 2025 - Michael Vetter + +- Update to 25.4.0: + Added: + * Support for Python 3.14 and Python 3.13.4. + * Python 3.14 has an backwards-incompatible change to logging.Logger.isEnabledFor() + (it now always returns False if a log entry is in flight) that has been backported + to 3.13.4 (expected on 2025-06-03). It mainly affects structlog.stdlib.filter_by_level(). #723 + * structlog.tracebacks now handles exception groups. structlog.tracebacks.Stack has two + new fields, is_group: bool and exceptions: list[Trace]. This works similarly to what + Rich v14.0.0 does. #720 + Fixed: + * structlog.processors.ExceptionPrettyPrinter now respects the exception_formatter + arguments instead of always using the default formatter. #724 + +------------------------------------------------------------------- +Mon Apr 28 10:25:13 UTC 2025 - Michael Vetter + +- Update to 25.3.0: + * Fix a rather ugly bug where seemingly UTC timestamps in TimeStamper + had the timestamp from the local timezone when passing utc=True #713 + +------------------------------------------------------------------- +Wed Mar 12 08:14:09 UTC 2025 - Michael Vetter + +- Update to 25.2.0: + Added: + * structlog.tracebacks.Stack now includes an exc_notes field reflecting + the notes attached to the exception. #684 + Changed: + * structlog.stdlib.BoundLogger's binding-related methods now also return Self. #694 + * structlog.processors.TimeStamper now produces internally timezone-aware + datetime objects. Default output hasn't changed, but you can now use %z in your fmt string. #709 + Fixed: + * Expose structlog.dev.RichTracebackFormatter for imports. #699 + * Expose structlog.processors.LogfmtRenderer for imports. #701 + +------------------------------------------------------------------- +Wed Feb 5 08:17:32 UTC 2025 - Michael Vetter + +- Update to 25.1.0: + Added: + * Add structlog.stdlib.render_to_log_args_and_kwargs processor. Same + as structlog.stdlib.render_to_log_kwargs, but also allows to pass + positional arguments to logging. With it, you do not need to add + structlog.stdlib.PositionalArgumentsFormatter processor to format + positional arguments from structlog loggers. #668 + * Native loggers now have is_enabled_for() and get_effective_level() + methods that mirror the behavior of the standard library's + logging.Logger.isEnabledFor() and logging.Logger.getEffectiveLevel(). #689 + Changed: + * structlog.typing.BindableLogger protocol now returns Self instead + of BindableLogger. This adds a dependency on typing-extensions for + Pythons older than 3.11. #642 #659 + * structlog.dev.ConsoleRenderer will quote string value with special characters. #647 + * structlog.stdlib.recreate_defaults() now also adds structlog.stdlib.PositionalArgumentsFormatter. + In default native mode, this is done by the loggers at the edge. + * structlog.make_filtering_bound_logger() now also accepts a string for min_level. + Fixed: + * Fix handling calls to {logger}.exception() outside of exception blocks. Depending + on the structlog configuration, this either resulted in an event dict key + exception: "MISSING" or lead to an error. Now, an invalid or missing exc_info will + just be ignored. This means, that calling {logger}.exception() outside of an + exception block is basically the same as calling {logger}.error(). #634 #680 + * Instantiating structlog.dev.ConsoleRenderer does not mutate the passed styles dict anymore. #669 + * The native FilteringBoundLogger.fatal() method now maps to the critical level, as it + does in the standard library. Note that the level is discouraged to use there, so we + recommend to stick to error() or critical(). #677 + * structlog.tracebacks.ExceptionDictTransformer now actually accepts None for locals_max_length + and locals_max_string. #675 + +------------------------------------------------------------------- +Mon Jul 22 08:48:22 UTC 2024 - Michael Vetter + +- Update to 24.4.0: + * This is just a docs / PyPI README update. No code changes whatsoever. + +------------------------------------------------------------------- +Mon Jul 22 08:46:41 UTC 2024 - Michael Vetter + +- Update to 24.3.0: + * Restore feature parity between structlog.traceback.ExceptionDictTransformer + and Rich's traceback extractor #627 + + When displaying locals, use Rich for formatting if it is available. + + When displaying locals, call repr() on strings, too (improves handling of + SecretStr implementations). + + Add locals_max_length config option + + Add locals_hide_sunder config option + + Add locals_hide_dunder config option + + Add suppress config option + * structlog.testing.capture_logs() now maps the exception log level to + error (as it's elsewhere) #628 + +------------------------------------------------------------------- +Mon Jun 10 08:28:13 UTC 2024 - Dirk Müller + +- update to 24.2.0: + * It is now possible to disable log level-padding in + `structlog.dev.LogLevelColumnFormatter` and + `structlog.dev.ConsoleRenderer`. + * The `structlog.processors.CallsiteParameterAdder` can now be + pickled. + * `structlog.processors.CallsiteParameterAdder` now also works + with `structlog.stdlib.BoundLogger`'s non-standard async + methods (`ainfo()`, and so forth) + * `structlog.processors.LogfmtRenderer` now escapes newlines. + * `structlog.processors.LogfmtRenderer` now escapes backslashes + and double quotes. + * `structlog.processors.CallsiteParameterAdder` has been + optimized to be about 2x faster. + * `structlog.stdlib.render_to_log_kwargs` now correctly passes + stacklevel as a kwarg to stdlib logging. + +------------------------------------------------------------------- +Wed Jan 24 07:35:08 UTC 2024 - ecsos + +- Add %{?sle15_python_module_pythons} + https://en.opensuse.org/openSUSE:Packaging_Python + +------------------------------------------------------------------- +Sun Jan 14 15:12:14 UTC 2024 - Dirk Müller + +- update to 24.1.0: + * The lazy logger proxy returned by `structlog.get_logger()` + now returns its initial values when asked for context. + * When asked for context before binding for the first time, it + returned an empty dictionary in 23.3.0. + * The displayed level name when using + `structlog.stdlib.BoundLogger.exception()` is `"error"` + instead of `"exception"`. + * Don't ignore the `width` argument of + `RichTracebackFormatter`. + * Implementing the output on top of the new columns API has + changed the default very slightly, but shouldn't be + noticeable. + * Async log methods (those starting with an `a`) now also + support the collection of callsite information using + `structlog.processors.CallsiteParameterAdder`. + * `structlog.stdlib.recreate_defaults()` now also adds + `structlog.stdlib.add_logger_name` to the processors. + * The return value from `get_logger()` (a + `BoundLoggerLazyProxy`) now passes `isinstance`-checks + against `structlog.typing.BindableLogger` on Python 3.12. + * `structlog.threadlocal.tmp_bind()` now also works with + `BoundLoggerLazyProxy` (in other words: before anything is + bound to a bound logger). + * stdlib: `ProcessorFormatter` can now be told to not render + the log record message using `getMessage` and just + `str(record.msg)` instead. + * stdlib: `structlog.stdlib.BoundLogger.exception()`'s handling + of`LogRecord.exc_info` is now set consistent with `logging`. + * Official support for Python 3.12. + * `structlog.processors.MaybeTimeStamper` that only adds a + timestamp if there isn't one already. + * `structlog.dev.ConsoleRenderer` now supports renamed + timestamp keys using the *timestamp_key* parameter. + * `structlog.dev.RichTracebackFormatter` that allows to + configure the traceback formatting. + * `FilteringBoundLogger.exception()` and + `FilteringBoundLogger.aexception()` now support positional + argument formatting like the rest of the methods. + * `structlog.processors.format_exc_info()` and + `structlog.dev.ConsoleRenderer` do not crash anymore when + told to format a non-existent exception. + * `structlog.stdlib.BoundLogger` now has, analogously to our + native logger, a full set of async log methods prefixed with + an `a`: `await log.ainfo("event!")` + * The default configuration now respects the presence of + `FORCE_COLOR` (regardless of its value, unless an empty + string). + * This disables all heuristics whether it makes sense to use + colors. + * The default configuration now respects the presence of + `NO_COLOR` (regardless of its value, unless an empty string). + * This disables all heuristics whether it makes sense to use + colors and overrides `FORCE_COLOR`. + * Accessing package metadata as attributes on the *structlog* + module is deprecated (for example, `structlog.__version__`). + * Please use `importlib.metadata` instead (for Python 3.7: the + *importlib-metadata* PyPI package). + * The `structlog.types` module is now deprecated in favor of + the `structlog.typing` module. + * It seems like the Python typing community is settling on this + name. + * The timestamps in the default configuration now use the + correct separator (`:`) for seconds. + +------------------------------------------------------------------- +Fri Nov 11 13:14:31 UTC 2022 - pgajdos@suse.com + +- silent rpmlint + +------------------------------------------------------------------- +Fri Nov 11 12:02:17 UTC 2022 - pgajdos@suse.com + +- python-six is not required + +------------------------------------------------------------------- +Thu Jul 21 07:12:29 UTC 2022 - Michael Vetter + +- Update to 22.1.0: + Removed: + * Python 3.6 is not supported anymore. + * Pickling is now only possible with protocol version 3 and newer. + Deprecated: + * The entire structlog.threadlocal module is deprecated. Please use the + primitives from structlog.contextvars instead. + * If you're using the modern APIs (bind_threadlocal() / merge_threadlocal()) + it's enough to replace them 1:1 with their contextvars counterparts. The old + approach around wrap_dict() has been discouraged for a while. + * Currently there are no concrete plans to remove the module, but no patches + against it will be accepted from now on. #409 + Added: + * structlog.processors.StackInfoRenderer now has an additional_ignores + parameter that allows you to filter out your own logging layer. #396 + * Added structlog.WriteLogger, a faster – but more low-level – alternative to + structlog.PrintLogger. It works the way PrintLogger used to work in previous + versions. #403 #404 + * structlog.make_filtering_bound_logger()-returned loggers now also have a + log() method to match the structlog.stdlib.BoundLogger signature closer. #413 + * Added structured logging of tracebacks via the structlog.tracebacks module, + and most notably the structlog.tracebacks.ExceptionDictTransformer which can be + used with the new structlog.processors.ExceptionRenderer to render JSON + tracebacks. #407 + * structlog.stdlib.recreate_defaults(log_level=logging.NOTSET) that recreates + structlog's defaults on top of standard library's logging. It optionally also + configures logging to log to standard out at the passed log level. #428 + * structlog.processors.EventRenamer allows you to rename the hitherto + hard-coded event dict key event to something else. Optionally, you can rename + another key to event at the same time, too. So adding EventRenamer(to="msg", + replace_by="_event") to your processor pipeline will rename the standard event + key to msg and then rename the _event key to event. This allows you to use the + event key in your own log files and to have consistent log message keys across + languages. + * structlog.dev.ConsoleRenderer(event_key="event") now allows to customize + the name of the key that is used for the log message. + Changed: + * structlog.make_filtering_bound_logger() now returns a method with the same + signature for all log levels, whether they are active or not. This ensures that + invalid calls to inactive log levels are caught immediately and don't explode + once the log level changes. #401 + * structlog.PrintLogger – that is used by default – now uses print() for + printing, making it a better citizen for interactive terminal applications. #399 + * structlog.testing.capture_logs now works for already initialized bound loggers. #408 + * structlog.processors.format_exc_info() is no longer a function, but an + instance of structlog.processors.ExceptionRenderer. Its behavior has not + changed. #407 + * The default configuration now includes the + structlog.contextvars.merge_contextvars processor. That means you can use + structlog.contextvars features without configuring structlog. + Fixed: + * Overloaded the bind, unbind, try_unbind and new methods in the + FilteringBoundLogger Protocol. This makes it easier to use objects of type + FilteringBoundLogger in a typed context. #392 + * Monkeypatched sys.stdouts are now handled more gracefully by + ConsoleRenderer (that's used by default). #404 + * structlog.stdlib.render_to_log_kwargs() now correctly handles the presence + of exc_info, stack_info, and stackLevel in the event dictionary. They are + transformed into proper keyword arguments instead of putting them into the + extra dictionary. #424, #427 + +------------------------------------------------------------------- +Tue Mar 1 10:55:24 UTC 2022 - Michael Vetter + +- Update to 21.5.0: + * Added the structlog.processors.LogfmtRenderer processor to render + log lines using the logfmt format. #376 + * 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. #209 #377 + * 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. #380 + +------------------------------------------------------------------- +Tue Mar 1 10:50:45 UTC 2022 - Michael Vetter + +- Update to 21.4.0: + * Fixed import when running in optimized mode (PYTHONOPTIMIZE=2 + or python -OO). #373 + * 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. #371 + +------------------------------------------------------------------- +Tue Mar 1 10:49:07 UTC 2022 - Michael Vetter + +- Update to 21.3.0: + * structlog.dev.ConsoleRenderer now has sort_keys boolean parameter + that allows to disable the sorting of keys on output. #358 + * structlog.processors.TimeStamper now works well with FreezeGun + even when it gets applied before the loggers are configured. #364 + * 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.LogRecords 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. #365 + +------------------------------------------------------------------- +Wed Oct 13 08:36:18 UTC 2021 - Michael Vetter + +- Update to 21.2.0: + Highlights: + * Support for for beautiful (and helpful!) exceptions by integrating + ConsoleRenderer with rich or better-exceptions. + * Helpers to access thread-local and context-local context. + * Deeper contextvars support. + 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). #313 + * 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(). #331 #337 + * 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.Tokens, allowing you to reset values using the + new structlog.contextvars.reset_contextvars(). #339 + * Exception rendering in structlog.dev.ConsoleLogger is now configurable + using the exception_formatter setting. If either the rich or the + 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. + #330 #349 + * 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. #345 + * The final processor can now return a bytearray (additionally to str + and bytes). #344 + +------------------------------------------------------------------- +Fri Feb 19 08:07:55 UTC 2021 - Michael Vetter + +- Update to 21.1.0: + * structlog.threadlocal.wrap_dict() now has a correct type + annotation. #290 + * Fix isolation in structlog.contextvars. #302 + * The default configuration and loggers are pickleable again. #301 + * structlog.dev.ConsoleRenderer will now look for a logger_name + key if no logger key is set. #295 + +------------------------------------------------------------------- +Mon Jan 4 11:16:18 UTC 2021 - Michael Vetter + +- Update to 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. #244 + * structlog is now fully type-annotated. This won't break your + applications, but if you use Mypy, it will most likely break your CI. + 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! #223, #282 + * 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. #271 + * 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. #266, + * structlog.PrintLogger now supports copy.deepcopy(). #268 + * 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. #245 + +------------------------------------------------------------------- +Tue Mar 17 11:33:05 UTC 2020 - pgajdos@suse.com + +- version update to 20.1.0 + - 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. + - 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. + `#201 `_, + `#236 `_ + - 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. + `#14 `_, + `#234 `_ + - Added ``structlog.threadlocal.unbind_threadlocal()``. + `#239 `_ + - The logger created by ``structlog.get_logger()`` is not detected as an abstract method anymore, when attached to an abstract base class. + `#229 `_ + - ``colorama`` isn't initialized lazily on Windows anymore because it breaks rendering. + `#232 `_, + `#242 `_ + +------------------------------------------------------------------- +Thu Oct 17 06:35:14 UTC 2019 - Michael Vetter + +- Update to 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. #198 + * structlog.stdlib.ProcessorFormatter now takes a logger object as an + optional keyword argument. This makes ProcessorFormatter work properly + with stuctlog.stdlib.filter_by_level(). #219 + * structlog.dev.ConsoleRenderer now uses no colors by default, if + colorama is not available. #215 + * structlog.dev.ConsoleRenderer now initializes colorama lazily, to + prevent accidental side-effects just by importing structlog. #210 + * 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. #130, #173, #200, #204 + * 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 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. Please report if you need any another class fixed. #126 + * Added a new thread-local API that allows binding values to a thread-local + context explicitly without affecting the default behavior of bind(). #222, #225 + * 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. #228 + * structlog.dev.ConsoleRenderer now calls str() on the event value. #221 + +------------------------------------------------------------------- +Tue Apr 2 11:12:35 UTC 2019 - mvetter@suse.com + +- Update to 19.1.0: + * structlog.ReturnLogger and structlog.PrintLogger now have + a fatal() log method. #181 + * Under certain (rather unclear) circumstances, the frame + extraction could throw an SystemError: error return without + exception set. A workaround has been added. #174 + * structlog now tolerates passing through dicts to stdlib + logging. #187 #188 #189 +- Use pytest macro + +------------------------------------------------------------------- +Thu Nov 29 08:06:43 UTC 2018 - ecsos@opensuse.org + +- Fix source address and add missing source. + +------------------------------------------------------------------- +Thu Nov 22 13:28:52 UTC 2018 - Karol Babioch + +- Version update to 18.2.0 + * 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. #171 + +------------------------------------------------------------------- +Tue Jul 31 12:37:20 UTC 2018 - kbabioch@suse.com + +- Initial packaging of version 18.1.0 diff --git a/python-structlog.spec b/python-structlog.spec new file mode 100644 index 0000000..c6ac35a --- /dev/null +++ b/python-structlog.spec @@ -0,0 +1,74 @@ +# +# spec file for package python-structlog +# +# Copyright (c) 2025 SUSE LLC and contributors +# +# All modifications and additions to the file contributed by third parties +# remain the property of their copyright owners, unless otherwise agreed +# upon. The license for this file, and modifications and additions to the +# file, is the same license as for the pristine package itself (unless the +# license for the pristine package is not an Open Source License, in which +# case the license is the MIT License). An "Open Source License" is a +# license that conforms to the Open Source Definition (Version 1.9) +# published by the Open Source Initiative. + +# Please submit bugfixes or comments via https://bugs.opensuse.org/ +# + + +%{?sle15_python_module_pythons} +Name: python-structlog +Version: 25.5.0 +Release: 0 +Summary: Structured Logging for Python +License: Apache-2.0 OR MIT +Group: Development/Languages/Python +URL: http://www.structlog.org/en/stable/ +Source: https://github.com/hynek/structlog/archive/%{version}.tar.gz +BuildRequires: %{python_module Twisted} +BuildRequires: %{python_module coverage} +BuildRequires: %{python_module flit >= 2} +BuildRequires: %{python_module freezegun >= 0.2.8} +BuildRequires: %{python_module hatch-fancy-pypi-readme} +BuildRequires: %{python_module hatch_vcs} +BuildRequires: %{python_module pip} +BuildRequires: %{python_module pretend} +BuildRequires: %{python_module pytest >= 3.3.0} +BuildRequires: %{python_module pytest-asyncio} +BuildRequires: %{python_module python-rapidjson} +BuildRequires: %{python_module simplejson} +BuildRequires: %{python_module time-machine} +BuildRequires: %{python_module wheel} +BuildRequires: fdupes +BuildRequires: python-rpm-macros +BuildArch: noarch +%python_subpackages + +%description +structlog makes logging in Python less painful and more powerful by adding +structure to your log entries. + +It’s up to you whether you want structlog to take care about the output of your +log entries or whether you prefer to forward them to an existing logging system +like the standard library’s logging module. + +%prep +%setup -q -n structlog-%{version} + +%build +%pyproject_wheel + +%install +%pyproject_install +%python_expand %fdupes %{buildroot}%{$python_sitelib} + +%check +%pytest + +%files %{python_files} +%doc CHANGE* README* +%license LICENSE* +%{python_sitelib}/structlog +%{python_sitelib}/structlog*-info + +%changelog