tPjP UdZddlmZmZddlmZmZmZmZddl m Z m Z m Z ddl mZddlmZmZddlmZddlmZmZdd lmZdd lmZdd lmZmZmZmZm Z dd l!mZ"dd l#m$Z$ddl%m&Z&m'Z'm(Z(ddl)m*Z*m+Z+m,Z,m-Z-ddl.m/Z/ddl0m1Z1m2Z2m3Z3ddl4m5Z5ddl6m7Z8ddl9m:Z:m;Z;ddlm?Z?er ddlm@Z@ddlAmBZBe?je2je?je2je?je2je?je2je?je2jiZHeeIe?e2feJd<de?de2fdZKiZLeeIeMee:ge-ffeJd<deMdee:ge-fddfd ZNGd!d"e'ZOd#eMdzdeMdzfd$ZPd%eMdzdeIeMeMffd&ZQd'ZReeJd(<d)ZSeeJd*<d+ZTeeJd,<deMded-fd.ZUd/e:de-fd0ZVd1e-d2eWdzde'fd3ZXd4e;de-fd5ZYd#eMdzdeMdzfd6ZZd4e;dd7fd8Z[d#eMdzdeMdzfd9Z\d4e;defd:Z] dOd4e;d;edzdefd<Z^ dOd4e;d=edzdedzfd>Z_dPd?ed@eMdefdAZ` dOd4e;dBdCde"fdDZa dOd4e;dEedzdefdFZbdPd?ed@eMddGfdHZcd4e;de$fdIZd dQd4e;d1e-dzdJe'dzdKeWdzde(f dLZedPd?e(d@eMde3fdMZf dOd4e;dzdege(e/ffdNZhy)Rz9Provider / exporter factory + the Baggage span processor.)CallableIterable) TYPE_CHECKINGAnyFinalLiteral)_logsbaggagemetrics) EventLogger)LoggerProviderNoOpLoggerProvider)Context) MeterProviderNoOpMeterProvider)EventLoggerProvider)r )BatchLogRecordProcessorConsoleLogExporterInMemoryLogExporter LogExporterSimpleLogRecordProcessor)r)Resource) ReadableSpan SpanProcessorTracerProvider)BatchSpanProcessorConsoleSpanExporterSimpleSpanProcessor SpanExporter)InMemorySpanExporter)SpanSpanKindTracer)parse_env_headers)version) ExporterSpecOpenTelemetryV2Config)LiteLLM)LiteLLMSpanKind)Meter) MetricReader_SPAN_KIND_BY_ROLE_KINDkindreturnct|SN)r,)r-s q/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/litellm/integrations/otel/plumbing/providers.pyto_otel_span_kindr25s "4 ((_EXPORTER_FACTORIESfactoryNc2|t|j<y)zARegister a custom exporter ``factory`` for the exporter ``kind``.N)r4lower)r-r5s r1register_exporter_factoryr8Bs(/ %r3ceZdZdZej ffdeedeedfddfdZ dede fd Z dd e d e dzddfd Zd eddfd ZddZddede fdZy)LiteLLMBaggageSpanProcessorzFStamps an allowlisted set of Baggage entries onto every span at start. allowed_keysallowed_prefixes.r.NcDt||_t||_yr0) frozenset _allowed_keystuple_allowed_prefixes)selfr;r<s r1__init__z$LiteLLMBaggageSpanProcessor.__init__Js '|4!&'7!8r3keyc`|jvxstfd|jDS)Nc3@K|]}j|ywr0) startswith).0prefixrDs r1 z:LiteLLMBaggageSpanProcessor._is_allowed..Ss/l6v0F/ls)r?anyrA)rBrDs `r1 _is_allowedz'LiteLLMBaggageSpanProcessor._is_allowedRs+d(((lC/lUYUkUk/l,llr3spanparent_contextctj|jD]J\}}|j|st |t t ttfs9|j||Lyr0) r get_allitemsrL isinstancestrboolintfloat set_attribute)rBrMrNrDvalues r1on_startz$LiteLLMBaggageSpanProcessor.on_startUsW!//.9??A /JC$ECsE;R)S""3. /r3cyr0)rBrMs r1on_endz"LiteLLMBaggageSpanProcessor.on_endZr3cyr0r[)rBs r1shutdownz$LiteLLMBaggageSpanProcessor.shutdown]r]r3timeout_milliscy)NTr[)rBr`s r1 force_flushz'LiteLLMBaggageSpanProcessor.force_flush`r]r3r0)r.N)i0u)__name__ __module__ __qualname____doc__r(METADATA_PREFIXrrSr@rCrTrLr!rrYrr\r_rUrbr[r3r1r:r:GsP .5-D-D,F9sm9 S/9  9msmtm/T/7T>/T/ <D#$r3r:endpointc|s|S|jd}|jdsd|vr|SdD]'}|j|s|dt| dzcS|dzS)aPoint an OTLP/HTTP base endpoint at the ``/v1/traces`` signal path. ``OTEL_EXPORTER_OTLP_ENDPOINT`` is a base URL (e.g. ``http://host:4318``). The OTLP/HTTP exporter only appends the ``/v1/traces`` path when it reads that env var itself; when an endpoint is passed explicitly it is used verbatim, so a base URL would POST to the root and the collector returns 404. Append the signal path here (leaving an already-correct path intact). / /v1/tracesz/v2/trace/otlp)/v1/logs /v1/metricsNrstripendswithlenrh other_signals r1_otlp_traces_endpointrtds| s#H&*:h*F3A   \ *0s<001L@ @A l ""r3rawc6|siStt|dS)aParse an OTLP ``"k=v,k=v"`` header string into a dict. ``OTEL_EXPORTER_OTLP_HEADERS`` is W3C Baggage encoded per the OTLP spec, so values are percent-decoded: a vendor that documents ``Authorization=Basic%20`` (Grafana Cloud does, because a bare space is not representable there) has to reach the exporter as ``Basic ``, not with a literal ``%20`` that the backend rejects as malformed. The SDK's own parser is used so litellm decodes exactly what the OTLP exporters do when they read the env var themselves; ``liberal`` keeps values that are not percent-encoded (``Authorization=Bearer ``) working unchanged. T)liberal)dictr$)rus r1 parse_headersryys  !#t4 55r3 in_memoryinmemorymemory_IN_MEMORY_KINDS otlp_httphttpz http/protobufz http/json_OTLP_HTTP_KINDS otlp_grpcgrpc_OTLP_GRPC_KINDS)rr headerlesscX|j}|tvs|tvry|tvryy)aHow an exporter of this ``kind`` carries credentials, per ``_exporter_from_spec``. ``http``/``grpc`` exporters (and any registered factory, which builds an OTLP exporter) stamp ``spec.headers``; ``console``, ``in_memory``, and any unrecognized kind (which falls back to a header-ignoring console exporter) are ``headerless``. Routability decisions must read this rather than a denylist, so a typo'd or unavailable kind is not mistaken for OTLP. rrr)r7rr4r)r-resolveds r1exporter_transportrs2jjlH##x3F'F## r3specc|jxsdj}tj|}|||S|tvr t S|t vr6ddlm}|t|jt|jS|tvr-ddlm}||jt|jStS)Nconsoler)OTLPSpanExporterrhheaders)r-r7r4getr~r r5opentelemetry.exporter.otlp.proto.http.trace_exporterrrtrhryrr5opentelemetry.exporter.otlp.proto.grpc.trace_exporterr)rr-r5 HTTPExporter GRPCExporters r1_exporter_from_specrs99) 002D(,,T2Gt} #%%  *4==9!$,,/    T]]M$,,@T*UV ,6 x (X >? j  r3c|jxsdj}|dvr tS|dvr6ddlm}|t |j t|jS|dvr. ddl m}||j t|jStS#t$r}td|d }~wwxYw) aBuild a log exporter mirroring the exporter selection of the other signals. ``console`` (and any unrecognized kind) exports to the console; ``otlp_http`` and ``otlp_grpc`` export over OTLP with the configured endpoint/headers; ``in_memory`` buffers for tests. Like GenAI metrics, events ride the single-destination shorthand fields, not the multi-exporter ``exporters`` list. rrzrr)OTLPLogExporterrrzOpenTelemetry OTLP gRPC log exporter is not available. Install `opentelemetry-exporter-otlp` and `grpcio` (or `litellm[grpc]`).N) rr7r4opentelemetry.exporter.otlp.proto.http._log_exporterrrrhryr4opentelemetry.exporter.otlp.proto.grpc._log_exporterrr)rr-HTTPLogExporterGRPCLogExporterrs r1build_log_exporterr's??/i668D 22"$$ BB (9!&..1   $$  v~~A^__   S  s,B## B=, B88B= log_exporterc||n t|}tt|}t|tt f}|j |rt||St||S)uBuild the :class:`LoggerProvider` GenAI events export through. ``log_exporter`` is an explicit override (tests inject an ``InMemoryLogExporter``); otherwise the exporter is selected from the config's exporter kind via :func:`build_log_exporter`. Console and in-memory exporters get a Simple processor (synchronous export, which tests rely on), everything else a Batch processor — the same split as span processing. resource) rSDKLoggerProviderbuild_resourcerRrradd_log_record_processorrr)rrrproviderrs r1build_logger_providerrJsq'3&>lDVW]D^H'1GHH"8.@BU-VWJ %%.8 * O?VV^>_ Or3logger_providerc||Stj}t|tr|St|tryt |}tj ||S)aResolve the :class:`LoggerProvider` GenAI events record through, or ``None`` when the operator has opted out of the logs signal. Same resolution order as :func:`resolve_meter_provider`: an injected provider wins (DI/tests); an operator-configured SDK global is reused so events ride their pipeline; an explicit ``NoOpLoggerProvider`` global is an opt-out and yields ``None``, so no event is ever built. Only the default placeholder global makes V2 build a provider from the config and publish it as the global. N)r get_logger_providerrRrrrset_logger_provider)rrexistingrs r1resolve_logger_providerr_sY"&+&?&?&AH(-.(./+F3H h' Or3rnamecBt|j|tS)N)r)rget_event_loggerlitellm_versionrrs r1rrzs x 8 I I$P_ ``r3 metric_readerzMetricReader | NonecN||n t|}t|gt|S)zBuild the :class:`MeterProvider` for GenAI metrics. ``metric_reader`` is an explicit override (tests inject an ``InMemoryMetricReader``); otherwise the reader is selected from the config's exporter kind via :func:`build_metric_reader`. )metric_readersr)rSDKMeterProviderr)rrreaders r1build_meter_providerr~s+&3%>MDWX^D_F F8nV>T UUr3meter_providerc||Stj}t|ttfr|St |}tj ||S)aqResolve the :class:`MeterProvider` GenAI metrics record through. An injected provider wins (DI/tests). Otherwise reuse whatever the operator has configured as the global, whether a real SDK provider or an explicit ``NoOpMeterProvider``, so the GenAI histograms ride the operator's readers/exporters and an explicit opt-out is honored. Only when the global is still the default proxy placeholder does V2 build one from the config and publish it as the global, mirroring how V2 owns trace export. The built provider is the one returned, so its reader thread is always live, never orphaned. )r get_meter_providerrRrrrset_meter_provider)rrrrs r1resolve_meter_providerrsQ!002H(-/@AB*62H x( Or3r*c.|j|tSr0) get_meterrrs r1rrs   dO 44r3cd|ji}|jr|j|d<|j|jt j |S)Nz service.namezdeployment.environment) service_namedeployment_environmentupdateresource_attributesrcreate)r attributess r1rrsO)79L9L(MJ $$/5/L/L +,f001 ??: &&r3baggage_processoruse_simple_processorctt|}|t|j}|j |||j t |||S|j D]Y}|jr |jst|}|j t ||j |jn|[|S)uBuild the shared :class:`TracerProvider`. Attach the Baggage processor first (so identity attributes land on each span before any export decision), then add one ``SpanProcessor`` per ``config.exporters`` entry — this is what fans spans out to multiple backends. ``exporter`` and ``use_simple_processor`` are explicit overrides: pass a single exporter to attach exactly that one (used by tests). r)r;) rrr:baggage_promoted_keysadd_span_processorr exportersrequires_headersrrr)rrrrrrexps r1build_tracer_providerrs%nV.DEH 7VEaEab  12##N8=Q$RS      !$'## .2.G.G.S**Ym    Or3c.|j|tSr0) get_tracerrrs r1rrs   t_ 55r3cX|xs td}t}t||}||fS)zCConvenience for tests: a provider exporting to an in-memory buffer.r{)r)r'r r)rcfgrrs r1in_memory_providerrs3F0+FC*,H+C(CH X r3r0)litellm)NNN)irfcollections.abcrrtypingrrrr opentelemetryr r r opentelemetry._eventsr opentelemetry._logsr ropentelemetry.contextropentelemetry.metricsrropentelemetry.sdk._eventsropentelemetry.sdk._logsropentelemetry.sdk._logs.exportrrrrropentelemetry.sdk.metricsropentelemetry.sdk.resourcesropentelemetry.sdk.tracerrropentelemetry.sdk.trace.exportrrrr6opentelemetry.sdk.trace.export.in_memory_span_exporterr opentelemetry.tracer!r"r#opentelemetry.util.rer$litellm._versionr%r&litellm.integrations.otel.model.configr&r''litellm.integrations.otel.model.semconvr(%litellm.integrations.otel.model.spansr)r*rr+SERVERCLIENTINTERNALPRODUCERCONSUMERr,rx__annotations__r2r4rSr8r:rtryr~rrrrrTrrrrrrrrrrrrrrrr@rr[r3r1rs?.5511-B)B9GH0OO 7637V;A+=HOOHOOh//h//h// CtOX$=>?)O))QSU4X|nl.J%K KLMR0C0(L><;W2X0]a0 -:#C$J#3:#*6sTz6d38n6">%=M%M/%/SW-I%J"!l!|!2 Y\ Ytd{ Y} Yu 5u,u$S4Z$C$J$&/P 5/P./Pd!#*!t!&  4    J(, !$.15 !&-6a0aaKa ,0 V ! V( V V ,0 !!D(65 5S55'0'X'%).2(, # !#T!#%t+#+ #  #L66s666,0 !D ( >/ /0r3