g/ddlmZddlZddlZddlmZddlmZddlm Z ddl m Z m Z m Z mZmZddlZddlmZmZe rdd lmZ dd Z dd ZeGd d eZedZddZddZy)) annotationsN)deque) dataclass)partial) TYPE_CHECKINGAnyCallableContextManagerTypeVar)BaseTransformer LogfireArgs)Logfirec dtjjgt|||||}t |t j sJt||dddfd }|S)a-Compile a modified AST of the module's source code in the module's namespace. Returns a function which accepts module globals and executes the compiled code. The modified AST wraps the body of every function definition in `with context_factories[index]():`. `context_factories` is added to the module's namespace as `logfire_`. `index` is a different constant number for each function definition. `context_factories[index]` is one of these: - `partial(logfire_instance._fast_span, name, attributes)` where the name and attributes are constructed from `filename`, `module_name`, attributes of `logfire_instance`, and the qualified name and line number of the current function. - `MeasureTime`, a class that measures the time elapsed. If it exceeds `min_duration`, then `context_factories[index]` is replaced with the `partial` above. If `min_duration` is greater than 0, then `context_factories[index]` is initially `MeasureTime`. Otherwise, it's initially the `partial` above. logfire_execT) dont_inheritc*|<t||yN)r)globscodecontext_factories logfire_names ]/var/www/openai/venv/lib/python3.12/site-packages/logfire/_internal/auto_trace/rewrite_ast.pyexecutezcompile_source..execute,s/l T5% )rzdict[str, Any])uuiduuid4hex rewrite_ast isinstanceastModulecompile) treefilename module_namelogfire_instance min_durationrrrrs @@@rcompile_sourcer*sm&djjl../0LAC tX|[BRTegs tD dCJJ '' ' 46 =D! Nrc t|j|j}t|||||||}|j |Sr)r_tags _sample_rateAutoTraceTransformervisit) r%r&rr'r(rr) logfire_args transformers rr r 3sM/557G7T7TUL&lHk;KM^`lK   T ""rcleZdZUdZded<ded<ded<d dZdfd Zdfd Zdfd Zdd Z xZ S)r.zUTrace all encountered functions except those explicitly marked with `@no_auto_trace`.rr('list[Callable[[], ContextManager[Any]]]rintr)c:td|jDS)zUReturn true if the node has a `@no_auto_trace` or `@logfire.no_auto_trace` decorator.c3K|]}t|tjxr|jtj k(xst|tj xrl|jtj k(xrMt|jtjxr'|jjtj k(ywr) r!r"Nameid no_auto_trace__name__ Attributeattrvaluelogfire).0nodes r z;AutoTraceTransformer.check_no_auto_trace..Ms  ,4*6GG}555tS]]3: ]%;%;;:"4::sxx8: )9)99 ,sC C)anydecorator_list)selfr@s rcheck_no_auto_tracez(AutoTraceTransformer.check_no_auto_traceKs$  ++   rcH|j|r|St| |Sr)rEsupervisit_ClassDefrDr@ __class__s rrHz#AutoTraceTransformer.visit_ClassDef[s&  # #D )Kw%d++rcH|j|r|St| |Sr)rErGvisit_FunctionDefrIs rrLz&AutoTraceTransformer.visit_FunctionDefas&  # #D )Kw(..rc>t|r|St| ||Sr) has_yieldrGrewrite_function)rDr@qualnamerJs rrOz%AutoTraceTransformer.rewrite_functiongs! T?Kw'h77rc tjtjjgj ||j jdkDrdjj}|jjjGfdd}jj|njjtjtjtjj tj"tj$tj&tj"ggS)Nrc.eZdZdZfdZfdZy)BAutoTraceTransformer.logfire_method_call_node..MeasureTimestartc|_yr)rT)_selftimers r __enter__zLAutoTraceTransformer.logfire_method_call_node..MeasureTime.__enter__s "''EKrcT|jz k\rj<yyr)rTr)rV_indexr)rD span_factoryrWs r__exit__zKAutoTraceTransformer.logfire_method_call_node..MeasureTime.__exit__s+w, <8D..u5=rN)r: __module__ __qualname__ __slots__rXr])r[r)rDr\rWsr MeasureTimerS}s# *EErra)r8ctx)r=)r=slicerb)funcargskeywords)lenrrr( _fast_spanlogfire_method_arg_valueslinenor)_configadvancedns_timestamp_generatorappendr"Call Subscriptr7logfire_method_nameLoadIndexConstant) rDr@rPconfigrar[r)r\rWs ` @@@@rlogfire_method_call_nodez-AutoTraceTransformer.logfire_method_call_nodemsD**+  ! ! , ,  + +Hdkk B    q **22FOO::E,,L E E  " " ) )+ 6  " " ) ), 7 xxhh$":": Kiicll&?@HHJ   r)r@z5ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDefreturnbool)r@z ast.ClassDef)r@&ast.FunctionDef | ast.AsyncFunctionDef)r@ryrPstrrwast.AST)r@ryrPrzrwzast.Call) r:r^r___doc____annotations__rErHrLrOrv __classcell__)rJs@rr.r.Cs1_>> , / 8 * rr.Tc|S)aDecorator to prevent a function/class from being traced by `logfire.install_auto_tracing`. This is useful for small functions that are called very frequently and would generate too much noise. The decorator is detected at import time. Only `@no_auto_trace` or `@logfire.no_auto_trace` are supported. Renaming/aliasing either the function or module won't work. Neither will calling this indirectly via another function. Any decorated function, or any function defined anywhere inside a decorated function/class, will be completely ignored by `logfire.install_auto_tracing`. This decorator simply returns the argument unchanged, so there is zero runtime overhead. )xs rr9r9s  Hrcjt|g}|r|j}tj|D]y}t |tj tj fryt |tjtjtjfri|j|{|ryy)NT) rpopleftr"iter_child_nodesr!Yield YieldFrom FunctionDefAsyncFunctionDefLambdarn)r@queuechilds rrNrNsz 4&ME }}))$/E%#))S]]!;<ecoos7K7KSZZ%XY U# 0 r) r%r{r&rzr'rzr(rr)r4rwz Callable[[dict[str, Any]], None])r%r{r&rzrrzr'rzr(rrr3r)r4rwr{)rrrwr)r@r{) __future__rr"r collectionsr dataclassesr functoolsrtypingrrr r r r> ast_utilsr rmainrr*r r.rr9rNrrrrs" !HH4  /2FM]`%B #  # # # #  # ? # #  #  S ?S  S l CL $$r