ޠj ( S r SSKJr SSKrSSKrSSKrSSKrSSKrSSKrSSK r SSK
J r J r J
r
Jr SSKJr SSKJrJr \R& S: a SSKJr OSSKJr S S
KJr S S KJr S S KJrJ r S S
K J r J r J r S SKJ!r!J"r"J#r# S SK$J%r% S SK&J'r' S SKJ(r(J)r)J*r*J+r+J,r,J-r- / SQr.\R^ S.S.S jjr0\1" 5 r2 " S S\Rf 5 r4 " S S\5 r5S/S jr6 " S S5 r7 " S S 5 r8 " S S 5 r9 S0S jr: S0S! jr; S0S" jr<\Rz " S#SS$SS%S&S5 R| R 5 r@ " S' S(5 rAS)rB S1S* jrC S2S+ jrD " S, S-\R 5 rFg)3z
Processors and helpers specific to the :mod:`logging` module from the `Python
standard library `_.
See also :doc:`structlog's standard library support `.
) annotationsN)Callable
CollectionIterableSequence)partial)Anycast) )Self )_config)BoundLoggerBase) _find_first_app_frame_and_name
_format_stack)
LEVEL_TO_NAME
NAME_TO_LEVEL
add_log_level)_ASYNC_CALLING_STACK_ASYNC_CALLING_THREADmerge_contextvars) DropEvent)StackInfoRenderer)Context EventDictExcInfo ProcessorProcessorReturnValue
WrappedLogger)
BoundLogger
ExtraAdder
LoggerFactory PositionalArgumentsFormatterProcessorFormatterr add_log_level_numberadd_logger_namefilter_by_level
get_loggerrecreate_defaults render_to_log_args_and_kwargsrender_to_log_kwargs) log_levelc
Z U b, SS0n[ R " S S[ R U S.UD6 [ R
" 5 [ R " [ 5 [ [ [ [ 5 [ R S [ R S /[ [ 5 S9 g)
a
Recreate defaults on top of standard library's logging.
The output looks the same, but goes through `logging`.
As with vanilla defaults, the backwards-compatibility guarantees don't
apply to the settings applied here.
Args:
log_level:
If `None`, don't configure standard library logging **at all**.
Otherwise configure it to log to `sys.stdout` at *log_level*
(``logging.NOTSET`` being the default).
If you need more control over `logging`, pass `None` here and
configure it yourself.
.. versionadded:: 22.1.0
.. versionchanged:: 23.3.0 Added `add_logger_name`.
.. versionchanged:: 25.1.0 Added `PositionalArgumentsFormatter`.
NforceT %(message)s)formatstreamlevel)
processors
wrapper_classlogger_factory )logging basicConfigsysstdoutr reset_defaults configurer$ r r r' r _BUILTIN_DEFAULT_PROCESSORSr! r# )r- kws J/var/www/html/gaurav/venv/lib/python3.13/site-packages/structlog/stdlib.pyr* r* G s . t_
::
( * / / 3 / / 3
"$ c 2 \ rS rSrSr S SS jjrSrg)_FixedFindCallerLogger{ z]
Change the behavior of `logging.Logger.findCaller` to cope with
*structlog*'s extra frames.
c U( a [ SUS-
5 OSn[ S/US9u pEU( a [ U5 OSnUR R UR
UR R U4$ )z
Finds the first caller frame outside of structlog so that the caller
info is populated for wrapping stdlib.
This logger gets set as the default one when using LoggerFactory.
r r Nr: )
stacklevel)maxr r f_code co_filenamef_linenoco_name)self
stack_inforH adjusted_stacklevelf_namesinfos rB
findCaller!_FixedFindCallerLogger.findCaller se 9Cc!Z!^ 41
K$7
%/
a Dxx##QZZ1A1A5HHrC r9 NFr rO boolrH intreturnz tuple[str, int, str, str | None])__name__
__module__ __qualname____firstlineno____doc__rT __static_attributes__r9 rC rB rE rE { s3 ;<I I47I )I IrC rE c ^ \ rS rSr% SrS\S' S/U 4S jjrS0U 4S jjrS0U 4S jjrS/U 4S jjr S1S2S jjr
S1S2S
jjr S1S2S jjr \ r
S1S2S jjrS1S2S
jjrS1S2S jjr S1 S2S jjr S1 S3S jjr S1 S4U 4S jjjr\S5S j5 r\S6S j5 r\S7S j5 r\S8S j5 r\S7S j5 r\S6S j5 rS9S jr S: S;S jjr S< S=S jjr S>S jr S?S jr S?S jr S8S jr!S>S jr"S6S jr#S@S! jr$S@S" jr%S6S# jr&SAS$ jr' SBS% jr(SCS& jr)SCS' jr*SCS( jr+SCS) jr,SCS* jr-SCS+ jr.SCS, jr/ SDS- jr0S.r1U =r2$ )Er! a
Python Standard Library version of `structlog.BoundLogger`.
Works exactly like the generic one except that it takes advantage of
knowing the logging methods in advance.
Use it like::
structlog.configure(
wrapper_class=structlog.stdlib.BoundLogger,
)
It also contains a bunch of properties that pass-through to the wrapped
`logging.Logger` which should make it work as a drop-in replacement.
.. versionadded:: 23.1.0
Async variants `alog()`, `adebug()`, `ainfo()`, and so forth.
.. versionchanged:: 24.2.0
Callsite parameters are now also collected by
`structlog.processors.CallsiteParameterAdder` for async log methods.
logging.Logger_loggerc $ > [ TU ] " S0 UD6$ )zC
Return a new logger with *new_values* added to the existing ones.
r9 )superbindrN
new_values __class__s rB rg BoundLogger.bind s w|)j))rC c > [ TU ] " U6 $ )zy
Return a new logger with *keys* removed from the context.
Raises:
KeyError: If the key is not part of the context.
)rf unbindrN keysrj s rB rm BoundLogger.unbind s w~t$$rC c > [ TU ] " U6 $ )z[
Like :meth:`unbind`, but best effort: missing keys are ignored.
.. versionadded:: 18.2.0
)rf
try_unbindrn s rB rr BoundLogger.try_unbind s w!4((rC c $ > [ TU ] " S0 UD6$ )z
Clear context and binds *initial_values* using `bind`.
Only necessary with dict implementations that keep global state like
those wrapped by `structlog.threadlocal.wrap_dict` when threads
are reused.
r9 )rf newrh s rB ru BoundLogger.new s w{(Z((rC c 0 U R " SU/UQ70 UD6$ )z@
Process event and call `logging.Logger.debug` with the result.
debug_proxy_to_loggerrN eventargsrA s rB rx BoundLogger.debug ! $$WeAdAbAArC c 0 U R " SU/UQ70 UD6$ )z?
Process event and call `logging.Logger.info` with the result.
infory r{ s rB r BoundLogger.info s! $$VU@T@R@@rC c 0 U R " SU/UQ70 UD6$ )zB
Process event and call `logging.Logger.warning` with the result.
warningry r{ s rB r BoundLogger.warning s! $$YCCCCrC c 0 U R " SU/UQ70 UD6$ )z@
Process event and call `logging.Logger.error` with the result.
errorry r{ s rB r BoundLogger.error r rC c 0 U R " SU/UQ70 UD6$ zC
Process event and call `logging.Logger.critical` with the result.
criticalry r{ s rB r BoundLogger.critical ! $$ZDDDDrC c 0 U R " SU/UQ70 UD6$ r ry r{ s rB fatalBoundLogger.fatal r rC c T UR SS5 U R " SU/UQ70 UD6$ )z
Process event and call `logging.Logger.exception` with the result,
after setting ``exc_info`` to `True` if it's not already set.
exc_infoT exception)
setdefaultrz r{ s rB r BoundLogger.exception s/
j$'$$[%E$E"EErC c > U R " [ U U/UQ70 UD6$ )zO
Process *event* and call the appropriate logging method depending on
*level*.
)rz r rN r3 r| r} rA s rB logBoundLogger.log s& $$]5%95N4N2NNrC c @ > U( a X4S' [ TU ] " U4SU0UD6$ )z
Propagate a method call to the wrapped logger.
This is the same as the superclass implementation, except that
it also preserves positional arguments in the ``event_dict`` so
that the stdlib's support for format strings can be used.
positional_argsr| )rf rz )rN method_namer|
event_argsevent_kwrj s rB rz BoundLogger._proxy_to_logger
s+ *4& 'w' M5MHMMrC c . U R R $ )z%
Returns :attr:`logging.Logger.name`
)rd namerN s rB r BoundLogger.name# s
|| rC c . U R R $ )z&
Returns :attr:`logging.Logger.level`
)rd r3 r s rB r3 BoundLogger.level* s
||!!!rC c . U R R $ )z'
Returns :attr:`logging.Logger.parent`
)rd parentr s rB r BoundLogger.parent1 s
||"""rC c . U R R $ )z*
Returns :attr:`logging.Logger.propagate`
)rd propagater s rB r BoundLogger.propagate8 s
||%%%rC c . U R R $ )z)
Returns :attr:`logging.Logger.handlers`
)rd handlersr s rB r BoundLogger.handlers?
||$$$rC c . U R R $ )z)
Returns :attr:`logging.Logger.disabled`
)rd disabledr s rB r BoundLogger.disabledF r rC c : U R R U5 g)zB
Calls :meth:`logging.Logger.setLevel` with unmodified arguments.
N)rd setLevelrN r3 s rB r BoundLogger.setLevelM s
e$rC c 4 U R R XS9$ )zD
Calls :meth:`logging.Logger.findCaller` with unmodified arguments.
)rO rH )rd rT )rN rO rH s rB rT BoundLogger.findCallerS s# ||&&! '
rC c
< U R R XX4XVXxU S9 $ )zD
Calls :meth:`logging.Logger.makeRecord` with unmodified arguments.
)funcextra)rd
makeRecord)
rN r r3 fnlnomsgr} r r r s
rB r BoundLogger.makeRecord_ s+ ||&& #X '
rC c : U R R U5 g)z@
Calls :meth:`logging.Logger.handle` with unmodified arguments.
N)rd handlerN records rB r BoundLogger.handler s
F#rC c : U R R U5 g)zD
Calls :meth:`logging.Logger.addHandler` with unmodified arguments.
N)rd
addHandlerrN hdlrs rB r BoundLogger.addHandlerx s
%rC c : U R R U5 g)zG
Calls :meth:`logging.Logger.removeHandler` with unmodified arguments.
N)rd
removeHandlerr s rB r BoundLogger.removeHandler~ s
""4(rC c 6 U R R 5 $ )z_
Calls :meth:`logging.Logger.hasHandlers` with unmodified arguments.
Exists only in Python 3.
)rd hasHandlersr s rB r BoundLogger.hasHandlers s ||''))rC c : U R R U5 g)zF
Calls :meth:`logging.Logger.callHandlers` with unmodified arguments.
N)rd callHandlersr s rB r BoundLogger.callHandlers s
!!&)rC c 6 U R R 5 $ )zK
Calls :meth:`logging.Logger.getEffectiveLevel` with unmodified
arguments.
rd getEffectiveLevelr s rB r BoundLogger.getEffectiveLevel s
||--//rC c 8 U R R U5 $ )zF
Calls :meth:`logging.Logger.isEnabledFor` with unmodified arguments.
rd isEnabledForr s rB r BoundLogger.isEnabledFor s ||((//rC c 8 U R R U5 $ )aZ
A snake_case alias of `isEnabledFor` for compatibility with
`structlog.typing.FilteringBoundLogger`.
.. note::
This method is more complex than the native `is_enabled_for` since
it supports standard library-only features like
:attr:`logging.Logger.disabled` while the native one only compares
log levels.
.. versionadded:: 26.1.0
r r s rB is_enabled_forBoundLogger.is_enabled_for s ||((//rC c 6 U R R 5 $ )z
A snake_case alias of `getEffectiveLevel` for compatibility with
`structlog.typing.FilteringBoundLogger`.
.. versionadded:: 26.1.0
r r s rB get_effective_level BoundLogger.get_effective_level s ||--//rC c 8 U R R U5 $ )zB
Calls :meth:`logging.Logger.getChild` with unmodified arguments.
)rd getChild)rN suffixs rB r BoundLogger.getChild s ||$$V,,rC c t ^^^^^# [ R " [ R " 5 [ R " 5 R
45 n[ R " [ R " 5 R R 5 n[ R " 5 m [ R " 5 R SUUUUU4S j5 I Sh vN [ R " U5 [ R " U5 g N1! [ R " U5 [ R " U5 f = f7f)C
Merge contextvars and log using the sync logger in a thread pool.
Nc 4 > TR U UUU4S j5 $ )Nc > T" T/T Q70 TD6$ Nr9 r} r| rA meths rB ABoundLogger._dispatch_to_sync.... U(@T(@R(@rC runr} ctxr| rA r s rB r /BoundLogger._dispatch_to_sync.. @ArC )r set threading get_identcurrent_threadr r r< _getframef_back contextvars copy_contextasyncioget_running_looprun_in_executorresetrN r r| r} rA thread_token scs_tokenr s ```` @rB _dispatch_to_sync BoundLogger._dispatch_to_sync s -00
"I$<$<$>$C$C D
),,S]]_-C-C-J-JK &&( 6**,<<AA
! & &y 1 ! ' ' 5
! & &y 1 ! ' ' 5s0 BD8#0D DD -D8D .D55D8c Z # U R U R XU5 I Sh vN g N7f)zY
Log using `debug()`, but asynchronously in a separate thread.
.. versionadded:: 23.1.0
N)r rx r{ s rB adebugBoundLogger.adebug # $$TZZbAAA !+)+c Z # U R U R XU5 I Sh vN g N7f)zX
Log using `info()`, but asynchronously in a separate thread.
.. versionadded:: 23.1.0
N)r r r{ s rB ainfoBoundLogger.ainfo s# $$TYYR@@@r c Z # U R U R XU5 I Sh vN g N7f)z[
Log using `warning()`, but asynchronously in a separate thread.
.. versionadded:: 23.1.0
N)r r r{ s rB awarningBoundLogger.awarning s# $$T\\5CCCr c Z # U R U R XU5 I Sh vN g N7f)zY
Log using `error()`, but asynchronously in a separate thread.
.. versionadded:: 23.1.0
N)r r r{ s rB aerrorBoundLogger.aerror r
r c Z # U R U R XU5 I Sh vN g N7fz\
Log using `critical()`, but asynchronously in a separate thread.
.. versionadded:: 23.1.0
Nr r r{ s rB acriticalBoundLogger.acritical # $$T]]EDDDr c Z # U R U R XU5 I Sh vN g N7fr r r{ s rB afatalBoundLogger.afatal r r c # UR SS5 SL a* UR S5 c [ R " 5 US' U R U R XU5 I Sh vN g N7f)z]
Log using `exception()`, but asynchronously in a separate thread.
.. versionadded:: 23.1.0
r Tr N)getr< r r r r{ s rB
aexceptionBoundLogger.aexception sS 66*d #t +{0C0K \\^BzN$$T^^U"EEEs A A*"A(#A*c n # U R [ U R U5 X#U5 I Sh vN g N7f)zW
Log using `log()`, but asynchronously in a separate thread.
.. versionadded:: 23.1.0
N)r r r r s rB alogBoundLogger.alog s* $$WTXXu%=uBOOO +535r9 ri r rZ r
ro strrZ r
r )r|
str | Noner} r rA r rZ r )
r3 rY r| r) r} r rA r rZ r )
r r( r| r) r r( r r rZ r )rZ r( )rZ rY )rZ r )rZ rX )r3 rY rZ NonerV rW )NN)r r( r3 rY r r( r rY r r( r} tuple[Any, ...]r r r r) r r rZ logging.LogRecord)r r, rZ r* )r zlogging.HandlerrZ r* )r3 rY rZ rX )r r( rZ rc
r zCallable[..., Any]r| r( r} r+ rA zdict[str, Any]rZ r* r| r( r} r rA r rZ r*
r3 r r| r( r} r rA r rZ r* )3r[ r\ r] r^ r_ __annotations__rg rm rr ru rx r r warnr r r r r rz propertyr r3 r r r r r rT r r r r r r r r r r r r r r
r r r r r r# r`
__classcell__rj s @rB r! r! s . * %))B A D DB E E #'F F/2F:=F F /3OO!+O;>OFIO O !NN N N
N
N N, ! ! " " # # & & % % % % % ;<
47
)
*
&$ & ) ** 00 0 0-6 6 6 6
6
64BADBEE FPP!$P-0P8;P
P PrC r! c . [ R " U 0 UD6$ )a
Only calls `structlog.get_logger`, but has the correct type hints.
.. warning::
Does **not** check whether -- or ensure that -- you've configured
*structlog* for standard library :mod:`logging`!
See :doc:`standard-library` for details.
.. versionadded:: 20.2.0
)r r) )r} initial_valuess rB r) r) ! s t 6~ 66rC c
\ rS rSr% SrSrS\S' Sr\r SSS. SS jjr
\ SS j5 r SS
jr
SS jrSS jrSS
jr S S jrS S jrS S jrS S jrS S jrS S jrS S jrS S jrS S jrS S jrSrg) AsyncBoundLoggeri1 a
Wraps a `BoundLogger` & exposes its logging methods as ``async`` versions.
This approach has turned out to be a mistake and the class has been
deprecated in 23.1.0. Use the regular `BoundLogger` with its a-prefixed
methods instead.
.. versionadded:: 20.2.0
.. versionchanged:: 20.2.0 fix _dispatch_to_sync contextvars usage
.. deprecated:: 23.1.0
Use the regular `BoundLogger` with its a-prefixed methods instead.
.. versionchanged:: 23.3.0
Callsite parameters are now also collected for async log methods.
)_loopsync_blr! r: N)_sync_blr9 c U( a
X@l XPl g U R XUS9U l [ R " 5 U l g )N)loggerr6 context)r: r9 _bound_logger_factoryr r )rN r= r6 r> r; r9 s rB __init__AsyncBoundLogger.__init__J sB #L J 11' 2
--/
rC c . U R R $ r )r: _contextr s rB rC AsyncBoundLogger._contexta s ||$$$rC c
p U R S S0 U R R " S0 UD6U R S9$ Nr9 )r= r6 r> r; r9 )rj r: rg r9 rN ri s rB rg AsyncBoundLogger.binde s? ~~ \\&&44**
rC c
p U R S S0 U R R " S0 UD6U R S9$ rF )rj r: ru r9 rG s rB ru AsyncBoundLogger.newq s= ~~\\%%3
3**
rC c j U R S S0 U R R " U6 U R S9$ rF )rj r: rm r9 rN ro s rB rm AsyncBoundLogger.unbind{ s: ~~\\(($/**
rC c j U R S S0 U R R " U6 U R S9$ rF )rj r: rr r9 rL s rB rr AsyncBoundLogger.try_unbind s: ~~\\,,d3**
rC c ^^^^^# [ R " [ R " 5 [ R " 5 R
45 n[ R " [ R " 5 R R 5 n[ R " 5 m [ R " 5 R U R UUUUU4S j5 I Sh vN [ R " U5 [ R " U5 g N1! [ R " U5 [ R " U5 f = f7f)r c 4 > TR U UUU4S j5 $ )Nc > T" T/T Q70 TD6$ r r9 r s rB r FAsyncBoundLogger._dispatch_to_sync.... r rC r r s rB r 4AsyncBoundLogger._dispatch_to_sync.. r rC N)r r r r r r r r< r r r r r r r _executorr r s ```` @rB r "AsyncBoundLogger._dispatch_to_sync s -00
"I$<$<$>$C$C D
),,S]]_-C-C-J-JK &&( 6**,<<AA
! & &y 1 ! ' ' 5
! & &y 1 ! ' ' 5s0 BE#:D D D "-ED .D??Ec n # U R U R R XU5 I S h vN g N7fr )r r: rx r{ s rB rx AsyncBoundLogger.debug ' $$T\\%7%7bIIIr% c n # U R U R R XU5 I S h vN g N7fr )r r: r r{ s rB r AsyncBoundLogger.info s' $$T\\%6%6RHHHr% c n # U R U R R XU5 I S h vN g N7fr r r: r r{ s rB r AsyncBoundLogger.warning ' $$T\\%9%95KKKr% c n # U R U R R XU5 I S h vN g N7fr r] r{ s rB r1 AsyncBoundLogger.warn r_ r% c n # U R U R R XU5 I S h vN g N7fr )r r: r r{ s rB r AsyncBoundLogger.error rY r% c n # U R U R R XU5 I S h vN g N7fr r r: r r{ s rB r AsyncBoundLogger.critical ' $$T\\%:%:ELLLr% c n # U R U R R XU5 I S h vN g N7fr re r{ s rB r AsyncBoundLogger.fatal rg r% c # UR SS 5 nUc' UR S5 c [ R " 5 nXCS' U R U R
R XU5 I S h vN g N7f)Nr r )popr r< r r r: r )rN r| r} rA eis rB r AsyncBoundLogger.exception s^ VVJ
%
:"&&-5 B:$$T\\%;%;U"MMMs A+A5-A3.A5c # U R [ U R R U5 X#U5 I S h vN g N7fr )r r r: r r s rB r AsyncBoundLogger.log s5 $$ DLL$$e ,e2
s 5?=?)
r= rc r6 zIterable[Processor]r> r r; r r9 r )rZ r r& r' r- r. r/ ) r[ r\ r] r^ r_ __slots__r0 rU r! r? r@ r2 rC rg ru rm rr r rx r r r1 r r r r r r` r9 rC rB r8 r8 1 s
%I I ' 0 0 (0 0 0 0. % %
6 6 6 6
6
64JILLJMM N
rC r8 c 0 \ rS rSrSrSSS jjrS S jrSrg)
r# i a
Build a standard library logger when an *instance* is called.
Sets a custom logger using :func:`logging.setLoggerClass` so variables in
log format are expanded properly.
>>> from structlog import configure
>>> from structlog.stdlib import LoggerFactory
>>> configure(logger_factory=LoggerFactory())
Args:
ignore_frame_names:
When guessing the name of a logger, skip frames whose names *start*
with one of these. For example, in pyramid applications you'll
want to set it to ``["venusian", "pyramid.config"]``. This argument
is called *additional_ignores* in other APIs throughout
*structlog*.
Nc D Xl [ R " [ 5 g r )_ignorer: setLoggerClassrE )rN ignore_frame_namess rB r@ LoggerFactory.__init__ s ) 56rC c U( a [ R " US 5 $ [ U R 5 u p#[ R " U5 $ )a
Deduce the caller's module name and create a stdlib logger.
If an optional argument is passed, it will be used as the logger name
instead of guesswork. This optional argument would be passed from the
:func:`structlog.get_logger` call. For example
``structlog.get_logger("foo")`` would cause this method to be called
with ``"foo"`` as its first positional argument.
.. versionchanged:: 0.4.0
Added support for optional positional arguments. Using the first
one for naming the constructed logger.
r )r: getLoggerr rs )rN r} _r s rB __call__LoggerFactory.__call__ s? $$T!W- - 1 > &&rC )rs r )ru zlist[str] | None)r} r rZ rc r[ r\ r] r^ r_ r@ rz r` r9 rC rB r# r# s &7'rC r# c @ \ rS rSrSrSSS jjr S S jrSrg)
r$ i a
Apply stdlib-like string formatting to the ``event`` key.
If the ``positional_args`` key in the event dict is set, it must
contain a tuple that is used for formatting (using the ``%s`` string
formatting operator) of the value from the ``event`` key. This works
in the same way as the stdlib handles arguments to the various log
methods: if the tuple contains only a single `dict` argument it is
used for keyword placeholders in the ``event`` string, otherwise it
will be used for positional placeholders.
``positional_args`` is populated by `structlog.stdlib.BoundLogger` or
can be set manually.
The *remove_positional_args* flag can be set to `False` to keep the
``positional_args`` key in the event dict; by default it will be
removed from the event dict after formatting a message.
c Xl g r remove_positional_args)rN r s rB r@ %PositionalArgumentsFormatter.__init__ s &<#rC c UR S5 nU( aC [ U5 S:X a' [ US [ 5 ( a US ( a US nUS== U- ss' U R ( a Ub US U$ )Nr r r r| )r len
isinstancedictr )rN ry __
event_dictr} s rB rz %PositionalArgumentsFormatter.__call__ so ~~ /0 4yA~*T!Wd";";QAw w 4 ' & &4+;,-rC r N)T)r rX rZ r* ry r r r( r r rZ r r| r9 rC rB r$ r$ s1 &= $'5> rC r$ c j U R ( d [ U U R 5 : a U$ [ e)a
Check whether logging is configured to accept messages from this log level.
Should be the first processor if stdlib's filtering by level is used so
possibly expensive processors like exception formatters are avoided in the
first place.
>>> import logging
>>> from structlog.stdlib import filter_by_level
>>> logging.basicConfig(level=logging.WARN)
>>> logger = logging.getLogger()
>>> filter_by_level(logger, 'warn', {})
{}
>>> filter_by_level(logger, 'debug', {})
Traceback (most recent call last):
...
DropEvent
)r r r r r= r r s rB r( r( + s, 0
OO + &&*B*B*D D
OrC c [ U US' U$ )a
Add the log level number to the event dict.
Log level numbers map to the log level names. The Python stdlib uses them
for filtering logic. This adds the same numbers so users can leverage
similar filtering. Compare::
level in ("warning", "error", "critical")
level_number >= 30
The mapping of names to numbers is in
``structlog.stdlib._log_levels._NAME_TO_LEVEL``.
.. versionadded:: 18.2.0
level_number)r r s rB r& r& K s $ "/{!;J~ rC c n UR S5 nUc U R US' U$ UR US' U$ )z(
Add the logger name to the event dict.
_recordr= )r r )r= r r r s rB r' r' b sC ^^I
&F
~ %{{
8 &{{
8 rC r pathnamer r9 c \ rS rSrSrSrS S
S jjr S S jr\ S S j5 r \ S
S j5 r
Sr g)r" iu aP
Add 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.
Args:
allow:
An optional collection of attributes that, if present in
`logging.LogRecord` objects, will be copied to event dictionaries.
If ``allow`` is None all attributes of `logging.LogRecord` objects
that do not exist on a standard `logging.LogRecord` object will be
copied to event dictionaries.
.. versionadded:: 21.5.0
)_copierNc U Ub) [ R " U R / UQ5 U l g U R U l g r ) functoolsr
_copy_allowedr _copy_all)rN allows rB r@ ExtraAdder.__init__ s6 %,,T-?-?5JDL >>DLrC c P UR S5 nUb U R X45 U$ )Nr )r r )rN r= r r r s rB rz ExtraAdder.__call__ s* ,6>>)+D LL ,rC c j UR R 5 H u p4U[ ; d M XAU' M g r )__dict__items_LOG_RECORD_KEYS)clsr r keyvalues rB r ExtraAdder._copy_all s- !////1JC**"'3 2rC c Z U H% nXCR ; d M UR U X$' M' g r )r )r r r r r s rB r ExtraAdder._copy_allowed s( Coo%"(//#"6
rC r )r zCollection[str] | NonerZ r* )r= rc r r( r r rZ r )r r r r, rZ r* )r zCollection[str]r r r r, rZ r* ) r[ r\ r] r^ r_ rp r@ rz classmethodr r r` r9 rC rB r" r" u s & I*$,/=F ("(,=(
( ( 7 7 7 " 7
7 7rC r" )r rO rH c UR S5 /UR SS5 Q7n[ Vs0 sH nXB; d M
XBR U5 _M nnU( a X%S' X54$ s snf )a
Render ``event_dict`` into positional and keyword arguments for
`logging.Logger` logging methods.
See `logging.Logger.debug` method for keyword arguments reference.
The ``event`` field is passed in the first positional argument, positional
arguments from ``positional_args`` field are passed in subsequent positional
arguments, keyword arguments are extracted from the *event_dict* and the
rest of the *event_dict* is added as ``extra``.
This allows you to defer formatting to `logging`.
.. versionadded:: 25.1.0
r| r r9 r rk LOG_KWARG_NAMES)ry r r r}
kwarg_namekwargss rB r+ r+ su "
NN7 # Ljnn5F&K LD *)J # /
NN:..)
$w <s
A A c UR S5 US.[ Vs0 sH nX2; d M
X2R U5 _M snE$ s snf )aW
Render ``event_dict`` into keyword arguments for `logging.Logger` logging
methods.
See `logging.Logger.debug` method for keyword arguments reference.
The ``event`` field is translated into ``msg``, keyword arguments are
extracted from the *event_dict* and the rest of the *event_dict* is added as
``extra``.
This allows you to defer formatting to `logging`.
.. versionadded:: 17.1.0
.. versionchanged:: 22.1.0
``exc_info``, ``stack_info``, and ``stacklevel`` are passed as proper
kwargs and not put into ``extra``.
.. versionchanged:: 24.2.0
``stackLevel`` corrected to ``stacklevel``.
r| )r r r )ry r r rA s rB r, r, sX , ~~g&
&
%
#Br" "%
s
AAc ^ \ rS rSrSr S S U 4S jjjrS
U 4S jjr\ S S j5 r\ S S j5 r Sr
U =r $ )
r% i a
Call *structlog* processors on `logging.LogRecord`\s.
This is an implementation of a `logging.Formatter` that can be used to
format log entries from both *structlog* and `logging`.
Its static method `wrap_for_formatter` must be the final processor in
*structlog*'s processor chain.
Please refer to :ref:`processor-formatter` for examples.
Args:
foreign_pre_chain:
If not `None`, it is used as a processor chain that is applied to
**non**-*structlog* log entries before the event dictionary is
passed to *processors*. (default: `None`)
processors:
A chain of *structlog* processors that is used to process **all**
log entries. The last one must render to a `str` which then gets
passed on to `logging` for output.
Compared to *structlog*'s regular processor chains, there's a few
differences:
- The event dictionary contains two additional keys:
#. ``_record``: a `logging.LogRecord` that either was created
using `logging` APIs, **or** is a wrapped *structlog* log
entry created by `wrap_for_formatter`.
#. ``_from_structlog``: a `bool` that indicates whether or not
``_record`` was created by a *structlog* logger.
Since you most likely don't want ``_record`` and
``_from_structlog`` in your log files, we've added the static
method `remove_processors_meta` to ``ProcessorFormatter`` that
you can add just before your renderer.
- Since this is a `logging` *formatter*, raising
`structlog.DropEvent` will crash your application.
keep_exc_info:
``exc_info`` on `logging.LogRecord`\ s is added to the
``event_dict`` and removed afterwards. Set this to ``True`` to keep
it on the `logging.LogRecord`. (default: False)
keep_stack_info:
Same as *keep_exc_info* except for ``stack_info``. (default: False)
logger:
Logger which we want to push through the *structlog* processor
chain. This parameter is necessary for some of the processors like
`filter_by_level`. (default: None)
pass_foreign_args:
If True, pass a foreign log record's ``args`` attribute to the
``event_dict`` under ``positional_args`` key. (default: False)
processor:
A single *structlog* processor used for rendering the event
dictionary before passing it off to `logging`. Must return a `str`.
The event dictionary does **not** contain ``_record`` and
``_from_structlog``.
This parameter exists for historic reasons. Please use *processors*
instead.
use_get_message:
If True, use ``record.getMessage`` to get a fully rendered log
message, otherwise use ``str(record.msg)``. (default: True)
Raises:
TypeError: If both or neither *processor* and *processors* are passed.
.. versionadded:: 17.1.0
.. versionadded:: 17.2.0 *keep_exc_info* and *keep_stack_info*
.. versionadded:: 19.2.0 *logger*
.. versionadded:: 19.2.0 *pass_foreign_args*
.. versionadded:: 21.3.0 *processors*
.. deprecated:: 21.3.0
*processor* (singular) in favor of *processors* (plural). Removal is not
planned.
.. versionadded:: 23.3.0 *use_get_message*
c 4 > U
R SS5 n [ T
U ] " U SU 0U
D6 U( a U( a
Sn [ U 5 eU Ub U R U4U l OU( a X l O
Sn [ U 5 eX0l X@l XPl X`l Xpl
Xl g )Nfmtr0 zBThe `processor` and `processors` arguments are mutually exclusive.z2Either `processor` or `processors` must be passed.) rk rf r@ TypeErrorremove_processors_metar6 foreign_pre_chain
keep_exc_infokeep_stack_infor= pass_foreign_argsuse_get_message)rN processorr6 r r r r= r r r} r r r rj s rB r@ ProcessorFormatter.__init__I s jj
.
$2C262
C. # : :I FDO
(OFCC. !2 * . !2 . rC c > [ R " UR 5 n[ US[ 5 n[ USS5 nU[ Lax US:w ar U R
b U R
n[
[ UR 5 n[
[ [ [ 4 UR 5 R 5 nXS' SUS' OU R
nUR R 5 nU R ( a UR! 5 O[ UR 5 USS .nU R" ( a UR$ US
' S Ul UR& ( a UR& US ' UR( ( a UR( US
' U R* =( d S H n[
[, U" X#U5 5 nM U R. ( d SUl SUl U R2 ( d SUl U R4 H nU" X#U5 nM [7 U[ 5 ( dG [8 R: " SU R4 S S[= U5 S3[> SS9 [
[ U5 nXAl [@ TU ] U5 $ )z
Extract *structlog*'s `event_dict` from ``record.msg`` and format it.
*record* has been patched by `wrap_for_formatter` first though, so the
type isn't quite right.
rd rR __structlog_sentinel__Nr T_from_structlogF)r| r r r r9 r rO zNThe last processor in ProcessorFormatter.processors must return a string, but r5 z returned a z instead.r )categoryrH )"r:
makeLogRecordr getattr _SENTINELr= r
r( rR r r r copy levelnamelowerr
getMessager r} r rO r r r exc_textr r6 r warningsr1 typeRuntimeWarningrf r1 )rN r r= meth_nameedprocprj s rB r1 ProcessorFormatter.formatp s &&v7I6FG-EF "y4L'L{{& S&,,/I
d38nfjj1668B "yM$(B ![[F ((..0I ++ %%' VZZ !#(B %%(. $% FK !' : #)#4#4< ..4"4)T&R%@A 5 !! "FO "FO## $F A6b)B ! "c"" MM((,(;'r s
#
D D w & " B D D
" ) " 29 .b
H IW^^ I