WIP

Author: ocelotl

opentelemetry-api/src/opentelemetry/__init__.py

@@ -73,7 +73,6 @@ def __init__(self, *args, **kwargs):
     def _init(self, *args, **kwargs):
         pass
 
-    @staticmethod
     @abstractmethod
     def _get_default_arguments(self, *args, **kwargs):
         pass

opentelemetry-api/src/opentelemetry/metrics/__init__.py

@@ -28,15 +28,16 @@
 from threading import RLock
 from typing import Optional, cast
 
+from opentelemetry.safe import BaseSafeClass
 from opentelemetry.environment_variables import OTEL_PYTHON_METER_PROVIDER
 from opentelemetry.metrics.instrument import (
     Counter,
-    DefaultCounter,
-    DefaultHistogram,
-    DefaultObservableCounter,
-    DefaultObservableGauge,
-    DefaultObservableUpDownCounter,
-    DefaultUpDownCounter,
+    NoOpCounter,
+    NoOpHistogram,
+    NoOpObservableCounter,
+    NoOpObservableGauge,
+    NoOpObservableUpDownCounter,
+    NoOpUpDownCounter,
     Histogram,
     ObservableCounter,
     ObservableGauge,
@@ -64,110 +65,108 @@ def get_meter(
             _logger.warning("Invalid name: %s", name)
 
 
-class _DefaultMeterProvider(MeterProvider):
-    def get_meter(
-        self,
-        name,
-        version=None,
-        schema_url=None,
-    ) -> "Meter":
-        with self._lock:
-            super().get_meter(name, version=version, schema_url=schema_url)
-            # This is done in order to make it possible to store configuration
-            # in the meter provider and make it automatically accessible for
-            # any meter even after it changes.
-            meter = _DefaultMeter(name, version=version, schema_url=schema_url)
-            meter._meter_provider = self  # pylint: disable=protected-access
-            return meter
-
-
-class ProxyMeterProvider(MeterProvider):
-    def get_meter(
-        self,
-        name,
-        version=None,
-        schema_url=None,
-    ) -> "Meter":
-        with self._lock:
-            if _METER_PROVIDER:
-                return _METER_PROVIDER.get_meter(
-                    name, version=version, schema_url=schema_url
-                )
-            return ProxyMeter(name, version=version, schema_url=schema_url)
-
-
 class Meter(ABC):
     def __init__(self, name, version=None, schema_url=None):
         super().__init__()
-        self._lock = RLock()
-        self._name = name
-        self._version = version
-        self._schema_url = schema_url
-        self._instrument_names = set()
-        self._meter_provider = None
 
-    @property
-    def name(self):
-        with self._lock:
-            return self._name
+    def _secure_instrument_name(self, name) -> bool:
+        name = name.lower()
 
-    @property
-    def version(self):
-        with self._lock:
-            return self._version
+        if name in self._instrument_names:
+            warn(f"Instrument name {name} has been used already")
+            return False
 
-    @property
-    def schema_url(self):
-        with self._lock:
-            return self._schema_url
-
-    def _secure_instrument_name(self, name):
-        with self._lock:
-            name = name.lower()
-
-            if name in self._instrument_names:
-                _logger.error("Instrument name %s has been used already", name)
-
-            else:
-                self._instrument_names.add(name)
+        else:
+            self._instrument_names.add(name)
+            return True
 
     @abstractmethod
     def create_counter(self, name, unit="", description="") -> Counter:
-        with self._lock:
-            self._secure_instrument_name(name)
+        pass
 
     @abstractmethod
     def create_up_down_counter(
         self, name, unit="", description=""
     ) -> UpDownCounter:
-        with self._lock:
-            self._secure_instrument_name(name)
+        pass
 
     @abstractmethod
     def create_observable_counter(
         self, name, callback, unit="", description=""
     ) -> ObservableCounter:
-        with self._lock:
-            self._secure_instrument_name(name)
+        pass
 
     @abstractmethod
     def create_histogram(self, name, unit="", description="") -> Histogram:
-        with self._lock:
-            self._secure_instrument_name(name)
+        pass
 
     @abstractmethod
     def create_observable_gauge(
         self, name, callback, unit="", description=""
     ) -> ObservableGauge:
-        with self._lock:
-            self._secure_instrument_name(name)
+        pass
 
     @abstractmethod
     def create_observable_up_down_counter(
         self, name, callback, unit="", description=""
     ) -> ObservableUpDownCounter:
+        pass
+
+
+class NoOpMeter(BaseSafeClass, Meter):
+    def create_counter(self, name, unit="", description="") -> Counter:
+        return NoOpCounter(_safe=True)
+
+    def create_up_down_counter(
+        self, name, unit="", description=""
+    ) -> UpDownCounter:
+        return NoOpUpDownCounter(_safe=True)
+
+    def create_observable_counter(
+        self, name, callback, unit="", description=""
+    ) -> ObservableCounter:
+
+    def create_histogram(self, name, unit="", description="") -> Histogram:
+
+    def create_observable_gauge(
+        self, name, callback, unit="", description=""
+    ) -> ObservableGauge:
+
+    def create_observable_up_down_counter(
+        self, name, callback, unit="", description=""
+    ) -> ObservableUpDownCounter:
+
+
+class NoOpMeterProvider(BaseSafeClass, MeterProvider):
+    def get_meter(
+        self,
+        name,
+        version=None,
+        schema_url=None,
+    ) -> "Meter":
+        
+
+    def _init(self, *args, **kwargs):
+        pass
+
+    def _get_default_arguments(self, *args, **kwargs):
+        return (), {}
+
+
+class ProxyMeterProvider(MeterProvider):
+    def get_meter(
+        self,
+        name,
+        version=None,
+        schema_url=None,
+    ) -> "Meter":
         with self._lock:
-            self._secure_instrument_name(name)
+            if _METER_PROVIDER:
+                return _METER_PROVIDER.get_meter(
+                    name, version=version, schema_url=schema_url
+                )
+            return ProxyMeter(name, version=version, schema_url=schema_url)
+
 
 
 class ProxyMeter(Meter):
@@ -226,71 +225,6 @@ def create_observable_up_down_counter(
             )
 
 
-class _DefaultMeter(Meter):
-    def create_counter(self, name, unit="", description="") -> Counter:
-        with self._lock:
-            super().create_counter(name, unit=unit, description=description)
-            return DefaultCounter(name, unit=unit, description=description)
-
-    def create_up_down_counter(
-        self, name, unit="", description=""
-    ) -> UpDownCounter:
-        with self._lock:
-            super().create_up_down_counter(
-                name, unit=unit, description=description
-            )
-            return DefaultUpDownCounter(
-                name, unit=unit, description=description
-            )
-
-    def create_observable_counter(
-        self, name, callback, unit="", description=""
-    ) -> ObservableCounter:
-        with self._lock:
-            super().create_observable_counter(
-                name, callback, unit=unit, description=description
-            )
-            return DefaultObservableCounter(
-                name,
-                callback,
-                unit=unit,
-                description=description,
-            )
-
-    def create_histogram(self, name, unit="", description="") -> Histogram:
-        with self._lock:
-            super().create_histogram(name, unit=unit, description=description)
-            return DefaultHistogram(name, unit=unit, description=description)
-
-    def create_observable_gauge(
-        self, name, callback, unit="", description=""
-    ) -> ObservableGauge:
-        with self._lock:
-            super().create_observable_gauge(
-                name, callback, unit=unit, description=description
-            )
-            return DefaultObservableGauge(
-                name,
-                callback,
-                unit=unit,
-                description=description,
-            )
-
-    def create_observable_up_down_counter(
-        self, name, callback, unit="", description=""
-    ) -> ObservableUpDownCounter:
-        with self._lock:
-            super().create_observable_up_down_counter(
-                name, callback, unit=unit, description=description
-            )
-            return DefaultObservableUpDownCounter(
-                name,
-                callback,
-                unit=unit,
-                description=description,
-            )
-
-
 _METER_PROVIDER = None
 _PROXY_METER_PROVIDER = None