U

�
b�&�@s|dZd
dl
m
Z

d
dlmZmZmZ
d
dlmZ
d
dlm	Z	
ddl
mZmZ
ddl
mZmZ
Gd	d
�d
�Ze�Zdd�Zd
S)z
Logger class.
�)
�time)�Any�Optional�cast)
�currentframe)
�Failure�
)�ILogObserver�LogTrace)�InvalidLogLevelError�LogLevelc@s
eZ
dZd
Zeed�
dd��
Zd eeeeeddd�dd	�Z	d!eee
dd
�dd�Zed�
d
d�Zd"e
eeedd�dd�Zde
jfeeee
edd�dd�Zd#eeedd�dd�Zd$eeedd�dd�Zd%eeedd�dd�Zd&eeedd�dd�Zd'eeedd�dd�ZdS)(�Loggera~

    A L{Logger} emits log messages to an observer.  You should instantiate it
    as a class or module attribute, as documented in L{this module's
    documentation <twisted.logger>}.

    @ivar namespace: the namespace for this logger
    @ivar source: The object which is emitting events via this logger
    @ivar observer: The observer that this logger will send events to.
    )
�returncCs2ztt
td
�
jd�WStk
r,


YdSXdS)z�
        Derive a namespace from the module containing the caller's caller.

        @return: the fully qualified python name of a module.
        ��__name__z	<unknown>N)r�strr�	f_globals�KeyError�rr�8/usr/lib/python3/dist-packages/twisted/logger/_logger.py�_namespaceFromCallingContexts


z#Logger._namespaceFromCallingContextNr	)�	namespace�source�observerrcCsB|
d
kr|��}
|
|_
||_|d
kr8ddlm}
||_n||_d
S)a3
        @param namespace: The namespace for this logger.  Uses a dotted
            notation, as used by python modules.  If not L{None}, then the name
            of the module of the caller is used.
        @param source: The object which is emitting events via this
            logger; this is automatically set on instances of a class
            if this L{Logger} is an attribute of that class.
        @param observer: The observer that this logger will send events to.
            If L{None}, use the L{global log publisher <globalLogPublisher>}.
        Nr)
�globalLogPublisher)rrr�_globalrr)�selfrrrrrrr�__init__)s


zLogger.__init__)�instance�ownerrcCs>|d
k	st�
|
d
kr|}n|
}|j
d�|j|jg�
||jd�S)a�
        When used as a descriptor, i.e.::

            # File: athing.py
            class Something:
                log = Logger()
                def hello(self):
                    self.log.info("Hello")

        a L{Logger}'s namespace will be set to the name of the class it is
        declared on.  In the above example, the namespace would be
        C{athing.Something}.

        Additionally, its source will be set to the actual object referring to
        the L{Logger}.  In the above example, C{Something.log.source} would be
        C{Something}, and C{Something().log.source} would be an instance of
        C{Something}.
        N�
.)
r)�AssertionError�	__class__�join�
__module__rr)rrrrrrr�__get__Fs



�zLogger.__get__c

Csd
|jj
�d|j�d�S)N�
<�
 �
>)r"rr)
rrrr�__repr__fs
zLogger.__repr__)�level�format�kwargsrcKsz|
t�
�kr*|jd
tt|
�
�
|
|d�
dS|}|j||
|j|j|t�d�
d|krlt	t
|d��||jf�

|�|�

dS)a
        Emit a log event to all log observers at the given level.

        @param level: a L{LogLevel}
        @param format: a message format using new-style (PEP 3101)
            formatting.  The logging event (which is a L{dict}) is
            used to render this format string.
        @param kwargs: additional key/value pairs to include in the event.
            Note that values which are later mutated may result in
            non-deterministic behavior from observers that schedule work for
            later execution.
        z:Got invalid log level {invalidLevel!r} in {logger}.emit().)ZinvalidLevel�loggerN)Z
log_logger�	log_level�
log_namespaceZ
log_source�
log_format�log_timeZ	log_trace)
r�
iterconstants�failurerr�updaterrrrr
�appendr)rr*r+r,�eventrrr�emitis(





�






�	
zLogger.emit)r+r3r*r,rcKs*|d
krt�}|j
||
fd|i
|��

