tPjӪ ZUdZddlmZddlmZmZmZmZddlm Z ddl m Z ddl m Z m Z mZmZddlmZmZmZddlmZdd lmZdd lmZmZmZmZmZmZmZdd l Z dd l!m"Z"dd l#m$Z$ddl%m&Z&m'Z'ddl(m)Z)ddl*m+Z+ddl,m-Z-ddl.m/Z/m0Z0m1Z1m2Z2ddl3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;ddlm?Z?m@Z@ddlAmBZBddlCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKddlLmMZMddlNmOZOmPZPddlQmRZRmSZSmTZTmUZUmVZVmWZWddlXmYZYe r"ddlZm[Z[ddl\m]Z]ddl^m_Z_ddl`maZadd lbmcZcmdZdmeZed!Zfeegd"<d d d#d$d%d&ehd zd'eid zd(e9fd)Zjd*Zkeegd+<d,Zleegd-<d.ed zd(emed/fd zfd0ZnGd1d2ZoGd3d4e$Zp dCd5eeqd6d7d(d4fd8Zr dCd5eeqd9eegd fd6d7d(d4fd:ZsdDd;ZtdEd<ZudCd=eqd>eid zd(d fd?Zve d@eid(dAfdBZwy )Fz:``CustomLogger`` adapter on the OpenTelemetry span engine.) OrderedDict)CallableIteratorMappingSequence)contextmanager)datetime) TYPE_CHECKINGAnyFinalcast)Contextattach get_current)LoggerProvider)TracerProvider) INVALID_SPANLinkSpanTracerget_current_spanset_span_in_contextuse_spanN)verbose_logger) CustomLogger) SpanEmitter stamp_error)resolve_mappers)promoted_baggage)OpenTelemetryV2Config) LLMCallEventRequestIdentity auth_metadatamodel_from_request_data)GuardrailSpanDataLLMCallSpanDataMCPListToolsSpanDataMCPToolCallSpanDataServiceSpanData SpanErroris_mcp_list_toolsis_mcp_tool_call)Error)SpanRolespan_role_for_service)to_ns)is_recordable_spanmcp_message_transport_spanrequest_root_spanresolve_mcp_span_contextresolve_parent_contextresolve_request_span_contextset_request_baggageset_request_root_span)GenAIEventRecorder)GenAIMetricRecordercreate_genai_metrics)build_tracer_providerget_event_logger get_meter get_tracerresolve_logger_providerresolve_meter_provider)TenantTracerCache) MeterProvider) DualCache)UserAPIKeyAuth)ServiceLoggerPayload)CallTypesLiteral#StandardLoggingGuardrailInformationStandardLoggingPayloadlitellmLITELLM_TRACER_NAME) status_code traceback_str exceptionException | NonerLrMreturnc Rddlm}|j||}t|j dxs|j dxsd|j dxsd| t |n|j dxsd|j dxsd|j d xsd S) aaA ``SpanError`` for a proxy-level failure that never produced a ``StandardLoggingPayload`` (auth / validation / malformed-body rejections), mirroring ``_parse_error``'s field mapping so it stamps the same v2 keys a failed LLM call does. ``status_code`` pins ``error.code`` to the real response status, matching v1's SERVER-span behavior.r)StandardLoggingPayloadSetup)original_exceptionrM error_class error_codeN error_message traceback llm_provider) error_typemessagecode stack_tracerX)*litellm.litellm_core_utils.litellm_loggingrRget_error_informationr*getstr)rNrLrMrRinfos e/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/litellm/integrations/otel/logger.py_span_error_from_exceptionrcXsW-CC$#DD 88M*Ldhh|.DL)1T!,!8S txx ?U?]Y]HH[)1TXXn-5  )zlitellm.integrations.otelz"litellm.integrations.opentelemetry _OTEL_MODULESi'_OPEN_CALLS_MAXcontext.cht|j}|jr t|fSdS)zIA link back to the request trace, for a span detached into its own trace.N)rget_span_contextis_validr)rganchors rb_request_trace_linksrls,$W->>@F$ooDL?747rdc 6eZdZdZdZ d dddedzddd dfd Zy) _LLMCallSpanuCThe state carried from the ``pre_call`` boundary to span close. ``span`` is the live span when it could be opened at the boundary (the server span was ambient), or ``None`` when creation was deferred because no ambient parent was visible — in which case the async callback creates it against its own (worker-copied) ambient context using ``start_time_ns``. The presence of a carrier for a call at all is the proof that ``pre_call`` ran, i.e. that an upstream call was actually attempted. ``provider`` is the routed provider the live span was opened on (``None`` on the default route or when creation was deferred). It is held in the tenant cache while the span is open so LRU eviction can't shut the provider down under it, and must be released exactly once when the carrier is removed. )providerspan start_time_nsNrp Span | NonerqrozTracerProvider | NonerPc.||_||_||_yNrprqro)selfrprqros rb__init__z_LLMCallSpan.__init__s  *  rdrt)__name__ __module__ __qualname____doc__ __slots__intrwrdrbrnrnsB 6I -1 !!Tz!* !  !rdrnceZdZdZ dKdedzdedzdedzdedzddd ed dffd Z dLd Z dedzd d fdZ de d dfdZ dMdZdZdZdMdZdMdZdNdZdZdededzded efdZd eeefdeezdzdeezdzd efdZd eeefdeezdzdeezdzd efdZd eeefdeezdzdeezdzd edzfd Z d!ed"e!d dfd#Z"dOd%Z#d"d$d&e$deezdzdeezdzd edzf d'Z% dPd(d)d*edzdeezdzdeezdzd+e&dzd df d,Z' dQd(d)d-edzd*edzdeezdzdeezdzd+e&dzd dfd.Z(d(d)d*edzdeezdzdeezdzd+e&dzd/edzd edzfd0Z)dRd1ededzd dfd2Z*e+d3ed d4fd5Z,d1d6d7d8d9e&d:d;d e&f d<Z-d=d>d?d@dAe.d dfdBZ/ dRdCe&dDe0d1d6dEdFd df dGZ1dSdHZ2dedIeeefdzd edzfdJZ3xZ4S)TOpenTelemetryV2z'The ``CustomLogger`` for OpenTelemetry.Nconfig callback_nametracer_providerlogger_providermeter_providerMeterProvider | NonekwargsrPc 4t|di||xs tdi||_||_||nt |j|_t|j t|_ |j||_ d|_ t|j|jt|jj|j!||_t%|j|t|_t)|_|j-y)NF)mappersevent_recorderr~)superrwr rrr<_tracer_providerr?rKtracer _init_metrics_metrics_recorder_metric_filter_error_loggedrr mapper_names _init_events_emitterrB_tenant_tracersr_open_llm_calls"_init_otel_logger_on_litellm_proxy)rvrrrrrr __class__s rbrwzOpenTelemetryV2.__init__s "6"-3-V7L7Vv7V *.:O@UVZVaVa@b ))>)>@ST !%!3!3N!C+0(# KK KK#DKK$<$<=,,_=   1mM`a?J} //1rdc|jjsyt|j|}t|t}t t ||jS)aoCreate the six GenAI histograms when metrics are enabled, else ``None``. ``meter_provider`` is an explicit override (tests inject one); otherwise the provider is resolved from the OTel global so the operator's configured readers/exporters receive the metrics, building and registering one only when no global provider is set. N)renable_metricsrAr>rKr:r;r)rvrrometers rbrzOpenTelemetryV2._init_metricssJ{{))0nM +>?"#7#>@R@RSSrdzGenAIEventRecorder | Nonec|jjsyt|j|}|ytt |t S)aCreate the GenAI event recorder when events are enabled, else ``None``. ``logger_provider`` is an explicit override (tests inject one); otherwise the provider is resolved from the OTel global so an operator-configured logs pipeline receives the events, building and registering one only when no global provider is set. A ``None`` resolution means the operator opted out of the logs signal, so no recorder is built. N)r enable_eventsr@r9r=rK)rvrros rbrzOpenTelemetryV2._init_eventssA{{((1$++O  !"28=P"QRRrd callbackscPtd|D}|s|j|yy)Nc3K|]:}t|ds|jjjt<yw)rN)hasattrrry startswithre.0cbs rb z=OpenTelemetryV2._register_in_callback_list..s6" BDU\]_alUmBLL # # . .} =" s A.A)anyappend)rvr already_otels rb_register_in_callback_listz*OpenTelemetryV2._register_in_callback_lists1!" HQ"     T "rdc~ ddlm} |jtj |jtj |jtj|jtjt|ddt|d|yy#t$rYywxYw#t$rY6wxYwNr) proxy_serveropen_telemetry_logger) litellm.proxyr ExceptionrrJservice_callbackinput_callback_async_success_callback_async_failure_callbackgetattrsetattr)rvrs rbrz2OpenTelemetryV2._init_otel_logger_on_litellm_proxys  2   + +G,D,D E  + +G,B,B C  + +G,K,K L  + +G,K,K L !"2>"BC  ! !'Cnn*>:RV3 D   d-%.. Y    ( ( 8  s A6E550F%cK|j|||ry|j|||ry|j||||j||||ywrt)_emit_mcp_tool_call_emit_mcp_list_tools_close_llm_call_record_metricsrvr response_obj start_timeend_times rbasync_log_success_eventz'OpenTelemetryV2.async_log_success_event?sV  # #FJ A   $ $VZ B  VZ: V\:xHsAAc:|jfdy)z3Record the GenAI metrics for a successful LLM call.c,|jSrt)record)recorderrrrrs rbz1OpenTelemetryV2._record_metrics..IshooflT^`h.irdN)_guarded_recordrs ````rbrzOpenTelemetryV2._record_metricsGs ijrdcvtjjry|jfdy)a~Record the GenAI metrics for a failed LLM call, so the duration histogram covers the whole traffic rather than only what survived. A synthetic proxy-gate log (auth / rate-limit rejection) is skipped for the same reason it gets no span: no upstream call happened, so its duration is not a GenAI operation's duration and would pull the histogram down.Nc*|jSrt)record_failure)rrrrs rbrz9OpenTelemetryV2._record_failure_metrics..Tsh.E.EfjZb.crd)r!rrr)rvrrrs ```rb_record_failure_metricsz'OpenTelemetryV2._record_failure_metricsKs+  ! !& ) = =  cdrdc|jy ||jy#t$r8}|js"tjd|d|_Yd}~yYd}~yd}~wt $r }tj d|Yd}~yd}~wwxYw)aRun one metric recording. Best-effort: a recording failure (e.g. a malformed payload) must never break the span close or the request itself. A misconfigured attribute filter is operator-fixable, so it is surfaced once at ERROR instead of being swallowed.NzLOpenTelemetryV2: invalid otel.attributes metric filter, metrics disabled: %sTz,OpenTelemetryV2: metric recording failed: %s)r ValueErrorrrerrorrdebug)rvrexcs rbrzOpenTelemetryV2._guarded_recordVs  ! ! )  V 4)) * 833$$b4800 4  V  !OQT U U Vs " B )A B *BB cK|j|||ry|j|||ry|j||||j|||ywrt)rrrrrs rbasync_log_failure_eventz'OpenTelemetryV2.async_log_failure_eventisT  # #FJ A   $ $VZ B  VZ: $$VZBsAAidentityrrgc t||t|jjt|jjt|jj }|r t ||S|S)aSeed authenticated request-identity Baggage onto ``context`` so the Baggage processor stamps team/key/metadata onto the span. Identity is read from the parsed payload, never the client's ``params._meta`` carrier, so it can't be spoofed. promoted_keys metadata_keysteam_metadata_keysrg)rtuplerbaggage_promoted_keysbaggage_metadata_keysbaggage_team_metadata_keysr7)rvrrrgbags rb_seed_identity_baggagez&OpenTelemetryV2._seed_identity_baggageqsb &   A AB A AB$T[[%K%KL  =@"38LWLrdrrc |jd}|r&ttttt f|sytd|}t j||jj}|jjr?|j|jj|jjd|jj!|j"dt%||} t'\}} |j)|jd|} |j*j-t.j0||j2rt5t6| n| t9|t9||j2rg| xsdt;| xsdn| |j"|jj=|j>y#|jj=|j>wxYw) uEmit an MCP tool-call span when the closed request was a tool call. MCP tool calls reach the success/failure callbacks like any other request (with ``call_type`` ``call_mcp_tool``), but they are not LLM calls and have no ``pre_call`` carrier — so they get their own CLIENT span here. It nests under the transport span of the request carrying this message, and trace context the client propagated in ``params._meta`` is recorded as a span link (see ``resolve_mcp_span_context``). Returns whether it handled the event, so the caller skips the LLM-call path. The whole span is emitted at once (there is no boundary to open it at), deduped on the call id. standard_logging_objectFrIcapture_contentNr~rrq end_time_nsrrT) r_r,r rr`objectr(from_standard_logging_payloadrcapture_span_contentrr_release_carrierrpoprrrr#r4rremitr. MCP_TOOL_CALLrrrr0rlrro rvrrr raw_payloadpayloaddatarrrseededs rbrz#OpenTelemetryV2._emit_mcp_tool_calls"$ZZ(AB "24V 8Lk3Z"[6 D)GG T[[%E%E  ==  ! !$"6"6":":4==;P;PRV"W X++55dkk4W^`fIgh 9$<$> !NE 77 t^\F MM  &&MR^^ 3L& Iag#J/!(ORWR`R`N%+2N*>v*F*L"Nfk||    ( ( 8  ( ( 8 9B6G'G<c |jd}|r&ttttt f|sytd|}t j||jj}|jjr?|j|jj|jjd|jj!|j"dt%||} t'\}} |j)|jd|} |j*j-t.j0||j2rt5t6| n| t9|t9||j2rg| xsdt;| xsdn| |j"|jj=|j>y#|jj=|j>wxYw) a'Emit an MCP ``tools/list`` span when the closed request was a discovery call. Like a tool call, listing reaches the success/failure callbacks (here with ``call_type`` ``list_mcp_tools``) with no ``pre_call`` carrier, so it gets its own CLIENT span, nested under the transport span of the request carrying this message with any ``params._meta`` trace context recorded as a span link (see ``resolve_mcp_span_context``). Returns whether it handled the event so the caller skips the LLM-call path. rFrIrNr~rT) r_r+r rr`rr'rrrrrrrrrrrr#r4rrrr.MCP_LIST_TOOLSrrrr0rlrrors rbrz$OpenTelemetryV2._emit_mcp_list_toolss$ZZ(AB "3Df9M{4["\6 D*HH T[[%E%E  ==  ! !$"6"6":":4==;P;PRV"W X++55dkk4W^`fIgh 9$<$> !NE 77 t^\F MM  ''MR^^ 3L& Iag#J/!(ORWR`R`N%+2N*>v*F*L"Nfk||    ( ( 8  ( ( 8rcJtj|}|j}|r|jj |dnd}|%|j s|j r |jy |j|||||j|S#|j|wxYw)u?Finish the LLM-call span opened at ``pre_call`` (or create it deferred). No carrier for this call id means ``pre_call`` never ran — the request was rejected at the gate or blocked by a pre-call guardrail before any upstream call — so there is nothing to record and no phantom span. N) r!rrrrrupstream_startedr_finish_carrierr)rvrrrrrcarriers rbrzOpenTelemetryV2._close_llm_calls#,,V4EL--11'4@QU ? 8 8@U@UY]YeYeYm +''z8L  ! !' *D ! !' *s *BB"rr c||j|<t|jtkDr1|jjd\}}|j |yy)a5Remember an in-flight LLM call, evicting the oldest if over budget. A call that opens but never closes (a stream that only fires stream events) would linger otherwise. Eviction only drops the boundary carrier, not the call: if that call later closes as a real completed call, it still emits through the deferred branch in ``_close_llm_call`` (the same path a team/key-scoped logger uses, since it never opens a carrier), deduplicated by call id. Only a call that is evicted and never closes goes unexported. F)lastN)rlenrfpopitemr)rvrr _evicteds rbrz OpenTelemetryV2._store_open_callsW)0W% t## $ 6--5555AJAw  ! !' * 7rd_LLMCallSpan | NonecT|&|jj|jyy)z?Release the routed provider a removed carrier was holding open.N)rrro)rvr s rbrz OpenTelemetryV2._release_carriers'    ( ()9)9 : rdrc |j}|j}|^|[|jO|jj |t j |jjt|ytj||jj|j}t|}|y|jm|jj |t j |jjt j |j|||jS|jj!|j"|j$|j&} |j)|j*|j,t/} |jj1t j || j2rt5t6| n| | |j8n t||| j"| j2r t;| nd|jj=| j>S#|jj=| j>wxYw)N)r)rtime_to_first_chunk_seconds)r)rrqrrr) rrrpr mark_emittedr.rendr0r&rrrr finish_spanrrrrr#rr request_modelr6rrrrrqrlrro) rvr rrrrrrrr parent_ctxs rbr zOpenTelemetryV2._finish_carrier s ?"w||'?  **7H4E4EF   %/ :%CC  KK<<(,(H(H  #8_  7<<#; MM & &w0A0A B MM % %h&7&7tYd % e<<  ++55dkk4CVCVX\XjXjk 9 $ ; ; t113O3Q!J==%%!!QVQ_Q_ 3L* Meo8?8Kw44QVWaQb'||:?..*:6d&  ( ( 8D ( ( 8s 1B2I 'I0rrFparent_otel_spanevent_metadatac:K|j|||||dyw)Nrrrrerror_override _emit_service)rvrrrrrs rbasync_service_success_hookz*OpenTelemetryV2.async_service_success_hookDs-  -!)  src BK|j||||||xsdyw)Nrrr )rvrrrrrrs rbasync_service_failure_hookz*OpenTelemetryV2.async_service_failure_hookUs2  -!) +G  src xtj||}t|j}|y||||y|C|j7t|j|j t ||j}t|} |jj||| t|t|S)N)r)rZ) service_name call_typerr)threadedrrqr) r) from_payloadr/r&rr'r*rr5rrr0) rvrrrrrrrrolers rbr!zOpenTelemetryV2._emit_servicegs++GNS ,D,=,=> <  !j&8X=MRbRj  %$***<"!....7#22 D!7@P Q}}!!  ) +h "  rduser_api_key_dictc   tj|}t||t|jj t|jj t|jj}|rvtt|ttxs t}t|r6t||jD]\}}|j!||yyy#t"$rYywxYw)u\Attach request-identity Baggage to the current context + server span. Seeding identity into Baggage makes **every** span emitted afterwards for this request — LLM call, guardrail, DB call — inherit it via ``LiteLLMBaggageSpanProcessor``. Called once at the auth boundary (as soon as the key resolves) so post-auth spans are labeled consistently; the Baggage rides the request task's contextvar from there on. Auth-internal DB lookups that run before the key is known stay unlabeled — identity isn't determined yet, which is correct. rrN)r"from_user_api_key_authrrrrrrrr7rr3rr1r8items set_attributer)rvr,rrr server_spankeyvalues rbseed_request_identityz%OpenTelemetryV2.seed_request_identitys -DDEVWH)#DKK$E$EF#DKK$E$EF#()O)O#P C*3 FG&7%8%N U#11#u=> 3(   sC2C77 DDnamezIterator[Span]c#K|jjtj|}t |d5 | dddy#t $r)}t |rt|t|ddd}~wwxYw#1swYyxYww)NT) end_on_exitF) record_event set_status) rrr.SERVICErrr1rrc)rvr5rprs rbstart_phase_spanz OpenTelemetryV2.start_phase_spansmm..x/?/?F d -      %d+&@&ETYfkl   s98B A?A  B  A<$A77A<<A??BB rEcacherDrr'rGcFK|j|t||SwN)r)r4r$)rvr,r<rr's rbasync_pre_call_hookz#OpenTelemetryV2.async_pre_call_hooks- "" )$/ #  s!rprrrNrOrLc| t|sytjt|ddxsdv}t |t ||| y)uStamp the v2 error.* attributes on the FastAPI-owned SERVER span for a failure that dies before any LLM-call span exists (malformed body, auth / validation rejection). Called from the proxy's global exception handler via ``_close_dangling_otel_server_span``, which swallows the exception into a ``JSONResponse`` so the instrumentor never sees it and leaves the span ``UNSET``; the status is set here instead (v1 did the same from the handler) so a failed request reads as failed and not merely as a span carrying an error message. The instrumentor still owns the span's lifecycle, so this never ends it. The exception event is recorded only when nothing stamped this span already — ``async_post_call_failure_hook`` and the ``auth`` phase span record their own, and a second event would duplicate it — while the attributes are always restamped so ``error.code`` stays pinned to the real response status.N attributesr~)rL)r8)r1r-TYPErrrc)rvrprNrLalready_stampeds rbrecord_error_attributes_on_spanz/OpenTelemetryV2.record_error_attributes_on_spansL& <1$7 !&lD0Q0WUW!X  &yk J,, rd request_datarSrMz str | NonecKtxstxs |j}| t|syt |t ||yw)aDStamp error.* on the request's root SERVER span for a proxy-level failure that never reached an LLM call (empty body rejected in the endpoint, auth failure), so the failed request carries the same error keys a failed LLM call does. v1's ``OpenTelemetry`` implemented this same hook; v2 lost it when it stopped subclassing ``OpenTelemetry``, which is the LIT-4179 regression for pre-call failures. An MCP message is handled on the session's task, where the request-root anchor is whatever request opened the session, so prefer the transport the gateway published for this specific message. Without that, a failed tool call aimed its error at the ``initialize`` request's finished span and the SDK dropped it, leaving the POST that actually failed unmarked.N)rM)r2r3rr1rrc)rvrErSr,rMrps rbasync_post_call_failure_hookz,OpenTelemetryV2.async_post_call_failure_hooksL&12o6G6IoM^MoMo <1$7 D45GWdefsA A c tj|}|jjtj |t t|jt|jy)Nr)) r%from_logging_entryrrr. GUARDRAILr6r0rr)rventryrs rbemit_guardrail_spanz#OpenTelemetryV2.emit_guardrail_spansU(::5A     790dmm,  rdheaderscHt}t|syt||Srt)rr1r8)rvrrMrps rb)create_litellm_proxy_request_started_spanz9OpenTelemetryV2.create_litellm_proxy_request_started_span)s$'(!$'d# rd)NNNNN)rrrPzGenAIMetricRecorder | None)rPN)rz%Callable[[GenAIMetricRecorder], None]rPN)r rrPN)NNNN)NNNNrtrKrHrPN)5rxryrzr{r r`rrr rwrrlistrrrrrrrrr"rrrrr floatboolrrrrrnrrr!r dictr"r$r!r4rr;r?r}rDrrGrLrO __classcell__)rs@rbrrs104$(151515 2%,2Tz2($. 2 ($. 2 / 22 28 TSNT,ASFaS(#D#T# A(< |Ik eV&C M MsTz M\c Mho M,V $,u$t+,U"T) ,  ,\'V $'u$t+'U"T) '  'R+V $+u$t++U"T) +  +> + +l +t +; 59&5959u$t+ 59 U"T) 59  59|)-.2,0&*  ' + u$t+  U"T)  t    ((,.2,0&* ' Tz +  u$t+  U"T)  t    $- '- + - u$t+ - U"T) - t - d -  - h)v)cDj)\`)VS-= +    &     &     B'+ &,  $   2 ,"-4S#X->-E rdrin_memory_loggers registeredOpenTelemetryV2 | NonecL||Std|Dd}||StS)u~The single ``OpenTelemetryV2`` whose provider should become the OTel global. The callback factory designates one logger as canonical the moment it builds the first one (``_init_otel_logger_on_litellm_proxy`` sets ``proxy_server.open_telemetry_logger``), and every other v2 entry point — guardrail, identity seeding, phase spans — already routes through that same ``registered`` owner. Reuse it here too so the global provider has one source of truth instead of a second, independently-derived guess; this is the logger a preset (arize, langfuse, …) folds the ``OTEL_*`` base exporter and its own exporter into, so the FastAPI server span and the gen-ai spans share one provider and one trace. Fall back to ``in_memory_loggers`` for the SDK path, where no proxy global is set (selecting from there, not ``service_callback``, which a preset logger does not always reach), and build a generic logger from ``OTEL_*`` only when none was configured at all. Each fallback still avoids the second generic logger that orphaned the gen-ai spans onto a different backend than the server span. Nc3BK|]}t|ts|ywrt) isinstancerrs rbrz/select_global_otel_v2_logger..Ks^2j_>]B^s)nextr)rWrXexistings rbselect_global_otel_v2_loggerr_3s7,^):^`deH+8B1BBrdset_global_providercDt||}||j|S)aSelect the single v2 logger and publish its provider as the OTel global. The proxy calls this once at startup, after callbacks are initialized, so the preset logger already exists; it passes ``registered`` (the canonical owner the factory designated as ``proxy_server.open_telemetry_logger``) so the global provider reuses the same logger the rest of the v2 code emits through (see :func:`select_global_otel_v2_logger`). Both ``registered`` and ``set_global_provider`` (the proxy passes ``opentelemetry.trace.set_tracer_provider``) are injected so the publish step is unit-testable without reading or mutating real global OTel state. Returns the logger whose provider was published. )rX)r_r)rWr`rXloggers rbpublish_global_otel_v2_providerrcOs$"11BzZF//0 Mrdcp ddlm}t|dd}t |t r|SdS#t$rYywxYwr)rrrrr\r)rrbs rb_registered_v2_loggerreesC.L*A4HF86BdB s ) 55c`t}|y |j|y#t$rYywxYw)uLEmit a guardrail span on the registered v2 OTel logger. Called by the guardrail-recording code the moment a guardrail finishes, so a span is produced regardless of whether a post-call hook later runs (it does not on the pass-through allow path). Routes through the single canonical logger — the same one every other v2 entry point uses — so a guardrail recorded once yields exactly one span; fanning out across every reachable ``OpenTelemetryV2`` instance double-emits the same entry. Best-effort: span emission must never break guardrail evaluation. N)rerLr)rKrbs rbrLrLns9*+F ~ ""5)    s ! --r,rcDt}||j||yyr>)rer4)r,rrbs rbr4r4s))+F $$%6e$Drdr5zIterator[Span | None]c#Kt}|dy|j|5}|dddy#1swYyxYwwrt)rer;)r5rbrps rb phase_spanrisD)+F ~    &$ s#?3 ?<?rt)rPrYrQ)xr{ collectionsrcollections.abcrrrr contextlibrr typingr r r r opentelemetry.contextrrropentelemetry.sdk._logsropentelemetry.sdk.traceropentelemetry.tracerrrrrrrrJlitellm._loggingr"litellm.integrations.custom_loggerr!litellm.integrations.otel.emitterrr!litellm.integrations.otel.mappersr'litellm.integrations.otel.model.baggager&litellm.integrations.otel.model.configr (litellm.integrations.otel.model.metadatar!r"r#r$(litellm.integrations.otel.model.payloadsr%r&r'r(r)r*r+r,'litellm.integrations.otel.model.semconvr-%litellm.integrations.otel.model.spansr.r/%litellm.integrations.otel.model.utilsr0*litellm.integrations.otel.plumbing.contextr1r2r3r4r5r6r7r8)litellm.integrations.otel.plumbing.eventsr9*litellm.integrations.otel.plumbing.metricsr:r;,litellm.integrations.otel.plumbing.providersr<r=r>r?r@rA*litellm.integrations.otel.plumbing.routingrBopentelemetry.metricsrClitellm.caching.dual_cacherDlitellm.proxy._typesrElitellm.types.servicesrFlitellm.types.utilsrGrHrIrK__annotations__r}r`rcrerfrrlrnrrr_rcrerLr4rir~rdrbrs@#AA%22>>22+;F=DH   :Q7   II343; 'U& # $ !t:   8 u 8'D.8U495E5L8 !!:K lK `,0C'C(CC>,0'!>"2D"89) ,C (EVEC$JERVE S4rd