go 6UdZddlZddlmZmZddlmZddlmZddl m Z ddl m Z m Z mZmZmZmZmZddlmZdd lmZmZmZmZmZmZmZmZmZmZm 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 l.m/Z/dd l0m1Z1ee2Z3ee%e'e&e(e)e*e+fZ4Gd deZ5Gdde5Z6Gdde5Z7GddeZ8Gdde8Z9Gdde8Z:e-Z;da d$de?de?de e5de e?ddf dZ@de5d eAddfd!ZBde5ddfd"ZCde5fd#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) getLogger)environ)Lock)ListOptionalSequenceSetTupleUnioncast)OTEL_PYTHON_METER_PROVIDER) CallbackTCounterGauge Histogram NoOpCounter NoOpGauge NoOpHistogramNoOpObservableCounterNoOpObservableGaugeNoOpObservableUpDownCounterNoOpUpDownCounterObservableCounterObservableGaugeObservableUpDownCounter UpDownCounter _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 ]/var/www/openai/venv/lib/python3.12/site-packages/opentelemetry/metrics/_internal/__init__.py get_meterzMeterProvider.get_metercNNN) __name__ __module__ __qualname____doc__rstrr r(r6r2r8r5r*r*^sc"&$(+/ ! ! #! SM ! Z( !  ! ! r8r*c FeZdZdZ d dedeedeedeeddf d Zy) NoOpMeterProviderzQThe default MeterProvider used when no MeterProvider implementation is available.Nr+r,r-r.r/r0ct|||S)zReturns a NoOpMeter.r,r-) NoOpMeterr3s r5r6zNoOpMeterProvider.get_metersw:FFr8r9)r:r;r<r=r>r r(r6r2r8r5r@r@sX[ "&$(+/ GG#GSM G Z( G  Gr8r@c ZeZdZd dZ d dedeedeedeeddf d Zd eddfd Z y)_ProxyMeterProviderr/Nc>t|_g|_d|_yN)r_lock_meters_real_meter_providerr4s r5__init__z_ProxyMeterProvider.__init__sV *, =A!r8r+r,r-r.r0c|j5|j&|jj|||cdddSt|||}|jj ||cdddS#1swYyxYwNrB)rHrJr6 _ProxyMeterrIappend)r4r+r,r-r.meters r5r6z_ProxyMeterProvider.get_metershZZ((400::':Z  g*ME LL   &ZZs)A4*A44A=meter_providerc|j5||_|jD]}|j| dddy#1swYyxYwrG)rHrJrIon_set_meter_provider)r4rRrQs r5rTz)_ProxyMeterProvider.on_set_meter_providers7 ZZ(6D %++N;&ZZs *AA r/Nr9) r:r;r<rLr>r r(r6r*rTr2r8r5rErEshB"&$(+/ #SM  Z(   ">4 E   & & 4 44$$((7 '  && '  &&s -BBcy)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. Nr2r4r+rerfs r5create_counterzMeter.create_counterr7r8cy)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. Nr2rqs r5create_up_down_counterzMeter.create_up_down_counterr7r8 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. Nr2r4r+rurerfs r5create_observable_counterzMeter.create_observable_counterr7r8cy)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. Nr2rqs r5create_histogramzMeter.create_histogramxr7r8c.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)warningswarnrqs r5 create_gaugezMeter.create_gauges  MNr8cy)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. Nr2rws r5create_observable_gaugezMeter.create_observable_gauger7r8cy)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. Nr2rws r5!create_observable_up_down_counterz'Meter.create_observable_up_down_counterr7r8NNrNrr)!r:r;r<r=r>r rLpropertyr+r,r-typer boolrorrrrrrtr rrrxrrzrr~rrrr __classcell__r`s@r5r0r0s"&$( + +# +SM +  +c #  HSM  '' $',/'>A' tSy '4                        48 ^ ^ HY/0^  ^  ^  ^ ^ @            $ OOO O  O 48   HY/0        &48   HY/0     !   r8r0c ZeZdZ ddedeedeeddffd ZdeddfdZ dded ed edefd Z dded ed ede fd Z dded ee e d ed edef dZ dded ed edefdZ dded ed edefdZ dded ee e d ed edef dZ dded ee e d ed edef dZxZS)rONr+r,r-r/cdt||||t|_g|_d|_yrN)rXrLrrH _instruments _real_meterr_s r5rLz_ProxyMeter.__init__s2 w:FV 57,0r8rRc|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)r6rYrZr[rHrr on_meter_set)r4rR real_meter instruments r5rTz!_ProxyMeter.on_set_meter_providersd $-- JJ t'7'7 ZZ)D #// '' 30 ZZs *A22A;rerfc|j5|jr&|jj|||cdddSt|||}|jj ||cdddS#1swYyxYwrG)rHrrrrrrPr4r+rerfproxys r5rrz_ProxyMeter.create_countersd ZZ''66tT;OZ"$k:E    $ $U + ZZ)A3)A33A<c|j5|jr&|jj|||cdddSt|||}|jj ||cdddS#1swYyxYwrG)rHrrtr%rrPrs r5rtz"_ProxyMeter.create_up_down_countersg ZZ''>>$ Z (dK@E    $ $U +ZZrruc|j5|jr'|jj||||cdddSt||||}|jj ||cdddS#1swYyxYwNrerf)rHrrxr"rrPr4r+rurerfrs r5rxz%_ProxyMeter.create_observable_counterspZZ''AA)T;Z ,id E    $ $U +ZZ*A6+A66A?c|j5|jr&|jj|||cdddSt|||}|jj ||cdddS#1swYyxYwrG)rHrrzr!rrPrs r5rzz_ProxyMeter.create_histogram sg ZZ''88$ Z $D$ r rLr*rTrrrrrtr rrrxrrzrr~rrrrrrs@r5rOrOs"&$( 1 1# 1SM 1  14M4d4(             $48 HY/0     *      $       48 HY/0     *48 HY/0    ! r8rOc eZdZdZ ddedededefdZ ddedededefdZ ddededede fdZ dded e e e dededef d Z ddedededefd Z dded e e e dededef d Z dded e e e dededef dZy )rCzeThe default Meter used when no Meter implementation is available. All operations are no-op. r+rerfr/c|j|t||dr'tjd|tj ||t|||S)zReturns a no-op Counter.rYAn instrument with name %s, type %s, unit %s and description %s has been created already.r)ror_loggerwarningrr:rqs r5rrzNoOpMeter.create_counterVsY  ) ) +t[   OO;    4d DDr8c|j|t||dr'tjd|tj ||t|||S)zReturns a no-op Gauge.rrr)rorrrrr:rqs r5r~zNoOpMeter.create_gaugejsT  ) )$ 4 M   OO;  DkBBr8c|j|t||dr'tjd|tj ||t|||S)zReturns a no-op UpDownCounter.rrr)rorrrrr:rqs r5rtz NoOpMeter.create_up_down_counter~sZ  ) ) #T;   OO;&&  !DkJJr8Nruc|j|t||dr'tjd|tj ||t||||S)z"Returns a no-op ObservableCounter.rrr)rorrrrr:rws r5rxz#NoOpMeter.create_observable_countersd  ) ) '{   OO;!**  %  #   r8c|j|t||dr'tjd|tj ||t|||S)zReturns a no-op Histogram.rrr)rorrrrr:rqs r5rzzNoOpMeter.create_histogramsY  ) ) -{   OO;""  T+FFr8c|j|t||dr'tjd|tj ||t||||S)z Returns a no-op ObservableGauge.rrr)rorrrrr:rws r5rz!NoOpMeter.create_observable_gaugesd  ) ) %t[   OO;((  #  #   r8c|j|t||dr'tjd|tj ||t||||S)z(Returns a no-op ObservableUpDownCounter.rrr)rorrrrr:rws r5rz+NoOpMeter.create_observable_up_down_countersd  ) ) -t[   OO;'00  +  #   r8rr)r:r;r<r=r>rrrrr~rrtr r rrrxrrzrrrrr2r8r5rCrCPs EEE E  E. CCC C  C. KKK K  K.48   HY/0       : GGG G  G.48   HY/0       :48   HY/0     !  r8rC_METER_PROVIDERr+r,rRr-r/c@| 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_providerr6)r+r,rRr-s r5r6r6s'+-  # #D': >>r8logcrdfd }tj|}|r|stjdyyy)Nc4atjyrG)r_PROXY_METER_PROVIDERrTrRsr5set_mpz#_set_meter_provider..set_mp s( 33NCr8z2Overriding of current MeterProvider is not allowedrU)_METER_PROVIDER_SET_ONCEdo_oncerr)rRrrdid_sets` r5_set_meter_providerr s4D'..v6G 7LMsr8ct|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 r5set_meter_providerrs D1r8ct/ttvrtSt td}t |dt dtS)z8Gets the current global :class:`~.MeterProvider` object.rRFrr*)rrrrr'rrrs r5rr#sC %W 4( ((6 &(8)  N6  11r8)rNN)Er=r|abcrrloggingrosr threadingrtypingrr r r r r r#opentelemetry.environment_variablesr*opentelemetry.metrics._internal.instrumentrrrrrrrrrrrrrrrrr r!r"r#r$r%opentelemetry.util._oncer&opentelemetry.util._providersr'opentelemetry.util.typesr(r:r_ProxyInstrumentTr*r@rEr0rOrCrr__annotations__rr>r6rrrrr2r8r5rs{"4#DDDJ0*8/ H ! ' C' T G G<-<