o
    h                  
   @   s  d dl Z d dlZd dlmZmZ d dlZd dlmZ d dlmZm	Z	m
Z
 d dlmZmZmZ d dlmZ d dlmZ erd dlZd dlmZ d d	lmZ d d
lmZ d dlmZ d dlmZ d dlmZ d dlmZ d dlmZ d dlmZ d dlmZ d dlmZ edZedZ d dl!Zd dlm"Z"m#Z#m$Z$ dZ%dZ&dZ'dZ(dZ)dZ*dZ+dZ,e(gZ-e+e+e+e)e(e+e)e)e)d	Z.G dd  d e/Z0G d!d" d"e/Z1G d#d$ d$e1Z2G d%d& d&e1Z3ered-d'd(Z4ed)d( Z4d-d*d(Z4d d+l5m6Z6m7Z7m8Z8m9Z9m:Z: d d,l;m<Z< dS ).    N)datetime	timedelta)INSTRUMENTER)is_valid_sample_rateloggernanosecond_time)datetime_utcnowutc_from_timestampPY2)SPANDATA)TYPE_CHECKING)Callable)Any)Dict)Iterator)List)Optional)overload)	ParamSpec)Tuple)Union)TypeVarPR)EventMeasurementUnitSamplingContextbaggagezsentry-tracecustomurlrouteview	componenttask)	endpointfunction_namehandler_namemethod_and_path_patternpath
route_nameroute_patternuri_templater   c                   @   s$   e Zd ZdZdZdd Zdd ZdS )_SpanRecorderz5Limits the number of spans recorded in a transaction.maxlenspansc                 C   s   |d | _ g | _d S )N   r-   selfr.    r3   U/var/www/html/aiguide_backend/venv/lib/python3.10/site-packages/sentry_sdk/tracing.py__init__H   s   

z_SpanRecorder.__init__c                 C   s*   t | j| jkrd |_d S | j| d S N)lenr/   r.   _span_recorderappend)r2   spanr3   r3   r4   addR   s   
z_SpanRecorder.addN)__name__
__module____qualname____doc__	__slots__r5   r;   r3   r3   r3   r4   r,   C   s
    
r,   c                   @   s  e Zd ZdZdZdd Z												d5ddZd	d
 Zdd Zdd Z	dd Z
dd Zedd ZejfddZdd Zedd Zedd Zdd Zedd  Zd!d" Zd#d$ Zd%d& Zd'd( Zd)d* Zd+d, Zd-d. Zd6d/d0Zd1d2 Zd3d4 Z dS )7SpanzuA span holds timing information of a block of code.
    Spans can have multiple child spans thus forming a span tree.)trace_idspan_idparent_span_idsame_process_as_parentsampledopdescriptionstart_timestamp_start_timestamp_monotonic_nsstatus	timestamp_tags_datar8   hub_context_manager_state_containing_transaction_local_aggregatorc                 K   s   d|v r	t tS t | S )z_
        Backwards-compatible implementation of Span and Transaction
        creation.
        transaction)object__new__Transaction)clskwargsr3   r3   r4   rU   s   s   


zSpan.__new__NTc                 C   s   |pt  j| _|pt  jdd  | _|| _|| _|| _|| _|| _	|	| _
|| _i | _i | _|| _|d u r:t }n	t|trCt|}|| _zt | _W n	 tyU   Y nw d | _d | _d | _d S )N   )uuiduuid4hexrB   rC   rD   rE   rF   rG   rH   rK   rO   rM   rN   rQ   r   
isinstancefloatr	   rI   r   rJ   AttributeErrorrL   r8   rR   )r2   rB   rC   rD   rE   rF   rG   rH   rO   rK   rS   containing_transactionrI   r3   r3   r4   r5      s2   

