Implement "named" meters + Remove "Batcher" from Meter constructor

examples/metrics/record.py

@@ -19,13 +19,15 @@
 import time
 
 from opentelemetry import metrics
-from opentelemetry.sdk.metrics import Counter, Meter
+from opentelemetry.sdk.metrics import Counter, MeterSource
 from opentelemetry.sdk.metrics.export import ConsoleMetricsExporter
 from opentelemetry.sdk.metrics.export.controller import PushController
 
+# The preferred tracer implementation must be set, as the opentelemetry-api
+# defines the interface with a no-op implementation.
+metrics.set_preferred_meter_source_implementation(lambda _: MeterSource())
 # Meter is responsible for creating and recording metrics
-metrics.set_preferred_meter_implementation(lambda _: Meter())
-meter = metrics.meter()
+meter = metrics.meter_source().get_meter(__name__)
 # exporter to export metrics to the console
 exporter = ConsoleMetricsExporter()
 # controller collects metrics created from meter and exports it via the

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

@@ -223,9 +223,49 @@ def record(self, value: ValueT, label_set: LabelSet) -> None:
             label_set: `LabelSet` to associate with the returned handle.
         """
 
+class MeterSource(abc.ABC):
 
-MetricT = TypeVar("MetricT", Counter, Gauge, Measure)
+    @abc.abstractmethod
+    def get_meter(
+        self,
+        instrumenting_module_name: str,
+        instrumenting_library_version: str = "",
+    ) -> "Meter":
+        """Returns a `Meter` for use by the given instrumentation library.
+
+        This function may return different `Meter` types (e.g. a no-op meter
+        vs. a functional meter).
+
+        Args:
+            instrumenting_module_name: The name of the instrumenting module
+                (usually just ``__name__``).
+
+                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.ext.http_requests"``.
+
+            instrumenting_library_version: Optional. The version string of the
+                instrumenting library.  Usually this should be the same as
+                ``pkg_resources.get_distribution(instrumenting_library_name).version``.
+        """
+
+class DefaultMeterSource(MeterSource):
+    """The default MeterSource, used when no implementation is available.
+
+    All operations are no-op.
+    """
 
+    def get_meter(
+        self,
+        instrumenting_module_name: str,
+        instrumenting_library_version: str = "",
+    ) -> "Meter":
+        # pylint:disable=no-self-use,unused-argument
+        return DefaultMeter()
+
+
+MetricT = TypeVar("MetricT", Counter, Gauge, Measure)
 
 # pylint: disable=unused-argument
 class Meter(abc.ABC):
@@ -322,45 +362,49 @@ def get_label_set(self, labels: Dict[str, str]) -> "LabelSet":
 # Once https://github.com/python/mypy/issues/7092 is resolved,
 # the following type definition should be replaced with
 # from opentelemetry.util.loader import ImplementationFactory
-ImplementationFactory = Callable[[Type[Meter]], Optional[Meter]]
+ImplementationFactory = Callable[[Type[MeterSource]], Optional[MeterSource]]
 
-_METER = None
-_METER_FACTORY = None
+_METER_SOURCE = None
+_METER_SOURCE_FACTORY = None
 
 
-def meter() -> Meter:
-    """Gets the current global :class:`~.Meter` object.
+def meter_source() -> MeterSource:
+    """Gets the current global :class:`~.MeterSource` object.
 
     If there isn't one set yet, a default will be loaded.
     """
-    global _METER, _METER_FACTORY  # pylint:disable=global-statement
+    global _METER_SOURCE, _METER_SOURCE_FACTORY  # pylint:disable=global-statement
 
-    if _METER is None:
+    if _METER_SOURCE is None:
         # pylint:disable=protected-access
         try:
-            _METER = loader._load_impl(Meter, _METER_FACTORY)  # type: ignore
+            _METER_SOURCE = loader._load_impl(
+                MeterSource, _METER_SOURCE_FACTORY  # type: ignore
+            )
         except TypeError:
             # if we raised an exception trying to instantiate an
-            # abstract class, default to no-op tracer impl
-            _METER = DefaultMeter()
-        del _METER_FACTORY
+            # abstract class, default to no-op meter impl
+            _METER_SOURCE = DefaultMeterSource()
+        del _METER_SOURCE_FACTORY
 
-    return _METER
+    return _METER_SOURCE
 
 
-def set_preferred_meter_implementation(factory: ImplementationFactory) -> None:
-    """Set the factory to be used to create the meter.
+def set_preferred_meter_source_implementation(
+    factory: ImplementationFactory
+) -> None:
+    """Set the factory to be used to create the meter source.
 
     See :mod:`opentelemetry.util.loader` for details.
 
     This function may not be called after a meter is already loaded.
 
     Args:
