graphing: Expose the raw to canonical metric name mapping

translate_metric_names walks each raw perf-data name to the canonical metric
name a plug-in translation renames it to, and then returns a frozenset. The
pairing it computed on the way - which raw column produced which canonical
name - is discarded, and no caller can recover it, because several raw names
may share one canonical name.

Add map_metric_names, the same walk keeping the pairing, and reduce
translate_metric_names to a frozenset over its values so the two cannot drift
apart. A raw name no translation renames maps to itself, matching what
_find_name_and_scale already falls back to, so every raw name has an entry and
a caller never has to tell "not translated" from "unknown".

No behaviour changes: every existing caller reads the same set as before.

Jira: CMK-37694
Change-Id: I6e9b85cd9f9383a2b7c722f86835734271ea87dd

Author: Tsadoq

cmk/gui/graphing/_engine_translations.py

@@ -179,18 +179,28 @@ def rrd_originals(
     ]
 
 
-def translate_metric_names(
+def map_metric_names(
     check_command: str,
     raw_metric_names: Sequence[MetricName],
     registered_translations: Sequence[translations_v1.Translation],
-) -> frozenset[MetricName]:
+) -> Mapping[MetricName, MetricName]:
     specs = _specs_for_command(check_command, registered_translations)
-    names: set[MetricName] = set()
-    for metric_name in raw_metric_names:
-        prefix, bare_name = _split_predict_prefix(metric_name)
+    mapping: dict[MetricName, MetricName] = {}
+    for raw_metric_name in raw_metric_names:
+        prefix, bare_name = _split_predict_prefix(raw_metric_name)
         name, _scale = _find_name_and_scale(MetricName(bare_name), specs)
-        names.add(MetricName(f"{prefix}{name}"))
-    return frozenset(names)
+        mapping[raw_metric_name] = MetricName(f"{prefix}{name}")
+    return mapping
+
+
+def translate_metric_names(
+    check_command: str,
+    raw_metric_names: Sequence[MetricName],
+    registered_translations: Sequence[translations_v1.Translation],
+) -> frozenset[MetricName]:
+    return frozenset(
+        map_metric_names(check_command, raw_metric_names, registered_translations).values()
+    )
 
 
 def _scaled(value: float | None, scale: float) -> float | None:

tests/unit/cmk/gui/graphing/test_engine_translations.py

@@ -9,6 +9,7 @@
 from cmk.graphing_engine import MetricName
 from cmk.gui.graphing._engine_perfdata import RawPerformanceData, RawPerformanceValue
 from cmk.gui.graphing._engine_translations import (
+    map_metric_names,
     rrd_originals,
     RRDOriginal,
     translate_metric_names,
@@ -46,6 +47,45 @@ def _original(name: str, scale: float) -> RRDOriginal:
     return RRDOriginal(metric_name=MetricName(name), scale=scale)
 
 
+def test_map_metric_names_pairs_raw_names_with_their_canonical_names() -> None:
+    # A set of canonical names cannot say which raw column produced which name; the mapping can. A
+    # raw name no translation renames is its own canonical name, so no raw name is dropped.
+    assert dict(
+        map_metric_names(
+            _CHECK_COMMAND,
+            [MetricName("old"), MetricName("untouched")],
+            _registered({"old": translations.RenameTo("new")}),
+        )
+    ) == {MetricName("old"): MetricName("new"), MetricName("untouched"): MetricName("untouched")}
+
+
+def test_two_raw_names_sharing_a_canonical_name_keep_their_own_entries() -> None:
+    # The case the frozenset cannot express at all: it reports one name where two columns exist, so
+    # a caller reading it back has no way to tell which of them it may ask an RRD for.
+    assert dict(
+        map_metric_names(
+            _CHECK_COMMAND,
+            [MetricName("if_in_octets"), MetricName("if_out_octets")],
+            _registered({"~if_.*_octets": translations.RenameTo("if_octets")}),
+        )
+    ) == {
+        MetricName("if_in_octets"): MetricName("if_octets"),
+        MetricName("if_out_octets"): MetricName("if_octets"),
+    }
+
+
+def test_a_scaling_translation_leaves_the_name_alone() -> None:
+    # A translation that only scales is still a translation, and a caller that resolves a name
+    # through the mapping has to get the raw name back rather than nothing.
+    assert dict(
+        map_metric_names(
+            _CHECK_COMMAND,
+            [MetricName("mem")],
+            _registered({"mem": translations.ScaleBy(1024)}),
+        )
+    ) == {MetricName("mem"): MetricName("mem")}
+
+
 def test_metric_names_are_reported_under_their_canonical_name() -> None:
     assert translate_metric_names(
         _CHECK_COMMAND,