zSpan.__init__c                 C   s   | j d u rt|| _ d S d S r6   )r8   r,   r1   r3   r3   r4   init_span_recorder   s   
zSpan.init_span_recorderc                 C   s   | j }|d u rt  }| _ |S r6   )rR   LocalAggregatorr2   rvr3   r3   r4   _get_local_aggregator   s   zSpan._get_local_aggregatorc                 C   s&   d| j j| j| j| j| j| j| jf S )NzS<%s(op=%r, description:%r, trace_id=%r, span_id=%r, parent_span_id=%r, sampled=%r)>)	__class__r<   rG   rH   rB   rC   rD   rF   r2   r3   r3   r4   __repr__   s   zSpan.__repr__c                 C   s8   | j ptjj}|jd \}}|j}| |_|||f| _| S )N)rO   
sentry_sdkHubcurrent_stackr:   rP   )r2   rO   _scopeold_spanr3   r3   r4   	__enter__   s   zSpan.__enter__c                 C   s6   |d ur	|  d | j\}}}| `| | ||_d S )Ninternal_error)
set_statusrP   finishr:   )r2   tyvaluetbrO   ro   rp   r3   r3   r4   __exit__   s   


zSpan.__exit__c                 C   s   | j S )zThe ``Transaction`` that this span belongs to.
        The ``Transaction`` is the root of the span tree,
        so one could also think of this ``Transaction`` as the "root span".)rQ   rg   r3   r3   r4   r`      s   
zSpan.containing_transactionc                 K   sz   | j ptjj}|j}|o|jd }||krt S |d| j t	d| j
| j| jd|}| jo3| jj}|r;|| |S )a  
        Start a sub-span from the current span or transaction.

        Takes the same arguments as the initializer of :py:class:`Span`. The
        trace id, sampling decision, transaction pointer, and span recorder are
        inherited from the current span/transaction.
        instrumenterrF   )rB   rD   r`   Nr3   )rO   rj   rk   rl   clientoptionsNoOpSpan
setdefaultrF   rA   rB   rC   r`   r8   r;   )r2   ry   rX   rO   rz   configuration_instrumenterchildspan_recorderr3   r3   r4   start_child   s$   	
zSpan.start_childc                 K   s   t d | jdi |S )zGDEPRECATED: use :py:meth:`sentry_sdk.tracing.Span.start_child` instead.z^Deprecated: use Span.start_child instead of Span.new_span. This will be removed in the future.Nr3   )r   warningr   r2   rX   r3   r3   r4   new_span  s   zSpan.new_spanc                 K   s(   | t u r	td tjt|fi |S )a(  
        Create a Transaction with the given params, then add in data pulled from
        the ``sentry-trace`` and ``baggage`` headers from the environ (if any)
        before returning the Transaction.

        This is different from :py:meth:`~sentry_sdk.tracing.Span.continue_from_headers`
        in that it assumes header names in the form ``HTTP_HEADER_NAME`` -
        such as you would get from a WSGI/ASGI environ -
        rather than the form ``header-name``.

        :param environ: The ASGI/WSGI environ to pull information from.
        zXDeprecated: use Transaction.continue_from_environ instead of Span.continue_from_environ.)rA   r   r   rV   continue_from_headersEnvironHeaders)rW   environrX   r3   r3   r4   continue_from_environ  s
   zSpan.continue_from_environc                 K   sp   | t u r	td t|t}|t|i t|t	}|dur,|| |
  tdi |}d|_|S )z
        Create a transaction with the given params (including any data pulled from
        the ``sentry-trace`` and ``baggage`` headers).

        :param headers: The dictionary with the HTTP headers to pull information from.
        zXDeprecated: use Transaction.continue_from_headers instead of Span.continue_from_headers.NFr3   )rA   r   r   Baggagefrom_incoming_headergetBAGGAGE_HEADER_NAMEupdateextract_sentrytrace_dataSENTRY_TRACE_HEADER_NAMEfreezerV   rE   )rW   headersrX   r   sentrytrace_kwargsrS   r3   r3   r4   r   0  s   
