"hk' x d Z ddlmZ ddlZddlZddlmZmZmZm Z ddl
m Z ddl m
Z
ddlmZmZ ddlmZ d d
lmZ d d lmZ d d lmZ d d
lmZmZ G d de Z G d d Z e e
fZ d dZ G d d Z! G d de Z ee G d d Z" ee G d d Z#d dZ$ G d d Z%y) z
Processors and tools specific to the `Twisted `_
networking engine.
See also :doc:`structlog's Twisted support `.
) annotationsN)AnyCallableSequenceTextIOlog)Failure) ILogObservertextFromEventDict) implementer )BoundLoggerBase)_BUILTIN_DEFAULT_PROCESSORS) JSONRenderer) EventDict
WrappedLoggerc $ e Zd ZdZdddZdddZy) BoundLoggera
Twisted-specific 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::
configure(
wrapper_class=structlog.twisted.BoundLogger,
)
Nc * | j d|fi |S )zG
Process event and call ``log.msg()`` with the result.
msg_proxy_to_loggerselfeventkws N/var/www/html/sandstorm/venv/lib/python3.12/site-packages/structlog/twisted.pyr zBoundLogger.msg. %t$$UE8R88 c * | j d|fi |S )zG
Process event and call ``log.err()`` with the result.
errr r s r r" zBoundLogger.err4 r r N)r z
str | Noner r returnr )__name__
__module__ __qualname____doc__r r" r r r r s 9 9r r c e Zd ZdZddZy)
LoggerFactoryz
Build a Twisted logger when an *instance* is called.
>>> from structlog import configure
>>> from structlog.twisted import LoggerFactory
>>> configure(logger_factory=LoggerFactory())
c t S )z
Positional arguments are silently ignored.
:rvalue: A new Twisted logger.
.. versionchanged:: 0.4.0
Added support for optional positional arguments.
r )r argss r __call__zLoggerFactory.__call__D s
r N)r- r r$ r r% r& r' r( r. r) r r r+ r+ ; s r r+ c | j dd }| j dd }| j dd }t |t rt |t r t d |rt |t r t d t |t st |t r|xs d}|}t |t r|}|s!t j dk7 r
t }t |t rt |t s t | }||| fS ) z
Removes all possible *_why*s and *_stuff*s, analyzes exc_info and returns
a tuple of ``(_stuff, _why, eventDict)``.
**Modifies** *eventDict*!
_stuffN_whyr z3Both _stuff and event contain an Exception/Failure.z!Both `_why` and `event` supplied.error)NNN) pop
isinstance _FAIL_TYPES
ValueErrorstrsysexc_infor
BaseException) eventDictr1 r2 r s r _extractStuffAndWhyr= S s ]]8T
*F == &D MM'4 (E&+&:e[+INOO
5#&<== fk *z%/Mw% clln(:: &-(FG1L 4 ""r c ( e Zd ZdZddZddZddZy) ReprWrappera
Wrap a string and return it as the ``__repr__``.
This is needed for ``twisted.python.log.err`` that calls `repr` on
``_stuff``:
>>> repr("foo")
"'foo'"
>>> repr(ReprWrapper("foo"))
'foo'
Note the extra quotes in the unwrapped example.
c || _ y r# string)r rB s r __init__zReprWrapper.__init__ s r c d t || j xr | j |j k( S )z5
Check for equality, just for tests.
)r5 __class__rB )r others r __eq__zReprWrapper.__eq__ s)
udnn - M$++ 2M
r c | j S r# rA )r s r __repr__zReprWrapper.__repr__ s {{r N)rB r8 r$ None)rF objectr$ bool)r$ r8 )r% r& r' r( rC rG rI r) r r r? r? x s
r r? c ( e Zd ZdZ ddZy)r a
Behaves like `structlog.processors.JSONRenderer` except that it formats
tracebacks and failures itself if called with ``err()``.
.. note::
This ultimately means that the messages get logged out using ``msg()``,
and *not* ``err()`` which renders failures in separate lines.
Therefore it will break your tests that contain assertions using
`flushLoggedErrors
`_.
*Not* an adapter like `EventAdapter` but a real formatter. Also does *not*
require to be adapted using it.
Use together with a `JSONLogObserverWrapper`-wrapped Twisted logger like
`plainJSONStdOutLogger` for pure-JSON logs.
c t | \ }}}|dk( r;||d< t |t r+|j d |d< |j n||d< t t
j | ||| fddifS )Nr" r verbose)detail exception
_structlogT)r= r5 r
getTraceback cleanFailurer? GenericJSONRendererr. r loggernamer< r1 r2 s r r. zJSONRenderer.__call__ s #6i"@ i 5=!%Ig &'*)/)<)`_
.. versionadded:: 0.2.0
c || _ y r# ) _observer)r observers r rC z JSONLogObserverWrapper.__init__ s !r c d|vr9t j t | |j d d f|d< d|d< | j | S )NrR system)r rk messageT)jsondumpsr getrh rc s r r. z JSONLogObserverWrapper.__call__ s[ y (
!2 %" #,--"9 $Ii '+Il #~~i((r N)ri r r$ rJ )r< r r$ r8 rd r) r r rf rf s ")r rf c F t t t j S )a
Return a logger that writes only the message to stdout.
Transforms non-`JSONRenderer` messages to JSON.
Ideal for JSONifying log entries from Twisted plugins and libraries that
are outside of your control::
$ twistd -n --logger structlog.twisted.plainJSONStdOutLogger web
{"event": "Log opened.", "system": "-"}
{"event": "twistd 13.1.0 (python 2.7.3) starting up.", "system": "-"}
{"event": "reactor class: twisted...EPollReactor.", "system": "-"}
{"event": "Site starting on 8080", "system": "-"}
{"event": "Starting factory ", ...}
...
Composes `PlainFileLogObserver` and `JSONLogObserverWrapper` to a usable
logger.
.. versionadded:: 0.2.0
)rf rZ r9 stdoutr) r r plainJSONStdOutLoggerrr s , ""6szz"B CCr c : e Zd ZdZ d ddZ ddZy) EventAdapterar
Adapt an ``event_dict`` to Twisted logging system.
Particularly, make a wrapped `twisted.python.log.err
`_
behave as expected.
Args:
dictRenderer:
Renderer that is used for the actual log message. Please note that
structlog comes with a dedicated `JSONRenderer`.
**Must** be the last processor in the chain and requires a *dictRenderer*
for the actual formatting as an constructor argument in order to be able to
fully support the original behaviors of ``log.msg()`` and ``log.err()``.
Nc ( |xs t d | _ y )N)r
_dictRenderer)r dictRenderers r rC zEventAdapter.__init__. s * L-H-Lr c |dk( r,t | \ }}}||d< d|| j ||| dfS | j ||| S )Nr" r r) )r1 r2 )r= rw rV s r r. zEventAdapter.__call__6 sh 5=
':)&D #FD)!%Ig $ . .vtY G
!!&$ ::r r# )rx z5Callable[[WrappedLogger, str, EventDict], str] | Noner$ rJ )rW r rX r8 r< r r$ r rd r) r r rt rt sN *
M
BM
M;#;+.;;D; ;r rt )r< r r$ ztuple[Any, Any, EventDict])r$ rf )&r(
__future__r rm r9 typingr r r r twisted.pythonr twisted.python.failurer
twisted.python.logr r zope.interfacer
_baser _configr
processorsr rU r r r r+ r; r6 r= r? rZ rf rr rt r) r r r s #
2 2 * > & " 0 ; ,9/ 98 * g& "#J <-
& -
`
\ 2
\ ) ) )DD2-; -;r