tPj5 UdZddlmZddlmZmZddlmZddlm Z ddl m Z m Z ddl mZmZmZmZmZmZddlmZeZeed <ed d Zed ed<dedd fdZd,dZedd Zeded< d-dZd.dZedd Zed ed<deddfdZ d/dZ!d,dZ"d0dZ#d1dee$e$fd e d zde fd!Z%d1d e d zde&e$e$ffd"Z'd1ded e d zde fd#Z(d1d$ed zde fd%Z)de fd&Z* d1 d2d'Z+d(ede,fd)Z-d*ee$e$fde d zfd+Z.y )3z Trace-context + Baggage helpers.)Mapping) ContextVarToken)Final)baggage)Context get_current)LinkNonRecordingSpanSpan SpanContextget_current_spanset_span_in_context)TraceContextTextMapPropagator _PROPAGATORlitellm_otel_request_root_spanN)defaultzContextVar[Span | None]_request_root_spanspanreturncFt|rtj|yy)uAnchor the request's root (server) span for explicit child parenting. No-ops for a non-recordable span so a bad capture can never replace a good one with a phantom parent. Idempotent — the proxy captures the same server span at more than one entry point. N)is_recordable_spanrsetrs o/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/litellm/integrations/otel/plumbing/context.pyset_request_root_spanr)s$t$ cHtj}t|r|SdS)zDThe anchored request root span, or ``None`` outside a proxy request.N)rgetrrs rrequest_root_spanr 4s"$((*D%d+455r&litellm_otel_mcp_message_trace_carrierz$ContextVar[Mapping[str, str] | None]_mcp_message_trace_carrierc,tj|S)zStash the current MCP message's propagated trace-context carrier. Returns the reset token; the caller must reset it once the message is handled so the carrier never leaks to the next message on the same session task. )r"r)carriers rset_mcp_message_trace_carrierr%Ds & ) )' 22rc.tj|yN)r"resettokens rreset_mcp_message_trace_carrierr+Os$$U+r'litellm_otel_mcp_message_transport_span_mcp_message_transport_spanToken[Span | None]ct|tr t|r|nd}||jr t |t j |S)uPublish the transport span of the request carrying the current MCP message. Also re-anchors the request root, so everything else the message emits or stamps — the identity attributes seeded onto the server span, a guardrail span, a proxy-level failure — lands on this request instead of on the one that opened the session. The MCP SDK dispatches each message on its own task, so the anchor is scoped to this message; the handler re-publishes it for the next one either way. Only a transport still open for writes is anchored: replacing the anchor with a request that already answered would just move the dropped writes from one finished span to another. Takes ``object`` because the gateway reads it back out of the ASGI scope, whose values are untyped; anything that is not a usable span is stored as ``None`` rather than trusted. Returns the reset token; the caller must reset it once the message is handled so the transport never leaks to the next message on the same session task. N) isinstancer r is_recordingrr-r)r transports rset_mcp_message_transport_spanr3dsG& *$5:LT:RtX\I!7!7!9i( & * *9 55rc.tj|yr')r-r(r)s r reset_mcp_message_transport_spanr5}s%%e,rcTtj}||jsy|S)uThe published transport span, only while it is still open for writes. Recording — not merely valid — is the bar here because this span is the target of ``error.*`` stamping from another task, and the publisher's validity check cannot speak for a span that has since ended. A finished span keeps a valid context forever, so it would otherwise be handed back for a write the SDK then refuses. The POST carrying a ``tools/call`` stays open until the result is written, so it is recording for the life of the call; a notification POST can answer first, and this returns ``None`` for it rather than writing into the void. N)r-rr1rs rmcp_message_transport_spanr7s*.113D |4,,. Krctj}||jSt}||jSdS)aThe transport span an MCP message span should attach to. Prefers the transport the gateway published for this specific message; falls back to the ambient request anchor for paths that emit an MCP span on the request task itself (the REST MCP endpoints). Parenting needs only the immutable context, and unlike ``mcp_message_transport_span`` it stays correct against a transport that has already finished, so this does not require the span to still be recording. N)r-rget_span_contextr ) publishedrs r_mcp_transport_span_contextr;sH3668I))++#%D&*&64 "@D@rvaluescontextc|}|jD]\}}tj|||}||S|xs tS)z6Return a context with ``values`` written into Baggage.r=)itemsr set_baggager )r<r=ctxkeyvalues rset_request_baggagerEsJ Clln; U!!#uc:;/3A(@;=Arctj|jDcic]\}}|t|c}}Scc}}w)z.All Baggage entries on ``context`` as strings.)rget_allr@str)r=rCrDs rget_baggage_attributesrIs4.5oog.F.L.L.N O UCUO OO OsAct||S)zDA context with ``span`` as the active span (for explicit parenting).r?)r)rr=s rcontext_from_spanrKs tW 55rthreadedcrt}t|r!tt|s t||}|S)uThe context a child span should parent under. Ambient-first: parent to the active OTel context (the server span, restored by the logging worker or active in the request task), falling back to a span passed explicitly (``threaded``) only when the ambient context has no recordable span — e.g. a background service call with no request on the stack. When neither is recordable the ambient context is returned unchanged, so the span starts a new root trace. Only service/DB spans pass ``threaded`` (the ``parent_otel_span`` handed to the service hook). Request-level spans — the LLM call and guardrails — are created where the server span is genuinely ambient, so they never need it. r?)r rrrK)rLrBs rresolve_parent_contextrNs3 -C(#,>?OPS?T,U#6 JrcDt}| t|StS)uThe parent context for a request-level span (the LLM call, a guardrail). These are direct children of the request's root server span — siblings of the ``auth`` phase span and of each other, never nested under whatever span is momentarily active. So prefer the explicitly anchored root span; fall back to ambient context only when there is no anchor (the SDK / no-proxy path), where the span legitimately starts its own root trace. Unlike :func:`resolve_parent_context` (used by DB/service spans, which DO want to nest under the active phase span, e.g. an auth DB lookup under ``auth``), this never returns the active span when an anchor exists. )r rKr )roots rresolve_request_span_contextrQs%$%D  && =rcZ||ntj}ttj t |xsit }t|rt|jfnd}t}| t |fStt|t |fS)uParent context + links for an MCP message span. The span always nests under the transport span of the request carrying this message, so a tool call and the ``POST`` that carried it stay in one trace. The transport comes from :func:`_mcp_transport_span_context`, which is the *current message's* POST rather than whatever request happened to open the session, so a long-lived session does not glue every message under its first request. When the client propagates W3C trace context in the request's ``params._meta`` (SEP-414), that remote context is recorded as a span *link*, never the parent. The OTel GenAI MCP semconv prefers the inverse (remote parent, transport link), but the gateway's tracing backend only ever receives the gateway's half of such a trace: parenting into the client's trace id roots the span in a trace whose root span never reaches the backend, so the span is unreachable from the trace view and the transport transaction shows a dangling link (observed with clients that propagate synthetic trace ids). Anchoring to the gateway's own request and linking the client's context keeps every trace renderable while preserving the client-side correlation. With no transport at all the span starts its own root trace, still carrying the link — the client context is only ever a link, so this event keeps one shape everywhere. Both returned contexts are built on an explicitly empty base, so ambient (stale session) state can never leak in, and the span inherits the transport's sampling decision exactly like every other request-level span — a client's sampled flag neither forces nor suppresses recording. Only trace context (``traceparent``/``tracestate``) is extracted, never the client's W3C Baggage: ``params._meta`` is caller-controlled, and the otel baggage processor stamps allowlisted baggage keys (``litellm.team.id``, ``litellm.metadata.*``, ...) onto the span as attributes, so honoring remote baggage would let a client spoof a span's identity attribution. The base context for extraction is explicitly empty so an absent or malformed ``traceparent`` can never fall through to the ambient (stale session) span. r?) r"rrrextractdictrrr r9r;rKr )r$source propagatedlinksr2s rresolve_mcp_span_contextrYsN '2G8R8V8V8XF()<)z&extract_traceparent..s?syy{m+?sN)anyr@rHrbrrT)r^rCrDr$s rextract_traceparentrfsW ?w? ?@G P*#uc#hnn&-PGP   w ''Qs$A#)rz Span | None)r$Mapping[str, str] | NonerToken[Mapping[str, str] | None])r*rhrN)r*r.rN)rzSpanContext | Noner')r$rgrz tuple[Context, tuple[Link, ...]])/__doc__collections.abcr contextvarsrrtypingr opentelemetryropentelemetry.contextrr opentelemetry.tracer r r r rr,opentelemetry.trace.propagation.tracecontextrr__annotations__rrr r"r%r+r-objectr3r5r7r;rHrErUrIrKrNrQrYboolrrfrSrrrts&#)!634 U4"8BBblp7qE34q%%%6MW,dME"HI 3 '3&3, AK-tAU#<= 664H62-"A"BS 1BGdNBV]BPGdNPd38nP 6D67T>6W6 TD[G(g(+/-T '-T'-T`,F,t,(c!2(w~(r