o pix @s UdZddlZddlmZmZddlmZddlmZddl m Z ddl m Z ddl mZmZmZmZmZmZdd lmZdd lmZmZmZmZmZmZmZmZmZm Z m!Z!m"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 l0m1Z1dd l2m3Z3ee4Z5ee'e)e(e*e+e,e-fZ6GdddeZ7Gddde7Z8Gddde7Z9eGdddZ:GdddeZ;Gddde;Zda?ee7e@d<e9ZA    d-deBdeBd ee7d!eeBd"ee3d#df d$d%ZCd e7d&eDd#dfd'd(ZEd e7d#dfd)d*ZFd#e7fd+d,ZGdS).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) dataclass) getLogger)environ)Lock)DictListOptionalSequenceUnioncast)OTEL_PYTHON_METER_PROVIDER) CallbackTCounterGauge Histogram NoOpCounter NoOpGauge NoOpHistogramNoOpObservableCounterNoOpObservableGaugeNoOpObservableUpDownCounterNoOpUpDownCounterObservableCounterObservableGaugeObservableUpDownCounter UpDownCounter_MetricsHistogramAdvisory _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)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-r1r1\/home/ubuntu/.local/lib/python3.10/site-packages/opentelemetry/metrics/_internal/__init__.py get_metergzMeterProvider.get_meterNNN) __name__ __module__ __qualname____doc__rstrr r(r5r1r1r1r4r)bs"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,) NoOpMeterr2r1r1r4r5szNoOpMeterProvider.get_meterr7)r8r9r:r;r<r r(r5r1r1r1r4r=s r=c @sZeZdZdddZ   ddedeedeedeedd f d d Zd eddfd dZ dS)_ProxyMeterProviderr.NcCst|_g|_d|_dSN)r_lock_meters_real_meter_providerr3r1r1r4__init__s z_ProxyMeterProvider.__init__r*r+r,r-r/cCsp|j+|jdur|j|||WdSt|||d}|j||WdS1s1wYdSNr>)rBrDr5 _ProxyMeterrCappend)r3r*r+r,r-meterr1r1r4r5s  $z_ProxyMeterProvider.get_metermeter_providercCsH|j||_|jD]}||q WddS1swYdSrA)rBrDrCon_set_meter_provider)r3rKrJr1r1r4rLs   "z)_ProxyMeterProvider.on_set_meter_providerr.Nr7) r8r9r:rFr<r r(r5r)rLr1r1r1r4r@s"  r@c@s2eZdZUeed<eed<eed<eeed<dS)_InstrumentRegistrationStatus instrument_idalready_registeredconflictcurrent_advisoryN)r8r9r:r<__annotations__boolr rr1r1r1r4rNs rNc seZdZdZ  d+dedeedeeddffdd Zedefd d Zedeefd d Z edeefd dZ d,dede dededee de f ddZededededede ddf ddZe  d-dedededefddZe  d-dedededefddZe   d.dedeeedededef dd Ze  d-dd!dededed"eeedef d#d$Z  d-dedededefd%d&Ze   d.dedeeedededef d'd(Z e   d.dedeeededede!f d)d*Z"Z#S)/r/zHandles instrument creation. This class provides methods for creating instruments which are then used to produce measurements. Nr*r+r,r.cs.t||_||_||_i|_t|_dSrA)superrF_name_version _schema_url_instrument_idsr_instrument_ids_lockr3r*r+r, __class__r1r4rFs  zMeter.__init__cC|jS)z7 The name of the instrumenting module. )rVrEr1r1r4r*z Meter.namecCr^)zB The version string of the instrumenting library. )rWrEr1r1r4r+r_z Meter.versioncCr^)zC Specifies the Schema URL of the emitted telemetry )rXrEr1r1r4r,r_zMeter.schema_urltype_unit descriptionadvisoryc Csd||j||g}d}d}d} |j||jv}|r)|j|} | |k}n||j|<Wdn1s8wYt|||| dS)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)rOrPrQrR)joinstriplowerr8rZrYrN) r3r*r`rarbrcrOrPrQrRr1r1r4_register_instruments(     zMeter._register_instrumentinstrumentation_typestatuscCstd|||||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.)_loggerwarningrR)r*rirarbrjr1r1r4%_log_instrument_registration_conflictsz+Meter._log_instrument_registration_conflictcCr0)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. Nr1r3r*rarbr1r1r4create_counter*r6zMeter.create_countercCr0)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. Nr1ror1r1r4create_up_down_counter:r6zMeter.create_up_down_counter callbackscCr0)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. Nr1r3r*rrrarbr1r1r4create_observable_counterJr6zMeter.create_observable_counter#explicit_bucket_boundaries_advisoryrvcCr0)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. Nr1)r3r*rarbrvr1r1r4create_histogramr6zMeter.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)warningswarnror1r1r4 create_gaugeszMeter.create_gaugecCr0)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. Nr1rsr1r1r4create_observable_gauger6zMeter.create_observable_gaugecCr0)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. Nr1rsr1r1r4!create_observable_up_down_counterr6z'Meter.create_observable_up_down_counterNNrArnrnNrnrn)$r8r9r:r;r<r rFpropertyr*r+r,typerrNrh staticmethodrmrrrprrqr rrrtfloatrrwrrzrr{rr| __classcell__r1r1r\r4r/s   ,     `      r/c sjeZdZ  ddedeedeeddffdd Zdeddfd d Z d ded ed edefddZ d ded ed ede fddZ  d!dedee e d ed edef ddZ d ddded ed edee edef ddZ d ded ed edefddZ  d!dedee e d ed edef ddZ  d!dedee e d ed edef ddZZS)"rHNr*r+r,r.cs*tj|||dt|_g|_d|_dSrG)rUrFrrB _instruments _real_meterr[r\r1r4rFs z_ProxyMeter.__init__rKcCs\||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)r5rVrWrXrBrr on_meter_set)r3rK real_meter instrumentr1r1r4rLs   "z!_ProxyMeter.on_set_meter_providerrnrarbcCj|j(|jr|j|||WdSt|||}|j||WdS1s.wYdSrA)rBrrprrrIr3r*rarbproxyr1r1r4rp  $z_ProxyMeter.create_countercCrrA)rBrrqr%rrIrr1r1r4rq s  $z"_ProxyMeter.create_up_down_counterrrcCp|j+|jr|j||||WdSt||||d}|j||WdS1s1wYdSNrarb)rBrrtr"rrIr3r*rrrarbrr1r1r4rt/ $z%_ProxyMeter.create_observable_counterrurvcCsp|j+|jr|jj||||dWdSt||||}|j||WdS1s1wYdS)Nru)rBrrwr!rrI)r3r*rarbrvrr1r1r4rwAs $z_ProxyMeter.create_histogramcCrrA)rBrrzr rrIrr1r1r4rzWrz_ProxyMeter.create_gaugecCrr)rBrr{r#rrIrr1r1r4r{drz#_ProxyMeter.create_observable_gaugecCrr)rBrr|r$rrIrr1r1r4r|vs $z-_ProxyMeter.create_observable_up_down_counterr}r~r)r8r9r:r<r rFr)rLrrprrqr rrrtrrrwrrzrr{rr|rr1r1r\r4rHs           rHc @s,eZdZdZ  ddedededefddZ  ddedededefd d Z  ddededede fd d Z  ddede e e dededef ddZ  dd ddededede e edef ddZ  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. rnr*rarbr.cC8||t||}|jr||tj|||t|||dS)zReturns a no-op Counter.r)rhrrQrmrr8r3r*rarbrjr1r1r4rpszNoOpMeter.create_countercCr)zReturns a no-op Gauge.r)rhrrQrmrr8rr1r1r4rzszNoOpMeter.create_gaugecCr)zReturns a no-op UpDownCounter.r)rhrrQrmrr8rr1r1r4rqsz NoOpMeter.create_up_down_counterNrrcC:||t||}|jr||tj|||t||||dS)z"Returns a no-op ObservableCounter.r)rhrrQrmrr8r3r*rrrarbrjr1r1r4rt"z#NoOpMeter.create_observable_counterrurvc CsB||t||t|d}|jr||tj|||t||||dS)zReturns a no-op Histogram.)explicit_bucket_boundaries)rarbrv)rhrrrQrmrr8)r3r*rarbrvrjr1r1r4rws.  zNoOpMeter.create_histogramcCr)z Returns a no-op ObservableGauge.r)rhrrQrmrr8rr1r1r4r{rz!NoOpMeter.create_observable_gaugecCr)z(Returns a no-op ObservableUpDownCounter.r)rhrrQrmrr8rr1r1r4r|"rz+NoOpMeter.create_observable_up_down_counterr~r)r8r9r:r;r<rrprrzrrqr r rrrtrrrwrr{rr|r1r1r1r4r?s       $   r?_METER_PROVIDERrnr*r+rKr,r-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_providerr5)r*r+rKr,r-r1r1r4r5Bsr5logcs6dfdd }t|}|r|stddSdSdS)Nr.csatdSrA)r_PROXY_METER_PROVIDERrLr1rKr1r4set_mpVsz#_set_meter_provider..set_mpz2Overriding of current MeterProvider is not allowedrM)_METER_PROVIDER_SET_ONCEdo_oncerkrl)rKrrdid_setr1rr4_set_meter_providerUs  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)rrr1r1r4set_meter_providercsrcCs4tdurttvr tSttd}t|ddtdtS)z8Gets the current global :class:`~.MeterProvider` object.NrKFrr))rrrrr'rr rr1r1r4rls  r)rnNNN)Hr;rxabcrr dataclassesrloggingrosr threadingrtypingrr r r r r #opentelemetry.environment_variablesr*opentelemetry.metrics._internal.instrumentrrrrrrrrrrrrrrrrrr r!r"r#r$r%opentelemetry.util._oncer&opentelemetry.util._providersr'opentelemetry.util.typesr(r8rk_ProxyInstrumentTr)r=r@rNr/rHr?rrrSrr<r5rTrrrr1r1r1r4sv      d    *82