o KDio @sUdZddlZddlmZmZddlmZddlmZddl 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 ddeZ5Gddde5Z6Gddde5Z7GdddeZ8Gddde8Z9Gddde8Z:e-Z;da   d)de?de?de e5de e?ddf d d!Z@de5d"eAddfd#d$ZBde5ddfd%d&ZCde5fd'd(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) 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 @sFeZdZdZe   d dedeedeedeeddf d d ZdS) MeterProviderz_ MeterProvider is the entry point of the API. It provides access to `Meter` instances. Nnameversion schema_url attributesreturnMetercCdS)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,r0r0a/var/www/Datamplify/venv/lib/python3.10/site-packages/opentelemetry/metrics/_internal/__init__.py get_meterdzMeterProvider.get_meterNNN) __name__ __module__ __qualname____doc__rstrrr'r4r0r0r0r3r(_s"r(c @sBeZdZdZ   d dedeedeedeeddf d d ZdS) NoOpMeterProviderzQThe default MeterProvider used when no MeterProvider implementation is available.Nr)r*r+r,r-r.cCst|||dS)zReturns a NoOpMeter.r*r+) NoOpMeterr1r0r0r3r4szNoOpMeterProvider.get_meterr6)r7r8r9r:r;rr'r4r0r0r0r3r<s r<c @sZeZdZdddZ   ddedeedeedeedd f d d Zd eddfd dZ dS)_ProxyMeterProviderr-NcCst|_g|_d|_dSN)r_lock_meters_real_meter_providerr2r0r0r3__init__s z_ProxyMeterProvider.__init__r)r*r+r,r.cCsp|j+|jdur|j|||WdSt|||d}|j||WdS1s1wYdSNr=)rArCr4 _ProxyMeterrBappend)r2r)r*r+r,meterr0r0r3r4s  $z_ProxyMeterProvider.get_metermeter_providercCsH|j||_|jD]}||q WddS1swYdSr@)rArCrBon_set_meter_provider)r2rJrIr0r0r3rKs   "z)_ProxyMeterProvider.on_set_meter_providerr-Nr6) r7r8r9rEr;rr'r4r(rKr0r0r0r3r?s"  r?c seZdZdZ  d$dedeedeeddffdd Zedefd d Zedeefd d Z edeefd dZ dede dedede e eff ddZe  d%dedededefddZe  d%dedededefddZe   d&dedeeedededef ddZe  d%dedededefddZ  d%dedededefddZe   d&dedeeedededef d d!Ze   d&dedeeedededef d"d#ZZ S)'r.zHandles instrument creation. This class provides methods for creating instruments which are then used to produce measurements. Nr)r*r+r-cs0t||_||_||_t|_t|_dSr@) superrE_name_version _schema_urlset_instrument_idsr_instrument_ids_lockr2r)r*r+ __class__r0r3rEs  zMeter.__init__cC|jS)z7 The name of the instrumenting module. )rNrDr0r0r3r)z Meter.namecCrW)zB The version string of the instrumenting library. )rOrDr0r0r3r*rXz Meter.versioncCrW)zC Specifies the Schema URL of the emitted telemetry )rPrDr0r0r3r+rXzMeter.schema_urltype_unit descriptioncCsd||j||g}d}|j#||jvrd}n|j|Wd||fSWd||fS1s9wY||fS)a) Check if an instrument with the same name, type, unit and description has been registered already. Returns a tuple. The first value is `True` if the instrument has been registered already, `False` otherwise. The second value is the instrument id. ,FTN)joinstriplowerr7rSrRadd)r2r)rYrZr[ instrument_idresultr0r0r3_is_instrument_registereds    zMeter._is_instrument_registeredcCr/)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. Nr0r2r)rZr[r0r0r3create_counterr5zMeter.create_countercCr/)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. Nr0rer0r0r3create_up_down_counterr5zMeter.create_up_down_counter callbackscCr/)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. Nr0r2r)rhrZr[r0r0r3create_observable_counterr5zMeter.create_observable_countercCr/)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. Nr0rer0r0r3create_histogramyr5zMeter.create_histogramcCstddS)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)warningswarnrer0r0r3 create_gaugeszMeter.create_gaugecCr/)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. Nr0rir0r0r3create_observable_gauger5zMeter.create_observable_gaugecCr/)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. Nr0rir0r0r3!create_observable_up_down_counterr5z'Meter.create_observable_up_down_counterNNrdrdNrdrd)!r7r8r9r:r;rrEpropertyr)r*r+typer boolrcrrrfrrgr rrrjrrkrrnrrorrp __classcell__r0r0rUr3r.s        `     r.c sXeZdZ  ddedeedeeddffdd Zdeddfd d Z dded ed edefddZ dded ed ede fddZ  ddedee e d ed edef ddZ dded ed edefddZ dded ed edefddZ  ddedee e d ed edef ddZ  ddedee e d ed edef ddZZS) rGNr)r*r+r-cs*tj|||dt|_g|_d|_dSrF)rMrErrA _instruments _real_meterrTrUr0r3rEs z_ProxyMeter.__init__rJcCs\||j|j|j}|j||_|jD]}||qWddS1s'wYdS)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)r4rNrOrPrAryrx on_meter_set)r2rJ real_meter instrumentr0r0r3rKs   "z!_ProxyMeter.on_set_meter_providerrdrZr[cCj|j(|jr|j|||WdSt|||}|j||WdS1s.wYdSr@)rAryrfrrxrHr2r)rZr[proxyr0r0r3rf  $z_ProxyMeter.create_countercCr}r@)rAryrgr$rxrHr~r0r0r3rg  $z"_ProxyMeter.create_up_down_counterrhcCp|j+|jr|j||||WdSt||||d}|j||WdS1s1wYdSNrZr[)rAryrjr!rxrHr2r)rhrZr[rr0r0r3rj $z%_ProxyMeter.create_observable_countercCr}r@)rAryrkr rxrHr~r0r0r3rk rz_ProxyMeter.create_histogramcCr}r@)rAryrnrrxrHr~r0r0r3rnrz_ProxyMeter.create_gaugecCrr)rAryror"rxrHrr0r0r3ro)rz#_ProxyMeter.create_observable_gaugecCrr)rAryrpr#rxrHrr0r0r3rp;s $z-_ProxyMeter.create_observable_up_down_counterrqrrrs)r7r8r9r;rrEr(rKrrfrrgr rrrjrrkrrnrrorrprwr0r0rUr3rGs          rGc @seZdZdZ  ddedededefddZ  ddedededefd d Z  ddededede fd d Z  ddede e e dededef ddZ  ddedededefddZ  ddede e e dededef ddZ  ddede e e dededef ddZd S)r>zeThe default Meter used when no Meter implementation is available. All operations are no-op. rdr)rZr[r-cC6||t||drtd|tj||t|||dS)zReturns a no-op Counter.rYAn instrument with name %s, type %s, unit %s and description %s has been created already.r)rcr_loggerwarningrr7rer0r0r3rfWzNoOpMeter.create_countercCr)zReturns a no-op Gauge.rrr)rcrrrrr7rer0r0r3rnkszNoOpMeter.create_gaugecCr)zReturns a no-op UpDownCounter.rrr)rcrrrrr7rer0r0r3rgrz NoOpMeter.create_up_down_counterNrhcC8||t||drtd|tj||t||||dS)z"Returns a no-op ObservableCounter.rrr)rcrrrrr7rir0r0r3rj$z#NoOpMeter.create_observable_countercCr)zReturns a no-op Histogram.rrr)rcrrrrr7rer0r0r3rkrzNoOpMeter.create_histogramcCr)z Returns a no-op ObservableGauge.rrr)rcrrrrr7rir0r0r3rorz!NoOpMeter.create_observable_gaugecCr)z(Returns a no-op ObservableUpDownCounter.rrr)rcrrrrr7rir0r0r3rprz+NoOpMeter.create_observable_up_down_counterrrrs)r7r8r9r:r;rrfrrnrrgrr rrrjrrkrrorrpr0r0r0r3r>Qs         r>_METER_PROVIDERrdr)r*rJr+r-cCs|durt}||||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. N)get_meter_providerr4)r)r*rJr+r0r0r3r4s r4logcs6dfdd }t|}|r|stddSdSdS)Nr-csatdSr@)r_PROXY_METER_PROVIDERrKr0rJr0r3set_mpsz#_set_meter_provider..set_mpz2Overriding of current MeterProvider is not allowedrL)_METER_PROVIDER_SET_ONCEdo_oncerr)rJrrdid_setr0rr3_set_meter_provider s  rcCst|dddS)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)rrr0r0r3set_meter_providersrcCs4tdurttvr tSttd}t|ddtdtS)z8Gets the current global :class:`~.MeterProvider` object.NrJFrr()rrrrr&rr rr0r0r3r$s  r)rdNN)Er:rlabcrrloggingrosr threadingrtypingrrr r r r r #opentelemetry.environment_variablesr*opentelemetry.metrics._internal.instrumentrrrrrrrrrrrrrrrrrr r!r"r#r$opentelemetry.util._oncer%opentelemetry.util._providersr&opentelemetry.util.typesr'r7r_ProxyInstrumentTr(r<r?r.rGr>rr__annotations__rr;r4rvrrrr0r0r0r3sj   $ `    *&