Bvhx lUdZddlZddlmZmZddlmZddlmZddl m Z ddl m Z ddl mZmZmZmZmZmZdd lmZdd lmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-dd l.m/Z/dd l0m1Z1dd l2m3Z3ee4Z5ee'e)e(e*e+e,e-fZ6GddeZ7Gdde7Z8Gdde7Z9eGddZ:GddeZ;Gdde;Z<Gdde;Z=e/Z>da?ee7e@d<e9ZA d(deBdeBdee7d eeBd!ee3d"df d#ZCde7d$eDd"dfd%ZEde7d"dfd&ZFd"e7fd'ZGy))a The OpenTelemetry metrics API describes the classes used to generate metrics. The :class:`.MeterProvider` provides users access to the :class:`.Meter` which in turn is used to create :class:`.Instrument` objects. The :class:`.Instrument` objects are used to record measurements. This module provides abstract (i.e. unimplemented) classes required for metrics, and a concrete no-op implementation :class:`.NoOpMeter` that allows applications to use the API package alone without a supporting implementation. To get a meter, you need to provide the package name from which you are calling the meter APIs to OpenTelemetry by calling `MeterProvider.get_meter` with the calling instrumentation name and the version of your package. The following code shows how to obtain a meter using the global :class:`.MeterProvider`:: from opentelemetry.metrics import get_meter meter = get_meter("example-meter") counter = meter.create_counter("example-counter") .. versionadded:: 1.10.0 N)ABCabstractmethod) dataclass) getLogger)environ)Lock)DictListOptionalSequenceUnioncast)OTEL_PYTHON_METER_PROVIDER) CallbackTCounterGauge Histogram NoOpCounter NoOpGauge NoOpHistogramNoOpObservableCounterNoOpObservableGaugeNoOpObservableUpDownCounterNoOpUpDownCounterObservableCounterObservableGaugeObservableUpDownCounter UpDownCounter_MetricsHistogramAdvisory _ProxyCounter _ProxyGauge_ProxyHistogram_ProxyObservableCounter_ProxyObservableGauge_ProxyObservableUpDownCounter_ProxyUpDownCounter)Once)_load_provider) Attributesc PeZdZdZe d dedeedeedeeddf d Zy) MeterProviderz_ MeterProvider is the entry point of the API. It provides access to `Meter` instances. Nnameversion schema_url attributesreturnMetercy)aDReturns a `Meter` for use by the given instrumentation library. For any two calls it is undefined whether the same or different `Meter` instances are returned, even for different library names. This function may return different `Meter` types (e.g. a no-op meter vs. a functional meter). Args: name: The name of the instrumenting module. ``__name__`` may not be used as this can result in different meter names if the meters are in different files. It is better to use a fixed string that can be imported where needed and used consistently as the name of the meter. This should *not* be the name of the module that is instrumented but the name of the module doing the instrumentation. E.g., instead of ``"requests"``, use ``"opentelemetry.instrumentation.requests"``. version: Optional. The version string of the instrumenting library. Usually this should be the same as ``importlib.metadata.version(instrumenting_library_name)``. schema_url: Optional. Specifies the Schema URL of the emitted telemetry. attributes: Optional. Attributes that are associated with the emitted telemetry. Nselfr,r-r.r/s R/RAG/venv/lib/python3.12/site-packages/opentelemetry/metrics/_internal/__init__.py get_meterzMeterProvider.get_metergNNN) __name__ __module__ __qualname____doc__rstrr r)r7r3r9r6r+r+bsc"&$(+/ ! ! #! SM ! Z( !  ! ! r9r+c FeZdZdZ d dedeedeedeeddf d Zy) NoOpMeterProviderzQThe default MeterProvider used when no MeterProvider implementation is available.Nr,r-r.r/r0r1ct|||S)zReturns a NoOpMeter.r-r.) NoOpMeterr4s r6r7zNoOpMeterProvider.get_metersw:FFr9r:)r;r<r=r>r?r r)r7r3r9r6rArAsX[ "&$(+/ GG#GSM G Z( G  Gr9rAc ZeZdZd dZ d dedeedeedeeddf d Zd eddfd Z y)_ProxyMeterProviderr0Nc>t|_g|_d|_yN)r_lock_meters_real_meter_providerr5s r6__init__z_ProxyMeterProvider.__init__sV *, =A!r9r,r-r.r/r1c|j5|j&|jj|||cdddSt|||}|jj ||cdddS#1swYyxYwNrC)rIrKr7 _ProxyMeterrJappend)r5r,r-r.r/meters r6r7z_ProxyMeterProvider.get_metershZZ((400::':Z  g*ME LL   &ZZs)A4*A44A=meter_providerc|j5||_|jD]}|j| dddy#1swYyxYwrH)rIrKrJon_set_meter_provider)r5rSrRs r6rUz)_ProxyMeterProvider.on_set_meter_providers7 ZZ(6D %++N;&ZZs *AA r0Nr:) r;r<r=rMr?r r)r7r+rUr3r9r6rFrFshB"&$(+/ #SM  Z(   ">4 E #  & &!.$2F2F!F !#'#7#7 #F +x76>$$]3'-'1-   ' &s 5BB#instrumentation_typestatuscLtjd|||||jy)NzAn instrument with name %s, type %s, unit %s and description %s has been created already with a different advisory value %s and will be used instead.)_loggerwarningr\)r,rvrmrnrws r6%_log_instrument_registration_conflictz+Meter._log_instrument_registration_conflicts-  D     # # r9cy)aRCreates a `Counter` instrument Args: name: The name of the instrument to be created unit: The unit for observations this instrument reports. For example, ``By`` for bytes. UCUM units are recommended. description: A description for this instrument and what it measures. Nr3r5r,rmrns r6create_counterzMeter.create_counter*r8r9cy)aYCreates an `UpDownCounter` instrument Args: name: The name of the instrument to be created unit: The unit for observations this instrument reports. For example, ``By`` for bytes. UCUM units are recommended. description: A description for this instrument and what it measures. Nr3r}s r6create_up_down_counterzMeter.create_up_down_counter:r8r9 callbackscy)aCreates an `ObservableCounter` instrument An observable counter observes a monotonically increasing count by calling provided callbacks which accept a :class:`~opentelemetry.metrics.CallbackOptions` and return multiple :class:`~opentelemetry.metrics.Observation`. For example, an observable counter could be used to report system CPU time periodically. Here is a basic implementation:: def cpu_time_callback(options: CallbackOptions) -> Iterable[Observation]: observations = [] with open("/proc/stat") as procstat: procstat.readline() # skip the first line for line in procstat: if not line.startswith("cpu"): break cpu, *states = line.split() observations.append(Observation(int(states[0]) // 100, {"cpu": cpu, "state": "user"})) observations.append(Observation(int(states[1]) // 100, {"cpu": cpu, "state": "nice"})) observations.append(Observation(int(states[2]) // 100, {"cpu": cpu, "state": "system"})) # ... other states return observations meter.create_observable_counter( "system.cpu.time", callbacks=[cpu_time_callback], unit="s", description="CPU time" ) To reduce memory usage, you can use generator callbacks instead of building the full list:: def cpu_time_callback(options: CallbackOptions) -> Iterable[Observation]: with open("/proc/stat") as procstat: procstat.readline() # skip the first line for line in procstat: if not line.startswith("cpu"): break cpu, *states = line.split() yield Observation(int(states[0]) // 100, {"cpu": cpu, "state": "user"}) yield Observation(int(states[1]) // 100, {"cpu": cpu, "state": "nice"}) # ... other states Alternatively, you can pass a sequence of generators directly instead of a sequence of callbacks, which each should return iterables of :class:`~opentelemetry.metrics.Observation`:: def cpu_time_callback(states_to_include: set[str]) -> Iterable[Iterable[Observation]]: # accept options sent in from OpenTelemetry options = yield while True: observations = [] with open("/proc/stat") as procstat: procstat.readline() # skip the first line for line in procstat: if not line.startswith("cpu"): break cpu, *states = line.split() if "user" in states_to_include: observations.append(Observation(int(states[0]) // 100, {"cpu": cpu, "state": "user"})) if "nice" in states_to_include: observations.append(Observation(int(states[1]) // 100, {"cpu": cpu, "state": "nice"})) # ... other states # yield the observations and receive the options for next iteration options = yield observations meter.create_observable_counter( "system.cpu.time", callbacks=[cpu_time_callback({"user", "system"})], unit="s", description="CPU time" ) The :class:`~opentelemetry.metrics.CallbackOptions` contain a timeout which the callback should respect. For example if the callback does asynchronous work, like making HTTP requests, it should respect the timeout:: def scrape_http_callback(options: CallbackOptions) -> Iterable[Observation]: r = requests.get('http://scrapethis.com', timeout=options.timeout_millis / 10**3) for value in r.json(): yield Observation(value) Args: name: The name of the instrument to be created callbacks: A sequence of callbacks that return an iterable of :class:`~opentelemetry.metrics.Observation`. Alternatively, can be a sequence of generators that each yields iterables of :class:`~opentelemetry.metrics.Observation`. unit: The unit for observations this instrument reports. For example, ``By`` for bytes. UCUM units are recommended. description: A description for this instrument and what it measures. Nr3r5r,rrmrns r6create_observable_counterzMeter.create_observable_counterJr8r9#explicit_bucket_boundaries_advisoryrcy)arCreates a :class:`~opentelemetry.metrics.Histogram` instrument Args: name: The name of the instrument to be created unit: The unit for observations this instrument reports. For example, ``By`` for bytes. UCUM units are recommended. description: A description for this instrument and what it measures. Nr3)r5r,rmrnrs r6create_histogramzMeter.create_histogramr8r9c.tjdy)aRCreates a ``Gauge`` instrument Args: name: The name of the instrument to be created unit: The unit for observations this instrument reports. For example, ``By`` for bytes. UCUM units are recommended. description: A description for this instrument and what it measures. z5create_gauge() is not implemented and will be a no-opN)warningswarnr}s r6 create_gaugezMeter.create_gauges  MNr9cy)aZCreates an `ObservableGauge` instrument Args: name: The name of the instrument to be created callbacks: A sequence of callbacks that return an iterable of :class:`~opentelemetry.metrics.Observation`. Alternatively, can be a generator that yields iterables of :class:`~opentelemetry.metrics.Observation`. unit: The unit for observations this instrument reports. For example, ``By`` for bytes. UCUM units are recommended. description: A description for this instrument and what it measures. Nr3rs r6create_observable_gaugezMeter.create_observable_gauger8r9cy)abCreates an `ObservableUpDownCounter` instrument Args: name: The name of the instrument to be created callbacks: A sequence of callbacks that return an iterable of :class:`~opentelemetry.metrics.Observation`. Alternatively, can be a generator that yields iterables of :class:`~opentelemetry.metrics.Observation`. unit: The unit for observations this instrument reports. For example, ``By`` for bytes. UCUM units are recommended. description: A description for this instrument and what it measures. Nr3rs r6!create_observable_up_down_counterz'Meter.create_observable_up_down_counterr8r9NNrHrNrr)$r;r<r=r>r?r rMpropertyr,r-r.typerrXru staticmethodr{rrr~rrr rrrfloatrrrrrrrr __classcell__rhs@r6r1r1sc"&$( + +# +SM +  +c #  HSM  9= * * *  *  * 45 *  '* X  !    .     $                        48 ^ ^ HY/0^  ^  ^  ^ ^ @  JN      .6huo-F     ( OOO O  O 48   HY/0        &48   HY/0     !   r9r1c peZdZ ddedeedeeddffd ZdeddfdZ dded ed edefd Z dded ed ede fd Z dded ee e d ed edef dZ dddded ed edee edef dZ dded ed edefdZ dded ee e d ed edef dZ dded ee e d ed edef dZxZS)rPNr,r-r.r0cdt||||t|_g|_d|_yrO)rarMrrI _instruments _real_meterrgs r6rMz_ProxyMeter.__init__s2 w:FV 57,0r9rSc|j|j|j|j}|j5||_|j D]}|j| dddy#1swYyxYw)zCalled when a real meter provider is set on the creating _ProxyMeterProvider Creates a real backing meter for this instance and notifies all created instruments so they can create real backing instruments. N)r7rbrcrdrIrr on_meter_set)r5rS real_meter instruments r6rUz!_ProxyMeter.on_set_meter_providersd $-- JJ t'7'7 ZZ)D #// '' 30 ZZs *A22A;rmrnc|j5|jr&|jj|||cdddSt|||}|jj ||cdddS#1swYyxYwrH)rIrr~r rrQr5r,rmrnproxys r6r~z_ProxyMeter.create_countersd ZZ''66tT;OZ"$k:E    $ $U + ZZ)A3)A33A<c|j5|jr&|jj|||cdddSt|||}|jj ||cdddS#1swYyxYwrH)rIrrr&rrQrs r6rz"_ProxyMeter.create_up_down_counter sg ZZ''>>$ Z (dK@E    $ $U +ZZrrc|j5|jr'|jj||||cdddSt||||}|jj ||cdddS#1swYyxYwNrmrn)rIrrr#rrQr5r,rrmrnrs r6rz%_ProxyMeter.create_observable_counter/spZZ''AA)T;Z ,id E    $ $U +ZZ*A6+A66A?rrc|j5|jr(|jj||||cdddSt||||}|jj ||cdddS#1swYyxYw)Nr)rIrrr"rrQ)r5r,rmrnrrs r6rz_ProxyMeter.create_histogramAsyZZ''888[ 9Z$dK)LE    $ $U +ZZs+A6*A66A?c|j5|jr&|jj|||cdddSt|||}|jj ||cdddS#1swYyxYwrH)rIrrr!rrQrs r6rz_ProxyMeter.create_gaugeWsd ZZ''44T4MZ dK8E    $ $U + ZZrc|j5|jr'|jj||||cdddSt||||}|jj ||cdddS#1swYyxYwr)rIrrr$rrQrs r6rz#_ProxyMeter.create_observable_gaugedspZZ''??)T;Z *id E    $ $U +ZZrc|j5|jr'|jj||||cdddSt||||}|jj ||cdddS#1swYyxYwr)rIrrr%rrQrs r6rz-_ProxyMeter.create_observable_up_down_countervssZZ''II Z2id E    $ $U +ZZrrrr)r;r<r=r?r rMr+rUrr~rrr rrrrrrrrrrrrrrs@r6rPrPs"&$( 1 1# 1SM 1  14M4d4(             $48 HY/0     *  JN   .6huo-F  2       48 HY/0     *48 HY/0    ! r9rPc .eZdZdZ ddedededefdZ ddedededefdZ ddededede fdZ dded e e e dededef d Z dd d dededed e e edef dZ dded e e e dededef dZ dded e e e dededef dZy )rDzeThe default Meter used when no Meter implementation is available. All operations are no-op. r,rmrnr0c|j|t||}|jr#|j|tj |||t|||S)zReturns a no-op Counter.r)rurr[r{rr;r5r,rmrnrws r6r~zNoOpMeter.create_countersZ** +t[  ??  6 6    4d DDr9c|j|t||}|jr#|j|tj |||t|||S)zReturns a no-op Gauge.r)rurr[r{rr;rs r6rzNoOpMeter.create_gaugesS**4D+N ??  6 6  DkBBr9c|j|t||}|jr#|j|tj |||t|||S)zReturns a no-op UpDownCounter.r)rurr[r{rr;rs r6rz NoOpMeter.create_up_down_counters[** #T;  ??  6 6&&  !DkJJr9Nrc|j|t||}|jr#|j|tj |||t||||S)z"Returns a no-op ObservableCounter.r)rurr[r{rr;r5r,rrmrnrws r6rz#NoOpMeter.create_observable_counterse** '{  ??  6 6!**  %  #   r9rrc |j|t||t|}|jr#|j |t j |||t||||S)zReturns a no-op Histogram.)explicit_bucket_boundaries)rmrnr)rurrr[r{rr;)r5r,rmrnrrws r6rzNoOpMeter.create_histogramsr**     %+N    ??  6 6""   #0S   r9c|j|t||}|jr#|j|tj |||t||||S)z Returns a no-op ObservableGauge.r)rurr[r{rr;rs r6rz!NoOpMeter.create_observable_gaugese** %t[  ??  6 6((  #  #   r9c|j|t||}|jr#|j|tj |||t||||S)z(Returns a no-op ObservableUpDownCounter.r)rurr[r{rr;rs r6rz+NoOpMeter.create_observable_up_down_counter"se** -t[  ??  6 6'00  +  #   r9rr)r;r<r=r>r?rr~rrrrr r rrrrrrrrrrr3r9r6rDrDs EEE E  E0 CCC C  C* KKK K  K.48   HY/0       :  JN      .6huo-F    H48   HY/0       :48   HY/0     !  r9rD_METER_PROVIDERr,r-rSr.r/r0cB| t}|j||||S)zReturns a `Meter` for use by the given instrumentation library. This function is a convenience wrapper for `opentelemetry.metrics.MeterProvider.get_meter`. If meter_provider is omitted the current configured one is used. )get_meter_providerr7)r,r-rSr.r/s r6r7r7Bs)+-  # #D':z JJr9logcrdfd }tj|}|r|stjdyyy)Nc4atjyrH)r_PROXY_METER_PROVIDERrUrSsr6set_mpz#_set_meter_provider..set_mpVs( 33NCr9z2Overriding of current MeterProvider is not allowedrV)_METER_PROVIDER_SET_ONCEdo_onceryrz)rSrrdid_sets` r6_set_meter_providerrUs4D'..v6G 7LMsr9ct|dy)zSets the current global :class:`~.MeterProvider` object. This can only be done once, a warning will be logged if any further attempt is made. TrN)rrs r6set_meter_providerrcs D1r9ct/ttvrtSt td}t |dt dtS)z8Gets the current global :class:`~.MeterProvider` object.rSFrr+)rrrrr(rrrs r6rrlsC %W 4( ((6 &(8)  N6  11r9)rNNN)Hr>rabcrr dataclassesrloggingrosr threadingrtypingr r r r r r#opentelemetry.environment_variablesr*opentelemetry.metrics._internal.instrumentrrrrrrrrrrrrrrrrr r!r"r#r$r%r&opentelemetry.util._oncer'opentelemetry.util._providersr(opentelemetry.util.typesr)r;ry_ProxyInstrumentTr+rArFrXr1rPrDrrr]rr?r7r^rrrr3r9r6rs"4#!>>J2*8 H ! ' C' T G G<-<< :: :s Cs l S%Sln n b 6+/-(/+- .2 $'+ K K K]+K K $ K  K& N ND NT N2}22 2M 2r9