From bb89e0ab3f6f98c48b38381a4aba21b34c3e96ed Mon Sep 17 00:00:00 2001 From: Srikanth Chekuri Date: Thu, 28 Mar 2024 23:14:26 +0530 Subject: [PATCH] Make `create_gauge` non-abstract method (#3817) --- CHANGELOG.md | 2 + .../metrics/_internal/__init__.py | 5 +- opentelemetry-api/tests/metrics/test_meter.py | 1 - .../metrics/test_subclass_instantiation.py | 209 ++++++++++++++++++ 4 files changed, 214 insertions(+), 3 deletions(-) create mode 100644 opentelemetry-api/tests/metrics/test_subclass_instantiation.py diff --git a/CHANGELOG.md b/CHANGELOG.md index aab968eddb..bf1754c214 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ## Unreleased +- Make create_gauge non-abstract method + ([#3817](https://github.com/open-telemetry/opentelemetry-python/pull/3817)) - Make `tracer.start_as_current_span()` decorator work with async functions ([#3633](https://github.com/open-telemetry/opentelemetry-python/pull/3633)) - Fix python 3.12 deprecation warning diff --git a/opentelemetry-api/src/opentelemetry/metrics/_internal/__init__.py b/opentelemetry-api/src/opentelemetry/metrics/_internal/__init__.py index 2e6914f8e3..1579a1a244 100644 --- a/opentelemetry-api/src/opentelemetry/metrics/_internal/__init__.py +++ b/opentelemetry-api/src/opentelemetry/metrics/_internal/__init__.py @@ -41,6 +41,7 @@ """ +import warnings from abc import ABC, abstractmethod from logging import getLogger from os import environ @@ -385,8 +386,7 @@ def create_histogram( description: A description for this instrument and what it measures. """ - @abstractmethod - def create_gauge( + def create_gauge( # type: ignore # pylint: disable=no-self-use self, name: str, unit: str = "", @@ -400,6 +400,7 @@ def create_gauge( example, ``By`` for bytes. UCUM units are recommended. description: A description for this instrument and what it measures. """ + warnings.warn("create_gauge() is not implemented and will be a no-op") @abstractmethod def create_observable_gauge( diff --git a/opentelemetry-api/tests/metrics/test_meter.py b/opentelemetry-api/tests/metrics/test_meter.py index 8b427a7372..2226965521 100644 --- a/opentelemetry-api/tests/metrics/test_meter.py +++ b/opentelemetry-api/tests/metrics/test_meter.py @@ -134,7 +134,6 @@ def test_create_gauge(self): """ self.assertTrue(hasattr(Meter, "create_gauge")) - self.assertTrue(Meter.create_gauge.__isabstractmethod__) def test_create_observable_gauge(self): """ diff --git a/opentelemetry-api/tests/metrics/test_subclass_instantiation.py b/opentelemetry-api/tests/metrics/test_subclass_instantiation.py new file mode 100644 index 0000000000..a5b68d1c06 --- /dev/null +++ b/opentelemetry-api/tests/metrics/test_subclass_instantiation.py @@ -0,0 +1,209 @@ +# Copyright The OpenTelemetry Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# type: ignore + +# NOTE: The tests in this file are intended to test the semver compatibility of the public API. +# Any tests that fail here indicate that the public API has changed in a way that is not backwards compatible. +# Either bump the major version of the API, or make the necessary changes to the API to remain semver compatible. + +from typing import Optional + +from opentelemetry.metrics import ( + Asynchronous, + Counter, + Histogram, + Instrument, + Meter, + MeterProvider, + ObservableCounter, + ObservableGauge, + ObservableUpDownCounter, + Synchronous, + UpDownCounter, + _Gauge, +) + + +class MeterProviderImplTest(MeterProvider): + def get_meter( + self, + name: str, + version: Optional[str] = None, + schema_url: Optional[str] = None, + ) -> Meter: + return super().get_meter(name, version, schema_url) + + +def test_meter_provider_subclass_instantiation(): + meter_provider = MeterProviderImplTest() + assert isinstance(meter_provider, MeterProvider) + + +class MeterImplTest(Meter): + def create_counter(self, name, description, **kwargs): + pass + + def create_up_down_counter(self, name, description, **kwargs): + pass + + def create_observable_counter(self, name, description, **kwargs): + pass + + def create_histogram(self, name, description, **kwargs): + pass + + def create_observable_gauge(self, name, description, **kwargs): + pass + + def create_observable_up_down_counter(self, name, description, **kwargs): + pass + + +def test_meter_subclass_instantiation(): + meter = MeterImplTest("subclass_test") + assert isinstance(meter, Meter) + + +class SynchronousImplTest(Synchronous): + def __init__( + self, name: str, unit: str = "", description: str = "" + ) -> None: + super().__init__(name, unit, description) + + +def test_synchronous_subclass_instantiation(): + synchronous = SynchronousImplTest("subclass_test") + assert isinstance(synchronous, Synchronous) + + +class AsynchronousImplTest(Asynchronous): + def __init__( + self, name: str, unit: str = "", description: str = "" + ) -> None: + super().__init__(name, unit, description) + + +def test_asynchronous_subclass_instantiation(): + asynchronous = AsynchronousImplTest("subclass_test") + assert isinstance(asynchronous, Asynchronous) + + +class CounterImplTest(Counter): + def __init__( + self, name: str, unit: str = "", description: str = "" + ) -> None: + super().__init__(name, unit, description) + + def add(self, amount: int, **kwargs): + pass + + +def test_counter_subclass_instantiation(): + counter = CounterImplTest("subclass_test") + assert isinstance(counter, Counter) + + +class UpDownCounterImplTest(UpDownCounter): + def __init__( + self, name: str, unit: str = "", description: str = "" + ) -> None: + super().__init__(name, unit, description) + + def add(self, amount: int, **kwargs): + pass + + +def test_up_down_counter_subclass_instantiation(): + up_down_counter = UpDownCounterImplTest("subclass_test") + assert isinstance(up_down_counter, UpDownCounter) + + +class ObservableCounterImplTest(ObservableCounter): + def __init__( + self, name: str, unit: str = "", description: str = "" + ) -> None: + super().__init__(name, unit, description) + + +def test_observable_counter_subclass_instantiation(): + observable_counter = ObservableCounterImplTest("subclass_test") + assert isinstance(observable_counter, ObservableCounter) + + +class HistogramImplTest(Histogram): + def __init__( + self, name: str, unit: str = "", description: str = "" + ) -> None: + super().__init__(name, unit, description) + + def record(self, amount: int, **kwargs): + pass + + +def test_histogram_subclass_instantiation(): + histogram = HistogramImplTest("subclass_test") + assert isinstance(histogram, Histogram) + + +class GaugeImplTest(_Gauge): + def __init__( + self, name: str, unit: str = "", description: str = "" + ) -> None: + super().__init__(name, unit, description) + + def set(self, amount: int, **kwargs): + pass + + +def test_gauge_subclass_instantiation(): + gauge = GaugeImplTest("subclass_test") + assert isinstance(gauge, _Gauge) + + +class InstrumentImplTest(Instrument): + def __init__( + self, name: str, unit: str = "", description: str = "" + ) -> None: + super().__init__(name, unit, description) + + +def test_instrument_subclass_instantiation(): + instrument = InstrumentImplTest("subclass_test") + assert isinstance(instrument, Instrument) + + +class ObservableGaugeImplTest(ObservableGauge): + def __init__( + self, name: str, unit: str = "", description: str = "" + ) -> None: + super().__init__(name, unit, description) + + +def test_observable_gauge_subclass_instantiation(): + observable_gauge = ObservableGaugeImplTest("subclass_test") + assert isinstance(observable_gauge, ObservableGauge) + + +class ObservableUpDownCounterImplTest(ObservableUpDownCounter): + def __init__( + self, name: str, unit: str = "", description: str = "" + ) -> None: + super().__init__(name, unit, description) + + +def test_observable_up_down_counter_subclass_instantiation(): + observable_up_down_counter = ObservableUpDownCounterImplTest( + "subclass_test" + ) + assert isinstance(observable_up_down_counter, ObservableUpDownCounter)