HEX

File: //opt/alt/python37/lib/python3.7/site-packages/sentry_sdk/__pycache__/serializer.cpython-37.pyc
B

Ta�?�@s�ddlZddlZddlmZddlmZmZmZmZmZm	Z	m
Z
ddlZddlm
Z
mZmZmZmZddlmZe�rBddlmZddlmZddlmZdd	lmZdd
lmZddlmZddlmZdd
lmZddlmZddlmZddlm Z ddlm!Z!m"Z"ee#efZ$eeee#efge e!e#ffZ%e e#e&fZ'e�rbddl(m)Z)m*Z*m+Z+eZ,nddl-m)Z)m*Z*m+Z+e#e.fZ,dZ/dZ0dZ1dZ2gZ3dd�Z4Gdd�de5�Z6ddd�Z7dS)�N)�datetime)�AnnotatedValue�capture_internal_exception�disable_capture_event�format_timestamp�
json_dumps�	safe_repr�strip_string)�	text_type�PY2�string_types�number_types�	iteritems)�MYPY)�	timedelta)�
TracebackType)�Any)�Callable)�ContextManager)�Dict)�List)�Optional)�Tuple)�Type)�Union)�NotImplementedType�Event)�Mapping�Sequence�Seti@B��
z<cyclic>cCst�|�dS)N)�global_repr_processors�append)�	processor�r%�F/opt/alt/python37/lib/python3.7/site-packages/sentry_sdk/serializer.py�add_global_repr_processorOsr'c@s0eZdZdZdd�Zdd�Zdd�Zdd	�Zd
S)�Memo)�_ids�_objscCsi|_g|_dS)N)r)r*)�selfr%r%r&�__init__Wsz
Memo.__init__cCs|j�|�|S)N)r*r#)r+�objr%r%r&�memoize\szMemo.memoizecCs2|jd}t|�|jkrdS||jt|�<dSdS)N���TF)r*�idr))r+r-r%r%r&�	__enter__as

zMemo.__enter__cCs|j�t|j���d�dS)N)r)�popr0r*)r+�ty�value�tbr%r%r&�__exit__jsz
Memo.__exit__N)�__name__�
__module__�__qualname__�	__slots__r,r.r1r6r%r%r%r&r(Ts
	r(Fc
	sTt��g�g�g�
��fdd���fdd����fdd��d����fdd�	��fd	d
����������	�
f	dd�����fd
d�}t�d�z��|f|�}�r�t|t�r��d|d<t�
�}�	�r@|dk�r@t|�d�p�g�}|tj	j
}||k�r@tt|��}|t}	|	dk�r@||||	���r@t|t��r@�d|d<|St�d�XdS)Ncs|x`t��t��kr`y(�t��d}�d�t|�i�}Wntk
rRi}YnX��|�qW�d�di��|�dS)N�r/�)�len�
setdefaultr
�
IndexErrorr#�update)�meta�segment�node)�
meta_stack�pathr%r&�	_annotate{s
zserialize.<locals>._annotatecs�yl�d}|dkr.�ddkr.�ddkr.dS|dkrj�dd	krj�ddkrj�d
dkrj�ddkrjdSWntk
r�dSXd
S)a�
        By default non-serializable objects are going through
        safe_repr(). For certain places in the event (local vars) we
        want to repr() even things that are JSON-serializable to
        make their type more apparent. For example, it's useful to
        see the difference between a unicode-string and a bytestring
        when viewing a stacktrace.

        For container-types we still don't do anything different.
        Generally we just try to make the Sentry UI present exactly
        what a pretty-printed repr would look like.

        :returns: `True` if we are somewhere in frame variables, and `False` if
            we are in a position where we will never encounter frame variables
            when recursing (for example, we're in `event.extra`). `None` if we
            are not (yet) in frame variables, but might encounter them when
            recursing (e.g.  we're in `event.exception`)
        rZ
stacktracer;�frames��varsT)�threads�	exception�values��NF)r?)�p0)rEr%r&�_should_repr_strings�s z'serialize.<locals>._should_repr_stringscs|yb��}|dkr|S�d}|dkr4�ddkr4dS|dkrT�ddkrT�d	dS|d
kr`dSWntk
rvdSXdS)
z�
        A databag is any value that we need to trim.

        :returns: Works like `_should_repr_strings()`. `True` for "yes",
            `False` for :"no", `None` for "maybe soon".
        )TNrZrequestr;�dataTZbreadcrumbsrL��extraNF)r?)�rvrO)rPrEr%r&�_is_databag�szserialize.<locals>._is_databagc	s�|dk	r��|�z^y0��|��}|r*tS�|||||d�SQRXWn(tk
rltt���|rhdSdSXWd|dk	r�����t��dd�=XdS)N)�
is_databag�should_repr_strings�remaining_depth�remaining_breadthz=<failed to serialize, use init(debug=True) to see error logs>r;)	r#r.�CYCLE_MARKER�
BaseExceptionr�sys�exc_infor2r=)r-rVrWrBrYrX�result)�_serialize_node_impl�memorDrEr%r&�_serialize_node�s(	

z"serialize.<locals>._serialize_nodecs t|t�r�f|j�|j}|S)N)�
isinstancer�metadatar4)r-)rFr%r&�_flatten_annotated�s
z%serialize.<locals>._flatten_annotatedcs�|dkr��}|dkr��}|r,|dkr,t}|r<|dkr<t}�|�}|dk	r||dkr|�ddggd�|rx�tt|���SdS|r�tr��|d�}x&tD]}|||�}|tk	r��|�Sq�W|dks�t|ttf��r|s�t|t	�r�t
�|�s�t
�|�r�t|�S|S�nPt|t
��r&|�stt|��St|�St|t��r�tt|��}i}d}	xxt|�D]l\}
}|dk	�r||	|k�r|�t|�d�Pt|
�}�|||||dk	�r�|dnd|d�}|||<|	d7}	�qPW|St|t��sPt|ttf��rPg}
xft|�D]Z\}	}|dk	�r|	|k�r�t|�d�P|
��||	|||dk	�r:|dnd|d���q�W|
S|�r`t|�}n,t|t��rx|�d	d
�}t|t��s�t|�}��r�t��dk�rΈddk�rΈd
dk�rΈ�t|��|S�t|��S)Nrz!limit�x)�rem)r`rX)r=r;)rBrWrVrXrYzutf-8�replacerH�spansr/�description)�MAX_DATABAG_DEPTH�MAX_DATABAG_BREADTHr	rr"�NotImplementedrb�boolr
�float�math�isinf�isnanrr
rr�dictrr=�serializable_str_typesrr�	enumerater#�bytes�decoder)r-rVrWrXrY�hintsr$r^Zrv_dict�i�k�vZstr_kZrv_list)	rFrdrUrarPr`rE�smart_transaction_trimming�span_description_bytesr%r&r_�s�




