o i>@sddlZddlZddlmZddlmZddlmZddlmZddl m Z ddl m Z ddl m Z dd lmZdd lmZd d Zzdd lmZWn eyUdZYnwzddlmZWn eyidZYnwe eZddiZdedefddZdeeeffddZe diddZ!de"dede"e#effddZ$ddZ%d d!Z&d"d#Z'd$d%Z(d&d'Z)d(d)Z*d*d+Z+d,d-Z,d.d/Z-d0d1Z.d2d3Z/dS)4N)config)unwrap)wrap)get_argument_value) parse_version)LANGGRAPH_ASTREAM_OUTPUT)LANGGRAPH_SPAN_TRACES_ASTREAM)LangGraphIntegration)tracercCsddlm}t|ddS)Nrversion __version__) langgraphr getattrr r\/home/ubuntu/.local/lib/python3.10/site-packages/ddtrace/contrib/internal/langgraph/patch.py get_versions  rPregel) ParentCommandzlanggraph._internal._runnablezlanggraph.utils.runnable module_namereturncCs t||S)zhNormalize the module name to the original module name used for langgraph<0.6.0 to avoid breaking changes)LANGGRAPH_MODULE_MAPget)rrrr_get_module_name's rcCsddiS)Nr*rrrrr_supported_versions,srrcCs,t|dg}|r |dnd}t|dd|fS)zKGets the name of the first step in a RunnableSeq instance as the node name.stepsrNname)r)instancer first_steprrr_get_node_name3s r"argskwargscCsht|\}}|dvrd|fStrt|ts|dkr0t||ddddp#i}d|did <d|fSd|fS) a= Determines if a node should be traced. If the first step is a writing or routing step, or the node represents a subgraph, we should not trace it. If the node is a subgraph, mark it as such in the config metadata for use in `traced_pregel_loop_tick`. Returns a tuple of (should_trace, node_name) )_write_routeF LangGraphrT)optionalmetadata _dd.subgraph)r"LangGraphPregel isinstancerr)r r#r$ node_namer!rrrr_should_trace_node:s r/c Cstj}t|||\}}|s||i|S|jdt|j|jj|fdd}d}z8z ||i|}WntyN} zt dusBt | t sI|j t d} ~ wwW|j||||dd||S|j||||dd|w)a Traces an invocation of a RunnableSeq, which represents a node in a graph. It represents the sequence containing node invocation (function, graph, callable), the channel write, and then any routing logic. We utilize `instance.steps` to grab the first step as the node. One caveat is that if the node represents a subgraph (LangGraph), we should skip tracing at this step, as we will trace the graph invocation separately with `traced_pregel_stream`. %s.%s.%sTsubmit_to_llmobsNnoder#r$response operationr_datadog_integrationr/tracer __module__ __class____name__ ExceptionLangGraphParentCommandErrorr- set_exc_infosysexc_infollmobs_set_tagsfinish funcr r#r$ integration should_tracer.spanresulterrrtraced_runnable_seq_invokeLs.  rKc stj}t|||\}}|s||i|IdHS|jdt|j|jj|fdd}d}z;z ||i|IdH}WntyU} zt dusIt | t sP|j t d} ~ wwW|j||||dd||S|j||||dd|w)z,Async version of traced_runnable_seq_invoke.Nr0Tr1r3r4r7rDrrrtraced_runnable_seq_ainvokens0 rLc stjt|\}}|s|iSjdt|j|jj|fddt ddz |iWnt ySj t jdddwfdd}|S) z This function returns a generator wrapper that yields the results of RunnableSeq.astream(), ending the span after the stream is consumed, otherwise following the logic of traced_runnable_seq_ainvoke(). r0Tr1Nr3r4c sd}d}d} z*IdH}|r,z |dur|n||}Wnty+|}d}Ynw|}|VWnBtyJj|ddYdStyt}ztdusZt|tsajt jdddd}~wwq)NTFr3r4) __anext__ TypeErrorStopAsyncIterationrBrCr=r>r-r?r@rA)itemr5 add_supportedrJr#rFr$rIrHrr_astreams:   z-traced_runnable_seq_astream.._astream)rr8r/r9rr:r;r< _set_ctx_itemrr=r?r@rArBrC)rEr r#r$rGr.rSrrRrtraced_runnable_seq_astreams(  rUcsTtj}||i|IdH}|jr(t}|s|S|tpd}|r(|t||S)a  Modifies the span tracing RunnableSeq.astream() to internally include its final output, as that iterator does not yield the final output in versions >=0.3.29. Instead, the final output is aggregated and returned as a single value by _consume_aiter(). NF) rr8llmobs_enabledr current_span _get_ctx_itemrrTr)rEr r#r$rFoutputrH from_astreamrrr!traced_runnable_seq_consume_aiters r[c tjt|ddjdt|j|jjfd|dz |iWn#tyGj t j ididdd wfd d }|S) a Trace the streaming of a Pregel (CompiledGraph) instance. This operation represents the parent execution of an individual graph. This graph could be standalone, or embedded as a subgraph in a node of a larger graph. Under the hood, this graph will `tick` through until all computed tasks are completed. Calling `invoke` on a graph calls `stream` under the hood. rr'r0Tr2r Ngraphr4c 3sd} z t}|VWnYty6t|tr|dn|}jidi|ddYdStyf}z%tdusFt|tsMjt jididddd}~wwqNTrr^r4) next StopIterationr-tuplerBrCr=r>r?r@rArPr5rJr#rFr$rrIrHrr_streams@  z%traced_pregel_stream.._streamrr8rr9rr:r;r<r=r?r@rArBrC)rEr r#r$rfrrertraced_pregel_streams"   rhc r\) z&Async version of traced_pregel_stream.rr'r0Tr]Nr^r4c sd} z IdH}|VWnYty9t|tr |dn|}jidi|ddYdStyi}z%tdusIt|tsPjt jididddd}~wwqr_) rMrOr-rcrBrCr=r>r?r@rArdrerrrS$s@  z'traced_pregel_astream.._astreamrg)rEr r#r$rSrrertraced_pregel_astreams"   ricCs&tj}||i|}|||||S)N)rr8llmobs_handle_agent_manifest)rEr r#r$rFagentrrrpatched_create_react_agentEsrlc Csptj}|js ||i|St|di}||i|}t|di}t|dididd}||||||S)zPNo tracing is done, and processing only happens if LLM Observability is enabled.tasksrr*r+F)rr8rVrrllmobs_handle_pregel_loop_tick) rEr r#r$rFfinished_tasksrI next_tasksis_subgraph_noderrrpatched_pregel_loop_tickNs  rrc Csrttdd}|s ttz ddlm}t|dd}|s*t|dtt|ddWdSWdSttfy8YdSw)N_datadog_patchFrprebuiltcreate_react_agentT) rr_patch_graph_modulesrurrlsetattr ImportErrorAttributeError) graph_patchedruprebuilt_patchedrrrpatch\s    r}cCsd|_ttjd}||_ddlm}tdkr#ddlm }ddl m }n ddl m }ddl m }t|dtt|d tt|d tt|d tt|d tt|d ttd krotdkret|jjdtdSt|jjdtdSdS)NT)integration_configrrrr PregelLoop RunnableSeqinvokeainvokeastreamstreamtickr_consume_aiter)rsr rrr8langgraph.pregelrLANGGRAPH_VERSIONlanggraph.pregel.looprlanggraph.utils.runnablerlanggraph._internal._runnablelanggraph.pregel._looprrKrLrUrhrirrutilsrunnabler[ _internal _runnable)rrFrrrrrrrwrs(           rwcCsttddrldt_ddlm}ddlm}tdkr&ddlm}ddl m }n ddl m }ddl m}t |d t |d t |d t |d t |d t |d tdkrgtdkr`t tjjdnt tjjdttdttdrttjddrdtj_t |ddSdSdS)NrsFrrtrrrrrrrrrrrr8rurv)rrrsrurrrrrrrrrrrrrrdelattrhasattr)rurrrrrrunpatchs0             r)0r@rddtracerddtrace.contrib.trace_utilsrrddtrace.internal.utilsrddtrace.internal.utils.versionr&ddtrace.llmobs._integrations.constantsrr&ddtrace.llmobs._integrations.langgraphr ddtrace.tracer rrrr,rylanggraph.errorsrr>rrstrrdictr_addr"rcboolr/rKrLrUr[rhrirlrrr}rwrrrrrsR             "<:3