jx UdZddlZddlmZmZddlmZddlmZddl 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?d e?d!e4dzd"e?dzd#e0d$df d%Z@d!e4d&eAd$dfd'ZBd!e4d$dfd(ZCd$e4fd)ZDdS)+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 ReZdZdZe d dededzdedzdeddf d ZdS) MeterProviderz_ MeterProvider is the entry point of the API. It provides access to `Meter` instances. Nnameversion schema_url attributesreturnMetercdS)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 XC:\Projects\Muse2API\.venv\Lib\site-packages\opentelemetry/metrics/_internal/__init__.py get_meterzMeterProvider.get_meter]NNN)__name__ __module__ __qualname____doc__rstrr%r3r/r5r2r'r'Xs#!%!% ! ! ! t! $J !  !  ! ! ! ^! ! ! r5r'c BeZdZdZ d dededzdedzdeddf d ZdS) NoOpMeterProviderzQThe default MeterProvider used when no MeterProvider implementation is available.Nr(r)r*r+r,r-c&t|||S)zReturns a NoOpMeter.r)r*) NoOpMeterr0s r2r3zNoOpMeterProvider.get_metersw:FFFFr5r6)r7r8r9r:r;r%r3r/r5r2r=r=s[[ #!%!% GGGtG$J G  G  GGGGGGr5r=c VeZdZd dZ d dededzdedzdeddf d Zd eddfd ZdS)_ProxyMeterProviderr,NcHt|_g|_d|_dSN)r _lock_meters_real_meter_providerr1s r2__init__z_ProxyMeterProvider.__init__s"VV *, :>!!!r5r(r)r*r+r-c|j5|j(|j|||cdddSt|||}|j||cdddS#1swxYwYdSNr?)rErGr3 _ProxyMeterrFappend)r1r(r)r*r+meters r2r3z_ProxyMeterProvider.get_metersZ  (40::4*UU         g*MMME L   & & &                   s#A2-A22A69A6meter_providerc|j5||_|jD]}|| ddddS#1swxYwYdSrD)rErGrFon_set_meter_provider)r1rOrNs r2rQz)_ProxyMeterProvider.on_set_meter_providers Z < <(6D % < <++N;;;; < < < < < < < < < < < < < < < < < < eZdZUeed<eed<eed<edzed<dS)_InstrumentRegistrationStatus instrument_idalready_registeredconflictNcurrent_advisory)r7r8r9r;__annotations__boolrr/r5r2rTrTsDNNN/$666666r5rTc eZdZdZ ddededzdedzddffd ZedefdZededzfd Zededzfd Z dded e d ed ede dzde f dZ ededed ed ede ddf dZe d ded ed edefdZe d ded ed edefdZe d!dedeedzd ed edef dZe d ddded ed edeedzdef dZ d ded ed edefdZe d!dedeedzd ed edef dZe d!dedeedzd ed ede f dZ!xZ"S)"r-zHandles instrument creation. This class provides methods for creating instruments which are then used to produce measurements. Nr(r)r*r,ct||_||_||_i|_t |_dSrD)superrI_name_version _schema_url_instrument_idsr _instrument_ids_lockr1r(r)r* __class__s r2rIzMeter.__init__sK   %LN$(FF!!!r5c|jS)z7 The name of the instrumenting module. )r^rHs r2r(z Meter.names zr5c|jS)zB The version string of the instrumenting library. )r_rHs r2r)z Meter.versions }r5c|jS)zC Specifies the Schema URL of the emitted telemetry )r`rHs r2r*zMeter.schema_urls r5type_unit descriptionadvisorycHd||j||g}d}d}d} |j5||jv}|r|j|} | |k}n ||j|<dddn #1swxYwYt |||| S)a Register an instrument with the name, type, unit and description as identifying keys and the advisory as value. Returns a tuple. The first value is the instrument id. The second value is an `_InstrumentRegistrationStatus` where `already_registered` is `True` if the instrument has been registered already. If `conflict` is set to True the `current_advisory` attribute contains the registered instrument advisory. ,FN)rUrVrWrX)joinstriplowerr7rbrarT) r1r(rhrirjrkrUrVrWrXs r2_register_instrumentzMeter._register_instruments($**,,"4"4"6"6k!Z[[ "  & ? ?!.$2F!F ! ?#'#7 #F +x76>$]3 ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?-'1-     s*BB  B instrumentation_typestatuscNtd|||||jdS)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_conflicts>  D     # r5cdS)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_counterr4r5cdS)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/rzs r2create_up_down_counterzMeter.create_up_down_counter*r4r5 callbackscdS)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_advisoryrcdS)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.tjddS)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)warningswarnrzs r2 create_gaugezMeter.create_gauges  MNNNNNr5cdS)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_gauger4r5cdS)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_counterr4r5NNrDrxrxNrxrx)#r7r8r9r:r;rIpropertyr(r)r*typerrTrq staticmethodrwrr r{rr}rr rrfloatrrrrrrrr __classcell__rds@r2r-r-sk#!% + + +t +$J +  + + + + + +cX tX  C$J   X 6: ( ( ( (  (  ( ,d2 (  '( ( ( ( T  !    .      \ $             ^               ^  15 M M M I&-M  M  M  M M M ^M ^  GK        .6e_t-C      ^ ( OOOO O  OOOO 15    I&-         ^ &15    I&-     !    ^     r5r-c eZdZ ddededzdedzddffd ZdeddfdZ dded ed edefd Z dded ed ede fd Z ddede e dzd ed ede f dZ dddded ed ede edzdef dZ dded ed edefdZ ddede e dzd ed edef dZ ddede e dzd ed edef dZxZS)rLNr(r)r*r,ct|||t|_g|_d|_dSrK)r]rIr rE _instruments _real_meterrcs r2rIz_ProxyMeter.__init__sE w:FFFVV 57)-r5rOc||j|j|j}|j5||_|jD]}|| ddddS#1swxYwYdS)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_provider!s $--dj$-IYZZ Z 4 4)D #/ 4 4 '' 3333 4  4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4s'A##A'*A'rxrirjc|j5|jr(|j|||cdddSt|||}|j||cdddS#1swxYwYdSrD)rErr{rrrMr1r(rirjproxys r2r{z_ProxyMeter.create_counter0s Z   P'66tT;OO        "$k::E   $ $U + + +                   #A1,A11A58A5c|j5|jr(|j|||cdddSt|||}|j||cdddS#1swxYwYdSrD)rErr}r"rrMrs r2r}z"_ProxyMeter.create_up_down_counter=s Z   X'>>tT;WW        (dK@@E   $ $U + + +                   rr~c|j5|jr)|j||||cdddSt||||}|j||cdddS#1swxYwYdSNrirj)rErrrrrMr1r(r~rirjrs r2rz%_ProxyMeter.create_observable_counterJsZ   f'AA$ SWYdee        ,D)$T_```E   $ $U + + +                   $A4.A44A8;A8rrc|j5|jr*|j||||cdddSt||||}|j||cdddS#1swxYwYdS)Nr)rErrrrrM)r1r(rirjrrs r2rz_ProxyMeter.create_histogramXsZ   '888[ 9        $D$ =`aaE   $ $U + + +                  s%A4-A44A8;A8c|j5|jr(|j|||cdddSt|||}|j||cdddS#1swxYwYdSrD)rErrrrrMrs r2rz_ProxyMeter.create_gaugels Z   N'44T4MM         dK88E   $ $U + + +                   rc|j5|jr)|j||||cdddSt||||}|j||cdddS#1swxYwYdSr)rErrr rrMrs r2rz#_ProxyMeter.create_observable_gaugeysZ   d'??iQUWbcc        *$ R]^^^E   $ $U + + +                   rc|j5|jr)|j||||cdddSt||||}|j||cdddS#1swxYwYdSr)rErrr!rrMrs r2rz-_ProxyMeter.create_observable_up_down_countersZ   'II         2$ ZefffE   $ $U + + +                  rrrr)r7r8r9r;rIr'rQr r{rr}rr rrrrrrrrrrrrrs@r2rLrLs#!% . . .t .$J .  . . . . . . 4M 4d 4 4 4 4$                      15   I&-         "  GK   .6e_t-C  .           15   I&-         "15 I&-    ! r5rLc HeZdZdZ ddedededefdZ ddedededefdZ ddededede fd Z dded e e d zdedede f d Z dd d dededede ed zdef dZ dded e e d zdededef dZ dded e e d zdededef dZd S)r@zeThe default Meter used when no Meter implementation is available. All operations are no-op. rxr(rirjr,c||t||}|jr#||tj|||t|||S)zReturns a no-op Counter.r)rqrrWrwr r7r1r(rirjrss r2r{zNoOpMeter.create_countersh**4dKPP ?   6 6     4d DDDDr5c||t||}|jr#||tj|||t|||S)zReturns a no-op Gauge.r)rqrrWrwrr7rs r2rzNoOpMeter.create_gaugesg**4D+NN ?   6 6    DkBBBBr5c||t||}|jr#||tj|||t|||S)zReturns a no-op UpDownCounter.r)rqrrWrwrr7rs r2r}z NoOpMeter.create_up_down_countersi**41BD+VV ?   6 6&    !DkJJJJr5Nr~c||t||}|jr#||tj|||t||||S)z"Returns a no-op ObservableCounter.r)rqrrWrwrr7r1r(r~rirjrss r2rz#NoOpMeter.create_observable_countersw**41FkZZ ?   6 6!*    %  #     r5rrc ||t||t|}|jr#||t j|||t||||S)zReturns a no-op Histogram.)explicit_bucket_boundaries)rirjr)rqrrrWrwrr7)r1r(rirjrrss r2rzNoOpMeter.create_histograms**     %Ad e e e    ?   6 6"     #0S     r5c||t||}|jr#||tj|||t||||S)z Returns a no-op ObservableGauge.r)rqrrWrwrr7rs r2rz!NoOpMeter.create_observable_gaugesw**41DdKXX ?   6 6(    #  #     r5c||t||}|jr#||tj|||t||||S)z(Returns a no-op ObservableUpDownCounter.r)rqrrWrwrr7rs r2rz+NoOpMeter.create_observable_up_down_counter'sx**41LdT_`` ?   6 6'0    +  #     r5rr)r7r8r9r:r;r r{rrrr}rr rrrrrrrrrr/r5r2r@r@s EEEE E  EEEE, CCCC C  CCCC* KKKK K  KKKK*15    I&-          6  GK        .6e_t-C       D15    I&-          615    I&-     !       r5r@_METER_PROVIDERrxr(r)rOr*r+r,cR|t}|||||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 r2r3r3Es/+--  # #D':z J JJr5logcdfd }t|}|r|stddSdSdS)Nr,c@atdSrD)r_PROXY_METER_PROVIDERrQrOsr2set_mpz#_set_meter_provider..set_mpYs$( 33NCCCCCr5z2Overriding of current MeterProvider is not allowedrR)_METER_PROVIDER_SET_ONCEdo_oncerurv)rOrrdid_sets` r2_set_meter_providerrXs~DDDDDD'..v66G N7NLMMMMMNNNNr5c(t|ddS)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_providerrfs D111111r5ct;ttvrtSt td}t |dt dtS)z8Gets the current global :class:`~.MeterProvider` object.NrOFrr')rr rrr$rr rs r2rrosW %W 4 4( ((6 &(8) )  N6666  1 11r5)rxNNN)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########$$$$$$!!!!!!JJJJJJ2*)))))888888 )H     $ $  ' ' ' ' ' C' ' ' T G G G G G G G G<<<<<-<<<8 7777777 7^ ^ ^ ^ ^ C^ ^ ^ B CCCCC%CCCLb b b b b b b b J 466(,%,,,++-- +/!! KK K K"D(Kd K  K  KKKK& N ND NT N N N N2}22222 2M 2 2 2 2 2 2r5