-        factory: Callback that should create a new :class:`Meter` instance.
+        factory: Callback that should create a new :class:`MeterSource` instance.
     """
-    global _METER, _METER_FACTORY  # pylint:disable=global-statement
+    global _METER_SOURCE_FACTORY  # pylint:disable=global-statement
 
-    if _METER:
-        raise RuntimeError("Meter already loaded.")
+    if _METER_SOURCE:
+        raise RuntimeError("MeterSource already loaded.")
 
-    _METER_FACTORY = factory
+    _METER_SOURCE_FACTORY = factory

opentelemetry-api/tests/metrics/test_metrics.py

@@ -20,24 +20,6 @@
 
 
 # pylint: disable=no-self-use
-class TestMeter(unittest.TestCase):
-    def setUp(self):
-        self.meter = metrics.DefaultMeter()
-
-    def test_record_batch(self):
-        counter = metrics.Counter()
-        label_set = metrics.LabelSet()
-        self.meter.record_batch(label_set, ((counter, 1),))
-
-    def test_create_metric(self):
-        metric = self.meter.create_metric("", "", "", float, metrics.Counter)
-        self.assertIsInstance(metric, metrics.DefaultMetric)
-
-    def test_get_label_set(self):
-        metric = self.meter.get_label_set({})
-        self.assertIsInstance(metric, metrics.DefaultLabelSet)
-
-
 class TestMetrics(unittest.TestCase):
     def test_default(self):
         default = metrics.DefaultMetric()
@@ -92,34 +74,3 @@ def test_gauge_handle(self):
     def test_measure_handle(self):
         handle = metrics.MeasureHandle()
         handle.record(1)
-
-
-@contextmanager
-# type: ignore
-def patch_metrics_globals(meter=None, meter_factory=None):
-    """Mock metrics._METER and metrics._METER_FACTORY.
-
-    This prevents previous changes to these values from affecting the code in
-    this scope, and prevents changes in this scope from leaking out and
-    affecting other tests.
-    """
-    with mock.patch("opentelemetry.metrics._METER", meter):
-        with mock.patch("opentelemetry.metrics._METER_FACTORY", meter_factory):
-            yield
-
-
-class TestGlobals(unittest.TestCase):
-    def test_meter_default_factory(self):
-        """Check that the default meter is a DefaultMeter."""
-        with patch_metrics_globals():
-            meter = metrics.meter()
-            self.assertIsInstance(meter, metrics.DefaultMeter)
-            # Check that we don't create a new instance on each call
-            self.assertIs(meter, metrics.meter())
-
-    def test_meter_custom_factory(self):
-        """Check that we use the provided factory for custom global meters."""
-        mock_meter = mock.Mock(metrics.Meter)
-        with patch_metrics_globals(meter_factory=lambda _: mock_meter):
-            meter = metrics.meter()
-            self.assertIs(meter, mock_meter)

opentelemetry-api/tests/test_implementation.py

@@ -25,6 +25,8 @@ class TestAPIOnlyImplementation(unittest.TestCase):
     https://github.com/open-telemetry/opentelemetry-python/issues/142
     """
 
+    # TRACER
+
     def test_tracer(self):
         with self.assertRaises(TypeError):
             # pylint: disable=abstract-class-instantiated
@@ -54,12 +56,30 @@ def test_default_span(self):
         self.assertEqual(span.get_context(), trace.INVALID_SPAN_CONTEXT)
         self.assertIs(span.is_recording_events(), False)
 
+    # METER
+
     def test_meter(self):
         with self.assertRaises(TypeError):
             # pylint: disable=abstract-class-instantiated
             metrics.Meter()  # type:ignore
 
     def test_default_meter(self):
+        meter_source = metrics.DefaultMeterSource()
+        meter = meter_source.get_meter(__name__)
+        self.assertIsInstance(meter, metrics.DefaultMeter)
+
+    def test_record_batch(self):
+        meter = metrics.DefaultMeter()
+        counter = metrics.Counter()
+        label_set = metrics.LabelSet()
+        meter.record_batch(label_set, ((counter, 1),))
+
+    def test_create_metric(self):
         meter = metrics.DefaultMeter()
         metric = meter.create_metric("", "", "", float, metrics.Counter)
         self.assertIsInstance(metric, metrics.DefaultMetric)
+
+    def test_get_label_set(self):
+        meter = metrics.DefaultMeter()
+        metric = meter.get_label_set({})
+        self.assertIsInstance(metric, metrics.DefaultLabelSet)

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

@@ -19,6 +19,7 @@
 from opentelemetry import metrics as metrics_api
 from opentelemetry.sdk.metrics.export.aggregate import Aggregator
 from opentelemetry.sdk.metrics.export.batcher import Batcher, UngroupedBatcher
+from opentelemetry.sdk.util import InstrumentationInfo
 from opentelemetry.util import time_ns
 
 logger = logging.getLogger(__name__)
@@ -261,11 +262,17 @@ class Meter(metrics_api.Meter):
     """See `opentelemetry.metrics.Meter`.
 
     Args:
+        instrumentation_info: The `InstrumentationInfo` for this meter.
         batcher: The `Batcher` used for this meter.
     """
 
-    def __init__(self, batcher: Batcher = UngroupedBatcher(True)):
+    def __init__(
+        self,
+        instrumentation_info: InstrumentationInfo,
+        batcher: Batcher
+    ):
         self.batcher = batcher
+        self.instrumentation_info = instrumentation_info
         self.metrics = set()
 
     def collect(self) -> None:
@@ -328,3 +335,21 @@ def get_label_set(self, labels: Dict[str, str]):
         if len(labels) == 0:
             return EMPTY_LABEL_SET
         return LabelSet(labels=labels)
+
+class MeterSource(metrics_api.MeterSource):
+
+    def get_meter(
+        self,
+        instrumenting_module_name: str,
+        instrumenting_library_version: str = "",
+        batcher: Batcher = UngroupedBatcher(True),
+    ) -> "metrics_api.Meter":
+        if not instrumenting_module_name:  # Reject empty strings too.
+            instrumenting_module_name = "ERROR:MISSING MODULE NAME"
+            logger.error("get_meter called with missing module name.")
+        return Meter(
+            InstrumentationInfo(
+                instrumenting_module_name, instrumenting_library_version
+            ),
+            batcher,
+        )