`Qjx nUdZddlZddlmZmZddlmZddlmZddl 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"e0d#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 JeZdZdZe d dededzdedzdeddf 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 m/home/oem/CyberBrain26-unified/.venv/lib/python3.12/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 @eZdZdZ d dededzdedzdeddf 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=sS[ #!%!% GGtG$J G  G  Gr5r=c TeZdZd dZ d dededzdedzdeddf 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_meterssZZ ((400::4*U   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; < < < $$]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_conflicts-  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 (  '( T  !    .     $                        15 M M I&-M  M  M  M M ^  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_provider!so $--djj$--IYIYZ ZZ 4)D #// 4 '' 3 4  4 4 4s *A22A;rirjc|j5|jr&|jj|||cdddSt|||}|jj ||cdddS#1swYyxYwrD)rErrzrrrMr1r(rirjproxys r2rzz_ProxyMeter.create_counter0sr 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_counter=sr ZZ ''>>tT;W  (dK@E    $ $U +    rr}c|j5|jr'|jj||||cdddSt||||}|jj ||cdddS#1swYyxYwNrirj)rErrrrrMr1r(r}rirjrs r2rz%_ProxyMeter.create_observable_counterJsyZZ ''AA$ SWYde  ,D)$T_`E    $ $U +    *A6+A66A?rrc|j5|jr(|jj||||cdddSt||||}|jj ||cdddS#1swYyxYw)Nr)rErrrrrM)r1r(rirjrrs r2rz_ProxyMeter.create_histogramXsZZ ''888[ 9  $D$ =`aE    $ $U +   s+A6*A66A?c|j5|jr&|jj|||cdddSt|||}|jj ||cdddS#1swYyxYwrD)rErrrrrMrs r2rz_ProxyMeter.create_gaugelsr ZZ ''44T4M   dK8E    $ $U +    rc|j5|jr'|jj||||cdddSt||||}|jj ||cdddS#1swYyxYwr)rErrr rrMrs r2rz#_ProxyMeter.create_observable_gaugeysyZZ ''??iQUWbc  *$ R]^E    $ $U +    rc|j5|jr'|jj||||cdddSt||||}|jj ||cdddS#1swYyxYwr)rErrr!rrMrs r2rz-_ProxyMeter.create_observable_up_down_counters}ZZ ''II   2$ ZefE    $ $U +   rrrr)r7r8r9r;rIr'rQr rzrr|rr rrrrrrrrrrrrrs@r2rLrLs#!% . .t .$J .  . 4M 4d 4$              15  I&-      "  GK   .6e_t-C  .       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_countersU**4dKP ??  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_countersV**41BD+V ??  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_counters`**41FkZ ??  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_histogramsp**     %Ad e   ??  6 6""   #0S   r5c|j|t||}|jr#|j|tj |||t||||S)z Returns a no-op ObservableGauge.r)rqrrWrwrr7rs r2rz!NoOpMeter.create_observable_gauges`**41DdKX ??  6 6((  #  #   r5c|j|t||}|jr#|j|tj |||t||||S)z(Returns a no-op ObservableUpDownCounter.r)rqrrWrwrr7rs r2rz+NoOpMeter.create_observable_up_down_counter'sa**41LdT_` ??  6 6'00  +  #   r5rr)r7r8r9r:r;r rzrrrr|rr rrrrrrrrrr/r5r2r@r@s EEE E  E, CCC C  C* KKK K  K*15   I&-       6  GK      .6e_t-C    D15   I&-       615   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 r2r3r3Es)+-  # #D':z JJr5logcrdfd }tj|}|r|stjdyyy)Nc4atjyrD)r_PROXY_METER_PROVIDERrQrOsr2set_mpz#_set_meter_provider..set_mpYs( 33NCr5z2Overriding of current MeterProvider is not allowedrR)_METER_PROVIDER_SET_ONCEdo_oncerurv)rOrrdid_sets` r2_set_meter_providerrXs4D'..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_providerrfs D1r5ct/ttvrtSt td}t |dt dtS)z8Gets the current global :class:`~.MeterProvider` object.rOFrr')rr rrr$rr rs r2rrosC %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<-<8 77 7^ C^ B C%CLb b J 6(,%,+- +/!! K K K"D(Kd K  K  K& N ND NT N2}22 2M 2r5