d
S)a2
        Log a failure and emit a traceback.

        For example::

            try:
                frob(knob)
            except Exception:
                log.failure("While frobbing {knob}", knob=knob)

        or::

            d = deferredFrob(knob)
            d.addErrback(lambda f: log.failure("While frobbing {knob}",
                                               f, knob=knob))

        This method is generally meant to capture unexpected exceptions in
        code; an exception that is caught and handled somehow should be logged,
        if appropriate, via L{Logger.error} instead.  If some unknown exception
        occurs and your code doesn't know how to handle it, as in the above
        example, then this method provides a means to describe the failure in
        nerd-speak.  This is done at L{LogLevel.critical} by default, since no
        corrective guidance can be offered to an user/administrator, and the
        impact of the condition is unknown.

        @param format: a message format using new-style (PEP 3101) formatting.
            The logging event (which is a L{dict}) is used to render this
            format string.
        @param failure: a L{Failure} to log.  If L{None}, a L{Failure} is
            created from the exception in flight.
        @param level: a L{LogLevel} to use.
        @param kwargs: additional key/value pairs to include in the event.
            Note that values which are later mutated may result in
            non-deterministic behavior from observers that schedule work for
            later execution.
        N�log_failure)rr7)rr+r3r*r,rrrr3�s+
zLogger.failure)r+r,rcKs|jt
j|
f|�

d
S)a�

        Emit a log event at log level L{LogLevel.debug}.

        @param format: a message format using new-style (PEP 3101) formatting.
            The logging event (which is a L{dict}) is used to render this
            format string.

        @param kwargs: additional key/value pairs to include in the event.
            Note that values which are later mutated may result in
            non-deterministic behavior from observers that schedule work for
            later execution.
        N)r7r�debug�rr+r,rrrr9�s
zLogger.debugcKs|jt
j|
f|�

d
S)a�

        Emit a log event at log level L{LogLevel.info}.

        @param format: a message format using new-style (PEP 3101) formatting.
            The logging event (which is a L{dict}) is used to render this
            format string.

        @param kwargs: additional key/value pairs to include in the event.
            Note that values which are later mutated may result in
            non-deterministic behavior from observers that schedule work for
            later execution.
        N)r7r�infor:rrrr;�s
zLogger.infocKs|jt
j|
f|�

d
S)a�

        Emit a log event at log level L{LogLevel.warn}.

        @param format: a message format using new-style (PEP 3101) formatting.
            The logging event (which is a L{dict}) is used to render this
            format string.

        @param kwargs: additional key/value pairs to include in the event.
            Note that values which are later mutated may result in
            non-deterministic behavior from observers that schedule work for
            later execution.
        N)r7r�warnr:rrrr<�s
zLogger.warncKs|jt
j|
f|�

d
S)a�

        Emit a log event at log level L{LogLevel.error}.

        @param format: a message format using new-style (PEP 3101) formatting.
            The logging event (which is a L{dict}) is used to render this
            format string.

        @param kwargs: additional key/value pairs to include in the event.
            Note that values which are later mutated may result in
            non-deterministic behavior from observers that schedule work for
            later execution.
        N)r7r�errorr:rrrr=�s
zLogger.errorcKs|jt
j|
f|�

d
S)a�

        Emit a log event at log level L{LogLevel.critical}.

        @param format: a message format using new-style (PEP 3101) formatting.
            The logging event (which is a L{dict}) is used to render this
            format string.

        @param kwargs: additional key/value pairs to include in the event.
            Note that values which are later mutated may result in
            non-deterministic behavior from observers that schedule work for
            later execution.
        N)r7r�criticalr:rrrr>�s
zLogger.critical)NNN)
N)
N)
N)
N)
N)
N)
N)rr$�__qualname__�__doc__�staticmethodrrr�objectr�typer%r)rr7r>rr3r9r;r<r=rrrrr
sF





�


� �

�*
�



�0r
c

Cst�
||j�S)
N)�_logr%r")
�objrrr�<lambda>

�rFN)r@r�typingrrr�twisted.python.compatr�twisted.python.failurer�_interfacesr	r
�_levelsrrr
rD�
_loggerForrrrr�<module>s



{