o Zh@sddlmZddlmZddlmZddlZddlZddlZddlm Z ddl m Z ddl m Z mZddlmZdd lmZdd lmZdd lmZmZmZmZdd lmZmZmZmZmZdd l m!Z!ddl"m#Z#m$Z$m%Z%m&Z&e!rddl'm(Z(ddl)m*Z*ddl)m+Z+ddl)m,Z,ddl)m-Z-ddl)m.Z.ddl)m/Z/ddl)m0Z0ddl)m1Z1ddl)m2Z2ddl)m3Z3ddl)m4Z4ddl m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>e3de+de*fdZ?e3dZ@gZAd d!ZBd"d#ZCd$d%ZDd&d'ZEGd(d)d)eFZGdS)*)copy)deque)chainN) Attachment)datetime_utcnow) FALSE_VALUES INSTRUMENTERwraps)Profile)Session)Baggageextract_sentrytrace_datahas_tracing_enablednormalize_incoming_data)BAGGAGE_HEADER_NAMESENTRY_TRACE_HEADER_NAMENoOpSpanSpan Transaction) TYPE_CHECKING)event_from_exceptionexc_info_from_errorloggercapture_internal_exceptions)MutableMapping)Any)Callable)Deque)Dict) Generator)Iterator)List)Optional)Tuple)TypeVar)Union) BreadcrumbBreadcrumbHintErrorProcessorEventEventProcessorExcInfoHint LogLevelStrTypeF.)boundTcCst|dSN)global_event_processorsappend) processorr7G/var/www/html/lang_env/lib/python3.10/site-packages/sentry_sdk/scope.pyadd_global_event_processorGr9cCst||jdS)N)fsetdoc)property__doc__fnr7r7r8 _attr_setterLr:rAcstfdd}|S)Ncs8|jsdSzd|_|g|Ri|Wd|_Sd|_w)NFT)_should_capture)selfargskwargsr?r7r8wrapperSs z!_disable_capture..wrapperr )r@rFr7r?r8_disable_captureQs rGcCsj|r|rtd|dur!t|}t|r|||S|||S|r1t|}|jdi||S|}|S)Nzcannot provide scope and kwargsr7) TypeErrorrcallableupdate_from_scopeupdate_from_kwargs)baseZ scope_change scope_kwargsZ final_scoper7r7r8 _merge_scopesas  rNc@steZdZdZdZddZddZddZd d Zd d Z d~ddZ ddZ ddZ ddZ ddZddZddZddZddZed d!Zd"d#Zed$d%Zed&d'Zejd(d'Zd~d)d*Zed+d,Zd-d.Zed/d0Zejd1d0Zed2d3Zejd4d3Zd5d6Zd7d8Z d9d:Z!d;d<Z"d=d>Z#d?d@Z$dAdBZ% CddDdEZ&ddFdGZ'd e(j)fdHdIZ*d e(j)fdJdKZ+ddLdMZ,ddNdOZ- ddPdQZ.ddRdSZ/dTdUZ0dVdWZ1dXdYZ2dZd[Z3d\d]Z4d^d_Z5 d~d`daZ6dbdcZ7dddeZ8dfdgZ9dhdiZ:djdkZ;dldmZdrdsZ?e@ d~dtduZAdvdwZB ddxdyZCdzd{ZDd|d}ZEd S)ScopezaThe scope holds extra information that should be sent with all events that belong to it. )_level_name _fingerprint _transaction_transaction_info_user_tags _contexts_extras _breadcrumbs_event_processors_error_processorsrB_span_session _attachments_force_auto_session_tracking_profile_propagation_contextcCs8g|_g|_d|_d|_||}|j|ddS)N) incoming_data)rZr[rQraclear_load_trace_data_from_envgenerate_propagation_context)rCincoming_trace_informationr7r7r8__init__szScope.__init__cCspd}tjdp d}|tv}|r4i}tjdr$tjdp!d|t<tjdr4tjdp1d|t<|p7dS)z Load Sentry trace id and baggage from environment variables. Can be disabled by setting SENTRY_USE_ENVIRONMENT to "false". NZSENTRY_USE_ENVIRONMENTZ SENTRY_TRACEZSENTRY_BAGGAGE)osenvirongetlowerrrr)rCrfZsentry_use_environmentZuse_environmentr7r7r8rds  zScope._load_trace_data_from_envcCsi}t|}|t}|rt||d<|t}|r*t|}|dur*||d|vo1d|v}|r;|| |rO|dsMt j dd|d<|SdS)Ndynamic_sampling_contexttrace_idspan_id) rrkrr Zfrom_incoming_headerrmrrupdate_create_new_propagation_contextuuiduuid4hex)rCdatacontextZnormalized_dataZbaggage_headerZsentry_trace_headerZsentrytrace_dataZonly_baggage_no_sentry_tracer7r7r8_extract_propagation_contexts.    z"Scope._extract_propagation_contextcCs"tjtjdddddS)Nrprnroparent_span_idrm)rsrtrurCr7r7r8rrs z%Scope._create_new_propagation_contextcCs||_td|jdS)zt Creates a new propagation context and sets it as `_propagation_context`. Overwriting existing one. z,[Tracing] Create new propagation context: %sN)rrrardebugr{r7r7r8set_new_propagation_contexts z!Scope.set_new_propagation_contextNcCsD|r||}|dur||_td|j|jdur |dSdS)z Makes sure `_propagation_context` is set. If there is `incoming_data` overwrite existing `_propagation_context`. if there is no `incoming_data` create new `_propagation_context`, but do NOT overwrite if already existing. Nz>[Tracing] Extracted propagation context from incoming data: %s)rxrarr|r})rCrbrwr7r7r8res   z"Scope.generate_propagation_contextcCs6|jdurdS|}|dur||jd<|jdS)z Returns the Dynamic Sampling Context from the Propagation Context. If not existing, creates a new one. Nrm)ra get_baggagerm)rCbaggager7r7r8get_dynamic_sampling_context s  z"Scope.get_dynamic_sampling_contextcOs\|dd}|durt|jr|jdur|jS|jdur dSd|jd|jdf}|S)z Returns the Sentry "sentry-trace" header (aka the traceparent) from the currently active span or the scopes Propagation Context. clientNz%s-%srnro)poproptionsspanZto_traceparentra)rCrDrEr traceparentr7r7r8get_traceparents    zScope.get_traceparentcOsf|dd}|durt|jr|jdur|jS|jdur dS|jd}|dur/t|St|S)Nrrm) rrrrZ to_baggagerarkr Z from_options)rCrDrErrmr7r7r8r~3s     zScope.get_baggagecCs6|jdurdS|jd|jd|jd|d}|S)zR Returns the Sentry "trace" context from the Propagation Context. Nrnrorzry)rar)rCZ trace_contextr7r7r8get_trace_contextJs zScope.get_trace_contextcOs~|dd}|durtd|dd}d}|j|d}|dur)|dt|f7}|j|d}|dur=|dt|f7}|S)z Return meta tags which should be injected into HTML templates to allow propagation of trace information. rNzaThe parameter `span` in trace_propagation_meta() is deprecated and will be removed in the future.rrhrz)rrwarningrrr~r serialize)rCrDrErrmetaZ sentry_tracerr7r7r8trace_propagation_meta[s(    zScope.trace_propagation_metaccsX|jdur(|}|durt|fV|}|dur*t|}t|fVdSdSdS)zz Creates a generator which returns the `sentry-trace` and `baggage` headers from the Propagation Context. N)rarrrr rr)rCrZdscrr7r7r8 iter_headers{s   zScope.iter_headerscos|dd}|dd}|o|jd}|sdS|p|j}|r4t|jr4|dur4|D]}|Vq,dS|D]}|Vq8dS)z Return HTTP headers which allow propagation of trace data. Data taken from the span representing the request, if available, or the current span on the scope if not. rNrpropagate_traces)rrrrr)rCrDrErrrheaderr7r7r8iter_trace_propagation_headerss     z$Scope.iter_trace_propagation_headerscCsfd|_d|_d|_i|_d|_i|_i|_i|_g|_| d|_ d|_ d|_ d|_ d|_d|_dS)zClears the entire scope.NT)rPrRrSrTrUrVrWrXr^clear_breadcrumbsrBr\r]r_r`rar{r7r7r8rcs  z Scope.clearcCstd||_dS)z When set this overrides the level. .. deprecated:: 1.0.0 Use :func:`set_level` instead. :param value: The level to set. zIDeprecated: use .set_level() instead. This will be removed in the future.N)rrrPrCvaluer7r7r8levels  z Scope.levelcC ||_dS)zX Sets the level for the scope. :param value: The level to set. NrPrr7r7r8 set_levels zScope.set_levelcCr)z0When set this overrides the default fingerprint.N)rRrr7r7r8 fingerprint zScope.fingerprintcCs&|jdurdS|jjdurdS|jjS)z8Return the transaction (root span) in the scope, if any.N)r\containing_transactionr{r7r7r8 transactions  zScope.transactioncCs4td||_|jr|jjr||jj_dSdSdS)zrWhen set this forces a specific transaction name to be set. Deprecated: use set_transaction_name instead.z`Assigning to scope.transaction directly is deprecated: use scope.set_transaction_name() instead.N)rrrSr\rnamerr7r7r8rscCsB||_|jr|jjr||jj_|r||jj_|r||jd<dSdS)z?Set the transaction name and optionally the transaction source.sourceN)rSr\rrrrT)rCrrr7r7r8set_transaction_names  zScope.set_transaction_namecCs||dS)zPWhen set a specific user is bound to the scope. Deprecated in favor of set_user.N)set_userrr7r7r8usersz Scope.usercCs&||_|jdur|jj|ddSdS)zSets a user for the scope.N)r)rUr]rqrr7r7r8rs zScope.set_usercC|jS)z,Get/set current tracing span or transaction.)r\r{r7r7r8rsz Scope.spancCsD||_t|tr|}|jr|j|_|jr |j|jd<dSdSdSdS)Nr)r\ isinstancerrrSrrT)rCrrr7r7r8r%s cCrr3r`r{r7r7r8profile2sz Scope.profilecCs ||_dSr3r)rCrr7r7r8r7rcC||j|<dS)z Sets a tag for a key to a specific value. :param key: Key of the tag to set. :param value: Value of the tag to set. N)rVrCkeyrr7r7r8set_tag= z Scope.set_tagcC|j|ddS)zX Removes a specific tag. :param key: Key of the tag to remove. N)rVrrCrr7r7r8 remove_tagHszScope.remove_tagcCr)zG Binds a context at a certain key to a specific value. N)rWrr7r7r8 set_contextQrzScope.set_contextcCr)zRemoves a context.N)rWrrr7r7r8remove_context\zScope.remove_contextcCr)z&Sets an extra key to a specific value.N)rXrr7r7r8 set_extracszScope.set_extracCr)zRemoves a specific extra key.N)rXrrr7r7r8 remove_extralrzScope.remove_extracCs t|_dS)zClears breadcrumb buffer.N)rrYr{r7r7r8rss zScope.clear_breadcrumbsFc Cs|jt|||||ddS)z)Adds an attachment to future events sent.)bytespathfilename content_typeadd_to_transactionsN)r^r5r)rCrrrrrr7r7r8add_attachmentxs zScope.add_attachmentcKs|dd}|dur dS|jd}|jd}t|pd}|||s'dSt|p+d}|ddur9t|d<|ddurDd|d<|durN|||}n|}|dur[|j|nt d |t |j|krv|j t |j|kshdSdS) a Adds a breadcrumb. :param crumb: Dictionary with the data as the sentry v7/v8 protocol expects. :param hint: An optional value that can be used by `before_breadcrumb` to customize the breadcrumbs that are emitted. rNbefore_breadcrumbmax_breadcrumbsr7 timestamptypedefaultz)before breadcrumb dropped breadcrumb (%s)) rrrkdictrqrrYr5rinfolenpopleft)rCZcrumbhintrErrrZ new_crumbr7r7r8add_breadcrumbs.          zScope.add_breadcrumbc Ks|dd}|dd}|o|jd}||krtS|di}|dur1|d|td i|}||jd}|||j|dt ||d} | j|d|j re|o\|jd  d p^d } |j | d |S)a Start and return a transaction. Start an existing transaction if given, otherwise create and start a new transaction with kwargs. This is the entry point to manual tracing instrumentation. A tree structure can be built by adding child spans to the transaction, and child spans to other spans. To start a new child span within the transaction or any span, call the respective `.start_child()` method. Every child span must be finished before the transaction is finished, otherwise the unfinished spans are discarded. When used as context managers, spans and transactions are automatically finished at the end of the `with` block. If not using context managers, call the `.finish()` method. When the transaction is finished, it will be sent to Sentry with all its finished child spans. For supported `**kwargs` see :py:class:`sentry_sdk.tracing.Transaction`. hubNr instrumentercustom_sampling_context)Ztransaction_contextparent_sampled)sampling_context)rZ _experiments max_spansi)maxlenr7) rrr setdefaultrto_jsonrrqZ_set_initial_sampling_decisionr ZsampledrkZinit_span_recorder) rCrrrErrconfiguration_instrumenterrrrrr7r7r8start_transactions.         zScope.start_transactionc Ks|dd}|o |jd}||krtSt|tsd|vrJd}t|tr2t||j|fi|Sd|vrJt||d}|jd d|i|S|durWd}t||S|d|j }|durm|j d i|} | Sd|vr| } | r~| d d nd} | dur| |d<t d i|S) a Start a span whose parent is the currently active span or transaction, if any. The return value is a :py:class:`sentry_sdk.tracing.Span` instance, typically used as a context manager to start and stop timing in a `with` block. Only spans contained in a transaction are sent to Sentry. Most integrations start a transaction at the appropriate time, for example for every incoming HTTP request. Use :py:meth:`sentry_sdk.start_transaction` to start a new transaction when one is not already in progress. For supported `**kwargs` see :py:class:`sentry_sdk.tracing.Span`. rNrrzcDeprecated: use start_transaction to start transactions and Transaction.start_child to start spans.rz]Deprecated: passing a span into `start_span` is deprecated and will be removed in the future.rn-rr7)rkrrrrrrrrrZ start_childrsplitr) rCrrrErrdeprecation_msgrZ active_spanZnew_child_spanrrnr7r7r8 start_spans:       zScope.start_spancCs$||tjt||||d}|S)ze Sets the propagation context from environment or headers and returns a transaction. )oprr)rerZcontinue_from_headersr)rCZenviron_or_headersrrrrr7r7r8continue_trace;s zScope.continue_tracecKs(|durdSt|||}|j|||dS)a Captures an event. Merges given scope data and calls :py:meth:`sentry_sdk.Client.capture_event`. :param event: A ready-made event that can be directly sent to Sentry. :param hint: Contains metadata about the event that can be read from `before_send`, such as the original exception object or a HTTP request object. :param client: The client to use for sending the event to Sentry. :param scope: An optional :py:class:`sentry_sdk.Scope` to apply to events. The `scope` and `scope_kwargs` parameters are mutually exclusive. :param scope_kwargs: Optional data to apply to event. For supported `**scope_kwargs` see :py:meth:`sentry_sdk.Scope.update_from_kwargs`. The `scope` and `scope_kwargs` parameters are mutually exclusive. :returns: An `event_id` if the SDK decided to send the event (see :py:meth:`sentry_sdk.Client.capture_event`). N)eventrscope)rN capture_event)rCrrrrrMr7r7r8rKs zScope.capture_eventcKs:|durdS|dur d}||d}|j|f||d|S)a Captures a message. :param message: The string to send as the message. :param level: If no level is provided, the default level is `info`. :param client: The client to use for sending the event to Sentry. :param scope: An optional :py:class:`sentry_sdk.Scope` to apply to events. The `scope` and `scope_kwargs` parameters are mutually exclusive. :param scope_kwargs: Optional data to apply to event. For supported `**scope_kwargs` see :py:meth:`sentry_sdk.Scope.update_from_kwargs`. The `scope` and `scope_kwargs` parameters are mutually exclusive. :returns: An `event_id` if the SDK decided to send the event (see :py:meth:`sentry_sdk.Client.capture_event`). Nr)messager)rr)r)rCrrrrrMrr7r7r8capture_messagehszScope.capture_messagecKsx|durdS|durt|}nt}t||jd\}}z|j|f|||d|WSty;|tYdSw)aCaptures an exception. :param error: An exception to capture. If `None`, `sys.exc_info()` will be used. :param client: The client to use for sending the event to Sentry. :param scope: An optional :py:class:`sentry_sdk.Scope` to apply to events. The `scope` and `scope_kwargs` parameters are mutually exclusive. :param scope_kwargs: Optional data to apply to event. For supported `**scope_kwargs` see :py:meth:`sentry_sdk.Scope.update_from_kwargs`. The `scope` and `scope_kwargs` parameters are mutually exclusive. :returns: An `event_id` if the SDK decided to send the event (see :py:meth:`sentry_sdk.Client.capture_event`). N)Zclient_options)rrr)rsysexc_inforrr Exception_capture_internal_exception)rCerrorrrrMrrrr7r7r8capture_exceptions$  zScope.capture_exceptioncCstjd|ddS)z Capture an exception that is likely caused by a bug in the SDK itself. These exceptions do not end up in Sentry and are just logged instead. zInternal error in sentry_sdk)rN)rr)rCrr7r7r8rs z!Scope._capture_internal_exceptioncOsX|dd}|dd}|j|dt|r|jdnd|r"|jdnd|j|d|_dS) zStarts a new session.rN session_modeZ applicationrrelease environment)rrrr)r end_sessionr rrUr])rCrDrErrr7r7r8 start_sessions    zScope.start_sessioncOsF|dd}|j}d|_|dur||dur!||dSdSdS)z)Ends the current session if there is one.rN)rr]closeZcapture_session)rCrDrErsessionr7r7r8rs zScope.end_sessioncOs"|dd}|j|dd|_dS)zStops automatic session tracking. This temporarily session tracking for the current scope when called. To resume session tracking call `resume_auto_session_tracking`. rNrF)rrr_)rCrDrErr7r7r8stop_auto_session_trackings   z Scope.stop_auto_session_trackingcCs d|_dS)zResumes automatic session tracking for the current scope if disabled earlier. This requires that generally automatic session tracking is enabled. N)r_r{r7r7r8resume_auto_session_trackings z"Scope.resume_auto_session_trackingcCs8t|jdkrtd|j|jdd=|j|dS)z}Register a scope local event processor on the scope. :param func: This function behaves like `before_send.` zLToo many event processors on scope! Clearing list to free up some memory: %rN)rrZrrr5)rCfuncr7r7r8add_event_processors zScope.add_event_processorcs.|dur||fdd}|j|dS)aRegister a scope local error processor on the scope. :param func: A callback that works similar to an event processor but is invoked with the original exception info triple as second argument. :param cls: Optionally, only process exceptions of this type. Ncs<z t|d}Wn tyd}Ynw|r||S|S)NF)rr)rrZis_instZcls_Z real_funcr7r8r s  z'Scope.add_error_processor..func)r[r5)rCrclsr7rr8add_error_processors   zScope.add_error_processorcCs|jdur |j|d<dSdS)NrrrCrrrr7r7r8_apply_level_to_events zScope._apply_level_to_eventcCs |didg|jdS)NZ breadcrumbsvalues)rextendrYrr7r7r8_apply_breadcrumbs_to_eventsz!Scope._apply_breadcrumbs_to_eventcC.|ddur|jdur|j|d<dSdSdS)Nr)rkrUrr7r7r8_apply_user_to_event$zScope._apply_user_to_eventcCr)Nr)rkrSrr7r7r8 _apply_transaction_name_to_event)rz&Scope._apply_transaction_name_to_eventcCr)NZtransaction_info)rkrTrr7r7r8 _apply_transaction_info_to_event.rz&Scope._apply_transaction_info_to_eventcCr)Nr)rkrRrr7r7r8_apply_fingerprint_to_event3rz!Scope._apply_fingerprint_to_eventcC"|jr|di|jdSdS)Nextra)rXrrqrr7r7r8_apply_extra_to_event8zScope._apply_extra_to_eventcCr)Ntags)rVrrqrr7r7r8_apply_tags_to_event=rzScope._apply_tags_to_eventc Cs|jr |di|j|di}|ddur1t|r+|jdur+|j|d<n||d<z |ddd}Wn ttfyHd}Ynw|durUd|i|d<dSdS)Ncontextstracerm replay_idZreplay) rWrrqrkrr\rKeyErrorrH)rCrrrrrr7r7r8_apply_contexts_to_eventBs    zScope._apply_contexts_to_eventc Cs|d}|dk}|dk}|dpg}|jD] }|r|jr#||q||d<|||||r?d|didii|d<|sr||||||||||||| |||| |||| |||| ||||s}|s}| |||dd} |d } | d ur|jD]} | || } | d ur| | d S| }q|stt|jD])} |} t | ||} Wd n1swY| d ur| | d S| }q|S) zBApplies the information contained on the scope to the given event.rrZcheck_in attachmentsrrcSstd||dS)Nz%s (%s) dropped event)rr)causetyr7r7r8_dropsz#Scope.apply_to_event.._droprNzerror processorzevent processor)rkr^rr5rrrrrrrrrrr[rr4rZr)rCrrrrZis_transactionZ is_check_inZattachments_to_send attachmentrrZerror_processorZ new_eventZevent_processorr7r7r8apply_to_event[sV        zScope.apply_to_eventcCs|jdur |j|_|jdur|j|_|jdur|j|_|jdur'|j|j|jdur0|j|_|jr:|j|j|jrD|j|j|jrN|j|j|j rX|j |j |j r_|j |_ |j ri|j |j |j rp|j |_ |jry|j|_dSdS)z+Update the scope with another scope's data.N)rPrRrSrTrqrUrVrWrXrYrr\r^r`ra)rCrr7r7r8rJs6      zScope.update_from_scopecCsn|dur||_|dur||_|dur|j||dur"|j||dur,|j||dur5||_dSdS)zUpdate the scope's attributes.N)rPrUrXrqrWrVrR)rCrrextrasrrrr7r7r8rKs     zScope.update_from_kwargscCst|j}|j|_|j|_|j|_|j|_t|j|_|j |_ t|j |_ t|j |_ t|j |_ t |j|_t|j|_t|j|_|j|_|j|_|j|_|j|_|j|_t|j|_|j|_|Sr3)object__new__ __class__rPrQrRrSrrTrUrVrWrXrrYlistrZr[rarBr\r]r_r^r`)rCrvr7r7r8__copy__s*         zScope.__copy__cCsd|jjtt||jfS)Nz<%s id=%s name=%s>)r__name__ruidrQr{r7r7r8__repr__s  zScope.__repr__r3)NNNNF)NN)NNN)NNNNNN)Fr __module__ __qualname__r> __slots__rgrdrxrrr}rerrr~rrrrrcrArrrr=rsetterrrrrrrrrrrrrrrrZSENTRYrrrrrrrrrrrrrrrrrrrrrrrGr rJrKrrr7r7r7r8rOws                   + A D  #$     F   rO)Hr collectionsr itertoolsrrirrsZsentry_sdk.attachmentsrZsentry_sdk._compatrZsentry_sdk.constsrrZsentry_sdk._functoolsr Zsentry_sdk.profilerr Zsentry_sdk.sessionr Zsentry_sdk.tracing_utilsr rrrZsentry_sdk.tracingrrrrrZsentry_sdk._typesrZsentry_sdk.utilsrrrrcollections.abcrtypingrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/Z sentry_sdkr0r2r4r9rArGrNr rOr7r7r7r8sN                    ,