osju tUdZddlZddlmZmZddlmZddlmZddl m Z ddl m Z ddl mZdd lmZdd lmZdd lmZmZmZmZmZmZmZmZmZmZmZmZm 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 l-m.Z.ddl/m0Z0e e1Z2e$e&ze%ze'ze(ze)ze*zZ3GddeZ4Gdde4Z5Gdde4Z6eGddZ7GddeZ8Gdde8Z9Gdde8Z:e,Z;da d)de?de?d e4dzd!e?dzd"e0dzd#df d$Z@d e4d%eAd#dfd&ZBd e4d#dfd'ZCd#e4fd(ZDy)*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)Sequence) dataclass) getLogger)environ)Lock)cast)OTEL_PYTHON_METER_PROVIDER) CallbackTCounterGauge Histogram NoOpCounter NoOpGauge NoOpHistogramNoOpObservableCounterNoOpObservableGaugeNoOpObservableUpDownCounterNoOpUpDownCounterObservableCounterObservableGaugeObservableUpDownCounter UpDownCounter_MetricsHistogramAdvisory _ProxyCounter _ProxyGauge_ProxyHistogram_ProxyObservableCounter_ProxyObservableGauge_ProxyObservableUpDownCounter_ProxyUpDownCounter)Once)_load_provider) Attributesc PeZdZdZe d dededzdedzdedzddf d Zy) MeterProviderz_ MeterProvider is the entry point of the API. It provides access to `Meter` instances. Nnameversion schema_url attributesreturnMetercy)aFReturns 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__`` should be avoided 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 [/root/.hermes/venv/lib/python3.12/site-packages/opentelemetry/metrics/_internal/__init__.py get_meterzMeterProvider.get_meter]NNN)__name__ __module__ __qualname____doc__rstrr%r3r/r5r2r'r'Xsc#!%(, ! ! t! $J ! % !  ! ! r5r'c FeZdZdZ d dededzdedzdedzddf d Zy) NoOpMeterProviderzQThe default MeterProvider used when no MeterProvider implementation is available.Nr(r)r*r+r,r-ct|||S)zReturns a NoOpMeter.r)r*) NoOpMeterr0s r2r3zNoOpMeterProvider.get_metersw:FFr5r6)r7r8r9r:r;r%r3r/r5r2r=r=sX[ #!%(, GGtG$J G % G  Gr5r=c ZeZdZd dZ d dededzdedzdedzddf d Zd eddfd Zy)_ProxyMeterProviderr,Nc>t|_g|_d|_yN)r _lock_meters_real_meter_providerr1s r2__init__z_ProxyMeterProvider.__init__sV *, :>!r5r(r)r*r+r-c|j5|j&|jj|||cdddSt|||}|jj ||cdddS#1swYyxYwNr?)rErGr3 _ProxyMeterrFappend)r1r(r)r*r+meters r2r3z_ProxyMeterProvider.get_metersvZZ ((400::':    g*ME LL   &   s)A4*A44A=meter_providerc|j5||_|jD]}|j| dddy#1swYyxYwrD)rErGrFon_set_meter_provider)r1rOrNs r2rQz)_ProxyMeterProvider.on_set_meter_providersG ZZ <(6D % <++N; < < < >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.)_loggerwarningrX)r(rrrirjrss r2%_log_instrument_registration_conflictz+Meter._log_instrument_registration_conflict s-  D     # # r5cy)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. Nr/r1r(rirjs r2create_counterzMeter.create_counterr4r5cy)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. Nr/rys r2create_up_down_counterzMeter.create_up_down_counter.r4r5 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. Nr/r1r(r}rirjs r2create_observable_counterzMeter.create_observable_counter>r4r5#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. Nr/)r1r(rirjrs r2create_histogramzMeter.create_histogramr4r5c.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)warningswarnrys r2 create_gaugezMeter.create_gauges  MNr5cy)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. Nr/rs r2create_observable_gaugezMeter.create_observable_gauger4r5cy)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. Nr/rs r2!create_observable_up_down_counterz'Meter.create_observable_up_down_counterr4r5NNrDrNrr)#r7r8r9r:r;rIpropertyr(r)r*typerrTrq staticmethodrwrr rzrr|rr rrfloatrrrrrrrr __classcell__rds@r2r-r-sb#!% + +t +$J +  +c t  C$J  6: * * *  *  * ,d2 *  '* X  !    .     $                        15 ^ ^ I&-^  ^  ^  ^ ^ @  GK      .6e_t-C     ( OOO O  O 15   I&-        &15   I&-     !   r5r-c peZdZ ddededzdedzddffd ZdeddfdZ dded ed edefd Z dded ed ede fd Z dded e e dzd ed ede f dZ dddded ed ede edzdef dZ dded ed edefdZ dded e e dzd ed edef dZ dded e e dzd ed edef dZxZS)rLNr(r)r*r,cdt||||t|_g|_d|_yrK)r]rIr rE _instruments _real_meterrcs r2rIz_ProxyMeter.__init__s2 w:FV 57)-r5rOc|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)r3r^r_r`rErr on_meter_set)r1rO real_meter instruments r2rQz!_ProxyMeter.on_set_meter_providerst $-- JJ t'7'7 ZZ 4)D #// 4 '' 3 4  4 4 4s *A22A;rirjc|j5|jr&|jj|||cdddSt|||}|jj ||cdddS#1swYyxYwrD)rErrzrrrMr1r(rirjproxys r2rzz_ProxyMeter.create_countersr ZZ ''66tT;O  "$k:E    $ $U +    )A3)A33A<c|j5|jr&|jj|||cdddSt|||}|jj ||cdddS#1swYyxYwrD)rErr|r"rrMrs r2r|z"_ProxyMeter.create_up_down_countersu ZZ ''>>$    (dK@E    $ $U +   rr}c|j5|jr'|jj||||cdddSt||||}|jj ||cdddS#1swYyxYwNrirj)rErrrrrMr1r(r}rirjrs r2rz%_ProxyMeter.create_observable_counter#s~ZZ ''AA)T;   ,id E    $ $U +   *A6+A66A?rrc|j5|jr(|jj||||cdddSt||||}|jj ||cdddS#1swYyxYw)Nr)rErrrrrM)r1r(rirjrrs r2rz_ProxyMeter.create_histogram5sZZ ''888[ 9  $dK)LE    $ $U +   s+A6*A66A?c|j5|jr&|jj|||cdddSt|||}|jj ||cdddS#1swYyxYwrD)rErrrrrMrs r2rz_ProxyMeter.create_gaugeKsr ZZ ''44T4M   dK8E    $ $U +    rc|j5|jr'|jj||||cdddSt||||}|jj ||cdddS#1swYyxYwr)rErrr rrMrs r2rz#_ProxyMeter.create_observable_gaugeXs~ZZ ''??)T;   *id E    $ $U +   rc|j5|jr'|jj||||cdddSt||||}|jj ||cdddS#1swYyxYwr)rErrr!rrMrs r2rz-_ProxyMeter.create_observable_up_down_counterjsZZ ''II   2id E    $ $U +   rrrr)r7r8r9r;rIr'rQr rzrr|rr rrrrrrrrrrrrrs@r2rLrLs#!% . .t .$J .  .4M4d4(             $15 I&-     *  GK   .6e_t-C  2       15 I&-     *15 I&-    ! r5rLc .eZdZdZ ddedededefdZ ddedededefdZ ddededede fdZ dded e e d zdedede f d Z dd d dededed e ed zdef dZ dded e e d zdededef dZ dded e e d zdededef dZy )r@zeThe default Meter used when no Meter implementation is available. All operations are no-op. r(rirjr,c|j|t||}|jr#|j|tj |||t|||S)zReturns a no-op Counter.r)rqrrWrwr r7r1r(rirjrss r2rzzNoOpMeter.create_countersZ** +t[  ??  6 6    4d DDr5c|j|t||}|jr#|j|tj |||t|||S)zReturns a no-op Gauge.r)rqrrWrwrr7rs r2rzNoOpMeter.create_gaugesS**4D+N ??  6 6  DkBBr5c|j|t||}|jr#|j|tj |||t|||S)zReturns a no-op UpDownCounter.r)rqrrWrwrr7rs r2r|z NoOpMeter.create_up_down_counters[** #T;  ??  6 6&&  !DkJJr5Nr}c|j|t||}|jr#|j|tj |||t||||S)z"Returns a no-op ObservableCounter.r)rqrrWrwrr7r1r(r}rirjrss r2rz#NoOpMeter.create_observable_counterse** '{  ??  6 6!**  %  #   r5rrc |j|t||t|}|jr#|j |t j |||t||||S)zReturns a no-op Histogram.)explicit_bucket_boundaries)rirjr)rqrrrWrwrr7)r1r(rirjrrss r2rzNoOpMeter.create_histogramsr**     %+N    ??  6 6""   #0S   r5c|j|t||}|jr#|j|tj |||t||||S)z Returns a no-op ObservableGauge.r)rqrrWrwrr7rs r2rz!NoOpMeter.create_observable_gaugese** %t[  ??  6 6((  #  #   r5c|j|t||}|jr#|j|tj |||t||||S)z(Returns a no-op ObservableUpDownCounter.r)rqrrWrwrr7rs r2rz+NoOpMeter.create_observable_up_down_counterse** -t[  ??  6 6'00  +  #   r5rr)r7r8r9r:r;r rzrrrr|rr rrrrrrrrrr/r5r2r@r@s EEE E  E0 CCC C  C* KKK K  K.15   I&-       :  GK      .6e_t-C    H15   I&-       :15   I&-     !  r5r@_METER_PROVIDERr(r)rOr*r+r,cB| 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_providerr3)r(r)rOr*r+s r2r3r36s)+-  # #D':z JJr5logcrdfd }tj|}|r|stjdyyy)Nc4atjyrD)r_PROXY_METER_PROVIDERrQrOsr2set_mpz#_set_meter_provider..set_mpJs( 33NCr5z2Overriding of current MeterProvider is not allowedrR)_METER_PROVIDER_SET_ONCEdo_oncerurv)rOrrdid_sets` r2_set_meter_providerrIs4D'..v6G 7LMsr5ct|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 r2set_meter_providerrWs D1r5ct/ttvrtSt td}t |dt dtS)z8Gets the current global :class:`~.MeterProvider` object.rOFrr')rr rrr$rr rs r2rr`sC %W 4( ((6 &(8)  N6  11r5)rNNN)Er:rabcrrcollections.abcr dataclassesrloggingrosr threadingr typingr #opentelemetry.environment_variablesr *opentelemetry.metrics._internal.instrumentr r rrrrrrrrrrrrrrrrrrr r!r"opentelemetry.util._oncer#opentelemetry.util._providersr$opentelemetry.util.typesr%r7ru_ProxyInstrumentTr'r=rBrTr-rLr@rrrYrr;r3rZrrrr/r5r2rs 4#$!J2*8 H    $ $  ' C' T G G<-<< 77 7q Cq h S%Sln n b 6(,%,+- +/!$( K K K"D(Kd K T! K  K& N ND NT N2}22 2M 2r5