Make the new support for collectors without names be explicit.

This adds a parameters to the constructor of CollectorRegistry to allow that new behavior rather than make it be the default.

Signed-off-by: Mathias Kende <[email protected]>

Author: mathias-kende

docs/content/multiprocess/_index.md

@@ -13,7 +13,7 @@ This comes with a number of limitations:
 - Registries can not be used as normal
   - Registering metrics to a registry later used by a `MultiProcessCollector`
     may cause duplicate metrics to be exported
-  - Filtering on metrics works but is inefficient
+  - Filtering on metrics works but might be inefficient
 - Custom collectors do not work (e.g. cpu and memory metrics)
 - Gauges cannot use `set_function`
 - Info and Enum metrics do not work
@@ -50,7 +50,7 @@ MY_COUNTER = Counter('my_counter', 'Description of my counter')
 
 # Expose metrics.
 def app(environ, start_response):
-    registry = CollectorRegistry()
+    registry = CollectorRegistry(support_collectors_without_names=True)
     multiprocess.MultiProcessCollector(registry)
     data = generate_latest(registry)
     status = '200 OK'

prometheus_client/registry.py

@@ -26,14 +26,16 @@ class CollectorRegistry(Collector):
     exposition formats.
     """
 
-    def __init__(self, auto_describe: bool = False, target_info: Optional[Dict[str, str]] = None):
+    def __init__(self, auto_describe: bool = False, target_info: Optional[Dict[str, str]] = None,
+                 support_collectors_without_names: bool = False):
         self._collector_to_names: Dict[Collector, List[str]] = {}
         self._names_to_collectors: Dict[str, Collector] = {}
         self._auto_describe = auto_describe
         self._lock = Lock()
         self._target_info: Optional[Dict[str, str]] = {}
+        self._support_collectors_without_names = support_collectors_without_names
+        self._collectors_without_names: List[Collector] = []
         self.set_target_info(target_info)
-        self._collectors_with_no_names: List[Collector] = []
 
     def register(self, collector: Collector) -> None:
         """Add a collector to the registry."""
@@ -47,8 +49,8 @@ def register(self, collector: Collector) -> None:
             for name in names:
                 self._names_to_collectors[name] = collector
             self._collector_to_names[collector] = names
-            if not names:
-                self._collectors_with_no_names.append(collector)
+            if self._support_collectors_without_names and not names:
+                self._collectors_without_names.append(collector)
 
     def unregister(self, collector: Collector) -> None:
         """Remove a collector from the registry."""
@@ -151,7 +153,7 @@ def __init__(self, names: Iterable[str], registry: CollectorRegistry):
         self._registry = registry
 
     def collect(self) -> Iterable[Metric]:
-        collectors = set(self._registry._collectors_with_no_names)
+        collectors = set(self._registry._collectors_without_names)
         target_info_metric = None
         with self._registry._lock:
             if 'target_info' in self._name_set and self._registry._target_info:

tests/test_core.py

@@ -1024,13 +1024,22 @@ def test_restricted_registry_does_not_call_extra(self):
         self.assertEqual([m], list(registry.restricted_registry(['s_sum']).collect()))
         mock_collector.collect.assert_not_called()
 
-    def test_restricted_registry_collects_no_names_collectors(self):
+    def test_restricted_registry_ignore_no_names_collectors(self):
         from unittest.mock import MagicMock
         registry = CollectorRegistry()
         mock_collector = MagicMock()
         mock_collector.describe.return_value = []
         registry.register(mock_collector)
         self.assertEqual(list(registry.restricted_registry(['metric']).collect()), [])
+        mock_collector.collect.assert_not_called()
+
+    def test_restricted_registry_collects_no_names_collectors(self):
+        from unittest.mock import MagicMock
+        registry = CollectorRegistry(support_collectors_without_names=True)
+        mock_collector = MagicMock()
+        mock_collector.describe.return_value = []
+        registry.register(mock_collector)
+        self.assertEqual(list(registry.restricted_registry(['metric']).collect()), [])
         mock_collector.collect.assert_called()
 
     def test_restricted_registry_does_not_yield_while_locked(self):

tests/test_multiprocess.py

@@ -52,7 +52,7 @@ def setUp(self):
         self.tempdir = tempfile.mkdtemp()
         os.environ['PROMETHEUS_MULTIPROC_DIR'] = self.tempdir
         values.ValueClass = MultiProcessValue(lambda: 123)
-        self.registry = CollectorRegistry()
+        self.registry = CollectorRegistry(support_collectors_without_names=True)
         self.collector = MultiProcessCollector(self.registry)
 
     @property