z'serialize.<locals>._serialize_node_implcs�d}�fdd�}��d�x�tt|�d�p,g�|d�D]|\}}|�d�pJd}t|�|krZq6|t|�|8}��|dg��t||d��|d<�d	d
�=�t��dd
�=|dkr6Pq6W����t��dd
�=d
S)
a�
        Modifies serialized_event in-place trying to remove excess_bytes from
        span descriptions. The original event is used read-only to access the
        span timestamps (represented as RFC3399-formatted strings in
        serialized_event).

        It uses heuristics to prioritize preserving the description of spans
        that might be the most interesting ones in terms of understanding and
        optimizing performance.
        r!c	s\|\}}�d|}t��}|�d�p(|}|�d�p6|}||}|�d�pLd}|t|�fS)NrhZstart_timestamp�	timestamprir<)r�utcnow�getr=)	�argsrxZserialized_span�span�now�start�endZdurationri)�eventr%r&�+shortest_duration_longest_description_first�szcserialize.<locals>._truncate_span_descriptions.<locals>.shortest_duration_longest_description_firstrh)�keyrir<)�
max_length���Nr;r)r#�sortedrtrr=�extendr	r2)Zserialized_eventr��excess_bytesZ
min_lengthr�rxr�ri)rdrDrE)r�r&�_truncate_span_descriptionsss&


z.serialize.<locals>._truncate_span_descriptionsTrZ_metarhF)NNNNN)
r(r�setrbrr�sumr=r�
sentry_sdk�utilsZMAX_STRING_LENGTHr�MAX_EVENT_BYTES)
r�r{�kwargsr�rTZsum_span_description_bytesZ
span_countZdescriptions_budget_bytes�original_bytesr�r%)rFrdrUrar_rPr`rDrEr{r|r&�	serializetsB
&}6


r�)F)8r\rorZsentry_sdk.utilsrrrrrrr	r�Zsentry_sdk._compatr
rrr
rZsentry_sdk._typesrr�typesr�typingrrrrrrrrrrr�strZSpanZ
ReprProcessor�intZSegment�collectionsrrrrs�collections.abcrur�rjrkrZr"r'�objectr(r�r%r%r%r&�<module>sF$