YfD `ddlZddlZddlmZmZmZddlZddlmZmZddl m Z m Z m Z m Z ddlmZerddlmZmZmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlm Z m!Z!edZ"edZ#ddl$Zddlm%Z%m&Z&m'Z'm(Z(Gdde dZ)Gdde)dZ*dZ+dZ,dZ-dZ.dZ/d Z0d!Z1d"Z2e.gZ3e1e1e1e/e.e1e/e/e/d# Z4Gd$d%Z5Gd&d'Z6Gd(d)e6Z7Gd*d+e6Z8ered1d,Z9ed-Z9d1d.Z9dd/l:m;Z;mZ>m?Z?dd0l@mAZAy)2N)datetime timedeltatimezone) INSTRUMENTERSPANDATA)get_current_thread_metais_valid_sample_rateloggernanosecond_time) TYPE_CHECKING)CallableMappingMutableMapping)Any)Dict)Iterator)List)Optional)overload) ParamSpec)Tuple)Union)TypeVar) TypedDictUnpackPR)EventMeasurementUnitSamplingContextMeasurementValueceZdZUeed< eed< eed< eed< eed< eed< eed< eded < eed < ed ed < eeee fed < ded<y) SpanKwargstrace_idspan_idparent_span_idsame_process_as_parentsampledop descriptionzsentry_sdk.Hubhubstatus Transactioncontaining_transactionstart_timestampzsentry_sdk.ScopescopeN) __name__ __module__ __qualname__str__annotations__boolrrrfloatR/var/www/highfloat_scraper/venv/lib/python3.12/site-packages/sentry_sdk/tracing.pyr#r#)s   T< $$J   Q & ''s r ( 778!%%"899 "!Xr9r#F)totalc<eZdZUeed< eed< eed< ded<y)TransactionKwargsnamesourceparent_sampledBaggagebaggageN)r1r2r3r4r5r6r8r9r:r=r=Zs( K  Pr9r=rBz sentry-tracecustomurlrouteview componenttask) endpoint function_name handler_namemethod_and_path_patternpath route_name route_pattern uri_templaterDc eZdZdZdZdZdZy) _SpanRecorderz5Limits the number of spans recorded in a transaction.maxlenspansc&|dz |_g|_y)NrSselfrTs r:__init__z_SpanRecorder.__init__sqj  r9ct|j|jkDrd|_y|jj |yN)lenrUrT_span_recorderappend)rYspans r:addz_SpanRecorder.adds0 tzz?T[[ ("&D  JJ  d #r9N)r1r2r3__doc__ __slots__rZrar8r9r:rRrRs?#I$r9rRceZdZdZdZ ddZdZdZdZdZ d Z e d Z e jfd Zed Zed ZdZedZdZdZdZdZdZddZdZdZdZddZdZdZ y)SpanaA span holds timing information of a block of code. Spans can have multiple child spans thus forming a span tree. :param trace_id: The trace ID of the root span. If this new span is to be the root span, omit this parameter, and a new trace ID will be generated. :param span_id: The span ID of this span. If omitted, a new span ID will be generated. :param parent_span_id: The span ID of the parent span, if applicable. :param same_process_as_parent: Whether this span is in the same process as the parent span. :param sampled: Whether the span should be sampled. Overrides the default sampling decision for this span when provided. :param op: The span's operation. A list of recommended values is available here: https://develop.sentry.dev/sdk/performance/span-operations/ :param description: A description of what operation is being performed within the span. :param hub: The hub to use for this span. .. deprecated:: 2.0.0 Please use the `scope` parameter, instead. :param status: The span's status. Possible values are listed at https://develop.sentry.dev/sdk/event-payloads/span/ :param containing_transaction: The transaction that this span belongs to. :param start_timestamp: The timestamp when the span started. If omitted, the current time will be used. :param scope: The scope to use for this span. If not provided, we use the current scope. )r$r%r&r'r(r)r* _measurementsr/_start_timestamp_monotonic_nsr, timestamp_tags_datar^r+_context_manager_state_containing_transaction_local_aggregatorr0Nc |xstjj|_|xs!tjjdd|_||_||_||_||_||_ | |_ ||_ | |_ i|_ i|_i|_| |_| $t#j$t&j(} n4t+| t,r$t#j.| t&j(} | |_ t3|_d|_d|_d|_t?\} }|jA| |y#t6$rY@wxYw)N)!uuiduuid4hexr$r%r&r'r(r)r*r,r+r0rfrirjrlrnowrutc isinstancer7 fromtimestampr/r rgAttributeErrorrhr^rmr set_thread)rYr$r%r&r'r(r)r*r+r,r.r/r0 thread_id thread_names r:rZz Span.__init__s/ !4DJJL$4$4 7$**,"2"223"7 ,&<# &    '=$  "&ll8<<8O  /&44_hllSO. 2A1BD . "!%!8!: ;  ;/   sE EEc>|jt||_yyr\)r^rRrXs r:init_span_recorderzSpan.init_span_recorders    &"/"7D  'r9cD|j}|tx}|_|Sr\)rmLocalAggregatorrYrvs r:_get_local_aggregatorzSpan._get_local_aggregator s'  # # :*9*; ;B' r9cd|jjd|jd|jd|jd|j d|j d|jdS) N) __class__r1r)r*r$r%r&r(rYs r:__repr__z Span.__repr__sI ''    ##   r9c|jxstjj}|j}||_||f|_|Sr\)r0 sentry_sdkScopeget_current_scoper`rk)rYr0old_spans r: __enter__zSpan.__enter__#sA Bj..@@B:: ',h&7# r9c|||jd|j\}}|`|j|||_y)Ninternal_error) set_statusrkfinishr`)rYtyvaluetbr0rs r:__exit__z Span.__exit__+s=   OO, -55x  ' E r9c|jS)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".)rlrs r:r.zSpan.containing_transaction5s+++r9c ztjjjd}||k7r t S|j d|j td|j|j|jd|}|jxr|jj}|r|j||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. instrumenterr()r$r&r.r8) rr get_clientoptionsNoOpSpan setdefaultr(rer$r%r.r^ra)rYrkwargsconfiguration_instrumenterchild span_recorders r: start_childzSpan.start_childAs&0%5%5%@%@%B%J%J & " 5 5: )T\\2 ]]<<#'#>#>     ' ' VD,G,G,V,V     e $ r9c z|turtjdtjt |fi|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.)rer warningr-continue_from_headersEnvironHeaders)clsenvironrs r:continue_from_environzSpan.continue_from_environbs9& $; NN9 001HSFSSr9c d|turtjdtj|j t }|jt |it|j t}|!|j||jtdi|}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.Fr8) rer rrAfrom_incoming_headergetBAGGAGE_HEADER_NAMEupdateextract_sentrytrace_dataSENTRY_TRACE_HEADER_NAMEfreezer-r')rheadersrrBsentrytrace_kwargs transactions r:rzSpan.continue_from_headers|s $; NN9 ..w{{;N/OP *G455 KK0 1   ) MM, - NN !+F+ -2 *r9c#K|jsyt|jf|jjj }|r t |fyyw)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.rto_traceparent get_baggage serializer)rYrBs r: iter_headerszSpan.iter_headerssZ** &(;(;(===--99;EEG %w. . sAAc dtjd|sy|jt|ifi|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 rrr)r traceparentrs r:from_traceparentzSpan.from_traceparentsC  A (s(( %{ 3 7=  r9c|jdurd}n|jdurd}nd}|jd|j}||d|z }|S)NT1F0-)r(r$r%)rYr(rs r:rzSpan.to_traceparentsT <<4 G \\U "GG!% =   G- -Kr9cP|jr|jjSy)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.rrs r: to_baggagezSpan.to_baggages%  & &..::< <r9c"||j|<yr\)rirYkeyrs r:set_tagz Span.set_tag 3r9c"||j|<yr\)rjrs r:set_dataz Span.set_datarr9c||_yr\r,rYrs r:rzSpan.set_statuss  r9c(||d|j|<yN)runitrfrYr>rrs r:set_measurementzSpan.set_measurement-2D#A4 r9c|M|jtjt||!|jtj|yyyr\)rr THREAD_IDr4 THREAD_NAME)rYryrzs r:rxzSpan.set_threadsF  MM(,,c)n =& h22K@' !r9c|jdt||jtj||dkr|j dyd|cxkrdkrnn|dk(r|j dy|dk(r|j dy|d k(r|j d y|d k(r|j d y|d k(r|j dy|dk(r|j dy|j dyd|cxkrdkrZnnW|dk(r|j dy|dk(r|j dy|dk(r|j dy|j dy|j dy)Nzhttp.status_codeiokiipermission_deniedi not_foundiresource_exhaustedifailed_preconditioniunauthenticatedialready_existsinvalid_argumentiXideadline_exceededi unimplementedi unavailabler unknown_error)rr4rrHTTP_STATUS_CODErrY http_statuss r:set_http_statuszSpan.set_http_statuss< K 0  h//=   OOD ! K %# %c! 34# ,# 45# 56# 12# 01 23 K %# %c! 34#0# . 01 OOO ,r9c |jdk(S)Nrrrs r: is_successzSpan.is_success(s{{d""r9c|jy |r> % 8mU3$,$:$:=(,,$WM!.)+d.P.PP!%!5!5 !(49" =));;=*5$7  8%\\(,,7DN 8sA6B441C('C(c |j|j|j|j|j|j |j |jd}|jr|j|jd<|j!|jj}|r||d<t|jdkDr|j|d<|j}|r||d<|j}|r||d<|S)z5Returns a JSON-compatible representation of the span.)r$r%r&r'r)r*r/rhr,_metrics_summaryr measurementstagsdata)r$r%r&r'r)r*r/rhr,rirmto_jsonr]rfrj)rYrmetrics_summaryrrs r:rz Span.to_jsonRs  ||"11&*&A&A''++#33   ;;#';;DJJx  ! ! -"44<<>O)8%& t!! "Q &!%!3!3B~ zz BvJzz BvJ r9c|j|j|j|j|jd}|j r|j |d<|j r+|j jj|d<|S)N)r$r%r&r)r*r,dynamic_sampling_context) r$r%r&r)r*r,r.rrrs r:get_trace_contextzSpan.get_trace_contextvs~ ||"11''++   ;;;;BxL  & &++779RRT ) * r9) NNNTNNNNNNNNNN)!r1r2r3rbrcrZr|rrrrpropertyr.rSENTRYr classmethodrrrrrrrrrrrxrrrrrr8r9r:reres2I2#  #10j8    , ,(4':':BTT2''R/(  0   BA"-H#$L"Hr9receZdZdZdZdddeffd ZdZfdZfdZ e d Z dfd Z dd Z d Zfd ZfdZdZdZxZS)r-aiThe Transaction is the root element that holds all the spans for Sentry performance instrumentation. :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". :param kwargs: Additional arguments to be passed to the Span constructor. See :py:class:`sentry_sdk.tracing.Span` for available arguments. )r>r?r@ sample_raterf _contexts_profile_baggagerNc t|di|||_||_d|_||_i|_i|_d|_||_ yNr8) superrZr>r?rr@rfrrr)rYr>r@rBr?rrs r:rZzTransaction.__init__sP "6"  ,  r9cd|jjd|jd|jd|jd|j d|j d|jd|jd S) Nrz(name=z, op=rrrrz , source=r) rr1r>r)r$r%r&r(r?rs r:rzTransaction.__repr__sN ''   ##    r9cpt||j|jj|Sr\)r rr)rYrs r:rzTransaction.__enter__s-  == $ MM # # % r9cz|j|jj|||t||||yr\)rrr )rYrrrrs r:rzTransaction.__exit__s4 == $ MM " "2ub 1 UB'r9c|S)znThe root element of the span tree. In the case of a transaction it is the transaction itself. r8rs r:r.z"Transaction.containing_transactions  r9c |jy|xs(|jxstjj}tj j }|jsy|j|jdurtjdntjd|jr\t|jrG|jr|jj dkDrd}nd}|jj#|d y|j$stj&d d |_t( |U|||js"|jtj&d y|jj,Dcgc]}|j|j/ }}d|_i}|j1|j2|j1d |j5id|j$d|j6i||j8|j|j:|d}|j<0|j<j?r|j<|d<d|_|j@|d<|jB!|jBj/} | r| |d<|jE|Scc}w)aFinishes 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. NFz.Discarding transaction because sampled = FalsezSDiscarding transaction because it was not started with sentry_sdk.start_transactionr backpressurerr) data_categoryzCTransaction has no name, falling back to ``.zz1Discarding transaction without sampling decision.tracer?)typertransaction_infocontextsrrhr/rUprofilerr)#rhr+rHubcurrentrr is_activer^r(r debug transporthas_tracing_enabledrmonitordownsample_factorrecord_lost_eventr>rr rrUrrrrr?rir/rvalidrfrm capture_event) rYr+rclientreasonr`finished_spansreventrrs r:rzTransaction.finishsb >> %7TXX7!7!7!!,,.!    &||u$ MN i$7$G>>fnn&F&F&J+F*F  2262Wyy NNU 2DI sM*||||#RS++11 ~~) LLN  #'$"8"8":;<"99!)4;; 7 JJ#33#   == $)<)<)>#}}E)  DM $ 2 2n  ! ! -"44<<>O,;()  ''Q s#Kc(||d|j|<yrrrs r:rzTransaction.set_measurementQrr9c"||j|<y)aSets 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)rrs r: set_contextzTransaction.set_contextUs$sr9cLt|||jdd|iy)zySets the status of the Transaction according to the given HTTP status. :param http_status: The HTTP status code.response status_codeN)r rr')rYrrs r:rzTransaction.set_http_status`s'  , m[%ABr9c~t|}|j|d<|j|d<|j|d<|S)zr?r()r rr>r?r()rYrrs r:rzTransaction.to_jsonhs=W_ YY6 {{8  9  r9c|jr|jjrtj||_|jS)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.)rmutablerApopulate_from_transactionrs r:rzTransaction.get_baggagess3}} 5 5#==dCDM}}r9c tjj}dj|jrd|jzdznd|j }t |jsd|_y|jt|j|_ yt|jjdr|jd|n|d |d n|jd }t|d s-tjd j|d|_yt||_ |j r,|xjd|j j"zzc_ |jsTtj$dj|t|jjdrdndd|_yt'j&|jk|_|jr&tj$dj|ytj$dj||jy)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}>rz> r)r)r>FNtraces_samplerr@traces_sample_rateTracing)r?zN[Tracing] Discarding {transaction_description} because of invalid sample rate.)transaction_descriptionz?[Tracing] Discarding {transaction_description} because {reason}z"traces_sampler returned 0 or Falseztraces_sample_rate is set to 0)r3r"z,[Tracing] Starting {transaction_description}z}[Tracing] Discarding {transaction_description} because it's not included in the random sample (sampling rate = {sample_rate}))r3r)rrrformatr)r>rrr(r7rcallablerr r rrrrrandom)rYsampling_contextr!r3rs r:_set_initial_sampling_decisionz*Transaction._set_initial_sampling_decisions'*!!,,."<"C"C(,dgg $Rtyy#D#  #6>>2 DL  << #$T\\2D  **+;<= -FNN+ ,-= > $$45A!!12^^$89 $K B NN`gg,Ch  !DL  - >>   6>>#C#C C C  LLQXX,C$FNN$6$67G$HI== Y !DL  }})9)99 << LL>EE,CF  LLPWW,C $ 0 0W r9rr)r1r2r3rbrcTRANSACTION_SOURCE_CUSTOMrZrrrrr.rrr'rrrr9 __classcell__)rs@r:r-r-sm" I(  * (  f(PB $C  fr9r-ceZdZdZedZejfdZdZ dZ dZ dZ dZ d Zd Zd Zd Zd ZdZddZddZdZdZdZy)rc4d|jjzS)Nz<%s>)rr1rs r:rzNoOpSpan.__repr__s////r9cyr\r8rs r:r.zNoOpSpan.containing_transactionsr9c tSr\)r)rYrrs r:rzNoOpSpan.start_childs zr9cy)Nrr8rs r:rzNoOpSpan.to_traceparentsr9cyr\r8rs r:rzNoOpSpan.to_baggager9cyr\r8rs r:rzNoOpSpan.get_baggagerBr9ctdSr)iterrs r:rzNoOpSpan.iter_headerss Bxr9cyr\r8rs r:rzNoOpSpan.set_tag r9cyr\r8rs r:rzNoOpSpan.set_data rGr9cyr\r8rs r:rzNoOpSpan.set_statusrGr9cyr\r8rs r:rzNoOpSpan.set_http_statusrGr9cy)NTr8rs r:rzNoOpSpan.is_successrBr9ciSr\r8rs r:rzNoOpSpan.to_json r9ciSr\r8rs r:rzNoOpSpan.get_trace_contextrMr9Ncyr\r8)rYr+rs r:rzNoOpSpan.finish#rGr9cyr\r8rs r:rzNoOpSpan.set_measurement'rGr9cyr\r8rs r:r'zNoOpSpan.set_context+rGr9cyr\r8rXs r:r|zNoOpSpan.init_span_recorder/rGr9cyr\r8)rYr8s r:r9z'NoOpSpan._set_initial_sampling_decision3rGr9rr)r1r2r3rrr.rrrrrrrrrrrrrrrrr'r|r9r8r9r:rrs{0(4':':         r9rcyr\r8funcs r:rr: r9cyr\r8rUs r:rr?rWr9c&ddlm}|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)sentry_sdk.tracing_utilsrZ)rVrZs r:rrEs&D )$//))r9)rArrrr)r~r\)Brpr7rrrrsentry_sdk.constsrrsentry_sdk.utilsrr r r sentry_sdk._typesr collections.abcr rrtypingrrrrrrrrrrtyping_extensionsrrrrsentry_sdk.profilerrrr r!r#r=rrr:TRANSACTION_SOURCE_URLTRANSACTION_SOURCE_ROUTETRANSACTION_SOURCE_VIEWTRANSACTION_SOURCE_COMPONENTTRANSACTION_SOURCE_TASKLOW_QUALITY_TRANSACTION_SOURCESSOURCE_FOR_STYLErRrer-rrr[rArrrrsentry_sdk.metricsr~r8r9r:rksj 224 ,AA 3#A A/YYe/YbQJeQ$ ) %" * # -107 ".-, # $$.eeP\$\~ L tL ^     *>/r9