zSpan.continue_from_headersc                 c   s>    t |  fV  | jr| j  }|rt|fV  dS dS dS )z
        Creates a generator which returns the span's ``sentry-trace`` and ``baggage`` headers.
        If the span's containing transaction doesn't yet have a ``baggage`` value,
        this will cause one to be generated and stored.
        N)r   to_traceparentr`   get_baggage	serializer   )r2   r   r3   r3   r4   iter_headersZ  s   zSpan.iter_headersc                 K   s(   t d |s	dS | jt|ifi |S )a  
        DEPRECATED: Use :py:meth:`sentry_sdk.tracing.Span.continue_from_headers`.

        Create a ``Transaction`` with the given params, then add in data pulled from
        the given ``sentry-trace`` header value before returning the ``Transaction``.
        zwDeprecated: Use Transaction.continue_from_headers(headers, **kwargs) instead of from_traceparent(traceparent, **kwargs)N)r   r   r   r   )rW   traceparentrX   r3   r3   r4   from_traceparenth  s   zSpan.from_traceparentc                 C   sN   | j du rd}n
| j du rd}nd }d| j| jf }|d ur%|d|f 7 }|S )NT1F0z%s-%sz-%s)rF   rB   rC   )r2   rF   r   r3   r3   r4   r     s   

zSpan.to_traceparentc                 C   s   | j r| j  S dS )zReturns the :py:class:`~sentry_sdk.tracing_utils.Baggage`
        associated with this ``Span``, if any. (Taken from the root of the span tree.)
        N)r`   r   rg   r3   r3   r4   
to_baggage  s   
zSpan.to_baggagec                 C      || j |< d S r6   )rM   r2   keyrv   r3   r3   r4   set_tag     zSpan.set_tagc                 C   r   r6   )rN   r   r3   r3   r4   set_data  r   zSpan.set_datac                 C   s
   || _ d S r6   rK   r2   rv   r3   r3   r4   rs        
zSpan.set_statusc                 C   sT  |  dt| | tj| |dk r| d d S d|  kr$dk ron nI|dkr1| d d S |dkr<| d d S |d	krG| d
 d S |dkrR| d d S |dkr]| d d S |dkrh| d d S | d d S d|  krydk rn n(|dkr| d d S |dkr| d d S |dkr| d d S | d d S | d d S )Nzhttp.status_codei  oki  i  permission_deniedi  	not_foundi  resource_exhaustedi  failed_preconditioni  unauthenticatedi  already_existsinvalid_argumentiX  i  deadline_exceededi  unimplementedi  unavailablerr   unknown_error)r   strr   r   HTTP_STATUS_CODErs   r2   http_statusr3   r3   r4   set_http_status  s:   zSpan.set_http_statusc                 C   s
   | j dkS )Nr   r   rg   r3   r3   r4   
is_success  r   zSpan.is_successc                 C   s   | j durdS |p| jptjj}z"|r t|trt|}|| _ nt | j	 }| j
t|d d | _ W n ty?   t | _ Y nw t||  dS )a4  Sets the end timestamp of the span.
        Additionally it also creates a breadcrumb from the span,
        if the span represents a database or HTTP request.

        :param hub: The hub to use for this transaction.
            If not provided, the current hub will be used.
        :param end_timestamp: Optional timestamp that should
            be used as timestamp instead of the current time.

        :return: Always ``None``. The type is ``Optional[str]`` to match
            the return value of :py:meth:`sentry_sdk.tracing.Transaction.finish`.
        Ni  )microseconds)rL   rO   rj   rk   rl   r]   r^   r	   r   rJ   rI   r   r_   r   "maybe_create_breadcrumbs_from_span)r2   rO   end_timestampelapsedr3   r3   r4   rt     s$   



zSpan.finishc              	   C   s   | j | j| j| j| j| j| j| jd}| jr| j| j	d< | j
dur,| j
 }|r,||d< | j	}|r5||d< | j}|r>||d< |S )z5Returns a JSON-compatible representation of the span.)rB   rC   rD   rE   rG   rH   rI   rL   rK   N_metrics_summarytagsdata)rB   rC   rD   rE   rG   rH   rI   rL   rK   rM   rR   to_jsonrN   )r2   rd   metrics_summaryr   r   r3   r3   r4   r     s,   

