U


W[U'�@s
dZd
dl
Z
d
dlmZ
d
dlmZmZ
d
dlmZ
ddl	m
Z

ddlmZ
dd	l
mZ
dd
lmZ
d
dlmZmZ
d
dlmZ
e�Zd
d�Zdd�Zdd�Zdd�ed�
dd�dd�fdd�ed�
eefgZedd�eD�
�
Zdd�Zdd�Zd d!�Zd"d#�Z d*d%d&�
Z!d+d(d)�
Z"dS),zA
Tools for saving and loading log events in a structured format.
�N)
�
NamedConstant)�dumps�loads)
�UUID�
)
�flattenEvent�
�FileLogObserver)
�LogLevel)
�Logger)�unicode�_PY3)
�Failurec

Cs t|�
�t|jj|jjd
�d�S)a

    Convert a failure to a JSON-serializable data structure.

    @param failure: A failure to serialize.
    @type failure: L{Failure}

    @return: a mapping of strings to ... stuff, mostly reminiscent of
        L{Failure.__getstate__}
    @rtype: L{dict}
    )�
__module__�__name__)
�type)�dict�__getstate__rrr)
Zfailure�r�6/usr/lib/python3/dist-packages/twisted/logger/_json.py�
failureAsJSONs



��rc

CsPt|t
�rtt|�St|t�r4td
d�|��D�
�
St|t�rH|�d�
S|SdS)a�

    On Python 2, we really need native strings in a variety of places;
    attribute names will sort of work in a __dict__, but they're subtly wrong;
    however, printing tracebacks relies on I/O to containers that only support
    bytes.  This function converts _all_ native strings within a
    JSON-deserialized object to bytes.

    @param obj: An object to convert to bytes.
    @type obj: L{object}

    @return: A string of UTF-8 bytes.
    @rtype: L{bytes}
    c
ss"|]\}
}t|
�
t|�
fV
qdS�
N)
�asBytes)�.0�
k�
vrrr�	<genexpr>AszasBytes.<locals>.<genexpr>�utf-8N)�
isinstance�list�maprr�itemsr�encode)
�objrrrr0s









rc
CsZtt
d
d�}
|
dkr t�t
�
}n|
t
�
}ts4t|�
}|d}t|dd|�|d<||_|S)a#

    Load a L{Failure} from a dictionary deserialized from JSON.

    @param failureDict: a JSON-deserialized object like one previously returned
        by L{failureAsJSON}.
    @type failureDict: L{dict} mapping L{unicode} to attributes

    @return: L{Failure}
    @rtype: L{Failure}
    �__new__Nrrr)�getattrr�typesZInstanceTyper
rr�__dict__)ZfailureDictZ
newFailure�
fZtypeInforrr�failureFromJSONIs





r)c

Cst|t
�ott|jd�|kSr)rrr%r
�name�
�levelrrr�<lambda>is


r-z$02E59486-F24D-46AD-8224-3ACDF2A5732Ac

Cst|j
d
�
S)N)
r*)rr*r+rrrr-n�c

Cstt
|d
d�S)Nr*)r%r
r+rrrr-or.c

Cs
t|t
�Sr)rr)
�
orrrr-sr.z$E76887E2-20ED-49BF-A8F8-BA25CC586F2Dc
Csg|]\}
}}}||f�qSrr)r�	predicate�uuid�saver�loaderrrr�
<listcomp>{s

r4c

Cs d
|krtt
|d
�
|�
S|S)aR

    Dictionary-to-object-translation hook for certain value types used within
    the logging system.

    @see: the C{object_hook} parameter to L{json.load}

    @param aDict: A dictionary loaded from a JSON object.
    @type aDict: L{dict}

    @return: C{aDict} itself, or the object represented by C{aDict}
    @rtype: L{object}
    �__class_uuid__)�uuidToLoaderr)
ZaDictrrr�objectLoadHook�s


r7c
Cs>tD]0\}
}}}|
|�
r||�
}t
|�
|d
<|
Sqddi
S)a�

    Object-to-serializable hook for certain value types used within the logging
    system.

    @see: the C{default} parameter to L{json.dump}

    @param pythonObject: Any object.
    @type pythonObject: L{object}

    @return: If the object is one of the special types the logging system
        supports, a specially-formatted dictionary; otherwise, a marker
        dictionary indicating that it could not be serialized.
    r5Z
unpersistableT)�	classInfo�str)ZpythonObjectr0r1r2r3�resultrrr�objectSaveHook�s





r;c
CsZtt
krttd
dd�}
ndd�}t|dd�}
t|�

