o iP@svUddlmZddlmZddlZddlZddlZddlZddlm Z ddlm Z ddlm Z ddlm Z ddl mZdd l mZdd l mZdd l mZerUdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZeddgZde d<egdZ!de d<dZ"de d<d/ddZ#d0d$d%Z$d1d'd(Z%Gd)d*d*Z&Gd+d,d,Z'Gd-d.d.ej(Z)dS)2)absolute_import) annotationsN)CodeType) FrameType) ModuleType) TracebackType) TYPE_CHECKING)Any)Callable)Optional) UnionType)ddup)config) _threading) collector)_task)Tracer_acquire_releasezfrozenset[str]ACQUIRE_RELEASE_CO_NAMES)acquirerelease __enter____exit__ __aenter__ __aexit__ENTER_EXIT_CO_NAMESintCALLER_FRAME_INDEXreturntuple[int, str]cCst}|t|fSN)_thread get_identrget_thread_name) thread_idr'U/home/ubuntu/.local/lib/python3.10/site-packages/ddtrace/profiling/collector/_lock.py_current_thread%sr) module_namestr class_nameCallable[..., Any]cCs6ddl}||}t||}t|tr|jr|jS|S)znReconstruct the original lock class when unpickling. Since this is a module-level function, it can be pickled.rN) importlib import_modulegetattr isinstance_LockAllocatorWrapper_original_class)r*r,r.moduleobjr'r'r(_get_original_lock_class*s   r6r cCs:|dkr|dkr d\}}n|dkrd\}}t||}|S)zNCreate an instance of the original lock class when unpickling a _ProfiledLock.r#lock) threadingLockRLock)r8r:)r6)r*r, lock_classr'r'r(_create_original_lock_instance8s  r<c@seZdZdZdZ dBdCddZdDddZdEddZdFddZdGddZ dHddZ dIdd Z dJd#d$Z dJd%d&Z dJd'd(ZdKd+d,ZdJd-d.ZdLd/d0ZdJd1d2ZdMd3d4ZdNd8d9ZdOd=d>ZdPd?d@ZdAS)Q _ProfiledLockz Lightweight lock wrapper that profiles lock acquire/release operations. It intercepts lock methods without the overhead of a full proxy object. ) __wrapped__tracercapture_sampler init_location acquired_timename is_internalFwrappedr r?Optional[Tracer]r@collector.CaptureSamplerrDboolr NonecCsz||_||_||_ztt}Wnty tjrd|_ Ynw|j }t j |jd|j|_ d|_d|_||_dS)Nz unknown:0:)r>r?r@sys _getframer ValueErrorrenable_assertsrAf_codeospathbasename co_filenamef_linenorBrCrD)selfrEr?r@rDframecoder'r'r(__init__Us   z_ProfiledLock.__init__othercCs t|tr |j|jkS|j|kSr")r1r=r>rUrYr'r'r(__eq__rs   z_ProfiledLock.__eq__rCr+cCs t|j|Sr")r0r>)rUrCr'r'r( __getattr__ws z_ProfiledLock.__getattr__rcCs t|jSr")hashr>rUr'r'r(__hash__{s z_ProfiledLock.__hash__cCsd|jd|jdS)Nz<_ProfiledLock(z) at >)r>rAr^r'r'r(__repr__~sz_ProfiledLock.__repr__1tuple[Callable[[str, str], Any], tuple[str, str]]cCst|j}t|j|jffS)zSupport pickling by returning the wrapped lock. In the context of multiprocessing, the child process will get the unwrapped lock class, which will be re-wrapped if profiling is enabled there. )typer>r< __module__ __qualname__)rU wrapped_typer'r'r( __reduce__s  z_ProfiledLock.__reduce__cCs |jS)z&Return True if lock is currently held.)r>lockedr^r'r'r(rhs z_ProfiledLock.lockedargskwargscO|j|jjg|Ri|Sr")rr>rrUrirjr'r'r(rz_ProfiledLock.acquirecOrkr")rr>rrlr'r'r(rrmz_ProfiledLock.__enter__cOrkr")rr>rrlr'r'r(rrmz_ProfiledLock.__aenter__ inner_funcr-c Os|jstjr|jdusJd|j||i|St}d}d}z ||i|}WntyD}z ||jf}WYd}~nd}~wwt}||_|j ssz| |j ||ddWnt yjtjrhYn t yrYnw|dur|\} } | | |S)NzCExpected acquired_time to be None when acquire is not sampled, got T) is_acquire)r@capturerrNrBtime monotonic_ns BaseException __traceback__rD _update_name _flush_sampleAssertionError Exceptionwith_traceback) rUrnrirjstartresult error_infoexcenderrtbr'r'r(rs@      z_ProfiledLock._acquirecOrkr")rr>rrlr'r'r(rrmz_ProfiledLock.releasecOs |j|jjg|Ri|dSr")rr>rrlr'r'r(rs z_ProfiledLock.__exit__cOrkr")rr>rrlr'r'r(rrmz_ProfiledLock.__aexit__c Ost|dd}d|_d}d}z ||i|}Wnty-}z ||jf}WYd}~nd}~ww|rU|jsUz |j|tddWntyLt j rJYn t yTYnw|durb|\}} | | |S)NrBF)r~ro) r0rBrsrtrDrvrqrrrwrrNrxry) rUrnrirjrzr{r|r}rrr'r'r(rs0     z_ProfiledLock._releaserzr~rocCs|jrdSzrt}|||jr|jd|jn|j}||||}|r0||dn||dt \}}t \} } } | | | | t|} ||| ||jdure||j| pktt} || |WdStytjrYdStyYdSw)z!Push lock profiling data to ddup.NrJ)rDr SampleHandlepush_monotonic_nsrCrApush_lock_name push_acquire push_releaser)rget_task push_task_idpush_task_namerget_thread_native_idpush_threadinfor? push_span current_spanrKrLr push_pyframes flush_samplerwrrNrx)rUrzr~rohandle lock_name duration_nsr& thread_nametask_id task_name task_framethread_native_idrVr'r'r(rvs:           z_ProfiledLock._flush_samplevar_dictdict[str, Any] Optional[str]c Cs|D]@\}}|dst|trq||ur|StjjrDt|D] }z|ds9t|||ur9|WSWq#t yCYq#wqdS)N__) items startswithr1rrr7name_inspect_dirdirr0AttributeError)rUrrCvalue attributer'r'r( _find_names   z_ProfiledLock._find_namecCs|jdurdSzDtjr5td}|jjtvr td|jjdtd}|jjt vr5td|jjdtt }| |j pG| |j pGd|_WdStyYtjrVYdStybYdSw)z/Get lock variable name from the caller's frame.NrzUnexpected frame in stack: '')rCrrNrKrLrOco_namerrwrrrf_locals f_globalsrx)rUrVr'r'r(ru,s&      $  z_ProfiledLock._update_nameN)F) rEr r?rFr@rGrDrHr rI)rYr r rHrCr+r r )r r)r r+)r rb)r rH)rir rjr r r )rnr-rir rjr r r rir rjr r rI)rnr-rir rjr r rI)rzrr~rrorHr rI)rrr rr rI)__name__rdre__doc__ __slots__rXr[r\r_rargrhrrrrrrrrrvrrur'r'r'r(r=Es,           '     4r=c@sfeZdZdZdZd&dd Zd'd d Zd(d)ddZd*ddZd+ddZ d+ddZ d,d!d"Z d-d$d%Z d S).r2aWrapper for lock allocator functions that prevents method binding. For simple locks (Lock, RLock), this wrapper just intercepts instantiation. For class-based locks with inheritance (Semaphore, BoundedSemaphore), this wrapper also handles the case where a subclass calls Parent.__init__(self, value). Example: # In Python's threading.py: class BoundedSemaphore(Semaphore): def __init__(self, value=1): Semaphore.__init__(self, value) # <-- We intercept this! self._initial_value = value When we patch threading.Semaphore with this wrapper, the call to Semaphore.__init__ goes to our __init__, which detects the inheritance case and delegates to the original Semaphore.__init__. )_funcr3rir rjr rIcOs|r!t|dr!|jdur!|d}t||jr!|jj|i|dS|||rC|d|_|dp?t|dkr>|d|_dSd|_dS|d|_|d|_dS)Nr3roriginal_classrfunc)hasattrr3r1rXrgetlen)rUrirj first_argr'r'r(rX`s   . z_LockAllocatorWrapper.__init__r=cOs|j|i|Sr")rrlr'r'r(__call__|sz_LockAllocatorWrapper.__call__NinstanceownerOptional[type[Any]]cCs|Sr"r')rUrrr'r'r(__get__sz_LockAllocatorWrapper.__get__rCr+cCs:t|d}|durt||Stdt|jd|d)Nr3rz' object has no attribute ')object__getattribute__r0rrcr)rUrCrr'r'r(r\s  z!_LockAllocatorWrapper.__getattr__rYtype[Any] | Noner cCst|jtr |j|BStS)zCSupport PEP 604 type union syntax (e.g., asyncio.Condition | None).r1r3rcNotImplementedrZr'r'r(__or__z_LockAllocatorWrapper.__or__cCst|jtr ||jBStS)zCSupport PEP 604 type union syntax (e.g., None | asyncio.Condition).rrZr'r'r(__ror__rz_LockAllocatorWrapper.__ror__basestuple[Any, ...]tuple[type[Any], ...]cCs|jfS)aSupport subclassing the wrapped lock type (PEP 560). When custom lock types inherit from a wrapped lock (e.g. neo4j's AsyncRLock that inherits from asyncio.Lock), program error with: > TypeError: _LockAllocatorWrapper.__init__() takes 2 positional arguments but 4 were given This method returns the actual object type to be used as the base class. )r3)rUrr'r'r(__mro_entries__s z%_LockAllocatorWrapper.__mro_entries__@tuple[Callable[[str, str], Callable[..., Any]], tuple[str, str]]cCs&|jdur tdt|jj|jjffS)zSupport pickling by returning the original class. In the context of multiprocessing, the child process will get the unwrapped lock class, which will be re-wrapped if profiling is enabled there. Nz1Cannot pickle uninitialized _LockAllocatorWrapper)r3 TypeErrorr6rdrer^r'r'r(rgs z _LockAllocatorWrapper.__reduce__rrir rjr r r=r")rr rrr r2r)rYrr r )rrr r)r r) rrdrerrrXrrr\rrrrgr'r'r'r(r2Ks       r2cseZdZUdZded<ded<ded<dZd ed < d"d#fdd Zd$ddZd%ddZd&fdd Z d&fdd Z d&ddZ d&d d!Z Z S)' LockCollectorzRecord lock usage.z type[Any]PROFILED_LOCK_CLASSrMODULEr+PATCHED_LOCK_NAMENrINTERNAL_MODULE_FILEr?rFrir rjr rIcs"tj|i|||_d|_dSr")superrXr?_original_lock)rUr?rirj __class__r'r(rXs zLockCollector.__init__r-cCst|j|jSr")r0rrr^r'r'r(_get_patch_targetszLockCollector._get_patch_targetrcCst|j|j|dSr")setattrrr)rUrr'r'r(_set_patch_targetszLockCollector._set_patch_targetcs"t|tt|dS)zStart collecting lock usage.N)rinitialize_gevent_supportpatchrr_start_servicer^rr'r(rszLockCollector._start_servicecstt||dS)zStop collecting lock usage.N)rr _stop_serviceunpatchr^rr'r(rs zLockCollector._stop_servicecsT_jjdurddl}|jd fdd }t|d dS) z.Patch the module for tracking lock allocation.Nrrir rjr r=c sd}z%tdjj}r&|r&tjtj|}tjtj}||k}Wn tt t fy3Ynwj |i|j j |dS)zSimple wrapper that returns profiled locks. Detects if the lock is being created from within the stdlib module (i.e., internal to Semaphore/Condition) to avoid double-counting. Fr)rEr?r@rD)rKrLrOrSrPrQnormpathrealpathrMrOSErrorrr?_capture_sampler)rirjrDcaller_filename internal_fileinternal_module_file original_lockrUr'r(_profiled_allocate_locks" z4LockCollector.patch.._profiled_allocate_lock)rr)rrrr8__file__rr2)rUthreading_modulerr'rr(rs zLockCollector.patchcCs||jdS)z:Unpatch the threading module for tracking lock allocation.N)rrr^r'r'r(rszLockCollector.unpatchr")r?rFrir rjr r rI)r r-)rr r rIr)rrdrer__annotations__rrXrrrrrr __classcell__r'r'rr(rs    +r)r r!)r*r+r,r+r r-)r*r+r,r+r r )* __future__rrr#os.pathrPrKrqtypesrrrrtypingrr r r r "ddtrace.internal.datadog.profilingr #ddtrace.internal.settings.profilingrddtrace.profilingrrddtrace.profiling.collectorr ddtrace.tracer frozensetrrrrr)r6r<r=r2CaptureSamplerCollectorrr'r'r'r(sF                     c