zSpan.to_jsonc                 C   sF   | j | j| j| j| jd}| jr| j|d< | jr!| j  |d< |S )N)rB   rC   rD   rG   rH   rK   dynamic_sampling_context)	rB   rC   rD   rG   rH   rK   r`   r   r   rc   r3   r3   r4   get_trace_context  s   
zSpan.get_trace_context)NNNTNNNNNNNNNN)!r<   r=   r>   r?   r@   rU   r5   ra   re   rh   rq   rx   propertyr`   r   SENTRYr   r   classmethodr   r   r   r   r   r   r   r   rs   r   r   rt   r   r   r3   r3   r3   r4   rA   Z   sV    
0

!

)
	$
(!rA   c                       s   e Zd ZdZdZdddef fdd	Zdd Z fd	d
Z fddZ	e
dd Zd fdd	ZdddZdd Z fddZ fddZdd Zdd Z  ZS )rV   zhThe Transaction is the root element that holds all the spans
    for Sentry performance instrumentation.)namesourceparent_sampledsample_rate_measurements	_contexts_profile_baggage Nc                    sj   |sd|v rt d |d}tt| jdi | || _|| _d| _|| _	i | _
i | _d| _|| _dS )a  Constructs a new Transaction.

        :param name: Identifier of the transaction.
            Will show up in the Sentry UI.
        :param parent_sampled: Whether the parent transaction was sampled.
            If True this transaction will be kept, if False it will be discarded.
        :param baggage: The W3C baggage header value.
            (see https://www.w3.org/TR/baggage/)
        :param source: A string describing the source of the transaction name.
            This will be used to determine the transaction's type.
            See https://develop.sentry.dev/sdk/event-payloads/transaction/#transaction-annotations
            for more information. Default "custom".
        rS   z^Deprecated: use Transaction(name=...) to create transactions instead of Span(transaction=...).Nr3   )r   r   popsuperrV   r5   r   r   r   r   r   r   r   r   )r2   r   r   r   r   rX   rf   r3   r4   r5   :  s   

zTransaction.__init__c              	   C   s*   d| j j| j| j| j| j| j| j| jf S )NzW<%s(name=%r, op=%r, trace_id=%r, span_id=%r, parent_span_id=%r, sampled=%r, source=%r)>)	rf   r<   r   rG   rB   rC   rD   rF   r   rg   r3   r3   r4   rh   e  s   zTransaction.__repr__c                    s&   t t|   | jd ur| j  | S r6   )r   rV   rq   r   rg   r   r3   r4   rq   u  s   