t|f
|
�
}t|t�sVt|dd�S|S)	a�

    Encode an event as JSON, flattening it if necessary to preserve as much
    structure as possible.

    Not all structure from the log event will be preserved when it is
    serialized.

    @param event: A log event dictionary.
    @type event: L{dict} with arbitrary keys and values

    @return: A string of the serialized JSON; note that this will contain no
        newline characters, and may thus safely be stored in a line-delimited
        file.
    @rtype: L{unicode}
    �charmapT)�default�encoding�skipkeysc

Sst|t
�r|�d
�
St|�
S)z�
            Serialize an object not otherwise serializable by L{dumps}.

            @param unencodable: An unencodable object.
            @return: C{unencodable}, serialized
            r<)r�bytes�decoder;)
Zunencodablerrrr=�s



zeventAsJSON.<locals>.default)r=r?r�replace)r@r9rr;rrrr)�event�kwr=r:rrr�eventAsJSON�s





rEc
Cst|t
d
�}
|
S)z�
    Decode a log event from JSON.

    @param eventText: The output of a previous call to L{eventAsJSON}
    @type eventText: L{unicode}

    @return: A reconstructed version of the log event.
    @rtype: L{dict}
    )
Zobject_hook)rr7)Z	eventTextZloadedrrr�
eventFromJSON�s

rF�
cst|�f
d
d��S)a;
    Create a L{FileLogObserver} that emits JSON-serialized events to a
    specified (writable) file-like object.

    Events are written in the following form::

        RS + JSON + NL

    C{JSON} is the serialized event, which is JSON text.  C{NL} is a newline
    (C{u"\n"}).  C{RS} is a record separator.  By default, this is a single
    RS character (C{u"\x1e"}), which makes the default output conform to the
    IETF draft document "draft-ietf-json-text-sequence-13".

    @param outFile: A file-like object.  Ideally one should be passed which
        accepts L{unicode} data.  Otherwise, UTF-8 L{bytes} will be used.
    @type outFile: L{io.IOBase}

    @param recordSeparator: The record separator to use.
    @type recordSeparator: L{unicode}

    @return: A file log observer.
    @rtype: L{FileLogObserver}
    c

sd
��t
|�
�S)Nz{0}{1}
)�formatrE)
rC�
�recordSeparatorrrr-�r.z%jsonFileLogObserver.<locals>.<lambda>r)ZoutFilerJrrIr�jsonFileLogObserver�s


�rK�c#s�d
d�}dd��|
dkr:||�d�
�
}|dkr4|}
qFd}
n||
�
}
d}|
dkrXd	}
�}n�f
d
d�}t
|�
}|�|�
}|s�t|�
dkr�||�
}|dk	r�|V
q�|||�
7}|�|
�
}	|	dd
�D]&}
t|
�
dkr�||
�
}|dk	r�|V
q�|	d
}qldS)a�
    Load events from a file previously saved with L{jsonFileLogObserver}.
    Event records that are truncated or otherwise unreadable are ignored.

    @param inFile: A (readable) file-like object.  Data read from C{inFile}
        should be L{unicode} or UTF-8 L{bytes}.
    @type inFile: iterable of lines

    @param recordSeparator: The expected record separator.
        If L{None}, attempt to automatically detect the record separator from
        one of C{u"\x1e"} or C{u""}.
    @type recordSeparator: L{unicode}

    @param bufferSize: The size of the read buffer used while reading from
        C{inFile}.
    @type bufferSize: integer

    @return: Log events as read from C{inFile}.
    @rtype: iterable of L{dict}
    c

Sst|�
t
kr|S|�d
�
SdS)Nr)rr@r")
�
srrrr
s

z&eventsFromJSONLogFile.<locals>.asBytesc
Sstzt|�
�
d
�
}
Wn(tk
r:


tjdt|�
d�
YdSXz
t|
�
WStk
rn


tjdt|�
d�
YdSXdS)Nrz2Unable to decode UTF-8 for JSON record: {record!r}�
�recordz&Unable to read JSON record: {record!r})r@rA�UnicodeDecodeError�log�errorrF�
ValueError)rO�textrrr�eventFromBytearray
s 





�





�z1eventsFromJSONLogFile.<locals>.eventFromBytearrayNr�
r.�

c

s.|d
td�
kr�|�
St
jdt|�
d�
dS)N����

z0Unable to read truncated JSON record: {record!r}rN)�ordrQrRr@rN�
rUrr�eventFromRecordD
s



�z.eventsFromJSONLogFile.<locals>.eventFromRecordr
rX)�read�	bytearray�len�split)ZinFilerJZ
bufferSizer�firstr\�bufferZnewDatarCZrecordsrOrr[r�eventsFromJSONLogFile

s:















rc)
rG)NrL)#�__doc__r&Z
constantlyrZjsonrrr1rZ_flattenrZ_filer	Z_levelsr
Z_loggerrZtwisted.python.compatrr
Ztwisted.python.failurerrQrrr)r8rr6r7r;rErFrKrcrrrr�<module>sD





 

�

��
�(