zTransaction.__enter__c                    s2   | j d ur| j ||| tt| ||| d S r6   )r   rx   r   rV   )r2   ru   rv   rw   r   r3   r4   rx   ~  s   
zTransaction.__exit__c                 C   s   | S )znThe root element of the span tree.
        In the case of a transaction it is the transaction itself.
        r3   rg   r3   r3   r4   r`     s   
z"Transaction.containing_transactionc           	   	      s  | j durdS |p| jptjj}|j}|du rdS | jdu rCtd |j	rAt
|jrA|jr7|jjdkr7d}nd}|j	j|dd dS | jsNtd d	| _tt| || | jsf| jdu rdtd
 dS dd | jjD }d| _i }|| j |d|  i d| jd| ji|| j| j | j|d}| jdur| j r| j|d< d| _| j|d< | jdur| j  }|r||d< |!|S )a  Finishes the transaction and sends it to Sentry.
        All finished spans in the transaction will also be sent to Sentry.

        :param hub: The hub to use for this transaction.
            If not provided, the current hub will be used.
        :param end_timestamp: Optional timestamp that should
            be used as timestamp instead of the current time.

        :return: The event ID if the transaction was sent to Sentry,
            otherwise None.
        Nz.Discarding transaction because sampled = Falser   backpressurer   rS   )data_categoryzCTransaction has no name, falling back to `<unlabeled transaction>`.z<unlabeled transaction>z1Discarding transaction without sampling decision.c                 S   s   g | ]}|j d ur| qS r6   )rL   r   ).0r:   r3   r3   r4   
<listcomp>  s
    
z&Transaction.finish.<locals>.<listcomp>tracer   )typerS   transaction_infocontextsr   rL   rI   r/   profilemeasurementsr   )"rL   rO   rj   rk   rl   rz   r8   r   debug	transporthas_tracing_enabledr{   monitordownsample_factorrecord_lost_eventr   r   r   rV   rt   rF   r/   r   r   r   r   rM   rI   r   validr   rR   r   capture_event)	r2   rO   r   rz   reasonfinished_spansr   eventr   r   r3   r4   rt     sb   










zTransaction.finishc                 C   s   ||d| j |< d S )N)rv   unit)r   r2   r   rv   r   r3   r3   r4   set_measurement  s   zTransaction.set_measurementc                 C   s   || j |< dS )a  Sets a context. Transactions can have multiple contexts
        and they should follow the format described in the "Contexts Interface"
        documentation.

        :param key: The name of the context.
        :param value: The information about the context.
        N)r   r   r3   r3   r4   set_context  s   	zTransaction.set_contextc                    s$   t t| | | dd|i dS )zySets the status of the Transaction according to the given HTTP status.

        :param http_status: The HTTP status code.responsestatus_codeN)r   rV   r   r   r   r   r3   r4   r     s   zTransaction.set_http_statusc                    s0   t t|  }| j|d< | j|d< | j|d< |S )z<Returns a JSON-compatible representation of the transaction.r   r   rF   )r   rV   r   r   r   rF   rc   r   r3   r4   r     s
   


zTransaction.to_jsonc                 C   s    | j r| j jrt| | _ | j S )zReturns the :py:class:`~sentry_sdk.tracing_utils.Baggage`
        associated with the Transaction.

        The first time a new baggage with Sentry items is made,
        it will be frozen.)r   mutabler   populate_from_transactionrg   r3   r3   r4   r     s   zTransaction.get_baggagec                 C   sv  | j ptjj}|j}|r|jpi }dj| jrd| j d nd| jd}|r)t	|s.d| _
dS | j
dur;t| j
| _dS t|drH|d |n|d	 durR|d	 n|d
 }t|ddsjtdj|d d| _
dS t|| _|jr}|  jd|jj   _| jstdj|t|drdndd d| _
dS t | jk | _
| j
rtdj|d dS tdj|| jd dS )aO  
        Sets the transaction's sampling decision, according to the following
        precedence rules:

        1. If a sampling decision is passed to `start_transaction`
        (`start_transaction(name: "my transaction", sampled: True)`), that
        decision will be used, regardless of anything else

        2. If `traces_sampler` is defined, its decision will be used. It can
        choose to keep or ignore any parent sampling decision, or use the
        sampling context data to make its own decision or to choose a sample
        rate for the transaction.

        3. If `traces_sampler` is not defined, but there's a parent sampling
        decision, the parent sampling decision will be used.

        4. If `traces_sampler` is not defined and there's no parent sampling
        decision, `traces_sample_rate` will be used.
        z{op}transaction <{name}><z> r   )rG   r   FNtraces_samplerr   traces_sample_rateTracing)r   zN[Tracing] Discarding {transaction_description} because of invalid sample rate.)transaction_description   z?[Tracing] Discarding {transaction_description} because {reason}z"traces_sampler returned 0 or Falseztraces_sample_rate is set to 0)r   r   z,[Tracing] Starting {transaction_description}z}[Tracing] Discarding {transaction_description} because it's not included in the random sample (sampling rate = {sample_rate}))r   r   )rO   rj   rk   rl   rz   r{   formatrG   r   r   rF   r^   r   callabler   r   r   r   r   r   r   random)r2   sampling_contextrO   rz   r{   r   r   r3   r3   r4   _set_initial_sampling_decision#  sj   


z*Transaction._set_initial_sampling_decisionr   r   )r<   r=   r>   r?   r@   TRANSACTION_SOURCE_CUSTOMr5   rh   rq   rx   r   r`   rt   r   r   r   r   r   r   __classcell__r3   r3   r   r4   rV   *  s(    +	

crV   c                   @   s   e Zd Zdd Zedd ZejfddZdd Z	d	d
 Z
dd Zdd Zdd Zdd Zdd Zdd Zdd Zdd Zdd Zdd Zd+d d!Zd,d#d$Zd%d& Zd'd( Zd)d* ZdS )-r|   c                 C   s   | j jS r6   )rf   r<   rg   r3   r3   r4   rh        zNoOpSpan.__repr__c                 C      d S r6   r3   rg   r3   r3   r4   r`        zNoOpSpan.containing_transactionc                 K   s   t  S r6   )r|   )r2   ry   rX   r3   r3   r4   r     s   zNoOpSpan.start_childc                 K   s   | j di |S Nr3   )r   r   r3   r3   r4   r     s   zNoOpSpan.new_spanc                 C      dS )Nr   r3   rg   r3   r3   r4   r        zNoOpSpan.to_traceparentc                 C   r   r6   r3   rg   r3   r3   r4   r     r  zNoOpSpan.to_baggagec                 C   r   r6   r3   rg   r3   r3   r4   r     r  zNoOpSpan.get_baggagec                 C   s   t dS r   )iterrg   r3   r3   r4   r     r   zNoOpSpan.iter_headersc                 C   r   r6   r3   r   r3   r3   r4   r     r  zNoOpSpan.set_tagc                 C   r   r6   r3   r   r3   r3   r4   r     r  zNoOpSpan.set_datac                 C   r   r6   r3   r   r3   r3   r4   rs     r  zNoOpSpan.set_statusc                 C   r   r6   r3   r   r3   r3   r4   r     r  zNoOpSpan.set_http_statusc                 C   r  )NTr3   rg   r3   r3   r4   r     r  zNoOpSpan.is_successc                 C      i S r6   r3   rg   r3   r3   r4   r     r  zNoOpSpan.to_jsonc                 C   r  r6   r3   rg   r3   r3   r4   r     r  zNoOpSpan.get_trace_contextNc                 C   r   r6   r3   )r2   rO   r   r3   r3   r4   rt     r  zNoOpSpan.finishr   c                 C   r   r6   r3   r   r3   r3   r4   r     r  zNoOpSpan.set_measurementc                 C   r   r6   r3   r   r3   r3   r4   r     r  zNoOpSpan.set_contextc                 C   r   r6   r3   r1   r3   r3   r4   ra     r  zNoOpSpan.init_span_recorderc                 C   r   r6   r3   )r2   r   r3   r3   r4   r     r  z'NoOpSpan._set_initial_sampling_decisionr   r   )r<   r=   r>   rh   r   r`   r   r   r   r   r   r   r   r   r   r   rs   r   r   r   r   rt   r   r   ra   r   r3   r3   r3   r4   r|     s,    


r|   c                 C   r   r6   r3   funcr3   r3   r4   r     r   r   c                 C   r   r6   r3   r  r3   r3   r4   r     r   c                 C   s.   t r	ddlm} nddlm} | r|| S |S )av  
    Decorator to start a child span under the existing current transaction.
    If there is no current transaction, then nothing will be traced.

    .. code-block::
        :caption: Usage

        import sentry_sdk

        @sentry_sdk.trace
        def my_function():
            ...

        @sentry_sdk.trace
        async def my_async_function():
            ...
    r   )start_child_span_decorator)r
   sentry_sdk.tracing_utils_py2r  sentry_sdk.tracing_utils_py3)r  r  r3   r3   r4   r     s   )r   r   r   r   r   )rb   r6   )=rZ   r   r   r   rj   sentry_sdk.constsr   sentry_sdk.utilsr   r   r   sentry_sdk._compatr   r	   r
   r   sentry_sdk._typesr   typingcollections.abcr   r   r   r   r   r   r   r   r   r   r   r   r   sentry_sdk.profilerr   r   r   r   r   r   TRANSACTION_SOURCE_URLTRANSACTION_SOURCE_ROUTETRANSACTION_SOURCE_VIEWTRANSACTION_SOURCE_COMPONENTTRANSACTION_SOURCE_TASKLOW_QUALITY_TRANSACTION_SOURCESSOURCE_FOR_STYLErT   r,   rA   rV   r|   r   sentry_sdk.tracing_utilsr   r   r   r   r   sentry_sdk.metricsrb   r3   r3   r3   r4   <module>   s~       S  fS

"